From 2e32ecac741027c0c4a77107d6a6446bf3ea58ac Mon Sep 17 00:00:00 2001 From: Akshay Date: Sun, 26 Jan 2025 08:50:18 +0000 Subject: [PATCH] use html form for login - also add session mgmt - still dbg-ing authenticated requests --- Cargo.lock | 1 + core/Cargo.toml | 1 + core/src/main.rs | 204 +++++++++++++++++++++++++++++++++++++---------- flake.nix | 1 + 4 files changed, 163 insertions(+), 44 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8e615baf..cd242b6b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -417,6 +417,7 @@ dependencies = [ "atrium-xrpc-client", "axum", "hickory-resolver", + "serde", "tokio", "tower-sessions", ] diff --git a/core/Cargo.toml b/core/Cargo.toml index 3560d28d..ec450e38 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -15,4 +15,5 @@ atrium-common = { workspace=true } hickory-resolver = "0.24.2" anyhow = "1.0.95" tower-sessions = "0.14.0" +serde = "1.0.217" diff --git a/core/src/main.rs b/core/src/main.rs index 06a894fa..40c069a3 100644 --- a/core/src/main.rs +++ b/core/src/main.rs @@ -1,54 +1,39 @@ use std::sync::Arc; -use atrium_api::{did_doc::DidDocument, types::string::AtIdentifier}; +use atrium_api::{ + client::AtpServiceClient, did_doc::DidDocument, types::string::AtIdentifier, + xrpc::types::AuthorizationToken, +}; use atrium_common::resolver::Resolver; use atrium_identity::{ did::{CommonDidResolver, CommonDidResolverConfig, DEFAULT_PLC_DIRECTORY_URL}, handle::{AtprotoHandleResolver, AtprotoHandleResolverConfig, DnsTxtResolver}, }; use atrium_oauth_client::{ - AtprotoLocalhostClientMetadata, AuthorizeOptions, DefaultHttpClient, KnownScope, OAuthClient, - OAuthClientConfig, OAuthResolverConfig, Scope, store::state::MemoryStateStore, + AtprotoClientMetadata, AtprotoLocalhostClientMetadata, AuthorizeOptionPrompt, AuthorizeOptions, + DefaultHttpClient, DpopClient, KnownScope, OAuthClient, OAuthClientConfig, OAuthResolverConfig, + Scope, store::state::MemoryStateStore, }; use atrium_xrpc::HttpClient; +use atrium_xrpc_client::isahc::{IsahcClient, IsahcClientBuilder}; use axum::{Router, routing}; use hickory_resolver::TokioAsyncResolver; -struct HickoryDnsTxtResolver { - resolver: TokioAsyncResolver, -} - -impl Default for HickoryDnsTxtResolver { - fn default() -> Self { - Self { - resolver: TokioAsyncResolver::tokio_from_system_conf() - .expect("failed to create resolver"), - } - } -} - -impl DnsTxtResolver for HickoryDnsTxtResolver { - async fn resolve( - &self, - query: &str, - ) -> core::result::Result, Box> { - Ok(self - .resolver - .txt_lookup(query) - .await? - .iter() - .map(|txt| txt.to_string()) - .collect()) - } -} - #[tokio::main] async fn main() { - let state = AppState::new(); + let session_store = tower_sessions::MemoryStore::default(); + let session_layer = tower_sessions::SessionManagerLayer::new(session_store) + .with_secure(false) + .with_expiry(tower_sessions::Expiry::OnSessionEnd); + + let app_state = AppState::new(); let service = Router::new() + .route("/", routing::get(index::get)) + .route("/test-auth", routing::get(test_atproto::get)) .route("/login", routing::get(login::get).post(login::post)) .route("/callback", routing::get(callback::get)) - .with_state(state); + .layer(session_layer) + .with_state(app_state); let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap(); axum::serve(listener, service).await.unwrap(); @@ -67,13 +52,14 @@ impl AppState { } } -type DidResolver = CommonDidResolver; -type HandleResolver = AtprotoHandleResolver; - struct AppStateInner { - did_resolver: DidResolver, - handle_resolver: HandleResolver, - oauth_client: OAuthClient, + did_resolver: CommonDidResolver, + handle_resolver: AtprotoHandleResolver, + oauth_client: OAuthClient< + atrium_oauth_client::store::state::MemoryStateStore, + CommonDidResolver, + atrium_identity::handle::AtprotoHandleResolver, + >, } impl AppStateInner { @@ -83,6 +69,7 @@ impl AppStateInner { let handle_resolver = Self::handle_resolver(client.clone()); let config = OAuthClientConfig { client_metadata: AtprotoLocalhostClientMetadata { + // TODO: change this redirect_uris: Some(vec![String::from("http://127.0.0.1:3000/callback")]), scopes: Some(vec![ Scope::Known(KnownScope::Atproto), @@ -138,9 +125,10 @@ impl AppStateInner { mod login { use axum::{ - extract::{Json, State}, + extract::{Form, State}, response::{IntoResponse, Redirect, Result}, }; + use serde::Deserialize; use super::*; @@ -148,11 +136,17 @@ mod login { "hello world".to_owned() } + #[derive(Deserialize, Debug)] + pub struct Req { + handle: AtIdentifier, + } + pub async fn post( State(state): State, - Json(handle): Json, + Form(req): Form, ) -> Result { - let did_document = state.inner.resolve_did_document(&handle).await.unwrap(); + let did_document = state.inner.resolve_did_document(&req.handle).await.unwrap(); + dbg!(&did_document); let res = state .inner .oauth_client @@ -161,6 +155,7 @@ mod login { Scope::Known(KnownScope::Atproto), Scope::Known(KnownScope::TransitionGeneric), ], + prompt: Some(AuthorizeOptionPrompt::Login), ..Default::default() }) .await @@ -180,9 +175,130 @@ mod callback { pub async fn get( Query(params): Query, State(state): State, + session: tower_sessions::Session, ) -> StatusCode { - let ts = state.inner.oauth_client.callback(params).await; - println!("ts: {ts:?}"); + let ts = state.inner.oauth_client.callback(params).await.unwrap(); + let _ = session.insert("bild", &ts).await; StatusCode::OK } } + +// dummy endpoint to test if sessions are working +mod index { + use axum::http::StatusCode; + + pub async fn get(session: tower_sessions::Session) -> StatusCode { + dbg!( + session + .get::("bild") + .await + .unwrap() + ); + StatusCode::OK + } +} + +struct AuthenticatedClient { + token: String, + base_uri: String, + inner: IsahcClient, +} + +impl atrium_xrpc::HttpClient for AuthenticatedClient { + async fn send_http( + &self, + request: atrium_xrpc::http::Request>, + ) -> Result< + atrium_xrpc::http::Response>, + Box, + > { + self.inner.send_http(request).await + } +} + +impl atrium_xrpc::XrpcClient for AuthenticatedClient { + fn base_uri(&self) -> String { + self.base_uri.clone() + } + async fn authorization_token(&self, _: bool) -> Option { + Some(AuthorizationToken::Dpop(self.token.clone())) + } +} + +// dummy endpoint to perform an atproto request with access token +mod test_atproto { + use atrium_api::{ + agent::{AtpAgent, store::MemorySessionStore}, + app, com, + }; + use axum::http::StatusCode; + + use super::*; + + fn get_session_client( + tokenset: &atrium_oauth_client::TokenSet, + ) -> AtpServiceClient { + //) -> AtpAgent { + // AtpAgent::new( + // AuthenticatedClient { + // token: tokenset.access_token.clone(), + // base_uri: tokenset.iss.clone(), + // inner: IsahcClient::new(tokenset.iss.clone()), + // }, + // MemorySessionStore::default(), + // ) + AtpServiceClient::new(AuthenticatedClient { + token: tokenset.access_token.clone(), + base_uri: tokenset.aud.clone(), + inner: IsahcClient::new(tokenset.aud.clone()), + }) + } + + pub async fn get(session: tower_sessions::Session) -> StatusCode { + let token_set = session + .get::("bild") + .await + .ok() + .flatten() + .unwrap(); + let client = get_session_client(&token_set); + let res = client + .service + .com + .atproto + .repo + .upload_blob(vec![0]) + .await + .unwrap(); + dbg!(res); + StatusCode::OK + } +} + +struct HickoryDnsTxtResolver { + resolver: TokioAsyncResolver, +} + +impl Default for HickoryDnsTxtResolver { + fn default() -> Self { + Self { + resolver: TokioAsyncResolver::tokio_from_system_conf() + .expect("failed to create resolver"), + } + } +} + +impl DnsTxtResolver for HickoryDnsTxtResolver { + async fn resolve( + &self, + query: &str, + ) -> core::result::Result, Box> { + Ok(self + .resolver + .txt_lookup(query) + .await? + .iter() + .map(|txt| txt.to_string()) + .collect()) + } +} diff --git a/flake.nix b/flake.nix index bb5226eb..26293f00 100644 --- a/flake.nix +++ b/flake.nix @@ -40,6 +40,7 @@ pkgs.go pkgs.air + pkgs.httpie pkgs.bacon rust-bin pkgs.pkg-config -- knotmirror 0.0.1