Address review comments

Author: conradgrobler

remote_attestation/rust/Cargo.toml

@@ -6,9 +6,8 @@ edition = "2021"
 license = "Apache-2.0"
 
 [features]
-default = ["alloc"]
+default = []
 std = ["anyhow/std", "prost/std"]
-alloc = []
 
 [dependencies]
 anyhow = { version = "*", default-features = false }

remote_attestation/rust/src/crypto.rs

@@ -20,7 +20,7 @@
 // protocol.
 
 use crate::message::EncryptedData;
-use alloc::vec::Vec;
+use alloc::{format, vec, vec::Vec};
 use anyhow::{anyhow, Context};
 use core::convert::TryInto;
 use ring::{
@@ -194,7 +194,7 @@ impl KeyNegotiator {
             .map_err(|error| anyhow!("Couldn't get public key: {:?}", error))?
             .as_ref()
             .to_vec();
-        public_key.as_slice().try_into().context(alloc::format!(
+        public_key.as_slice().try_into().context(format!(
             "Incorrect public key length, expected {}, found {}",
             KEY_AGREEMENT_ALGORITHM_KEY_LENGTH,
             public_key.len()
@@ -235,7 +235,7 @@ impl KeyNegotiator {
             &agreement::UnparsedPublicKey::new(KEY_AGREEMENT_ALGORITHM, peer_public_key),
             anyhow!("Couldn't derive session keys"),
             |key_material| {
-                let key_material = key_material.try_into().context(alloc::format!(
+                let key_material = key_material.try_into().context(format!(
                     "Incorrect key material length, expected {}, found {}",
                     KEY_AGREEMENT_ALGORITHM_KEY_LENGTH,
                     key_material.len()
@@ -299,7 +299,7 @@ impl KeyNegotiator {
         client_public_key: &[u8; KEY_AGREEMENT_ALGORITHM_KEY_LENGTH],
     ) -> anyhow::Result<[u8; AEAD_ALGORITHM_KEY_LENGTH]> {
         // Session key is derived from a purpose string and two public keys.
-        let info = alloc::vec![key_purpose.as_bytes(), server_public_key, client_public_key];
+        let info = vec![key_purpose.as_bytes(), server_public_key, client_public_key];
 
         // Initialize key derivation function.
         let salt = Salt::new(HKDF_SHA256, KEY_DERIVATION_SALT.as_bytes());
@@ -352,7 +352,7 @@ impl Signer {
 
     pub fn public_key(&self) -> anyhow::Result<[u8; SIGNING_ALGORITHM_KEY_LENGTH]> {
         let public_key = self.key_pair.public_key().as_ref().to_vec();
-        public_key.as_slice().try_into().context(alloc::format!(
+        public_key.as_slice().try_into().context(format!(
             "Incorrect public key length, expected {}, found {}",
             SIGNING_ALGORITHM_KEY_LENGTH,
             public_key.len()
@@ -367,7 +367,7 @@ impl Signer {
             .map_err(|error| anyhow!("Couldn't sign input: {:?}", error))?
             .as_ref()
             .to_vec();
-        signature.as_slice().try_into().context(alloc::format!(
+        signature.as_slice().try_into().context(format!(
             "Incorrect signature length, expected {}, found {}",
             SIGNATURE_LENGTH,
             signature.len()

remote_attestation/rust/src/handshaker.rs

@@ -34,7 +34,7 @@ use crate::{
     },
     proto::{AttestationInfo, AttestationReport},
 };
-use alloc::{boxed::Box, vec::Vec};
+use alloc::{boxed::Box, vec, vec::Vec};
 use anyhow::{anyhow, Context};
 use prost::Message;
 
@@ -304,7 +304,7 @@ impl ClientHandshaker {
                 // Signing public key.
                 [Default::default(); SIGNING_ALGORITHM_KEY_LENGTH],
                 // Attestation info.
-                alloc::vec![],
+                vec![],
             )
         };
 
@@ -485,9 +485,9 @@ impl ServerHandshaker {
                 // Signing public key.
                 [Default::default(); SIGNING_ALGORITHM_KEY_LENGTH],
                 // Attestation info.
-                alloc::vec![],
+                vec![],
                 // Additional info.
-                alloc::vec![],
+                vec![],
             )
         };
 
@@ -681,9 +681,7 @@ struct Transcript {
 
 impl Transcript {
     pub fn new() -> Self {
-        Self {
-            value: alloc::vec![],
-        }
+        Self { value: vec![] }
     }
 
     /// Appends a serialized `message` to the end of [`Transcript::value`].

remote_attestation/rust/src/tests/handshaker.rs

@@ -22,6 +22,7 @@ use crate::{
     },
     tests::message::INVALID_MESSAGE_HEADER,
 };
+use alloc::{boxed::Box, vec};
 use assert_matches::assert_matches;
 
 const TEE_MEASUREMENT: &str = "Test TEE measurement";
@@ -33,7 +34,7 @@ fn create_handshakers() -> (ClientHandshaker, ServerHandshaker) {
             .unwrap();
     let client_handshaker = ClientHandshaker::new(
         bidirectional_attestation,
-        alloc::boxed::Box::new(|server_identity| {
+        Box::new(|server_identity| {
             if !server_identity.additional_info.is_empty() {
                 Ok(())
             } else {
@@ -113,7 +114,7 @@ fn test_handshake() {
 #[test]
 fn test_invalid_message_after_initialization() {
     let (mut client_handshaker, mut server_handshaker) = create_handshakers();
-    let invalid_message = alloc::vec![INVALID_MESSAGE_HEADER];
+    let invalid_message = vec![INVALID_MESSAGE_HEADER];
 
     let result = client_handshaker.next_step(&invalid_message);
     assert_matches!(result, Err(_));
@@ -129,7 +130,7 @@ fn test_invalid_message_after_initialization() {
 #[test]
 fn test_invalid_message_after_hello() {
     let (mut client_handshaker, mut server_handshaker) = create_handshakers();
-    let invalid_message = alloc::vec![INVALID_MESSAGE_HEADER];
+    let invalid_message = vec![INVALID_MESSAGE_HEADER];
 
     let client_hello = client_handshaker.create_client_hello().unwrap();
     let result = client_handshaker.next_step(&invalid_message);
@@ -148,7 +149,7 @@ fn test_invalid_message_after_hello() {
 #[test]
 fn test_invalid_message_after_identities() {
     let (mut client_handshaker, mut server_handshaker) = create_handshakers();
-    let invalid_message = alloc::vec![INVALID_MESSAGE_HEADER];
+    let invalid_message = vec![INVALID_MESSAGE_HEADER];
 
     let client_hello = client_handshaker.create_client_hello().unwrap();
     let server_identity = server_handshaker.next_step(&client_hello).unwrap().unwrap();

remote_attestation/rust/src/tests/message.rs

@@ -25,7 +25,7 @@ use crate::{
         MAXIMUM_MESSAGE_SIZE, REPLAY_PROTECTION_ARRAY_LENGTH, SERVER_IDENTITY_HEADER,
     },
 };
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 use anyhow::{anyhow, Context};
 use assert_matches::assert_matches;
 use quickcheck::{quickcheck, TestResult};
@@ -201,8 +201,8 @@ fn test_deserialize_message() {
         default_array(),
         default_array(),
         default_array(),
-        alloc::vec![],
-        alloc::vec![],
+        vec![],
+        vec![],
     );
     let deserialized_server_identity = deserialize_message(&server_identity.serialize().unwrap());
     assert_matches!(deserialized_server_identity, Ok(_));
@@ -211,23 +211,23 @@ fn test_deserialize_message() {
         MessageWrapper::ServerIdentity(server_identity)
     );
 
-    let client_identity = ClientIdentity::new(default_array(), default_array(), alloc::vec![]);
+    let client_identity = ClientIdentity::new(default_array(), default_array(), vec![]);
     let deserialized_client_identity = deserialize_message(&client_identity.serialize().unwrap());
     assert_matches!(deserialized_client_identity, Ok(_));
     assert_eq!(
         deserialized_client_identity.unwrap(),
         MessageWrapper::ClientIdentity(client_identity)
     );
 
-    let encrypted_data = EncryptedData::new(default_array(), alloc::vec![]);
+    let encrypted_data = EncryptedData::new(default_array(), vec![]);
     let deserialized_encrypted_data = deserialize_message(&encrypted_data.serialize().unwrap());
     assert_matches!(deserialized_encrypted_data, Ok(_));
     assert_eq!(
         deserialized_encrypted_data.unwrap(),
         MessageWrapper::EncryptedData(encrypted_data)
     );
 
-    let invalid_message = alloc::vec![INVALID_MESSAGE_HEADER];
+    let invalid_message = vec![INVALID_MESSAGE_HEADER];
     let deserialized_invalid_message = deserialize_message(&invalid_message);
     assert_matches!(deserialized_invalid_message, Err(_));
 
@@ -249,7 +249,7 @@ fn test_deserialize_message() {
     assert_matches!(deserialized_big_client_identity, Err(_));
 
     let big_encrypted_data =
-        EncryptedData::new([0; NONCE_LENGTH], alloc::vec![0; MAXIMUM_MESSAGE_SIZE + 1])
+        EncryptedData::new([0; NONCE_LENGTH], vec![0; MAXIMUM_MESSAGE_SIZE + 1])
             .serialize()
             .unwrap();
     let deserialized_big_encrypted_data = deserialize_message(&big_encrypted_data);