コード例 #1
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
        /// <summary>
        /// Return the size of the key in bytes.
        /// </summary>
        internal static int DsaKeySize(SafeDsaHandle dsa)
        {
            int keySize = DsaSizeP(dsa);

            // Assume an even multiple of 8 bytes \ 64 bits (OpenSsl also makes the same assumption)
            keySize = (keySize + 7) / 8 * 8;
            return keySize;
        }
コード例 #2
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
        internal static DSAParameters ExportDsaParameters(SafeDsaHandle key, bool includePrivateParameters)
        {
            Debug.Assert(
                key != null && !key.IsInvalid,
                "Callers should check the key is invalid and throw an exception with a message");

            if (key == null || key.IsInvalid)
            {
                throw new CryptographicException();
            }

            IntPtr p_bn, q_bn, g_bn, y_bn, x_bn; // these are not owned
            int    p_cb, q_cb, g_cb, y_cb, x_cb;

            bool refAdded = false;
            try
            {
                key.DangerousAddRef(ref refAdded); // Protect access to the *_bn variables

                if (!GetDsaParameters(key,
                    out p_bn, out p_cb,
                    out q_bn, out q_cb,
                    out g_bn, out g_cb,
                    out y_bn, out y_cb,
                    out x_bn, out x_cb))
                {
                    throw new CryptographicException();
                }

                // Match Windows semantics where p, g and y have same length
                int pgy_cb = GetMax(p_cb, g_cb, y_cb);

                // Match Windows semantics where q and x have same length
                int qx_cb = GetMax(q_cb, x_cb);

                DSAParameters dsaParameters = new DSAParameters
                {
                    P = Crypto.ExtractBignum(p_bn, pgy_cb),
                    Q = Crypto.ExtractBignum(q_bn, qx_cb),
                    G = Crypto.ExtractBignum(g_bn, pgy_cb),
                    Y = Crypto.ExtractBignum(y_bn, pgy_cb),
                };

                if (includePrivateParameters)
                {
                    dsaParameters.X = Crypto.ExtractBignum(x_bn, qx_cb);
                }

                return dsaParameters;
            }
            finally
            {
                if (refAdded)
                    key.DangerousRelease();
            }
        }
コード例 #3
0
        internal static SafeDsaHandle DuplicateHandle(IntPtr handle)
        {
            Debug.Assert(handle != IntPtr.Zero);

            // Reliability: Allocate the SafeHandle before calling Dsa_up_ref so
            // that we don't lose a tracked reference in low-memory situations.
            SafeDsaHandle safeHandle = new SafeDsaHandle();

            if (!Interop.Crypto.DsaUpRef(handle))
            {
                throw Interop.Crypto.CreateOpenSslCryptographicException();
            }

            safeHandle.SetHandle(handle);
            return safeHandle;
        }
コード例 #4
0
ファイル: DSAOpenSsl.cs プロジェクト: dotnet/corefx
            private void SetKey(SafeDsaHandle newKey)
            {
                // Use ForceSet instead of the property setter to ensure that LegalKeySizes doesn't interfere
                // with the already loaded key.
                ForceSetKeySize(BitsPerByte * Interop.Crypto.DsaKeySize(newKey));

                _key = new Lazy<SafeDsaHandle>(() => newKey, isThreadSafe:true);

                // Have Lazy<T> consider the key to be loaded
                var dummy = _key.Value;
            }
コード例 #5
0
ファイル: DSAOpenSsl.cs プロジェクト: dotnet/corefx
 private static void CheckInvalidKey(SafeDsaHandle key)
 {
     if (key == null || key.IsInvalid)
     {
         throw new CryptographicException(SR.Cryptography_OpenInvalidHandle);
     }
 }
コード例 #6
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
 internal static extern bool DsaVerify(SafeDsaHandle dsa, byte[] hash, int hashLength, byte[] signature, int signatureLength);
コード例 #7
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
 internal static extern bool DsaSign(SafeDsaHandle dsa, byte[] hash, int hashLength, byte[] refSignature, out int outSignatureLength);
コード例 #8
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
 private static extern int DsaSizeP(SafeDsaHandle dsa);
コード例 #9
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
 /// <summary>
 /// Return the maximum size of the DER-encoded key in bytes.
 /// </summary>
 internal static int DsaEncodedSignatureSize(SafeDsaHandle dsa)
 {
     int size = DsaSizeSignature(dsa);
     return size;
 }
コード例 #10
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
 /// <summary>
 /// Return the size of the 'r' or 's' signature fields in bytes.
 /// </summary>
 internal static int DsaSignatureFieldSize(SafeDsaHandle dsa)
 {
     int size = DsaSizeQ(dsa);
     Debug.Assert(size * 2 < DsaEncodedSignatureSize(dsa));
     return size;
 }
コード例 #11
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
 private static extern int DsaSizeSignature(SafeDsaHandle dsa);
コード例 #12
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
 internal static extern bool DsaGenerateKey(out SafeDsaHandle dsa, int bits);
コード例 #13
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
 internal static extern bool DsaKeyCreateByExplicitParameters(
     out SafeDsaHandle dsa,
     byte[] p,
     int pLength,
     byte[] q,
     int qLength,
     byte[] g,
     int gLength,
     byte[] y,
     int yLength,
     byte[] x,
     int xLength);
コード例 #14
0
ファイル: Interop.Dsa.cs プロジェクト: geoffkizer/corefx
 private static extern bool GetDsaParameters(
     SafeDsaHandle key,
     out IntPtr p, out int p_cb,
     out IntPtr q, out int q_cb,
     out IntPtr g, out int g_cb,
     out IntPtr y, out int y_cb,
     out IntPtr x, out int x_cb);
コード例 #15
0
 internal static extern bool EvpPkeySetDsa(SafeEvpPKeyHandle pkey, SafeDsaHandle key);