Дешифрование
Адрес одного из адресатов должен присутствовать в личных сертификатах пользователя или компьютера на локальной машине. Он должен быть связан с закрытым ключом. Согласно плану, который уже всем хорошо известен, существует список параметров вместе с определением длины.
/**<summary>Дешифровывает данные</summary>
* <param name="_arInput">Данные для расшифровки</param>
* <param name="_arRes">Результат</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <param name="_pCert">Сертификат</param>
* <returns>Стандартный код ошибки, если UCOnsts.S_OK то все ок</returns>
* **/
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 {
// 0) Подготовка параметров
CRYPT_DECRYPT_MESSAGE_PARA pParams = new CRYPT_DECRYPT_MESSAGE_PARA();
pParams.dwMsgAndCertEncodingType = UCConsts.PKCS_7_OR_X509_ASN_ENCODING;
pParams.cCertStore = 1;
pParams.rghCertStore = GC.AddrOfPinnedObject();
pParams.cbSize = Marshal.SizeOf(pParams);
int iLen = 0;
// 1) Первый вызов определяем длину
if (!UCryptoAPI.CryptDecryptMessage(ref pParams, _arInput, _arInput.Length,
null, ref iLen, ref hOutCertL)) {
_sError = UCConsts.S_DECRYPT_LEN_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
// 2) Второй вызов дешифруем
_arRes = new byte[iLen];
if (!UCryptoAPI.CryptDecryptMessage(ref pParams, _arInput, _arInput.Length,
_arRes, ref iLen, ref hOutCert)) {
_sError = UCConsts.S_DECRYPT_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
// 3) Если есть вытаскиваем сертификат
if (hOutCert != IntPtr.Zero) _pCert = new ISDP_X509Cert(hOutCert);
if(_pCert != null) hOutCert = IntPtr.Zero;
// Все ок возвращаем
return UConsts.S_OK;
} catch (Exception E) {
_sError = UCConsts.S_DECRYPT_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;
} finally {
if (hOutCertL != IntPtr.Zero) UCryptoAPI.CertFreeCertificateContext(hOutCertL);
if (hOutCert != IntPtr.Zero) UCryptoAPI.CertFreeCertificateContext(hOutCert);
GC.Free();
UCryptoAPI.CertCloseStore(hSysStore, 0);
}
}
Укажите местоположение хранилища, из которого система будет извлекать необходимый сертификат при настройке параметров. Затем система отобразит расшифрованные данные вместе с применяемым сертификатом.
Извлечение информация из подписи
В системах, использующих криптографию, иногда требуется печатная версия подписи. Каждая ситуация уникальна, а для печатной информации предпочтительнее выбирать категорию подписных документов, которые могут включать печать. В
Список сертификатов и список подписавших — это два компонента, из которых состоит сама подпись. Список сертификатов может быть пустым или включать все цепочки, необходимые для проверки. Сколько фактических подписей указано под каждым подписавшим в списке.
Читаем подпись
/**<summary>Расшифровать</summary>
* <param name="_arSign">Подпись</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <returns>Стандартный код ошибки, если UConsts.S_OK то все ок</returns>
* **/
public int Decode(byte[] _arSign, ref string _sError) {
IntPtr hMsg = IntPtr.Zero;
// 0) Формируем информацию
try {
hMsg = UCryptoAPI.CryptMsgOpenToDecode(UCConsts.PKCS_7_OR_X509_ASN_ENCODING, UCConsts.CMSG_DETACHED_FLAG,
0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
if (hMsg == IntPtr.Zero) {
_sError = UCConsts.S_CRYP_MSG_FORM_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
// 1) Вносим сообщение
if (!UCryptoAPI.CryptMsgUpdate(hMsg, _arSign, (uint)_arSign.Length, true)) {
_sError = UCConsts.S_CRYP_MSG_SIGN_COPY_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
// 2) Проверяем тип (PKCS7 SignedData)
uint iMessType = UCUtils.GetCryptMsgParam<uint>(hMsg, UCConsts.CMSG_TYPE_PARAM);
if (UCConsts.CMSG_SIGNED != iMessType) {
_sError = UCConsts.S_CRYP_MSG_SIGN_TYPE_ERR.Frm(iMessType, UCConsts.CMSG_SIGNED);
return UConsts.E_CRYPTO_ERR;
}
// 3) Формируем список сертфикатов
fpCertificates = UCUtils.GetSignCertificates(hMsg);
// 4) Список подписантов
uint iSignerCount = UCUtils.GetCryptMsgParam<uint>(hMsg, UCConsts.CMSG_SIGNER_COUNT_PARAM);
for (int i = 0; i < iSignerCount; i ) {
ISDPSignerInfo pInfo = new ISDPSignerInfo();
fpSignerInfos.Add(pInfo);
int iRes = pInfo.Decode(hMsg, i, this, ref _sError);
if (iRes != UConsts.S_OK) return iRes;
}
return UConsts.S_OK;
} catch (Exception E) {
_sError = UCConsts.S_SIGN_INFO_GEN_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;
} finally {
if(hMsg != IntPtr.Zero) UCryptoAPI.CryptMsgClose(hMsg);
}
}
Чтобы правильно разобрать подпись, сначала должна быть создана структура сообщения (CryptMsgOpenToDecode), а затем добавлены фактические данные. Остается только составить список подписавших и окончательно убедиться, что это действительно подпись. Список сертификатов публикуется по порядку:
Параметр CMSG_CERT-COUNTAPARAM используется сначала для подсчета общего количества сертификатов, после чего выводится информация о каждом экземпляре. завершает процесс построения основы проекта и контекста сертификата.
Получить данные подписанта может быть сложнее. Они включают список параметров и сертификат подписи. Ниже описана процедура извлечения данных:
/**<summary>Распарсить информацию из подписи</summary>
* <param name="_hMsg">Handler подписи</param>
* <param name="_iIndex">Индекс подписанта</param>
* <param name="_pSignedCms">Структура подписи</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <returns>Стандартный код ошибки, если UConsts.S_OK то все ок</returns>
* **/
public int Decode(IntPtr _hMsg, int _iIndex, ISDPSignedCms _pSignedCms, ref string _sError) {
// 1) Определяем длину
uint iLen = 0;
// 2) Считываем
IntPtr hInfo = IntPtr.Zero;
try {
if (!UCryptoAPI.CryptMsgGetParam(_hMsg, UCConsts.CMSG_SIGNER_INFO_PARAM, (uint)_iIndex, IntPtr.Zero, ref iLen)) {
_sError = UCConsts.S_ERR_SIGNER_INFO_LEN.Frm(_iIndex, Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
hInfo = Marshal.AllocHGlobal((int)iLen);
if (!UCryptoAPI.CryptMsgGetParam(_hMsg, UCConsts.CMSG_SIGNER_INFO_PARAM, (uint)_iIndex, hInfo, ref iLen)) {
_sError = UCConsts.S_ERR_SIGNER_INFO.Frm(_iIndex, Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
CMSG_SIGNER_INFO pSignerInfo = (CMSG_SIGNER_INFO) Marshal.PtrToStructure(hInfo, typeof(CMSG_SIGNER_INFO));
// 2.1) Ищем сертификат
byte[] arSerial = new byte[pSignerInfo.SerialNumber.cbData];
Marshal.Copy(pSignerInfo.SerialNumber.pbData, arSerial, 0, arSerial.Length);
X509Certificate2Collection pLocCerts = _pSignedCms.pCertificates.Find(X509FindType.FindBySerialNumber,
arSerial.Reverse().ToArray().ToHex(), false);
if (pLocCerts.Count != 1) {
_sError = UCConsts.S_ERR_SIGNER_INFO_CERT.Frm(_iIndex);
return UConsts.E_NO_CERTIFICATE;
}
fpCertificate = pLocCerts[0];
fpSignedAttributes = UCUtils.ReadCryptoAttrsCollection(pSignerInfo.AuthAttrs);
return UConsts.S_OK;
} catch (Exception E) {
_sError = UCConsts.S_ERR_SIGNER_INFO_READ.Frm(_iIndex, E.Message);
return UConsts.E_GEN_EXCEPTION;
} finally {
if(hInfo != IntPtr.Zero) Marshal.FreeHGlobal(hInfo);
}
}
После определения размера структуры подписанта извлекается структура CMSG_SIGNER. Она позволяет узнать серийный номер сертификата и использовать его для поиска нужного сертификата. Серийный номер, как вы видите, находится в обратном порядке.
Дата подписания — самый важный параметр, который необходимо выбрать после получения сертификата (даже если он не подтвержден сервером штампов времени).
Пройдя первый уровень, мы формируем вложенный список: Атрибуты представляют собой вложенный каталог типа Oid — список значений (в реальности это дизассемблированная структура ASN.1).
Правильный выбор наследника PKCS9AttributeObject имеет решающее значение. Проблема в том, что вы должны сформировать выбор класса непосредственно из кода, потому что обычный метод создания терпит неудачу. Моно неспособен создать дату.
Мы получаем аналог SignedCms путем классификации вышеупомянутых методов на две категории.
Краткое руководство пользователя по работе с эцп криптопро jcp 1.0.54
Краткое руководство пользователя по работе с ЭДП «КриптоПро JCP» 1.0.54
Установка КриптоПро 1.0.54.
Какой порядок установки и настройки электронной подписи?
Установить JDK 7u21;
— Установить и настроить JCP;
— установите корневой сертификат центра сертификации;
— Отправьте готовый запрос на создание тестового ключа.
Проверить работу крипто-механизмов.
Установка JDK 7u21:
Установите JDK 7u21 в соответствии с номерами процессоров (32-бит или 64-бит), в зависимости от разрядности вашего компьютера.
Установка КриптоПро 1.0.54
Установить JCP 1.0.54
2) Запустить командную строку от имени администратора:
Запустите команду с расположением программного обеспечения JCP в командной строке. Введите «Disk name:» и нажмите «Enter»
Рисунок 1: CMD в командной строке
2) Покажите команду «CD», введите путь к папке, содержащей установленный модуль JCP. Например, CDC-JCP.1.0.54LIB (Рисунок 2).
Рисунок 2: Расположение папки
3) Прописать команду «Install. bat «пробел» путь к установленной ранее ПО Java JDK, нажать «Enter». Пример:Install.bat “C:ProgramFiles (x86)Javajdk1.7.0_21”.Путь необходимо взять в “кавычки” (рисунок 3).
Выполнение установки программного обеспечения, Рисунок 3
Запустите модуль JCP.
Команда ControlPane должна быть выполнена. Введите после того, как у него была «пролета» яндекс «простирается» установленную java jdk. ControlPane.»C: ProgramFiles (x86) javajdk1.7_21″ в пакетном файле
5) Появится окно с настройками КриптоПро JCP (рисунок 4).
Рисунок 4 – Настройка КриптоПро
Добавить сертификат в контейнер.
Дважды нажмите на контейнере «HDImageStore Container», чтобы открыть его во вкладке «Key and Certificate Store» (Рисунок 5).
Рисунок 5 – Контейнер HDImageStore
На экране появится окно «Генерация ключей» (Рисунок 6). Выберите «Новое имя контейнера» из выпадающего меню окна, введите пароль LPU и «Ключ подписи», а затем нажмите «Создать».
Рисунок 6 — Ключевое поколение
— Установите BASE64 hb в окне (Рисунок 7). Выберите «Сохранить» в меню.
Запрос на государственный сертификат, рисунок 7.
— Выберите имя файла и место для его сохранения. Появится сообщение «Генерация и запись завершена». Выберите опцию OK. В контейнер будет добавлена запись (Рисунок 8).
Рисунок 8: Обновление контейнера записью
B) Откройте файл в Блокноте и вставьте сообщение. Переименуйте файл, добавив расширение *.txt.
В) Вставить скопированное сообщение, нажать кнопку «Выдать». Нажмите на ссылку Загрузить сертификат, выбрать документ и вставить его.
D) перейдите в Container Store, выберите созданный контейнер и введите пароль. Чтобы ввести пароль, нажмите на контейнер. В контейнере будут видны ключ и сертификат (Рисунок 9).
На рисунке 9 показан контейнер с добавленным ключом и сертификатом.
3 направления о том, как импортировать клавиши CryptoPro
Необходимо хранить ключи КриптоПро в хранилище контейнера CP на рабочей станции персонального компьютера. Для хранения ключей используются следующие форматы:
· файлы в формате реестра Windows «.reg»;
Файлы в каталоге с именем «.000» в файловой системе;
Ключевые контейнеры CryptoPro CSP физически расположены на диске Windows.
В данном руководстве объясняется, как экспортировать ключи из КриптоПро CSP в КриптоПро JCP, используемую системой управления персональным здоровьем, после их импорта из файлов реестра формата «.reg».
1. reg-файлы ключей от заказчика.
2. reg-файлы ключей могут быть отправлены по электронной почте на рабочую станцию КриптоПро.
3. инструкции по экспорту файлов из «КриптоПро» в файловую систему.
4. Чтобы использовать CryptoPro, IP-код может быть загружен на терминалы LPU.
Следуйте этим действиям:
1. КриптоПро CSP получит reg-файлы, содержащие ключи.
2. Введите в текстовом редакторе ключ реестра в следующем формате:.
Поиск сертификата
Вы должны найти сертификат с помощью криптографии. Для этого в crypt32 есть два простых окна с использованием метода CertOSystem Store NETWORK и метода CertOpenStore, которые открывают указанное хранилище и личные данные пользователя соответственно. Мы подключаемся к первому пакету, потому что использование сертификатов относится не только к частной информации о пользователях:
/**<summary>Поиск сертификата (первого удовлетворяющего критериям поиска)</summary>
* <param name="_pFindType">Тип поиска</param>
* <param name="_pFindValue">Значение поиска</param>
* <param name="_pLocation">Место </param>
* <param name="_pName">Имя хранилища</param>
* <param name="_pCert">Возвращаемый сертификат</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <param name="_fVerify">Проверить сертфиикат</param>
* <returns>Стандартый код ошибки, если UConsts.S_OK то все ок</returns>
* **/
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 {
// 0) Открываем хранилище
hSysStore = UCryptoAPI.CertOpenStore(UCConsts.AR_CERT_STORE_PROV_SYSTEM[fIsLinux.ToByte()],
UCConsts.PKCS_7_OR_X509_ASN_ENCODING,
IntPtr.Zero,
UCUtils.MapX509StoreFlags(_pLocation, OpenFlags.ReadOnly),
UCConsts.AR_CRYPTO_STORE_NAME[(int)_pName]);
if (hSysStore == IntPtr.Zero) {
_sError = UCConsts.S_ERR_STORE_OPEN.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
// 1) Формируем данные в пакете
if ((_pFindType == X509FindType.FindByThumbprint) || (_pFindType == X509FindType.FindBySerialNumber))
{
byte[] arData = _pFindValue.FromHex();
CRYPTOAPI_BLOB cryptBlob;
cryptBlob.cbData = arData.Length;
hInternal = GCHandle.Alloc(arData, GCHandleType.Pinned);
cryptBlob.pbData = hInternal.AddrOfPinnedObject();
hFull = GCHandle.Alloc(cryptBlob, GCHandleType.Pinned);
} else {
byte[] arData;
if(fIsLinux)
arData = Encoding.UTF8.GetBytes(_pFindValue);
else
arData = Encoding.Unicode.GetBytes(_pFindValue);
hFull = GCHandle.Alloc(arData, GCHandleType.Pinned);
}
// 2) Получаем
IntPtr hPrev = IntPtr.Zero;
do {
hCert = UCryptoAPI.CertFindCertificateInStore(hSysStore,
UCConsts.PKCS_7_OR_X509_ASN_ENCODING, 0,
UCConsts.AR_CRYPT_FIND_TYPE[(int)_pFindType, fIsLinux.ToByte()],
hFull.AddrOfPinnedObject(), hPrev);
// 2.1) Освобождаем предыдущий
if(hPrev != IntPtr.Zero) UCryptoAPI.CertFreeCertificateContext(hPrev);
// 2.2) Кончились в списке
if(hCert == IntPtr.Zero) return UConsts.E_NO_CERTIFICATE;
// 2.3) Нашли и валиден
X509Certificate2 pCert = new ISDP_X509Cert(hCert);
if (!_fVerify || pCert.ISDPVerify()) {
hCert = IntPtr.Zero;
_pCert = pCert;
return UConsts.S_OK;
}
hPrev = hCert;
// Чтобы не очистило
hCert = IntPtr.Zero;
} while(hCert != IntPtr.Zero);
return UConsts.E_NO_CERTIFICATE;
} catch (Exception E) {
_sError = UCConsts.S_FIND_CERT_GEN_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;
} finally {
// Очищаем ссылки и закрываем хранилище
if(hInternal.IsAllocated) hInternal.Free();
if(hFull.IsAllocated) hFull.Free();
if (hCert != IntPtr.Zero) UCryptoAPI.CertFreeCertificateContext(hCert);
UCryptoAPI.CertCloseStore(hSysStore, 0);
}
}
Поиск происходит в несколько этапов:
- Открыть хранилище;
- Сформировать искомую структуру данных;
- Получить сертификат;
- При необходимости проверить сертификат (описано в отдельном разделе);
- Закрыть хранилище и освободить структуру из шага 2 (поскольку мы работаем здесь с неуправляемой памятью, .Net не будет ничего делать для ее очистки);
Процесс поиска сертификатов связан с рядом нюансов.
КриптоПро поддерживает только UTF8 в Windows и строки ANSI.
- При подключении метода открытия хранилища в Linux необходимо явно указать тип маршалинга для параметра кода хранилища [In, MarshalAs (UnmanagedType. LPStr)];
- Передача строки поиска (например. для имени субъекта), должны быть преобразованы в набор байтов с использованием различных кодировок;
- Для всех криптоконстант, имеющих переменный строковый тип (например, CERT_FIND_SUBJECT_STR_A и CERT_FIND_SUBJECT_STR_W), выберите *_W в Windows и *_A в Linux;
Из источников Microsoft можно получить MapX509StoreFlags, который генерирует только финальную маску.
Тип поиска, как правило, определяет значение (см. Пример). Примеры включают в себя имена субъекта или эмитента и отметка Loof на упаковке автомобиля, которые представляют два наиболее популярных формата струн и двоичные опционы.
В Linux и Windows функция Intptptr не работает. Windows легко создаст сертификат.
new X509Certificate2(hCert);В Linux для получения сертификата необходимо создать ряд документов всего в два этапа.
X509Certificate2(new X509Certificate(hCert));В будущем нам потребуется доступ к HCERT для рабочих целей, поэтому его следует сохранить в сертификате. В Windows его можно найти в свойствах Handle, но в данном случае Linux предоставляет ссылку на структуру X509_ST (Opensl) и указывает ее.
Обратите внимание, что после завершения работы вы должны освободить ссылку на неуправляемую область памяти. В деструкторе рекомендуется очистка с помощью CerFreeCommunit (certifries), поскольку в Net 4.5 X5509Certificate2 не является Disposable!
Проверка подписи
Подпись проверяется дважды: один раз для самой подписи и один раз для сертификата (или цепочки подписей), который был создан.
/**<summary>Формирует стандартную сктруктуру для проверки подписи </summary>
* <returns>Структуру</returns>
* **/
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;
}
/**<summary>Проверяет подпись</summary>
* <param name="_arData">данные, которые было подписаны</param>
* <param name="_pSign">подпись</param>
* <param name="_pCert">сертификат</param>
* <param name="_sError">возвращаемая строка с ошибкой</param>
* <param name="_fVerifyOnlySign">Проверять только подпись</param>
* <param name="_pRevMode">Режим проверки сертификата</param>
* <param name="_pRevFlag">Флаг проверки сертфииката</param>
* <returns>Стандартый код ошибки, если UConsts.S_OK то все ок</returns>
* <remarks>Проверяется только первый подписант</remarks>
* **/
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();
// 0) Проверка подписи
bool fRes = UCryptoAPI.CryptVerifyDetachedMessageSignature(
ref pVerParam, // Параметры подтверждения
0, // Индекс подписанта
_pSign, // Подпись
_pSign.Length, // Длина подписи
1, // кол-во файлов на подпись
new IntPtr[1] { pHData }, // подписанные файлы
new int[1] { _arData.Length }, // Длины подписанных файлов
pCertContext.AddrOfPinnedObject());// Ссылка на сертификат
if (!fRes) {
_sError = UCConsts.S_SIGN_CHECK_ERR.Frm(Marshal.GetLastWin32Error().ToString("X"));
return UConsts.E_CRYPTO_ERR;
}
// 1) Извлечение сертфииката
_pCert = new ISDP_X509Cert((IntPtr)pCertContext.Target);
if (_pCert == null) {
_sError = UCConsts.S_SIGN_CHECK_CERT_ERR;
return UConsts.E_CRYPTO_ERR;
}
// 2) Проверка сертификата
if (!_fVerifyOnlySign) {
List<DateTime> pDates;
// 2.1) Получаем список дат
int iRes = GetSignDateTimeCP(_pSign, out pDates, ref _sError);
// 2.2) Верифицируем первый сертификат
iRes = _pCert.ISDPVerify(ref _sError, pDates[0], _pRevMode, _pRevFlag);
if (iRes != UConsts.S_OK) return iRes;
}
return UConsts.S_OK;
} catch (Exception E) {
_sError = UCConsts.S_SIGN_CHECK_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;;
} finally {
Marshal.FreeHGlobal(pHData);
if ((_pCert == null) && pCertContext.IsAllocated && ((IntPtr)pCertContext.Target != IntPtr.Zero))
UCryptoAPI.CertFreeCertificateContext((IntPtr)pCertContext.Target);
pCertContext.Free();
}
}
Метод GetStdSignVerifyPar выделен в отдельный инструмент в зависимости от ваших целей и задач. Первый подписант удаляется после верификации (в конце концов, это экзотика).
Мы проверяем сертификат подписанта на соответствие параметрам метода после извлечения его из нашего класса. Для проверки используется дата, когда первый подписант подписал документ (см. разделы об извлечении информации из подписей и проверке сертификата).
Проверка сертификата
Сертификат — это больше, чем просто открытый ключ;Он также содержит подробную информацию о человеке, который является владельцем документа, в том числе, который выпустил сертификат и о том, как его использовать. Сертификат также подлежит отзыва в случае компромисса и имеет дату истечения срока действия. Проверка сертификата может означать одно из следующих:
- Целостность цепочки (сертификат издателя, сертификат издателя, сертификат издателя сертификата издателя и т.д.)
- Сертификат корневого издателя — должен находиться в хранилище доверенного корневого центра;
- Срок действия всех сертификатов — время использования сертификата должно быть в пределах этого срока;
- Каждый сертификат в цепочке, кроме корневого, не должен находиться в списке отозванных сертификатов (CRL) своего издателя;
Преимущество в том, что вам придется выполнять его в реальных обстоятельствах.
Одной из самых сложных задач является проверка достоверности сертификата. Из -за этого есть много разных способов реализации каждого элемента в библиотеке. Итак, давайте возьмем источники x509Certificate2, чтобы упростить ситуацию. Проверьте () их, затем отправьте их нам.
Проверка состоит из двух этапов:
- Создать цепочку сертификатов вплоть до корневого сертификата
- Проверить каждый сертификат в цепочке (на отзыв, время и т.д.);
Во время проверки подписи в текущую дату эта проверка проводится перед подписью и шифрованием. Есть способ определить, какая техника вы используете:
/**<summary>Проверить сертификат</summary>
* <param name="_iRevFlag">Флаг отзыва</param>
* <param name="_iRevMode">Режим отзыва</param>
* <param name="_hPolicy">Ссылка на правила проверки</param>
* <param name="_hCert">контекст сертфиката</param>
* <param name="_iCTLTimeout">таймаут запроса списка отзыва</param>
* <param name="_rOnDate">Дата верификацмм</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <returns>Стандартый код ошибки, если UConsts.S_OK то все ок</returns>
* **/
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)));
// 1) Формируем цепочку
IntPtr hChain = IntPtr.Zero;
try {
int iRes = BuildChain(new IntPtr(UCConsts.HCCE_CURRENT_USER), _hCert, __iRevMode, _iRevFlag,
_rOnDate, _iCTLTimeout, ref hChain, ref _sError);
if (iRes != UConsts.S_OK) return iRes;
// 2) Проверяем цепочку
if (UCryptoAPI.CertVerifyCertificateChainPolicy(_hPolicy, hChain, ref pPolicyParam, ref pPolicyStatus)) {
if (pPolicyStatus.dwError != 0) {
_sError = UCConsts.S_CRYPTO_CHAIN_CHECK_ERR.Frm(pPolicyStatus.dwError);
return UConsts.E_CRYPTO_ERR;
}
} else{
_sError = UCConsts.S_CRYPTO_CHAIN_CHECK_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
return UConsts.S_OK;
} catch (Exception E) {
_sError = UCConsts.S_CRYPTO_CERT_VERIFY_GEN_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;
} finally {
if(hChain != IntPtr.Zero) UCryptoAPI.CertFreeCertificateChain(hChain);
}
}
Проверка цепочки осуществляется после ее создания с помощью метода BuildChain. Структура параметров, дата проверки и флаги контроля формируются в процессе формирования цепочки:
/**<summary>Формирует цепочку сертфикиата для проверки</summary>
* <param name="_hChain">КОнтекст цепочки сертфиикатов</param>
* <param name="_iRevFlag">Флаг отзыва</param>
* <param name="_iRevMode">Режим отзыва</param>
* <param name="_hChainEngine">Тип хранилища</param>
* <param name="_hCert">контекст сертфиката</param>
* <param name="_rCTLTimeOut">таймаут запроса списка отзыва</param>
* <param name="_rOnDate">Дата верификацмм</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <returns>Стандартый код ошибки, если UConsts.S_OK то все ок</returns>
* **/
internal static int BuildChain (IntPtr _hChainEngine, IntPtr _hCert, X509RevocationMode _iRevMode,
X509RevocationFlag _iRevFlag, DateTime _rOnDate, TimeSpan _rCTLTimeOut,
ref IntPtr _hChain, ref string _sError) {
// 0) Проверка наличия сертификата
if (_hCert == IntPtr.Zero) {
_sError = UCConsts.S_CRYPTO_CERT_CHAIN_ERR;
return UConsts.E_NO_CERTIFICATE;
}
// 1) Параметры
CERT_CHAIN_PARA pChainParams = new CERT_CHAIN_PARA();
pChainParams.cbSize = (uint) Marshal.SizeOf(pChainParams);
IntPtr hAppPolicy = IntPtr.Zero;
IntPtr hCertPolicy = IntPtr.Zero;
try {
// 2) Формируем правила приложения
pChainParams.dwUrlRetrievalTimeout = (uint)Math.Floor(_rCTLTimeOut.TotalMilliseconds);
// 3) Время проверки
FILETIME pVerifyTime = new FILETIME(_rOnDate.ToFileTime());
// 4) Формируем флаг
uint _iFlags = MapRevocationFlags(_iRevMode, _iRevFlag);
// 5) Формирование цепочки
if (!UCryptoAPI.CertGetCertificateChain(_hChainEngine, _hCert, ref pVerifyTime,
IntPtr.Zero, ref pChainParams, _iFlags,
IntPtr.Zero, ref _hChain)) {
_sError = UCConsts.S_CRYPTO_CHAIN_BUILD_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
} catch(Exception E) {
_sError = UCConsts.S_CRYPTO_CHAIN_GEN_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;
} finally {
Marshal.FreeHGlobal(hAppPolicy);
Marshal.FreeHGlobal(hCertPolicy);
}
return UConsts.S_OK;
}
Это более сжатое объяснение того, как формируется цепочка, чем то, как это делает Microsoft. OID-ami можно использовать для заполнения HCERTPOLSY и HAPPPPPOLICY, которые показывают права на действия в проверяемом сертификате. Однако, если мы не проверим их в примере, то будем считать их безнадежными.
Кроме того, хранилище сертификатов (например, добавляется к параметру построения цепи (извлекается из подписи).
Вы можете использовать метод MapRevocationFlags из источника. Не внося никаких изменений, он просто создает флаги на основе набора передаваемых сигналов.
Установка ключа в криптопро | newman блог
Лучший способ сделать тестовый ключ в КриптоПро. Эта информация объясняет, как вставить в систему уже имеющийся у вас ключ. с которым центр сертификации предоставил. или который дал вам клиент для устранения неполадок. Обычно «ключ» представляет собой папку с произвольным именем, внутри которой находятся шесть файлов.key и семь файлов jpeg.
Данный ключ необходимо установить в систему, чтобы в последующем им можно было воспользоваться.
Сначала проверьте, есть ли у текущего пользователя хранилище сертификата:
/opt/cprocsp/bin/amd64/csptest -keyset -enum_cont -fqcn -verifyc
Будет выведен список сертификатов в хранилище в следующем формате:
.HDIMAGEcert1
.HDIMAGEcert2
Папка с именем пользователя в /var/opt/2cproccsp_keys — еще один признак наличия хранилища.
Если HDIMAGE еще не существует, его необходимо создать. При создании используются привилегии root.
/opt/cprocsp/sbin/amd64/cpconfig -hardware reader -add HDIMAGE store
Теперь ключ необходимо добавить в хранилище. Допустим, что папка в новом окне принадлежит пользователю Newkeys.000, и ключ нужно добавить к его имени пользователя.
В данной ситуации папку необходимо скопировать в каталог/Var/OPT/CPROSSP_KEYS Имя пользователя.
После копирования необходимо установить разрешения для файла.
chmod 700 /var/opt/cprocsp/keys/username/newkeys.000 chmod 600 /var/opt/cprocsp/keys/username/newkeys.000/*
Мы должны сделать имя пользователя владельцем файлов, если мы этого еще не сделали.
chown -R username:username /var/opt/cprocsp/keys/username/newkeys.000
Однако лучше всего выполнять все действия в качестве пользователя.
После этого вы можете убедиться, что новый контейнер был добавлен в хранилище. В любом случае это можно сделать с помощью одной и той же команды.
/opt/cprocsp/bin/amd64/csptest -keyset -enum_cont -fqcn -verifyc
Вывод контейнеров начнется с нового терминала. Как правило, он имеет то же имя, что и папка. Или имя контейнера имеет в качестве префикса имя ключевой папки.
К примеру, вывод данной команды может стать следующим
.HDIMAGEcert1
.HDIMAGEcert2
.HDIMAGEnewkeys_KEY_FOR_USER
Проверьте точность этого контейнера и ключи внутри. Командная группа
/opt/cprocsp/bin/amd64/csptest -keyset -check -cont '.HDIMAGEnewkeys_KEY_FOR_USER'
Если все в порядке, утилита выведет информационное сообщение о том, что ключ установлен правильно и сам ключ исправен.
Если сертификат был включен в ключевые файлы, контейнер также должен установить этот сертификат. С помощью команды:
/opt/cprocsp/bin/amd64/certmgr -inst -store uMy -file newkeys.crt -cont .HDIMAGEnewkeys_KEY_FOR_USER'
Выводить список доступных сертификатов
/opt/cprocsp/bin/amd64/certmgr -list
Сертификат и ключ могут затем использоваться как обычно после этого.
Формирование подписи
G OST часто используют невыгодные подписи с одной подписью. Для создания такой подписи достаточно одного блока кода:
/**<summary> Подписывает информацию</summary>
* <param name="_arData">Данные для подписания</param>
* <param name="_pCert">Сертификат</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <param name="_arRes">Подпись сертфииката</param>
* <returns>Стандартый код ошибки, если UConsts.S_OK то все ок</returns>
* **/
public static int SignDataCP(byte[] _arData, X509Certificate2 _pCert, out byte[] _arRes, ref string _sError)
{
_arRes = new byte[0];
// 0) Формируем параметры
CRYPT_SIGN_MESSAGE_PARA pParams = new CRYPT_SIGN_MESSAGE_PARA();
pParams.cbSize = Marshal.SizeOf(typeof(CRYPT_SIGN_MESSAGE_PARA));
pParams.dwMsgEncodingType = (int)(UCConsts.PKCS_7_OR_X509_ASN_ENCODING);
pParams.pSigningCert = _pCert.getRealHandle();
pParams.cMsgCert = 1;
pParams.HashAlgorithm.pszObjId = _pCert.getHashAlgirtmOid();
IntPtr pGlobData = Marshal.AllocHGlobal(_arData.Length);
GCHandle pGC = GCHandle.Alloc(_pCert.getRealHandle(), GCHandleType.Pinned);
try {
pParams.rgpMsgCert = pGC.AddrOfPinnedObject();
Marshal.Copy(_arData, 0, pGlobData, _arData.Length);
uint iLen = 50000;
byte[] arRes = new byte[iLen];
// 1) Формирование подписи
if (!UCryptoAPI.CryptSignMessage(ref pParams, true, 1, new IntPtr[1] { pGlobData },
new uint[1] { (uint)_arData.Length }, arRes, ref iLen)) {
_sError = UCConsts.S_MAKE_SIGN_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
Array.Resize(ref arRes, (int)iLen);
_arRes = arRes;
return UConsts.S_OK;;
} catch (Exception E) {
_sError = UCConsts.S_MAKE_SIGN_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;
} finally {
pGC.Free();
Marshal.FreeHGlobal(pGlobData);
}
}
Структура с параметрами создается во время выполнения метода, после чего вызывается метод подписи. Поля cMsgCert и rgpMSGcert, первое из которых хранит количество сертификатов, зарегистрированных на данные сертификаты, являются пояснениями к структуре параметров, которые могут позволить хранить сертификаты в подписи для формирования полной цепочки.
С помощью метода подписания можно одновременно подать на подпись несколько документов, используя одну подпись. Пользователю вряд ли понравится требование многократно нажимать кнопку «подписать», но это не противоречит 63-ФЗ и может быть очень удобно.
В частности, этот метод терпит неудачу в двух ситуациях, типичных для большинства библиотечных методов (первая с NULL — который обеспечивает требуемую длину буфера). Создайте длинный буфер, а затем разрежьте его по фактической длине, чтобы решить эту задачу.
Отсутствие в сертификате алгоритма хэширования (Digest), используемого для подписи, является единственным реальным недостатком. Если вы просто укажете пустую строку в Windows, она будет автоматически подцеплена.
Тем не менее, есть трюк: Algide сохраняет идентификатор алгоритма хэш -алгоритма, в то время как PSZOID сохраняет информацию об алгоритме подписи (структура CRMT_OID). Кроме того, это уже вопрос техники переименовать Algid в OID:
/**<summary>Получение OID алгоритма хэширования сертификату</summary>
* <param name="_hCertHandle">Хэндл сертификата</param>
* <param name="_sOID">Возвращаемый параметр OID</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <returns>Стандартный код ошибки, если UConsts.S_OK то все ок</returns>
* **/
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));
// Извлекаем AlgID
// через UCryptoAPI.CertAlgIdToOID в Windows первый раз работает, второй падает
byte[] arData = BitConverter.GetBytes(UCryptoAPI.CertOIDToAlgId(pCertInfo.SignatureAlgorithm.pszObjId));
hData = Marshal.AllocHGlobal(arData.Length);
Marshal.Copy(arData, 0, hData, arData.Length);
// Поиск OID
hHashAlgInfo = UCryptoAPI.CryptFindOIDInfo(UCConsts.CRYPT_OID_INFO_ALGID_KEY,
hData,
UCConsts.CRYPT_HASH_ALG_OID_GROUP_ID);
if (hHashAlgInfo == IntPtr.Zero) {
_sError = UCConsts.S_NO_HASH_ALG_ERR.Frm( Marshal.GetLastWin32Error());
return UConsts.E_GEN_EXCEPTION;
}
CRYPT_OID_INFO pHashAlgInfo = (CRYPT_OID_INFO)Marshal.PtrToStructure(hHashAlgInfo, typeof(CRYPT_OID_INFO));
_sOID = pHashAlgInfo.pszOID;
return UConsts.S_OK;
} catch (Exception E) {
_sError = UCConsts.S_DETERM_HASH_ALG_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;
} finally {
Marshal.FreeHGlobal(hData);
}
}
Вы можете быть удивлены, узнав, что OID на нем прост (CertoidToAlgid), если вы тщательно прочитаете код. Имеет смысл использовать обе сложные методы, которые успешно в Linux.
Шифрование
Во многом шифрование и подпись похожи, но выбор правильного алгоритма является основной проблемой. В отличие от подписи, шифрование чаще всего используется в сочетании с одним или несколькими получателями (например, при отправке электронной почты сразу на несколько адресов).
/**<summary>Зашифрованные данные</summary>
* <param name="_arInput">Данные для расшифровки</param>
* <param name="_pCert">Сертификат</param>
* <param name="_arRes">Результат</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <returns>Стандартный код с ошибкой, если UConsts.S_OK то все ок</returns>
* **/
public static int EncryptDataCP(byte[] _arInput, X509Certificate2 _pCert, out byte[] _arRes, ref string _sError) {
_arRes = new byte[0];
try {
// 0) Инициализация параметров
CRYPT_ENCRYPT_MESSAGE_PARA pParams = new CRYPT_ENCRYPT_MESSAGE_PARA();
pParams.dwMsgEncodingType = UCConsts.PKCS_7_OR_X509_ASN_ENCODING;
pParams.ContentEncryptionAlgorithm.pszObjId = _pCert.getEncodeAlgirtmOid();
pParams.cbSize = Marshal.SizeOf(pParams);
// 1) Извлечение длины
int iLen = 0;
if (!UCryptoAPI.CryptEncryptMessage(ref pParams, 1, new IntPtr[] { _pCert.getRealHandle() },
_arInput, _arInput.Length, null, ref iLen)) {
_sError = UCConsts.S_CRYPT_ENCODE_LEN_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
// 2) Второй запрос реальное шифрование
_arRes = new byte[iLen];
if (!UCryptoAPI.CryptEncryptMessage(ref pParams, 1, new IntPtr[] {_pCert.getRealHandle() },
_arInput, _arInput.Length, _arRes, ref iLen)) {
_sError = UCConsts.S_CRYPT_ENCODE_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
return UConsts.S_OK;
} catch (Exception E) {
_sError = UCConsts.S_CRYPT_ENCODE_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;
}
}
Три этапа шифрования — заполнение параметров, расчет длины и, наконец, декодирование. Метод поддерживает режим двух проблем, потому что зашифрованный текст может быть довольно большим.
В примере зашифрован адрес только одного адресата, однако, установив больше методов суммарной обработки и дополнительные сертификаты, можно увеличить количество адресатов.
Опять же, есть проблемы с алгоритмом. Сертификат не содержит информации ни о ком, и ни одно из этих косвенных значений не может быть идентифицировано (как это было возможно с алгоритмом подписи). Провайдеру необходимо будет опубликовать список поддерживаемых алгоритмов:
/**<summary>Получение OID алгоритма шифрования сертификату</summary>
* <param name="_hCertHandle">Хэндл сертификата</param>
* <param name="_sOID">Возвращаемый параметр OID</param>
* <param name="_sError">Возвращаемая строка с ошибкой</param>
* <returns>Стандартный код ошибки, если UConsts.S_OK то все ок</returns>
* **/
internal static int GetEncodeAlgoritmOID(IntPtr _hCertHandle, out string _sOID, ref string _sError) {
bool fNeedRelease = false;
_sOID = "";
uint iKeySpec = 0;
IntPtr hCrypto = IntPtr.Zero;
try {
// 0) Получаем контекст провайдера
if (!UCryptoAPI.CryptAcquireCertificatePrivateKey(_hCertHandle, 0, IntPtr.Zero,
ref hCrypto, ref iKeySpec, ref fNeedRelease)) {
_sError = UCConsts.S_CRYPTO_PROV_INIT_ERR.Frm(Marshal.GetLastWin32Error());
return UConsts.E_CRYPTO_ERR;
}
uint iLen = 1000;
byte[] arData = new byte[1000];
uint iFlag = 1; // Инициализация
// 1) Проходим в цикле по алгоритмам
while (UCryptoAPI.CryptGetProvParam(hCrypto, UCConsts.PP_ENUMALGS, arData, ref iLen, iFlag)){
iFlag = 2; // Следующий
PROV_ENUMALGS pInfo = ConvertBytesToStruct<PROV_ENUMALGS>(arData);
// 2) Пытаемся получить OID в рамках алгоримтов шифрования
byte[] arDataAlg = BitConverter.GetBytes(pInfo.aiAlgid);
IntPtr hDataAlg = Marshal.AllocHGlobal(arDataAlg.Length);
try {
Marshal.Copy(arDataAlg, 0, hDataAlg, arDataAlg.Length);
IntPtr hHashAlgInfo2 = UCryptoAPI.CryptFindOIDInfo(UCConsts.CRYPT_OID_INFO_ALGID_KEY,
hDataAlg,
UCConsts.CRYPT_ENCRYPT_ALG_OID_GROUP_ID);
// 2.1) Нашли - возвращаем
if (hHashAlgInfo2 != IntPtr.Zero) {
CRYPT_OID_INFO pHashAlgInfo2 = (CRYPT_OID_INFO)Marshal.PtrToStructure(hHashAlgInfo2,
typeof(CRYPT_OID_INFO));
_sOID = pHashAlgInfo2.pszOID ;
return UConsts.S_OK;
}
} finally {
Marshal.FreeHGlobal(hDataAlg);
}
}
// 3) Не нашли - ошибка
_sError = UCConsts.S_NO_ENCODE_ALG_ERR;
return UConsts.E_CRYPTO_ERR;
} catch (Exception E) {
_sError = UCConsts.S_DETERM_ENCODE_ALG_ERR.Frm(E.Message);
return UConsts.E_GEN_EXCEPTION;
}finally {
if((hCrypto != IntPtr.Zero) && fNeedRelease) UCryptoAPI.CryptReleaseContext(hCrypto, 0);
}
}
В примере определяется контексты частного ключа и поиск алгоритмов, использующих их. Только шифрование необходимо отфильтровать, потому что список уже включает в себя все алгоритмы (обмен ключами, хэшинг и подпись). Мы заменяем только компоненты шифрования в Uckonstants (постоянная UC), а не устанавливают их. Если данные расположены, наш алгоритм отвечает.
Алгоритмы также могут быть отфильтрованы по размеру (на основе размеров хэша), если таких алгоритмов несколько.
