feat: Detect Human Verification Request

Detect and provide the means to solve a human verification request. See
captcha example on how to solve html captcha.

Author: LeanderBB

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "proton-api-rs"
 authors = ["Leander Beernaert <[email protected]>"]
-version = "0.8.1"
+version = "0.9.0"
 edition = "2021"
 license = "AGPL-3.0-only"
 description = "Unofficial implemention of proton REST API in rust"
@@ -33,7 +33,6 @@ default = []
 http-ureq = ["dep:ureq"]
 http-reqwest = ["dep:reqwest"]
 
-
 [dependencies.reqwest]
 version = "0.11"
 default-features = false
@@ -43,6 +42,7 @@ optional = true
 [dev-dependencies]
 env_logger = "0.10"
 tokio = {version ="1", features = ["full"]}
+wry = {version = "0.28"}
 
 [[example]]
 name = "user_id"
@@ -51,3 +51,7 @@ required-features = ["http-reqwest"]
 [[example]]
 name = "user_id_sync"
 required-features = ["http-ureq"]
+
+[[example]]
+name = "captcha"
+required-features = ["http-ureq"]

examples/captcha.rs

@@ -0,0 +1,112 @@
+use proton_api_rs::clientv2::ping;
+use proton_api_rs::domain::{HVCaptchaMessage, HumanVerificationLoginData, HumanVerificationType};
+use proton_api_rs::{captcha_get, http, LoginError, Session};
+use std::process::exit;
+
+fn main() {
+    env_logger::init();
+
+    let user_email = std::env::var("PAPI_USER_EMAIL").unwrap();
+    let user_password = std::env::var("PAPI_USER_PASSWORD").unwrap();
+    let app_version = std::env::var("PAPI_APP_VERSION").unwrap();
+
+    let client = http::ClientBuilder::new()
+        .app_version(&app_version)
+        .build::<http::ureq_client::UReqClient>()
+        .unwrap();
+
+    ping(&client).unwrap();
+
+    let login_result = Session::login(&client, &user_email, &user_password, None, None);
+    if let Err(LoginError::HumanVerificationRequired(hv)) = &login_result {
+        let captcha_body = captcha_get(&client, &hv.token, true).unwrap();
+        run_captcha(captcha_body, app_version, user_email, user_password);
+    }
+
+    if let Err(e) = &login_result {
+        eprintln!("Got login error:{e}");
+    }
+
+    eprintln!("Human Verification request not triggered try again");
+    return;
+}
+
+fn run_captcha(html: String, app_version: String, user: String, password: String) -> ! {
+    std::fs::write("/tmp/captcha.html", &html).unwrap();
+    use wry::{
+        application::{
+            event::{Event, StartCause, WindowEvent},
+            event_loop::{ControlFlow, EventLoop},
+            window::WindowBuilder,
+        },
+        webview::WebViewBuilder,
+    };
+
+    let event_loop = EventLoop::new();
+    let window = WindowBuilder::new()
+        .with_title("Proton API Captcha")
+        .build(&event_loop)
+        .unwrap();
+    let _webview = WebViewBuilder::new(window)
+        .unwrap()
+        .with_html(html)
+        //.with_url("http://127.0.0.1:8000/captcha.html")
+        .unwrap()
+        .with_devtools(true)
+        .with_ipc_handler(move |_, req| match HVCaptchaMessage::new(&req) {
+            Ok(m) => {
+                println!("Got message {:?}", m);
+                if let Some(token) = m.get_token() {
+                    let client = http::ClientBuilder::new()
+                        .app_version(&app_version)
+                        .build::<http::ureq_client::UReqClient>()
+                        .unwrap();
+
+                    let login_result = Session::login(
+                        &client,
+                        &user,
+                        &password,
+                        Some(HumanVerificationLoginData {
+                            hv_type: HumanVerificationType::Captcha,
+                            token: token.to_string(),
+                        }),
+                        None,
+                    );
+
+                    if let Err(e) = login_result {
+                        eprintln!("Captcha Err {e}");
+                    } else {
+                        println!("Log in success!!");
+                        exit(0);
+                    }
+                }
+            }
+            Err(e) => {
+                eprintln!("Failed to publish event{e}");
+            }
+        })
+        .build()
+        .unwrap();
+
+    _webview
+        .evaluate_script(
+            "postMessageToParent = function(message) { window.ipc.postMessage(JSON.stringify(message), '*')}",
+        )
+        .unwrap();
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            Event::NewEvents(StartCause::Init) => println!("Wry has started!"),
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => {
+                println!("Close requested");
+                *control_flow = ControlFlow::Exit
+            }
+            _ => (),
+        }
+    });
+}

examples/user_id.rs

@@ -16,7 +16,7 @@ async fn main() {
 
     ping_async(&client).await.unwrap();
 
-    let session = match Session::login_async(&client, &user_email, &user_password, None)
+    let session = match Session::login_async(&client, &user_email, &user_password, None, None)
         .await
         .unwrap()
     {

examples/user_id_sync.rs

@@ -1,5 +1,6 @@
 use proton_api_rs::clientv2::{ping, SessionType};
-use proton_api_rs::{http, Session};
+use proton_api_rs::domain::CaptchaErrorDetail;
+use proton_api_rs::{captcha_get, http, LoginError, Session};
 use std::io::{BufRead, Write};
 
 fn main() {
@@ -16,7 +17,49 @@ fn main() {
 
     ping(&client).unwrap();
 
-    let session = match Session::login(&client, &user_email, &user_password, None).unwrap() {
+    let login_result = Session::login(&client, &user_email, &user_password, None);
+    if let Err(LoginError::Request(http::Error::API(e))) = &login_result {
+        if e.api_code != 9001 {
+            panic!("{e}")
+        }
+        let captcha_desc =
+            serde_json::from_value::<CaptchaErrorDetail>(e.details.clone().unwrap()).unwrap();
+
+        let captcha_body = captcha_get(&client, &captcha_desc.human_verification_token).unwrap();
+        run_captcha(captcha_body);
+        // TODO: Start webview with the downloaded body - use https://github.com/tauri-apps/wry
+        // Click
+        // Handle postMessageToParent which has token & token type
+        // repeat submission with x-pm-human-verification-token and x-pm-human-verification-token-type
+        // Use the event below to catch this
+        // window.addEventListener(
+        //   "message",
+        //   (event) => {
+        //      -> event.Data
+        //   },
+        //   false
+        // );
+        // On Success
+        // postMessageToParent({
+        //                 "type": "pm_captcha",
+        //                 "token": response
+        //             });
+        //
+        // on expired
+        // postMessageToParent({
+        //                 "type": "pm_captcha_expired",
+        //                 "token": response
+        //             });
+        //
+        // on height:
+        // postMessageToParent({
+        //                 'type': 'pm_height',
+        //                 'height': height
+        //             });
+        return;
+    }
+
+    let session = match login_result.unwrap() {
         SessionType::Authenticated(s) => s,
         SessionType::AwaitingTotp(mut t) => {
             let mut line_reader = std::io::BufReader::new(std::io::stdin());
@@ -65,3 +108,53 @@ fn main() {
 
     session.logout(&client).unwrap();
 }
+
+fn run_captcha(html: String) {
+    std::fs::write("/tmp/captcha.html", html).unwrap();
+    use wry::{
+        application::{
+            event::{Event, StartCause, WindowEvent},
+            event_loop::{ControlFlow, EventLoop},
+            window::WindowBuilder,
+        },
+        webview::WebViewBuilder,
+    };
+
+    let event_loop = EventLoop::new();
+    let window = WindowBuilder::new()
+        .with_title("Proton API Captcha")
+        .build(&event_loop)
+        .unwrap();
+    let _webview = WebViewBuilder::new(window)
+        .unwrap()
+        .with_url("http://127.0.0.1:8000/captcha.html")
+        .unwrap()
+        .with_devtools(true)
+        .with_ipc_handler(|window, req| {
+            println!("Window IPC: {req}");
+        })
+        .build()
+        .unwrap();
+
+    _webview
+        .evaluate_script(
+            "postMessageToParent = function(message) { window.ipc.postMessage(JSON.stringify(message), '*')}",
+        )
+        .unwrap();
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            Event::NewEvents(StartCause::Init) => println!("Wry has started!"),
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => {
+                println!("Close requested");
+                *control_flow = ControlFlow::Exit
+            }
+            _ => (),
+        }
+    });
+}

src/clientv2/client.rs

@@ -1,6 +1,6 @@
 use crate::http;
 use crate::http::Request;
-use crate::requests::Ping;
+use crate::requests::{CaptchaRequest, Ping};
 
 pub fn ping<T: http::ClientSync>(client: &T) -> Result<(), http::Error> {
     Ping.execute_sync::<T>(client, &http::DefaultRequestFactory {})
@@ -10,3 +10,21 @@ pub async fn ping_async<T: http::ClientAsync>(client: &T) -> Result<(), http::Er
     Ping.execute_async::<T>(client, &http::DefaultRequestFactory {})
         .await
 }
+
+pub fn captcha_get<T: http::ClientSync>(
+    client: &T,
+    token: &str,
+    force_web: bool,
+) -> Result<String, http::Error> {
+    CaptchaRequest::new(token, force_web).execute_sync(client, &http::DefaultRequestFactory {})
+}
+
+pub async fn captcha_get_async<T: http::ClientAsync>(
+    client: &T,
+    token: &str,
+    force_web: bool,
+) -> Result<String, http::Error> {
+    CaptchaRequest::new(token, force_web)
+        .execute_async(client, &http::DefaultRequestFactory {})
+        .await
+}

src/clientv2/request_repeater.rs

@@ -1,18 +1,20 @@
 //! Automatic request repeater based on the expectations Proton has for their clients.
 
-use crate::domain::UserUid;
+use crate::domain::{SecretString, UserUid};
 use crate::http::{
     ClientAsync, ClientSync, DefaultRequestFactory, Method, Request, RequestData, RequestFactory,
 };
 use crate::requests::{AuthRefreshRequest, UserAuth};
 use crate::{http, SessionRefreshData};
-use secrecy::ExposeSecret;
+use secrecy::{ExposeSecret, Secret};
 
-pub type OnAuthRefreshedCallback = Box<dyn Fn(&UserUid, &str)>;
+pub trait OnAuthRefreshed: Send + Sync {
+    fn on_auth_refreshed(&self, user: &Secret<UserUid>, token: &SecretString);
+}
 
 pub struct RequestRepeater {
     user_auth: parking_lot::RwLock<UserAuth>,
-    on_auth_refreshed: Option<OnAuthRefreshedCallback>,
+    on_auth_refreshed: Option<Box<dyn OnAuthRefreshed>>,
 }
 
 impl std::fmt::Debug for RequestRepeater {
@@ -31,7 +33,7 @@ impl std::fmt::Debug for RequestRepeater {
 }
 
 impl RequestRepeater {
-    pub fn new(user_auth: UserAuth, on_auth_refreshed: Option<OnAuthRefreshedCallback>) -> Self {
+    pub fn new(user_auth: UserAuth, on_auth_refreshed: Option<Box<dyn OnAuthRefreshed>>) -> Self {
         Self {
             user_auth: parking_lot::RwLock::new(user_auth),
             on_auth_refreshed,
@@ -50,10 +52,7 @@ impl RequestRepeater {
                 let mut borrow = self.user_auth.write();
                 *borrow = UserAuth::from_auth_refresh_response(&s);
                 if let Some(cb) = &self.on_auth_refreshed {
-                    (cb)(
-                        borrow.uid.expose_secret(),
-                        borrow.access_token.expose_secret(),
-                    );
+                    cb.on_auth_refreshed(&borrow.uid, &borrow.access_token);
                 }
                 Ok(())
             }
@@ -75,10 +74,7 @@ impl RequestRepeater {
                 let mut borrow = self.user_auth.write();
                 *borrow = UserAuth::from_auth_refresh_response(&s);
                 if let Some(cb) = &self.on_auth_refreshed {
-                    (cb)(
-                        borrow.uid.expose_secret(),
-                        borrow.access_token.expose_secret(),
-                    );
+                    cb.on_auth_refreshed(&borrow.uid, &borrow.access_token);
                 }
                 Ok(())
             }
@@ -105,6 +101,8 @@ impl RequestRepeater {
 
                         // Execute request again
                         return request.execute_sync(client, self);
+                    } else if api_err.http_code == 422 && api_err.http_code == 9001 {
+                        //TODO: Handle captcha .....
                     }
                 }
                 Err(original_error)