feat: Add identity stage1 signing

Cargo.toml

@@ -4,5 +4,6 @@ members = [
     "src/dfx_derive",
     "src/dfx_info",
     "src/ic_http_agent",
+    "src/ic_identity_manager",
     "src/serde_idl",
 ]

src/dfx/Cargo.toml

@@ -29,6 +29,7 @@ flate2 = "1.0.11"
 futures = "0.1.28"
 hex = "0.3.2"
 ic-http-agent = { path = "../ic_http_agent" }
+ic-identity-manager = { path = "../ic_identity_manager" }
 indicatif = "0.13.0"
 lazy-init = "0.3.0"
 lazy_static = "1.4.0"

src/dfx/src/lib/environment.rs

@@ -2,12 +2,14 @@ use crate::config::cache::{Cache, DiskBasedCache};
 use crate::config::dfinity::Config;
 use crate::config::dfx_version;
 use crate::lib::error::DfxResult;
+use crate::lib::identity_interface::Identity;
 use crate::lib::progress_bar::ProgressBar;
 
 use ic_http_agent::{Agent, AgentConfig};
 use lazy_init::Lazy;
 use semver::Version;
 use slog::Record;
+use std::fs::create_dir_all;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 
@@ -75,7 +77,7 @@ impl EnvironmentImpl {
                 .into_path(),
             Some(c) => c.get_path().parent().unwrap().join(".dfx"),
         };
-        std::fs::create_dir_all(&temp_dir)?;
+        create_dir_all(&temp_dir)?;
 
         // Figure out which version of DFX we should be running. This will use the following
         // fallback sequence:
@@ -156,9 +158,15 @@ impl Environment for EnvironmentImpl {
                     let start = config.get_config().get_defaults().get_start();
                     let address = start.get_address("localhost");
                     let port = start.get_port(8000);
+                    let dfx_root = self.get_temp_dir();
+                    let local_project_identity = dfx_root.join("identity").join("default");
+                    if create_dir_all(&local_project_identity).is_err() {
+                        return None;
+                    }
 
                     Agent::new(AgentConfig {
                         url: format!("http://{}:{}", address, port).as_str(),
+                        signer: Box::new(Identity::new(local_project_identity)),
                         ..AgentConfig::default()
                     })
                     .ok()
@@ -195,13 +203,19 @@ pub struct AgentEnvironment<'a> {
 
 impl<'a> AgentEnvironment<'a> {
     pub fn new(backend: &'a dyn Environment, agent_url: &str) -> Self {
+        // We do not expose the path directly for now.
+        let dfx_root = backend.get_temp_dir();
+        let local_project_identity = dfx_root.join("identity").join("default");
+        // N.B. Do not assume the existence of this directory yet.
+        create_dir_all(&local_project_identity).expect("Failed to construct identity profile");
         AgentEnvironment {
             backend,
             agent: Agent::new(AgentConfig {
                 url: agent_url,
+                signer: Box::new(Identity::new(local_project_identity)),
                 ..AgentConfig::default()
             })
-            .unwrap(),
+            .expect("Failed to construct agent"),
         }
     }
 }

src/dfx/src/lib/identity_interface.rs

@@ -0,0 +1,75 @@
+use ic_http_agent::to_request_id;
+use ic_http_agent::AgentError;
+use ic_http_agent::Blob;
+use ic_http_agent::RequestId;
+use ic_http_agent::SignedMessage;
+use ic_http_agent::Signer;
+use std::path::PathBuf;
+
+pub struct Identity(ic_identity_manager::Identity);
+
+impl Identity {
+    /// Construct a new identity handling object, providing given
+    /// configuration.
+    pub fn new(identity_config_path: PathBuf) -> Self {
+        Self(
+            // We panic as discussed, as that should not be the
+            // case. I personally prefer this to be an error.
+            ic_identity_manager::Identity::new(identity_config_path)
+                .expect("Expected a valid identity configuration"),
+        )
+    }
+}
+
+impl Signer for Identity {
+    fn sign<'a>(
+        &self,
+        request: Box<(dyn erased_serde::Serialize + Send + Sync + 'a)>,
+    ) -> Result<
+        (
+            RequestId,
+            Box<dyn erased_serde::Serialize + Send + Sync + 'a>,
+        ),
+        AgentError,
+    > {
+        let request_id = to_request_id(&request).map_err(AgentError::from)?;
+        let signature_tuple = self
+            .0
+            .sign(Blob::from(request_id).as_slice())
+            .map_err(|e| AgentError::SigningError(e.to_string()))?;
+        let signature = Blob::from(signature_tuple.signature.clone());
+        let sender_pubkey = Blob::from(signature_tuple.public_key);
+        let signed_request = SignedMessage {
+            request_with_sender: request,
+            signature,
+            sender_pubkey,
+        };
+        Ok((request_id, Box::new(signed_request)))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use proptest::prelude::*;
+    use serde::Serialize;
+    use tempfile::tempdir;
+
+    // Dummy proptest checking request id is correct for now.
+    proptest! {
+    #[test]
+    fn request_id_identity(request: String) {
+        let dir = tempdir().unwrap();
+
+        #[derive(Clone,Serialize)]
+        struct TestAPI { inner : String}
+        let request = TestAPI { inner: request};
+
+        let request_with_sender = request.clone();
+        let actual_request_id = to_request_id(&request_with_sender).expect("Failed to produce request id");
+
+        let signer = Identity::new(dir.into_path());
+        let request_id = signer.sign(Box::new(request)).expect("Failed to sign").0;
+        assert_eq!(request_id, actual_request_id)
+    }}
+}

src/dfx/src/lib/mod.rs

@@ -1,6 +1,7 @@
 pub mod canister_info;
 pub mod environment;
 pub mod error;
+pub mod identity_interface;
 pub mod logger;
 pub mod message;
 pub mod progress_bar;

src/ic_http_agent/src/agent/agent_error.rs

@@ -10,6 +10,8 @@ pub enum AgentError {
     ClientError(u16, String),
     TimeoutWaitingForResponse,
 
+    SigningError(String),
+
     InvalidCborData(serde_cbor::Error),
     ReqwestError(reqwest::Error),
     SerdeError(SerdeError),

src/ic_identity_manager/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "ic-identity-manager"
+version = "0.1.0"
+authors = ["DFINITY Stiftung"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+openssl = "0.10.28"
+pem = "0.7.0"
+ring = "0.16.11"
+serde = { version = "1.0", features = ["derive"] }
+ic-http-agent = { path = "../ic_http_agent" }
+
+
+[dev-dependencies]
+serde_cbor = "0.10"