Dans un article précédent, le processus d'intégration des certificats GOST de CryptoPro avec mono a été décrit. De même, nous nous attardons sur la connexion des certificats RSA.
Nous avons continué à porter l'un de nos systèmes serveurs écrits en C # vers Linux, et la file d'attente a atteint la partie liée à RSA. Si la dernière fois les difficultés de connexion s'expliquaient facilement par l'interaction de deux systèmes qui n'étaient pas initialement connectés l'un à l'autre, alors lors de la connexion de certificats RSA «ordinaires» à partir de mono, personne ne s'attendait à une capture.
L'installation du certificat et de la clé n'a pas posé de problème et le système l'a même vu dans le stockage standard. Cependant, il n'était plus possible de signer, de crypter ou d'extraire des données à partir d'une signature précédemment générée - mono est tombé de manière stable avec une erreur. Je devais, comme dans le cas de CryptoPro, me connecter directement à la bibliothèque de cryptage. Pour les certificats RSA sous Linux, le principal candidat pour une telle connexion est OpenSSL.
Installation de certificat
Heureusement, Centos 7 dispose d'une version intégrée d'OpenSSL - 1.0.2k. Afin de ne pas introduire de difficultés supplémentaires dans le système, nous avons décidé de nous connecter à cette version. OpenSSL vous permet de créer des magasins de certificats de fichiers spéciaux, cependant:
- un tel magasin contient des certificats et des listes de révocation de certificats, et non des clés privées, dans ce cas, ils devront être stockés séparément;
- le stockage de certificats et de clés privées dans Windows sur un disque sous une forme non sécurisée est «extrêmement précaire» (les responsables de la sécurité numérique le décrivent généralement de manière plus efficace et moins censurée), pour être honnête, ce n'est pas très sûr sous Linux, mais, en fait, c'est courant la pratique;
- la coordination de l'emplacement de ces référentiels sous Windows et Linux est assez problématique;
- en cas de mise en œuvre manuelle du stockage, un utilitaire sera nécessaire pour gérer l'ensemble des certificats;
- mono utilise lui-même le stockage sur disque avec une structure OpenSSL, et stocke également les clés privées sous une forme ouverte à proximité;
Pour ces raisons, nous utiliserons les magasins de certificats standard .Net et mono pour connecter OpenSSL. Pour ce faire, sous Linux, le certificat et la clé privée doivent d'abord être placés dans le référentiel mono.
Installation de certificatPour cela, nous utiliserons l'utilitaire standard certmgr. Tout d'abord, installez la clé privée de pfx:
certmgr -importKey -c -p {password} My {pfx file}
Ensuite, nous mettons le certificat de ce pfx, la clé privée s'y connectera automatiquement:
certmgr -add -c My {cer file}
Si vous souhaitez installer la clé dans le stockage de la machine, vous devez ajouter l'option -m.
Après quoi le certificat peut être vu dans le référentiel:
certmgr -list -c -v My
Faites attention à l'émission. Il convient de noter que le certificat est visible par le système et est lié à la clé privée téléchargée précédemment. Après cela, vous pouvez procéder à la connexion dans le code.
Connexion en code
Tout comme la dernière fois, le système, malgré son portage sur Linux, aurait dû continuer à fonctionner dans l'environnement Windows. Par conséquent, extérieurement, le travail avec la cryptographie devrait être effectué à l'aide de méthodes générales de la forme «octet [] SignData (octet [] _arData, X509Certificate2 _pCert)», qui devraient fonctionner de la même manière sous Linux et Windows.
Idéalement, il devrait y avoir des méthodes qui fonctionnent comme sous Windows - quel que soit le type de certificat (sous Linux via OpenSSL ou CryptoPro selon le certificat, et sous Windows via crypt32).
L'analyse des bibliothèques OpenSSL a montré que sous Windows, la bibliothèque principale est «libeay32.dll» et sous Linux «libcrypto.so.10». Ainsi que la dernière fois, nous formons deux classes WOpenSSLAPI et LOpenSSLAPI, contenant une liste de méthodes de bibliothèque de bibliothèque:
[DllImport(CTRYPTLIB, CharSet = CharSet.Auto, SetLastError = true, CallingConvention = CallingConvention.Cdecl)] internal static extern void OPENSSL_init();
Faites attention à la convention d'appel, contrairement à CryptoPro - ici, elle doit être explicitement spécifiée. La syntaxe de connexion de chacune des méthodes devra cette fois être générée indépendamment sur la base des fichiers source * .h OpenSSL.
Les règles de base pour générer la syntaxe d'appel en C # à partir des données des fichiers .h sont les suivantes:
- tout lien vers des structures, chaînes, etc. - IntPtr, y compris les liens au sein des structures elles-mêmes;
- liens vers des liens - réf IntPtr, si cette option ne fonctionne pas, alors juste IntPtr. Dans ce cas, le lien lui-même devra être mis et supprimé manuellement;
- tableaux - octet [];
- long en C (OpenSSL) est un int en C # (une petite erreur, à première vue, peut se transformer en heures de recherche de la source d'erreurs imprévisibles);
Dans la déclaration, par habitude, vous pouvez spécifier SetLastError = true, mais la bibliothèque l'ignorera - les erreurs ne seront pas disponibles via Marshal.GetLastWin32Error (). OpenSSL a ses propres méthodes pour accéder aux erreurs.
Et puis nous formons la classe statique déjà familière "UOpenSSLAPI" qui, selon le système, appellera la méthode de l'une des deux classes:
private static object fpOSSection = new object(); public static void OPENSSL_init() { lock (pOSSection) { if (fIsLinux) LOpenSSLAPI.OPENSSL_init(); else WOpenSSLAPI.OPENSSL_init(); } } public static object pOSSection { get { return fpOSSection; } } public static bool fIsLinux { get { int iPlatform = (int) Environment.OSVersion.Platform; return (iPlatform == 4) || (iPlatform == 6) || (iPlatform == 128); } }
Aussitôt, on note la présence d'une section critique. OpenSSL fournit théoriquement du travail dans un environnement multi-thread. Mais, tout d'abord, immédiatement dans la description, il est dit que cela n'est pas garanti:
Mais vous ne pouvez toujours pas utiliser simultanément la plupart des objets dans plusieurs threads.
Et deuxièmement, la méthode de connexion n'est pas la plus triviale. La machine virtuelle à deux cœurs habituelle (un serveur avec un processeur Intel Xeon E5649 en mode Hyper-Threading) lors de l'utilisation d'une telle section critique donne environ 100 cycles complets (voir l'algorithme de test de l' article précédent) ou 600 signatures par seconde, ce qui est fondamentalement suffisant pour la plupart des tâches ( sous de lourdes charges, le microservice ou l'architecture nodale du système sera quand même utilisé).
Initialisation et déchargement d'OpenSSL
Contrairement à CryptoPro, OpenSSL nécessite certaines actions avant de commencer à l'utiliser et après avoir fini de travailler avec la bibliothèque:
public static void InitOpenSSL() { UOpenSSLAPI.OPENSSL_init(); UOpenSSLAPI.ERR_load_crypto_strings(); UOpenSSLAPI.ERR_load_RSA_strings(); UOpenSSLAPI.OPENSSL_add_all_algorithms_conf(); UOpenSSLAPI.OpenSSL_add_all_ciphers(); UOpenSSLAPI.OpenSSL_add_all_digests(); } public static void CleanupOpenSSL() { UOpenSSLAPI.EVP_cleanup(); UOpenSSLAPI.CRYPTO_cleanup_all_ex_data(); UOpenSSLAPI.ERR_free_strings(); }
Informations sur l'erreur
OpenSSL stocke les informations d'erreur dans les structures internes pour lesquelles il existe des méthodes spéciales dans la bibliothèque. Malheureusement, certaines des méthodes simples, telles que ERR_error_string, sont instables, vous devez donc utiliser des méthodes plus complexes:
Obtention d'informations sur les erreurs public static string GetErrStrPart(ulong _iErr, int _iPart) {
Une erreur dans OpenSSL contient des informations sur la bibliothèque dans laquelle elle s'est produite, la méthode et la raison. Par conséquent, après avoir reçu le code d'erreur lui-même, il est nécessaire d'extraire ces trois parties séparément et de les rassembler dans une ligne de texte. La longueur de chaque ligne, selon la documentation OpenSSL , ne dépasse pas 120 caractères, et comme nous utilisons du code managé, nous devons soigneusement extraire la ligne du lien:
Obtention d'une chaîne par IntPtr public static string PtrToFirstStr(IntPtr _hPtr, int _iLen = 256) { if(_hPtr == IntPtr.Zero) return ""; try { byte[] arStr = new byte[_iLen]; Marshal.Copy(_hPtr, arStr, 0, arStr.Length); string[] arRes = Encoding.ASCII.GetString(arStr).Split(new char[] { (char)0 }, StringSplitOptions.RemoveEmptyEntries); if (arRes.Length > 0) return arRes[0]; return ""; }catch { return ""; } }
Les erreurs lors de la vérification des certificats ne font pas partie de la liste générale et doivent être extraites par une méthode distincte, selon le contexte de vérification:
Recevoir une erreur de vérification de certificat public static string GetCertVerifyErr(IntPtr _hStoreCtx) { int iErr = UOpenSSLAPI.X509_STORE_CTX_get_error(_hStoreCtx); return PtrToFirstStr(UOpenSSLAPI.X509_verify_cert_error_string(iErr)); }
Recherche de certificat
Comme toujours, la cryptographie commence par une recherche de certificat. Nous utilisons un stockage à temps plein, nous allons donc rechercher en utilisant des méthodes régulières:
Recherche de certificat internal static int FindCertificateOS(string _pFindValue, out X509Certificate2 _pCert, ref string _sError, StoreLocation _pLocation = StoreLocation.CurrentUser, StoreName _pName = StoreName.My, X509FindType _pFindType = X509FindType.FindByThumbprint, bool _fVerify = false) { lock (UOpenSSLAPI.pOSSection) {
Faites attention à la section critique. Mono avec certificats fonctionne également via OpenSSL, mais pas via UOpenSSLAPI. Si vous ne le faites pas ici, vous pouvez obtenir des fuites de mémoire et des erreurs flottantes incompréhensibles sous charge.
La principale caractéristique est la création d'un certificat. Contrairement à la version pour CryptoPro, dans ce cas, nous obtenons le certificat lui-même (X509Certificate2) à partir du magasin, et le lien dans Handle est déjà dirigé vers la structure OpenSSL X509_st. Il semblerait que cela soit nécessaire, mais il n'y a pas de pointeur vers EVP_PKEY (lien vers la structure de clé privée dans OpenSSL) dans le certificat.
Il s'est avéré que la clé privée elle-même est stockée en clair dans le champ interne du certificat - impl / fallback / _cert / _rsa / rsa. Il s'agit de la classe RSAManaged, et un rapide coup d'œil à son code (par exemple, la méthode DecryptValue ) montre à quel point le mono est mauvais avec la cryptographie. Au lieu d'utiliser honnêtement les techniques de cryptographie OpenSSL, ils semblent avoir implémenté plusieurs algorithmes manuellement. Cette hypothèse est supportée par un résultat de recherche vide pour leur projet de méthodes OpenSSL telles que CMS_final, CMS_sign ou CMS_ContentInfo_new. Et sans eux, il est difficile d'imaginer la formation d'une structure de signature CMS standard. Dans le même temps, le travail avec les certificats est partiellement effectué via OpenSSL.
Cela signifie que la clé privée devra être déchargée de mono et chargée dans EVP_PKEY via pem. Pour cette raison, nous avons à nouveau besoin de l'héritier de classe de X509Certificate, qui stockera tous les liens supplémentaires.
Voici quelques tentatives, comme dans le cas de CryptoPro pour créer un nouveau certificat à partir de Handle - ne mènent pas non plus au succès (les plantages mono avec une erreur), et la création sur la base du certificat reçu entraîne des fuites de mémoire. Par conséquent, la seule option consiste à créer un certificat basé sur un tableau d'octets contenant pem. Le certificat PEM peut être obtenu comme suit:
Obtention d'un certificat PEM public static int ToCerFile(this X509Certificate2 _pCert, out byte[] _arData, ref string _sError, bool _fBase64 = true) { _arData = new byte[0]; try { byte[] arData = _pCert.Export(X509ContentType.Cert);
Le certificat est obtenu sans clé privée et nous le connectons nous-mêmes, formant un champ séparé pour un lien vers ENV_PKEY:
Génération d'ENV_PKEY basée sur la clé privée PEM internal static IntPtr GetENV_PKEYOS(byte[] _arData) { IntPtr hBIOPem = IntPtr.Zero; try {
En téléchargeant la clé privée dans PEM, la tâche est beaucoup plus compliquée que le certificat PEM, mais elle est déjà décrite ici . Notez que le déchargement de la clé privée est une activité «extrêmement dangereuse», et cela doit être évité de toutes les manières. Et comme un tel déchargement est nécessaire pour travailler avec OpenSSL, dans Windows, il est préférable d'utiliser les méthodes crypt32.dll ou les classes .Net normales lors de l'utilisation de cette bibliothèque. Sous Linux, pour l'instant, vous devez travailler comme ça.
Il convient également de rappeler que les liens générés indiquent une zone de mémoire non gérée et doivent être libérés. Parce que dans .Net 4.5 X509Certificate2 n'est pas jetable, vous devez le faire dans le destructeur
Signature
Pour signer OpenSSL, vous pouvez utiliser la méthode CMS_sign simplifiée, cependant, elle s'appuie sur un fichier de configuration pour choisir un algorithme, qui sera le même pour tous les certificats. Par conséquent, il est préférable de s'appuyer sur le code de cette méthode pour implémenter une génération de signature similaire:
Signature des données internal static int SignDataOS(byte[] _arData, X509Certificate2 _pCert, out byte[] _arRes, ref string _sError) { _arRes = new byte[0]; uint iFlags = UCConsts.CMS_DETACHED; IntPtr hData = IntPtr.Zero; IntPtr hBIORes = IntPtr.Zero; IntPtr hCMS = IntPtr.Zero; try {
La progression de l'algorithme est la suivante. Tout d'abord, convertissez le certificat entrant (s'il s'agit de X509Certificate2) en notre type. Parce que Puisque nous travaillons avec des liens vers une zone de mémoire non gérée, nous devons les surveiller attentivement. .Net quelque temps après que le lien vers le certificat soit hors de portée, il lancera le destructeur. Et nous y avons déjà prescrit précisément les méthodes nécessaires pour effacer toute la mémoire non gérée qui lui est associée. Cette approche nous permet de ne pas perdre de temps à suivre ces liens directement à l'intérieur de la méthode.
Après avoir traité le certificat, nous formons un BIO avec des données et une structure de signature. Ensuite, nous ajoutons les données du signataire, définissons le drapeau pour déconnecter la signature et commençons la formation finale de la signature. Le résultat est transféré à BIO. Il ne reste plus qu'à extraire un tableau d'octets du BIO. La conversion de BIO en un ensemble d'octets et vice versa est souvent utilisée, il est donc préférable de les placer dans une méthode distincte:
BIO en octet [] et vice versa internal static int ReadFromBIO_OS(IntPtr _hBIO, out byte[] _arRes, ref string _sError, uint _iLen = 0) { _arRes = new byte[0]; IntPtr hRes = IntPtr.Zero; uint iLen = _iLen; if(iLen == 0) iLen = int.MaxValue; try {
Comme dans le cas de CryptoPro, il est nécessaire d'extraire des informations sur l'algorithme de hachage de signature du certificat. Mais dans le cas d'OpenSSL, il est stocké directement dans le certificat:
Récupération d'un algorithme de hachage public static IntPtr GetDigestAlgOS(IntPtr _hCert) { x509_st pCert = (x509_st)Marshal.PtrToStructure(_hCert, typeof(x509_st)); X509_algor_st pAlgInfo = (X509_algor_st)Marshal.PtrToStructure(pCert.sig_alg, typeof(X509_algor_st)); IntPtr hAlgSn = UOpenSSLAPI.OBJ_nid2sn(UOpenSSLAPI.OBJ_obj2nid(pAlgInfo.algorithm)); return UOpenSSLAPI.EVP_get_digestbyname(hAlgSn); }
La méthode s'est avérée assez délicate, mais elle fonctionne. Vous pouvez trouver la méthode EVP_get_digestbynid dans la documentation 1.0.2, mais les bibliothèques de la version que nous utilisons ne l'exportent pas. Par conséquent, nous formons d'abord nid, et sur sa base un nom court. Et déjà par un nom court, vous pouvez extraire l'algorithme de la manière habituelle de recherche par nom.
Vérification de signature
La signature reçue doit être vérifiée. OpenSSL vérifie la signature comme suit:
Vérification de signature internal static int CheckSignOS(byte[] _arData, byte[] _arSign, out X509Certificate2 _pCert, ref string _sError, bool _fVerifyOnlySign = true, StoreLocation _pLocation = StoreLocation.CurrentUser){ _pCert = null; IntPtr hBIOData = IntPtr.Zero; IntPtr hCMS = IntPtr.Zero; IntPtr hTrStore = IntPtr.Zero; try {
Tout d'abord, les données de signature sont converties du tableau d'octets dans la structure CMS:
Formation de la structure CMS internal static int GetCMSFromBytesOS(byte[] _arData, out IntPtr _hCMS, ref string _sError) { _hCMS = IntPtr.Zero; IntPtr hBIOCMS = IntPtr.Zero; IntPtr hCMS = IntPtr.Zero; try {
, BIO. , , ( ) :
internal static int GetTrustStoreOS(StoreLocation _pLocation, out IntPtr _hStore, ref string _sError) { _hStore = IntPtr.Zero; IntPtr hStore = IntPtr.Zero; try { List<X509Certificate2> pCerts = GetCertList(_pLocation, StoreName.Root, TCryptoPath.cpOpenSSL); pCerts.AddRange(GetCertList(_pLocation, StoreName.AuthRoot, TCryptoPath.cpOpenSSL));
, ( , ). CMS_Verify, .
(, CRL), iFlag .
. , , . .Net — SignedCms, .
( , ) . — , .
internal int DecodeOS(byte[] _arSign, byte[] _arContent, ref string _sError) { IntPtr hBIOData = IntPtr.Zero; IntPtr hCMS = IntPtr.Zero; IntPtr hCerts = IntPtr.Zero; try {
, BIO ( ) CMS, . , — .
(STACK_OF(X509)), sk_pop, . , sk_value.
, CMS_get0_signers CMS_get1_certs. , . , , :
CRYPTO_add(&cch->d.certificate->references, 1, CRYPTO_LOCK_X509)
1.1.0 X509_up_ref, .
:
public int DecodeOS(IntPtr _hSignerInfo, ref string _sError) { try {
, , . ASN.1. asn1_string_st Pkcs9SigningTime.
:
internal static int GetSignerInfoCertOS(IntPtr _hSignerInfo, X509Certificate2Collection _pCerts, out X509Certificate2 _pCert, ref string _sError) { _pCert = null; try {
, . asn1_string_st, hex :
hex ANS.1 internal static int GetBinaryHexFromASNOS(IntPtr _hASN, out string _sHexData, ref string _sError) { _sHexData = ""; try { asn1_string_st pSerial = (asn1_string_st)Marshal.PtrToStructure(_hASN, typeof(asn1_string_st)); byte[] arStr = new byte[pSerial.iLength]; Marshal.Copy(pSerial.hData, arStr, 0, (int)pSerial.iLength); _sHexData = arStr.ToHex().ToUpper(); return UConsts.S_OK; } catch (Exception E) { _sError = UCConsts.S_HEX_ASN_BINARY_ERR.Frm(E.Message); return UConsts.E_GEN_EXCEPTION; } }
, , .
OpenSSL :
internal static int EncryptDataOS(byte[] _arInput, List<X509Certificate2> _pReceipients, out byte[] _arRes, ref string _sError) { _arRes = new byte[0]; uint iFlags = UCConsts.CMS_BINARY; IntPtr hData = IntPtr.Zero; IntPtr hReceipts = IntPtr.Zero; IntPtr hBIORes = IntPtr.Zero; IntPtr hCMS = IntPtr.Zero; try {
BIO — . . , BIO . OpenSSL , , , . EVP_des_ede3_cbc, .
, . . OpenSSL:
public static int GetCertsStackOS(List<X509Certificate2> _pCerts, out IntPtr _hStack, ref string _sError) { _hStack = IntPtr.Zero; IntPtr hStack = IntPtr.Zero; try { hStack = UOpenSSLAPI.sk_new_null(); foreach (X509Certificate2 pCert in _pCerts) {
, . :
- , ;
- ;
- ;
- ;
- BIO ;
internal static int DecryptDataOS(byte[] _arInput, out X509Certificate2 _pCert, out byte[] _arRes, ref string _sError, StoreLocation _pLocation = StoreLocation.CurrentUser ) { _arRes = new byte[0]; _pCert = null; uint iFlag = UCConsts.CMS_BINARY; IntPtr hBIORes = IntPtr.Zero; IntPtr hCMS = IntPtr.Zero; X509Certificate2 pCert; try {
. , CMS_RecipientInfo_set0_pkey, CMS, .
, , . , . :
internal static int GetRecepInfoCertOS(IntPtr _hRecep, StoreLocation _pLocation, out X509Certificate2 _pCert, ref string _sError) { _pCert = null; try {
CMS_RecipientInfo_ktri_get0_signer_id , hSNO . .
C , , . ktri — . OpenSSL : CMS_RecipientInfo_kari_*, CMS_RecipientInfo_kekri_* CMS_RecipientInfo_set0_password pwri.
, . . , . . . OpenSSL . ( ), , .
, , , :
internal static int VerifyCertificateOS(IntPtr _hCert, X509RevocationMode _iRevMode, X509RevocationFlag _iRevFlag, StoreLocation _pLocation, DateTime _rOnDate, ref string _sError) { IntPtr hStore = IntPtr.Zero; IntPtr hStoreCtx = IntPtr.Zero; try {
(X509_STORE_CTX) . :
public static void SetStoreCtxCheckDate(IntPtr _hStoreCtx, DateTime _rDate) { uint iFlags = UCConsts.X509_V_FLAG_USE_CHECK_TIME | UCConsts.X509_V_FLAG_X509_STRICT | UCConsts.X509_V_FLAG_CRL_CHECK_ALL;
, .
Conclusion
, . X509Certificate2 (mono) . .
, Windows . . Linux , , .
CSP 5.0 , RSA . , , , RSA, , .
Les références
- OpenSSL 1.0.2 ManPages ;
- OpenSSL 1 2 ;
- OpenSSL :
- cms_smime.c;
- Wiki OpenSSL ;
- mono:
- RSAManaged ;