mirror of
https://github.com/crypto-pro-web/crypto-pro-js.git
synced 2024-11-24 00:55:00 +03:00
1063 lines
43 KiB
JavaScript
1063 lines
43 KiB
JavaScript
webpackJsonpCryptoPro([1],[
|
||
/* 0 */,
|
||
/* 1 */,
|
||
/* 2 */,
|
||
/* 3 */,
|
||
/* 4 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
var cryptoCommon = __webpack_require__(5),
|
||
cryptoConstants = __webpack_require__(7),
|
||
_certListCache;
|
||
|
||
function Certificate(item) {
|
||
this._cert = item._cert;
|
||
this.thumbprint = item.thumbprint;
|
||
this.subjectName = item.subjectName;
|
||
this.issuerName = item.issuerName;
|
||
this.validFrom = item.validFrom;
|
||
this.validTo = item.validTo;
|
||
}
|
||
|
||
/**
|
||
* Проверяет, валиден ли сертификат
|
||
* */
|
||
Certificate.prototype.isValid = function isValid() {
|
||
var cert = this._cert;
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var result;
|
||
|
||
try {
|
||
result = yield cert.IsValid();
|
||
result = yield result.Result;
|
||
} catch (err) {
|
||
reject('Ошибка при проверке сертификата: ', err.message);
|
||
return;
|
||
}
|
||
|
||
resolve(result);
|
||
});
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Достает указанное свойство у сертификата
|
||
* */
|
||
Certificate.prototype.getProp = function (propName) {
|
||
var cert = this._cert;
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var result;
|
||
|
||
try {
|
||
result = yield cert[propName];
|
||
} catch (err) {
|
||
reject('Ошибка при обращении к свойству сертификата: ', err.message);
|
||
return;
|
||
}
|
||
|
||
resolve(result);
|
||
});
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Экспорт base64 представления сертификата пользователя
|
||
* */
|
||
Certificate.prototype.exportBase64 = function exportBase64() {
|
||
var cert = this._cert;
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var base64;
|
||
|
||
try {
|
||
base64 = yield cert.Export(0);
|
||
} catch (err) {
|
||
reject('Ошибка при экспорте сертификата: ', err.message);
|
||
return;
|
||
}
|
||
|
||
resolve(base64);
|
||
});
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Возвращает информацию об алгоритме
|
||
* */
|
||
Certificate.prototype.getAlgorithm = function getAlgorithm() {
|
||
var cert = this._cert;
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var result = {},
|
||
algorithm;
|
||
|
||
try {
|
||
algorithm = yield cert.PublicKey();
|
||
algorithm = yield algorithm.Algorithm;
|
||
|
||
result.algorithm = yield algorithm.FriendlyName;
|
||
result.oid = yield algorithm.Value;
|
||
} catch (err) {
|
||
reject('Ошибка при получении алгоритма: ', err.message);
|
||
return;
|
||
}
|
||
|
||
resolve(result);
|
||
});
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Разбирает SubjectName сертификата по тэгам
|
||
* */
|
||
Certificate.prototype.getOwnerInfo = function getOwnerInfo() {
|
||
return getCertInfo.call(this, cryptoCommon.subjectNameTagsTranslations, 'SubjectName');
|
||
};
|
||
|
||
/**
|
||
* Разбирает IssuerName сертификата по тэгам
|
||
* */
|
||
Certificate.prototype.getIssuerInfo = function getIssuerInfo() {
|
||
return getCertInfo.call(this, cryptoCommon.issuerNameTagsTranslations, 'IssuerName');
|
||
};
|
||
|
||
/**
|
||
* Получение OID сертификата
|
||
*
|
||
* @returns {Array} Возвращает массив OID (улучшенного ключа)
|
||
* */
|
||
Certificate.prototype.getExtendedKeyUsage = function getExtendedKeyUsage() {
|
||
var cert = this._cert;
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var OIDS = [],
|
||
count,
|
||
item;
|
||
|
||
try {
|
||
count = yield cert.ExtendedKeyUsage();
|
||
count = yield count.EKUs;
|
||
count = yield count.Count;
|
||
|
||
if (count > 0) {
|
||
while (count > 0) {
|
||
item = yield cert.ExtendedKeyUsage();
|
||
item = yield item.EKUs;
|
||
item = yield item.Item(count);
|
||
item = yield item.OID;
|
||
|
||
OIDS.push(item);
|
||
|
||
count--;
|
||
}
|
||
}
|
||
} catch (err) {
|
||
reject('Ошибка при получении ОИД\'ов: ', err.message);
|
||
return;
|
||
}
|
||
|
||
resolve(OIDS);
|
||
});
|
||
});
|
||
};
|
||
|
||
Certificate.prototype.getDecodedExtendedKeyUsage = cryptoCommon.getDecodedExtendedKeyUsage;
|
||
|
||
Certificate.prototype.hasExtendedKeyUsage = cryptoCommon.hasExtendedKeyUsage;
|
||
|
||
/**
|
||
* Проверяет корректность настроек ЭП на машине
|
||
* */
|
||
function isValidEDSSettings() {
|
||
return new Promise(function (resolve, reject) {
|
||
eval(cryptoCommon.execute(function () {
|
||
var result;
|
||
|
||
try {
|
||
result = cryptoCommon.createObj('CAdESCOM.About');
|
||
} catch (error) {
|
||
reject('Настройки ЭП на данной машине не верны');
|
||
}
|
||
|
||
resolve();
|
||
}));
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Получить сертификат в формате cades по хэшу
|
||
* */
|
||
function getCadesCert(hash) {
|
||
return new Promise(function (resolve, reject) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var oStore = yield cadesplugin.CreateObjectAsync('CAdESCOM.Store'),
|
||
certs,
|
||
certCnt,
|
||
cert;
|
||
|
||
if (!oStore) {
|
||
reject('Не удалось получить доступ к хранилищу сертификатов');
|
||
return;
|
||
}
|
||
|
||
// Открываем хранилище
|
||
try {
|
||
yield oStore.Open(
|
||
cadesplugin.CAPICOM_CURRENT_USER_STORE,
|
||
cadesplugin.CAPICOM_MY_STORE,
|
||
cadesplugin.CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED
|
||
);
|
||
} catch (err) {
|
||
reject('Ошибка при открытии хранилища: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
// Получаем доступ к сертификатам
|
||
try {
|
||
certs = yield oStore.Certificates;
|
||
certCnt = yield certs.Count;
|
||
} catch (err) {
|
||
reject('Ошибка получения списка сертификатов: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
if (!certCnt) {
|
||
reject('Нет доступных сертификатов');
|
||
return;
|
||
}
|
||
|
||
// Получаем сертификат по хэшу
|
||
try {
|
||
certs = yield certs.Find(cadesplugin.CAPICOM_CERTIFICATE_FIND_SHA1_HASH, hash);
|
||
|
||
if (certs.Count) {
|
||
cert = yield certs.Item(1);
|
||
} else {
|
||
throw new Error(hash);
|
||
}
|
||
} catch (err) {
|
||
reject('Не удалось получить сертификат по хэшу: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
oStore.Close();
|
||
|
||
resolve(cert);
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Разбирает информацию сертификата по тэгам
|
||
* */
|
||
function getCertInfo(tags, propName) {
|
||
var cert = this._cert;
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var propInfo;
|
||
|
||
try {
|
||
propInfo = yield cert[propName];
|
||
} catch (err) {
|
||
reject('Ошибка при извлечении данных из сертификата: ', err.message);
|
||
return;
|
||
}
|
||
|
||
resolve(cryptoCommon.parseCertInfo(tags, propInfo));
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Возвращает список сертификатов, доступных в системе
|
||
*
|
||
* @param {Boolean} [resetCache=false] -- нужно ли сбросить кэш списка сертификатов
|
||
* @returns {Promise} -- со списком сертификатов {Array}
|
||
* */
|
||
function getCertsList(resetCache) {
|
||
return new Promise(function (resolve, reject) {
|
||
if (!resetCache && _certListCache) {
|
||
resolve(_certListCache);
|
||
return;
|
||
}
|
||
|
||
eval(cryptoCommon.execute(function () {
|
||
var oStore = 'yield' + cryptoCommon.createObj('CAdESCOM.Store'),
|
||
result = [],
|
||
certs,
|
||
count,
|
||
item;
|
||
|
||
// Открываем хранилище
|
||
try {
|
||
'yield' + oStore.Open(
|
||
cadesplugin.CAPICOM_CURRENT_USER_STORE,
|
||
cadesplugin.CAPICOM_MY_STORE,
|
||
cadesplugin.CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED
|
||
);
|
||
} catch (err) {
|
||
reject('Ошибка при открытии хранилища: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
// Получаем доступ к сертификатам
|
||
try {
|
||
certs = 'yield' + oStore.Certificates;
|
||
|
||
if (certs) {
|
||
certs = 'yield' + certs.Find(cadesplugin.CAPICOM_CERTIFICATE_FIND_TIME_VALID);
|
||
/**
|
||
* Не рассматриваются сертификаты, в которых отсутствует закрытый ключ
|
||
* или не действительны на данный момент
|
||
* */
|
||
certs = 'yield' + certs.Find(
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_EXTENDED_PROPERTY,
|
||
cryptoConstants.PropId.CAPICOM_PROPID_KEY_PROV_INFO
|
||
);
|
||
|
||
count = 'yield' + certs.Count;
|
||
}
|
||
} catch (err) {
|
||
reject('Ошибка получения списка сертификатов: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
if (!count) {
|
||
reject('Нет доступных сертификатов');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
while (count) {
|
||
item = 'yield' + certs.Item(count);
|
||
|
||
result.push(new Certificate({
|
||
_cert: 'yield' + item,
|
||
thumbprint: 'yield' + item.Thumbprint,
|
||
subjectName: 'yield' + item.SubjectName,
|
||
issuerName: 'yield' + item.IssuerName,
|
||
validFrom: 'yield' + item.ValidFromDate,
|
||
validTo: 'yield' + item.ValidToDate
|
||
}));
|
||
|
||
count--;
|
||
}
|
||
} catch (err) {
|
||
reject('Ошибка обработки сертификатов: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
oStore.Close();
|
||
|
||
_certListCache = cryptoCommon.prepareCertsInfo(result);
|
||
|
||
resolve(_certListCache);
|
||
}));
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Получить сертификат по хэшу
|
||
* */
|
||
function getCert(hash) {
|
||
return new Promise(function (resolve, reject) {
|
||
if (!hash) {
|
||
reject('Хэш не указан');
|
||
return;
|
||
}
|
||
|
||
getCertsList().then(function (list) {
|
||
var foundCert;
|
||
|
||
list.some(function (cert) {
|
||
if (hash === cert.thumbprint) {
|
||
foundCert = cert;
|
||
return true;
|
||
}
|
||
});
|
||
|
||
if (foundCert) {
|
||
resolve(foundCert);
|
||
} else {
|
||
reject('Сертификат с хэшем: "' + hash + '" не найден');
|
||
}
|
||
}, reject);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Создает подпись base64 строки по hash'у сертификата
|
||
*
|
||
* @param {String} hash -- fingerprint (thumbprint) сертификата
|
||
* @param {String} dataBase64 -- строковые данные в формате base64
|
||
* @param {Boolean} signType -- тип подписи открепленная (true) / присоединенная (false) (default: true)
|
||
* @returns {Promise} -- обещание, которое зарезолвится с данными о подписи {String}
|
||
* */
|
||
function signData(hash, dataBase64, signType) {
|
||
signType = typeof signType === 'undefined' ? true : Boolean(signType);
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
getCadesCert(hash).then(function (cert) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var clientTime = new Date(),
|
||
oAttrs = yield cadesplugin.CreateObjectAsync('CADESCOM.CPAttribute'),
|
||
oSignedData = yield cadesplugin.CreateObjectAsync('CAdESCOM.CadesSignedData'),
|
||
oSigner = yield cadesplugin.CreateObjectAsync('CAdESCOM.CPSigner'),
|
||
attrs,
|
||
signature;
|
||
|
||
clientTime = cryptoCommon.getDateObj(clientTime);
|
||
|
||
try {
|
||
yield oAttrs.propset_Name(cryptoConstants.Time.AUTHENTICATED_ATTRIBUTE_SIGNING_TIME);
|
||
yield oAttrs.propset_Value(clientTime);
|
||
} catch (err) {
|
||
reject('Ошибка при установке данных подписи: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
// Задаем настройки для подписи
|
||
try {
|
||
yield oSigner.propset_Certificate(cert);
|
||
attrs = yield oSigner.AuthenticatedAttributes2;
|
||
yield attrs.Add(oAttrs);
|
||
yield oSignedData.propset_ContentEncoding(cadesplugin.CADESCOM_BASE64_TO_BINARY);
|
||
yield oSignedData.propset_Content(dataBase64);
|
||
yield oSigner.propset_Options(cadesplugin.CAPICOM_CERTIFICATE_INCLUDE_END_ENTITY_ONLY);
|
||
} catch (err) {
|
||
reject('Не удалось установить настройки для подписи: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
signature = yield oSignedData.SignCades(
|
||
oSigner,
|
||
cadesplugin.CADESCOM_CADES_BES,
|
||
signType
|
||
);
|
||
} catch (err) {
|
||
reject('Не удалось создать подпись: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
resolve(signature);
|
||
});
|
||
}, reject);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Создает подпись XML строки по hash'у сертификата
|
||
*
|
||
* @param {String} hash -- fingerprint (thumbprint) сертификата
|
||
* @param {String} dataXML -- данные в формате XML
|
||
* @returns {Promise} -- обещание, которое зарезолвится с данными о подписи {String}
|
||
* */
|
||
function signDataXML(hash, dataXML) {
|
||
return new Promise(function (resolve, reject) {
|
||
getCadesCert(hash).then(function (cert) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var oSigner = yield cadesplugin.CreateObjectAsync('CAdESCOM.CPSigner'),
|
||
signerXML = yield cadesplugin.CreateObjectAsync('CAdESCOM.SignedXML'),
|
||
cnts = cryptoConstants,
|
||
signature;
|
||
|
||
// Задаем настройки для подписи
|
||
try {
|
||
yield oSigner.propset_Certificate(cert);
|
||
// Добавляем данные для подписи
|
||
yield signerXML.propset_Content(dataXML);
|
||
// Устанавливаем тип подписи
|
||
yield signerXML.propset_SignatureType(cnts.SignatureType.CADESCOM_XML_SIGNATURE_TYPE_ENVELOPED);
|
||
// Устанавливаем алгоритм подписи
|
||
yield signerXML.propset_SignatureMethod(cnts.GostXmlDSigUrls.XmlDsigGost3410Url);
|
||
// Устанавливаем алгоритм хэширования
|
||
yield signerXML.propset_DigestMethod(cnts.GostXmlDSigUrls.XmlDsigGost3411Url);
|
||
} catch (err) {
|
||
reject('Не удалось установить настройки для подписи: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
signature = yield signerXML.Sign(oSigner);
|
||
} catch (err) {
|
||
reject('Не удалось создать подпись: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
resolve(signature);
|
||
});
|
||
}, reject);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Возвращает информацию о версии CSP и плагина
|
||
* */
|
||
function getSystemInfo() {
|
||
var sysInfo = cryptoCommon.getEnvInfo();
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
cadesplugin.async_spawn(function* () {
|
||
var e;
|
||
|
||
try {
|
||
e = yield cadesplugin.CreateObjectAsync('CAdESCOM.About');
|
||
|
||
sysInfo.cadesVersion = yield e.PluginVersion;
|
||
// Возможен вызов в ранних версиях в виде sysInfo.cspVersion = yield e.CSPVersion('', 75);
|
||
sysInfo.cspVersion = yield e.CSPVersion();
|
||
|
||
if (!sysInfo.cadesVersion) {
|
||
sysInfo.cadesVersion = yield e.Version;
|
||
}
|
||
|
||
sysInfo.cadesVersion = yield sysInfo.cadesVersion.toString();
|
||
sysInfo.cspVersion = yield sysInfo.cspVersion.toString();
|
||
|
||
resolve(sysInfo);
|
||
} catch (err) {
|
||
reject('Ошибка при получении информации о системе: ', err.message);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Promise обертка для синхронного вызова проверки версии CSP
|
||
* */
|
||
function isValidCSPVersion(version) {
|
||
return new Promise(function (resolve) {
|
||
resolve(cryptoCommon.isValidCSPVersion(version));
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Promise обертка для синхронного вызова проверки версии плагина
|
||
* */
|
||
function isValidCadesVersion(version) {
|
||
return new Promise(function (resolve) {
|
||
resolve(cryptoCommon.isValidCadesVersion(version));
|
||
});
|
||
}
|
||
|
||
module.exports = {
|
||
isValidEDSSettings: isValidEDSSettings,
|
||
getCertsList: getCertsList,
|
||
getCert: getCert,
|
||
signData: signData,
|
||
signDataXML: signDataXML,
|
||
getSystemInfo: getSystemInfo,
|
||
isValidCSPVersion: isValidCSPVersion,
|
||
isValidCadesVersion: isValidCadesVersion
|
||
};
|
||
|
||
/***/ },
|
||
/* 5 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
var bowser = __webpack_require__(1);
|
||
var oids = __webpack_require__(6);
|
||
|
||
var subjectNameTagsTranslations = [
|
||
{possibleNames: ['UnstructuredName'], translation: 'Неструктурированное имя'},
|
||
{possibleNames: ['CN'], translation: 'Владелец'},
|
||
{possibleNames: ['SN'], translation: 'Фамилия'},
|
||
{possibleNames: ['G'], translation: 'Имя Отчество'},
|
||
{possibleNames: ['C'], translation: 'Страна'},
|
||
{possibleNames: ['S'], translation: 'Регион'},
|
||
{possibleNames: ['STREET'], translation: 'Адрес'},
|
||
{possibleNames: ['O'], translation: 'Компания'},
|
||
{possibleNames: ['OU'], translation: 'Отдел/подразделение'},
|
||
{possibleNames: ['T'], translation: 'Должность'},
|
||
{possibleNames: ['ОГРН', 'OGRN'], translation: 'ОГРН'},
|
||
{possibleNames: ['ОГРНИП', 'OGRNIP'], translation: 'ОГРНИП'},
|
||
{possibleNames: ['СНИЛС', 'SNILS'], translation: 'СНИЛС'},
|
||
{possibleNames: ['ИНН', 'INN'], translation: 'ИНН'},
|
||
{possibleNames: ['E'], translation: 'Email'},
|
||
{possibleNames: ['L'], translation: 'Город'}
|
||
],
|
||
|
||
issuerNameTagsTranslations = [
|
||
{possibleNames: ['UnstructuredName'], translation: 'Неструктурированное имя'},
|
||
{possibleNames: ['CN'], translation: 'Удостоверяющий центр'},
|
||
{possibleNames: ['S'], translation: 'Регион'},
|
||
{possibleNames: ['C'], translation: 'Страна'},
|
||
{possibleNames: ['STREET'], translation: 'Адрес'},
|
||
{possibleNames: ['O'], translation: 'Компания'},
|
||
{possibleNames: ['OU'], translation: 'Тип'},
|
||
{possibleNames: ['T'], translation: 'Должность'},
|
||
{possibleNames: ['ОГРН', 'OGRN'], translation: 'ОГРН'},
|
||
{possibleNames: ['ОГРНИП', 'OGRNIP'], translation: 'ОГРНИП'},
|
||
{possibleNames: ['СНИЛС', 'SNILS'], translation: 'СНИЛС'},
|
||
{possibleNames: ['ИНН', 'INN'], translation: 'ИНН'},
|
||
{possibleNames: ['E'], translation: 'Email'},
|
||
{possibleNames: ['L'], translation: 'Город'}
|
||
];
|
||
|
||
function execute(cb) {
|
||
if (cadesplugin.CreateObjectAsync) {
|
||
var GeneratorFunction = (new Function('', 'return Object.getPrototypeOf(function*(){}).constructor'))();
|
||
|
||
cb = String(cb);
|
||
|
||
var args = cb.match(/^function\s*?\((.*?)\)/);
|
||
|
||
args = (args && args[1]) || '';
|
||
|
||
cb = cb.replace(/^.*?{([\s\S]*?)}$/, '$1');
|
||
|
||
cb = String(new GeneratorFunction(args, cb));
|
||
|
||
cb = cb.replace(/cryptoCommon\.createObj(\([\s\S]*?\))/gm, 'cadesplugin.CreateObjectAsync$1');
|
||
cb = cb.replace(/("|')(yield)(\1)\s*?\+\s*?\b/gm, '$2 ');
|
||
|
||
return 'cadesplugin.async_spawn(' + cb + ');';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Парсит информацию из строки с информацией о сертификате
|
||
* */
|
||
function parseCertInfo(tags, infoString) {
|
||
/**
|
||
* Пример входной строки:
|
||
*
|
||
|
||
T=Генеральный директор, UnstructuredName="INN=7811514257/KPP=781101001/OGRN=1127847087884",
|
||
STREET="Крыленко, д.3, лит.Б", CN=Король Анатолий Евгеньевич, G=Анатолий Евгеньевич, SN=Король,
|
||
OU=Администрация, O="ООО ""Аксиома""", L=Санкт-Петербург, S=78 г. Санкт-Петербург, C=RU, E=korol@sferasro.ru,
|
||
INN=007811514257, OGRN=1127847087884, SNILS=11617693460
|
||
|
||
* */
|
||
var result = infoString.match(/([а-яА-Яa-zA-Z0-9\.]+)=(?:("[^"]+?")|(.+?))(?:,|$)/g);
|
||
|
||
if (result) {
|
||
result = result.map(function (group) {
|
||
/**
|
||
* Пример входной строки:
|
||
*
|
||
|
||
UnstructuredName="INN=7811514257/KPP=781101001/OGRN=1127847087884",
|
||
|
||
* */
|
||
var parts = group.match(/^([а-яА-Яa-zA-Z0-9\.]+)=(.+?),?$/),
|
||
title = parts && parts[1],
|
||
descr = parts && parts[2],
|
||
translated = false,
|
||
oidTitle;
|
||
|
||
// Если тайтл содержит ОИД, пытаемся расшифровать
|
||
if (/^OID./.test(title)) {
|
||
oidTitle = title.match(/^OID\.(.*)/);
|
||
|
||
if (oidTitle && oidTitle[1]) {
|
||
oidTitle = oids[oidTitle[1]];
|
||
|
||
if (oidTitle) {
|
||
title = oidTitle;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Вырезаем лишние кавычки
|
||
descr = descr.replace(/^"(.*)"/, '$1');
|
||
descr = descr.replace(/"{2}/g, '"');
|
||
|
||
tags.some(function (tag) {
|
||
return tag.possibleNames.some(function (possible) {
|
||
var match = possible === title;
|
||
|
||
if (match) {
|
||
title = tag.translation;
|
||
translated = true;
|
||
}
|
||
|
||
return match;
|
||
});
|
||
});
|
||
|
||
return {
|
||
title: title,
|
||
descr: descr,
|
||
translated: translated
|
||
};
|
||
});
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* Возвращает дату в формате (dd.mm.yyyy hh:mm:ss) из строки, формата, используемого плагином cryptoPro
|
||
* */
|
||
function getReadableDate(date) {
|
||
date = new Date(date);
|
||
|
||
return ([
|
||
date.getDate(),
|
||
date.getMonth() + 1,
|
||
date.getFullYear()
|
||
].join('.') + ' ' + [
|
||
date.getHours(),
|
||
date.getMinutes(),
|
||
date.getSeconds()
|
||
].join(':')).replace(/\b(\d)\b/g, '0$1');
|
||
}
|
||
|
||
/**
|
||
* Преобразует дату для IE
|
||
* */
|
||
function getDateObj(dateObj) {
|
||
return bowser.msie ? dateObj.getVarDate() : dateObj;
|
||
}
|
||
|
||
/**
|
||
* Подготавливает информацию о сертификатах
|
||
* */
|
||
function prepareCertsInfo(items) {
|
||
return items.map(function (c) {
|
||
c.name = c.subjectName.match(/CN=(.+?),/);
|
||
|
||
// Удалось ли вытащить Common Name
|
||
if (c.name && c.name[1]) {
|
||
c.name = c.name[1];
|
||
}
|
||
|
||
c.validFrom = getReadableDate(c.validFrom);
|
||
c.validTo = getReadableDate(c.validTo);
|
||
|
||
c.label = c.name + ' (до ' + c.validTo + ')';
|
||
|
||
return c;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Возвращает расшифрованные ОИД'ы
|
||
* */
|
||
function getDecodedExtendedKeyUsage() {
|
||
var that = this;
|
||
|
||
return new Promise(function (resolve) {
|
||
that.getExtendedKeyUsage().then(function (certOids) {
|
||
resolve(certOids.reduce(function (oidsLst, oid) {
|
||
oid = {
|
||
id: oid,
|
||
descr: oids[oid] || null
|
||
};
|
||
|
||
if (oid.descr) {
|
||
oidsLst.unshift(oid);
|
||
} else {
|
||
oidsLst.push(oid);
|
||
}
|
||
|
||
return oidsLst;
|
||
}, []));
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Проверка наличия ОИД'а(ОИД'ов) у сертификата
|
||
*
|
||
* @param {String|Array} oids - ОИД'ы для проверки
|
||
* @returns {Promise} с отложенным результатом типа {Boolean}
|
||
* */
|
||
function hasExtendedKeyUsage(oids) {
|
||
var that = this;
|
||
|
||
return new Promise(function (resolve) {
|
||
that.getExtendedKeyUsage().then(function (certOids) {
|
||
var result;
|
||
|
||
if (Array.isArray(oids)) {
|
||
result = oids.every(function (oidToCheck) {
|
||
return certOids.some(function (certOid) {
|
||
return certOid === oidToCheck;
|
||
});
|
||
});
|
||
} else {
|
||
result = certOids.some(function (certOid) {
|
||
return certOid === oids;
|
||
});
|
||
}
|
||
|
||
resolve(result);
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Выводит информацию о системе пользователя
|
||
* */
|
||
function getEnvInfo() {
|
||
var parsed = bowser._detect(navigator.userAgent),
|
||
info = {
|
||
browserName: parsed.name,
|
||
browserVersion: parsed.version
|
||
};
|
||
|
||
if (parsed.mac) {
|
||
info.os = 'Mac';
|
||
} else if (parsed.windows) {
|
||
info.os = 'Windows';
|
||
} else if (parsed.linux) {
|
||
info.os = 'Linux';
|
||
}
|
||
|
||
return info;
|
||
}
|
||
|
||
/**
|
||
* Подходящая ли версия CSP
|
||
* */
|
||
function isValidCSPVersion(version) {
|
||
version = version.match(/\d+?\b(?:\.\d+)?/);
|
||
|
||
return version >= 3.6;
|
||
}
|
||
|
||
/**
|
||
* Подходящая ли версия cades плагина
|
||
* */
|
||
function isValidCadesVersion(version) {
|
||
version = version.split('.').reduce(function (verInfo, number, i) {
|
||
if (i === 0) {
|
||
verInfo.major = number;
|
||
} else if (i === 1) {
|
||
verInfo.minor = number;
|
||
} else if (i === 2) {
|
||
verInfo.patch = number;
|
||
}
|
||
|
||
return verInfo;
|
||
}, {});
|
||
|
||
if (version.major < 2) {
|
||
return false;
|
||
}
|
||
|
||
return version.patch >= 12438;
|
||
}
|
||
|
||
module.exports = {
|
||
execute: execute,
|
||
subjectNameTagsTranslations: subjectNameTagsTranslations,
|
||
issuerNameTagsTranslations: issuerNameTagsTranslations,
|
||
parseCertInfo: parseCertInfo,
|
||
getReadableDate: getReadableDate,
|
||
getDateObj: getDateObj,
|
||
prepareCertsInfo: prepareCertsInfo,
|
||
getDecodedExtendedKeyUsage: getDecodedExtendedKeyUsage,
|
||
hasExtendedKeyUsage: hasExtendedKeyUsage,
|
||
getEnvInfo: getEnvInfo,
|
||
isValidCSPVersion: isValidCSPVersion,
|
||
isValidCadesVersion: isValidCadesVersion
|
||
};
|
||
|
||
/***/ },
|
||
/* 6 */
|
||
/***/ function(module, exports) {
|
||
|
||
module.exports = {
|
||
'1.2.840.113549.1.9.2': 'Неструктурированное имя',
|
||
'1.2.643.3.141.1.1': 'РНС ФСС',
|
||
'1.2.643.3.141.1.2': 'КП ФСС',
|
||
'1.2.643.3.131.1.1': 'ИНН',
|
||
'1.3.6.1.5.5.7.3.2': 'Проверка подлинности клиента',
|
||
'1.3.6.1.5.5.7.3.4': 'Защищенная электронная почта',
|
||
'1.2.643.3.8.100.1': 'Сертификат типа "ekey-ГОСТ"',
|
||
'1.2.643.3.8.100.1.1': 'Общее использование в системах ИОК без права заверения финансовых документов',
|
||
'1.2.643.3.8.100.1.2': 'Передача отчетности по ТКС',
|
||
'1.2.643.3.8.100.1.3': 'Оформление взаимных обязательств, соглашений, договоров, актов и т.п.',
|
||
'1.2.643.3.8.100.1.4': 'Внутрикорпоративный документооборот',
|
||
'1.2.643.3.8.100.1.5': 'Использование в системах электронной торговли',
|
||
'1.2.643.3.8.100.1.6': 'Использование в торгово-закупочной системе "ЭЛЕКТРА"',
|
||
'1.2.643.6.2.1.7.2': 'Использование физическим лицом в отношениях, связанных с возникновением, исполнением (осуществлением) и прекращением гражданских прав и обязанностей в отношении инвестиционных паев паевых инвестиционных фондов, в том числе отношения, связанные с учетом и/или фиксацией прав на инвестиционные паи паевых инвестиционных фондов',
|
||
'1.2.643.6.2.1.7.1': 'Использование единоличным исполнительным органом юридического лица или уполномоченными представителями юридического лица в отношениях, связанных с возникновением, исполнением (осуществлением) и прекращением гражданских и иных прав и обязанностей в сфере негосударственного пенсионного обеспечения, негосударственного пенсионного страхования, в сфере деятельности паевых инвестиционных фондов, акционерных инвестиционных фондов, профессиональных участников рынка ценных бумаг, а также связанной с обслуживанием указанной деятельности услуг кредитных и иных организаций',
|
||
'1.3.6.1.4.1.29919.21': 'Использование в системе Портал государственных закупок Ростовской области "Рефери".',
|
||
'1.2.643.3.2.100.65.13.11': 'Использование в системе АИС "Госзакупки" Сахалинской области.',
|
||
'1.2.643.3.8.100.1.7': 'Использование в системе Портал государственных закупок Ставропольского края.',
|
||
'1.2.643.3.8.100.1.8': 'Использование в Единой системе электронной торговли B2B-Center и B2G.',
|
||
'1.2.643.3.8.100.1.9': 'Для участия в электронных торгах и подписания государственного контракта в электронной площадке ОАО «ЕЭТП» уполномоченными лицами участников размещения государственного или муниципального заказа',
|
||
'1.2.643.3.8.100.1.10': 'Для участия в электронных торгах и подписания государственного контракта в информационных системах Тендерного комитета города Москвы уполномоченными лицами участников размещения государственного заказа города Москвы',
|
||
'1.2.643.3.8.100.1.11': 'Подписание электронных документов в автоматизированной информационной системе размещения государственного и муниципального заказа Саратовской области',
|
||
'1.2.643.3.8.100.1.12': 'Использование в системе государственного заказа Иркутской области',
|
||
'1.2.643.3.8.100.1.13': 'Использование в электронной торговой площадке агентства государственного заказа Красноярского края',
|
||
'1.3.6.1.4.1.24138.1.1.8.1': 'Обеспечение юридической значимости в Системе "Электронная Торговая Площадка"',
|
||
'1.2.643.3.8.100.1.14': 'Использование в электронной торговой площадке "Тендер"',
|
||
'1.2.643.6.3': 'Использование в электронных торговых системах и в программном обеспечении, связанным с обменом электронных сообщений',
|
||
'1.2.643.2.2.34.6': 'Пользователь Центра Регистрации',
|
||
'1.2.643.2.39.1.1': 'Использование в программных продуктах системы "1С:Предприятие 8"',
|
||
'1.2.643.5.1.24.2.1.3': 'Формирование документов для получения государственных услуг в сфере ведения государственного кадастра недвижимости со стороны заявителя',
|
||
'1.2.643.5.1.24.2.1.3.1': 'Формирование кадастровым инженером документов для получения государственных услуг в сфере ведения государственного кадастра недвижимости со стороны заявителя',
|
||
'1.2.643.5.1.24.2.2.2': 'Формирование документов как результата оказания услуги со стороны органов регистрации прав',
|
||
'1.2.643.5.1.24.2.2.3': 'Формирование документов для получения государственных услуг в сфере государственной регистрации прав на недвижимое имущество и сделок с ним со стороны заявителя',
|
||
'1.2.643.6.3.1.1': 'Использование на электронных площадок отобранных для проведения аукционах в электронной форме',
|
||
'1.2.643.6.3.1.2.1': 'Тип участника - Юридическое лицо',
|
||
'1.2.643.6.3.1.2.2': 'Тип участника - Физическое лицо',
|
||
'1.2.643.6.3.1.2.3': 'Тип участника - Индивидуальный предприниматель',
|
||
'1.2.643.6.3.1.3.1': 'Участник размещения заказа',
|
||
'1.2.643.6.3.1.4.1': 'Администратор организации',
|
||
'1.2.643.6.3.1.4.2': 'Уполномоченный специалист',
|
||
'1.2.643.6.3.1.4.3': 'Специалист с правом подписи контракта',
|
||
'1.3.643.3.8.100.15': 'Использование в ЭТП "uTender"'
|
||
};
|
||
|
||
/***/ },
|
||
/* 7 */
|
||
/***/ function(module, exports) {
|
||
|
||
module.exports = {
|
||
// CAPICOM_STORE_LOCATION enumeration
|
||
StoreLocation: {
|
||
CAPICOM_MEMORY_STORE: 0,
|
||
CAPICOM_LOCAL_MACHINE_STORE: 1,
|
||
CAPICOM_CURRENT_USER_STORE: 2,
|
||
CAPICOM_ACTIVE_DIRECTORY_USER_STORE: 3,
|
||
CAPICOM_SMART_CARD_USER_STORE: 4
|
||
},
|
||
// CAPICOM_STORE_OPEN_MODE enumeration
|
||
StoreOpenMode: {
|
||
CAPICOM_STORE_OPEN_READ_ONLY: 0,
|
||
CAPICOM_STORE_OPEN_READ_WRITE: 1,
|
||
CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED: 2,
|
||
CAPICOM_STORE_OPEN_EXISTING_ONLY: 128,
|
||
CAPICOM_STORE_OPEN_INCLUDE_ARCHIVED: 256
|
||
},
|
||
// CAPICOM_CERTIFICATE_FIND_TYPE enumeration
|
||
CertFindType: {
|
||
CAPICOM_CERTIFICATE_FIND_SHA1_HASH: 0,
|
||
CAPICOM_CERTIFICATE_FIND_SUBJECT_NAME: 1,
|
||
CAPICOM_CERTIFICATE_FIND_ISSUER_NAME: 2,
|
||
CAPICOM_CERTIFICATE_FIND_ROOT_NAME: 3,
|
||
CAPICOM_CERTIFICATE_FIND_TEMPLATE_NAME: 4,
|
||
CAPICOM_CERTIFICATE_FIND_EXTENSION: 5,
|
||
CAPICOM_CERTIFICATE_FIND_EXTENDED_PROPERTY: 6,
|
||
CAPICOM_CERTIFICATE_FIND_APPLICATION_POLICY: 7,
|
||
CAPICOM_CERTIFICATE_FIND_CERTIFICATE_POLICY: 8,
|
||
CAPICOM_CERTIFICATE_FIND_TIME_VALID: 9,
|
||
CAPICOM_CERTIFICATE_FIND_TIME_NOT_YET_VALID: 10,
|
||
CAPICOM_CERTIFICATE_FIND_TIME_EXPIRED: 11,
|
||
CAPICOM_CERTIFICATE_FIND_KEY_USAGE: 12
|
||
},
|
||
Time: {
|
||
AUTHENTICATED_ATTRIBUTE_SIGNING_TIME: 0
|
||
},
|
||
Check: {
|
||
CHECK_NONE: 0,
|
||
CHECK_TRUSTED_ROOT: 1,
|
||
CHECK_TIME_VALIDITY: 2,
|
||
CHECK_SIGNATURE_VALIDITY: 4,
|
||
CHECK_ONLINE_REVOCATION_STATUS: 8,
|
||
CHECK_OFFLINE_REVOCATION_STATUS: 16,
|
||
TRUST_IS_NOT_TIME_VALID: 1,
|
||
TRUST_IS_NOT_TIME_NESTED: 2,
|
||
TRUST_IS_REVOKED: 4,
|
||
TRUST_IS_NOT_SIGNATURE_VALID: 8,
|
||
TRUST_IS_NOT_VALID_FOR_USAGE: 16,
|
||
TRUST_IS_UNTRUSTED_ROOT: 32,
|
||
TRUST_REVOCATION_STATUS_UNKNOWN: 64,
|
||
TRUST_IS_CYCLIC: 128,
|
||
TRUST_IS_PARTIAL_CHAIN: 65536,
|
||
TRUST_CTL_IS_NOT_TIME_VALID: 131072,
|
||
TRUST_CTL_IS_NOT_SIGNATURE_VALID: 262144,
|
||
TRUST_CTL_IS_NOT_VALID_FOR_USAGE: 524288,
|
||
},
|
||
// CAPICOM_PROPID enumeration
|
||
PropId: {
|
||
CAPICOM_PROPID_UNKNOWN: 0,
|
||
CAPICOM_PROPID_KEY_PROV_HANDLE: 1,
|
||
CAPICOM_PROPID_KEY_PROV_INFO: 2,
|
||
CAPICOM_PROPID_SHA1_HASH: 3,
|
||
CAPICOM_PROPID_HASH_PROP: 3,
|
||
CAPICOM_PROPID_MD5_HASH: 4,
|
||
CAPICOM_PROPID_KEY_CONTEXT: 5,
|
||
CAPICOM_PROPID_KEY_SPEC: 6,
|
||
CAPICOM_PROPID_IE30_RESERVED: 7,
|
||
CAPICOM_PROPID_PUBKEY_HASH_RESERVED: 8,
|
||
CAPICOM_PROPID_ENHKEY_USAGE: 9,
|
||
CAPICOM_PROPID_CTL_USAGE: 9,
|
||
CAPICOM_PROPID_NEXT_UPDATE_LOCATION: 10,
|
||
CAPICOM_PROPID_FRIENDLY_NAME: 11,
|
||
CAPICOM_PROPID_PVK_FILE: 12,
|
||
CAPICOM_PROPID_DESCRIPTION: 13,
|
||
CAPICOM_PROPID_ACCESS_STATE: 14,
|
||
CAPICOM_PROPID_SIGNATURE_HASH: 15,
|
||
CAPICOM_PROPID_SMART_CARD_DATA: 16,
|
||
CAPICOM_PROPID_EFS: 17,
|
||
CAPICOM_PROPID_FORTEZZA_DATA: 18,
|
||
CAPICOM_PROPID_ARCHIVED: 19,
|
||
CAPICOM_PROPID_KEY_IDENTIFIER: 20,
|
||
CAPICOM_PROPID_AUTO_ENROLL: 21,
|
||
CAPICOM_PROPID_PUBKEY_ALG_PARA: 22,
|
||
CAPICOM_PROPID_CROSS_CERT_DIST_POINTS: 23,
|
||
CAPICOM_PROPID_ISSUER_PUBLIC_KEY_MD5_HASH: 24,
|
||
CAPICOM_PROPID_SUBJECT_PUBLIC_KEY_MD5_HASH: 25,
|
||
CAPICOM_PROPID_ENROLLMENT: 26,
|
||
CAPICOM_PROPID_DATE_STAMP: 27,
|
||
CAPICOM_PROPID_ISSUER_SERIAL_NUMBER_MD5_HASH: 28,
|
||
CAPICOM_PROPID_SUBJECT_NAME_MD5_HASH: 29,
|
||
CAPICOM_PROPID_EXTENDED_ERROR_INFO: 30,
|
||
CAPICOM_PROPID_RENEWAL: 64,
|
||
CAPICOM_PROPID_ARCHIVED_KEY_HASH: 65,
|
||
CAPICOM_PROPID_FIRST_RESERVED: 66,
|
||
CAPICOM_PROPID_LAST_RESERVED: 0x00007FFF,
|
||
CAPICOM_PROPID_FIRST_USER: 0x00008000,
|
||
CAPICOM_PROPID_LAST_USER: 0x0000FFFF
|
||
},
|
||
// CADESCOM_XML_SIGNATURE_TYPE enumeration
|
||
SignatureType: {
|
||
CADESCOM_XML_SIGNATURE_TYPE_ENVELOPED: 0,
|
||
CADESCOM_XML_SIGNATURE_TYPE_ENVELOPING: 1,
|
||
CADESCOM_XML_SIGNATURE_TYPE_TEMPLATE: 2
|
||
},
|
||
// CADESCOM_HASH_ALGORITHM enumeration
|
||
HashAlgorithm: {
|
||
CADESCOM_HASH_ALGORITHM_CP_GOST_3411: 100,
|
||
CADESCOM_HASH_ALGORITHM_MD2: 1,
|
||
CADESCOM_HASH_ALGORITHM_MD4: 2,
|
||
CADESCOM_HASH_ALGORITHM_MD5: 3,
|
||
CADESCOM_HASH_ALGORITHM_SHA_256: 4,
|
||
CADESCOM_HASH_ALGORITHM_SHA_384: 5,
|
||
CADESCOM_HASH_ALGORITHM_SHA_512: 6,
|
||
CADESCOM_HASH_ALGORITHM_SHA1: 0
|
||
},
|
||
CadesType: {
|
||
CADESCOM_CADES_DEFAULT: 0,
|
||
CADESCOM_CADES_BES: 1,
|
||
CADESCOM_CADES_X_LONG_TYPE_1: 0x5d
|
||
},
|
||
ContentEncoding: {
|
||
CADESCOM_BASE64_TO_BINARY: 0x01,
|
||
CADESCOM_STRING_TO_UCS2LE: 0x00
|
||
},
|
||
StoreNames: {
|
||
CAPICOM_MY_STORE: 'My'
|
||
},
|
||
Chain: {
|
||
CAPICOM_CERTIFICATE_INCLUDE_CHAIN_EXCEPT_ROOT: 0,
|
||
CAPICOM_CERTIFICATE_INCLUDE_WHOLE_CHAIN: 1,
|
||
CAPICOM_CERTIFICATE_INCLUDE_END_ENTITY_ONLY: 2
|
||
},
|
||
GostXmlDSigUrls: {
|
||
XmlDsigGost3410Url: 'urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr34102001-gostr3411',
|
||
XmlDsigGost3411Url: 'urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr3411',
|
||
XmlDsigGost3410UrlObsolete: 'http://www.w3.org/2001/04/xmldsig-more#gostr34102001-gostr3411',
|
||
XmlDsigGost3411UrlObsolete: 'http://www.w3.org/2001/04/xmldsig-more#gostr3411'
|
||
}
|
||
};
|
||
|
||
/***/ }
|
||
]);
|
||
//# sourceMappingURL=1.crypto-pro.js.map
|