Add signature verification enhancements in KeeShare tests and core logic

Author: plyght

src/KeeShare.Tests/SignatureVerificationTests.cs

@@ -6,6 +6,23 @@ namespace KeeShare.Tests
 {
     public class SignatureVerificationTests
     {
+        /// <summary>
+        /// Helper to convert bytes to hex string (KeeShare format)
+        /// </summary>
+        private static string BytesToHex(byte[] bytes)
+        {
+            return BitConverter.ToString(bytes).Replace("-", "").ToLowerInvariant();
+        }
+
+        /// <summary>
+        /// Helper to format signature in KeeShare format: "rsa|<hex>"
+        /// </summary>
+        private static byte[] FormatKeeShareSignature(byte[] signature)
+        {
+            string hex = BytesToHex(signature);
+            return Encoding.UTF8.GetBytes($"rsa|{hex}");
+        }
+
         [Fact]
         public void VerifySignature_WithValidSignature_ReturnsTrue()
         {
@@ -15,12 +32,27 @@ public void VerifySignature_WithValidSignature_ReturnsTrue()
             byte[] testData = Encoding.UTF8.GetBytes("Test KDBX data content");
             byte[] hash = SHA256.HashData(testData);
             byte[] signature = rsa.SignHash(hash, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
-            string signatureBase64 = Convert.ToBase64String(signature);
-            byte[] signatureData = Encoding.UTF8.GetBytes(signatureBase64);
+            byte[] signatureData = FormatKeeShareSignature(signature);
             bool result = KeeShare.VerifySignatureCore(publicKeyCert, testData, signatureData);
             Assert.True(result, "Signature verification should succeed with valid signature");
         }
 
+        [Fact]
+        public void VerifySignature_WithValidSignatureWithoutPrefix_ReturnsTrue()
+        {
+            using var rsa = RSA.Create(2048);
+            var publicKeyBytes = rsa.ExportSubjectPublicKeyInfo();
+            var publicKeyCert = Convert.ToBase64String(publicKeyBytes);
+            byte[] testData = Encoding.UTF8.GetBytes("Test KDBX data content");
+            byte[] hash = SHA256.HashData(testData);
+            byte[] signature = rsa.SignHash(hash, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
+            // Hex without "rsa|" prefix should also work
+            string signatureHex = BytesToHex(signature);
+            byte[] signatureData = Encoding.UTF8.GetBytes(signatureHex);
+            bool result = KeeShare.VerifySignatureCore(publicKeyCert, testData, signatureData);
+            Assert.True(result, "Signature verification should succeed with hex signature without prefix");
+        }
+
         [Fact]
         public void VerifySignature_WithInvalidSignature_ReturnsFalse()
         {
@@ -30,8 +62,7 @@ public void VerifySignature_WithInvalidSignature_ReturnsFalse()
             byte[] testData = Encoding.UTF8.GetBytes("Test KDBX data content");
             byte[] invalidSignature = new byte[256];
             new Random().NextBytes(invalidSignature);
-            string signatureBase64 = Convert.ToBase64String(invalidSignature);
-            byte[] signatureData = Encoding.UTF8.GetBytes(signatureBase64);
+            byte[] signatureData = FormatKeeShareSignature(invalidSignature);
             bool result = KeeShare.VerifySignatureCore(publicKeyCert, testData, signatureData);
             Assert.False(result, "Signature verification should fail with invalid signature");
         }
@@ -45,8 +76,7 @@ public void VerifySignature_WithTamperedData_ReturnsFalse()
             byte[] originalData = Encoding.UTF8.GetBytes("Original KDBX data");
             byte[] hash = SHA256.HashData(originalData);
             byte[] signature = rsa.SignHash(hash, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
-            string signatureBase64 = Convert.ToBase64String(signature);
-            byte[] signatureData = Encoding.UTF8.GetBytes(signatureBase64);
+            byte[] signatureData = FormatKeeShareSignature(signature);
             byte[] tamperedData = Encoding.UTF8.GetBytes("Tampered KDBX data");
             bool result = KeeShare.VerifySignatureCore(publicKeyCert, tamperedData, signatureData);
             Assert.False(result, "Signature verification should fail when data is tampered");
@@ -62,8 +92,7 @@ public void VerifySignature_WithPemFormattedCertificate_ReturnsTrue()
             byte[] testData = Encoding.UTF8.GetBytes("Test KDBX data content");
             byte[] hash = SHA256.HashData(testData);
             byte[] signature = rsa.SignHash(hash, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
-            string signatureBase64 = Convert.ToBase64String(signature);
-            byte[] signatureData = Encoding.UTF8.GetBytes(signatureBase64);
+            byte[] signatureData = FormatKeeShareSignature(signature);
             bool result = KeeShare.VerifySignatureCore(publicKeyCertPem, testData, signatureData);
             Assert.True(result, "Signature verification should work with PEM formatted certificate");
         }
@@ -72,7 +101,7 @@ public void VerifySignature_WithPemFormattedCertificate_ReturnsTrue()
         public void VerifySignature_WithEmptyCertificate_ReturnsFalse()
         {
             byte[] testData = Encoding.UTF8.GetBytes("Test data");
-            byte[] signatureData = Encoding.UTF8.GetBytes("fake signature");
+            byte[] signatureData = Encoding.UTF8.GetBytes("rsa|abcd1234");
             bool result = KeeShare.VerifySignatureCore("", testData, signatureData);
             Assert.False(result, "Signature verification should fail with empty certificate");
         }
@@ -83,7 +112,7 @@ public void VerifySignature_WithNullData_ReturnsFalse()
             using var rsa = RSA.Create(2048);
             var publicKeyBytes = rsa.ExportSubjectPublicKeyInfo();
             var publicKeyCert = Convert.ToBase64String(publicKeyBytes);
-            byte[] signatureData = Encoding.UTF8.GetBytes("signature");
+            byte[] signatureData = Encoding.UTF8.GetBytes("rsa|abcd1234");
             bool result = KeeShare.VerifySignatureCore(publicKeyCert, null, signatureData);
             Assert.False(result, "Signature verification should fail with null data");
         }
@@ -94,21 +123,35 @@ public void VerifySignature_WithEmptyData_ReturnsFalse()
             using var rsa = RSA.Create(2048);
             var publicKeyBytes = rsa.ExportSubjectPublicKeyInfo();
             var publicKeyCert = Convert.ToBase64String(publicKeyBytes);
-            byte[] signatureData = Encoding.UTF8.GetBytes("signature");
+            byte[] signatureData = Encoding.UTF8.GetBytes("rsa|abcd1234");
             bool result = KeeShare.VerifySignatureCore(publicKeyCert, new byte[0], signatureData);
             Assert.False(result, "Signature verification should fail with empty data");
         }
 
         [Fact]
-        public void VerifySignature_WithMalformedBase64Signature_ReturnsFalse()
+        public void VerifySignature_WithMalformedHexSignature_ReturnsFalse()
+        {
+            using var rsa = RSA.Create(2048);
+            var publicKeyBytes = rsa.ExportSubjectPublicKeyInfo();
+            var publicKeyCert = Convert.ToBase64String(publicKeyBytes);
+            byte[] testData = Encoding.UTF8.GetBytes("Test data");
+            // Invalid hex characters
+            byte[] signatureData = Encoding.UTF8.GetBytes("rsa|not-valid-hex!@#$GHIJ");
+            bool result = KeeShare.VerifySignatureCore(publicKeyCert, testData, signatureData);
+            Assert.False(result, "Signature verification should fail with malformed hex");
+        }
+
+        [Fact]
+        public void VerifySignature_WithOddLengthHex_ReturnsFalse()
         {
             using var rsa = RSA.Create(2048);
             var publicKeyBytes = rsa.ExportSubjectPublicKeyInfo();
             var publicKeyCert = Convert.ToBase64String(publicKeyBytes);
             byte[] testData = Encoding.UTF8.GetBytes("Test data");
-            byte[] signatureData = Encoding.UTF8.GetBytes("not-valid-base64!@#$");
+            // Odd-length hex string (invalid)
+            byte[] signatureData = Encoding.UTF8.GetBytes("rsa|abc");
             bool result = KeeShare.VerifySignatureCore(publicKeyCert, testData, signatureData);
-            Assert.False(result, "Signature verification should fail with malformed base64");
+            Assert.False(result, "Signature verification should fail with odd-length hex");
         }
 
         [Fact]
@@ -120,11 +163,44 @@ public void VerifySignature_WithSignatureContainingWhitespace_ReturnsTrue()
             byte[] testData = Encoding.UTF8.GetBytes("Test KDBX data content");
             byte[] hash = SHA256.HashData(testData);
             byte[] signature = rsa.SignHash(hash, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
-            string signatureBase64 = Convert.ToBase64String(signature);
-            string signatureWithWhitespace = $"\r\n  {signatureBase64}  \r\n";
+            string signatureHex = BytesToHex(signature);
+            // Add whitespace around the signature
+            string signatureWithWhitespace = $"\r\n  rsa|{signatureHex}  \r\n";
             byte[] signatureData = Encoding.UTF8.GetBytes(signatureWithWhitespace);
             bool result = KeeShare.VerifySignatureCore(publicKeyCert, testData, signatureData);
             Assert.True(result, "Signature verification should handle whitespace in signature");
         }
+
+        [Fact]
+        public void VerifySignature_WithUppercaseHex_ReturnsTrue()
+        {
+            using var rsa = RSA.Create(2048);
+            var publicKeyBytes = rsa.ExportSubjectPublicKeyInfo();
+            var publicKeyCert = Convert.ToBase64String(publicKeyBytes);
+            byte[] testData = Encoding.UTF8.GetBytes("Test KDBX data content");
+            byte[] hash = SHA256.HashData(testData);
+            byte[] signature = rsa.SignHash(hash, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
+            // Use uppercase hex
+            string signatureHex = BitConverter.ToString(signature).Replace("-", "").ToUpperInvariant();
+            byte[] signatureData = Encoding.UTF8.GetBytes($"rsa|{signatureHex}");
+            bool result = KeeShare.VerifySignatureCore(publicKeyCert, testData, signatureData);
+            Assert.True(result, "Signature verification should handle uppercase hex");
+        }
+
+        [Fact]
+        public void VerifySignature_WithUppercaseRsaPrefix_ReturnsTrue()
+        {
+            using var rsa = RSA.Create(2048);
+            var publicKeyBytes = rsa.ExportSubjectPublicKeyInfo();
+            var publicKeyCert = Convert.ToBase64String(publicKeyBytes);
+            byte[] testData = Encoding.UTF8.GetBytes("Test KDBX data content");
+            byte[] hash = SHA256.HashData(testData);
+            byte[] signature = rsa.SignHash(hash, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
+            string signatureHex = BytesToHex(signature);
+            // Use uppercase "RSA|" prefix
+            byte[] signatureData = Encoding.UTF8.GetBytes($"RSA|{signatureHex}");
+            bool result = KeeShare.VerifySignatureCore(publicKeyCert, testData, signatureData);
+            Assert.True(result, "Signature verification should handle uppercase RSA prefix");
+        }
     }
 }

src/keepass2android-app/KeeShare.cs

@@ -422,7 +422,7 @@ private bool VerifySignature(PwGroup group, byte[] kdbxData, byte[] signatureDat
         /// </summary>
         /// <param name="trustedCertificate">The trusted certificate (public key) as base64-encoded DER or PEM format</param>
         /// <param name="kdbxData">The KDBX file data that was signed</param>
-        /// <param name="signatureData">The signature data (base64-encoded)</param>
+        /// <param name="signatureData">The signature data in KeeShare format ("rsa|&lt;hex&gt;")</param>
         /// <returns>True if signature is valid, false otherwise</returns>
         internal static bool VerifySignatureCore(string trustedCertificate, byte[]? kdbxData, byte[]? signatureData)
         {
@@ -443,22 +443,35 @@ internal static bool VerifySignatureCore(string trustedCertificate, byte[]? kdbx
                     return false;
                 }
 
-                // KeeShare signature format: base64-encoded RSA signature
+                // KeeShare signature format: "rsa|<hex>" where hex is the RSA signature
                 // The signature is computed over the kdbx file data using SHA-256
                 string signatureText = Encoding.UTF8.GetString(signatureData).Trim();
 
                 // Remove any whitespace/newlines
                 signatureText = signatureText.Replace("\r", "").Replace("\n", "").Replace(" ", "");
 
+                // Strip "rsa|" prefix if present
+                const string rsaPrefix = "rsa|";
+                if (signatureText.StartsWith(rsaPrefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    signatureText = signatureText.Substring(rsaPrefix.Length);
+                }
+                
+                // Hex-decode the signature
                 byte[] signatureBytes;
                 try
                 {
-                    signatureBytes = Convert.FromBase64String(signatureText);
+                    signatureBytes = HexStringToBytes(signatureText);
                 }
                 catch (Exception)
                 {
                     return false;
                 }
+                
+                if (signatureBytes == null || signatureBytes.Length == 0)
+                {
+                    return false;
+                }
 
                 // Parse the trusted certificate (public key)
                 // Format: PEM-encoded public key or base64-encoded DER
@@ -542,5 +555,36 @@ internal static bool VerifySignatureCore(string trustedCertificate, byte[]? kdbx
                 return false;
             }
         }
+
+        /// <summary>
+        /// Converts a hexadecimal string to a byte array.
+        /// </summary>
+        /// <param name="hex">The hexadecimal string (case-insensitive, no separators)</param>
+        /// <returns>The decoded byte array, or null if the input is invalid</returns>
+        private static byte[]? HexStringToBytes(string hex)
+        {
+            if (string.IsNullOrEmpty(hex))
+            {
+                return null;
+            }
+
+            // Hex string must have even length
+            if (hex.Length % 2 != 0)
+            {
+                return null;
+            }
+
+            byte[] bytes = new byte[hex.Length / 2];
+            for (int i = 0; i < bytes.Length; i++)
+            {
+                string byteStr = hex.Substring(i * 2, 2);
+                if (!byte.TryParse(byteStr, System.Globalization.NumberStyles.HexNumber, null, out bytes[i]))
+                {
+                    return null;
+                }
+            }
+
+            return bytes;
+        }
     }
 }