Harden key authorization attachment

Author: decofe

crates/tempo-common/src/keys/signer.rs

@@ -4,9 +4,12 @@
 //! resolves a network's key entry into a ready-to-use [`Signer`]
 //! (private key signer + signing mode + effective `from` address).
 
-use alloy::{primitives::Address, signers::local::PrivateKeySigner};
+use alloy::{
+    primitives::{Address, TxKind},
+    signers::local::PrivateKeySigner,
+};
 use mpp::client::tempo::signing::{KeychainVersion, TempoSigningMode};
-use tempo_primitives::transaction::SignedKeyAuthorization;
+use tempo_primitives::transaction::{Call, CallScope, SelectorRule, SignedKeyAuthorization};
 
 use crate::{
     error::{ConfigError, KeyError, TempoError},
@@ -78,6 +81,23 @@ impl Signer {
         })
     }
 
+    /// Returns a copy whose signing mode includes the stored key authorization,
+    /// after verifying that authorization is valid for this transaction.
+    ///
+    /// This prevents stale or unrelated local authorizations from being attached
+    /// to provisioning retries for a different chain, key, or scoped call set.
+    pub fn with_key_authorization_for_transaction(
+        &self,
+        chain_id: u64,
+        calls: &[Call],
+    ) -> Result<Option<Self>, TempoError> {
+        let Some(auth) = self.stored_key_authorization.as_deref() else {
+            return Ok(None);
+        };
+        validate_key_authorization_for_transaction(auth, self.signer.address(), chain_id, calls)?;
+        Ok(self.with_key_authorization())
+    }
+
     /// Whether this signer has a stored key authorization available for
     /// provisioning retries.
     #[must_use]
@@ -86,6 +106,94 @@ impl Signer {
     }
 }
 
+fn validate_key_authorization_for_transaction(
+    auth: &SignedKeyAuthorization,
+    signer_address: Address,
+    chain_id: u64,
+    calls: &[Call],
+) -> Result<(), TempoError> {
+    if auth.authorization.key_id != signer_address {
+        return Err(KeyError::SigningOperation {
+            operation: "key authorization validation",
+            reason: format!(
+                "authorization key {:#x} does not match signer {:#x}",
+                auth.authorization.key_id, signer_address
+            ),
+        }
+        .into());
+    }
+
+    if auth.authorization.chain_id != chain_id {
+        return Err(KeyError::SigningOperation {
+            operation: "key authorization validation",
+            reason: format!(
+                "authorization chain {} does not match transaction chain {}",
+                auth.authorization.chain_id, chain_id
+            ),
+        }
+        .into());
+    }
+
+    if let Some(expiry) = auth.authorization.expiry {
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+        if expiry.get() <= now {
+            return Err(KeyError::SigningOperation {
+                operation: "key authorization validation",
+                reason: "authorization is expired".to_string(),
+            }
+            .into());
+        }
+    }
+
+    let Some(scopes) = auth.authorization.allowed_calls.as_deref() else {
+        return Ok(());
+    };
+    if calls.is_empty() || !calls.iter().all(|call| call_matches_scopes(call, scopes)) {
+        return Err(KeyError::SigningOperation {
+            operation: "key authorization validation",
+            reason: "authorization scopes do not cover transaction calls".to_string(),
+        }
+        .into());
+    }
+
+    Ok(())
+}
+
+fn call_matches_scopes(call: &Call, scopes: &[CallScope]) -> bool {
+    let TxKind::Call(target) = call.to else {
+        return false;
+    };
+    scopes.iter().any(|scope| {
+        scope.target == target && call_matches_scope_rules(call, &scope.selector_rules)
+    })
+}
+
+fn call_matches_scope_rules(call: &Call, rules: &[SelectorRule]) -> bool {
+    if rules.is_empty() {
+        return true;
+    }
+    let Some(selector) = call.input.get(..4) else {
+        return false;
+    };
+    rules.iter().any(|rule| {
+        rule.selector == selector
+            && (rule.recipients.is_empty()
+                || first_abi_address_argument(call)
+                    .is_some_and(|recipient| rule.recipients.contains(&recipient)))
+    })
+}
+
+fn first_abi_address_argument(call: &Call) -> Option<Address> {
+    let arg = call.input.get(4..36)?;
+    if arg[..12].iter().any(|byte| *byte != 0) {
+        return None;
+    }
+    Some(Address::from_slice(&arg[12..]))
+}
+
 impl Keystore {
     /// Resolve the wallet signer for a network.
     ///
@@ -158,6 +266,9 @@ impl Keystore {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloy::primitives::{Bytes, U256};
+    use alloy::signers::SignerSync;
+    use tempo_primitives::transaction::{KeyAuthorization, PrimitiveSignature, SignatureType};
     use zeroize::Zeroizing;
 
     use crate::keys::KeyEntry;
@@ -292,6 +403,52 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_key_authorization_for_transaction_rejects_chain_mismatch() {
+        let signer = signer_with_auth(|auth| auth);
+
+        let result = signer
+            .with_key_authorization_for_transaction(4218, &[call_to(Address::repeat_byte(0x11))]);
+        assert!(result.is_err());
+        let err = result.err().unwrap().to_string();
+        assert!(err.contains("authorization chain 4217"));
+        assert!(err.contains("transaction chain 4218"));
+    }
+
+    #[test]
+    fn test_key_authorization_for_transaction_rejects_uncovered_scope() {
+        let allowed = Address::repeat_byte(0x11);
+        let denied = Address::repeat_byte(0x22);
+        let signer = signer_with_auth(|auth| {
+            auth.with_allowed_calls(vec![CallScope {
+                target: allowed,
+                selector_rules: vec![],
+            }])
+        });
+
+        let result = signer.with_key_authorization_for_transaction(4217, &[call_to(denied)]);
+        assert!(result.is_err());
+        let err = result.err().unwrap().to_string();
+        assert!(err.contains("authorization scopes do not cover transaction calls"));
+    }
+
+    #[test]
+    fn test_key_authorization_for_transaction_accepts_covered_scope() {
+        let allowed = Address::repeat_byte(0x11);
+        let signer = signer_with_auth(|auth| {
+            auth.with_allowed_calls(vec![CallScope {
+                target: allowed,
+                selector_rules: vec![],
+            }])
+        });
+
+        let provisioning = signer
+            .with_key_authorization_for_transaction(4217, &[call_to(allowed)])
+            .unwrap()
+            .expect("covered auth should attach");
+        assert!(provisioning.signing_mode.key_authorization().is_some());
+    }
+
     #[test]
     fn test_signer_direct_has_no_stored_auth() {
         let keys = Keystore::from_private_key(TEST_PRIVATE_KEY).unwrap();
@@ -300,6 +457,47 @@ mod tests {
         assert!(signer.with_key_authorization().is_none());
     }
 
+    fn signer_with_auth(update: impl FnOnce(KeyAuthorization) -> KeyAuthorization) -> Signer {
+        let wallet_signer = parse_private_key_signer(
+            "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d",
+        )
+        .unwrap();
+        let access_signer = parse_private_key_signer(TEST_PRIVATE_KEY).unwrap();
+        let auth = KeyAuthorization {
+            chain_id: 4217,
+            key_type: SignatureType::Secp256k1,
+            key_id: access_signer.address(),
+            expiry: std::num::NonZero::new(9_999_999_999),
+            limits: None,
+            allowed_calls: None,
+        };
+        let auth = update(auth);
+        let sig = wallet_signer
+            .sign_hash_sync(&auth.signature_hash())
+            .unwrap();
+
+        Signer {
+            signer: access_signer,
+            signing_mode: TempoSigningMode::Keychain {
+                wallet: wallet_signer.address(),
+                key_authorization: None,
+                version: KeychainVersion::V2,
+            },
+            from: wallet_signer.address(),
+            stored_key_authorization: Some(Box::new(
+                auth.into_signed(PrimitiveSignature::Secp256k1(sig)),
+            )),
+        }
+    }
+
+    fn call_to(to: Address) -> Call {
+        Call {
+            to: TxKind::Call(to),
+            value: U256::ZERO,
+            input: Bytes::from_static(&[0xaa, 0xbb, 0xcc, 0xdd]),
+        }
+    }
+
     #[test]
     fn test_signer_no_key_for_network() {
         let keys = Keystore::default();

crates/tempo-common/src/payment/session/tx.rs

@@ -138,14 +138,13 @@ pub async fn resolve_and_sign_tx_with_fee_payer(
     let gas_limit = match gas_result {
         Ok(gas) => gas,
         Err(original) if wallet.has_stored_key_authorization() => {
-            provisioning_signer =
-                wallet
-                    .with_key_authorization()
-                    .ok_or_else(|| KeyError::SigningOperation {
-                        operation: "key provisioning",
-                        reason: "stored key authorization could not be applied to signing mode"
-                            .to_string(),
-                    })?;
+            provisioning_signer = wallet
+                .with_key_authorization_for_transaction(chain_id, &calls)?
+                .ok_or_else(|| KeyError::SigningOperation {
+                    operation: "key provisioning",
+                    reason: "stored key authorization could not be applied to signing mode"
+                        .to_string(),
+                })?;
             effective_wallet = &provisioning_signer;
             key_auth = effective_wallet.signing_mode.key_authorization();
             let mut gas_request = TempoTransactionRequest {
@@ -240,14 +239,13 @@ pub async fn submit_tempo_tx(
     match provider.send_raw_transaction(&tx_bytes).await {
         Ok(pending) => Ok(format!("{:#x}", pending.tx_hash())),
         Err(original) if wallet.has_stored_key_authorization() => {
-            let provisioning_signer =
-                wallet
-                    .with_key_authorization()
-                    .ok_or_else(|| KeyError::SigningOperation {
-                        operation: "key provisioning",
-                        reason: "stored key authorization could not be applied to signing mode"
-                            .to_string(),
-                    })?;
+            let provisioning_signer = wallet
+                .with_key_authorization_for_transaction(chain_id, &calls)?
+                .ok_or_else(|| KeyError::SigningOperation {
+                    operation: "key provisioning",
+                    reason: "stored key authorization could not be applied to signing mode"
+                        .to_string(),
+                })?;
             let retry_bytes = resolve_and_sign_tx(
                 provider,
                 &provisioning_signer,