From 2fe5bb7d51c3dd65f0f3aed96f5113cf9f420017 Mon Sep 17 00:00:00 2001 From: "egor.okhotin" Date: Fri, 17 Apr 2020 13:33:00 +0400 Subject: [PATCH] change native api & target frameworks --- .../GostCryptography.Tests.csproj | 3 +- .../GostCryptography/GostCryptography.csproj | 9 +- Source/GostCryptography/Native/CryptoApi.cs | 350 ++++++++++-------- Source/GostCryptography/Native/INativeApi.cs | 102 +++++ Source/GostCryptography/Native/LinuxApi.cs | 336 +++++++++++++++++ .../Native/LinuxCryptoProNativeApi.cs | 204 ++++++++++ .../Native/LinuxVipNetNativeApi.cs | 198 ++++++++++ .../Native/NativeApiFactory.cs | 12 + Source/GostCryptography/Native/SafeStore.cs | 47 +++ Source/GostCryptography/Native/WindowsApi.cs | 189 ++++++++++ .../Native/WindowsNativeApi.cs | 198 ++++++++++ 11 files changed, 1491 insertions(+), 157 deletions(-) create mode 100644 Source/GostCryptography/Native/INativeApi.cs create mode 100644 Source/GostCryptography/Native/LinuxApi.cs create mode 100644 Source/GostCryptography/Native/LinuxCryptoProNativeApi.cs create mode 100644 Source/GostCryptography/Native/LinuxVipNetNativeApi.cs create mode 100644 Source/GostCryptography/Native/NativeApiFactory.cs create mode 100644 Source/GostCryptography/Native/SafeStore.cs create mode 100644 Source/GostCryptography/Native/WindowsApi.cs create mode 100644 Source/GostCryptography/Native/WindowsNativeApi.cs diff --git a/Source/GostCryptography.Tests/GostCryptography.Tests.csproj b/Source/GostCryptography.Tests/GostCryptography.Tests.csproj index d7122a6..90cc18e 100644 --- a/Source/GostCryptography.Tests/GostCryptography.Tests.csproj +++ b/Source/GostCryptography.Tests/GostCryptography.Tests.csproj @@ -1,7 +1,7 @@  - net40;net452 + netcoreapp3.1 false @@ -14,6 +14,7 @@ + diff --git a/Source/GostCryptography/GostCryptography.csproj b/Source/GostCryptography/GostCryptography.csproj index 5fcd929..f27e1af 100644 --- a/Source/GostCryptography/GostCryptography.csproj +++ b/Source/GostCryptography/GostCryptography.csproj @@ -1,7 +1,7 @@  - net40;net452 + netcoreapp3.1 true GostCryptography GostCryptography @@ -27,12 +27,11 @@ true - - - - + + + diff --git a/Source/GostCryptography/Native/CryptoApi.cs b/Source/GostCryptography/Native/CryptoApi.cs index 162ad72..1de3733 100644 --- a/Source/GostCryptography/Native/CryptoApi.cs +++ b/Source/GostCryptography/Native/CryptoApi.cs @@ -1,158 +1,206 @@ -using System; +using GostCryptography.Base; +using System; using System.Runtime.ConstrainedExecution; using System.Runtime.InteropServices; using System.Security; using System.Text; namespace GostCryptography.Native -{ - /// - /// Функции для работы с Microsoft CryptoAPI. - /// - [SecurityCritical] - public static class CryptoApi - { - // ReSharper disable InconsistentNaming - - #region Для работы с криптографическим провайдером - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)] - public static extern bool CryptAcquireContext([In] [Out] ref SafeProvHandleImpl hProv, [In] string pszContainer, [In] string pszProvider, [In] uint dwProvType, [In] uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptReleaseContext(IntPtr hCryptProv, uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] - [DllImport("advapi32.dll", CharSet = CharSet.Ansi, SetLastError = true)] - public static extern bool CryptContextAddRef([In] IntPtr hProv, [In] byte[] pdwReserved, [In] uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)] - public static extern bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint dwDataLen, [In] uint dwFlags); - - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.LPStr)] StringBuilder pbData, ref uint dwDataLen, uint dwFlags); - - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.U8)] long pbData, ref uint dwDataLen, uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptSetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] IntPtr pbData, [In] uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] - [DllImport("advapi32.dll", EntryPoint = "CryptSetProvParam", SetLastError = true)] - public static extern bool CryptSetProvParam2(IntPtr hCryptProv, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); - - #endregion - - - #region Для работы с функцией хэширования криптографического провайдера - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptCreateHash([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags, [In] [Out] ref SafeHashHandleImpl phHash); - - [return: MarshalAs(UnmanagedType.Bool)] - [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptDestroyHash(IntPtr pHashCtx); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptGetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptSetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, [In] uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptHashData([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbData, [In] uint dwDataLen, [In] uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern unsafe bool CryptHashData([In] SafeHashHandleImpl hHash, byte* pbData, [In] uint dwDataLen, [In] uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptHashSessionKey([In] SafeHashHandleImpl hHash, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags); - - #endregion - - - #region Для работы с функцией шифрования криптографического провайдера - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptDecrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptEncrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwBufLen); - - #endregion - - - #region Для работы с ключами криптографического провайдера - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptGenKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptGetUserKey([In] SafeProvHandleImpl hProv, [In] uint dwKeySpec, [In] [Out] ref SafeKeyHandleImpl phUserKey); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptDeriveKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeHashHandleImpl hBaseData, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptDuplicateKey([In] IntPtr hKey, [In] byte[] pdwReserved, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); - - [return: MarshalAs(UnmanagedType.Bool)] - [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptDestroyKey(IntPtr pKeyCtx); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptGetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptSetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptExportKey([In] SafeKeyHandleImpl hKey, [In] SafeKeyHandleImpl hExpKey, [In] uint dwBlobType, [In] uint dwFlags, [Out] byte[] pbData, ref uint pdwDataLen); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", SetLastError = true)] - public static extern bool CryptImportKey([In] SafeProvHandleImpl hCryptProv, [In] byte[] pbData, [In] uint dwDataLen, [In] SafeKeyHandleImpl hPubKey, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); - - #endregion - - - #region Для работы с цифровой подписью - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", CharSet = CharSet.Ansi, SetLastError = true)] - public static extern bool CryptSignHash([In] SafeHashHandleImpl hHash, [In] uint dwKeySpec, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags, [In] [Out] byte[] pbSignature, ref uint pdwSigLen); - - [return: MarshalAs(UnmanagedType.Bool)] - [DllImport("advapi32.dll", CharSet = CharSet.Ansi, SetLastError = true)] - public static extern bool CryptVerifySignature([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbSignature, uint pdwSigLen, [In] SafeKeyHandleImpl hPubKey, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags); - - #endregion - - // ReSharper restore InconsistentNaming - } +{ + /// + /// Функции для работы с Microsoft CryptoAPI. + /// + [SecurityCritical] + internal static class CryptoApi + { + private static INativeApi _api; + + internal static ProviderType ProviderType { get; set; } + internal static NativeApiFactory Factory { get; set; } + public static INativeApi Api + { + get + { + return Factory.CreateApi(ProviderType); + } + } + + public static bool CertCloseStore(SafeStore hCertStore, uint dwFlags) + { + return Api.CertCloseStore(hCertStore, dwFlags); + } + + public static bool CryptAcquireContext(ref SafeProvHandleImpl hProv, string pszContainer, string pszProvider, uint dwProvType, uint dwFlags) + { + return Api.CryptAcquireContext(ref hProv, pszContainer, pszProvider, dwProvType, dwFlags); + } + + public static bool CryptContextAddRef(IntPtr hProv, byte[] pdwReserved, uint dwFlags) + { + return Api.CryptContextAddRef(hProv, pdwReserved, dwFlags); + } + + public static bool CryptCreateHash(SafeProvHandleImpl hProv, uint Algid, SafeKeyHandleImpl hKey, uint dwFlags, ref SafeHashHandleImpl phHash) + { + return Api.CryptCreateHash(hProv, Algid, hKey, dwFlags, ref phHash); + } + + public static bool CryptDecrypt(SafeKeyHandleImpl hKey, SafeHashHandleImpl hHash, bool Final, uint dwFlags, byte[] pbData, ref uint pdwDataLen) + { + return Api.CryptDecrypt(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen); + } + + public static bool CryptDeriveKey(SafeProvHandleImpl hProv, uint Algid, SafeHashHandleImpl hBaseData, uint dwFlags, ref SafeKeyHandleImpl phKey) + { + return Api.CryptDeriveKey(hProv, Algid, hBaseData, dwFlags, ref phKey); + } + + public static bool CryptDestroyHash(IntPtr pHashCtx) + { + return Api.CryptDestroyHash(pHashCtx); + } + + public static bool CryptDestroyKey(IntPtr pKeyCtx) + { + return Api.CryptDestroyKey(pKeyCtx); + } + + public static bool CryptDuplicateKey(IntPtr hKey, byte[] pdwReserved, uint dwFlags, ref SafeKeyHandleImpl phKey) + { + return Api.CryptDuplicateKey(hKey, pdwReserved, dwFlags, ref phKey); + } + + public static bool CryptEncrypt(SafeKeyHandleImpl hKey, SafeHashHandleImpl hHash, bool Final, uint dwFlags, byte[] pbData, ref uint pdwDataLen, uint dwBufLen) + { + return Api.CryptEncrypt(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen, dwBufLen); + } + + public static bool CryptExportKey(SafeKeyHandleImpl hKey, SafeKeyHandleImpl hExpKey, uint dwBlobType, uint dwFlags, byte[] pbData, ref uint pdwDataLen) + { + return Api.CryptExportKey(hKey, hExpKey, dwBlobType, dwFlags, pbData, ref pdwDataLen); + } + + public static bool CryptGenKey(SafeProvHandleImpl hProv, uint Algid, uint dwFlags, ref SafeKeyHandleImpl phKey) + { + return Api.CryptGenKey(hProv, Algid, dwFlags, ref phKey); + } + + public static bool CryptGetHashParam(SafeHashHandleImpl hHash, uint dwParam, byte[] pbData, ref uint pdwDataLen, uint dwFlags) + { + return Api.CryptGetHashParam(hHash, dwParam, pbData, ref pdwDataLen, dwFlags); + } + + public static bool CryptGetKeyParam(SafeKeyHandleImpl hKey, uint dwParam, byte[] pbData, ref uint pdwDataLen, uint dwFlags) + { + return Api.CryptGetKeyParam(hKey, dwParam, pbData, ref pdwDataLen, dwFlags); + } + + public static bool CryptGetProvParam(SafeProvHandleImpl hProv, uint dwParam, byte[] pbData, ref uint dwDataLen, uint dwFlags) + { + return Api.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + } + + public static bool CryptGetProvParam(SafeProvHandleImpl hProv, uint dwParam, StringBuilder pbData, ref uint dwDataLen, uint dwFlags) + { + return Api.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + } + + public static bool CryptGetProvParam(SafeProvHandleImpl hProv, uint dwParam, long pbData, ref uint dwDataLen, uint dwFlags) + { + return Api.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + } + + public static bool CryptGetUserKey(SafeProvHandleImpl hProv, uint dwKeySpec, ref SafeKeyHandleImpl phUserKey) + { + return Api.CryptGetUserKey(hProv, dwKeySpec, ref phUserKey); + } + + public static bool CryptHashData(SafeHashHandleImpl hHash, byte[] pbData, uint dwDataLen, uint dwFlags) + { + return Api.CryptHashData(hHash, pbData, dwDataLen, dwFlags); + } + + public static unsafe bool CryptHashData(SafeHashHandleImpl hHash, byte* pbData, uint dwDataLen, uint dwFlags) + { + return Api.CryptHashData(hHash, pbData, dwDataLen, dwFlags); + } + + public static bool CryptHashSessionKey(SafeHashHandleImpl hHash, SafeKeyHandleImpl hKey, uint dwFlags) + { + return Api.CryptHashSessionKey(hHash, hKey, dwFlags); + } + + public static bool CryptImportKey(SafeProvHandleImpl hCryptProv, byte[] pbData, uint dwDataLen, SafeKeyHandleImpl hPubKey, uint dwFlags, ref SafeKeyHandleImpl phKey) + { + return Api.CryptImportKey(hCryptProv, pbData, dwDataLen, hPubKey, dwFlags, ref phKey); + } + + public static bool CryptReleaseContext(IntPtr hCryptProv, uint dwFlags) + { + return Api.CryptReleaseContext(hCryptProv, dwFlags); + } + + public static bool CryptSetHashParam(SafeHashHandleImpl hHash, uint dwParam, byte[] pbData, uint dwFlags) + { + return Api.CryptSetHashParam(hHash, dwParam, pbData, dwFlags); + } + + public static bool CryptSetKeyParam(SafeKeyHandleImpl hKey, uint dwParam, byte[] pbData, uint dwFlags) + { + return Api.CryptSetKeyParam(hKey, dwParam, pbData, dwParam); + } + + public static bool CryptSetProvParam(SafeProvHandleImpl hProv, uint dwParam, IntPtr pbData, uint dwFlags) + { + return Api.CryptSetProvParam(hProv, dwParam, pbData, dwFlags); + } + + public static bool CryptSetProvParam2(IntPtr hCryptProv, uint dwParam, byte[] pbData, uint dwFlags) + { + return Api.CryptSetProvParam2(hCryptProv, dwParam, pbData, dwFlags); + } + + public static bool CryptSignHash(SafeHashHandleImpl hHash, uint dwKeySpec, StringBuilder sDescription, uint dwFlags, byte[] pbSignature, ref uint pdwSigLen) + { + return Api.CryptSignHash(hHash, dwKeySpec, sDescription, dwFlags, pbSignature, ref pdwSigLen); + } + + public static bool CryptVerifySignature(SafeHashHandleImpl hHash, byte[] pbSignature, uint pdwSigLen, SafeKeyHandleImpl hPubKey, StringBuilder sDescription, uint dwFlags) + { + return Api.CryptVerifySignature(hHash, pbSignature, pdwSigLen, hPubKey, sDescription, dwFlags); + } + + public static SafeStore CertOpenSystemStore(SafeStore hCertStore, string pszStoreName) + { + return Api.CertOpenSystemStore(hCertStore, pszStoreName); + } + + public static IntPtr CertEnumCertificatesInStore(SafeStore hCertStore, IntPtr pPrevCertContext) + { + return Api.CertEnumCertificatesInStore(hCertStore, pPrevCertContext); + } + + public static uint CertGetNameString(IntPtr pCertContext, uint dwType, uint dwFlags, IntPtr pvTypePara, byte[] pszNameString, uint cchNameString) + { + return Api.CertGetNameString(pCertContext, dwType, dwFlags, pvTypePara, pszNameString, cchNameString); + } + + public static bool CertGetCertificateContextProperty(IntPtr pCertContext, uint dwPropId, IntPtr pvData, ref uint pcbData) + { + return Api.CertGetCertificateContextProperty(pCertContext, dwPropId, pvData, ref pcbData); + } + + public static bool CryptImportPublicKeyInfo([In] SafeProvHandleImpl hCryptProv, + [In] uint dwCertEncodingType, + [In] IntPtr pSubjectPublicKeyInfo, + [Out][In]ref SafeKeyHandleImpl phKey) + { + return Api.CryptImportPublicKeyInfo(hCryptProv, dwCertEncodingType, pSubjectPublicKeyInfo, ref phKey); + } + + public static IntPtr CertCreateCertificateContext(uint dwCertEncodingType, byte[] pCertEncoded, int cbCertEncoded) + { + return Api.CertCreateCertificateContext(dwCertEncodingType, pCertEncoded, cbCertEncoded); + } + } } \ No newline at end of file diff --git a/Source/GostCryptography/Native/INativeApi.cs b/Source/GostCryptography/Native/INativeApi.cs new file mode 100644 index 0000000..a6dc0c9 --- /dev/null +++ b/Source/GostCryptography/Native/INativeApi.cs @@ -0,0 +1,102 @@ +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Text; + +namespace GostCryptography.Native +{ + interface INativeApi + { + + bool CryptAcquireContext([In] [Out] ref SafeProvHandleImpl hProv, [In] string pszContainer, [In] string pszProvider, [In] uint dwProvType, [In] uint dwFlags); + + bool CryptReleaseContext(IntPtr hCryptProv, uint dwFlags); + + bool CryptContextAddRef([In] IntPtr hProv, [In] byte[] pdwReserved, [In] uint dwFlags); + + bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint dwDataLen, [In] uint dwFlags); + + bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.LPStr)] StringBuilder pbData, ref uint dwDataLen, uint dwFlags); + + bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.U8)] long pbData, ref uint dwDataLen, uint dwFlags); + + bool CryptSetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] IntPtr pbData, [In] uint dwFlags); + + bool CryptSetProvParam2(IntPtr hCryptProv, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); + + bool CryptImportPublicKeyInfo( + [In] SafeProvHandleImpl hCryptProv, + [In] uint dwCertEncodingType, + [In] IntPtr pPublicKeyInfo, + [Out][In] ref SafeKeyHandleImpl phKey + ); + + SafeStore CertOpenSystemStore(SafeStore hCertStore, string pszStoreName); + + IntPtr CertEnumCertificatesInStore([In]SafeStore hCertStore, [In]IntPtr pPrevCertContext); + + uint CertGetNameString( + [In]IntPtr pCertContext, + uint dwType, + uint dwFlags, + IntPtr pvTypePara, + byte[] pszNameString, + uint cchNameString); + + bool CertGetCertificateContextProperty( + [In]IntPtr pCertContext, + [In]uint dwPropId, + [Out]IntPtr pvData, + [In][Out]ref uint pcbData); + + IntPtr CertCreateCertificateContext( + uint dwCertEncodingType, + byte[] pCertEncoded, + int cbCertEncoded + ); + + bool CertCloseStore(SafeStore hCertStore, uint dwFlags); + bool CryptCreateHash([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags, [In] [Out] ref SafeHashHandleImpl phHash); + + bool CryptDestroyHash(IntPtr pHashCtx); + + bool CryptGetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); + + bool CryptSetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, [In] uint dwFlags); + + bool CryptHashData([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbData, [In] uint dwDataLen, [In] uint dwFlags); + + unsafe bool CryptHashData([In] SafeHashHandleImpl hHash, byte* pbData, [In] uint dwDataLen, [In] uint dwFlags); + + bool CryptHashSessionKey([In] SafeHashHandleImpl hHash, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags); + + + bool CryptDecrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen); + + bool CryptEncrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwBufLen); + + bool CryptGenKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + bool CryptGetUserKey([In] SafeProvHandleImpl hProv, [In] uint dwKeySpec, [In] [Out] ref SafeKeyHandleImpl phUserKey); + + bool CryptDeriveKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeHashHandleImpl hBaseData, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + bool CryptDuplicateKey([In] IntPtr hKey, [In] byte[] pdwReserved, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + bool CryptDestroyKey(IntPtr pKeyCtx); + + bool CryptGetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); + + bool CryptSetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); + + bool CryptExportKey([In] SafeKeyHandleImpl hKey, [In] SafeKeyHandleImpl hExpKey, [In] uint dwBlobType, [In] uint dwFlags, [Out] byte[] pbData, ref uint pdwDataLen); + + bool CryptImportKey([In] SafeProvHandleImpl hCryptProv, [In] byte[] pbData, [In] uint dwDataLen, [In] SafeKeyHandleImpl hPubKey, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + + bool CryptSignHash([In] SafeHashHandleImpl hHash, [In] uint dwKeySpec, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags, [In] [Out] byte[] pbSignature, ref uint pdwSigLen); + + bool CryptVerifySignature([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbSignature, uint pdwSigLen, [In] SafeKeyHandleImpl hPubKey, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags); + + } +} diff --git a/Source/GostCryptography/Native/LinuxApi.cs b/Source/GostCryptography/Native/LinuxApi.cs new file mode 100644 index 0000000..2ddfafc --- /dev/null +++ b/Source/GostCryptography/Native/LinuxApi.cs @@ -0,0 +1,336 @@ +using GostCryptography.Base; +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Text; + +namespace GostCryptography.Native +{ + class LinuxApi : INativeApi + { + private readonly ProviderType _providerType; + + public LinuxApi(ProviderType type) + { + _providerType = type; + } + public bool CertCloseStore(SafeStore hCertStore, uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CertCloseStore(hCertStore, dwFlags); + else + return LinuxVipNetNativeApi.CertCloseStore(hCertStore, dwFlags); + } + + public IntPtr CertEnumCertificatesInStore([In] SafeStore hCertStore, [In] IntPtr pPrevCertContext) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CertEnumCertificatesInStore(hCertStore, pPrevCertContext); + else + return LinuxVipNetNativeApi.CertEnumCertificatesInStore(hCertStore, pPrevCertContext); + } + + public bool CertGetCertificateContextProperty([In] IntPtr pCertContext, [In] uint dwPropId, [Out] IntPtr pvData, [In, Out] ref uint pcbData) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CertGetCertificateContextProperty(pCertContext, dwPropId, pvData, ref pcbData); + else + return LinuxVipNetNativeApi.CertGetCertificateContextProperty(pCertContext, dwPropId, pvData, ref pcbData); + } + + public uint CertGetNameString([In] IntPtr pCertContext, uint dwType, uint dwFlags, IntPtr pvTypePara, byte[] pszNameString, uint cchNameString) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CertGetNameString(pCertContext, dwType, dwFlags, pvTypePara, pszNameString, cchNameString); + else + return LinuxVipNetNativeApi.CertGetNameString(pCertContext, dwType, dwFlags, pvTypePara, pszNameString, cchNameString); + } + + public SafeStore CertOpenSystemStore(SafeStore hCertStore, string pszStoreName) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CertOpenSystemStore(hCertStore, pszStoreName); + else + return LinuxVipNetNativeApi.CertOpenSystemStore(hCertStore, pszStoreName); + } + + public bool CryptAcquireContext([In, Out] ref SafeProvHandleImpl hProv, [In] string pszContainer, + [In] string pszProvider, [In] uint dwProvType, [In] uint dwFlags) + { + bool result; + try + { + //This string depends on encoding of system + var containerNamePtr = MarshalString(pszContainer); + var providerNamePtr = MarshalString(pszProvider); + result = _providerType.IsCryptoPro() + ? LinuxCryptoProNativeApi.CryptAcquireContext(ref hProv, containerNamePtr, providerNamePtr, dwProvType, dwFlags) + : LinuxVipNetNativeApi.CryptAcquireContext(ref hProv, containerNamePtr, providerNamePtr, dwProvType, + dwFlags); + Marshal.FreeHGlobal(containerNamePtr); + Marshal.FreeHGlobal(providerNamePtr); + } + catch + { + result = false; + } + + return result; + } + + public bool CryptContextAddRef([In] IntPtr hProv, [In] byte[] pdwReserved, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptContextAddRef(hProv, pdwReserved, dwFlags); + else + return LinuxVipNetNativeApi.CryptContextAddRef(hProv, pdwReserved, dwFlags); + } + + public bool CryptCreateHash([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags, [In, Out] ref SafeHashHandleImpl phHash) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptCreateHash(hProv, Algid, hKey, dwFlags, ref phHash); + else + return LinuxVipNetNativeApi.CryptCreateHash(hProv, Algid, hKey, dwFlags, ref phHash); + } + + public bool CryptDecrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In, MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In, Out] byte[] pbData, ref uint pdwDataLen) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptDecrypt(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen); + else + return LinuxVipNetNativeApi.CryptDecrypt(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen); + } + + public bool CryptDeriveKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeHashHandleImpl hBaseData, [In] uint dwFlags, [In, Out] ref SafeKeyHandleImpl phKey) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptDeriveKey(hProv, Algid, hBaseData, dwFlags, ref phKey); + else + return LinuxVipNetNativeApi.CryptDeriveKey(hProv, Algid, hBaseData, dwFlags, ref phKey); + } + + public bool CryptDestroyHash(IntPtr pHashCtx) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptDestroyHash(pHashCtx); + else + return LinuxVipNetNativeApi.CryptDestroyHash(pHashCtx); + } + + public bool CryptDestroyKey(IntPtr pKeyCtx) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptDestroyKey(pKeyCtx); + else + return LinuxVipNetNativeApi.CryptDestroyKey(pKeyCtx); + } + + public bool CryptDuplicateKey([In] IntPtr hKey, [In] byte[] pdwReserved, [In] uint dwFlags, [In, Out] ref SafeKeyHandleImpl phKey) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptDuplicateKey(hKey, pdwReserved, dwFlags, ref phKey); + else + return LinuxVipNetNativeApi.CryptDuplicateKey(hKey, pdwReserved, dwFlags, ref phKey); + } + + public bool CryptEncrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In, MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In, Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwBufLen) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptEncrypt(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen, dwBufLen); + else + return LinuxVipNetNativeApi.CryptEncrypt(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen, dwBufLen); + } + + public bool CryptExportKey([In] SafeKeyHandleImpl hKey, [In] SafeKeyHandleImpl hExpKey, [In] uint dwBlobType, [In] uint dwFlags, [Out] byte[] pbData, ref uint pdwDataLen) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptExportKey(hKey, hExpKey, dwBlobType, dwFlags, pbData, ref pdwDataLen); + else + return LinuxVipNetNativeApi.CryptExportKey(hKey, hExpKey, dwBlobType, dwFlags, pbData, ref pdwDataLen); + } + + public bool CryptGenKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] uint dwFlags, [In, Out] ref SafeKeyHandleImpl phKey) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptGenKey(hProv, Algid, dwFlags, ref phKey); + else + return LinuxVipNetNativeApi.CryptGenKey(hProv, Algid, dwFlags, ref phKey); + } + + public bool CryptGetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In, Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptGetHashParam(hHash, dwParam, pbData, ref pdwDataLen, dwFlags); + else + return LinuxVipNetNativeApi.CryptGetHashParam(hHash, dwParam, pbData, ref pdwDataLen, dwFlags); + } + + public bool CryptGetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In, Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptGetKeyParam(hKey, dwParam, pbData, ref pdwDataLen, dwFlags); + else + return LinuxVipNetNativeApi.CryptGetKeyParam(hKey, dwParam, pbData, ref pdwDataLen, dwFlags); + } + + public bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In, Out] byte[] pbData, ref uint dwDataLen, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + else + return LinuxVipNetNativeApi.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + } + + public bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.LPStr)] StringBuilder pbData, ref uint dwDataLen, uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + else + return LinuxVipNetNativeApi.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + } + + public bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.U8)] long pbData, ref uint dwDataLen, uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + else + return LinuxVipNetNativeApi.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + } + + public bool CryptGetUserKey([In] SafeProvHandleImpl hProv, [In] uint dwKeySpec, [In, Out] ref SafeKeyHandleImpl phUserKey) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptGetUserKey(hProv, dwKeySpec, ref phUserKey); + else + return LinuxVipNetNativeApi.CryptGetUserKey(hProv, dwKeySpec, ref phUserKey); + } + + public bool CryptHashData([In] SafeHashHandleImpl hHash, [In, Out] byte[] pbData, [In] uint dwDataLen, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptHashData(hHash, pbData, dwDataLen, dwFlags); + else + return LinuxVipNetNativeApi.CryptHashData(hHash, pbData, dwDataLen, dwFlags); + } + + public unsafe bool CryptHashData([In] SafeHashHandleImpl hHash, byte* pbData, [In] uint dwDataLen, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptHashData(hHash, pbData, dwDataLen, dwFlags); + else + return LinuxVipNetNativeApi.CryptHashData(hHash, pbData, dwDataLen, dwFlags); + } + + public bool CryptHashSessionKey([In] SafeHashHandleImpl hHash, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptHashSessionKey(hHash, hKey, dwFlags); + else + return LinuxVipNetNativeApi.CryptHashSessionKey(hHash, hKey, dwFlags); + } + + public bool CryptImportKey([In] SafeProvHandleImpl hCryptProv, [In] byte[] pbData, [In] uint dwDataLen, [In] SafeKeyHandleImpl hPubKey, [In] uint dwFlags, [In, Out] ref SafeKeyHandleImpl phKey) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptImportKey(hCryptProv, pbData, dwDataLen, hPubKey, dwFlags, ref phKey); + else + return LinuxVipNetNativeApi.CryptImportKey(hCryptProv, pbData, dwDataLen, hPubKey, dwFlags, ref phKey); + } + + public bool CryptImportPublicKeyInfo([In] SafeProvHandleImpl hCryptProv, [In] uint dwCertEncodingType, [In] /*CERT_PUBLIC_KEY_INFO*/ IntPtr pPublicKeyInfo, [Out][In] ref SafeKeyHandleImpl phKey) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptImportPublicKeyInfo(hCryptProv, dwCertEncodingType, pPublicKeyInfo, ref phKey); + else + return LinuxVipNetNativeApi.CryptImportPublicKeyInfo(hCryptProv, dwCertEncodingType, pPublicKeyInfo, ref phKey); + } + + public bool CryptReleaseContext(IntPtr hCryptProv, uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptReleaseContext(hCryptProv, dwFlags); + else + return LinuxVipNetNativeApi.CryptReleaseContext(hCryptProv, dwFlags); + } + + public bool CryptSetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In, Out] byte[] pbData, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptSetHashParam(hHash, dwParam, pbData, dwFlags); + else + return LinuxVipNetNativeApi.CryptSetHashParam(hHash, dwParam, pbData, dwFlags); + } + + public bool CryptSetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptSetKeyParam(hKey, dwParam, pbData, dwParam); + else + return LinuxVipNetNativeApi.CryptSetKeyParam(hKey, dwParam, pbData, dwParam); + } + + public bool CryptSetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] IntPtr pbData, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptSetProvParam(hProv, dwParam, pbData, dwFlags); + else + return LinuxVipNetNativeApi.CryptSetProvParam(hProv, dwParam, pbData, dwFlags); + } + + public bool CryptSetProvParam2(IntPtr hCryptProv, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CryptSetProvParam2(hCryptProv, dwParam, pbData, dwFlags); + else + return LinuxVipNetNativeApi.CryptSetProvParam2(hCryptProv, dwParam, pbData, dwFlags); + } + + public bool CryptSignHash([In] SafeHashHandleImpl hHash, [In] uint dwKeySpec, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags, [In, Out] byte[] pbSignature, ref uint pdwSigLen) + { + var sDecriptionPtr = MarshalStringBuilder(sDescription); + var result = _providerType.IsCryptoPro() ? + LinuxCryptoProNativeApi.CryptSignHash(hHash, dwKeySpec, sDecriptionPtr, dwFlags, pbSignature, ref pdwSigLen) : + LinuxVipNetNativeApi.CryptSignHash(hHash, dwKeySpec, sDecriptionPtr, dwFlags, pbSignature, ref pdwSigLen); + Marshal.FreeHGlobal(sDecriptionPtr); + return result; + } + + public bool CryptVerifySignature([In] SafeHashHandleImpl hHash, [In, Out] byte[] pbSignature, uint pdwSigLen, [In] SafeKeyHandleImpl hPubKey, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags) + { + var sDecriptionPtr = MarshalStringBuilder(sDescription); + var result = _providerType.IsCryptoPro() ? + LinuxCryptoProNativeApi.CryptVerifySignature(hHash, pbSignature, pdwSigLen, hPubKey, sDecriptionPtr, dwFlags) : + LinuxVipNetNativeApi.CryptVerifySignature(hHash, pbSignature, pdwSigLen, hPubKey, sDecriptionPtr, dwFlags); + Marshal.FreeHGlobal(sDecriptionPtr); + return result; + } + + public IntPtr CertCreateCertificateContext( + uint dwCertEncodingType, + byte[] pCertEncoded, + int cbCertEncoded) + { + if (_providerType.IsCryptoPro()) + return LinuxCryptoProNativeApi.CertCreateCertificateContext(dwCertEncodingType, pCertEncoded, cbCertEncoded); + else + return LinuxVipNetNativeApi.CertCreateCertificateContext(dwCertEncodingType, pCertEncoded, cbCertEncoded); + } + + private IntPtr MarshalString(string str) + { + if (str == null) return IntPtr.Zero; + str += '\0'; //add end of string + var buffer = Encoding.UTF32.GetBytes(str); + var result = Marshal.AllocHGlobal(buffer.Length); + Marshal.Copy(buffer, 0, result, buffer.Length); + return result; + } + + private IntPtr MarshalStringBuilder(StringBuilder builder) + { + if (builder == null) return IntPtr.Zero; //rigth now string builder in arguments always null + return MarshalString(builder.ToString()); + } + } +} diff --git a/Source/GostCryptography/Native/LinuxCryptoProNativeApi.cs b/Source/GostCryptography/Native/LinuxCryptoProNativeApi.cs new file mode 100644 index 0000000..bad5b2e --- /dev/null +++ b/Source/GostCryptography/Native/LinuxCryptoProNativeApi.cs @@ -0,0 +1,204 @@ +using System; +using System.Collections.Generic; +using System.Runtime.ConstrainedExecution; +using System.Runtime.InteropServices; +using System.Text; + +namespace GostCryptography.Native +{ + class LinuxCryptoProNativeApi + { + + #region Для работы с криптографическим провайдером + + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CertCloseStore(SafeStore hCertStore, uint dwFlags); + + [DllImport("libcapi20", CharSet = CharSet.Auto, SetLastError = true)] + public static extern IntPtr CertCreateCertificateContext( + uint dwCertEncodingType, + byte[] pCertEncoded, + int cbCertEncoded + ); + + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptImportPublicKeyInfo( + [In] SafeProvHandleImpl hCryptProv, + [In] uint dwCertEncodingType, + [In] IntPtr pSubjectPublicKeyInfo, + [Out][In] ref SafeKeyHandleImpl phKey + ); + + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CertGetCertificateContextProperty( + [In]IntPtr pCertContext, + [In]uint dwPropId, + [Out]IntPtr pvData, + [In][Out]ref uint pcbData); + + [DllImport("libcapi20", SetLastError = true)] + public static extern SafeStore CertOpenSystemStore( + SafeStore hCertStore, + [MarshalAs(UnmanagedType.LPStr)]string pszStoreName); + + [DllImport("libcapi20", SetLastError = true, CharSet = CharSet.Ansi)] + public static extern IntPtr CertOpenStore( + [In]uint lpszStoreProvider, + [In]uint dwEncodingType, + [In]IntPtr hCryptProv, //HCRYPTPROV_LEGACY + [In]int dwFlags, + [In]StringBuilder pvPara //const void* + ); + + [DllImport("libcapi20", SetLastError = true)] + public static extern IntPtr CertEnumCertificatesInStore( + [In]SafeStore hCertStore, + [In]IntPtr pPrevCertContext); + + [DllImport("libcapi20", SetLastError = true, CharSet = CharSet.Auto)] + public static extern uint CertGetNameString( + [In]IntPtr pCertContext, + uint dwType, + uint dvFlags, + IntPtr pvTypePara, + byte[] pszNameString, + uint cchNameString); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", CharSet = CharSet.Auto, SetLastError = true)] + public static extern bool CryptAcquireContext([In] [Out] ref SafeProvHandleImpl hProv, [In] IntPtr pszContainer, [In] IntPtr pszProvider, [In] uint dwProvType, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptReleaseContext(IntPtr hCryptProv, uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("libcapi20", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern bool CryptContextAddRef([In] IntPtr hProv, [In] byte[] pdwReserved, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", CharSet = CharSet.Unicode, SetLastError = true)] + public static extern bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint dwDataLen, [In] uint dwFlags); + + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.LPStr)] StringBuilder pbData, ref uint dwDataLen, uint dwFlags); + + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.U8)] long pbData, ref uint dwDataLen, uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptSetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] IntPtr pbData, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("libcapi20", EntryPoint = "CryptSetProvParam", SetLastError = true)] + public static extern bool CryptSetProvParam2(IntPtr hCryptProv, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); + + #endregion + + + #region Для работы с функцией хэширования криптографического провайдера + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptCreateHash([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags, [In] [Out] ref SafeHashHandleImpl phHash); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptDestroyHash(IntPtr pHashCtx); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptGetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptSetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptHashData([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbData, [In] uint dwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern unsafe bool CryptHashData([In] SafeHashHandleImpl hHash, byte* pbData, [In] uint dwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptHashSessionKey([In] SafeHashHandleImpl hHash, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags); + + #endregion + + + #region Для работы с функцией шифрования криптографического провайдера + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptDecrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptEncrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwBufLen); + + #endregion + + + #region Для работы с ключами криптографического провайдера + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptGenKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptGetUserKey([In] SafeProvHandleImpl hProv, [In] uint dwKeySpec, [In] [Out] ref SafeKeyHandleImpl phUserKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptDeriveKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeHashHandleImpl hBaseData, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptDuplicateKey([In] IntPtr hKey, [In] byte[] pdwReserved, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptDestroyKey(IntPtr pKeyCtx); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptGetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptSetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptExportKey([In] SafeKeyHandleImpl hKey, [In] SafeKeyHandleImpl hExpKey, [In] uint dwBlobType, [In] uint dwFlags, [Out] byte[] pbData, ref uint pdwDataLen); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", SetLastError = true)] + public static extern bool CryptImportKey([In] SafeProvHandleImpl hCryptProv, [In] byte[] pbData, [In] uint dwDataLen, [In] SafeKeyHandleImpl hPubKey, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + #endregion + + + #region Для работы с цифровой подписью + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern bool CryptSignHash([In] SafeHashHandleImpl hHash, [In] uint dwKeySpec, IntPtr sDescription, [In] uint dwFlags, [In] [Out] byte[] pbSignature, ref uint pdwSigLen); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("libcapi20", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern bool CryptVerifySignature([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbSignature, uint pdwSigLen, [In] SafeKeyHandleImpl hPubKey, IntPtr sDescription, [In] uint dwFlags); + + #endregion + } +} diff --git a/Source/GostCryptography/Native/LinuxVipNetNativeApi.cs b/Source/GostCryptography/Native/LinuxVipNetNativeApi.cs new file mode 100644 index 0000000..8dec694 --- /dev/null +++ b/Source/GostCryptography/Native/LinuxVipNetNativeApi.cs @@ -0,0 +1,198 @@ +using System; +using System.Collections.Generic; +using System.Runtime.ConstrainedExecution; +using System.Runtime.InteropServices; +using System.Text; + +namespace GostCryptography.Native +{ + class LinuxVipNetNativeApi + { + #region Для работы с криптографическим провайдером + + [DllImport("/opt/itcs/lib/libcrypt32.so", SetLastError = true, ThrowOnUnmappableChar = true, CharSet = CharSet.Unicode, EntryPoint = "CryptImportPublicKeyInfo", ExactSpelling = true)] + public static extern bool CryptImportPublicKeyInfo( + [In] SafeProvHandleImpl hCryptProv, + [In] uint dwCertEncodingType, + [In] IntPtr pSubjectPublicKeyInfo, + [Out][In] ref SafeKeyHandleImpl phKey + ); + + [DllImport("/opt/itcs/lib/libcrypt32.so", CharSet = CharSet.Auto, SetLastError = true)] + public static extern IntPtr CertCreateCertificateContext( + uint dwCertEncodingType, + byte[] pCertEncoded, + int cbCertEncoded + ); + + [DllImport("/opt/itcs/lib/libcrypt32.so", SetLastError = true)] + public static extern bool CertCloseStore(SafeStore hCertStore, uint dwFlags); + + [DllImport("/opt/itcs/lib/libcrypt32.so", SetLastError = true)] + public static extern bool CertGetCertificateContextProperty( + [In]IntPtr pCertContext, + [In]uint dwPropId, + [Out]IntPtr pvData, + [In][Out]ref uint pcbData); + + [DllImport("/opt/itcs/lib/libcrypt32.so", SetLastError = true)] + public static extern SafeStore CertOpenSystemStore( + SafeStore hCertStore, + string pszStoreName); + + [DllImport("/opt/itcs/lib/libcrypt32.so", SetLastError = true)] + public static extern IntPtr CertEnumCertificatesInStore( + [In]SafeStore hCertStore, + [In]IntPtr pPrevCertContext); + + [DllImport("/opt/itcs/lib/libcrypt32.so", SetLastError = true, CharSet = CharSet.Auto)] + public static extern uint CertGetNameString( + [In]IntPtr pCertContext, + uint dwType, + uint dvFlags, + IntPtr pvTypePara, + byte[] pszNameString, + uint cchNameString); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", CharSet = CharSet.Auto, SetLastError = true)] + public static extern bool CryptAcquireContext([In] [Out] ref SafeProvHandleImpl hProv, [In] IntPtr pszContainer, [In] IntPtr pszProvider, [In] uint dwProvType, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", CharSet = CharSet.Auto, SetLastError = true, EntryPoint = "CryptAcquireContextA")] + public static extern bool CryptAcquireContext([In] [Out] ref IntPtr hProv, [In] string pszContainer, [In] string pszProvider, [In] uint dwProvType, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptReleaseContext(IntPtr hCryptProv, uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("/opt/itcs/lib/libadvapi32.so", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern bool CryptContextAddRef([In] IntPtr hProv, [In] byte[] pdwReserved, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", CharSet = CharSet.Unicode, SetLastError = true)] + public static extern bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint dwDataLen, [In] uint dwFlags); + + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.LPStr)] StringBuilder pbData, ref uint dwDataLen, uint dwFlags); + + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.U8)] long pbData, ref uint dwDataLen, uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptSetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] IntPtr pbData, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("/opt/itcs/lib/libadvapi32.so", EntryPoint = "CryptSetProvParam", SetLastError = true)] + public static extern bool CryptSetProvParam2(IntPtr hCryptProv, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); + + #endregion + + + #region Для работы с функцией хэширования криптографического провайдера + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptCreateHash([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags, [In] [Out] ref SafeHashHandleImpl phHash); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptDestroyHash(IntPtr pHashCtx); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptGetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptSetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptHashData([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbData, [In] uint dwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern unsafe bool CryptHashData([In] SafeHashHandleImpl hHash, byte* pbData, [In] uint dwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptHashSessionKey([In] SafeHashHandleImpl hHash, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags); + + #endregion + + + #region Для работы с функцией шифрования криптографического провайдера + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptDecrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptEncrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwBufLen); + + #endregion + + + #region Для работы с ключами криптографического провайдера + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptGenKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptGetUserKey([In] SafeProvHandleImpl hProv, [In] uint dwKeySpec, [In] [Out] ref SafeKeyHandleImpl phUserKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptDeriveKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeHashHandleImpl hBaseData, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptDuplicateKey([In] IntPtr hKey, [In] byte[] pdwReserved, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptDestroyKey(IntPtr pKeyCtx); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptGetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptSetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptExportKey([In] SafeKeyHandleImpl hKey, [In] SafeKeyHandleImpl hExpKey, [In] uint dwBlobType, [In] uint dwFlags, [Out] byte[] pbData, ref uint pdwDataLen); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", SetLastError = true)] + public static extern bool CryptImportKey([In] SafeProvHandleImpl hCryptProv, [In] byte[] pbData, [In] uint dwDataLen, [In] SafeKeyHandleImpl hPubKey, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + #endregion + + + #region Для работы с цифровой подписью + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern bool CryptSignHash([In] SafeHashHandleImpl hHash, [In] uint dwKeySpec, IntPtr sDescription, [In] uint dwFlags, [In] [Out] byte[] pbSignature, ref uint pdwSigLen); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("/opt/itcs/lib/libadvapi32.so", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern bool CryptVerifySignature([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbSignature, uint pdwSigLen, [In] SafeKeyHandleImpl hPubKey, IntPtr sDescription, [In] uint dwFlags); + + #endregion + } +} diff --git a/Source/GostCryptography/Native/NativeApiFactory.cs b/Source/GostCryptography/Native/NativeApiFactory.cs new file mode 100644 index 0000000..b82ee89 --- /dev/null +++ b/Source/GostCryptography/Native/NativeApiFactory.cs @@ -0,0 +1,12 @@ +using GostCryptography.Base; +using System; +using System.Collections.Generic; +using System.Text; + +namespace GostCryptography.Native +{ + abstract class NativeApiFactory + { + public abstract INativeApi CreateApi(ProviderType provider); + } +} diff --git a/Source/GostCryptography/Native/SafeStore.cs b/Source/GostCryptography/Native/SafeStore.cs new file mode 100644 index 0000000..5df996c --- /dev/null +++ b/Source/GostCryptography/Native/SafeStore.cs @@ -0,0 +1,47 @@ +using Microsoft.Win32.SafeHandles; +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Security; +using System.Text; + +namespace GostCryptography.Native +{ + [SecurityCritical] + class SafeStore : SafeHandleZeroOrMinusOneIsInvalid + { + public static SafeStore InvalidHandle => new SafeStore(IntPtr.Zero); + + + public SafeStore() : base(true) + { + } + + public SafeStore(IntPtr handle) : base(true) + { + SetHandle(handle); + } + + + [SecurityCritical] + protected override bool ReleaseHandle() + { + + + return true; + } + + protected override void Dispose(bool disposing) + { + if (handle != IntPtr.Zero) + { + if (!CryptoApi.CertCloseStore(this, 0)) + { + var errCode = Marshal.GetLastWin32Error(); + throw new SystemException(errCode.ToString("x")); + } + } + base.Dispose(disposing); + } + } +} diff --git a/Source/GostCryptography/Native/WindowsApi.cs b/Source/GostCryptography/Native/WindowsApi.cs new file mode 100644 index 0000000..497770c --- /dev/null +++ b/Source/GostCryptography/Native/WindowsApi.cs @@ -0,0 +1,189 @@ +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Text; + +namespace GostCryptography.Native +{ + internal class WindowsApi : INativeApi + { + public bool CertCloseStore(SafeStore hCertStore, uint dwFlags) + { + return WindowsNativeApi.CertCloseStore(hCertStore, dwFlags); + } + + public IntPtr CertEnumCertificatesInStore([In] SafeStore hCertStore, [In] IntPtr pPrevCertContext) + { + return WindowsNativeApi.CertEnumCertificatesInStore(hCertStore, pPrevCertContext); + } + + public bool CertGetCertificateContextProperty([In] IntPtr pCertContext, [In] uint dwPropId, [Out] IntPtr pvData, [In, Out] ref uint pcbData) + { + return WindowsNativeApi.CertGetCertificateContextProperty(pCertContext, dwPropId, pvData, ref pcbData); + } + + public uint CertGetNameString([In] IntPtr pCertContext, uint dwType, uint dwFlags, IntPtr pvTypePara, byte[] pszNameString, uint cchNameString) + { + return WindowsNativeApi.CertGetNameString(pCertContext, dwType, dwFlags, pvTypePara, pszNameString, cchNameString); + } + + public SafeStore CertOpenSystemStore(SafeStore hCertStore, string pszStoreName) + { + return WindowsNativeApi.CertOpenSystemStore(hCertStore, pszStoreName); + } + + public bool CryptAcquireContext([In, Out] ref SafeProvHandleImpl hProv, [In] string pszContainer, [In] string pszProvider, [In] uint dwProvType, [In] uint dwFlags) + { + return WindowsNativeApi.CryptAcquireContext(ref hProv, pszContainer, pszProvider, dwProvType, dwFlags); + } + + public bool CryptContextAddRef([In] IntPtr hProv, [In] byte[] pdwReserved, [In] uint dwFlags) + { + return WindowsNativeApi.CryptContextAddRef(hProv, pdwReserved, dwFlags); + } + + public bool CryptCreateHash([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags, [In, Out] ref SafeHashHandleImpl phHash) + { + return WindowsNativeApi.CryptCreateHash(hProv, Algid, hKey, dwFlags, ref phHash); + } + + public bool CryptDecrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In, MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In, Out] byte[] pbData, ref uint pdwDataLen) + { + return WindowsNativeApi.CryptDecrypt(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen); + } + + public bool CryptDeriveKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeHashHandleImpl hBaseData, [In] uint dwFlags, [In, Out] ref SafeKeyHandleImpl phKey) + { + return WindowsNativeApi.CryptDeriveKey(hProv, Algid, hBaseData, dwFlags, ref phKey); + } + + public bool CryptDestroyHash(IntPtr pHashCtx) + { + return WindowsNativeApi.CryptDestroyHash(pHashCtx); + } + + public bool CryptDestroyKey(IntPtr pKeyCtx) + { + return WindowsNativeApi.CryptDestroyKey(pKeyCtx); + } + + public bool CryptDuplicateKey([In] IntPtr hKey, [In] byte[] pdwReserved, [In] uint dwFlags, [In, Out] ref SafeKeyHandleImpl phKey) + { + return WindowsNativeApi.CryptDuplicateKey(hKey, pdwReserved, dwFlags, ref phKey); + } + + public bool CryptEncrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In, MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In, Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwBufLen) + { + return WindowsNativeApi.CryptEncrypt(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen, dwBufLen); + } + + public bool CryptExportKey([In] SafeKeyHandleImpl hKey, [In] SafeKeyHandleImpl hExpKey, [In] uint dwBlobType, [In] uint dwFlags, [Out] byte[] pbData, ref uint pdwDataLen) + { + return WindowsNativeApi.CryptExportKey(hKey, hExpKey, dwBlobType, dwFlags, pbData, ref pdwDataLen); + } + + public bool CryptGenKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] uint dwFlags, [In, Out] ref SafeKeyHandleImpl phKey) + { + return WindowsNativeApi.CryptGenKey(hProv, Algid, dwFlags, ref phKey); + } + + public bool CryptGetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In, Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags) + { + return WindowsNativeApi.CryptGetHashParam(hHash, dwParam, pbData, ref pdwDataLen, dwFlags); + } + + public bool CryptGetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In, Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags) + { + return WindowsNativeApi.CryptGetKeyParam(hKey, dwParam, pbData, ref pdwDataLen, dwFlags); + } + + public bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In, Out] byte[] pbData, ref uint dwDataLen, [In] uint dwFlags) + { + return WindowsNativeApi.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + } + + public bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.LPStr)] StringBuilder pbData, ref uint dwDataLen, uint dwFlags) + { + return WindowsNativeApi.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + } + + public bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.U8)] long pbData, ref uint dwDataLen, uint dwFlags) + { + return WindowsNativeApi.CryptGetProvParam(hProv, dwParam, pbData, ref dwDataLen, dwFlags); + } + + public bool CryptGetUserKey([In] SafeProvHandleImpl hProv, [In] uint dwKeySpec, [In, Out] ref SafeKeyHandleImpl phUserKey) + { + return WindowsNativeApi.CryptGetUserKey(hProv, dwKeySpec, ref phUserKey); + } + + public bool CryptHashData([In] SafeHashHandleImpl hHash, [In, Out] byte[] pbData, [In] uint dwDataLen, [In] uint dwFlags) + { + return WindowsNativeApi.CryptHashData(hHash, pbData, dwDataLen, dwFlags); + } + + public unsafe bool CryptHashData([In] SafeHashHandleImpl hHash, byte* pbData, [In] uint dwDataLen, [In] uint dwFlags) + { + return WindowsNativeApi.CryptHashData(hHash, pbData, dwDataLen, dwFlags); + } + + public bool CryptHashSessionKey([In] SafeHashHandleImpl hHash, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags) + { + return WindowsNativeApi.CryptHashSessionKey(hHash, hKey, dwFlags); + } + + public bool CryptImportKey([In] SafeProvHandleImpl hCryptProv, [In] byte[] pbData, [In] uint dwDataLen, [In] SafeKeyHandleImpl hPubKey, [In] uint dwFlags, [In, Out] ref SafeKeyHandleImpl phKey) + { + return WindowsNativeApi.CryptImportKey(hCryptProv, pbData, dwDataLen, hPubKey, dwFlags, ref phKey); + } + + public bool CryptImportPublicKeyInfo([In] SafeProvHandleImpl hCryptProv, [In] uint dwCertEncodingType, [In] /*CERT_PUBLIC_KEY_INFO*/ IntPtr pSubjectPublicKeyInfo, [Out][In] ref SafeKeyHandleImpl phKey) + { + return WindowsNativeApi.CryptImportPublicKeyInfo(hCryptProv, dwCertEncodingType, pSubjectPublicKeyInfo, ref phKey); + } + + public bool CryptReleaseContext(IntPtr hCryptProv, uint dwFlags) + { + return WindowsNativeApi.CryptReleaseContext(hCryptProv, dwFlags); + } + + public bool CryptSetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In, Out] byte[] pbData, [In] uint dwFlags) + { + return WindowsNativeApi.CryptSetHashParam(hHash, dwParam, pbData, dwFlags); + } + + public bool CryptSetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags) + { + return WindowsNativeApi.CryptSetKeyParam(hKey, dwParam, pbData, dwParam); + } + + public bool CryptSetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] IntPtr pbData, [In] uint dwFlags) + { + return WindowsNativeApi.CryptSetProvParam(hProv, dwParam, pbData, dwFlags); + } + + public bool CryptSetProvParam2(IntPtr hCryptProv, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags) + { + return WindowsNativeApi.CryptSetProvParam2(hCryptProv, dwParam, pbData, dwFlags); + } + + public bool CryptSignHash([In] SafeHashHandleImpl hHash, [In] uint dwKeySpec, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags, [In, Out] byte[] pbSignature, ref uint pdwSigLen) + { + return WindowsNativeApi.CryptSignHash(hHash, dwKeySpec, sDescription, dwFlags, pbSignature, ref pdwSigLen); + } + + public bool CryptVerifySignature([In] SafeHashHandleImpl hHash, [In, Out] byte[] pbSignature, uint pdwSigLen, [In] SafeKeyHandleImpl hPubKey, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags) + { + return WindowsNativeApi.CryptVerifySignature(hHash, pbSignature, pdwSigLen, hPubKey, sDescription, dwFlags); + } + + public IntPtr CertCreateCertificateContext( + uint dwCertEncodingType, + byte[] pCertEncoded, + int cbCertEncoded + ) + { + return WindowsNativeApi.CertCreateCertificateContext(dwCertEncodingType, pCertEncoded, cbCertEncoded); + } + } +} diff --git a/Source/GostCryptography/Native/WindowsNativeApi.cs b/Source/GostCryptography/Native/WindowsNativeApi.cs new file mode 100644 index 0000000..41fc20e --- /dev/null +++ b/Source/GostCryptography/Native/WindowsNativeApi.cs @@ -0,0 +1,198 @@ +using System; +using System.Collections.Generic; +using System.Runtime.ConstrainedExecution; +using System.Runtime.InteropServices; +using System.Text; + +namespace GostCryptography.Native +{ + class WindowsNativeApi + { + #region Для работы с криптографическим провайдером + + [DllImport("CRYPT32.DLL", SetLastError = true, ThrowOnUnmappableChar = true, CharSet = CharSet.Unicode, EntryPoint = "CryptImportPublicKeyInfo", ExactSpelling = true)] + public static extern bool CryptImportPublicKeyInfo( + [In] SafeProvHandleImpl hCryptProv, + [In] uint dwCertEncodingType, + [In] IntPtr pSubjectPublicKeyInfo, + [Out][In] ref SafeKeyHandleImpl phKey + ); + + [DllImport("CRYPT32.DLL", SetLastError = true)] + public static extern bool CertCloseStore(SafeStore hCertStore, uint dwFlags); + + [DllImport("CRYPT32.DLL", SetLastError = true)] + public static extern bool CertGetCertificateContextProperty( + [In]IntPtr pCertContext, + [In]uint dwPropId, + [Out]IntPtr pvData, + [In][Out]ref uint pcbData); + + [DllImport("CRYPT32.DLL", SetLastError = true)] + public static extern SafeStore CertOpenSystemStore( + SafeStore hCertStore, + string pszStoreName); + + [DllImport("CRYPT32.DLL", SetLastError = true)] + public static extern IntPtr CertEnumCertificatesInStore( + [In]SafeStore hCertStore, + [In]IntPtr pPrevCertContext); + + [DllImport("CRYPT32.DLL", SetLastError = true, CharSet = CharSet.Auto)] + public static extern uint CertGetNameString( + [In]IntPtr pCertContext, + uint dwType, + uint dvFlags, + IntPtr pvTypePara, + byte[] pszNameString, + uint cchNameString); + + [DllImport("Crypt32.dll", CharSet = CharSet.Auto, SetLastError = true)] + public static extern IntPtr CertCreateCertificateContext( + uint dwCertEncodingType, + byte[] pCertEncoded, + int cbCertEncoded + ); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)] + public static extern bool CryptAcquireContext([In] [Out] ref SafeProvHandleImpl hProv, [In] string pszContainer, [In] string pszProvider, [In] uint dwProvType, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true, EntryPoint = "CryptAcquireContextA")] + public static extern bool CryptAcquireContext([In] [Out] ref IntPtr hProv, [In] string pszContainer, [In] string pszProvider, [In] uint dwProvType, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptReleaseContext(IntPtr hCryptProv, uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("advapi32.dll", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern bool CryptContextAddRef([In] IntPtr hProv, [In] byte[] pdwReserved, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + public static extern bool CryptGetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint dwDataLen, [In] uint dwFlags); + + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.LPStr)] StringBuilder pbData, ref uint dwDataLen, uint dwFlags); + + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptGetProvParam([In]SafeProvHandleImpl hProv, [In] uint dwParam, [MarshalAs(UnmanagedType.U8)] long pbData, ref uint dwDataLen, uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptSetProvParam([In] SafeProvHandleImpl hProv, [In] uint dwParam, [In] IntPtr pbData, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("advapi32.dll", EntryPoint = "CryptSetProvParam", SetLastError = true)] + public static extern bool CryptSetProvParam2(IntPtr hCryptProv, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); + + #endregion + + + #region Для работы с функцией хэширования криптографического провайдера + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptCreateHash([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags, [In] [Out] ref SafeHashHandleImpl phHash); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptDestroyHash(IntPtr pHashCtx); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptGetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptSetHashParam([In] SafeHashHandleImpl hHash, [In] uint dwParam, [In] [Out] byte[] pbData, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptHashData([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbData, [In] uint dwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern unsafe bool CryptHashData([In] SafeHashHandleImpl hHash, byte* pbData, [In] uint dwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptHashSessionKey([In] SafeHashHandleImpl hHash, [In] SafeKeyHandleImpl hKey, [In] uint dwFlags); + + #endregion + + + #region Для работы с функцией шифрования криптографического провайдера + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptDecrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptEncrypt([In] SafeKeyHandleImpl hKey, [In] SafeHashHandleImpl hHash, [In] [MarshalAs(UnmanagedType.Bool)] bool Final, [In] uint dwFlags, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwBufLen); + + #endregion + + + #region Для работы с ключами криптографического провайдера + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptGenKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptGetUserKey([In] SafeProvHandleImpl hProv, [In] uint dwKeySpec, [In] [Out] ref SafeKeyHandleImpl phUserKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptDeriveKey([In] SafeProvHandleImpl hProv, [In] uint Algid, [In] SafeHashHandleImpl hBaseData, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptDuplicateKey([In] IntPtr hKey, [In] byte[] pdwReserved, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + [return: MarshalAs(UnmanagedType.Bool)] + [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptDestroyKey(IntPtr pKeyCtx); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptGetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] [Out] byte[] pbData, ref uint pdwDataLen, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptSetKeyParam([In] SafeKeyHandleImpl hKey, [In] uint dwParam, [In] byte[] pbData, [In] uint dwFlags); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptExportKey([In] SafeKeyHandleImpl hKey, [In] SafeKeyHandleImpl hExpKey, [In] uint dwBlobType, [In] uint dwFlags, [Out] byte[] pbData, ref uint pdwDataLen); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", SetLastError = true)] + public static extern bool CryptImportKey([In] SafeProvHandleImpl hCryptProv, [In] byte[] pbData, [In] uint dwDataLen, [In] SafeKeyHandleImpl hPubKey, [In] uint dwFlags, [In] [Out] ref SafeKeyHandleImpl phKey); + + #endregion + + + #region Для работы с цифровой подписью + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern bool CryptSignHash([In] SafeHashHandleImpl hHash, [In] uint dwKeySpec, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags, [In] [Out] byte[] pbSignature, ref uint pdwSigLen); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("advapi32.dll", CharSet = CharSet.Ansi, SetLastError = true)] + public static extern bool CryptVerifySignature([In] SafeHashHandleImpl hHash, [In] [Out] byte[] pbSignature, uint pdwSigLen, [In] SafeKeyHandleImpl hPubKey, [MarshalAs(UnmanagedType.LPStr)] StringBuilder sDescription, [In] uint dwFlags); + + #endregion + } +}