test: Add signature verification for II attributes (dfinity#3611)

<!-- Make sure you talk to us before submitting changes. See
CONTRIBUTING.md. -->

# Motivation

Stronger testing in Rust for the upcoming certified attributes feature.

# Changes

No production code changes (modulo derived traits).

# Tests

* Added signature verification test infrastructure for Internet Identity
attributes with proper delegation and attribute signature validation

Author: aterga

src/canister_tests/src/framework.rs

@@ -7,6 +7,7 @@ use ic_representation_independent_hash::Value;
 use identity_jose::jws::Decoder;
 use internet_identity_interface::archive::types::*;
 use internet_identity_interface::http_gateway::{HeaderField, HttpRequest};
+use internet_identity_interface::internet_identity::types::attributes::CertifiedAttribute;
 use internet_identity_interface::internet_identity::types::vc_mvp::SignedIdAlias;
 use internet_identity_interface::internet_identity::types::*;
 use lazy_static::lazy_static;
@@ -646,6 +647,40 @@ pub fn verify_delegation(
     .expect("delegation signature invalid");
 }
 
+pub fn verify_attribute(
+    env: &PocketIc,
+    user_key: UserKey,
+    certified_attribute: &CertifiedAttribute,
+    expiration: u64,
+    root_key: &[u8],
+) {
+    const DOMAIN_SEPARATOR: &[u8] = b"ii-request-attribute";
+
+    // The signed message is a signature domain separator
+    // followed by the representation independent hash of a map with entries
+    // expiration, attribute-key/attribute-value.
+    let key_value_pairs = vec![
+        ("expiration".to_string(), Value::Number(expiration)),
+        (
+            certified_attribute.key.clone(),
+            Value::Bytes(certified_attribute.value.clone()),
+        ),
+    ];
+    let mut msg: Vec<u8> = Vec::from([(DOMAIN_SEPARATOR.len() as u8)]);
+    msg.extend_from_slice(DOMAIN_SEPARATOR);
+    msg.extend_from_slice(
+        &ic_representation_independent_hash::representation_independent_hash(&key_value_pairs),
+    );
+
+    env.verify_canister_signature(
+        msg,
+        certified_attribute.signature.clone(),
+        user_key.into_vec(),
+        root_key.to_vec(),
+    )
+    .expect("attribute signature invalid");
+}
+
 pub fn verify_id_alias_credential_via_env(
     env: &PocketIc,
     canister_sig_pk_der: CanisterSigPublicKeyDer,

src/internet_identity/tests/integration/attributes.rs

@@ -1,14 +1,68 @@
 //! Tests related to prepare_attributes and get_attributes II canister calls.
 
+use candid::Principal;
 use canister_tests::api::internet_identity as api;
 use canister_tests::framework::*;
+use ic_canister_sig_creation::extract_raw_canister_sig_pk_from_der;
 use internet_identity_interface::internet_identity::types::attributes::{
     CertifiedAttribute, CertifiedAttributes, GetAttributesRequest, PrepareAttributeRequest,
 };
-use internet_identity_interface::internet_identity::types::OpenIdConfig;
+use internet_identity_interface::internet_identity::types::{
+    GetDelegationResponse, OpenIdConfig, SignedDelegation,
+};
+use pocket_ic::PocketIc;
 use pretty_assertions::assert_eq;
+use serde_bytes::ByteBuf;
 use std::time::Duration;
 
+fn verify_delegation_and_attribute_signatures(
+    env: &PocketIc,
+    session_public_key: ByteBuf,
+    user_key: ByteBuf,
+    ii_backend_canister_id: Principal,
+    signed_delegation: SignedDelegation,
+    attributes: Vec<CertifiedAttribute>,
+    attribute_expiration: u64,
+) {
+    let root_key = env.root_key().unwrap();
+
+    let now_timestamp_ns = env.get_time().as_nanos_since_unix_epoch();
+
+    assert_eq!(signed_delegation.delegation.pubkey, session_public_key);
+    assert!(
+        signed_delegation.delegation.expiration > now_timestamp_ns,
+        "Delegation has expired: {} <= {}",
+        signed_delegation.delegation.expiration,
+        now_timestamp_ns
+    );
+
+    assert_eq!(signed_delegation.delegation.targets, None);
+    assert!(attribute_expiration > now_timestamp_ns);
+
+    // Ensure that the user key is a canister signature (we rely on `user_key` being DER-encoded)
+    let canister_id_bytes = extract_raw_canister_sig_pk_from_der(&user_key).unwrap();
+
+    let canister_id = {
+        let canister_id_bytes_len = canister_id_bytes[0] as usize;
+        let bound = canister_id_bytes_len + 1;
+        Principal::from_slice(&canister_id_bytes[1..bound])
+    };
+
+    assert_eq!(canister_id, ii_backend_canister_id);
+
+    verify_delegation(env, user_key.clone(), &signed_delegation, &root_key);
+
+    for attribute in &attributes {
+        verify_attribute(
+            env,
+            user_key.clone(),
+            attribute,
+            attribute_expiration,
+            &root_key,
+        );
+    }
+}
+
 #[test]
 fn should_get_certified_attributes() {
     let env = env();
@@ -29,7 +83,7 @@ fn should_get_certified_attributes() {
         fedcm_uri: Some("https://accounts.google.com/gsi/fedcm.json".into()),
     }]);
 
-    let canister_id = install_ii_canister_with_arg_and_cycles(
+    let ii_backend_canister_id = install_ii_canister_with_arg_and_cycles(
         &env,
         II_WASM.clone(),
         Some(init_args),
@@ -39,29 +93,40 @@ fn should_get_certified_attributes() {
     // This also handles the fetch triggered by initialize()
     crate::openid::mock_google_certs_response(&env);
 
-    deploy_archive_via_ii(&env, canister_id);
+    deploy_archive_via_ii(&env, ii_backend_canister_id);
 
     // Create an identity with the required authn method
-    let user_number = crate::v2_api::authn_method_test_helpers::create_identity_with_authn_method(
-        &env,
-        canister_id,
-        &test_authn_method,
-    );
+    let identity_number =
+        crate::v2_api::authn_method_test_helpers::create_identity_with_authn_method(
+            &env,
+            ii_backend_canister_id,
+            &test_authn_method,
+        );
 
     // Sync time to the JWT iat
     let time_to_advance = Duration::from_millis(test_time) - Duration::from_nanos(time(&env));
     env.advance_time(time_to_advance);
 
     // Add OpenID credential
-    api::openid_credential_add(&env, canister_id, test_principal, user_number, &jwt, &salt)
-        .expect("failed to add openid credential")
-        .expect("openid_credential_add error");
+    api::openid_credential_add(
+        &env,
+        ii_backend_canister_id,
+        test_principal,
+        identity_number,
+        &jwt,
+        &salt,
+    )
+    .expect("failed to add openid credential")
+    .expect("openid_credential_add error");
 
     let origin = "https://some-dapp.com";
 
     // 1. Prepare attributes
+
+    env.advance_time(Duration::from_secs(15));
+
     let prepare_request = PrepareAttributeRequest {
-        identity_number: user_number,
+        identity_number,
         origin: origin.to_string(),
         account_number: None,
         attribute_keys: vec![
@@ -70,59 +135,110 @@ fn should_get_certified_attributes() {
         ],
     };
 
-    let prepare_response =
-        api::prepare_attributes(&env, canister_id, test_principal, prepare_request)
-            .expect("failed to call prepare_attributes")
-            .expect("prepare_attributes error");
+    let prepare_response = api::prepare_attributes(
+        &env,
+        ii_backend_canister_id,
+        test_principal,
+        prepare_request,
+    )
+    .expect("failed to call prepare_attributes")
+    .expect("prepare_attributes error");
 
     assert_eq!(prepare_response.attributes.len(), 2);
 
     // 2. Get attributes
+    env.advance_time(Duration::from_secs(5));
+
     let get_request = GetAttributesRequest {
-        identity_number: user_number,
+        identity_number,
         origin: origin.to_string(),
         account_number: None,
         issued_at_timestamp_ns: prepare_response.issued_at_timestamp_ns,
         attributes: prepare_response.attributes.clone(),
     };
 
-    let get_response = api::get_attributes(&env, canister_id, test_principal, get_request)
-        .expect("failed to call get_attributes")
-        .expect("get_attributes error");
+    let get_response =
+        api::get_attributes(&env, ii_backend_canister_id, test_principal, get_request)
+            .expect("failed to call get_attributes")
+            .expect("get_attributes error");
 
-    let mut actual_response = get_response;
-    actual_response.certified_attributes.sort();
+    let mut redacted_response = get_response.clone();
+    redacted_response.certified_attributes.sort();
 
     // Check the signatures (not a full verification step, just a smoke test)
-    for attribute in actual_response.certified_attributes.iter() {
+    for attribute in redacted_response.certified_attributes.iter() {
         assert!(attribute
             .signature
             .starts_with(&[217, 217, 247, 162, 107, 99, 101, 114]));
     }
 
     // Redact the signatures so we can compare the response
-    actual_response
+    redacted_response
         .certified_attributes
         .iter_mut()
         .for_each(|attr| attr.signature = vec![]);
 
     assert_eq!(
-        actual_response,
+        redacted_response,
         CertifiedAttributes {
             certified_attributes: vec![
                 CertifiedAttribute {
                     key: "openid:https://accounts.google.com:email".into(),
                     value: b"andri.schatz@dfinity.org".to_vec(),
-                    signature: vec![] // redacted
+                    signature: vec![], // redacted
                 },
                 CertifiedAttribute {
                     key: "openid:https://accounts.google.com:name".into(),
                     value: b"Andri Schatz".to_vec(),
-                    signature: vec![],
+                    signature: vec![], // redacted
                 },
             ],
             expires_at_timestamp_ns: prepare_response.issued_at_timestamp_ns
                 + Duration::from_secs(30 * 60).as_nanos() as u64,
         }
     );
+
+    // Verify the signatures; this relies on delegation verification for the same (origin, user).
+
+    let session_public_key = ByteBuf::from("session public key");
+
+    env.advance_time(Duration::from_secs(35));
+
+    let (canister_sig_key, expiration) = api::prepare_delegation(
+        &env,
+        ii_backend_canister_id,
+        test_principal,
+        identity_number,
+        origin,
+        &session_public_key,
+        None,
+    )
+    .unwrap();
+
+    env.advance_time(Duration::from_secs(5));
+
+    let signed_delegation = match api::get_delegation(
+        &env,
+        ii_backend_canister_id,
+        test_principal,
+        identity_number,
+        origin,
+        &session_public_key,
+        expiration,
+    )
+    .unwrap()
+    {
+        GetDelegationResponse::SignedDelegation(delegation) => delegation,
+        GetDelegationResponse::NoSuchDelegation => panic!("failed to get delegation"),
+    };
+
+    verify_delegation_and_attribute_signatures(
+        &env,
+        session_public_key,
+        canister_sig_key,
+        ii_backend_canister_id,
+        signed_delegation,
+        get_response.certified_attributes,
+        get_response.expires_at_timestamp_ns,
+    );
 }

src/internet_identity_interface/src/internet_identity/types/attributes.rs

@@ -402,14 +402,14 @@ impl TryFrom<GetAttributesRequest> for ValidatedGetAttributesRequest {
     }
 }
 
-#[derive(Debug, PartialEq, CandidType, Serialize, Deserialize, Eq, PartialOrd, Ord)]
+#[derive(Clone, Debug, PartialEq, CandidType, Serialize, Deserialize, Eq, PartialOrd, Ord)]
 pub struct CertifiedAttribute {
     pub key: String,
     pub value: Vec<u8>,
     pub signature: Vec<u8>,
 }
 
-#[derive(Debug, PartialEq, CandidType, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, CandidType, Serialize, Deserialize)]
 pub struct CertifiedAttributes {
     pub certified_attributes: Vec<CertifiedAttribute>,
     pub expires_at_timestamp_ns: Timestamp,