Finish moving DSAOpenSsl to EVP_PKEY for the shim boundary.

src/libraries/Common/src/Internal/Cryptography/AsymmetricAlgorithmHelpers.Der.cs

@@ -13,6 +13,34 @@ namespace Internal.Cryptography
     //
     internal static partial class AsymmetricAlgorithmHelpers
     {
+        internal static bool ValidateRfc3279DerSequence(ReadOnlySpan<byte> signature)
+        {
+            try
+            {
+                AsnValueReader reader = new AsnValueReader(signature, AsnEncodingRules.DER);
+                AsnValueReader payload = reader.ReadSequence();
+
+                if (reader.HasData)
+                {
+                    return false;
+                }
+
+                payload.ReadIntegerBytes();
+                payload.ReadIntegerBytes();
+
+                if (payload.HasData)
+                {
+                    return false;
+                }
+
+                return true;
+            }
+            catch (AsnContentException)
+            {
+                return false;
+            }
+        }
+
         /// <summary>
         /// Convert Ieee1363 format of (r, s) to Der format
         /// </summary>

src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.EcDsa.ImportExport.cs

@@ -295,5 +295,40 @@ internal static ECParameters GetECCurveParameters(
                     key.DangerousRelease();
             }
         }
+
+        /// <summary>
+        /// Return the maximum value in the array; assumes non-negative values.
+        /// </summary>
+        private static int GetMax(int[] values)
+        {
+            int max = 0;
+
+            foreach (var i in values)
+            {
+                Debug.Assert(i >= 0);
+                if (i > max)
+                    max = i;
+            }
+
+            return max;
+        }
+
+        /// <summary>
+        /// Return the maximum value in the array; assumes non-negative values.
+        /// </summary>
+        private static int GetMax(int value1, int value2)
+        {
+            Debug.Assert(value1 >= 0);
+            Debug.Assert(value2 >= 0);
+            return (value1 > value2 ? value1 : value2);
+        }
+
+        /// <summary>
+        /// Return the maximum value in the array; assumes non-negative values.
+        /// </summary>
+        private static int GetMax(int value1, int value2, int value3)
+        {
+            return GetMax(GetMax(value1, value2), value3);
+        }
     }
 }

src/libraries/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.EvpPkey.Dsa.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 using Microsoft.Win32.SafeHandles;
@@ -9,11 +11,89 @@ internal static partial class Interop
 {
     internal static partial class Crypto
     {
-        [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_EvpPkeyGetDsa")]
-        internal static extern SafeDsaHandle EvpPkeyGetDsa(SafeEvpPKeyHandle pkey);
+        [DllImport(Libraries.CryptoNative)]
+        private static extern SafeEvpPKeyHandle CryptoNative_EvpPKeyCreateDsa(IntPtr dsa);
 
-        [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_EvpPkeySetDsa")]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        internal static extern bool EvpPkeySetDsa(SafeEvpPKeyHandle pkey, SafeDsaHandle key);
+        internal static SafeEvpPKeyHandle EvpPKeyCreateDsa(IntPtr dsa)
+        {
+            Debug.Assert(dsa != IntPtr.Zero);
+
+            SafeEvpPKeyHandle pkey = CryptoNative_EvpPKeyCreateDsa(dsa);
+
+            if (pkey.IsInvalid)
+            {
+                pkey.Dispose();
+                throw CreateOpenSslCryptographicException();
+            }
+
+            return pkey;
+        }
+
+        [DllImport(Libraries.CryptoNative)]
+        private static extern SafeEvpPKeyHandle CryptoNative_DsaGenerateKey(int keySize);
+
+        internal static SafeEvpPKeyHandle DsaGenerateKey(int keySize)
+        {
+            SafeEvpPKeyHandle handle = CryptoNative_DsaGenerateKey(keySize);
+
+            if (handle.IsInvalid)
+            {
+                handle.Dispose();
+                throw CreateOpenSslCryptographicException();
+            }
+
+            return handle;
+        }
+
+        [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_DsaSizeQ")]
+        private static extern int DsaSizeQ(SafeEvpPKeyHandle dsa);
+
+        /// <summary>
+        /// Return the size of the 'r' or 's' signature fields in bytes.
+        /// </summary>
+        internal static int DsaSignatureFieldSize(SafeEvpPKeyHandle dsa)
+        {
+            int size = DsaSizeQ(dsa);
+            Debug.Assert(size * 2 < EvpPKeySize(dsa));
+            return size;
+        }
+
+        [DllImport(Libraries.CryptoNative)]
+        private static extern unsafe int CryptoNative_DsaSignHash(
+            SafeEvpPKeyHandle key,
+            byte* hash,
+            int hashLen,
+            byte* destination,
+            int destinationLen);
+
+        internal static int DsaSignHash(
+            SafeEvpPKeyHandle key,
+            ReadOnlySpan<byte> hash,
+            Span<byte> destination)
+        {
+            int written;
+
+            unsafe
+            {
+                fixed (byte* hashPtr = hash)
+                fixed (byte* destPtr = destination)
+                {
+                    written = CryptoNative_DsaSignHash(
+                        key,
+                        hashPtr,
+                        hash.Length,
+                        destPtr,
+                        destination.Length);
+                }
+            }
+
+            if (written < 0)
+            {
+                Debug.Assert(written == -1);
+                throw CreateOpenSslCryptographicException();
+            }
+
+            return written;
+        }
     }
 }