Prototype for signing in with IndieAuth

The code is really janky and unpolished, the error handling is
TERRIBLE, and I think I can't publish it like this. This'll need a
refactor, but it'll come tomorrow.

1 files changed, 535 insertions, 0 deletions

diff --git a/src/components/signin.rs b/src/components/signin.rs
new file mode 100644
index 0000000..159711e
--- /dev/null
+++ b/src/components/signin.rs
@@ -0,0 +1,535 @@
+use std::cell::RefCell;
+
+use adw::prelude::*;
+use kittybox_indieauth::{AuthorizationRequest, AuthorizationResponse, Error as IndieauthError, GrantResponse, Metadata};
+use relm4::prelude::*;
+use soup::prelude::{ServerExt, ServerExtManual, SessionExt};
+
+const REDIRECT_URI: &str = "http://localhost:60000/callback";
+
+#[derive(Debug)]
+pub struct Output {
+    pub me: glib::Uri,
+    pub micropub: glib::Uri,
+    pub userinfo: Option<glib::Uri>,
+
+    pub access_token: String,
+    pub refresh_token: Option<String>,
+    pub expires_in: Option<std::time::Duration>,
+    pub profile: Option<kittybox_indieauth::Profile>,
+}
+
+#[derive(Debug)]
+pub struct SignIn {
+    client_id: glib::Uri,
+    me_buffer: gtk::EntryBuffer,
+
+    http: soup::Session,
+    busy_guard: Option<gio::ApplicationBusyGuard>,
+    callback_server: Option<soup::Server>,
+
+    state: kittybox_indieauth::State,
+    code_verifier: kittybox_indieauth::PKCEVerifier,
+    micropub_uri: Option<glib::Uri>,
+    metadata: Option<Metadata>
+}
+
+#[derive(Debug, thiserror::Error)]
+enum Error {
+    #[error("glib error: {0}")]
+    Glib(#[from] glib::Error),
+    #[error("indieauth error: {0}")]
+    IndieAuth(#[from] IndieauthError),
+    #[error("json error: {0}")]
+    Json(#[from] serde_json::Error),
+    #[error("error parsing query string: {0}")]
+    QueryDecode(#[from] serde_urlencoded::de::Error),
+    #[error("error parsing your homepage: {0}")]
+    Mf2(#[from] microformats::Error),
+
+    #[error("Your website doesn't support IndieAuth.")]
+    MetadataNotFound,
+    #[error("Your website doesn't support Micropub.")]
+    MicropubLinkNotFound,
+    #[error("Not a HTTP[S] URL!")]
+    WrongScheme,
+    #[error("Your IndieAuth metadata endpoint returned HTTP status {0:?}")]
+    MetadataEndpointFailed(soup::Status),
+}
+
+#[doc(hidden)]
+#[derive(Debug)]
+#[allow(private_interfaces)]
+pub enum Input {
+    Start,
+    Callback(Result<AuthorizationResponse, Error>),
+}
+
+fn callback_handler(sender: AsyncComponentSender<SignIn>) -> impl Fn(&soup::Server, &soup::ServerMessage, &str, std::collections::HashMap<&str, &str>) {
+    move |server, msg, _, _| {
+        let server = ObjectExt::downgrade(server);
+        let sender = sender.clone();
+        let url = msg.uri().unwrap();
+        let q = url.query().unwrap_or_default();
+        match serde_urlencoded::from_str::<AuthorizationResponse>(q.as_str()) {
+            Ok(response) => {
+                // We're using RefCells here because of a deficiency in GLib types.
+                //
+                // The `finished` signal is only supposed to be fired once for a given
+                // SoupServerMessage, but the type system doesn't know about this.
+                //
+                // Thus we're forced to put our moved value into a RefCell<Option<T>>,
+                // from which it can only be taken once. Taking it twice results in a
+                // panic because of the `Option::unwrap()`.
+                let response = RefCell::new(Some(response));
+                msg.set_status(200, soup::Status::phrase(200).as_deref());
+                msg.set_response(
+                    Some("text/plain; charset=\"utf-8\""),
+                    soup::MemoryUse::Static,
+                    "Thank you! This window can now be closed.".as_bytes()
+                );
+                msg.connect_finished(move |_| {
+                    sender.input(Input::Callback(Ok(response.take().unwrap())));
+                    if let Some(server) = server.upgrade() {
+                        log::info!("Stopping callback receiver server...");
+                        soup::prelude::ServerExt::disconnect(&server);
+                    }
+                });
+            },
+            Err(err) => {
+                msg.set_status(400, soup::Status::phrase(400).as_deref());
+                if let Ok(err) = serde_urlencoded::from_str::<IndieauthError>(q.as_str()) {
+                    let err = RefCell::new(Some(err));
+                    msg.connect_finished(move |_| {
+                        sender.input(Input::Callback(Err(err.take().unwrap().into())));
+                        if let Some(server) = server.upgrade() {
+                            log::info!("Stopping callback receiver server...");
+                            soup::prelude::ServerExt::disconnect(&server);
+                        }
+                    });
+                } else {
+                    let err = RefCell::new(Some(err));
+                    msg.connect_finished(move |_| {
+                        sender.input(Input::Callback(Err(err.take().unwrap().into())));
+                        if let Some(server) = server.upgrade() {
+                            log::info!("Stopping callback receiver server...");
+                            soup::prelude::ServerExt::disconnect(&server);
+                        }
+                    });
+                }
+            }
+        };
+    }
+}
+
+impl SignIn {
+    fn bail_out(&mut self, widgets: &mut <Self as AsyncComponent>::Widgets, sender: AsyncComponentSender<Self>, err: Error) {
+        widgets.toasts.add_toast(adw::Toast::builder()
+            .title(err.to_string())
+            .priority(adw::ToastPriority::High)
+            .build()
+        );
+        // Reset all the state for the component for security reasons.
+        self.busy_guard = None;
+        self.callback_server = None;
+        self.metadata = None;
+        self.micropub_uri = None;
+        self.state = kittybox_indieauth::State::new();
+        self.code_verifier = kittybox_indieauth::PKCEVerifier::new();
+        self.update_view(widgets, sender);
+    }
+
+    async fn well_known_metadata(http: soup::Session, url: glib::Uri) -> Option<Metadata> {
+        let well_known = url.parse_relative(
+            "/.well-known/oauth-authorization-server",
+            glib::UriFlags::NONE
+        ).unwrap();
+        // Speculatively check for metadata at the well-known path
+        let msg = soup::Message::from_uri("GET", &well_known);
+        msg.request_headers().unwrap().append("Accept", "application/json");
+        match http.send_and_read_future(&msg, glib::Priority::DEFAULT).await {
+            Ok(body) if msg.status() == soup::Status::Ok => {
+                match serde_json::from_slice(&body) {
+                    Ok(metadata) => {
+                        log::info!("Speculative metadata request successful: {:#?}", metadata);
+                        Some(metadata)
+                    },
+                    Err(err) => {
+                        log::warn!("Parsing OAuth2 metadata from {} failed: {}", well_known, err);
+                        None
+                    }
+                }
+            },
+            Ok(_) => {
+                log::warn!("Speculative request to {} returned {:?} ({})", well_known, msg.status(), msg.reason_phrase().unwrap());
+
+                None
+            },
+            Err(err) => {
+                log::warn!("Speculative request to {} failed: {}", well_known, err);
+
+                None
+            }
+        }
+    }
+}
+
+#[relm4::component(pub async)]
+impl AsyncComponent for SignIn {
+    type CommandOutput = ();
+    #[doc(hidden)]
+    type Input = Input;
+    type Output = Output;
+    /// Client ID for authorizing.
+    type Init = glib::Uri;
+
+    view! {
+        #[root]
+        #[name = "toasts"]
+        adw::ToastOverlay {
+            adw::Clamp {
+                set_maximum_size: 360,
+
+                gtk::Box {
+                    set_orientation: gtk::Orientation::Vertical,
+                    set_spacing: 16,
+                    set_margin_all: 16,
+
+                    gtk::Label {
+                        add_css_class: "title-1",
+                        set_text: "Sign in",
+                        set_justify: gtk::Justification::Center,
+                    },
+
+                    gtk::Label {
+                        set_text: "Please sign in with your website to use Bowl.\nYour website needs to support IndieAuth and Micropub for this app to work.",
+                        set_wrap: true,
+                        set_halign: gtk::Align::BaselineCenter,
+                        set_valign: gtk::Align::BaselineCenter,
+                        set_justify: gtk::Justification::Center,
+                    },
+
+                    gtk::Entry {
+                        set_buffer: &model.me_buffer,
+                        set_placeholder_text: Some("https://example.com/"),
+                        connect_activate => Self::Input::Start,
+                        #[watch] set_sensitive: model.callback_server.is_none() && model.busy_guard.is_none(),
+                    },
+
+                    gtk::Button {
+                        set_hexpand: false,
+                        set_halign: gtk::Align::Center,
+                        #[wrap(Some)]
+                        set_child = &gtk::Box {
+                            set_halign: gtk::Align::Center,
+                            set_orientation: gtk::Orientation::Horizontal,
+                            set_spacing: 5,
+                            gtk::Spinner {
+                                set_spinning: true,
+                                #[watch]
+                                set_visible: model.busy_guard.is_some() || model.callback_server.is_some(),
+                            },
+                            gtk::Label {
+                                #[watch]
+                                set_text: if model.busy_guard.is_some() {
+                                    "Talking to your website..."
+                                } else if model.callback_server.is_some() {
+                                    "Waiting for authorization..."
+                                } else {
+                                    "Sign in"
+                                },
+                            }
+                        },
+                        connect_clicked => Self::Input::Start,
+                        #[watch] set_sensitive: model.callback_server.is_none() && model.busy_guard.is_none(),
+                    },
+                }
+            }
+        }
+    }
+
+    fn init(
+        init: Self::Init,
+        root: Self::Root,
+        sender: AsyncComponentSender<Self>,
+    ) -> impl std::future::Future<Output = AsyncComponentParts<Self>> {
+        let model = Self {
+            client_id: init,
+            me_buffer: Default::default(),
+
+            http: soup::Session::new(),
+            callback_server: None,
+            busy_guard: None,
+
+            state: kittybox_indieauth::State::new(),
+            code_verifier: kittybox_indieauth::PKCEVerifier::new(),
+            micropub_uri: None,
+            metadata: None,
+        };
+
+        let widgets = view_output!();
+
+        std::future::ready(AsyncComponentParts { model, widgets })
+    }
+
+    async fn update_with_view(&mut self, widgets: &mut Self::Widgets, msg: Self::Input, sender: AsyncComponentSender<Self>, _root: &Self::Root) {
+        match msg {
+            Input::Start => {
+                self.busy_guard = Some(relm4::main_adw_application().mark_busy());
+                self.update_view(widgets, sender.clone());
+
+                let mut url: String = self.me_buffer.text().into();
+                // Normalize bare domains by assuming `https://`
+                match glib::Uri::peek_scheme(url.as_str()) {
+                    None => {
+                        self.me_buffer.insert_text(0, "https://");
+                        url = self.me_buffer.text().into();
+                    },
+                    Some(scheme) => {
+                        if scheme != "https" && scheme != "http" {
+                            return self.bail_out(
+                                widgets, sender,
+                                Error::WrongScheme
+                            );
+                        }
+                    },
+                }
+                let url = match glib::Uri::parse(url.as_str(), glib::UriFlags::SCHEME_NORMALIZE) {
+                    Ok(url) => url,
+                    Err(err) => {
+                        return self.bail_out(
+                            widgets, sender,
+                            err.into()
+                        );
+                    },
+                };
+
+                let (metadata, micropub_uri) = {
+                    // Fire off a speculative request at the well-known URI. This could
+                    // improve UX by parallelizing how we query the user's website.
+                    //
+                    // Note that exposing the metadata at the .well-known URI is
+                    // RECOMMENDED though optional according to IndieAuth specification
+                    // § 4.1.1, so we could use that if it's there to speed up the
+                    // process.
+                    let metadata = relm4::spawn_local(
+                        Self::well_known_metadata(self.http.clone(), url.clone())
+                    );
+                    let msg = soup::Message::from_uri("GET", &url);
+                    let body = match self.http.send_future(&msg, glib::Priority::DEFAULT).await {
+                        Ok(body) => body,
+                        Err(err) => {
+                            return self.bail_out(
+                                widgets, sender,
+                                err.into()
+                            );
+                        },
+                    };
+
+                    let mf2 = match microformats::from_reader(
+                        std::io::BufReader::new(body.into_read()),
+                        url.to_string().parse().unwrap()
+                    ) {
+                        Ok(mf2) => mf2,
+                        Err(err) => {
+                            return self.bail_out(
+                                widgets, sender,
+                                err.into()
+                            );
+                        }
+                    };
+
+                    let rels = mf2.rels.by_rels();
+                    let metadata_url = if let Some(url) = rels
+                        .get("indieauth-metadata")
+                        .map(Vec::as_slice)
+                        .and_then(<[_]>::first)
+                    {
+                        glib::Uri::parse(url.as_str(), glib::UriFlags::NONE).unwrap()
+                    } else {
+                        // I intentionally refuse to support older IndieAuth versions.
+                        // The new versions are superior by providing more features that
+                        // were previously proprietary extensions, and are more clearer in
+                        // general.
+                        return self.bail_out(
+                            widgets, sender,
+                            Error::MetadataNotFound
+                        );
+                    };
+
+                    let micropub_uri = if let Some(url) = rels
+                        .get("micropub")
+                        .map(Vec::as_slice)
+                        .and_then(<[_]>::first)
+                    {
+                        glib::Uri::parse(url.as_str(), glib::UriFlags::NONE).unwrap()
+                    } else {
+                        return self.bail_out(
+                            widgets, sender,
+                            Error::MicropubLinkNotFound
+                        );
+                    };
+
+                    if let Ok(Some(metadata)) = metadata.await {
+                        (metadata, micropub_uri)
+                    } else {
+                        let msg = soup::Message::from_uri("GET", &metadata_url);
+                        msg.request_headers().unwrap().append("Accept", "application/json");
+                        match self.http.send_and_read_future(&msg, glib::Priority::DEFAULT).await {
+                            Ok(body) if msg.status() == soup::Status::Ok => {
+                                match serde_json::from_slice(&body) {
+                                    Ok(metadata) => (metadata, micropub_uri),
+                                    Err(err) => return self.bail_out(widgets, sender, err.into()),
+                                }
+                            },
+                            Ok(_) => {
+                                return self.bail_out(
+                                    widgets, sender,
+                                    Error::MetadataEndpointFailed(msg.status())
+                                )
+                            },
+                            Err(err) => return self.bail_out(widgets, sender, err.into()),
+                        }
+                    }
+                };
+
+                let auth_request = AuthorizationRequest {
+                    response_type: kittybox_indieauth::ResponseType::Code,
+                    client_id: self.client_id.to_str().parse().unwrap(),
+                    redirect_uri: REDIRECT_URI.parse().unwrap(),
+                    state: self.state.clone(),
+                    code_challenge: kittybox_indieauth::PKCEChallenge::new(
+                        &self.code_verifier, kittybox_indieauth::PKCEMethod::S256
+                    ),
+                    scope: Some(kittybox_indieauth::Scopes::new(vec![
+                        kittybox_indieauth::Scope::Profile,
+                        kittybox_indieauth::Scope::Create,
+                        kittybox_indieauth::Scope::Media
+                    ])),
+                    me: Some(url.to_str().parse().unwrap())
+                };
+
+                let auth_url = {
+                    let mut url = metadata.authorization_endpoint.clone();
+                    url.query_pairs_mut().extend_pairs(auth_request.as_query_pairs());
+
+                    url
+                };
+
+                self.metadata = Some(metadata);
+                self.micropub_uri = Some(micropub_uri);
+                self.callback_server = Some({
+                    let server = soup::Server::builder().build();
+                    server.add_handler(None, callback_handler(sender.clone()));
+                    match server.listen_local(60000, soup::ServerListenOptions::empty()) {
+                        Ok(()) => server,
+                        Err(err) => return self.bail_out(widgets, sender, err.into())
+                    }
+                });
+
+                if let Err(err) = gtk::UriLauncher::new(auth_url.as_str()).launch_future(
+                    None::<&adw::ApplicationWindow>
+                ).await {
+                    return self.bail_out(widgets, sender, err.into())
+                };
+
+                self.busy_guard = None;
+                self.update_view(widgets, sender);
+            },
+            Input::Callback(Ok(res)) => {
+                // Immediately drop the event if we didn't take a server.
+                if self.callback_server.take().is_none() { return; }
+                self.busy_guard = Some(relm4::main_adw_application().mark_busy());
+                let metadata = self.metadata.take().unwrap();
+                let micropub_uri = self.micropub_uri.take().unwrap();
+
+                if res.state != self.state {
+                    return self.bail_out(widgets, sender, IndieauthError {
+                        kind: kittybox_indieauth::ErrorKind::InvalidRequest,
+                        msg: Some("state doesn't match what we remember, ceremony aborted".to_owned()),
+                        error_uri: None,
+                    }.into())
+                }
+
+                if res.iss != metadata.issuer {
+                    return self.bail_out(widgets, sender, IndieauthError {
+                        kind: kittybox_indieauth::ErrorKind::InvalidRequest,
+                        msg: Some("issuer doesn't match what we remember, ceremony aborted".to_owned()),
+                        error_uri: None,
+                    }.into())
+                }
+
+                let code = res.code;
+                let token_grant = kittybox_indieauth::GrantRequest::AuthorizationCode {
+                    code,
+                    client_id: self.client_id.to_string().parse().unwrap(),
+                    redirect_uri: REDIRECT_URI.parse().unwrap(),
+                    code_verifier: std::mem::replace(
+                        &mut self.code_verifier,
+                        kittybox_indieauth::PKCEVerifier::new()
+                    )
+                };
+
+                let url = glib::Uri::parse(metadata.token_endpoint.as_str(), glib::UriFlags::NONE).unwrap();
+                let msg = soup::Message::from_uri("POST", &url);
+                let headers = msg.request_headers().unwrap();
+                headers.append("Accept", "application/json");
+                msg.set_request_body_from_bytes(
+                    Some("application/x-www-form-urlencoded"),
+                    Some(&glib::Bytes::from_owned(
+                        serde_urlencoded::to_string(token_grant).unwrap().into_bytes()
+                    ))
+                );
+                match self.http.send_and_read_future(&msg, glib::Priority::DEFAULT).await {
+                    Ok(body) if msg.status() == soup::Status::Ok => {
+                        match serde_json::from_slice::<GrantResponse>(&body) {
+                            Ok(GrantResponse::ProfileUrl(_)) => unreachable!(),
+                            Ok(GrantResponse::AccessToken {
+                                me,
+                                token_type: _,
+                                scope,
+                                access_token,
+                                state: _,
+                                expires_in,
+                                profile,
+                                refresh_token
+                            }) => {
+                                let _ = sender.output(Output {
+                                    me: glib::Uri::parse(me.as_str(), glib::UriFlags::NONE).unwrap(),
+                                    micropub: micropub_uri,
+                                    userinfo: metadata.userinfo_endpoint
+                                        .map(|u| glib::Uri::parse(
+                                            u.as_str(), glib::UriFlags::NONE
+                                        ).unwrap()),
+                                    access_token,
+                                    refresh_token,
+                                    expires_in: expires_in.map(std::time::Duration::from_secs),
+                                    profile,
+                                });
+                                self.busy_guard = None;
+                                self.update_view(widgets, sender);
+                            },
+                            Err(err) => self.bail_out(widgets, sender, err.into()),
+                        }
+                    },
+                    Ok(body) => {
+                        match serde_json::from_slice::<IndieauthError>(&body) {
+                            Ok(err) => self.bail_out(widgets, sender, err.into()),
+                            Err(err) => self.bail_out(widgets, sender, err.into())
+                        }
+                    },
+                    Err(err) => self.bail_out(widgets, sender, err.into())
+                }
+            },
+            Input::Callback(Err(err)) => {
+                self.bail_out(widgets, sender, err)
+            },
+        }
+    }
+
+    fn shutdown(&mut self, _: &mut Self::Widgets, _: relm4::Sender<Self::Output>) {
+        if let Some(server) = self.callback_server.as_ref() {
+            soup::prelude::ServerExt::disconnect(server);
+        }
+    }
+}