feat: intel sgx attestation

crates/notary/server/Cargo.toml

@@ -3,6 +3,9 @@ name = "notary-server"
 version = "0.1.0-alpha.7"
 edition = "2021"
 
+[features]
+tee_quote = ["dep:mc-sgx-dcap-types", "dep:hex", "dep:rand_chacha", "dep:once_cell"]
+
 [dependencies]
 tlsn-core = { workspace = true }
 tlsn-common = { workspace = true }
@@ -49,3 +52,8 @@ tracing-subscriber = { workspace = true, features = ["env-filter"] }
 uuid = { workspace = true, features = ["v4", "fast-rng"] }
 ws_stream_tungstenite = { workspace = true, features = ["tokio_io"] }
 zeroize = { workspace = true }
+
+mc-sgx-dcap-types = { version = "0.11.0", optional = true }
+hex = { workspace = true, optional = true }
+rand_chacha = { workspace = true, optional = true }
+once_cell = { workspace = true, optional =true }

crates/notary/server/build.rs

@@ -1,21 +1,25 @@
-use std::process::Command;
+use std::{env, process::Command};
 
 fn main() {
-    // Used to extract latest HEAD commit hash and timestamp for the /info endpoint
-    let output = Command::new("git")
-        .args(["show", "HEAD", "-s", "--format=%H,%cI"])
-        .output()
-        .expect("Git command to get commit hash and timestamp should work during build process");
+    if env::var("GIT_COMMIT_HASH").is_err() || env::var("GIT_COMMIT_TIMESTAMP").is_err() {
+        // Used to extract latest HEAD commit hash and timestamp for the /info endpoint
+        let output = Command::new("git")
+            .args(["show", "HEAD", "-s", "--format=%H,%cI"])
+            .output()
+            .expect(
+                "Git command to get commit hash and timestamp should work during build process",
+            );
 
-    let output_string =
-        String::from_utf8(output.stdout).expect("Git command should produce valid string output");
+        let output_string = String::from_utf8(output.stdout)
+            .expect("Git command should produce valid string output");
 
-    let (commit_hash, commit_timestamp) = output_string
-        .as_str()
-        .split_once(',')
-        .expect("Git commit hash and timestamp string output should be comma separated");
+        let (commit_hash, commit_timestamp) = output_string
+            .as_str()
+            .split_once(',')
+            .expect("Git commit hash and timestamp string output should be comma separated");
 
-    // Pass these 2 values as env var to the program
-    println!("cargo:rustc-env=GIT_COMMIT_HASH={}", commit_hash);
-    println!("cargo:rustc-env=GIT_COMMIT_TIMESTAMP={}", commit_timestamp);
+        // Pass these 2 values as env var to the program
+        println!("cargo:rustc-env=GIT_COMMIT_HASH={}", commit_hash);
+        println!("cargo:rustc-env=GIT_COMMIT_TIMESTAMP={}", commit_timestamp);
+    }
 }

crates/notary/server/src/domain.rs

@@ -1,7 +1,8 @@
 pub mod auth;
 pub mod cli;
 pub mod notary;
-
+#[cfg(feature = "tee_quote")]
+use crate::tee::Quote;
 use serde::{Deserialize, Serialize};
 
 /// Response object of the /info API
@@ -16,4 +17,7 @@ pub struct InfoResponse {
     pub git_commit_hash: String,
     /// Current git commit timestamp of notary-server
     pub git_commit_timestamp: String,
+    /// Hardware attestation
+    #[cfg(feature = "tee_quote")]
+    pub quote: Quote,
 }

crates/notary/server/src/lib.rs

@@ -6,6 +6,8 @@ mod server;
 mod server_tracing;
 mod service;
 mod signing;
+#[cfg(feature = "tee_quote")]
+mod tee;
 mod util;
 
 pub use config::{

crates/notary/server/src/server.rs

@@ -46,11 +46,19 @@
     util::parse_csv_file,
 };
 
+#[cfg(feature = "tee_quote")]
+use crate::tee::{ephemeral_keypair, quote};
+
 /// Start a TCP server (with or without TLS) to accept notarization request for
 /// both TCP and WebSocket clients
 #[tracing::instrument(skip(config))]
 pub async fn run_server(config: &NotaryServerProperties) -> Result<(), NotaryServerError> {
+    // tee uses ephemeral key
+    #[cfg(feature = "tee_quote")]
+    let (attestation_key, public_key) = ephemeral_keypair();
+
     // Load the private key for notarized transcript signing
+    #[cfg(not(feature = "tee_quote"))]
     let attestation_key = load_attestation_key(&config.notary_key).await?;
     let crypto_provider = build_crypto_provider(attestation_key);
 
@@ -107,8 +115,10 @@
     );
 
     // Parameters needed for the info endpoint
+    #[cfg(not(feature = "tee_quote"))]
     let public_key = std::fs::read_to_string(&config.notary_key.public_key_pem_path)
         .map_err(|err| eyre!("Failed to load notary public signing key for notarization: {err}"))?;
+
     let version = env!("CARGO_PKG_VERSION").to_string();
     let git_commit_hash = env!("GIT_COMMIT_HASH").to_string();
     let git_commit_timestamp = env!("GIT_COMMIT_TIMESTAMP").to_string();
@@ -142,6 +152,8 @@
                         public_key,
                         git_commit_hash,
                         git_commit_timestamp,
+                        #[cfg(feature = "tee_quote")]
+                        quote: quote().await,
                     }),
                 )
                     .into_response()
@@ -231,6 +243,7 @@
 }
 
 /// Load notary signing key for attestations from static file
+#[allow(dead_code)]
 async fn load_attestation_key(config: &NotarySigningKeyProperties) -> Result<AttestationKey> {
     debug!("Loading notary server's signing key");
 

crates/notary/server/src/tee.rs

@@ -0,0 +1,174 @@
+use base64::{engine::general_purpose::STANDARD, Engine};
+use mc_sgx_dcap_types::QlError;
+use once_cell::sync::OnceCell;
+use serde::{Deserialize, Serialize};
+use std::fs;
+
+use crate::signing::AttestationKey;
+use k256::ecdsa::{SigningKey, VerifyingKey as PublicKey};
+use pkcs8::{DecodePrivateKey, EncodePrivateKey, LineEnding};
+use rand_chacha::{
+    rand_core::{OsRng, SeedableRng},
+    ChaCha20Rng,
+};
+use std::{
+    fs::File,
+    io::{self, Read},
+    path::Path,
+};
+use tracing::{debug, error, instrument};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Quote {
+    raw_quote: Option<String>,
+    mrsigner: Option<String>,
+    mrenclave: Option<String>,
+    error: Option<String>,
+}
+
+impl Default for Quote {
+    fn default() -> Quote {
+        Quote {
+            raw_quote: Some("".to_string()),
+            mrsigner: None,
+            mrenclave: None,
+            error: None,
+        }
+    }
+}
+
+impl std::fmt::Debug for QuoteError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            QuoteError::IoError(err) => write!(f, "IoError: {:?}", err),
+            QuoteError::IntelQuoteLibrary(err) => {
+                write!(f, "IntelQuoteLibrary: {}", err)
+            }
+        }
+    }
+}
+
+impl From<io::Error> for QuoteError {
+    fn from(err: io::Error) -> QuoteError {
+        QuoteError::IoError(err)
+    }
+}
+
+enum QuoteError {
+    IoError(io::Error),
+    IntelQuoteLibrary(QlError),
+}
+
+impl From<QlError> for QuoteError {
+    fn from(src: QlError) -> Self {
+        Self::IntelQuoteLibrary(src)
+    }
+}
+
+static PUBLIC_KEY: OnceCell<PublicKey> = OnceCell::new();
+
+#[instrument(level = "debug", skip_all)]
+async fn gramine_quote() -> Result<Quote, QuoteError> {
+    //// Check if the the gramine pseudo-hardware exists
+    if !Path::new("/dev/attestation/quote").exists() {
+        return Ok(Quote::default());
+    }
+
+    // Reading attestation type
+    let mut attestation_file = File::open("/dev/attestation/attestation_type")?;
+    let mut attestation_type = String::new();
+    attestation_file.read_to_string(&mut attestation_type)?;
+    debug!("Detected attestation type: {}", attestation_type);
+
+    // Read `/dev/attestation/my_target_info`
+    let my_target_info = fs::read("/dev/attestation/my_target_info")?;
+
+    // Write to `/dev/attestation/target_info`
+    fs::write("/dev/attestation/target_info", my_target_info)?;
+
+    //// Writing the pubkey to bind the instance to the hw (note: this is not
+    //// mrsigner)
+    fs::write(
+        "/dev/attestation/user_report_data",
+        PUBLIC_KEY
+            .get()
+            .expect("pub_key_get")
+            .to_encoded_point(true)
+            .as_bytes(),
+    )?;
+
+    //// Reading from the gramine quote pseudo-hardware `/dev/attestation/quote`
+    let mut quote_file = File::open("/dev/attestation/quote")?;
+    let mut quote = Vec::new();
+    quote_file.read_to_end(&mut quote)?;
+
+    if quote.len() < 432 {
+        error!("Quote data is too short, expected at least 432 bytes");
+        return Err(QuoteError::IntelQuoteLibrary(QlError::InvalidReport));
+    }
+
+    //// Extract mrenclave: enclave image,  and mrsigner: identity key bound to
+    //// enclave https://github.com/intel/linux-sgx/blob/main/common/inc/sgx_quote.h
+    let mrenclave = hex::encode(&quote[112..144]);
+    let mrsigner = hex::encode(&quote[176..208]);
+
+    debug!("mrenclave: {}", mrenclave);
+    debug!("mrsigner: {}", mrsigner);
+
+    //// Return the Quote struct with the extracted data
+    Ok(Quote {
+        raw_quote: Some(hex::encode(quote)),
+        mrsigner: Some(mrsigner),
+        mrenclave: Some(mrenclave),
+        error: None,
+    })
+}
+
+pub fn ephemeral_keypair() -> (AttestationKey, String) {
+    let mut rng = ChaCha20Rng::from_rng(OsRng).expect("os rng err!");
+    let signing_key = SigningKey::random(&mut rng);
+    let pem_string = signing_key
+        .clone()
+        .to_pkcs8_pem(LineEnding::LF)
+        .expect("to pem");
+    let attkey = AttestationKey::from_pkcs8_pem(&pem_string).expect("from pem");
+    let derk = signing_key
+        .verifying_key()
+        .to_encoded_point(true)
+        .to_bytes();
+    let b64k = STANDARD.encode(derk.as_ref());
+    let pem = format!(
+        "-----BEGIN PUBLIC KEY-----\n{}\n-----END PUBLIC KEY-----\n",
+        b64k
+    );
+
+    let _ = PUBLIC_KEY
+        .set(*signing_key.verifying_key())
+        .map_err(|_| "Public key has already been set");
+    (attkey, pem)
+}
+
+pub async fn quote() -> Quote {
+    //// tee-detection logic will live here, for now its only gramine-sgx
+    match gramine_quote().await {
+        Ok(quote) => quote,
+        Err(err) => {
+            error!("Failed to retrieve quote: {:?}", err);
+            match err {
+                QuoteError::IoError(_) => Quote {
+                    raw_quote: None,
+                    mrsigner: None,
+                    mrenclave: None,
+                    error: Some("io".to_owned()),
+                },
+                QuoteError::IntelQuoteLibrary(_) => Quote {
+                    raw_quote: None,
+                    mrsigner: None,
+                    mrenclave: None,
+                    error: Some("hw".to_owned()),
+                },
+            }
+        }
+    }
+}

crates/notary/server/tee/Dockerfile

@@ -0,0 +1,25 @@
+#tlsnotary server for testing <> gramine sgx (gramine1.7, g++13, libiomp off :()
+### notaryserverbuilds.azurecr.io/prod/notary-sgx
+
+FROM            notaryserverbuilds.azurecr.io/prod/gramine AS teesdk
+
+ARG             TOOLCHAIN=1.81.0
+ENV             PATH=/root/.cargo/bin:/usr/local/musl/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+
+RUN             set -eux \
+                && curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain=$TOOLCHAIN \
+                && rustup target add \
+                x86_64-unknown-linux-gnu
+
+
+RUN             apt update && apt install -y libssl-dev libclang-dev
+ARG             TLSN_TAG=dev
+ARG             TLSN_FT=tee_quote
+RUN             git clone --depth 1 -b $TLSN_TAG https://github.com/tlsnotary/tlsn /tlsn  && \
+                cargo build --release --bin notary-server --features $TLSN_FT --color always --manifest-path /tlsn/Cargo.toml
+RUN             cd tlsn/crates/notary/server/tee && gramine-sgx-gen-private-key && SGX=1 make
+
+FROM            notaryserverbuilds.azurecr.io/prod/gramine AS teetime
+WORKDIR /tee
+COPY            --from=teesdk tlsn/crates/notary/server/tee .
+ENTRYPOINT      ["gramine-sgx", "notary-server"]