En relación con la transición a Linux, se hizo necesario portar uno de nuestros sistemas de servidor escritos en C # a Mono. El sistema funciona con firmas digitales mejoradas, por lo que una de las tareas a las que nos enfrentamos fue probar el rendimiento de los certificados GOST de CryptoPro en mono. CryptoPro ha implementado CSP para Linux durante bastante tiempo, pero el primer intento de usarlo demostró que las clases de criptografía Mono nativas (similares a las de la base .Net - X509Store, X509Certificate2, etc.) no solo no funcionan con claves de invitado, sino que incluso no los veo en sus bóvedas. Debido a esto, el trabajo con criptografía tuvo que conectarse directamente a través de las bibliotecas CryptoPro.
Instalación de certificado
Antes de implementar el código, debe instalar el certificado y asegurarse de que funciona correctamente.
Instalación de certificadoEl componente CryptoPro CSP versión 3.9 se instaló en Centos 7 en la carpeta / opt / cprocsp. Para evitar conflictos entre las utilidades mono y CryptoPro con el mismo nombre (por ejemplo, certmgr), la ruta a la carpeta no se agregó a las variables de entorno y todas las utilidades se llamaron en la ruta completa.
Primero, definimos una lista de lectores:
/opt/cprocsp/bin/amd64/csptest -enum -info -type PP_ENUMREADERS | iconv -f cp1251
Si no hay un lector de la carpeta en el disco (HDIMAGE) entre la lista, póngalo:
/opt/cprocsp/sbin/amd64/cpconfig -hardware reader -add HDIMAGE store
Luego puede crear contenedores con la forma '\\. \ HDIMAGE \ {container name}' ya sea creando un nuevo contenedor con claves:
/opt/cprocsp/bin/amd64/csptest -keyset -provtype 75 -newkeyset -cont '\\.\HDIMAGE\test'
o creando la carpeta / var / opt / cprocsp / keys / root / {container name} .000, que contiene el conjunto estándar de archivos de contenedor CryptoPro (* .key, * .mask, etc.).
Después de eso, el certificado del contenedor se puede instalar en el almacén de certificados:
/opt/cprocsp/bin/amd64/certmgr -inst mMy -cont '\\.\HDIMAGE\{ }'
El certificado instalado se puede ver con el siguiente comando:
/opt/cprocsp/bin/amd64/certmgr -list mMy
El funcionamiento del certificado se puede verificar de la siguiente manera:
/opt/cprocsp/bin/amd64/cryptcp – sign -norev -thumbprint {} {} { }
/opt/cprocsp/bin/amd64/cryptcp – verify -norev { }
Si todo está bien con el certificado, puede proceder a la conexión en el código.
Conexión en código
A pesar del proceso de portabilidad a Linux, se suponía que el sistema continuaría funcionando en el entorno de Windows, por lo que, externamente, el trabajo con criptografía debía realizarse a través de métodos generales de la forma "byte [] SignData (byte [] _arData, X509Certificate2 _pCert)", que debería funcionar igual que tanto en Linux como en Windows.
El análisis de los métodos de las bibliotecas de criptografía resultó exitoso, porque CryptoPro implementó la biblioteca "libcapi20.so", que imita completamente las bibliotecas de cifrado estándar de Windows: "crypt32.dll" y "advapi32.dll". Quizás, por supuesto, no del todo, pero todos los métodos necesarios para trabajar con criptografía están disponibles allí, y casi todos funcionan.
Por lo tanto, formamos dos clases estáticas "WCryptoAPI" y "LCryptoAPI", cada una de las cuales importará el conjunto de métodos necesarios de la siguiente manera:
[DllImport(LIBCAPI20, SetLastError = true)] internal static extern bool CertCloseStore(IntPtr _hCertStore, uint _iFlags);
La sintaxis de conexión para cada uno de los métodos se puede crear de forma independiente, o usar el sitio web pinvoke , o copiar de fuentes .Net (clase CAPISafe ). Desde el mismo módulo, puede dibujar constantes y estructuras asociadas con la criptografía, cuya presencia siempre facilita la vida al trabajar con bibliotecas externas.
Y luego formamos la clase estática "UCryptoAPI" que, dependiendo del sistema, llamará al método de una de dos clases:
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); } }
Por lo tanto, utilizando los métodos de la clase UCryptoAPI, puede implementar código casi uniforme para ambos sistemas.
Búsqueda de certificados
El trabajo con criptografía generalmente comienza con una búsqueda de certificados, para esto en crypt32.dll hay dos métodos CertOpenStore (abre el almacén de certificados especificado) y un simple CertOpenSystemStore (abre los certificados personales del usuario). Debido al hecho de que trabajar con certificados no se limita a los certificados de usuario personales, conectamos el primero:
Búsqueda de certificados 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 búsqueda se lleva a cabo en varias etapas:
- apertura de almacenamiento;
- formación de la estructura de datos por la cual estamos buscando;
- búsqueda de certificados;
- si es necesario, luego la verificación del certificado (descrito en una sección separada)
- cerrar el repositorio y liberar la estructura desde el punto 2 (ya que en todas partes hay trabajo con memoria .Net no administrada, no se hará nada para limpiarlo);
Hay algunos puntos sutiles al buscar certificados.
CryptoPro en Linux funciona con cadenas ANSI y en Windows con UTF8, por lo tanto:
- al conectar el método de abrir almacenamiento en Linux, es necesario indicar explícitamente el tipo de cálculo de referencias [In, MarshalAs (UnmanagedType.LPStr)] para el parámetro del código de almacenamiento;
- pasando la cadena de búsqueda (por ejemplo, por el nombre del Asunto) se debe convertir en un conjunto de bytes con diferentes codificaciones;
- para todas las constantes criptográficas que tienen variaciones según el tipo de cadena (por ejemplo, CERT_FIND_SUBJECT_STR_A y CERT_FIND_SUBJECT_STR_W) en Windows, debe seleccionar * _W y en Linux * _A;
El método MapX509StoreFlags se puede tomar directamente de las fuentes de Microsoft sin cambios, simplemente forma una máscara final basada en banderas .Net.
El valor por el cual se realiza la búsqueda depende del tipo de búsqueda (consulte con MSDN para CertFindCertificateInStore ), el ejemplo muestra las dos opciones más utilizadas: para el formato de cadena (nombres Asunto, Emisor, etc.) y binario (huella digital, número de serie).
El proceso de creación de un certificado de IntPtr en Windows y Linux es muy diferente. Windows creará el certificado de una manera simple:
new X509Certificate2(hCert);
en Linux, debe crear un certificado en dos pasos:
X509Certificate2(new X509Certificate(hCert));
En el futuro, necesitamos acceso a hCert para el trabajo, y debería almacenarse en el objeto de certificado. En Windows, se puede recuperar más tarde de la propiedad Handle, pero Linux convierte la estructura CERT_CONTEXT que sigue al enlace hCert en un enlace a la estructura x509_st (OpenSSL) y lo registra en Handle. Por lo tanto, vale la pena crear un heredero de X509Certificate2 (ISDP_X509Cert en el ejemplo), que almacenará hCert en ambos sistemas en un campo separado.
No olvide que este es un enlace a un área de memoria no administrada y debe liberarse después del final del trabajo. Porque en .Net 4.5 X509Certificate2 no es desechable: la limpieza con el método CertFreeCertificateContext debe realizarse en el destructor.
Formación de firma
Cuando se trabaja con certificados GOST, las firmas desconectadas con un firmante casi siempre se usan. Para crear dicha firma, se requiere un bloque de código bastante simple:
Formación de firma public static int SignDataCP(byte[] _arData, X509Certificate2 _pCert, out byte[] _arRes, ref string _sError) { _arRes = new byte[0];
Durante el trabajo del método, se forma una estructura con parámetros y se llama al método de firma. La estructura de parámetros puede permitirle guardar certificados en la firma para formar una cadena completa (los campos cMsgCert y rgpMsgCert, el primero almacena el número de certificados, la segunda lista de enlaces a las estructuras de estos certificados).
El método de firma puede recibir uno o más documentos para la firma simultánea con una firma. Esto, por cierto, no contradice la Ley Federal 63 y es muy conveniente, porque es poco probable que el usuario esté contento de la necesidad de hacer clic en el botón "firmar" varias veces.
La peculiaridad principal de este método es que no funciona en el modo de dos llamadas, lo cual es típico para la mayoría de los métodos de biblioteca que funcionan con grandes bloques de memoria (el primero con nulo, devuelve la longitud de búfer requerida, el segundo llena el búfer). Por lo tanto, es necesario crear un búfer grande y luego acortarlo a su longitud real.
El único problema grave es la búsqueda del OID del algoritmo hash (resumen) utilizado al firmar; en forma explícita, no está en el certificado (solo existe el algoritmo de la firma en sí). Y si en Windows puede especificarlo con una cadena vacía, se recuperará automáticamente, pero Linux se negará a firmar si el algoritmo no es el mismo.
Pero hay un truco: en la información sobre el algoritmo de firma (estructura CRYPT_OID_INFO), el OID de firma se almacena en pszOID y el identificador del algoritmo hash se almacena en Algid. Y convertir Algid a OID ya es una cuestión técnica:
Obteniendo el OID del algoritmo hash 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));
Después de leer cuidadosamente el código, puede sorprenderse de que el identificador del algoritmo se obtenga de una manera simple (CertOIDToAlgId) y que el Oid sea complicado (CryptFindOIDInfo). Sería lógico suponer el uso de métodos tanto complejos como simples, y en Linux ambas opciones funcionan con éxito. Sin embargo, en Windows, la difícil opción de obtener un identificador y simplemente obtener un OID es inestable, por lo que un híbrido tan extraño sería una solución estable.
Verificación de firma
La verificación de la firma se lleva a cabo en dos etapas, al principio se verifica la firma y luego se verifica el certificado con el que se generó (cadena, fecha de firma, etc.).
Además de al firmar, debe especificar el conjunto de datos a firmar, los parámetros de firma y la firma en sí:
Verificación de firma 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();
Por conveniencia, el proceso de formar una estructura con parámetros se ha movido a un método separado (GetStdSignVerifyPar). Después de eso, se verifica la firma en sí y se extrae el primer firmante (para bien, sería necesario extraer todo, pero una firma que contenga varios firmantes sigue siendo exótica).
Después de extraer el certificado del firmante, lo convertiremos a nuestra clase y lo verificaremos (si se especifica en los parámetros del método). Para la verificación, se utiliza la fecha de firma del primer firmante (consulte la sección sobre la extracción de información de la firma y la sección sobre la verificación del certificado).
Extraer información de firma
A menudo, los sistemas criptográficos requieren una representación impresa de la firma. En cada caso, es diferente, por lo que es mejor crear una clase de información sobre la firma, que contendrá la información en una forma conveniente para su uso y con su ayuda proporcionará una presentación impresa. En .Net existe tal clase: SignedCms, sin embargo, su análogo en mono con las firmas de CritoPro se niega a funcionar en el primero, en segundo lugar contiene el modificador sellado y en tercer lugar casi todas sus propiedades están protegidas contra escritura, por lo que debe crear su propio análogo.
La firma en sí contiene dos elementos principales: una lista de certificados y una lista de firmantes. La lista de certificados puede estar vacía o puede contener todos los certificados para verificación, incluidas las cadenas completas. La lista de firmantes indica el número de firmas reales. La comunicación entre ellos se lleva a cabo por el número de serie y el editor (Emisor). Teóricamente, en una firma puede haber dos certificados de diferentes editores con el mismo número de serie, pero en la práctica esto puede ser descuidado y buscado solo por el número de serie.
La lectura de la firma es la siguiente:
Extraer información de firma public int Decode(byte[] _arSign, ref string _sError) { IntPtr hMsg = IntPtr.Zero;
La firma se analiza en varias etapas, primero se forma la estructura del mensaje (CryptMsgOpenToDecode), luego se ingresan los datos reales de la firma (CryptMsgUpdate). Queda por verificar que se trata de una firma real y primero obtener una lista de certificados y luego una lista de firmantes. La lista de certificados se recupera secuencialmente:
Obtener una lista de certificados 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; }
Primero, el número de certificados se determina a partir del parámetro CMSG_CERT_COUNT_PARAM, y luego la información sobre cada certificado se recupera secuencialmente. El proceso de creación del contexto del certificado y sobre la base del propio certificado completa el proceso de creación.
Recuperar los datos del firmante es más difícil. Contienen una indicación del certificado y una lista de parámetros de firma (por ejemplo, la fecha de la firma). El proceso de extracción de datos es el siguiente:
Recuperando información del firmante 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);
, .
Como ya está claro en la introducción, verificar la validez del certificado es una de las tareas más difíciles. Es por eso que la biblioteca tiene muchos métodos para implementar cada uno de los elementos individualmente. Por lo tanto, para simplificar, recurrimos a las fuentes .Net para el método X509Certificate2.Verify () y las tomamos como base.
La verificación consta de dos etapas:- formar una cadena de certificados hasta la raíz;
- verifique cada uno de los certificados que contiene (por revocación, tiempo, etc.);
Dicha verificación debe realizarse antes de firmar y cifrar en la fecha actual, y en el momento de la verificación de la firma en la fecha de la firma. El método de verificación en sí es pequeño:
Verificación de certificado 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)));
Primero, se forma una cadena usando el método BuildChain, y luego se verifica. Durante la formación de la cadena, se forman la estructura de parámetros, la fecha de verificación y las banderas de verificación:
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 .
Conclusión
:
- 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 .
Referencias
- CAPILite
- c #
- .Net:
- CAPIBase
- X509Certificate2
- SignedCMS
- SignerInfo
- mono:
- X509Certificate2
- X509CertificateImplBtls