| //! Test methods to confirm basic functionality of trait implementations. |
| |
| extern crate alloc; |
| use authgraph_core::key::{ |
| AesKey, EcSignKey, EcVerifyKey, EcdhSecret, HmacKey, Identity, Key, Nonce12, PseudoRandKey, |
| CURVE25519_PRIV_KEY_LEN, EXPLICIT_KEY_DICE_CERT_CHAIN_VERSION, IDENTITY_VERSION, |
| }; |
| use authgraph_core::keyexchange; |
| use authgraph_core::traits::{ |
| AesGcm, Device, EcDh, EcDsa, Hkdf, Hmac, MonotonicClock, Rng, Sha256, |
| }; |
| use authgraph_core::{ag_err, error::Error}; |
| use authgraph_wire::ErrorCode; |
| use coset::{ |
| cbor::Value, |
| iana::{self, EnumI64}, |
| Algorithm, CborSerializable, CoseKey, CoseKeyBuilder, CoseSign1Builder, HeaderBuilder, |
| KeyOperation, KeyType, Label, |
| }; |
| use std::ffi::CString; |
| |
| /// Test basic [`Rng`] functionality. |
| pub fn test_rng<R: Rng>(rng: &mut R) { |
| let mut nonce1 = [0; 16]; |
| let mut nonce2 = [0; 16]; |
| rng.fill_bytes(&mut nonce1); |
| assert_ne!(nonce1, nonce2, "random value is all zeroes!"); |
| |
| rng.fill_bytes(&mut nonce2); |
| assert_ne!(nonce1, nonce2, "two random values match!"); |
| } |
| |
| /// Test basic [`MonotonicClock`] functionality. |
| pub fn test_clock<C: MonotonicClock>(clock: &C) { |
| let t1 = clock.now(); |
| let t2 = clock.now(); |
| assert!(t2.0 >= t1.0); |
| std::thread::sleep(std::time::Duration::from_millis(400)); |
| let t3 = clock.now(); |
| assert!(t3.0 > (t1.0 + 200)); |
| } |
| |
| /// Test basic [`Sha256`] functionality. |
| pub fn test_sha256<S: Sha256>(digest: &S) { |
| let tests: &[(&'static [u8], &'static str)] = &[ |
| (b"", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"), |
| (b"abc", "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"), |
| ]; |
| for (i, (data, want)) in tests.iter().enumerate() { |
| let got = digest.compute_sha256(data).unwrap(); |
| assert_eq!(hex::encode(got), *want, "incorrect for case {i}") |
| } |
| } |
| |
| /// Test basic [`Hmac`] functionality. |
| pub fn test_hmac<H: Hmac>(hmac: &H) { |
| struct TestCase { |
| key: &'static str, // 32 bytes, hex-encoded |
| data: &'static [u8], |
| want: &'static str, // 32 bytes, hex-encoded |
| } |
| let tests = [ |
| TestCase { |
| key: "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", |
| data: b"Hello", |
| want: "0adc968519e7e86e9fde625df7037baeab85ea5001583b93b9f576258bf7b20c", |
| }, |
| TestCase { |
| key: "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", |
| data: &[], |
| want: "d38b42096d80f45f826b44a9d5607de72496a415d3f4a1a8c88e3bb9da8dc1cb", |
| }, |
| ]; |
| |
| for (i, test) in tests.iter().enumerate() { |
| let key = hex::decode(test.key).unwrap(); |
| let key = HmacKey(key.try_into().unwrap()); |
| let got = hmac.compute_hmac(&key, test.data).unwrap(); |
| assert_eq!(hex::encode(&got), test.want, "incorrect for case {i}"); |
| } |
| } |
| |
| /// Test basic HKDF functionality. |
| pub fn test_hkdf<H: Hkdf>(h: &H) { |
| struct TestCase { |
| ikm: &'static str, |
| salt: &'static str, |
| info: &'static str, |
| want: &'static str, |
| } |
| |
| let tests = [ |
| // RFC 5869 section A.1 |
| TestCase { |
| ikm: "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", |
| salt: "000102030405060708090a0b0c", |
| info: "f0f1f2f3f4f5f6f7f8f9", |
| want: "3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf", |
| }, |
| // RFC 5869 section A.2 |
| TestCase { |
| ikm: concat!( |
| "000102030405060708090a0b0c0d0e0f", |
| "101112131415161718191a1b1c1d1e1f", |
| "202122232425262728292a2b2c2d2e2f", |
| "303132333435363738393a3b3c3d3e3f", |
| "404142434445464748494a4b4c4d4e4f", |
| ), |
| salt: concat!( |
| "606162636465666768696a6b6c6d6e6f", |
| "707172737475767778797a7b7c7d7e7f", |
| "808182838485868788898a8b8c8d8e8f", |
| "909192939495969798999a9b9c9d9e9f", |
| "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf", |
| ), |
| info: concat!( |
| "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf", |
| "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf", |
| "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf", |
| "e0e1e2e3e4e5e6e7e8e9eaebecedeeef", |
| "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", |
| ), |
| want: "b11e398dc80327a1c8e7f78c596a49344f012eda2d4efad8a050cc4c19afa97c", |
| }, |
| TestCase { |
| ikm: "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", |
| salt: "", |
| info: "", |
| want: "8da4e775a563c18f715f802a063c5a31b8a11f5c5ee1879ec3454e5f3c738d2d", |
| }, |
| ]; |
| |
| for (i, test) in tests.iter().enumerate() { |
| let ikm = hex::decode(test.ikm).unwrap(); |
| let salt = hex::decode(test.salt).unwrap(); |
| let info = hex::decode(test.info).unwrap(); |
| |
| let got = hkdf(h, &salt, &ikm, &info).unwrap().0; |
| assert_eq!(hex::encode(got), test.want, "incorrect for case {i}"); |
| } |
| } |
| |
| fn hkdf(hkdf: &dyn Hkdf, salt: &[u8], ikm: &[u8], info: &[u8]) -> Result<PseudoRandKey, Error> { |
| let ikm = EcdhSecret(ikm.to_vec()); |
| let prk = hkdf.extract(salt, &ikm)?; |
| hkdf.expand(&prk, info) |
| } |
| |
| /// Simple test that AES key generation is random. |
| pub fn test_aes_gcm_keygen<A: AesGcm, R: Rng>(aes: &A, rng: &mut R) { |
| let key1 = aes.generate_key(rng).unwrap(); |
| let key2 = aes.generate_key(rng).unwrap(); |
| assert_ne!(key1.0, key2.0, "identical generated AES keys!"); |
| } |
| |
| /// Test basic AES-GCM round-trip functionality. |
| pub fn test_aes_gcm_roundtrip<A: AesGcm, R: Rng>(aes: &A, rng: &mut R) { |
| let key = aes.generate_key(rng).unwrap(); |
| let msg = b"The Magic Words are Squeamish Ossifrage"; |
| let aad = b"the aad"; |
| let nonce = Nonce12(*b"1243567890ab"); |
| let ct = aes.encrypt(&key, msg, aad, &nonce).unwrap(); |
| let pt = aes.decrypt(&key, &ct, aad, &nonce).unwrap(); |
| assert_eq!(pt, msg); |
| |
| // Modifying any of the inputs should induce failure. |
| let bad_key = aes.generate_key(rng).unwrap(); |
| let bad_aad = b"the AAD"; |
| let bad_nonce = Nonce12(*b"ab1243567890"); |
| let mut bad_ct = ct.clone(); |
| bad_ct[0] ^= 0x01; |
| |
| assert!(aes.decrypt(&bad_key, &ct, aad, &nonce).is_err()); |
| assert!(aes.decrypt(&key, &bad_ct, aad, &nonce).is_err()); |
| assert!(aes.decrypt(&key, &ct, bad_aad, &nonce).is_err()); |
| assert!(aes.decrypt(&key, &ct, aad, &bad_nonce).is_err()); |
| } |
| |
| /// Test AES-GCM against test vectors. |
| pub fn test_aes_gcm<A: AesGcm>(aes: &A) { |
| struct TestCase { |
| key: &'static str, |
| iv: &'static str, |
| aad: &'static str, |
| msg: &'static str, |
| ct: &'static str, |
| tag: &'static str, |
| } |
| |
| // Test vectors from Wycheproof aes_gcm_test.json. |
| let aes_gcm_tests = [ |
| TestCase { |
| // tcId: 73 |
| key: "92ace3e348cd821092cd921aa3546374299ab46209691bc28b8752d17f123c20", |
| iv: "00112233445566778899aabb", |
| aad: "00000000ffffffff", |
| msg: "00010203040506070809", |
| ct: "e27abdd2d2a53d2f136b", |
| tag: "9a4a2579529301bcfb71c78d4060f52c", |
| }, |
| TestCase { |
| // tcId: 74 |
| key: "29d3a44f8723dc640239100c365423a312934ac80239212ac3df3421a2098123", |
| iv: "00112233445566778899aabb", |
| aad: "aabbccddeeff", |
| msg: "", |
| ct: "", |
| tag: "2a7d77fa526b8250cb296078926b5020", |
| }, |
| TestCase { |
| // tcId: 75 |
| key: "80ba3192c803ce965ea371d5ff073cf0f43b6a2ab576b208426e11409c09b9b0", |
| iv: "4da5bf8dfd5852c1ea12379d", |
| aad: "", |
| msg: "", |
| ct: "", |
| tag: "4771a7c404a472966cea8f73c8bfe17a", |
| }, |
| TestCase { |
| // tcId: 76 |
| key: "cc56b680552eb75008f5484b4cb803fa5063ebd6eab91f6ab6aef4916a766273", |
| iv: "99e23ec48985bccdeeab60f1", |
| aad: "", |
| msg: "2a", |
| ct: "06", |
| tag: "633c1e9703ef744ffffb40edf9d14355", |
| }, |
| TestCase { |
| // tcId: 77 |
| key: "51e4bf2bad92b7aff1a4bc05550ba81df4b96fabf41c12c7b00e60e48db7e152", |
| iv: "4f07afedfdc3b6c2361823d3", |
| aad: "", |
| msg: "be3308f72a2c6aed", |
| ct: "cf332a12fdee800b", |
| tag: "602e8d7c4799d62c140c9bb834876b09", |
| }, |
| TestCase { |
| // tcId: 78 |
| key: "67119627bd988eda906219e08c0d0d779a07d208ce8a4fe0709af755eeec6dcb", |
| iv: "68ab7fdbf61901dad461d23c", |
| aad: "", |
| msg: "51f8c1f731ea14acdb210a6d973e07", |
| ct: "43fc101bff4b32bfadd3daf57a590e", |
| tag: "ec04aacb7148a8b8be44cb7eaf4efa69", |
| }, |
| ]; |
| for (i, test) in aes_gcm_tests.iter().enumerate() { |
| let key = AesKey(hex::decode(test.key).unwrap().try_into().unwrap()); |
| let nonce = Nonce12(hex::decode(test.iv).unwrap().try_into().unwrap()); |
| let aad = hex::decode(test.aad).unwrap(); |
| let msg = hex::decode(test.msg).unwrap(); |
| let want_hex = test.ct.to_owned() + test.tag; |
| |
| let got = aes.encrypt(&key, &msg, &aad, &nonce).unwrap(); |
| assert_eq!(hex::encode(&got), want_hex, "incorrect for case {i}"); |
| |
| let got_pt = aes.decrypt(&key, &got, &aad, &nonce).unwrap(); |
| assert_eq!(hex::encode(got_pt), test.msg, "incorrect decrypt for case {i}"); |
| } |
| } |
| |
| /// Test `EcDh` impl for ECDH. |
| pub fn test_ecdh<E: EcDh>(ecdh: &E) { |
| let key1 = ecdh.generate_key().unwrap(); |
| let key2 = ecdh.generate_key().unwrap(); |
| let secret12 = ecdh.compute_shared_secret(&key1.priv_key, &key2.pub_key).unwrap(); |
| let secret21 = ecdh.compute_shared_secret(&key2.priv_key, &key1.pub_key).unwrap(); |
| assert_eq!(secret12.0, secret21.0); |
| } |
| |
| /// Test `EcDsa` impl for verify. |
| pub fn test_ecdsa<E: EcDsa>(ecdsa: &E) { |
| let ed25519_key = coset::CoseKeyBuilder::new_okp_key() |
| .param(iana::OkpKeyParameter::Crv as i64, Value::from(iana::EllipticCurve::Ed25519 as u64)) |
| .param( |
| iana::OkpKeyParameter::X as i64, |
| Value::from( |
| hex::decode("7d4d0e7f6153a69b6242b522abbee685fda4420f8834b108c3bdae369ef549fa") |
| .unwrap(), |
| ), |
| ) |
| .algorithm(coset::iana::Algorithm::EdDSA) |
| .build(); |
| let p256_key = CoseKeyBuilder::new_ec2_pub_key( |
| iana::EllipticCurve::P_256, |
| hex::decode("2927b10512bae3eddcfe467828128bad2903269919f7086069c8c4df6c732838").unwrap(), |
| hex::decode("c7787964eaac00e5921fb1498a60f4606766b3d9685001558d1a974e7341513e").unwrap(), |
| ) |
| .algorithm(iana::Algorithm::ES256) |
| .build(); |
| let p384_key = CoseKeyBuilder::new_ec2_pub_key( |
| iana::EllipticCurve::P_384, |
| hex::decode("2da57dda1089276a543f9ffdac0bff0d976cad71eb7280e7d9bfd9fee4bdb2f20f47ff888274389772d98cc5752138aa").unwrap(), |
| hex::decode("4b6d054d69dcf3e25ec49df870715e34883b1836197d76f8ad962e78f6571bbc7407b0d6091f9e4d88f014274406174f").unwrap(), |
| ) |
| .algorithm(iana::Algorithm::ES384) |
| .build(); |
| |
| struct TestCase { |
| key: EcVerifyKey, |
| msg: &'static str, // hex |
| sig: &'static str, // hex |
| } |
| let tests = [ |
| // Wycheproof: eddsa_test.json tcId=5 |
| TestCase { |
| key: EcVerifyKey::Ed25519(ed25519_key), |
| msg: "313233343030", |
| sig: "657c1492402ab5ce03e2c3a7f0384d051b9cf3570f1207fc78c1bcc98c281c2bf0cf5b3a289976458a1be6277a5055545253b45b07dcc1abd96c8b989c00f301", |
| }, |
| // Wycheproof: ecdsa_secp256r1_sha256_test.json tcId=3 |
| // Signature converted to R | S form |
| TestCase { |
| key: EcVerifyKey::P256(p256_key), |
| msg: "313233343030", |
| sig: "2ba3a8be6b94d5ec80a6d9d1190a436effe50d85a1eee859b8cc6af9bd5c2e18b329f479a2bbd0a5c384ee1493b1f5186a87139cac5df4087c134b49156847db", |
| }, |
| // Wycheproof: ecdsa_secp384r1_sha384_test.json tcId=3 |
| // Signature converted to R | S form |
| TestCase { |
| key: EcVerifyKey::P384(p384_key), |
| msg: "313233343030", |
| sig: "12b30abef6b5476fe6b612ae557c0425661e26b44b1bfe19daf2ca28e3113083ba8e4ae4cc45a0320abd3394f1c548d7e7bf25603e2d07076ff30b7a2abec473da8b11c572b35fc631991d5de62ddca7525aaba89325dfd04fecc47bff426f82", |
| }, |
| ]; |
| |
| for (i, test) in tests.iter().enumerate() { |
| let sig = hex::decode(test.sig).unwrap(); |
| let msg = hex::decode(test.msg).unwrap(); |
| |
| assert!(ecdsa.verify_signature(&test.key, &msg, &sig).is_ok(), "failed for case {i}"); |
| |
| // A modified message should not verify. |
| let mut bad_msg = msg.clone(); |
| bad_msg[0] ^= 0x01; |
| assert!( |
| ecdsa.verify_signature(&test.key, &bad_msg, &sig).is_err(), |
| "unexpected success for case {i}" |
| ); |
| |
| // A modified signature should not verify. |
| let mut bad_sig = sig; |
| bad_sig[0] ^= 0x01; |
| assert!( |
| ecdsa.verify_signature(&test.key, &msg, &bad_sig).is_err(), |
| "unexpected success for case {i}" |
| ); |
| } |
| } |
| |
| /// Test EdDSA signing and verification for Ed25519. |
| pub fn test_ed25519_round_trip<E: EcDsa>(ecdsa: &E) { |
| // Wycheproof: eddsa_test.json |
| let ed25519_pub_key = coset::CoseKeyBuilder::new_okp_key() |
| .param(iana::OkpKeyParameter::Crv as i64, Value::from(iana::EllipticCurve::Ed25519 as u64)) |
| .param( |
| iana::OkpKeyParameter::X as i64, |
| Value::from( |
| hex::decode("7d4d0e7f6153a69b6242b522abbee685fda4420f8834b108c3bdae369ef549fa") |
| .unwrap(), |
| ), |
| ) |
| .algorithm(coset::iana::Algorithm::EdDSA) |
| .build(); |
| let ed25519_verify_key = EcVerifyKey::Ed25519(ed25519_pub_key); |
| let ed25519_sign_key = EcSignKey::Ed25519( |
| hex::decode("add4bb8103785baf9ac534258e8aaf65f5f1adb5ef5f3df19bb80ab989c4d64b") |
| .unwrap() |
| .try_into() |
| .unwrap(), |
| ); |
| test_ecdsa_round_trip(ecdsa, &ed25519_verify_key, &ed25519_sign_key) |
| } |
| |
| // It's not possible to include a generic test for `EcDsa::sign` with NIST curves because the |
| // format of the `EcSignKey` is implementation-dependent. The following tests are therefore |
| // specific to implementations (such as the reference implementation) which store private key |
| // material for NIST EC curves in the form of DER-encoded `ECPrivateKey` structures. |
| |
| /// Test EdDSA signing and verification for P-256. |
| pub fn test_p256_round_trip<E: EcDsa>(ecdsa: &E) { |
| // Generated with: openssl ecparam --name prime256v1 -genkey -noout -out p256-privkey.pem |
| // |
| // Contents (der2ascii -pem -i p256-privkey.pem): |
| // |
| // SEQUENCE { |
| // INTEGER { 1 } |
| // OCTET_STRING { `0733c93e22240ba783739f9e2bd4b4065bfcecac9268362587dc814da5b84080` } |
| // [0] { |
| // # secp256r1 |
| // OBJECT_IDENTIFIER { 1.2.840.10045.3.1.7 } |
| // } |
| // [1] { |
| // BIT_STRING { `00` `04` |
| // `2b31afcfab1aba1f8850d7ecfa235e14d60a1ef5b2a75b93ccaa4322de094477` |
| // `21ba560a040bab8c922edd32a279e9d3ac991f1507d4b4beded5fd80298b7cee` |
| // } |
| // } |
| // } |
| let p256_priv_key = hex::decode("307702010104200733c93e22240ba783739f9e2bd4b4065bfcecac9268362587dc814da5b84080a00a06082a8648ce3d030107a144034200042b31afcfab1aba1f8850d7ecfa235e14d60a1ef5b2a75b93ccaa4322de09447721ba560a040bab8c922edd32a279e9d3ac991f1507d4b4beded5fd80298b7cee").unwrap(); |
| let p256_pub_key = CoseKeyBuilder::new_ec2_pub_key( |
| iana::EllipticCurve::P_256, |
| hex::decode("2b31afcfab1aba1f8850d7ecfa235e14d60a1ef5b2a75b93ccaa4322de094477").unwrap(), |
| hex::decode("21ba560a040bab8c922edd32a279e9d3ac991f1507d4b4beded5fd80298b7cee").unwrap(), |
| ) |
| .algorithm(iana::Algorithm::ES256) |
| .build(); |
| |
| test_ecdsa_round_trip(ecdsa, &EcVerifyKey::P256(p256_pub_key), &EcSignKey::P256(p256_priv_key)) |
| } |
| |
| /// Test EdDSA signing and verification for P-384. |
| pub fn test_p384_round_trip<E: EcDsa>(ecdsa: &E) { |
| // Generated with: openssl ecparam --name secp384r1 -genkey -noout -out p384-privkey.pem |
| // |
| // Contents (der2ascii -pem -i p384-privkey.pem): |
| // |
| // SEQUENCE { |
| // INTEGER { 1 } |
| // OCTET_STRING { `81a9d9e43e47dbbf3e7e4e9e06d467b1b126603969bf80f0ade1e1aea9ed534884b81d86ece0bbd41d541bf6d22f6be2` } |
| // [0] { |
| // # secp384r1 |
| // OBJECT_IDENTIFIER { 1.3.132.0.34 } |
| // } |
| // [1] { |
| // BIT_STRING { `00` `04` |
| // `fdf3f076a6e98047baf68a44d319f0200a03c4807eb0e869db88e1c9758ba96647fecbe0456c475feeb67021e053de93` |
| // `478ad58e972d52af0ea5911fe24f82448e9c073263aaa49117c451e787eced645796e50b24ee2c632a6c77e6d430ad01` |
| // } |
| // } |
| // } |
| let p384_priv_key = hex::decode("3081a4020101043081a9d9e43e47dbbf3e7e4e9e06d467b1b126603969bf80f0ade1e1aea9ed534884b81d86ece0bbd41d541bf6d22f6be2a00706052b81040022a16403620004fdf3f076a6e98047baf68a44d319f0200a03c4807eb0e869db88e1c9758ba96647fecbe0456c475feeb67021e053de93478ad58e972d52af0ea5911fe24f82448e9c073263aaa49117c451e787eced645796e50b24ee2c632a6c77e6d430ad01").unwrap(); |
| let p384_pub_key = CoseKeyBuilder::new_ec2_pub_key( |
| iana::EllipticCurve::P_384, |
| hex::decode("fdf3f076a6e98047baf68a44d319f0200a03c4807eb0e869db88e1c9758ba96647fecbe0456c475feeb67021e053de93").unwrap(), |
| hex::decode("478ad58e972d52af0ea5911fe24f82448e9c073263aaa49117c451e787eced645796e50b24ee2c632a6c77e6d430ad01").unwrap(), |
| ) |
| .algorithm(iana::Algorithm::ES384) |
| .build(); |
| |
| test_ecdsa_round_trip(ecdsa, &EcVerifyKey::P384(p384_pub_key), &EcSignKey::P384(p384_priv_key)) |
| } |
| |
| fn test_ecdsa_round_trip<E: EcDsa>(ecdsa: &E, verify_key: &EcVerifyKey, sign_key: &EcSignKey) { |
| let msg = b"This is the message"; |
| let sig = ecdsa.sign(sign_key, msg).unwrap(); |
| |
| assert!(ecdsa.verify_signature(verify_key, msg, &sig).is_ok()); |
| |
| // A modified message should not verify. |
| let mut bad_msg = *msg; |
| bad_msg[0] ^= 0x01; |
| assert!(ecdsa.verify_signature(verify_key, &bad_msg, &sig).is_err()); |
| |
| // A modified signature should not verify. |
| let mut bad_sig = sig; |
| bad_sig[0] ^= 0x01; |
| assert!(ecdsa.verify_signature(verify_key, msg, &bad_sig).is_err()); |
| } |
| |
| /// Test `create` method of key exchange protocol |
| pub fn test_key_exchange_create(source: &mut keyexchange::AuthGraphParticipant) { |
| let create_result = source.create(); |
| assert!(create_result.is_ok()); |
| |
| // TODO: Add more tests on the values returned from `create` (some of these tests may |
| // need to be done in `libauthgraph_boringssl_test`) |
| // 1. dh_key is not None, |
| // 2. dh_key->pub key is in CoseKey encoding (e..g purpose) |
| // 3. dh_key->priv_key arc can be decrypted from the pbk from the AgDevice, the IV attached |
| // in the unprotected headers, nonce for key exchange and the payload type = SecretKey |
| // attached in the protected headers |
| // 5. identity decodes to a CBOR vector and the second element is a bstr of |
| // CoseKey |
| // 6. nonce is same as the nonce attached in the protected header of the arc in |
| // #3 above |
| // 7. ECDH can be performed from the dh_key returned from this method |
| } |
| |
| /// Test `init` method of key exchange protocol |
| pub fn test_key_exchange_init( |
| source: &mut keyexchange::AuthGraphParticipant, |
| sink: &mut keyexchange::AuthGraphParticipant, |
| ) { |
| let keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: peer_ke_pub_key, .. }, |
| identity: peer_identity, |
| nonce: peer_nonce, |
| version: peer_version, |
| } = source.create().unwrap(); |
| |
| let init_result = |
| sink.init(&peer_ke_pub_key.unwrap(), &peer_identity, &peer_nonce, peer_version); |
| assert!(init_result.is_ok()) |
| // TODO: add more tests on init_result |
| } |
| |
| /// Test `finish` method of key exchange protocol |
| pub fn test_key_exchange_finish( |
| source: &mut keyexchange::AuthGraphParticipant, |
| sink: &mut keyexchange::AuthGraphParticipant, |
| ) { |
| let keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| identity: p1_identity, |
| nonce: p1_nonce, |
| version: p1_version, |
| } = source.create().unwrap(); |
| |
| let keyexchange::KeInitResult { |
| session_init_info: |
| keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p2_ke_pub_key, .. }, |
| identity: p2_identity, |
| nonce: p2_nonce, |
| version: p2_version, |
| }, |
| session_info: keyexchange::SessionInfo { session_id_signature: p2_signature, .. }, |
| } = sink.init(p1_ke_pub_key.as_ref().unwrap(), &p1_identity, &p1_nonce, p1_version).unwrap(); |
| |
| let finish_result = source.finish( |
| &p2_ke_pub_key.unwrap(), |
| &p2_identity, |
| &p2_signature, |
| &p2_nonce, |
| p2_version, |
| Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| ); |
| assert!(finish_result.is_ok()) |
| // TODO: add more tests on finish_result |
| } |
| |
| /// Test `authentication_complete` method of key exchange protocol |
| pub fn test_key_exchange_auth_complete( |
| source: &mut keyexchange::AuthGraphParticipant, |
| sink: &mut keyexchange::AuthGraphParticipant, |
| ) { |
| let keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| identity: p1_identity, |
| nonce: p1_nonce, |
| version: p1_version, |
| } = source.create().unwrap(); |
| |
| let keyexchange::KeInitResult { |
| session_init_info: |
| keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p2_ke_pub_key, .. }, |
| identity: p2_identity, |
| nonce: p2_nonce, |
| version: p2_version, |
| }, |
| session_info: |
| keyexchange::SessionInfo { |
| shared_keys: p2_shared_keys, |
| session_id: p2_session_id, |
| session_id_signature: p2_signature, |
| }, |
| } = sink.init(p1_ke_pub_key.as_ref().unwrap(), &p1_identity, &p1_nonce, p1_version).unwrap(); |
| |
| let keyexchange::SessionInfo { |
| shared_keys: _p1_shared_keys, |
| session_id: p1_session_id, |
| session_id_signature: p1_signature, |
| } = source |
| .finish( |
| &p2_ke_pub_key.unwrap(), |
| &p2_identity, |
| &p2_signature, |
| &p2_nonce, |
| p2_version, |
| Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| ) |
| .unwrap(); |
| |
| let auth_complete_result = sink.authentication_complete(&p1_signature, p2_shared_keys); |
| assert!(auth_complete_result.is_ok()); |
| assert_eq!(p1_session_id, p2_session_id) |
| // TODO: add more tests on finish_result, and encrypt/decrypt using the agreed keys |
| } |
| |
| /// Verify that the key exchange protocol works when source's version is higher than sink's version |
| /// and that the negotiated version is sink's version |
| pub fn test_ke_with_newer_source( |
| source_newer: &mut keyexchange::AuthGraphParticipant, |
| sink: &mut keyexchange::AuthGraphParticipant, |
| ) { |
| let source_version = source_newer.get_version(); |
| let sink_version = sink.get_version(); |
| assert!(source_version > sink_version); |
| |
| let keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| identity: p1_identity, |
| nonce: p1_nonce, |
| version: p1_version, |
| } = source_newer.create().unwrap(); |
| |
| let keyexchange::KeInitResult { |
| session_init_info: |
| keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p2_ke_pub_key, .. }, |
| identity: p2_identity, |
| nonce: p2_nonce, |
| version: p2_version, |
| }, |
| session_info: |
| keyexchange::SessionInfo { |
| shared_keys: p2_shared_keys, |
| session_id: p2_session_id, |
| session_id_signature: p2_signature, |
| }, |
| } = sink.init(p1_ke_pub_key.as_ref().unwrap(), &p1_identity, &p1_nonce, p1_version).unwrap(); |
| assert_eq!(p2_version, sink_version); |
| |
| let keyexchange::SessionInfo { |
| shared_keys: _p1_shared_keys, |
| session_id: p1_session_id, |
| session_id_signature: p1_signature, |
| } = source_newer |
| .finish( |
| &p2_ke_pub_key.unwrap(), |
| &p2_identity, |
| &p2_signature, |
| &p2_nonce, |
| p2_version, |
| Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| ) |
| .unwrap(); |
| |
| let auth_complete_result = sink.authentication_complete(&p1_signature, p2_shared_keys); |
| assert!(auth_complete_result.is_ok()); |
| assert_eq!(p1_session_id, p2_session_id) |
| } |
| |
| /// Verify that the key exchange protocol works when sink's version is higher than sources's version |
| /// and that the negotiated version is source's version |
| pub fn test_ke_with_newer_sink( |
| source: &mut keyexchange::AuthGraphParticipant, |
| sink_newer: &mut keyexchange::AuthGraphParticipant, |
| ) { |
| let source_version = source.get_version(); |
| let sink_version = sink_newer.get_version(); |
| assert!(sink_version > source_version); |
| |
| let keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| identity: p1_identity, |
| nonce: p1_nonce, |
| version: p1_version, |
| } = source.create().unwrap(); |
| |
| let keyexchange::KeInitResult { |
| session_init_info: |
| keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p2_ke_pub_key, .. }, |
| identity: p2_identity, |
| nonce: p2_nonce, |
| version: p2_version, |
| }, |
| session_info: |
| keyexchange::SessionInfo { |
| shared_keys: p2_shared_keys, |
| session_id: p2_session_id, |
| session_id_signature: p2_signature, |
| }, |
| } = sink_newer |
| .init(p1_ke_pub_key.as_ref().unwrap(), &p1_identity, &p1_nonce, p1_version) |
| .unwrap(); |
| assert_eq!(p2_version, source_version); |
| |
| let keyexchange::SessionInfo { |
| shared_keys: _p1_shared_keys, |
| session_id: p1_session_id, |
| session_id_signature: p1_signature, |
| } = source |
| .finish( |
| &p2_ke_pub_key.unwrap(), |
| &p2_identity, |
| &p2_signature, |
| &p2_nonce, |
| p2_version, |
| Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| ) |
| .unwrap(); |
| |
| let auth_complete_result = sink_newer.authentication_complete(&p1_signature, p2_shared_keys); |
| assert!(auth_complete_result.is_ok()); |
| assert_eq!(p1_session_id, p2_session_id) |
| } |
| |
| /// Verify that the key exchange protocol prevents version downgrade attacks when both source and |
| /// sink have versions newer than version 1 |
| pub fn test_ke_for_version_downgrade( |
| source: &mut keyexchange::AuthGraphParticipant, |
| sink: &mut keyexchange::AuthGraphParticipant, |
| ) { |
| let source_version = source.get_version(); |
| let sink_version = sink.get_version(); |
| assert!(source_version > 1); |
| assert!(sink_version > 1); |
| |
| let keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| identity: p1_identity, |
| nonce: p1_nonce, |
| version: _p1_version, |
| } = source.create().unwrap(); |
| |
| let downgraded_version = 1; |
| |
| let keyexchange::KeInitResult { |
| session_init_info: |
| keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p2_ke_pub_key, .. }, |
| identity: p2_identity, |
| nonce: p2_nonce, |
| version: p2_version, |
| }, |
| session_info: |
| keyexchange::SessionInfo { |
| shared_keys: _p2_shared_keys, |
| session_id: _p2_session_id, |
| session_id_signature: p2_signature, |
| }, |
| } = sink |
| .init(p1_ke_pub_key.as_ref().unwrap(), &p1_identity, &p1_nonce, downgraded_version) |
| .unwrap(); |
| assert_eq!(p2_version, downgraded_version); |
| |
| let finish_result = source.finish( |
| &p2_ke_pub_key.unwrap(), |
| &p2_identity, |
| &p2_signature, |
| &p2_nonce, |
| p2_version, |
| Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| ); |
| // `finish` should fail with signature verification error |
| match finish_result { |
| Ok(_) => panic!("protocol downgrade prevention is broken"), |
| Err(e) => match e { |
| Error(ErrorCode::InvalidSignature, _) => {} |
| _ => panic!("wrong error on protocol downgrade"), |
| }, |
| } |
| } |
| |
| /// Verify that the key exchange protocol prevents replay attacks |
| pub fn test_ke_for_replay( |
| source: &mut keyexchange::AuthGraphParticipant, |
| sink: &mut keyexchange::AuthGraphParticipant, |
| ) { |
| // Round 1 of the protocol |
| let keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| identity: p1_identity, |
| nonce: p1_nonce, |
| version: p1_version, |
| } = source.create().unwrap(); |
| |
| let keyexchange::KeInitResult { |
| session_init_info: |
| keyexchange::SessionInitiationInfo { |
| ke_key: Key { pub_key: p2_ke_pub_key, .. }, |
| identity: p2_identity, |
| nonce: p2_nonce, |
| version: p2_version, |
| }, |
| session_info: |
| keyexchange::SessionInfo { |
| shared_keys: p2_shared_keys, |
| session_id: p2_session_id, |
| session_id_signature: p2_signature, |
| }, |
| } = sink.init(p1_ke_pub_key.as_ref().unwrap(), &p1_identity, &p1_nonce, p1_version).unwrap(); |
| |
| let keyexchange::SessionInfo { |
| shared_keys: _p1_shared_keys, |
| session_id: p1_session_id, |
| session_id_signature: p1_signature, |
| } = source |
| .finish( |
| &p2_ke_pub_key.clone().unwrap(), |
| &p2_identity, |
| &p2_signature, |
| &p2_nonce, |
| p2_version, |
| Key { pub_key: p1_ke_pub_key.clone(), arc_from_pbk: p1_ke_priv_key_arc.clone() }, |
| ) |
| .unwrap(); |
| |
| let auth_complete_result = sink.authentication_complete(&p1_signature, p2_shared_keys.clone()); |
| assert!(auth_complete_result.is_ok()); |
| assert_eq!(p1_session_id, p2_session_id); |
| |
| // An attacker may try to run the key exchange protocol again, but this time, they try to |
| // replay the inputs of the previous protocol run, ignoring the outputs of `create` and `init` |
| // of the existing protocol run. In such cases, `finish` and `authentication_complete` should |
| // fail as per the measures against replay attacks. |
| source.create().unwrap(); |
| |
| sink.init(p1_ke_pub_key.as_ref().unwrap(), &p1_identity, &p1_nonce, p1_version).unwrap(); |
| |
| let finish_result = source.finish( |
| &p2_ke_pub_key.unwrap(), |
| &p2_identity, |
| &p2_signature, |
| &p2_nonce, |
| p2_version, |
| Key { pub_key: p1_ke_pub_key, arc_from_pbk: p1_ke_priv_key_arc }, |
| ); |
| match finish_result { |
| Ok(_) => panic!("replay prevention is broken in finish"), |
| Err(e) if e.0 == ErrorCode::InvalidKeKey => {} |
| Err(e) => panic!("got error {e:?}, wanted ErrorCode::InvalidKeKey"), |
| } |
| |
| let auth_complete_result = sink.authentication_complete(&p1_signature, p2_shared_keys); |
| match auth_complete_result { |
| Ok(_) => panic!("replay prevention is broken in authentication_complete"), |
| Err(e) if e.0 == ErrorCode::InvalidSharedKeyArcs => {} |
| Err(e) => panic!("got error {e:?}, wanted ErrorCode::InvalidSharedKeyArcs"), |
| } |
| } |
| |
| /// Test the logic of decoding and validating `Identity` using the test data created with open-dice. |
| pub fn validate_identity<E: EcDsa>(ecdsa: &E) { |
| for cert_chain_len in 0..6 { |
| let (pvt_sign_key, identity) = |
| create_identity(cert_chain_len).expect("error in creating identity"); |
| // decode identity |
| let decoded_identity = |
| Identity::from_slice(&identity).expect("error in decoding the identity"); |
| // validate identity |
| let verify_key = |
| decoded_identity.validate(ecdsa).expect("error in validating the identity"); |
| // re-encode the decoded identity |
| decoded_identity.to_vec().expect("failed to serialize Identity"); |
| |
| // sign using the private signing key derived from the leaf CDI attest |
| let data = b"test string to sign"; |
| |
| let protected = |
| HeaderBuilder::new().algorithm(verify_key.get_cose_sign_algorithm()).build(); |
| let cose_sign1 = CoseSign1Builder::new() |
| .protected(protected) |
| .payload(data.to_vec()) |
| .try_create_signature(&[], |input| ecdsa.sign(&pvt_sign_key, input)) |
| .expect("error creating the signature") |
| .build(); |
| // verify the signature with the public signing key extracted from the leaf certificate in |
| // the DICE chain |
| cose_sign1 |
| .verify_signature(&[], |signature, data| { |
| ecdsa.verify_signature(&verify_key, data, signature) |
| }) |
| .expect("error in verifying the signature"); |
| } |
| } |
| |
| /// Construct a CBOR serialized `Identity` with a `CertChain` containing the given number of |
| /// certificate entries, using open-dice. The maximum length supported by this method is 5. |
| /// Return the private signing key corresponding to the public signing key. |
| pub fn create_identity(dice_chain_len: usize) -> Result<(EcSignKey, Vec<u8>), Error> { |
| const UDS: [u8; diced_open_dice::CDI_SIZE] = [ |
| 0x1d, 0xa5, 0xea, 0x90, 0x47, 0xfc, 0xb5, 0xf6, 0x47, 0x12, 0xd3, 0x65, 0x9c, 0xf2, 0x00, |
| 0xe0, 0x06, 0xf7, 0xe8, 0x9e, 0x2f, 0xd0, 0x94, 0x7f, 0xc9, 0x9a, 0x9d, 0x40, 0xf7, 0xce, |
| 0x13, 0x21, |
| ]; |
| let pvt_key_seed = diced_open_dice::derive_cdi_private_key_seed(&UDS).unwrap(); |
| let (root_pub_key, pvt_key) = diced_open_dice::keypair_from_seed(pvt_key_seed.as_array()) |
| .expect("failed to create key pair from seed."); |
| let root_pub_cose_key = CoseKey { |
| kty: KeyType::Assigned(iana::KeyType::OKP), |
| alg: Some(Algorithm::Assigned(iana::Algorithm::EdDSA)), |
| key_ops: vec![KeyOperation::Assigned(iana::KeyOperation::Verify)].into_iter().collect(), |
| params: vec![ |
| ( |
| Label::Int(iana::Ec2KeyParameter::Crv.to_i64()), |
| iana::EllipticCurve::Ed25519.to_i64().into(), |
| ), |
| (Label::Int(iana::Ec2KeyParameter::X.to_i64()), Value::Bytes(root_pub_key.to_vec())), |
| ], |
| ..Default::default() |
| }; |
| let root_pub_cose_key_bstr = |
| root_pub_cose_key.to_vec().expect("failed to serialize root pub key"); |
| |
| if dice_chain_len == 0 { |
| let cert_chain = Value::Array(vec![ |
| Value::Integer(EXPLICIT_KEY_DICE_CERT_CHAIN_VERSION.into()), |
| Value::Bytes(root_pub_cose_key_bstr.clone()), |
| ]); |
| let identity = Value::Array(vec![ |
| Value::Integer(IDENTITY_VERSION.into()), |
| Value::Bytes(cert_chain.to_vec()?), |
| ]); |
| let pvt_key: [u8; CURVE25519_PRIV_KEY_LEN] = |
| pvt_key.as_array()[0..CURVE25519_PRIV_KEY_LEN].try_into().map_err(|e| { |
| ag_err!(InternalError, "error in constructing the private signing key {:?}", e) |
| })?; |
| return Ok((EcSignKey::Ed25519(pvt_key), identity.to_vec()?)); |
| } |
| |
| const CODE_HASH_PVMFW: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0x16, 0x48, 0xf2, 0x55, 0x53, 0x23, 0xdd, 0x15, 0x2e, 0x83, 0x38, 0xc3, 0x64, 0x38, 0x63, |
| 0x26, 0x0f, 0xcf, 0x5b, 0xd1, 0x3a, 0xd3, 0x40, 0x3e, 0x23, 0xf8, 0x34, 0x4c, 0x6d, 0xa2, |
| 0xbe, 0x25, 0x1c, 0xb0, 0x29, 0xe8, 0xc3, 0xfb, 0xb8, 0x80, 0xdc, 0xb1, 0xd2, 0xb3, 0x91, |
| 0x4d, 0xd3, 0xfb, 0x01, 0x0f, 0xe4, 0xe9, 0x46, 0xa2, 0xc0, 0x26, 0x57, 0x5a, 0xba, 0x30, |
| 0xf7, 0x15, 0x98, 0x14, |
| ]; |
| const AUTHORITY_HASH_PVMFW: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0xf9, 0x00, 0x9d, 0xc2, 0x59, 0x09, 0xe0, 0xb6, 0x98, 0xbd, 0xe3, 0x97, 0x4a, 0xcb, 0x3c, |
| 0xe7, 0x6b, 0x24, 0xc3, 0xe4, 0x98, 0xdd, 0xa9, 0x6a, 0x41, 0x59, 0x15, 0xb1, 0x23, 0xe6, |
| 0xc8, 0xdf, 0xfb, 0x52, 0xb4, 0x52, 0xc1, 0xb9, 0x61, 0xdd, 0xbc, 0x5b, 0x37, 0x0e, 0x12, |
| 0x12, 0xb2, 0xfd, 0xc1, 0x09, 0xb0, 0xcf, 0x33, 0x81, 0x4c, 0xc6, 0x29, 0x1b, 0x99, 0xea, |
| 0xae, 0xfd, 0xaa, 0x0d, |
| ]; |
| const HIDDEN_PVMFW: [u8; diced_open_dice::HIDDEN_SIZE] = [ |
| 0xa2, 0x01, 0xd0, 0xc0, 0xaa, 0x75, 0x3c, 0x06, 0x43, 0x98, 0x6c, 0xc3, 0x5a, 0xb5, 0x5f, |
| 0x1f, 0x0f, 0x92, 0x44, 0x3b, 0x0e, 0xd4, 0x29, 0x75, 0xe3, 0xdb, 0x36, 0xda, 0xc8, 0x07, |
| 0x97, 0x4d, 0xff, 0xbc, 0x6a, 0xa4, 0x8a, 0xef, 0xc4, 0x7f, 0xf8, 0x61, 0x7d, 0x51, 0x4d, |
| 0x2f, 0xdf, 0x7e, 0x8c, 0x3d, 0xa3, 0xfc, 0x63, 0xd4, 0xd4, 0x74, 0x8a, 0xc4, 0x14, 0x45, |
| 0x83, 0x6b, 0x12, 0x7e, |
| ]; |
| let comp_name_1 = CString::new("Protected VM firmware").expect("CString::new failed"); |
| let config_values_1 = diced_open_dice::DiceConfigValues { |
| component_name: Some(&comp_name_1), |
| component_version: Some(1), |
| resettable: true, |
| ..Default::default() |
| }; |
| let config_descriptor_1 = diced_open_dice::retry_bcc_format_config_descriptor(&config_values_1) |
| .expect("failed to format config descriptor"); |
| let input_values_1 = diced_open_dice::InputValues::new( |
| CODE_HASH_PVMFW, |
| diced_open_dice::Config::Descriptor(config_descriptor_1.as_slice()), |
| AUTHORITY_HASH_PVMFW, |
| diced_open_dice::DiceMode::kDiceModeDebug, |
| HIDDEN_PVMFW, |
| ); |
| let (cdi_values_1, cert_1) = diced_open_dice::retry_dice_main_flow(&UDS, &UDS, &input_values_1) |
| .expect("Failed to run first main flow"); |
| |
| if dice_chain_len == 1 { |
| let cert_chain = Value::Array(vec![ |
| Value::Integer(EXPLICIT_KEY_DICE_CERT_CHAIN_VERSION.into()), |
| Value::Bytes(root_pub_cose_key_bstr.clone()), |
| Value::from_slice(&cert_1).expect("failed to deserialize the certificate into CBOR"), |
| ]); |
| let identity = Value::Array(vec![ |
| Value::Integer(IDENTITY_VERSION.into()), |
| Value::Bytes(cert_chain.to_vec()?), |
| ]); |
| let pvt_key_seed = |
| diced_open_dice::derive_cdi_private_key_seed(&cdi_values_1.cdi_attest).unwrap(); |
| let (_, pvt_key) = diced_open_dice::keypair_from_seed(pvt_key_seed.as_array()) |
| .expect("failed to create key pair from seed."); |
| let pvt_key: [u8; CURVE25519_PRIV_KEY_LEN] = |
| pvt_key.as_array()[0..CURVE25519_PRIV_KEY_LEN].try_into().map_err(|e| { |
| ag_err!(InternalError, "error in constructing the private signing key {:?}", e) |
| })?; |
| return Ok((EcSignKey::Ed25519(pvt_key), identity.to_vec()?)); |
| } |
| |
| const CODE_HASH_SERVICE_VM: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0xa4, 0x0c, 0xcb, 0xc1, 0xbf, 0xfa, 0xcc, 0xfd, 0xeb, 0xf4, 0xfc, 0x43, 0x83, 0x7f, 0x46, |
| 0x8d, 0xd8, 0xd8, 0x14, 0xc1, 0x96, 0x14, 0x1f, 0x6e, 0xb3, 0xa0, 0xd9, 0x56, 0xb3, 0xbf, |
| 0x2f, 0xfa, 0x88, 0x70, 0x11, 0x07, 0x39, 0xa4, 0xd2, 0xa9, 0x6b, 0x18, 0x28, 0xe8, 0x29, |
| 0x20, 0x49, 0x0f, 0xbb, 0x8d, 0x08, 0x8c, 0xc6, 0x54, 0xe9, 0x71, 0xd2, 0x7e, 0xa4, 0xfe, |
| 0x58, 0x7f, 0xd3, 0xc7, |
| ]; |
| const AUTHORITY_HASH_SERVICE_VM: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0xb2, 0x69, 0x05, 0x48, 0x56, 0xb5, 0xfa, 0x55, 0x6f, 0xac, 0x56, 0xd9, 0x02, 0x35, 0x2b, |
| 0xaa, 0x4c, 0xba, 0x28, 0xdd, 0x82, 0x3a, 0x86, 0xf5, 0xd4, 0xc2, 0xf1, 0xf9, 0x35, 0x7d, |
| 0xe4, 0x43, 0x13, 0xbf, 0xfe, 0xd3, 0x36, 0xd8, 0x1c, 0x12, 0x78, 0x5c, 0x9c, 0x3e, 0xf6, |
| 0x66, 0xef, 0xab, 0x3d, 0x0f, 0x89, 0xa4, 0x6f, 0xc9, 0x72, 0xee, 0x73, 0x43, 0x02, 0x8a, |
| 0xef, 0xbc, 0x05, 0x98, |
| ]; |
| const HIDDEN_SERVICE_VM: [u8; diced_open_dice::HIDDEN_SIZE] = [ |
| 0x5b, 0x3f, 0xc9, 0x6b, 0xe3, 0x95, 0x59, 0x40, 0x5e, 0x64, 0xe5, 0x64, 0x3f, 0xfd, 0x21, |
| 0x09, 0x9d, 0xf3, 0xcd, 0xc7, 0xa4, 0x2a, 0xe2, 0x97, 0xdd, 0xe2, 0x4f, 0xb0, 0x7d, 0x7e, |
| 0xf5, 0x8e, 0xd6, 0x4d, 0x84, 0x25, 0x54, 0x41, 0x3f, 0x8f, 0x78, 0x64, 0x1a, 0x51, 0x27, |
| 0x9d, 0x55, 0x8a, 0xe9, 0x90, 0x35, 0xab, 0x39, 0x80, 0x4b, 0x94, 0x40, 0x84, 0xa2, 0xfd, |
| 0x73, 0xeb, 0x35, 0x7a, |
| ]; |
| |
| let comp_name_2 = CString::new("VM entry").expect("CString::new failed"); |
| let config_values_2 = diced_open_dice::DiceConfigValues { |
| component_name: Some(&comp_name_2), |
| component_version: Some(12), |
| resettable: true, |
| ..Default::default() |
| }; |
| let config_descriptor_2 = diced_open_dice::retry_bcc_format_config_descriptor(&config_values_2) |
| .expect("failed to format config descriptor"); |
| |
| let input_values_2 = diced_open_dice::InputValues::new( |
| CODE_HASH_SERVICE_VM, |
| diced_open_dice::Config::Descriptor(config_descriptor_2.as_slice()), |
| AUTHORITY_HASH_SERVICE_VM, |
| diced_open_dice::DiceMode::kDiceModeDebug, |
| HIDDEN_SERVICE_VM, |
| ); |
| |
| let (cdi_values_2, cert_2) = diced_open_dice::retry_dice_main_flow( |
| &cdi_values_1.cdi_attest, |
| &cdi_values_1.cdi_seal, |
| &input_values_2, |
| ) |
| .expect("Failed to run first main flow"); |
| |
| if dice_chain_len == 2 { |
| let cert_chain = Value::Array(vec![ |
| Value::Integer(EXPLICIT_KEY_DICE_CERT_CHAIN_VERSION.into()), |
| Value::Bytes(root_pub_cose_key_bstr.clone()), |
| Value::from_slice(&cert_1).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_2).expect("failed to deserialize the certificate into CBOR"), |
| ]); |
| let identity = Value::Array(vec![ |
| Value::Integer(IDENTITY_VERSION.into()), |
| Value::Bytes(cert_chain.to_vec()?), |
| ]); |
| let pvt_key_seed = |
| diced_open_dice::derive_cdi_private_key_seed(&cdi_values_2.cdi_attest).unwrap(); |
| let (_, pvt_key) = diced_open_dice::keypair_from_seed(pvt_key_seed.as_array()) |
| .expect("failed to create key pair from seed."); |
| let pvt_key: [u8; CURVE25519_PRIV_KEY_LEN] = |
| pvt_key.as_array()[0..CURVE25519_PRIV_KEY_LEN].try_into().map_err(|e| { |
| ag_err!(InternalError, "error in constructing the private signing key {:?}", e) |
| })?; |
| return Ok((EcSignKey::Ed25519(pvt_key), identity.to_vec()?)); |
| } |
| |
| const CODE_HASH_PAYLOAD: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0x08, 0x78, 0xc2, 0x5b, 0xe7, 0xea, 0x3d, 0x62, 0x70, 0x22, 0xd9, 0x1c, 0x4f, 0x3c, 0x2e, |
| 0x2f, 0x0f, 0x97, 0xa4, 0x6f, 0x6d, 0xd5, 0xe6, 0x4a, 0x6d, 0xbe, 0x34, 0x2e, 0x56, 0x04, |
| 0xaf, 0xef, 0x74, 0x3f, 0xec, 0xb8, 0x44, 0x11, 0xf4, 0x2f, 0x05, 0xb2, 0x06, 0xa3, 0x0e, |
| 0x75, 0xb7, 0x40, 0x9a, 0x4c, 0x58, 0xab, 0x96, 0xe7, 0x07, 0x97, 0x07, 0x86, 0x5c, 0xa1, |
| 0x42, 0x12, 0xf0, 0x34, |
| ]; |
| const AUTHORITY_HASH_PAYLOAD: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0xc7, 0x97, 0x5b, 0xa9, 0x9e, 0xbf, 0x0b, 0xeb, 0xe7, 0x7f, 0x69, 0x8f, 0x8e, 0xcf, 0x04, |
| 0x7d, 0x2c, 0x0f, 0x4d, 0xbe, 0xcb, 0xf5, 0xf1, 0x4c, 0x1d, 0x1c, 0xb7, 0x44, 0xdf, 0xf8, |
| 0x40, 0x90, 0x09, 0x65, 0xab, 0x01, 0x34, 0x3e, 0xc2, 0xc4, 0xf7, 0xa2, 0x3a, 0x5c, 0x4e, |
| 0x76, 0x4f, 0x42, 0xa8, 0x6c, 0xc9, 0xf1, 0x7b, 0x12, 0x80, 0xa4, 0xef, 0xa2, 0x4d, 0x72, |
| 0xa1, 0x21, 0xe2, 0x47, |
| ]; |
| |
| let comp_name_3 = CString::new("Payload").expect("CString::new failed"); |
| let config_values_3 = diced_open_dice::DiceConfigValues { |
| component_name: Some(&comp_name_3), |
| component_version: Some(12), |
| resettable: true, |
| ..Default::default() |
| }; |
| let config_descriptor_3 = diced_open_dice::retry_bcc_format_config_descriptor(&config_values_3) |
| .expect("failed to format config descriptor"); |
| |
| let input_values_3 = diced_open_dice::InputValues::new( |
| CODE_HASH_PAYLOAD, |
| diced_open_dice::Config::Descriptor(config_descriptor_3.as_slice()), |
| AUTHORITY_HASH_PAYLOAD, |
| diced_open_dice::DiceMode::kDiceModeDebug, |
| [0u8; diced_open_dice::HIDDEN_SIZE], |
| ); |
| |
| let (cdi_values_3, cert_3) = diced_open_dice::retry_dice_main_flow( |
| &cdi_values_2.cdi_attest, |
| &cdi_values_2.cdi_seal, |
| &input_values_3, |
| ) |
| .expect("Failed to run first main flow"); |
| |
| if dice_chain_len == 3 { |
| let cert_chain = Value::Array(vec![ |
| Value::Integer(EXPLICIT_KEY_DICE_CERT_CHAIN_VERSION.into()), |
| Value::Bytes(root_pub_cose_key_bstr.clone()), |
| Value::from_slice(&cert_1).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_2).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_3).expect("failed to deserialize the certificate into CBOR"), |
| ]); |
| let identity = Value::Array(vec![ |
| Value::Integer(IDENTITY_VERSION.into()), |
| Value::Bytes(cert_chain.to_vec()?), |
| ]); |
| let pvt_key_seed = |
| diced_open_dice::derive_cdi_private_key_seed(&cdi_values_3.cdi_attest).unwrap(); |
| let (_, pvt_key) = diced_open_dice::keypair_from_seed(pvt_key_seed.as_array()) |
| .expect("failed to create key pair from seed."); |
| let pvt_key: [u8; CURVE25519_PRIV_KEY_LEN] = |
| pvt_key.as_array()[0..CURVE25519_PRIV_KEY_LEN].try_into().map_err(|e| { |
| ag_err!(InternalError, "error in constructing the private signing key {:?}", e) |
| })?; |
| return Ok((EcSignKey::Ed25519(pvt_key), identity.to_vec()?)); |
| } |
| |
| const CODE_HASH_APK1: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0x41, 0x92, 0x0d, 0xd0, 0xf5, 0x60, 0xe3, 0x69, 0x26, 0x7f, 0xb8, 0xbc, 0x12, 0x3a, 0xd1, |
| 0x95, 0x1d, 0xb8, 0x9a, 0x9c, 0x3a, 0x3f, 0x01, 0xbf, 0xa8, 0xd9, 0x6d, 0xe9, 0x90, 0x30, |
| 0x1d, 0x0b, 0xaf, 0xef, 0x74, 0x3f, 0xec, 0xb8, 0x44, 0x11, 0xf4, 0x2f, 0x05, 0xb2, 0x06, |
| 0xa3, 0x0e, 0x75, 0xb7, 0x40, 0x9a, 0x4c, 0x58, 0xab, 0x96, 0xe7, 0x07, 0x97, 0x07, 0x86, |
| 0x5c, 0xa1, 0x42, 0x12, |
| ]; |
| const AUTHORITY_HASH_APK1: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0xe3, 0xd9, 0x1c, 0xf5, 0x6f, 0xee, 0x73, 0x40, 0x3d, 0x95, 0x59, 0x67, 0xea, 0x5d, 0x01, |
| 0xfd, 0x25, 0x9d, 0x5c, 0x88, 0x94, 0x3a, 0xc6, 0xd7, 0xa9, 0xdc, 0x4c, 0x60, 0x81, 0xbe, |
| 0x2b, 0x74, 0x40, 0x90, 0x09, 0x65, 0xab, 0x01, 0x34, 0x3e, 0xc2, 0xc4, 0xf7, 0xa2, 0x3a, |
| 0x5c, 0x4e, 0x76, 0x4f, 0x42, 0xa8, 0x6c, 0xc9, 0xf1, 0x7b, 0x12, 0x80, 0xa4, 0xef, 0xa2, |
| 0x4d, 0x72, 0xa1, 0x21, |
| ]; |
| |
| let comp_name_4 = CString::new("APK1").expect("CString::new failed"); |
| let config_values_4 = diced_open_dice::DiceConfigValues { |
| component_name: Some(&comp_name_4), |
| component_version: Some(12), |
| resettable: true, |
| ..Default::default() |
| }; |
| let config_descriptor_4 = diced_open_dice::retry_bcc_format_config_descriptor(&config_values_4) |
| .expect("failed to format config descriptor"); |
| |
| let input_values_4 = diced_open_dice::InputValues::new( |
| CODE_HASH_APK1, |
| diced_open_dice::Config::Descriptor(config_descriptor_4.as_slice()), |
| AUTHORITY_HASH_APK1, |
| diced_open_dice::DiceMode::kDiceModeDebug, |
| [0u8; diced_open_dice::HIDDEN_SIZE], |
| ); |
| |
| let (cdi_values_4, cert_4) = diced_open_dice::retry_dice_main_flow( |
| &cdi_values_3.cdi_attest, |
| &cdi_values_3.cdi_seal, |
| &input_values_4, |
| ) |
| .expect("Failed to run first main flow"); |
| |
| if dice_chain_len == 4 { |
| let cert_chain = Value::Array(vec![ |
| Value::Integer(EXPLICIT_KEY_DICE_CERT_CHAIN_VERSION.into()), |
| Value::Bytes(root_pub_cose_key_bstr.clone()), |
| Value::from_slice(&cert_1).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_2).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_3).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_4).expect("failed to deserialize the certificate into CBOR"), |
| ]); |
| let identity = Value::Array(vec![ |
| Value::Integer(IDENTITY_VERSION.into()), |
| Value::Bytes(cert_chain.to_vec()?), |
| ]); |
| let pvt_key_seed = |
| diced_open_dice::derive_cdi_private_key_seed(&cdi_values_4.cdi_attest).unwrap(); |
| let (_, pvt_key) = diced_open_dice::keypair_from_seed(pvt_key_seed.as_array()) |
| .expect("failed to create key pair from seed."); |
| let pvt_key: [u8; CURVE25519_PRIV_KEY_LEN] = |
| pvt_key.as_array()[0..CURVE25519_PRIV_KEY_LEN].try_into().map_err(|e| { |
| ag_err!(InternalError, "error in constructing the private signing key {:?}", e) |
| })?; |
| return Ok((EcSignKey::Ed25519(pvt_key), identity.to_vec()?)); |
| } |
| |
| const CODE_HASH_APEX1: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0x52, 0x93, 0x2b, 0xb0, 0x8d, 0xec, 0xdf, 0x54, 0x1f, 0x5c, 0x10, 0x9d, 0x17, 0xce, 0x7f, |
| 0xac, 0xb0, 0x2b, 0xe2, 0x99, 0x05, 0x7d, 0xa3, 0x9b, 0xa6, 0x3e, 0xf9, 0x99, 0xa2, 0xea, |
| 0xd4, 0xd9, 0x1d, 0x0b, 0xaf, 0xef, 0x74, 0x3f, 0xec, 0xb8, 0x44, 0x11, 0xf4, 0x2f, 0x05, |
| 0xb2, 0x06, 0xa3, 0x0e, 0x75, 0xb7, 0x40, 0x9a, 0x4c, 0x58, 0xab, 0x96, 0xe7, 0x07, 0x97, |
| 0x07, 0x86, 0x5c, 0xa1, |
| ]; |
| const AUTHORITY_HASH_APEX1: [u8; diced_open_dice::HASH_SIZE] = [ |
| 0xd1, 0xfc, 0x3d, 0x5f, 0xa0, 0x5f, 0x02, 0xd0, 0x83, 0x9b, 0x0e, 0x32, 0xc2, 0x27, 0x09, |
| 0x12, 0xcc, 0xfc, 0x42, 0xf6, 0x0d, 0xf4, 0x7d, 0xc8, 0x80, 0x1a, 0x64, 0x25, 0xa7, 0xfa, |
| 0x4a, 0x37, 0x2b, 0x74, 0x40, 0x90, 0x09, 0x65, 0xab, 0x01, 0x34, 0x3e, 0xc2, 0xc4, 0xf7, |
| 0xa2, 0x3a, 0x5c, 0x4e, 0x76, 0x4f, 0x42, 0xa8, 0x6c, 0xc9, 0xf1, 0x7b, 0x12, 0x80, 0xa4, |
| 0xef, 0xa2, 0x4d, 0x72, |
| ]; |
| |
| let comp_name_5 = CString::new("APEX1").expect("CString::new failed"); |
| let config_values_5 = diced_open_dice::DiceConfigValues { |
| component_name: Some(&comp_name_5), |
| component_version: Some(12), |
| resettable: true, |
| ..Default::default() |
| }; |
| let config_descriptor_5 = diced_open_dice::retry_bcc_format_config_descriptor(&config_values_5) |
| .expect("failed to format config descriptor"); |
| |
| let input_values_5 = diced_open_dice::InputValues::new( |
| CODE_HASH_APEX1, |
| diced_open_dice::Config::Descriptor(config_descriptor_5.as_slice()), |
| AUTHORITY_HASH_APEX1, |
| diced_open_dice::DiceMode::kDiceModeDebug, |
| [0u8; diced_open_dice::HIDDEN_SIZE], |
| ); |
| |
| let (cdi_values_5, cert_5) = diced_open_dice::retry_dice_main_flow( |
| &cdi_values_4.cdi_attest, |
| &cdi_values_4.cdi_seal, |
| &input_values_5, |
| ) |
| .expect("Failed to run first main flow"); |
| |
| if dice_chain_len == 5 { |
| let cert_chain = Value::Array(vec![ |
| Value::Integer(EXPLICIT_KEY_DICE_CERT_CHAIN_VERSION.into()), |
| Value::Bytes(root_pub_cose_key_bstr.clone()), |
| Value::from_slice(&cert_1).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_2).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_3).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_4).expect("failed to deserialize the certificate into CBOR"), |
| Value::from_slice(&cert_5).expect("failed to deserialize the certificate into CBOR"), |
| ]); |
| let identity = Value::Array(vec![ |
| Value::Integer(IDENTITY_VERSION.into()), |
| Value::Bytes(cert_chain.to_vec()?), |
| ]); |
| let pvt_key_seed = |
| diced_open_dice::derive_cdi_private_key_seed(&cdi_values_5.cdi_attest).unwrap(); |
| let (_, pvt_key) = diced_open_dice::keypair_from_seed(pvt_key_seed.as_array()) |
| .expect("failed to create key pair from seed."); |
| let pvt_key: [u8; CURVE25519_PRIV_KEY_LEN] = |
| pvt_key.as_array()[0..CURVE25519_PRIV_KEY_LEN].try_into().map_err(|e| { |
| ag_err!(InternalError, "error in constructing the private signing key {:?}", e) |
| })?; |
| return Ok((EcSignKey::Ed25519(pvt_key), identity.to_vec()?)); |
| } |
| Err(ag_err!(InternalError, "this method supports the maximum length of 5 for a DICE chain")) |
| } |
| |
| /// Add a smoke test for `get_identity` in the `Device` trait, to ensure that the returned Identity |
| /// passes a set of validation. |
| pub fn test_get_identity<D: Device, E: EcDsa>(ag_device: &D, ecdsa: &E) { |
| let (_, identity) = ag_device.get_identity().unwrap(); |
| identity.validate(ecdsa).unwrap(); |
| } |
| |
| /// Test validation of a sample BCC identity. |
| pub fn test_example_identity_validate<E: EcDsa>(ecdsa: &E) { |
| let mut hex_data = |
| std::str::from_utf8(include_bytes!("../testdata/sample_identity.hex")).unwrap().to_string(); |
| hex_data.retain(|c| !c.is_whitespace()); |
| let data = hex::decode(hex_data).unwrap(); |
| let identity = Identity::from_slice(&data).expect("identity data did not decode"); |
| identity.validate(ecdsa).expect("identity did not validate"); |
| } |
