Merge pull request #30 from lazor-kit/fix/signature-replay-discriminator

Fix/signature replay discriminator

Author: onspeedhp

program/src/auth/ed25519.rs

@@ -12,6 +12,7 @@ impl Authenticator for Ed25519Authenticator {
         authority_data: &mut [u8],
         _auth_payload: &[u8],
         _signed_payload: &[u8],
+        _discriminator: &[u8],
     ) -> Result<(), ProgramError> {
         if authority_data.len() < std::mem::size_of::<AuthorityAccountHeader>() + 32 {
             return Err(ProgramError::InvalidAccountData);

program/src/auth/secp256r1/mod.rs

@@ -36,6 +36,7 @@ impl Authenticator for Secp256r1Authenticator {
         auth_data: &mut [u8],
         auth_payload: &[u8],
         signed_payload: &[u8], // The message payload (e.g. compact instructions or args) that is signed
+        discriminator: &[u8],
     ) -> Result<(), ProgramError> {
         if auth_payload.len() < 12 {
             return Err(AuthError::InvalidAuthorityPayload.into());
@@ -94,8 +95,8 @@ impl Authenticator for Secp256r1Authenticator {
         #[cfg(target_os = "solana")]
         unsafe {
             let _res = pinocchio::syscalls::sol_sha256(
-                [signed_payload, &slot.to_le_bytes()].as_ptr() as *const u8,
-                2,
+                [discriminator, signed_payload, &slot.to_le_bytes()].as_ptr() as *const u8,
+                3,
                 hasher.as_mut_ptr(),
             );
         }

program/src/auth/traits.rs

@@ -16,5 +16,6 @@ pub trait Authenticator {
         authority_data: &mut [u8],
         auth_payload: &[u8],
         signed_payload: &[u8],
+        discriminator: &[u8],
     ) -> Result<(), ProgramError>;
 }

program/src/processor/create_session.rs

@@ -157,20 +157,25 @@ pub fn process(
     // For Secp256r1, we need to distinguish args from auth payload.
     // The instruction format is [discriminator][args][payload].
     // `instruction_data` here is [args][payload].
+    let data_payload = &instruction_data[..payload_offset];
 
     match auth_header.authority_type {
         0 => {
-            Ed25519Authenticator.authenticate(accounts, auth_data, &[], &[])?;
+            Ed25519Authenticator.authenticate(accounts, auth_data, &[], &[], &[5])?;
         },
         1 => {
-            if !authorizer_pda.is_writable() {
-                return Err(ProgramError::InvalidAccountData);
-            }
+            // Secp256r1 (WebAuthn) - Must be Writable
+            // Check removed: conditional writable check inside match
+            // Verified above.
+
+            // Secp256r1: Full authentication with payload
+            // signed_payload is CreateSessionArgs (contains session_key + expires_at)
             Secp256r1Authenticator.authenticate(
                 accounts,
                 auth_data,
                 authority_payload,
-                &instruction_data[..payload_offset], // Sign over args part?
+                data_payload,
+                &[5],
             )?;
         },
         _ => return Err(AuthError::InvalidAuthenticationKind.into()),

program/src/processor/execute.rs

@@ -102,16 +102,23 @@ pub fn process(
             }
             match authority_header.authority_type {
                 0 => {
-                    // Ed25519: Verify signer
-                    Ed25519Authenticator.authenticate(accounts, authority_data, &[], &[])?;
+                    // Ed25519: Verify signer (authority_payload ignored)
+                    Ed25519Authenticator.authenticate(accounts, authority_data, &[], &[], &[4])?;
                 },
                 1 => {
-                    // Secp256r1: Full authentication
+                    // Secp256r1 (WebAuthn)
+                    // signed_payload is compact_instructions bytes for Execute
+                    // The instruction format is [discriminator][compact_instructions_bytes][payload]
+                    // instruction_data is [compact_instructions_bytes][payload]
+                    let data_payload = &instruction_data[..compact_len];
+                    let authority_payload = &instruction_data[compact_len..];
+
                     Secp256r1Authenticator.authenticate(
                         accounts,
                         authority_data,
                         authority_payload,
-                        &compact_bytes,
+                        data_payload,
+                        &[4],
                     )?;
                 },
                 _ => return Err(AuthError::InvalidAuthenticationKind.into()),

program/src/processor/manage_authority.rs

@@ -185,7 +185,7 @@ pub fn process_add_authority(
     match admin_header.authority_type {
         0 => {
             // Ed25519: Verify signer (authority_payload ignored)
-            Ed25519Authenticator.authenticate(accounts, admin_data, &[], &[])?;
+            Ed25519Authenticator.authenticate(accounts, admin_data, &[], &[], &[1])?;
         },
         1 => {
             // Secp256r1 (WebAuthn) - Must be Writable
@@ -198,6 +198,7 @@ pub fn process_add_authority(
                 admin_data,
                 authority_payload,
                 data_payload,
+                &[1],
             )?;
         },
         _ => return Err(AuthError::InvalidAuthenticationKind.into()),
@@ -345,14 +346,15 @@ pub fn process_remove_authority(
     // Authentication
     match admin_header.authority_type {
         0 => {
-            Ed25519Authenticator.authenticate(accounts, admin_data, &[], &[])?;
+            Ed25519Authenticator.authenticate(accounts, admin_data, &[], &[], &[2])?;
         },
         1 => {
             Secp256r1Authenticator.authenticate(
                 accounts,
                 admin_data,
                 authority_payload,
                 data_payload,
+                &[2],
             )?;
         },
         _ => return Err(AuthError::InvalidAuthenticationKind.into()),

program/src/processor/transfer_ownership.rs

@@ -151,14 +151,21 @@ pub fn process(
         // Authenticate Current Owner
         match auth.authority_type {
             0 => {
-                Ed25519Authenticator.authenticate(accounts, data, &[], &[])?;
+                // Ed25519: Verify signer (authority_payload ignored)
+                Ed25519Authenticator.authenticate(accounts, data, &[], &[], &[3])?;
             },
             1 => {
+                // Secp256r1 (WebAuthn) - Must be Writable
+                if !current_owner.is_writable() {
+                    return Err(ProgramError::InvalidAccountData);
+                }
+                // Secp256r1: Full authentication with payload
                 Secp256r1Authenticator.authenticate(
                     accounts,
                     data,
                     authority_payload,
                     data_payload,
+                    &[3],
                 )?;
             },
             _ => return Err(AuthError::InvalidAuthenticationKind.into()),