Dans le cadre de la transition vers Linux, il est devenu nécessaire de porter l'un de nos systèmes serveurs écrits en C # vers Mono. Le système fonctionne avec des signatures numériques améliorées, donc l'une des tâches auxquelles nous avons été confrontés était de vérifier les performances des certificats GOST de CryptoPro en mono. CryptoPro lui-même a implémenté CSP pour Linux depuis un certain temps, mais la première tentative d'utilisation a montré que les classes de cryptographie Mono natives (similaires à celles de la base .Net - X509Store, X509Certificate2, etc.) non seulement ne fonctionnent pas avec les clés invitées, mais même ne les voyez pas dans leurs coffres. Pour cette raison, le travail avec la cryptographie devait être connecté directement via les bibliothèques CryptoPro.
Installation de certificat
Avant d'implémenter le code, vous devez installer le certificat et vous assurer qu'il fonctionne correctement.
Installation de certificatLa version 3.9 du composant CSP CryptoPro a été installée sur Centos 7 dans le dossier / opt / cprocsp. Afin d'éviter les conflits entre les utilitaires mono et CryptoPro portant le même nom (par exemple, certmgr), le chemin d'accès au dossier n'a pas été ajouté aux variables d'environnement et tous les utilitaires ont été appelés dans le chemin d'accès complet.
Tout d'abord, nous définissons une liste de lecteurs:
/opt/cprocsp/bin/amd64/csptest -enum -info -type PP_ENUMREADERS | iconv -f cp1251
S'il n'y a pas de lecteur du dossier sur le disque (HDIMAGE) dans la liste, mettez-le:
/opt/cprocsp/sbin/amd64/cpconfig -hardware reader -add HDIMAGE store
Ensuite, vous pouvez créer des conteneurs de la forme '\\. \ HDIMAGE \ {nom du conteneur}' en créant un nouveau conteneur avec des clés:
/opt/cprocsp/bin/amd64/csptest -keyset -provtype 75 -newkeyset -cont '\\.\HDIMAGE\test'
ou en créant le dossier / var / opt / cprocsp / keys / root / {nom du conteneur} .000, qui contient l'ensemble standard de fichiers conteneurs CryptoPro (* .key, * .mask, etc.).
Après cela, le certificat du conteneur peut être installé dans le magasin de certificats:
/opt/cprocsp/bin/amd64/certmgr -inst mMy -cont '\\.\HDIMAGE\{ }'
Le certificat installé peut être vu avec la commande suivante:
/opt/cprocsp/bin/amd64/certmgr -list mMy
Le fonctionnement du certificat peut être vérifié comme suit:
/opt/cprocsp/bin/amd64/cryptcp – sign -norev -thumbprint {} {} { }
/opt/cprocsp/bin/amd64/cryptcp – verify -norev { }
Si tout va bien avec le certificat, vous pouvez procéder à la connexion dans le code.
Connexion en code
Malgré le processus de portage vers Linux, le système était censé continuer à fonctionner dans l'environnement Windows, donc extérieurement, le travail avec la cryptographie devait être effectué par le biais de méthodes générales de la forme «octet [] SignData (octet [] _arData, X509Certificate2 _pCert)», qui devrait fonctionner de la même manière que sous Linux ainsi que sous Windows.
L'analyse des méthodes des bibliothèques de cryptographie s'est avérée réussie, car CryptoPro a implémenté la bibliothèque «libcapi20.so» qui imite complètement les bibliothèques de cryptage standard Windows - «crypt32.dll» et «advapi32.dll». Peut-être, bien sûr, pas entièrement, mais toutes les méthodes nécessaires pour travailler avec la cryptographie y sont disponibles, et presque toutes fonctionnent.
Par conséquent, nous formons deux classes statiques «WCryptoAPI» et «LCryptoAPI», chacune important l'ensemble de méthodes nécessaire comme suit:
[DllImport(LIBCAPI20, SetLastError = true)] internal static extern bool CertCloseStore(IntPtr _hCertStore, uint _iFlags);
La syntaxe de connexion pour chacune des méthodes peut être créée indépendamment, ou utiliser le site Web Pinvoke , ou être copiée à partir de sources .Net (classe CAPISafe ). À partir du même module, vous pouvez dessiner des constantes et des structures associées à la cryptographie, dont la présence facilite toujours la vie lorsque vous travaillez avec des bibliothèques externes.
Et puis nous formons la classe statique "UCryptoAPI" qui, selon le système, appellera la méthode de l'une des deux classes:
internal static bool CertCloseStore(IntPtr _hCertStore, uint _iFlags) { if (fIsLinux) return LCryptoAPI.CertCloseStore(_hCertStore, _iFlags); else return WCryptoAPI.CertCloseStore(_hCertStore, _iFlags); } public static bool fIsLinux { get { int iPlatform = (int) Environment.OSVersion.Platform; return (iPlatform == 4) || (iPlatform == 6) || (iPlatform == 128); } }
Ainsi, en utilisant les méthodes de la classe UCryptoAPI, vous pouvez implémenter du code presque uniforme pour les deux systèmes.
Recherche de certificat
Le travail avec la cryptographie commence généralement par une recherche de certificat, pour cela dans crypt32.dll, il existe deux méthodes CertOpenStore (ouvre le magasin de certificats spécifié) et un simple CertOpenSystemStore (ouvre les certificats personnels de l'utilisateur). Étant donné que l'utilisation des certificats ne se limite pas aux certificats d'utilisateur personnels, nous connectons le premier:
Recherche de certificat public static int FindCertificateCP(string _pFindValue, out X509Certificate2 _pCert, ref string _sError, StoreLocation _pLocation = StoreLocation.CurrentUser, StoreName _pName = StoreName.My, X509FindType _pFindType = X509FindType.FindByThumbprint, bool _fVerify = false) { _pCert = null; IntPtr hCert = IntPtr.Zero; GCHandle hInternal = new GCHandle(); GCHandle hFull = new GCHandle(); IntPtr hSysStore = IntPtr.Zero; try {
La recherche se déroule en plusieurs étapes:
- ouverture de stockage;
- formation de la structure de données par laquelle nous recherchons;
- recherche de certificats;
- si nécessaire, vérification du certificat (décrite dans une section distincte);
- fermer le référentiel et libérer la structure à partir du point 2 (car partout où il y a du travail avec de la mémoire .Net non gérée, rien ne sera fait pour que nous le nettoyions);
Il y a quelques points subtils lors de la recherche de certificats.
CryptoPro sur Linux fonctionne avec des chaînes ANSI, et sur Windows avec UTF8, donc:
- lors de la connexion de la méthode d'ouverture de stockage sous Linux, il est nécessaire d'indiquer explicitement le type de marshaling [In, MarshalAs (UnmanagedType.LPStr)] pour le paramètre de code de stockage;
- en passant la chaîne de recherche (par exemple, par le nom de Subject), elle doit être convertie en un ensemble d'octets avec différents encodages;
- pour toutes les constantes cryptographiques qui varient selon le type de chaîne (par exemple, CERT_FIND_SUBJECT_STR_A et CERT_FIND_SUBJECT_STR_W) sous Windows, vous devez sélectionner * _W et sous Linux * _A;
La méthode MapX509StoreFlags peut être prise directement à partir de sources Microsoft sans modifications, elle forme simplement un masque final basé sur des indicateurs .Net.
La valeur par laquelle la recherche a lieu dépend du type de recherche (vérifiez auprès de MSDN pour CertFindCertificateInStore ), l'exemple montre les deux options les plus couramment utilisées - pour le format de chaîne (noms Subject, Issuer, etc.) et binaire (empreinte digitale, numéro de série).
Le processus de création d'un certificat à partir d'IntPtr sur Windows et Linux est très différent. Windows créera le certificat de manière simple:
new X509Certificate2(hCert);
sous Linux, vous devez créer un certificat en deux étapes:
X509Certificate2(new X509Certificate(hCert));
À l'avenir, nous aurons besoin d'accéder à hCert pour le travail, et il devra être stocké dans l'objet de certificat. Sous Windows, il peut être récupéré ultérieurement à partir de la propriété Handle, mais Linux convertit la structure CERT_CONTEXT qui suit le lien hCert en un lien vers la structure x509_st (OpenSSL) et l'enregistre dans Handle. Par conséquent, il vaut la peine de créer un héritier de X509Certificate2 (ISDP_X509Cert dans l'exemple), qui stockera hCert dans les deux systèmes sur un champ distinct.
N'oubliez pas qu'il s'agit d'un lien vers une zone de mémoire non managée et qu'il doit être libéré après la fin du travail. Parce que dans .Net 4.5 X509Certificate2 n'est pas jetable - le nettoyage à l'aide de la méthode CertFreeCertificateContext doit être effectué dans le destructeur.
Formation Signature
Lorsque vous travaillez avec des certificats GOST, les signatures déconnectées avec un seul signataire sont presque toujours utilisées. Pour créer une telle signature, un bloc de code assez simple est requis:
Formation Signature public static int SignDataCP(byte[] _arData, X509Certificate2 _pCert, out byte[] _arRes, ref string _sError) { _arRes = new byte[0];
Pendant le travail de la méthode, une structure avec des paramètres est formée et la méthode de signature est appelée. La structure des paramètres peut vous permettre d'enregistrer des certificats dans la signature pour former une chaîne complète (les champs cMsgCert et rgpMsgCert, le premier stocke le nombre de certificats, la deuxième liste de liens vers les structures de ces certificats).
La méthode de signature peut recevoir un ou plusieurs documents pour une signature simultanée avec une signature. Soit dit en passant, cela ne contredit pas la loi fédérale 63 et est très pratique, car il est peu probable que l'utilisateur soit satisfait de la nécessité de cliquer plusieurs fois sur le bouton «signer».
La principale bizarrerie de cette méthode est qu'elle ne fonctionne pas en mode deux appels, ce qui est typique de la plupart des méthodes de bibliothèque qui fonctionnent avec de grands blocs de mémoire (la première avec null - renvoie la longueur de tampon requise, la seconde remplit le tampon). Par conséquent, il est nécessaire de créer un grand tampon, puis de le raccourcir à sa longueur réelle.
Le seul problème sérieux est la recherche de l'OID de l'algorithme de hachage (Digest) utilisé lors de la signature - sous forme explicite, il ne se trouve pas dans le certificat (il n'y a que l'algorithme de la signature elle-même). Et si sous Windows vous pouvez le spécifier avec une chaîne vide - il reprendra automatiquement, mais Linux refusera de signer si l'algorithme n'est pas le même.
Mais il y a une astuce - dans les informations sur l'algorithme de signature (structure CRYPT_OID_INFO), l'OID de signature est stocké dans pszOID et l'identifiant de l'algorithme de hachage est stocké dans Algid. Et la conversion d'Algid en OID est déjà une question technique:
Obtention de l'OID de l'algorithme de hachage internal static int GetHashAlgoritmOID(IntPtr _hCertHandle, out string _sOID, ref string _sError) { _sOID = ""; IntPtr hHashAlgInfo = IntPtr.Zero; IntPtr hData = IntPtr.Zero; try { CERT_CONTEXT pContext = (CERT_CONTEXT)Marshal.PtrToStructure(_hCertHandle, typeof(CERT_CONTEXT)); CERT_INFO pCertInfo = (CERT_INFO)Marshal.PtrToStructure(pContext.pCertInfo, typeof(CERT_INFO));
Après avoir lu attentivement le code, vous serez peut-être surpris que l'identifiant de l'algorithme soit obtenu de manière simple (CertOIDToAlgId) et que l'Oid qu'il contient est compliqué (CryptFindOIDInfo). Il serait logique de supposer l'utilisation de méthodes complexes ou simples, et sous Linux, les deux options fonctionnent correctement. Cependant, sous Windows, l'option difficile d'obtenir un identifiant et d'obtenir simplement un OID est instable, donc un hybride aussi étrange serait une solution stable.
Vérification de signature
La vérification de la signature se déroule en deux étapes, au début la signature elle-même est vérifiée, puis le certificat avec lequel elle a été générée est vérifié (chaîne, date de signature, etc.).
En plus de la signature, vous devez spécifier l'ensemble de données à signer, les paramètres de signature et la signature elle-même:
Vérification de signature internal static CRYPT_VERIFY_MESSAGE_PARA GetStdSignVerifyPar() { CRYPT_VERIFY_MESSAGE_PARA pVerifyParams = new CRYPT_VERIFY_MESSAGE_PARA(); pVerifyParams.cbSize = (int)Marshal.SizeOf(pVerifyParams); pVerifyParams.dwMsgEncodingType = UCConsts.PKCS_7_OR_X509_ASN_ENCODING; pVerifyParams.hCryptProv = 0; pVerifyParams.pfnGetSignerCertificate = IntPtr.Zero; pVerifyParams.pvGetArg = IntPtr.Zero; return pVerifyParams; } public static int CheckSignCP(byte[] _arData, byte[] _pSign, out X509Certificate2 _pCert, ref string _sError, bool _fVerifyOnlySign = true, X509RevocationMode _pRevMode = X509RevocationMode.Online, X509RevocationFlag _pRevFlag = X509RevocationFlag.ExcludeRoot){ _pCert = null; IntPtr pHData = Marshal.AllocHGlobal(_arData.Length); GCHandle pCertContext = GCHandle.Alloc(IntPtr.Zero, GCHandleType.Pinned); try { Marshal.Copy(_arData, 0, pHData, _arData.Length); CRYPT_VERIFY_MESSAGE_PARA pVerParam = UCUtils.GetStdSignVerifyPar();
Pour plus de commodité, le processus de formation d'une structure avec des paramètres a été déplacé vers une méthode distincte (GetStdSignVerifyPar). Après cela, la signature elle-même est vérifiée et le premier signataire est extrait (pour de bon il faudrait tout extraire, mais une signature contenant plusieurs signataires est toujours exotique).
Après avoir extrait le certificat du signataire, nous le convertirons dans notre classe et le vérifierons (si spécifié dans les paramètres de la méthode). Pour la vérification, la date de signature du premier signataire est utilisée (voir la section sur l'extraction des informations de la signature et la section sur la vérification des certificats).
Extraire les informations de signature
Souvent, les systèmes cryptographiques nécessitent une représentation imprimée de la signature. Dans chaque cas, c'est différent, il est donc préférable de créer une classe d'informations sur la signature, qui contiendra des informations sous une forme pratique à utiliser et, avec son aide, fournira une présentation imprimée. Dans .Net, il existe une telle classe - SignedCms, cependant, son analogue en mono avec les signatures de CritoPro refuse de fonctionner dans le premier, deuxièmement il contient le modificateur scellé et troisièmement presque toutes ses propriétés sont protégées en écriture, vous devez donc créer votre propre analogue.
La signature elle-même contient deux éléments principaux - une liste de certificats et une liste de signataires. La liste des certificats peut être vide ou contenir tous les certificats à vérifier, y compris les chaînes complètes. La liste des signataires indique le nombre de signatures réelles. La communication entre eux s'effectue par le numéro de série et l'éditeur (émetteur). Théoriquement, dans une signature, il peut y avoir deux certificats d'éditeurs différents avec le même numéro de série, mais en pratique, cela ne peut être négligé et recherché que par le numéro de série.
La lecture de la signature est la suivante:
Extraire les informations de signature public int Decode(byte[] _arSign, ref string _sError) { IntPtr hMsg = IntPtr.Zero;
La signature est analysée en plusieurs étapes, d'abord la structure du message (CryptMsgOpenToDecode) est formée, puis les données de signature réelles (CryptMsgUpdate) y sont entrées. Reste à vérifier qu'il s'agit bien d'une véritable signature et à obtenir d'abord une liste de certificats, puis une liste de signataires. La liste des certificats est récupérée séquentiellement:
Obtenir une liste de certificats internal static X509Certificate2Collection GetSignCertificates(IntPtr _hMsg) { X509Certificate2Collection certificates = new X509Certificate2Collection(); uint iCnt = GetCryptMsgParam<uint>(_hMsg, UCConsts.CMSG_CERT_COUNT_PARAM); for (int i = 0; i < iCnt; i++) { IntPtr hInfo = IntPtr.Zero; IntPtr hCert = IntPtr.Zero; try { uint iLen = 0; if (!GetCryptMsgParam(_hMsg, UCConsts.CMSG_CERT_PARAM, out hInfo, out iLen)) continue; hCert = UCryptoAPI.CertCreateCertificateContext(UCConsts.PKCS_7_OR_X509_ASN_ENCODING, hInfo, iLen); if (hCert != IntPtr.Zero) { certificates.Add(new ISDP_X509Cert(hCert)); hCert = IntPtr.Zero; } } finally { if (hInfo != IntPtr.Zero) Marshal.FreeHGlobal(hInfo); if (hInfo != IntPtr.Zero) Marshal.FreeHGlobal(hCert); } } return certificates; }
Tout d'abord, le nombre de certificats est déterminé à partir du paramètre CMSG_CERT_COUNT_PARAM, puis les informations sur chaque certificat sont récupérées séquentiellement. Le processus de création du contexte du certificat et sur la base du certificat lui-même achève le processus de création.
La récupération des données des signataires est plus difficile. Ils contiennent une indication du certificat et une liste des paramètres de signature (par exemple, la date de signature). Le processus d'extraction des données est le suivant:
Récupération des informations du signataire public int Decode(IntPtr _hMsg, int _iIndex, ISDPSignedCms _pSignedCms, ref string _sError) {
, CMSG_SIGNER_INFO. . , .
, — ( , ).
internal static CryptographicAttributeObjectCollection ReadCryptoAttrsCollection(CRYPT_ATTRIBUTES _pAttrs) { CryptographicAttributeObjectCollection pRes = new CryptographicAttributeObjectCollection(); for (int i = 0; i < _pAttrs.cAttr; i++) { IntPtr hAttr = new IntPtr((long)_pAttrs.rgAttr + (i * Marshal.SizeOf(typeof(CRYPT_ATTRIBUTE)))); CRYPT_ATTRIBUTE pAttr = (CRYPT_ATTRIBUTE) Marshal.PtrToStructure(hAttr, typeof(CRYPT_ATTRIBUTE)); CryptographicAttributeObject pAttrInfo = new CryptographicAttributeObject(new Oid(pAttr.pszObjId), GetAsnEncodedDataCollection(pAttr)); pRes.Add(pAttrInfo); } return pRes; }
Oid – ( ASN.1). :
internal static Pkcs9AttributeObject Pkcs9AttributeFromOID(string _sName) { switch (_sName) { case UCConsts.S_SIGN_DATE_OID : return new Pkcs9SigningTime();
Pkcs9AttributeObject. , mono . Mono .
— — SignedCms, .
, , . (, , ).
public static int EncryptDataCP(byte[] _arInput, X509Certificate2 _pCert, out byte[] _arRes, ref string _sError) { _arRes = new byte[0]; try {
— , . , , .
, , .
. , ( ). :
internal static int GetEncodeAlgoritmOID(IntPtr _hCertHandle, out string _sOID, ref string _sError) { bool fNeedRelease = false; _sOID = ""; uint iKeySpec = 0; IntPtr hCrypto = IntPtr.Zero; try {
. ( , , , .), . (UCConsts.CRYPT_ENCRYPT_ALG_OID_GROUP_ID). — .
( ).
, , . . — , :
public static int DecryptDataCP(byte[] _arInput, out X509Certificate2 _pCert, out byte[] _arRes, ref string _sError) { _arRes = new byte[0]; _pCert = null; IntPtr hSysStore = UCryptoAPI.CertOpenSystemStore(IntPtr.Zero, UCConsts.AR_CRYPTO_STORE_NAME[(int)StoreName.My]); GCHandle GC = GCHandle.Alloc(hSysStore, GCHandleType.Pinned); IntPtr hOutCertL = IntPtr.Zero; IntPtr hOutCert = IntPtr.Zero; try {
, . , ( Linux ).
, , , , . , . :
- ( , , . .);
- — ;
- — ;
- , , (CRL);
, .
Comme il ressort déjà de l'introduction, la vérification de la validité du certificat est l'une des tâches les plus difficiles. C'est pourquoi la bibliothèque dispose de nombreuses méthodes pour implémenter chacun des éléments individuellement. Par conséquent, pour plus de simplicité, nous nous tournons vers les sources .Net pour la méthode X509Certificate2.Verify () et les prenons comme base.
La vérification comprend deux étapes:- former une chaîne de certificats jusqu'à la racine;
- vérifier chacun des certificats qu'il contient (révocation, délai, etc.);
Cette vérification doit être effectuée avant la signature et le cryptage à la date du jour, et au moment de la vérification de la signature à la date de la signature. La méthode de vérification elle-même est petite:
Vérification du certificat internal static int VerifyCertificate (IntPtr _hCert, X509RevocationMode _iRevMode, X509RevocationFlag _iRevFlag, DateTime _rOnDate, TimeSpan _iCTLTimeout, IntPtr _hPolicy, ref string _sError) { if (_hCert == IntPtr.Zero) { _sError = UCConsts.S_CRYPTO_CERT_CHECK_ERR; return UConsts.E_NO_CERTIFICATE; } CERT_CHAIN_POLICY_PARA pPolicyParam = new CERT_CHAIN_POLICY_PARA(Marshal.SizeOf(typeof(CERT_CHAIN_POLICY_PARA))); CERT_CHAIN_POLICY_STATUS pPolicyStatus = new CERT_CHAIN_POLICY_STATUS(Marshal.SizeOf(typeof(CERT_CHAIN_POLICY_STATUS)));
Tout d'abord, une chaîne est formée à l'aide de la méthode BuildChain, puis elle est vérifiée. Lors de la formation de la chaîne, la structure des paramètres, la date de vérification et les drapeaux de contrôle sont formés:
internal static int BuildChain (IntPtr _hChainEngine, IntPtr _hCert, X509RevocationMode _iRevMode, X509RevocationFlag _iRevFlag, DateTime _rOnDate, TimeSpan _rCTLTimeOut, ref IntPtr _hChain, ref string _sError) {
, Microsoft. hCertPolicy hAppPolicy OID-, , . , , .
(, ).
MapRevocationFlags — .Net — uint .
Conclusion
:
- 10 ;
- ;
- byte[] {1, 2, 3, 4, 5};
- ;
- ;
- byte[] {1, 2, 3, 4, 5};
- ;
Windows Linux 1-, 10- 50- , Linux . Linux - - ( , ), «» . (deadlock-) ( «Access Violation»).
UCryptoAPI . fpCPSection object :
private static object fpCPSection = new object(); internal static bool CryptMsgClose(IntPtr _hCryptMsg) { lock (pCPSection) { if (fIsLinux) return LCryptoAPI.CryptMsgClose(_hCryptMsg); else return WCryptoAPI.CryptMsgClose(_hCryptMsg); } } public static object pCPSection { get { return fpCPSection;} }
, Linux- .
mono Issuer Subject . , , mono X500DistinguishedName . , mono ( ), (impl.issuerName impl.subjectName). (Reflection) X500DistinguishedName, CERT_CONTEXT .
Les références
- CAPILite
- c #
- .Net:
- CAPIBase
- X509Certificate2
- SignedCMS
- SignerInfo
- mono:
- X509Certificate2
- X509CertificateImplBtls