feat(be): sign a session to the II frontend at sign-in

Cargo.toml

@@ -49,7 +49,7 @@ rsa = "0.9.10"
 minicbor = "1.0.0"
 
 # DNSSEC verifier deps (PR 1b on docs/ongoing/email-recovery.md §7)
-p256 = { version = "0.13", default-features = false, features = ["ecdsa", "sha256"] }
+p256 = { version = "0.13", default-features = false, features = ["ecdsa", "sha256", "pkcs8"] }
 ed25519-dalek = { version = "2.2", default-features = false }
 
 # Certification

src/canister_tests/Cargo.toml

@@ -8,6 +8,8 @@ base64.workspace = true
 flate2 = "1.0"
 hex.workspace = true
 lazy_static.workspace = true
+# Signs the browser-key proof `prepare_account_session` requires.
+p256.workspace = true
 regex.workspace = true
 serde.workspace = true
 serde_cbor.workspace = true

src/canister_tests/src/api/internet_identity/api_v2.rs

@@ -746,3 +746,29 @@ pub fn get_account_delegation_with_read_only(
     )
     .map(|(x,)| x)
 }
+
+pub fn prepare_account_session(
+    env: &PocketIc,
+    canister_id: CanisterId,
+    sender: Principal,
+    request: PrepareAccountSessionRequest,
+) -> Result<Result<PrepareAccountSessionResponse, AccountSessionError>, RejectResponse> {
+    call_candid_as(
+        env,
+        canister_id,
+        RawEffectivePrincipal::None,
+        sender,
+        "prepare_account_session",
+        (request,),
+    )
+    .map(|(x,)| x)
+}
+
+pub fn get_account_session(
+    env: &PocketIc,
+    canister_id: CanisterId,
+    sender: Principal,
+    request: GetAccountSessionRequest,
+) -> Result<Result<GetAccountSessionResponse, AccountSessionError>, RejectResponse> {
+    query_candid_as(env, canister_id, sender, "get_account_session", (request,)).map(|(x,)| x)
+}

src/canister_tests/src/framework.rs

@@ -375,6 +375,70 @@ pub fn restore_compressed_stable_memory(env: &PocketIc, canister_id: CanisterId,
     env.set_stable_memory(canister_id, buffer, BlobCompression::Gzip);
 }
 
+/// A browser key of the kind `prepare_account_session` demands a proof from.
+///
+/// The DER encoding and the domain prefix have to match what the canister verifies,
+/// so both are spelled out here rather than derived.
+pub struct BrowserKey {
+    signing_key: p256::ecdsa::SigningKey,
+}
+
+/// The SPKI header WebCrypto emits for an `ECDSA` P-256 public key, ahead of the 65-byte
+/// uncompressed point.
+const P256_SPKI_HEADER: [u8; 26] = [
+    0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a,
+    0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00,
+];
+
+const BROWSER_KEY_SIGNATURE_DOMAIN: &[u8] = b"ii-session-browser-key";
+const SUCCESSOR_KEY_SIGNATURE_DOMAIN: &[u8] = b"ii-session-browser-successor";
+
+impl BrowserKey {
+    pub fn new(seed: u8) -> Self {
+        Self {
+            signing_key: p256::ecdsa::SigningKey::from_bytes(&[seed; 32].into())
+                .expect("failed to build a browser key"),
+        }
+    }
+
+    /// The key a browser rotates to after `self`, so a test can walk the chain.
+    pub fn successor(&self) -> Self {
+        let mut seed = [0u8; 32];
+        seed.copy_from_slice(&self.signing_key.to_bytes());
+        seed[0] = seed[0].wrapping_add(1);
+        Self {
+            signing_key: p256::ecdsa::SigningKey::from_bytes(&seed.into())
+                .expect("failed to build a browser key"),
+        }
+    }
+
+    pub fn public_key(&self) -> PublicKey {
+        let point = p256::ecdsa::VerifyingKey::from(&self.signing_key).to_encoded_point(false);
+        let mut der = P256_SPKI_HEADER.to_vec();
+        der.extend_from_slice(point.as_bytes());
+        ByteBuf::from(der)
+    }
+
+    pub fn sign(&self, session_key: &SessionKey, next_browser_key: &PublicKey) -> ByteBuf {
+        self.sign_with(BROWSER_KEY_SIGNATURE_DOMAIN, session_key, next_browser_key)
+    }
+
+    /// The successor's own signature, proving the browser holds the key it announces.
+    pub fn sign_as_successor(&self, session_key: &SessionKey, device_key: &PublicKey) -> ByteBuf {
+        self.sign_with(SUCCESSOR_KEY_SIGNATURE_DOMAIN, session_key, device_key)
+    }
+
+    fn sign_with(&self, domain: &[u8], session_key: &SessionKey, other: &PublicKey) -> ByteBuf {
+        use p256::ecdsa::signature::Signer;
+
+        let mut message = domain.to_vec();
+        message.extend_from_slice(session_key);
+        message.extend_from_slice(other);
+        let signature: p256::ecdsa::Signature = self.signing_key.sign(&message);
+        ByteBuf::from(signature.to_bytes().to_vec())
+    }
+}
+
 pub const PUBKEY_1: &str = "test";
 pub const PUBKEY_2: &str = "some other key";
 pub const RECOVERY_PUBKEY_1: &str = "recovery 1";

src/frontend/src/lib/generated/internet_identity_idl.js

@@ -386,6 +386,25 @@ export const idlFactory = ({ IDL }) => {
     'InternalCanisterError' : IDL.Text,
     'Unauthorized' : IDL.Principal,
   });
+  const GetAccountSessionRequest = IDL.Record({
+    'session_id' : IDL.Nat64,
+    'session_key' : SessionKey,
+    'origin' : FrontendHostname,
+    'account_number' : IDL.Opt(AccountNumber),
+    'expiration' : Timestamp,
+    'identity_number' : UserNumber,
+  });
+  const GetAccountSessionResponse = IDL.Record({
+    'signed_delegation' : SignedDelegation,
+  });
+  const AccountSessionError = IDL.Variant({
+    'InternalCanisterError' : IDL.Text,
+    'Unauthorized' : IDL.Principal,
+    'NoSuchSession' : IDL.Null,
+    'NoSuchAccount' : IDL.Null,
+    'InvalidBrowserKey' : IDL.Null,
+    'StaleBrowserKey' : IDL.Null,
+  });
   const GetAccountsError = IDL.Variant({
     'InternalCanisterError' : IDL.Text,
     'Unauthorized' : IDL.Principal,
@@ -559,6 +578,44 @@ export const idlFactory = ({ IDL }) => {
     'address' : IDL.Text,
     'last_used' : IDL.Opt(Timestamp),
   });
+  const OperatingSystem = IDL.Variant({
+    'Ios' : IDL.Null,
+    'Linux' : IDL.Null,
+    'Android' : IDL.Null,
+    'Macos' : IDL.Null,
+    'ChromeOs' : IDL.Null,
+    'Windows' : IDL.Null,
+    'Other' : IDL.Text,
+    'Ipados' : IDL.Null,
+  });
+  const FormFactor = IDL.Variant({
+    'Unknown' : IDL.Null,
+    'Tablet' : IDL.Null,
+    'Desktop' : IDL.Null,
+    'Mobile' : IDL.Null,
+  });
+  const BrowserBrand = IDL.Variant({
+    'Edge' : IDL.Null,
+    'Firefox' : IDL.Null,
+    'Safari' : IDL.Null,
+    'SamsungInternet' : IDL.Null,
+    'Opera' : IDL.Null,
+    'Other' : IDL.Text,
+    'Chrome' : IDL.Null,
+  });
+  const BrowserDescription = IDL.Record({
+    'os' : OperatingSystem,
+    'model' : IDL.Opt(IDL.Text),
+    'form_factor' : FormFactor,
+    'brand' : BrowserBrand,
+  });
+  const BrowserInfo = IDL.Record({
+    'id' : IDL.Nat32,
+    'session_count' : IDL.Nat32,
+    'description' : BrowserDescription,
+    'created_at' : Timestamp,
+    'last_used' : Timestamp,
+  });
   const McpConfig = IDL.Record({
     'url' : IDL.Opt(IDL.Text),
     'enabled' : IDL.Bool,
@@ -575,6 +632,7 @@ export const idlFactory = ({ IDL }) => {
     'name' : IDL.Opt(IDL.Text),
     'email_recovery' : IDL.Opt(IDL.Vec(EmailRecoveryCredential)),
     'created_at' : IDL.Opt(Timestamp),
+    'browsers' : IDL.Opt(IDL.Vec(BrowserInfo)),
     'mcp_config' : IDL.Opt(McpConfig),
     'authn_method_registration' : IDL.Opt(AuthnMethodRegistrationInfo),
     'openid_credentials' : IDL.Opt(IDL.Vec(OpenIdCredential)),
@@ -679,6 +737,27 @@ export const idlFactory = ({ IDL }) => {
     'user_key' : UserKey,
     'expiration' : Timestamp,
   });
+  const PrepareAccountSessionRequest = IDL.Record({
+    'permissions' : IDL.Opt(Permissions),
+    'max_idle' : IDL.Opt(IDL.Nat64),
+    'current_browser_key' : PublicKey,
+    'session_key' : SessionKey,
+    'valid_for' : IDL.Opt(IDL.Nat64),
+    'origin' : FrontendHostname,
+    'current_browser_key_signature' : IDL.Vec(IDL.Nat8),
+    'browser_description' : BrowserDescription,
+    'account_number' : IDL.Opt(AccountNumber),
+    'identity_number' : UserNumber,
+    'next_browser_key' : PublicKey,
+    'next_browser_key_signature' : IDL.Vec(IDL.Nat8),
+  });
+  const PrepareAccountSessionResponse = IDL.Record({
+    'user_key' : PublicKey,
+    'session_id' : IDL.Nat64,
+    'browser_id' : IDL.Nat32,
+    'expiration' : Timestamp,
+    'account_principal' : IDL.Principal,
+  });
   const PrepareAttributeRequest = IDL.Record({
     'origin' : FrontendHostname,
     'attribute_keys' : IDL.Vec(IDL.Text),
@@ -1032,6 +1111,16 @@ export const idlFactory = ({ IDL }) => {
         ],
         ['query'],
       ),
+    'get_account_session' : IDL.Func(
+        [GetAccountSessionRequest],
+        [
+          IDL.Variant({
+            'Ok' : GetAccountSessionResponse,
+            'Err' : AccountSessionError,
+          }),
+        ],
+        ['query'],
+      ),
     'get_accounts' : IDL.Func(
         [UserNumber, FrontendHostname],
         [
@@ -1288,6 +1377,16 @@ export const idlFactory = ({ IDL }) => {
         ],
         [],
       ),
+    'prepare_account_session' : IDL.Func(
+        [PrepareAccountSessionRequest],
+        [
+          IDL.Variant({
+            'Ok' : PrepareAccountSessionResponse,
+            'Err' : AccountSessionError,
+          }),
+        ],
+        [],
+      ),
     'prepare_attributes' : IDL.Func(
         [PrepareAttributeRequest],
         [