ethers-core = { version = "1.0" }

siwe = { version = "0.5" }

                .allow_methods([Method::GET, Method::POST, Method::PUT])

use std::convert::TryFrom;

use std::str::FromStr;

use ethers_core::types::{Signature, H160};

use serde::{Deserialize, Serialize, Serializer};

use crate::api::error::Error;

#[derive(Clone)]

#[derive(Deserialize, Serialize)]

pub struct AuthRequest {

    pub message: String,

    #[serde(deserialize_with = "deserialize_signature")]

    pub signature: Signature,

}

fn deserialize_signature<'de, D>(deserializer: D) -> Result<Signature, D::Error>

where

    D: serde::de::Deserializer<'de>,

{

    let buf = String::deserialize(deserializer)?;

    Signature::from_str(&buf).map_err(serde::de::Error::custom)

}

        nonce: String,

        expiration_time: DateTime,

    pub domain: String,

    pub address: H160,

    pub statement: Option<String>,

    pub uri: String,

    pub version: u64,

    pub chain_id: u64,

    pub nonce: String,

    pub expiration_time: Option<DateTime>,

    pub resources: Vec<String>,

}

impl TryFrom<siwe::Message> for Session {

    type Error = Error;

    fn try_from(message: siwe::Message) -> Result<Session, Error> {

        Ok(Session {

            domain: message.domain.host().to_string(),

            address: H160(message.address),

            statement: None,

            uri: message.uri.to_string(),

            version: message.version as u64,

            chain_id: message.chain_id,

            nonce: message.nonce,

            issued_at: DateTime(message.issued_at.as_ref().to_owned()),

            expiration_time: message

                .expiration_time

                .map(|x| DateTime(x.as_ref().to_owned())),

            resources: message.resources.iter().map(|r| r.to_string()).collect(),

        })

    }

}

#[cfg(test)]

mod test {

    #[test]

    fn test_auth_request_de() {

        let json = serde_json::json!({

            "message": "Hello World!",

            "signature": "20096c6ed2bcccb88c9cafbbbbda7a5a3cff6d0ca318c07faa58464083ca40a92f899fbeb26a4c763a7004b13fd0f1ba6c321d4e3a023e30f63c40d4154b99a41c"

        });

        let _req: super::AuthRequest = serde_json::from_value(json).unwrap();

    }

    /// An error occurred while verifying the siwe message.

    SiweVerification(#[from] siwe::VerificationError),

    /// An error occurred while parsing the siwe message.

    SiweParse(#[from] siwe::ParseError),

            Error::SiweParse(msg) => (StatusCode::BAD_REQUEST, Some(msg.to_string())),

            Error::SiweVerification(msg) => (StatusCode::BAD_REQUEST, Some(msg.to_string())),

use axum::http::Request;

pub async fn request(app: &Router, path: impl ToString) -> Response {

            .oneshot(

                Request::builder()

                    .uri(path.to_string())

                    .body(Body::empty())

                    .unwrap(),

            )

    use crate::api::test::{self, request, HEAD};

        let response = request(

    use crate::api::test::{self, request, HEAD, HEAD_1};

        let response = request(&app, "/projects").await;

        let response = request(&app, "/projects/rad:z4FucBZHZMCsxTyQE1dfE2YR59Qbp").await;

        let response = request(&app, "/projects/rad:z4FucBZHZMCsxTyQE1dfE2YR59Qbp/commits").await;

        let response = request(

        let response = request(

        let response = request(

        let response = request(&app, "/projects/rad:z4FucBZHZMCsxTyQE1dfE2YR59Qbp/remotes").await;

        let response = request(&app, "/projects/rad:z4FucBZHZMCsxTyQE1dfE2YR59Qbp/remotes/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi").await;

        let response = request(

        let response = request(

        let response = request(&app, "/projects/rad:z4FucBZHZMCsxTyQE1dfE2YR59Qbp/issues").await;

use std::collections::HashMap;

use std::convert::TryInto;

use std::env;

use std::str::FromStr;

use axum::routing::{get, post};

use ethers_core::utils::hex;

use hyper::http::uri::Authority;

use siwe::Message;

use crate::api::auth::{AuthRequest, AuthState, DateTime, Session};

        .route(

            "/sessions/:id",

            get(session_get_handler).put(session_signin_handler),

        )

    let (session_id, nonce) = create_session(&mut sessions, DateTime(expiration_time));

    Json(json!({ "id": session_id, "nonce": nonce }))

}

/// Get session.

/// `GET /sessions/:id`

async fn session_get_handler(

    State(ctx): State<Context>,

    Path(id): Path<String>,

) -> impl IntoResponse {

    let sessions = ctx.sessions.read().await;

    let session = sessions.get(&id).ok_or(Error::NotFound)?;

    match session {

        AuthState::Authorized(session) => {

            Ok::<_, Error>(Json(json!({ "id": id, "session": session })))

        }

        AuthState::Unauthorized {

            nonce,

            expiration_time,

        } => Ok::<_, Error>(Json(

            json!({ "id": id, "nonce": nonce, "expirationTime": expiration_time }),

        )),

    }

    Path(id): Path<String>,

    Json(request): Json<AuthRequest>,

    // Get unauthenticated session data, return early if not found

    let session = sessions.get(&id).ok_or(Error::NotFound)?;

    if let AuthState::Unauthorized { nonce, .. } = session {

        let message = Message::from_str(request.message.as_str()).map_err(Error::from)?;

        let host = env::var("RADICLE_DOMAIN").map_err(Error::from)?;

        // Validate nonce

        if *nonce != message.nonce {

            return Err(Error::Auth("Invalid nonce"));

        // Verify that domain is the correct one

        let authority = Authority::from_str(&host).map_err(|_| Error::Auth("Invalid host"))?;

        if authority != message.domain {

            return Err(Error::Auth("Invalid domain"));

        // Verifies the following:

        // - AuthRequest sig matches the address passed in the AuthRequest message.

        // - expirationTime is not in the past.

        // - notBefore time is in the future.

        message

            .verify(&request.signature.to_vec(), &Default::default())

            .await

        let session: Session = message.try_into()?;

        sessions.insert(id.clone(), AuthState::Authorized(session.clone()));

        return Ok::<_, Error>(Json(json!({ "id": id, "session": session })));

fn create_session(

    map: &mut HashMap<String, AuthState>,

    expiration_time: DateTime,

) -> (String, String) {

    let nonce = siwe::generate_nonce();

    // We generate a value from the RNG for the session id

    let rng = fastrand::Rng::new();

    let id = hex::encode(repeat_with(|| rng.u8(..)).take(32).collect::<Vec<u8>>());

    let auth_state = AuthState::Unauthorized {

        nonce: nonce.clone(),

        expiration_time,

    };

    map.insert(id.clone(), auth_state);

    (id, nonce)

    use crate::api::test::{self, request};

        let response = request(&app, "/stats").await;