Fix ECDSA signature verification and remove useless test

Copilot · marcschier · Copilot · commit 2ef39d0751cc · 2025-12-09T16:52:10.000Z
Co-authored-by: marcschier &lt;11168470+marcschier@users.noreply.github.com&gt;
diff --git a/Libraries/Opc.Ua.Security.Certificates/PKCS10/Pkcs10CertificationRequest.cs b/Libraries/Opc.Ua.Security.Certificates/PKCS10/Pkcs10CertificationRequest.cs
@@ -264,10 +264,15 @@ private bool VerifyEcdsaSignature(byte[] publicKeyBytes, HashAlgorithmName hashA
             {
                 ecdsa.ImportSubjectPublicKeyInfo(m_subjectPublicKeyInfo, out _);
                 
+                // PKCS#10 CSRs store ECDSA signatures in DER format (ASN.1 SEQUENCE)
+                // but .NET's VerifyData expects IEEE P1363 format (r || s)
+                // We need to convert the signature format
+                byte[] ieee1363Signature = ConvertEcdsaSignatureDerToIeee1363(m_signature);
+                
                 // Verify signature
                 return ecdsa.VerifyData(
                     m_certificationRequestInfo,
-                    m_signature,
+                    ieee1363Signature,
                     hashAlgorithm);
             }
             catch
@@ -282,5 +287,49 @@ private bool VerifyEcdsaSignature(byte[] publicKeyBytes, HashAlgorithmName hashA
                 "Please use .NET 6.0 or later.");
 #endif
         }
+
+        /// <summary>
+        /// Converts ECDSA signature from DER format to IEEE P1363 format.
+        /// </summary>
+        /// <param name="derSignature">DER-encoded signature (SEQUENCE { r INTEGER, s INTEGER })</param>
+        /// <returns>IEEE P1363 format signature (r || s)</returns>
+        private static byte[] ConvertEcdsaSignatureDerToIeee1363(byte[] derSignature)
+        {
+            // Parse DER SEQUENCE
+            var reader = new AsnReader(derSignature, AsnEncodingRules.DER);
+            AsnReader sequenceReader = reader.ReadSequence();
+            
+            // Read r and s as integers
+            byte[] r = sequenceReader.ReadIntegerBytes().ToArray();
+            byte[] s = sequenceReader.ReadIntegerBytes().ToArray();
+            
+            // Remove leading zero bytes that may be present for sign bit
+            r = TrimLeadingZero(r);
+            s = TrimLeadingZero(s);
+            
+            // Determine the key size (both r and s should be the same size)
+            int keySize = Math.Max(r.Length, s.Length);
+            
+            // Pad to the correct size
+            byte[] ieee1363Signature = new byte[keySize * 2];
+            Array.Copy(r, 0, ieee1363Signature, keySize - r.Length, r.Length);
+            Array.Copy(s, 0, ieee1363Signature, keySize * 2 - s.Length, s.Length);
+            
+            return ieee1363Signature;
+        }
+
+        /// <summary>
+        /// Removes leading zero byte if present (used for sign bit in ASN.1 INTEGER encoding).
+        /// </summary>
+        private static byte[] TrimLeadingZero(byte[] data)
+        {
+            if (data.Length > 1 && data[0] == 0 && (data[1] & 0x80) != 0)
+            {
+                byte[] trimmed = new byte[data.Length - 1];
+                Array.Copy(data, 1, trimmed, 0, trimmed.Length);
+                return trimmed;
+            }
+            return data;
+        }
     }
 }
diff --git a/Tests/Opc.Ua.Security.Certificates.Tests/Pkcs10CertificationRequestTests.cs b/Tests/Opc.Ua.Security.Certificates.Tests/Pkcs10CertificationRequestTests.cs
@@ -149,22 +149,8 @@ public void CreateAndParseEcdsaCsrP256()
 
             // Verify signature
 #if NET6_0_OR_GREATER
-            // Note: ECDSA CSR signature verification currently fails due to signature
-            // encoding differences between .NET's CertificateRequest.CreateSigningRequest
-            // and PKCS#10 expectations. .NET may use IEEE P1363 format while PKCS#10
-            // expects DER encoding. The important part is that the CSR can be parsed
-            // and the public key extracted. RSA verification works correctly, which is
-            // the primary use case for GDS Server.
-            
-            // Attempt verification but accept failure as known limitation
             bool isValid = csr.Verify();
-            if (!isValid)
-            {
-                Assert.Pass("ECDSA CSR parsed successfully. " +
-                    "Signature verification has known encoding incompatibilities " +
-                    "with .NET's CreateSigningRequest output.");
-            }
-            Assert.True(isValid, "CSR signature should be valid");
+            Assert.True(isValid, "ECDSA CSR signature should be valid");
 #else
             // ECDSA verification not supported on older frameworks
             Assert.Throws<NotSupportedException>(() => csr.Verify());
@@ -307,18 +293,6 @@ public void GetCertificationRequestInfoReturnsValidData()
             Assert.Greater(requestInfo.Length, 0);
         }
 
-        /// <summary>
-        /// Test parsing CSR with small RSA key (less than 1024 bits) throws exception.
-        /// </summary>
-        [Test]
-        public void ParseCsrWithSmallRsaKeyThrowsException()
-        {
-            // This test would require manually crafting a CSR with a small key
-            // which is complex, so we'll skip it for now as the validation
-            // happens during signature verification
-            Assert.Pass("Validation happens during key import in RSA.Create()");
-        }
-
         /// <summary>
         /// Test parsing multiple CSRs in sequence.
         /// </summary>
