In-app store, delta version support (#179)

* fix: windows launch

* feat: add necessary client fixes for store

* fix: keyring fix

* feat: delta version support

* feat: dl/disk progress

* feat: move to jwt auth

* fix: lint

desktop/src-tauri/remote/src/auth.rs

@@ -1,10 +1,15 @@
-use std::{collections::HashMap, env};
+use std::{
+    collections::HashMap,
+    env,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
 
 use chrono::Utc;
 use client::{app_status::AppStatus, user::User};
 use database::{DatabaseAuth, interface::borrow_db_checked};
 use droplet_rs::ssl::sign_nonce;
 use gethostname::gethostname;
+use jsonwebtoken::{Algorithm, EncodingKey, Header};
 use log::{error, warn};
 use serde::{Deserialize, Serialize};
 use url::Url;
@@ -60,18 +65,36 @@ impl From<HandshakeResponse> for DatabaseAuth {
     }
 }
 
+#[derive(Serialize, Deserialize)]
+struct Claims {
+    exp: usize,
+    nbf: usize,
+}
+
 pub fn generate_authorization_header() -> String {
     let certs = {
         let db = borrow_db_checked();
         db.auth.clone().expect("Authorisation not initialised")
     };
 
-    let nonce = Utc::now().timestamp_millis().to_string();
+    let system_time: usize = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or(Duration::from_secs(0))
+        .as_secs() as usize;
 
-    let signature =
-        sign_nonce(certs.private, nonce.clone()).expect("Failed to generate authorisation header");
+    let claims = Claims {
+        nbf: system_time,
+        exp: system_time + 10,
+    };
 
-    format!("Nonce {} {} {}", certs.client_id, nonce, signature)
+    let jwt = jsonwebtoken::encode(
+        &Header::new(Algorithm::ES384),
+        &claims,
+        &EncodingKey::from_ec_pem(certs.private.as_bytes()).unwrap(),
+    )
+    .expect("failed to sign jwt");
+
+    format!("JWT {} {}", certs.client_id, jwt)
 }
 
 pub async fn fetch_user() -> Result<User, RemoteAccessError> {

desktop/src-tauri/remote/src/server_proto.rs

@@ -1,6 +1,6 @@
 use database::borrow_db_checked;
 use http::{
-    HeaderMap, HeaderValue, Request, Response, StatusCode, Uri, header::USER_AGENT,
+    HeaderMap, HeaderValue, Request, Response, StatusCode, Uri, header::{CONTENT_SECURITY_POLICY, USER_AGENT, X_FRAME_OPTIONS},
 };
 use log::{error, warn};
 use tauri::UriSchemeResponder;
@@ -30,7 +30,7 @@ pub async fn handle_server_proto_wrapper(request: Request<Vec<u8>>, responder: U
     match handle_server_proto(request).await {
         Ok(r) => responder.respond(r),
         Err(e) => {
-            warn!("Cache error: {e}");
+            warn!("server proto error: {e}");
             responder.respond(
                 Response::builder()
                     .status(e)
@@ -84,12 +84,13 @@ async fn handle_server_proto(request: Request<Vec<u8>>) -> Result<Response<Vec<u
     let response = match DROP_CLIENT_ASYNC
         .request(request.method().clone(), new_uri.to_string())
         .headers(headers)
+        .body(request.body().clone()) // TODO: refactor this into a move
         .send()
         .await
     {
         Ok(response) => response,
         Err(e) => {
-            warn!("Could not send response. Got {e} when sending");
+            warn!("Could not send response. Got {e:?} when sending");
             return Err(e.status().unwrap_or(StatusCode::BAD_REQUEST));
         }
     };
@@ -102,6 +103,12 @@ async fn handle_server_proto(request: Request<Vec<u8>>) -> Result<Response<Vec<u
     {
         let client_response_headers = client_http_response.headers_mut().unwrap();
         for (header, header_value) in response.headers() {
+            if header == CONTENT_SECURITY_POLICY  {
+                continue;
+            }
+            if header == X_FRAME_OPTIONS {
+                continue;
+            }
             client_response_headers.insert(header, header_value.clone());
         }
     };