mirror of
https://github.com/crypto-pro-web/crypto-pro-js.git
synced 2024-11-24 00:55:00 +03:00
2557 lines
97 KiB
JavaScript
2557 lines
97 KiB
JavaScript
var CryptoPro =
|
||
/******/ (function(modules) { // webpackBootstrap
|
||
/******/ // The module cache
|
||
/******/ var installedModules = {};
|
||
/******/
|
||
/******/ // The require function
|
||
/******/ function __webpack_require__(moduleId) {
|
||
/******/
|
||
/******/ // Check if module is in cache
|
||
/******/ if(installedModules[moduleId])
|
||
/******/ return installedModules[moduleId].exports;
|
||
/******/
|
||
/******/ // Create a new module (and put it into the cache)
|
||
/******/ var module = installedModules[moduleId] = {
|
||
/******/ exports: {},
|
||
/******/ id: moduleId,
|
||
/******/ loaded: false
|
||
/******/ };
|
||
/******/
|
||
/******/ // Execute the module function
|
||
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
/******/
|
||
/******/ // Flag the module as loaded
|
||
/******/ module.loaded = true;
|
||
/******/
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
/******/
|
||
/******/
|
||
/******/ // expose the modules object (__webpack_modules__)
|
||
/******/ __webpack_require__.m = modules;
|
||
/******/
|
||
/******/ // expose the module cache
|
||
/******/ __webpack_require__.c = installedModules;
|
||
/******/
|
||
/******/ // __webpack_public_path__
|
||
/******/ __webpack_require__.p = "";
|
||
/******/
|
||
/******/ // Load entry module and return exports
|
||
/******/ return __webpack_require__(0);
|
||
/******/ })
|
||
/************************************************************************/
|
||
/******/ ([
|
||
/* 0 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
__webpack_require__(1);
|
||
|
||
var global = Function('return this')(),
|
||
canPromise = Boolean(global.Promise),
|
||
cadesplugin = global.cadesplugin,
|
||
cryptoService = __webpack_require__(2),
|
||
errorMsg = '',
|
||
loadedPlugin = false,
|
||
onLoadCallbacs = [],
|
||
|
||
execOnloadQueue = function execOnloadQueue() {
|
||
onLoadCallbacs.forEach(function (callback) {
|
||
callback();
|
||
});
|
||
},
|
||
|
||
passToWaitOnLoad = function passToWaitOnLoad(callback) {
|
||
if (Object.prototype.toString.call(callback) === '[object Function]') {
|
||
onLoadCallbacs.push(callback);
|
||
}
|
||
},
|
||
|
||
callOnLoad = function callOnLoad(method) {
|
||
loadedPlugin ? method() : passToWaitOnLoad(method);
|
||
},
|
||
|
||
finishLoading = function finishLoading() {
|
||
loadedPlugin = true;
|
||
|
||
execOnloadQueue();
|
||
},
|
||
|
||
call = function call() {
|
||
var args = Array.prototype.slice.call(arguments),
|
||
methodName = args.shift();
|
||
|
||
return new Promise(function (resolve, reject) {
|
||
callOnLoad(function () {
|
||
var method;
|
||
|
||
if (errorMsg) {
|
||
reject(errorMsg);
|
||
return;
|
||
}
|
||
|
||
method = cryptoService[methodName];
|
||
|
||
if (!method) {
|
||
reject('Метод "' + methodName + '" не доступен');
|
||
return;
|
||
}
|
||
|
||
method.apply(null, args).then(resolve, reject);
|
||
});
|
||
});
|
||
};
|
||
|
||
if (cadesplugin) {
|
||
// Уровень отладки (LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_ERROR)
|
||
cadesplugin.set_log_level(cadesplugin.LOG_LEVEL_ERROR);
|
||
|
||
if (canPromise) {
|
||
cadesplugin.then(finishLoading, function () {
|
||
errorMsg = 'КриптоПРО ЭЦП Browser Plug-In не доступен';
|
||
finishLoading();
|
||
});
|
||
} else {
|
||
throw new Error('Не поддерживаются промисы. Необходим полифилл.');
|
||
}
|
||
} else {
|
||
throw new Error('Не подключен модуль для работы с cades plugin');
|
||
}
|
||
|
||
module.exports = {
|
||
call: call
|
||
};
|
||
|
||
/***/ },
|
||
/* 1 */
|
||
/***/ function(module, exports) {
|
||
|
||
;(function () {
|
||
//already loaded
|
||
if(window.cadesplugin)
|
||
return;
|
||
|
||
var pluginObject;
|
||
var plugin_resolved = 0;
|
||
var plugin_reject;
|
||
var plugin_resolve;
|
||
var isOpera = 0;
|
||
var isFireFox = 0;
|
||
var isEdge = 0;
|
||
var isSafari = 0;
|
||
var failed_extensions = 0;
|
||
|
||
var canPromise = !!window.Promise;
|
||
var cadesplugin;
|
||
|
||
if(canPromise)
|
||
{
|
||
cadesplugin = new Promise(function(resolve, reject)
|
||
{
|
||
plugin_resolve = resolve;
|
||
plugin_reject = reject;
|
||
});
|
||
} else
|
||
{
|
||
cadesplugin = {};
|
||
}
|
||
|
||
function check_browser() {
|
||
var ua= navigator.userAgent, tem, M= ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
|
||
if(/trident/i.test(M[1])){
|
||
tem= /\brv[ :]+(\d+)/g.exec(ua) || [];
|
||
return {name:'IE',version:(tem[1] || '')};
|
||
}
|
||
if(M[1]=== 'Chrome'){
|
||
tem= ua.match(/\b(OPR|Edge)\/(\d+)/);
|
||
if(tem!= null) return {name:tem[1].replace('OPR', 'Opera'),version:tem[2]};
|
||
}
|
||
M= M[2]? [M[1], M[2]]: [navigator.appName, navigator.appVersion, '-?'];
|
||
if((tem= ua.match(/version\/(\d+)/i))!= null) M.splice(1, 1, tem[1]);
|
||
return {name:M[0],version:M[1]};
|
||
}
|
||
var browserSpecs = check_browser();
|
||
|
||
function cpcsp_console_log(level, msg){
|
||
//IE9 не может писать в консоль если не открыта вкладка developer tools
|
||
if(typeof(console) === 'undefined')
|
||
return;
|
||
if (level <= cadesplugin.current_log_level ){
|
||
if (level === cadesplugin.LOG_LEVEL_DEBUG)
|
||
console.log("DEBUG: %s", msg);
|
||
if (level === cadesplugin.LOG_LEVEL_INFO)
|
||
console.info("INFO: %s", msg);
|
||
if (level === cadesplugin.LOG_LEVEL_ERROR)
|
||
console.error("ERROR: %s", msg);
|
||
return;
|
||
}
|
||
}
|
||
|
||
function set_log_level(level){
|
||
if (!((level === cadesplugin.LOG_LEVEL_DEBUG) ||
|
||
(level === cadesplugin.LOG_LEVEL_INFO) ||
|
||
(level === cadesplugin.LOG_LEVEL_ERROR))){
|
||
cpcsp_console_log(cadesplugin.LOG_LEVEL_ERROR, "cadesplugin_api.js: Incorrect log_level: " + level);
|
||
return;
|
||
}
|
||
cadesplugin.current_log_level = level;
|
||
if (cadesplugin.current_log_level === cadesplugin.LOG_LEVEL_DEBUG)
|
||
cpcsp_console_log(cadesplugin.LOG_LEVEL_INFO, "cadesplugin_api.js: log_level = DEBUG");
|
||
if (cadesplugin.current_log_level === cadesplugin.LOG_LEVEL_INFO)
|
||
cpcsp_console_log(cadesplugin.LOG_LEVEL_INFO, "cadesplugin_api.js: log_level = INFO");
|
||
if (cadesplugin.current_log_level === cadesplugin.LOG_LEVEL_ERROR)
|
||
cpcsp_console_log(cadesplugin.LOG_LEVEL_INFO, "cadesplugin_api.js: log_level = ERROR");
|
||
if(isNativeMessageSupported())
|
||
{
|
||
if (cadesplugin.current_log_level === cadesplugin.LOG_LEVEL_DEBUG)
|
||
window.postMessage("set_log_level=debug", "*");
|
||
if (cadesplugin.current_log_level === cadesplugin.LOG_LEVEL_INFO)
|
||
window.postMessage("set_log_level=info", "*");
|
||
if (cadesplugin.current_log_level === cadesplugin.LOG_LEVEL_ERROR)
|
||
window.postMessage("set_log_level=error", "*");
|
||
}
|
||
}
|
||
|
||
function set_constantValues()
|
||
{
|
||
cadesplugin.CAPICOM_LOCAL_MACHINE_STORE = 1;
|
||
cadesplugin.CAPICOM_CURRENT_USER_STORE = 2;
|
||
cadesplugin.CADESCOM_LOCAL_MACHINE_STORE = 1;
|
||
cadesplugin.CADESCOM_CURRENT_USER_STORE = 2;
|
||
cadesplugin.CADESCOM_CONTAINER_STORE = 100;
|
||
|
||
cadesplugin.CAPICOM_MY_STORE = "My";
|
||
|
||
cadesplugin.CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED = 2;
|
||
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_SUBJECT_NAME = 1;
|
||
|
||
cadesplugin.CADESCOM_XML_SIGNATURE_TYPE_ENVELOPED = 0;
|
||
cadesplugin.CADESCOM_XML_SIGNATURE_TYPE_ENVELOPING = 1;
|
||
cadesplugin.CADESCOM_XML_SIGNATURE_TYPE_TEMPLATE = 2;
|
||
|
||
cadesplugin.XmlDsigGost3410UrlObsolete = "http://www.w3.org/2001/04/xmldsig-more#gostr34102001-gostr3411";
|
||
cadesplugin.XmlDsigGost3411UrlObsolete = "http://www.w3.org/2001/04/xmldsig-more#gostr3411";
|
||
cadesplugin.XmlDsigGost3410Url = "urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr34102001-gostr3411";
|
||
cadesplugin.XmlDsigGost3411Url = "urn:ietf:params:xml:ns:cpxmlsec:algorithms:gostr3411";
|
||
|
||
cadesplugin.CADESCOM_CADES_DEFAULT = 0;
|
||
cadesplugin.CADESCOM_CADES_BES = 1;
|
||
cadesplugin.CADESCOM_CADES_T = 0x5;
|
||
cadesplugin.CADESCOM_CADES_X_LONG_TYPE_1 = 0x5d;
|
||
cadesplugin.CADESCOM_PKCS7_TYPE = 0xffff;
|
||
|
||
cadesplugin.CADESCOM_ENCODE_BASE64 = 0;
|
||
cadesplugin.CADESCOM_ENCODE_BINARY = 1;
|
||
cadesplugin.CADESCOM_ENCODE_ANY = -1;
|
||
|
||
cadesplugin.CAPICOM_CERTIFICATE_INCLUDE_CHAIN_EXCEPT_ROOT = 0;
|
||
cadesplugin.CAPICOM_CERTIFICATE_INCLUDE_WHOLE_CHAIN = 1;
|
||
cadesplugin.CAPICOM_CERTIFICATE_INCLUDE_END_ENTITY_ONLY = 2;
|
||
|
||
cadesplugin.CAPICOM_CERT_INFO_SUBJECT_SIMPLE_NAME = 0;
|
||
cadesplugin.CAPICOM_CERT_INFO_ISSUER_SIMPLE_NAME = 1;
|
||
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_SHA1_HASH = 0;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_SUBJECT_NAME = 1;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_ISSUER_NAME = 2;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_ROOT_NAME = 3;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_TEMPLATE_NAME = 4;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_EXTENSION = 5;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_EXTENDED_PROPERTY = 6;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_APPLICATION_POLICY = 7;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_CERTIFICATE_POLICY = 8;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_TIME_VALID = 9;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_TIME_NOT_YET_VALID = 10;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_TIME_EXPIRED = 11;
|
||
cadesplugin.CAPICOM_CERTIFICATE_FIND_KEY_USAGE = 12;
|
||
|
||
cadesplugin.CAPICOM_DIGITAL_SIGNATURE_KEY_USAGE = 128;
|
||
|
||
cadesplugin.CAPICOM_PROPID_ENHKEY_USAGE = 9;
|
||
|
||
cadesplugin.CAPICOM_OID_OTHER = 0;
|
||
cadesplugin.CAPICOM_OID_KEY_USAGE_EXTENSION = 10;
|
||
|
||
cadesplugin.CAPICOM_EKU_CLIENT_AUTH = 2;
|
||
cadesplugin.CAPICOM_EKU_SMARTCARD_LOGON = 5;
|
||
cadesplugin.CAPICOM_EKU_OTHER = 0;
|
||
|
||
cadesplugin.CAPICOM_AUTHENTICATED_ATTRIBUTE_SIGNING_TIME = 0;
|
||
cadesplugin.CAPICOM_AUTHENTICATED_ATTRIBUTE_DOCUMENT_NAME = 1;
|
||
cadesplugin.CAPICOM_AUTHENTICATED_ATTRIBUTE_DOCUMENT_DESCRIPTION = 2;
|
||
cadesplugin.CADESCOM_AUTHENTICATED_ATTRIBUTE_SIGNING_TIME = 0;
|
||
cadesplugin.CADESCOM_AUTHENTICATED_ATTRIBUTE_DOCUMENT_NAME = 1;
|
||
cadesplugin.CADESCOM_AUTHENTICATED_ATTRIBUTE_DOCUMENT_DESCRIPTION = 2;
|
||
cadesplugin.CADESCOM_ATTRIBUTE_OTHER = -1;
|
||
|
||
cadesplugin.CADESCOM_STRING_TO_UCS2LE = 0;
|
||
cadesplugin.CADESCOM_BASE64_TO_BINARY = 1;
|
||
|
||
cadesplugin.CADESCOM_DISPLAY_DATA_NONE = 0;
|
||
cadesplugin.CADESCOM_DISPLAY_DATA_CONTENT = 1;
|
||
cadesplugin.CADESCOM_DISPLAY_DATA_ATTRIBUTE = 2;
|
||
|
||
cadesplugin.CADESCOM_ENCRYPTION_ALGORITHM_RC2 = 0;
|
||
cadesplugin.CADESCOM_ENCRYPTION_ALGORITHM_RC4 = 1;
|
||
cadesplugin.CADESCOM_ENCRYPTION_ALGORITHM_DES = 2;
|
||
cadesplugin.CADESCOM_ENCRYPTION_ALGORITHM_3DES = 3;
|
||
cadesplugin.CADESCOM_ENCRYPTION_ALGORITHM_AES = 4;
|
||
cadesplugin.CADESCOM_ENCRYPTION_ALGORITHM_GOST_28147_89 = 25;
|
||
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_SHA1 = 0;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_MD2 = 1;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_MD4 = 2;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_MD5 = 3;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_SHA_256 = 4;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_SHA_384 = 5;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_SHA_512 = 6;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_CP_GOST_3411 = 100;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_CP_GOST_3411_2012_256 = 101;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_CP_GOST_3411_2012_512 = 102;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_CP_GOST_3411_HMAC = 110;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_CP_GOST_3411_2012_256_HMAC = 111;
|
||
cadesplugin.CADESCOM_HASH_ALGORITHM_CP_GOST_3411_2012_512_HMAC = 112;
|
||
|
||
cadesplugin.LOG_LEVEL_DEBUG = 4;
|
||
cadesplugin.LOG_LEVEL_INFO = 2;
|
||
cadesplugin.LOG_LEVEL_ERROR = 1;
|
||
|
||
cadesplugin.CADESCOM_AllowNone = 0;
|
||
cadesplugin.CADESCOM_AllowNoOutstandingRequest = 0x1;
|
||
cadesplugin.CADESCOM_AllowUntrustedCertificate = 0x2;
|
||
cadesplugin.CADESCOM_AllowUntrustedRoot = 0x4;
|
||
cadesplugin.CADESCOM_SkipInstallToStore = 0x10000000;
|
||
}
|
||
|
||
function async_spawn(generatorFunc) {
|
||
function continuer(verb, arg) {
|
||
var result;
|
||
try {
|
||
result = generator[verb](arg);
|
||
} catch (err) {
|
||
return Promise.reject(err);
|
||
}
|
||
if (result.done) {
|
||
return result.value;
|
||
} else {
|
||
return Promise.resolve(result.value).then(onFulfilled, onRejected);
|
||
}
|
||
}
|
||
var generator = generatorFunc(Array.prototype.slice.call(arguments, 1));
|
||
var onFulfilled = continuer.bind(continuer, "next");
|
||
var onRejected = continuer.bind(continuer, "throw");
|
||
return onFulfilled();
|
||
}
|
||
|
||
function isIE() {
|
||
// var retVal = (("Microsoft Internet Explorer" == navigator.appName) || // IE < 11
|
||
// navigator.userAgent.match(/Trident\/./i)); // IE 11
|
||
return (browserSpecs.name === 'IE' || browserSpecs.name === 'MSIE');
|
||
}
|
||
|
||
function isIOS() {
|
||
return (navigator.userAgent.match(/ipod/i) ||
|
||
navigator.userAgent.match(/ipad/i) ||
|
||
navigator.userAgent.match(/iphone/i));
|
||
}
|
||
|
||
function isNativeMessageSupported()
|
||
{
|
||
// В IE работаем через NPAPI
|
||
if(isIE())
|
||
return false;
|
||
// В Edge работаем через NativeMessage
|
||
if(browserSpecs.name === 'Edge') {
|
||
isEdge = true;
|
||
return true;
|
||
}
|
||
// В Chrome, Firefox, Safari и Opera работаем через асинхронную версию в зависимости от версии
|
||
if(browserSpecs.name === 'Opera') {
|
||
isOpera = true;
|
||
if(browserSpecs.version >= 33){
|
||
return true;
|
||
}
|
||
else{
|
||
return false;
|
||
}
|
||
}
|
||
if(browserSpecs.name === 'Firefox') {
|
||
isFireFox = true;
|
||
if(browserSpecs.version >= 52){
|
||
return true;
|
||
}
|
||
else{
|
||
return false;
|
||
}
|
||
}
|
||
if(browserSpecs.name === 'Chrome') {
|
||
if(browserSpecs.version >= 42){
|
||
return true;
|
||
}
|
||
else{
|
||
return false;
|
||
}
|
||
}
|
||
//В Сафари начиная с 12 версии нет NPAPI
|
||
if(browserSpecs.name === 'Safari') {
|
||
isSafari = true;
|
||
if(browserSpecs.version >= 12) {
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Функция активации объектов КриптоПро ЭЦП Browser plug-in
|
||
function CreateObject(name) {
|
||
if (isIOS()) {
|
||
// На iOS для создания объектов используется функция
|
||
// call_ru_cryptopro_npcades_10_native_bridge, определенная в IOS_npcades_supp.js
|
||
return call_ru_cryptopro_npcades_10_native_bridge("CreateObject", [name]);
|
||
}
|
||
if (isIE()) {
|
||
// В Internet Explorer создаются COM-объекты
|
||
if (name.match(/X509Enrollment/i)) {
|
||
try {
|
||
// Объекты CertEnroll пробуем создавать через нашу фабрику,
|
||
// если не получилось то через CX509EnrollmentWebClassFactory
|
||
var objCertEnrollClassFactory = document.getElementById("webClassFactory");
|
||
return objCertEnrollClassFactory.CreateObject(name);
|
||
}
|
||
catch (e) {
|
||
try {
|
||
var objWebClassFactory = document.getElementById("certEnrollClassFactory");
|
||
return objWebClassFactory.CreateObject(name);
|
||
}
|
||
catch (err) {
|
||
throw ("Для создания обьектов X509Enrollment следует настроить веб-узел на использование проверки подлинности по протоколу HTTPS");
|
||
}
|
||
}
|
||
}
|
||
// Объекты CAPICOM и CAdESCOM создаются через CAdESCOM.WebClassFactory
|
||
try {
|
||
var objWebClassFactory = document.getElementById("webClassFactory");
|
||
return objWebClassFactory.CreateObject(name);
|
||
}
|
||
catch (e) {
|
||
// Для версий плагина ниже 2.0.12538
|
||
return new ActiveXObject(name);
|
||
}
|
||
}
|
||
// создаются объекты NPAPI
|
||
return pluginObject.CreateObject(name);
|
||
}
|
||
|
||
function decimalToHexString(number) {
|
||
if (number < 0) {
|
||
number = 0xFFFFFFFF + number + 1;
|
||
}
|
||
|
||
return number.toString(16).toUpperCase();
|
||
}
|
||
|
||
function GetMessageFromException(e) {
|
||
var err = e.message;
|
||
if (!err) {
|
||
err = e;
|
||
} else if (e.number) {
|
||
err += " (0x" + decimalToHexString(e.number) + ")";
|
||
}
|
||
return err;
|
||
}
|
||
|
||
function getLastError(exception) {
|
||
if(isNativeMessageSupported() || isIE() || isIOS() ) {
|
||
return GetMessageFromException(exception);
|
||
}
|
||
|
||
try {
|
||
return pluginObject.getLastError();
|
||
} catch(e) {
|
||
return GetMessageFromException(exception);
|
||
}
|
||
}
|
||
|
||
// Функция для удаления созданных объектов
|
||
function ReleasePluginObjects() {
|
||
return cpcsp_chrome_nmcades.ReleasePluginObjects();
|
||
}
|
||
|
||
// Функция активации асинхронных объектов КриптоПро ЭЦП Browser plug-in
|
||
function CreateObjectAsync(name) {
|
||
return pluginObject.CreateObjectAsync(name);
|
||
}
|
||
|
||
//Функции для IOS
|
||
var ru_cryptopro_npcades_10_native_bridge = {
|
||
callbacksCount : 1,
|
||
callbacks : {},
|
||
|
||
// Automatically called by native layer when a result is available
|
||
resultForCallback : function resultForCallback(callbackId, resultArray) {
|
||
var callback = ru_cryptopro_npcades_10_native_bridge.callbacks[callbackId];
|
||
if (!callback) return;
|
||
callback.apply(null,resultArray);
|
||
},
|
||
|
||
// Use this in javascript to request native objective-c code
|
||
// functionName : string (I think the name is explicit :p)
|
||
// args : array of arguments
|
||
// callback : function with n-arguments that is going to be called when the native code returned
|
||
call : function call(functionName, args, callback) {
|
||
var hasCallback = callback && typeof callback === "function";
|
||
var callbackId = hasCallback ? ru_cryptopro_npcades_10_native_bridge.callbacksCount++ : 0;
|
||
|
||
if (hasCallback)
|
||
ru_cryptopro_npcades_10_native_bridge.callbacks[callbackId] = callback;
|
||
|
||
var iframe = document.createElement("IFRAME");
|
||
var arrObjs = new Array("_CPNP_handle");
|
||
try{
|
||
iframe.setAttribute("src", "cpnp-js-call:" + functionName + ":" + callbackId+ ":" + encodeURIComponent(JSON.stringify(args, arrObjs)));
|
||
} catch(e){
|
||
alert(e);
|
||
}
|
||
document.documentElement.appendChild(iframe);
|
||
iframe.parentNode.removeChild(iframe);
|
||
iframe = null;
|
||
}
|
||
};
|
||
|
||
function call_ru_cryptopro_npcades_10_native_bridge(functionName, array){
|
||
var tmpobj;
|
||
var ex;
|
||
ru_cryptopro_npcades_10_native_bridge.call(functionName, array, function(e, response){
|
||
ex = e;
|
||
var str='tmpobj='+response;
|
||
eval(str);
|
||
if (typeof (tmpobj) === "string"){
|
||
tmpobj = tmpobj.replace(/\\\n/gm, "\n");
|
||
tmpobj = tmpobj.replace(/\\\r/gm, "\r");
|
||
}
|
||
});
|
||
if(ex)
|
||
throw ex;
|
||
return tmpobj;
|
||
}
|
||
|
||
function show_firefox_missing_extension_dialog()
|
||
{
|
||
if (!window.cadesplugin_skip_extension_install)
|
||
{
|
||
var ovr = document.createElement('div');
|
||
ovr.id = "cadesplugin_ovr";
|
||
ovr.style = "visibility: hidden; position: fixed; left: 0px; top: 0px; width:100%; height:100%; background-color: rgba(0,0,0,0.7)";
|
||
ovr.innerHTML = "<div id='cadesplugin_ovr_item' style='position:relative; width:400px; margin:100px auto; background-color:#fff; border:2px solid #000; padding:10px; text-align:center; opacity: 1; z-index: 1500'>" +
|
||
"<button id='cadesplugin_close_install' style='float: right; font-size: 10px; background: transparent; border: 1; margin: -5px'>X</button>" +
|
||
"<p>Для работы КриптоПро ЭЦП Browser plugin на данном сайте необходимо расширение для браузера. Убедитесь, что оно у Вас включено или установите его." +
|
||
"<p><a href='https://www.cryptopro.ru/sites/default/files/products/cades/extensions/firefox_cryptopro_extension_latest.xpi'>Скачать расширение</a></p>" +
|
||
"</div>";
|
||
document.getElementsByTagName("Body")[0].appendChild(ovr);
|
||
document.getElementById("cadesplugin_close_install").addEventListener('click',function()
|
||
{
|
||
plugin_loaded_error("Плагин недоступен");
|
||
document.getElementById("cadesplugin_ovr").style.visibility = 'hidden';
|
||
});
|
||
|
||
ovr.addEventListener('click',function()
|
||
{
|
||
plugin_loaded_error("Плагин недоступен");
|
||
document.getElementById("cadesplugin_ovr").style.visibility = 'hidden';
|
||
});
|
||
ovr.style.visibility="visible";
|
||
}
|
||
}
|
||
|
||
|
||
//Выводим окно поверх других с предложением установить расширение для Opera.
|
||
//Если установленна переменная cadesplugin_skip_extension_install - не предлагаем установить расширение
|
||
function install_opera_extension()
|
||
{
|
||
if (!window.cadesplugin_skip_extension_install)
|
||
{
|
||
document.addEventListener('DOMContentLoaded', function() {
|
||
var ovr = document.createElement('div');
|
||
ovr.id = "cadesplugin_ovr";
|
||
ovr.style = "visibility: hidden; position: fixed; left: 0px; top: 0px; width:100%; height:100%; background-color: rgba(0,0,0,0.7)";
|
||
ovr.innerHTML = "<div id='cadesplugin_ovr_item' style='position:relative; width:400px; margin:100px auto; background-color:#fff; border:2px solid #000; padding:10px; text-align:center; opacity: 1; z-index: 1500'>" +
|
||
"<button id='cadesplugin_close_install' style='float: right; font-size: 10px; background: transparent; border: 1; margin: -5px'>X</button>" +
|
||
"<p>Для работы КриптоПро ЭЦП Browser plugin на данном сайте необходимо установить расширение из каталога дополнений Opera." +
|
||
"<p><button id='cadesplugin_install' style='font:12px Arial'>Установить расширение</button></p>" +
|
||
"</div>";
|
||
document.getElementsByTagName("Body")[0].appendChild(ovr);
|
||
var btn_install = document.getElementById("cadesplugin_install");
|
||
btn_install.addEventListener('click', function(event) {
|
||
opr.addons.installExtension("epebfcehmdedogndhlcacafjaacknbcm",
|
||
function()
|
||
{
|
||
document.getElementById("cadesplugin_ovr").style.visibility = 'hidden';
|
||
location.reload();
|
||
},
|
||
function(){})
|
||
});
|
||
document.getElementById("cadesplugin_close_install").addEventListener('click',function()
|
||
{
|
||
plugin_loaded_error("Плагин недоступен");
|
||
document.getElementById("cadesplugin_ovr").style.visibility = 'hidden';
|
||
});
|
||
|
||
ovr.addEventListener('click',function()
|
||
{
|
||
plugin_loaded_error("Плагин недоступен");
|
||
document.getElementById("cadesplugin_ovr").style.visibility = 'hidden';
|
||
});
|
||
ovr.style.visibility="visible";
|
||
document.getElementById("cadesplugin_ovr_item").addEventListener('click',function(e){
|
||
e.stopPropagation();
|
||
});
|
||
});
|
||
}else
|
||
{
|
||
plugin_loaded_error("Плагин недоступен");
|
||
}
|
||
}
|
||
|
||
function firefox_or_edge_nmcades_onload() {
|
||
cpcsp_chrome_nmcades.check_chrome_plugin(plugin_loaded, plugin_loaded_error);
|
||
}
|
||
|
||
function nmcades_api_onload () {
|
||
window.postMessage("cadesplugin_echo_request", "*");
|
||
window.addEventListener("message", function (event){
|
||
if (typeof(event.data) !== "string" || !event.data.match("cadesplugin_loaded"))
|
||
return;
|
||
if(isFireFox || isEdge || isSafari)
|
||
{
|
||
// Для Firefox, Сафари, Edge вместе с сообщением cadesplugin_loaded прилетает url для загрузки nmcades_plugin_api.js
|
||
var url = event.data.substring(event.data.indexOf("url:") + 4);
|
||
var fileref = document.createElement('script');
|
||
fileref.setAttribute("type", "text/javascript");
|
||
fileref.setAttribute("src", url);
|
||
fileref.onerror = plugin_loaded_error;
|
||
fileref.onload = firefox_or_edge_nmcades_onload;
|
||
document.getElementsByTagName("head")[0].appendChild(fileref);
|
||
// Для Firefox, Safari и Edge у нас только по одному расширению.
|
||
failed_extensions++;
|
||
}else {
|
||
cpcsp_chrome_nmcades.check_chrome_plugin(plugin_loaded, plugin_loaded_error);
|
||
}
|
||
}, false);
|
||
}
|
||
|
||
//Загружаем расширения для Chrome, Opera, YaBrowser, FireFox, Edge, Safari
|
||
function load_extension()
|
||
{
|
||
|
||
if(isFireFox || isEdge || isSafari){
|
||
// вызываем callback руками т.к. нам нужно узнать ID расширения. Он уникальный для браузера.
|
||
nmcades_api_onload();
|
||
} else {
|
||
// в асинхронном варианте для chrome и opera подключаем оба расширения
|
||
var fileref = document.createElement('script');
|
||
fileref.setAttribute("type", "text/javascript");
|
||
fileref.setAttribute("src", "chrome-extension://iifchhfnnmpdbibifmljnfjhpififfog/nmcades_plugin_api.js");
|
||
fileref.onerror = plugin_loaded_error;
|
||
fileref.onload = nmcades_api_onload;
|
||
document.getElementsByTagName("head")[0].appendChild(fileref);
|
||
fileref = document.createElement('script');
|
||
fileref.setAttribute("type", "text/javascript");
|
||
fileref.setAttribute("src", "chrome-extension://epebfcehmdedogndhlcacafjaacknbcm/nmcades_plugin_api.js");
|
||
fileref.onerror = plugin_loaded_error;
|
||
fileref.onload = nmcades_api_onload;
|
||
document.getElementsByTagName("head")[0].appendChild(fileref);
|
||
}
|
||
}
|
||
|
||
//Загружаем плагин для NPAPI
|
||
function load_npapi_plugin()
|
||
{
|
||
var elem = document.createElement('object');
|
||
elem.setAttribute("id", "cadesplugin_object");
|
||
elem.setAttribute("type", "application/x-cades");
|
||
elem.setAttribute("style", "visibility: hidden");
|
||
document.getElementsByTagName("body")[0].appendChild(elem);
|
||
pluginObject = document.getElementById("cadesplugin_object");
|
||
if(isIE())
|
||
{
|
||
var elem1 = document.createElement('object');
|
||
elem1.setAttribute("id", "certEnrollClassFactory");
|
||
elem1.setAttribute("classid", "clsid:884e2049-217d-11da-b2a4-000e7bbb2b09");
|
||
elem1.setAttribute("style", "visibility: hidden");
|
||
document.getElementsByTagName("body")[0].appendChild(elem1);
|
||
var elem2 = document.createElement('object');
|
||
elem2.setAttribute("id", "webClassFactory");
|
||
elem2.setAttribute("classid", "clsid:B04C8637-10BD-484E-B0DA-B8A039F60024");
|
||
elem2.setAttribute("style", "visibility: hidden");
|
||
document.getElementsByTagName("body")[0].appendChild(elem2);
|
||
}
|
||
}
|
||
|
||
//Отправляем событие что все ок.
|
||
function plugin_loaded()
|
||
{
|
||
plugin_resolved = 1;
|
||
if(canPromise)
|
||
{
|
||
plugin_resolve();
|
||
}else {
|
||
window.postMessage("cadesplugin_loaded", "*");
|
||
}
|
||
}
|
||
|
||
//Отправляем событие что сломались.
|
||
function plugin_loaded_error(msg)
|
||
{
|
||
if(isNativeMessageSupported())
|
||
{
|
||
//в асинхронном варианте подключаем оба расширения, если сломались оба пробуем установить для Opera
|
||
failed_extensions++;
|
||
if(failed_extensions<2)
|
||
return;
|
||
if(isOpera && (typeof(msg) === 'undefined'|| typeof(msg) === 'object'))
|
||
{
|
||
install_opera_extension();
|
||
return;
|
||
}
|
||
}
|
||
if(typeof(msg) === 'undefined' || typeof(msg) === 'object')
|
||
msg = "Плагин недоступен";
|
||
plugin_resolved = 1;
|
||
if(canPromise)
|
||
{
|
||
plugin_reject(msg);
|
||
} else {
|
||
window.postMessage("cadesplugin_load_error", "*");
|
||
}
|
||
}
|
||
|
||
//проверяем что у нас хоть какое то событие ушло, и если не уходило кидаем еще раз ошибку
|
||
function check_load_timeout()
|
||
{
|
||
if(plugin_resolved === 1)
|
||
return;
|
||
if(isFireFox)
|
||
{
|
||
show_firefox_missing_extension_dialog();
|
||
}
|
||
plugin_resolved = 1;
|
||
if(canPromise)
|
||
{
|
||
plugin_reject("Истекло время ожидания загрузки плагина");
|
||
} else {
|
||
window.postMessage("cadesplugin_load_error", "*");
|
||
}
|
||
|
||
}
|
||
|
||
//Вспомогательная функция для NPAPI
|
||
function createPromise(arg)
|
||
{
|
||
return new Promise(arg);
|
||
}
|
||
|
||
function check_npapi_plugin (){
|
||
try {
|
||
var oAbout = CreateObject("CAdESCOM.About");
|
||
plugin_loaded();
|
||
}
|
||
catch (err) {
|
||
document.getElementById("cadesplugin_object").style.display = 'none';
|
||
// Объект создать не удалось, проверим, установлен ли
|
||
// вообще плагин. Такая возможность есть не во всех браузерах
|
||
var mimetype = navigator.mimeTypes["application/x-cades"];
|
||
if (mimetype) {
|
||
var plugin = mimetype.enabledPlugin;
|
||
if (plugin) {
|
||
plugin_loaded_error("Плагин загружен, но не создаются обьекты");
|
||
}else
|
||
{
|
||
plugin_loaded_error("Ошибка при загрузке плагина");
|
||
}
|
||
}else
|
||
{
|
||
plugin_loaded_error("Плагин недоступен");
|
||
}
|
||
}
|
||
}
|
||
|
||
//Проверяем работает ли плагин
|
||
function check_plugin_working()
|
||
{
|
||
var div = document.createElement("div");
|
||
div.innerHTML = "<!--[if lt IE 9]><i></i><![endif]-->";
|
||
var isIeLessThan9 = (div.getElementsByTagName("i").length === 1);
|
||
if (isIeLessThan9) {
|
||
plugin_loaded_error("Internet Explorer версии 8 и ниже не поддерживается");
|
||
return;
|
||
}
|
||
|
||
if(isNativeMessageSupported())
|
||
{
|
||
load_extension();
|
||
}else if(!canPromise) {
|
||
window.addEventListener("message", function (event){
|
||
if (event.data !== "cadesplugin_echo_request")
|
||
return;
|
||
load_npapi_plugin();
|
||
check_npapi_plugin();
|
||
},
|
||
false);
|
||
}else
|
||
{
|
||
if(document.readyState === "complete"){
|
||
load_npapi_plugin();
|
||
check_npapi_plugin();
|
||
} else {
|
||
window.addEventListener("load", function (event) {
|
||
load_npapi_plugin();
|
||
check_npapi_plugin();
|
||
}, false);
|
||
}
|
||
}
|
||
}
|
||
|
||
function set_pluginObject(obj)
|
||
{
|
||
pluginObject = obj;
|
||
}
|
||
|
||
function is_capilite_enabled()
|
||
{
|
||
if ((typeof (cadesplugin.EnableInternalCSP) !== 'undefined') && cadesplugin.EnableInternalCSP)
|
||
return true;
|
||
return false;
|
||
};
|
||
|
||
//Export
|
||
cadesplugin.JSModuleVersion = "2.1.2";
|
||
cadesplugin.async_spawn = async_spawn;
|
||
cadesplugin.set = set_pluginObject;
|
||
cadesplugin.set_log_level = set_log_level;
|
||
cadesplugin.getLastError = getLastError;
|
||
cadesplugin.is_capilite_enabled = is_capilite_enabled;
|
||
|
||
if(isNativeMessageSupported())
|
||
{
|
||
cadesplugin.CreateObjectAsync = CreateObjectAsync;
|
||
cadesplugin.ReleasePluginObjects = ReleasePluginObjects;
|
||
}
|
||
|
||
if(!isNativeMessageSupported())
|
||
{
|
||
cadesplugin.CreateObject = CreateObject;
|
||
}
|
||
|
||
if(window.cadesplugin_load_timeout)
|
||
{
|
||
setTimeout(check_load_timeout, window.cadesplugin_load_timeout);
|
||
}
|
||
else
|
||
{
|
||
setTimeout(check_load_timeout, 20000);
|
||
}
|
||
|
||
set_constantValues();
|
||
|
||
cadesplugin.current_log_level = cadesplugin.LOG_LEVEL_ERROR;
|
||
window.cadesplugin = cadesplugin;
|
||
check_plugin_working();
|
||
}());
|
||
|
||
|
||
/***/ },
|
||
/* 2 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
var cryptoCommon = __webpack_require__(3),
|
||
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) {
|
||
eval(cryptoCommon.generateAsyncFn(function isValid() {
|
||
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) {
|
||
eval(cryptoCommon.generateAsyncFn(function getProp() {
|
||
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) {
|
||
eval(cryptoCommon.generateAsyncFn(function exportBase64() {
|
||
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) {
|
||
eval(cryptoCommon.generateAsyncFn(function getAlgorithm() {
|
||
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) {
|
||
eval(cryptoCommon.generateAsyncFn(function getExtendedKeyUsage() {
|
||
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.generateAsyncFn(function isValidEDSSettings() {
|
||
var result;
|
||
|
||
try {
|
||
result = 'yield' + cryptoCommon.createObj('CAdESCOM.About');
|
||
} catch (error) {
|
||
reject('Настройки ЭП на данной машине не верны');
|
||
}
|
||
|
||
resolve();
|
||
}));
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Получить сертификат в формате cades по хэшу
|
||
* */
|
||
function getCadesCert(hash) {
|
||
return new Promise(function (resolve, reject) {
|
||
eval(cryptoCommon.generateAsyncFn(function getCadesCert() {
|
||
var oStore,
|
||
certs,
|
||
certCnt,
|
||
cert;
|
||
|
||
// Получаем доступ к хранилищу
|
||
try {
|
||
oStore = 'yield' + cryptoCommon.createObj('CAdESCOM.Store');
|
||
} catch (err) {
|
||
reject('Ошибка при попытке доступа к хранилищу: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
if (!oStore) {
|
||
reject('Не удалось получить доступ к хранилищу сертификатов');
|
||
return;
|
||
}
|
||
|
||
// Открываем хранилище
|
||
try {
|
||
void('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) {
|
||
eval(cryptoCommon.generateAsyncFn(function getCertInfo() {
|
||
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.generateAsyncFn(function getCertsList() {
|
||
var result = [],
|
||
oStore,
|
||
certs,
|
||
count,
|
||
item;
|
||
|
||
// Получаем доступ к хранилищу
|
||
try {
|
||
oStore = 'yield' + cryptoCommon.createObj('CAdESCOM.Store');
|
||
} catch (err) {
|
||
reject('Ошибка при попытке доступа к хранилищу: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
// Открываем хранилище
|
||
try {
|
||
void('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) {
|
||
eval(cryptoCommon.generateAsyncFn(function signData() {
|
||
var clientTime = new Date(),
|
||
oAttrs,
|
||
oSignedData,
|
||
oSigner,
|
||
attrs,
|
||
signature;
|
||
|
||
try {
|
||
oAttrs = 'yield' + cryptoCommon.createObj('CADESCOM.CPAttribute');
|
||
oSignedData = 'yield' + cryptoCommon.createObj('CAdESCOM.CadesSignedData');
|
||
oSigner = 'yield' + cryptoCommon.createObj('CAdESCOM.CPSigner');
|
||
} catch (error) {
|
||
reject('Ошибка при инициализации подписи: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
clientTime = cryptoCommon.getDateObj(clientTime);
|
||
|
||
try {
|
||
void('yield' + oAttrs.propset_Name(cryptoConstants.Time.AUTHENTICATED_ATTRIBUTE_SIGNING_TIME));
|
||
void('yield' + oAttrs.propset_Value(clientTime));
|
||
} catch (err) {
|
||
reject('Ошибка при установке данных подписи: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
// Задаем настройки для подписи
|
||
try {
|
||
void('yield' + oSigner.propset_Certificate(cert));
|
||
attrs = 'yield' + oSigner.AuthenticatedAttributes2;
|
||
void('yield' + attrs.Add(oAttrs));
|
||
void('yield' + oSignedData.propset_ContentEncoding(cadesplugin.CADESCOM_BASE64_TO_BINARY));
|
||
void('yield' + oSignedData.propset_Content(dataBase64));
|
||
void('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) {
|
||
eval(cryptoCommon.generateAsyncFn(function signDataXML() {
|
||
var cnts = cryptoConstants,
|
||
oSigner,
|
||
signerXML,
|
||
signature;
|
||
|
||
try {
|
||
oSigner = 'yield' + cryptoCommon.createObj('CAdESCOM.CPSigner');
|
||
signerXML = 'yield' + cryptoCommon.createObj('CAdESCOM.SignedXML');
|
||
} catch (err) {
|
||
reject('Ошибка при инициализации подписи: ' + err.message);
|
||
return;
|
||
}
|
||
|
||
// Задаем настройки для подписи
|
||
try {
|
||
void('yield' + oSigner.propset_Certificate(cert));
|
||
// Добавляем данные для подписи
|
||
void('yield' + signerXML.propset_Content(dataXML));
|
||
// Устанавливаем тип подписи
|
||
void('yield' + signerXML.propset_SignatureType(cnts.SignatureType.CADESCOM_XML_SIGNATURE_TYPE_ENVELOPED));
|
||
// Устанавливаем алгоритм подписи
|
||
void('yield' + signerXML.propset_SignatureMethod(cnts.GostXmlDSigUrls.XmlDsigGost3410Url));
|
||
// Устанавливаем алгоритм хэширования
|
||
void('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) {
|
||
eval(cryptoCommon.generateAsyncFn(function getSystemInfo() {
|
||
var e;
|
||
|
||
try {
|
||
e = 'yield' + cryptoCommon.createObj('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
|
||
};
|
||
|
||
/***/ },
|
||
/* 3 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
var bowser = __webpack_require__(4);
|
||
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 generateAsyncFn(cb) {
|
||
var canAsync = cadesplugin.CreateObjectAsync;
|
||
var dynamicScriptName = cb.name || 'asyncFn';
|
||
|
||
cb = String(cb);
|
||
|
||
var args = cb.match(/^function[\s\w]*?\((.*?)\)/);
|
||
|
||
args = (args && args[1]) || '';
|
||
|
||
cb = cb.replace(/^.*?{([\s\S]*?)}$/, '$1');
|
||
|
||
function GeneratorFunction() {
|
||
return (new Function('', 'return Object.getPrototypeOf(function*(){}).constructor'))();
|
||
}
|
||
|
||
cb = String(new (canAsync ? GeneratorFunction() : Function)(args, cb));
|
||
|
||
cb = cb.replace(/cryptoCommon\.createObj(\([\s\S]*?\))/gm, 'cadesplugin.CreateObject' + (canAsync ? 'Async' : '') + '$1');
|
||
cb = cb.replace(/("|')(yield)(\1)\s*?\+\s*?\b/gm, canAsync ? '$2 ' : '');
|
||
|
||
if (!canAsync) {
|
||
cb = cb.replace(/propset_(.*?)\((.*?)\)/gm, '$1 = $2');
|
||
}
|
||
|
||
return (canAsync ?
|
||
'cadesplugin.async_spawn(' + cb + ');'
|
||
: '(' + cb + ')();') + '//# sourceURL=evaled-' + dynamicScriptName + '.js';
|
||
}
|
||
|
||
/**
|
||
* Парсит информацию из строки с информацией о сертификате
|
||
* */
|
||
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 = {
|
||
generateAsyncFn: generateAsyncFn,
|
||
subjectNameTagsTranslations: subjectNameTagsTranslations,
|
||
issuerNameTagsTranslations: issuerNameTagsTranslations,
|
||
parseCertInfo: parseCertInfo,
|
||
getReadableDate: getReadableDate,
|
||
getDateObj: getDateObj,
|
||
prepareCertsInfo: prepareCertsInfo,
|
||
getDecodedExtendedKeyUsage: getDecodedExtendedKeyUsage,
|
||
hasExtendedKeyUsage: hasExtendedKeyUsage,
|
||
getEnvInfo: getEnvInfo,
|
||
isValidCSPVersion: isValidCSPVersion,
|
||
isValidCadesVersion: isValidCadesVersion
|
||
};
|
||
|
||
/***/ },
|
||
/* 4 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*!
|
||
* Bowser - a browser detector
|
||
* https://github.com/ded/bowser
|
||
* MIT License | (c) Dustin Diaz 2015
|
||
*/
|
||
|
||
!function (name, definition) {
|
||
if (typeof module != 'undefined' && module.exports) module.exports = definition()
|
||
else if (true) __webpack_require__(5)(name, definition)
|
||
else this[name] = definition()
|
||
}('bowser', function () {
|
||
/**
|
||
* See useragents.js for examples of navigator.userAgent
|
||
*/
|
||
|
||
var t = true
|
||
|
||
function detect(ua) {
|
||
|
||
function getFirstMatch(regex) {
|
||
var match = ua.match(regex);
|
||
return (match && match.length > 1 && match[1]) || '';
|
||
}
|
||
|
||
function getSecondMatch(regex) {
|
||
var match = ua.match(regex);
|
||
return (match && match.length > 1 && match[2]) || '';
|
||
}
|
||
|
||
var iosdevice = getFirstMatch(/(ipod|iphone|ipad)/i).toLowerCase()
|
||
, likeAndroid = /like android/i.test(ua)
|
||
, android = !likeAndroid && /android/i.test(ua)
|
||
, nexusMobile = /nexus\s*[0-6]\s*/i.test(ua)
|
||
, nexusTablet = !nexusMobile && /nexus\s*[0-9]+/i.test(ua)
|
||
, chromeos = /CrOS/.test(ua)
|
||
, silk = /silk/i.test(ua)
|
||
, sailfish = /sailfish/i.test(ua)
|
||
, tizen = /tizen/i.test(ua)
|
||
, webos = /(web|hpw)os/i.test(ua)
|
||
, windowsphone = /windows phone/i.test(ua)
|
||
, samsungBrowser = /SamsungBrowser/i.test(ua)
|
||
, windows = !windowsphone && /windows/i.test(ua)
|
||
, mac = !iosdevice && !silk && /macintosh/i.test(ua)
|
||
, linux = !android && !sailfish && !tizen && !webos && /linux/i.test(ua)
|
||
, edgeVersion = getFirstMatch(/edge\/(\d+(\.\d+)?)/i)
|
||
, versionIdentifier = getFirstMatch(/version\/(\d+(\.\d+)?)/i)
|
||
, tablet = /tablet/i.test(ua)
|
||
, mobile = !tablet && /[^-]mobi/i.test(ua)
|
||
, xbox = /xbox/i.test(ua)
|
||
, result
|
||
|
||
if (/opera/i.test(ua)) {
|
||
// an old Opera
|
||
result = {
|
||
name: 'Opera'
|
||
, opera: t
|
||
, version: versionIdentifier || getFirstMatch(/(?:opera|opr|opios)[\s\/](\d+(\.\d+)?)/i)
|
||
}
|
||
} else if (/opr|opios/i.test(ua)) {
|
||
// a new Opera
|
||
result = {
|
||
name: 'Opera'
|
||
, opera: t
|
||
, version: getFirstMatch(/(?:opr|opios)[\s\/](\d+(\.\d+)?)/i) || versionIdentifier
|
||
}
|
||
}
|
||
else if (/SamsungBrowser/i.test(ua)) {
|
||
result = {
|
||
name: 'Samsung Internet for Android'
|
||
, samsungBrowser: t
|
||
, version: versionIdentifier || getFirstMatch(/(?:SamsungBrowser)[\s\/](\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/coast/i.test(ua)) {
|
||
result = {
|
||
name: 'Opera Coast'
|
||
, coast: t
|
||
, version: versionIdentifier || getFirstMatch(/(?:coast)[\s\/](\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/yabrowser/i.test(ua)) {
|
||
result = {
|
||
name: 'Yandex Browser'
|
||
, yandexbrowser: t
|
||
, version: versionIdentifier || getFirstMatch(/(?:yabrowser)[\s\/](\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/ucbrowser/i.test(ua)) {
|
||
result = {
|
||
name: 'UC Browser'
|
||
, ucbrowser: t
|
||
, version: getFirstMatch(/(?:ucbrowser)[\s\/](\d+(?:\.\d+)+)/i)
|
||
}
|
||
}
|
||
else if (/mxios/i.test(ua)) {
|
||
result = {
|
||
name: 'Maxthon'
|
||
, maxthon: t
|
||
, version: getFirstMatch(/(?:mxios)[\s\/](\d+(?:\.\d+)+)/i)
|
||
}
|
||
}
|
||
else if (/epiphany/i.test(ua)) {
|
||
result = {
|
||
name: 'Epiphany'
|
||
, epiphany: t
|
||
, version: getFirstMatch(/(?:epiphany)[\s\/](\d+(?:\.\d+)+)/i)
|
||
}
|
||
}
|
||
else if (/puffin/i.test(ua)) {
|
||
result = {
|
||
name: 'Puffin'
|
||
, puffin: t
|
||
, version: getFirstMatch(/(?:puffin)[\s\/](\d+(?:\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/sleipnir/i.test(ua)) {
|
||
result = {
|
||
name: 'Sleipnir'
|
||
, sleipnir: t
|
||
, version: getFirstMatch(/(?:sleipnir)[\s\/](\d+(?:\.\d+)+)/i)
|
||
}
|
||
}
|
||
else if (/k-meleon/i.test(ua)) {
|
||
result = {
|
||
name: 'K-Meleon'
|
||
, kMeleon: t
|
||
, version: getFirstMatch(/(?:k-meleon)[\s\/](\d+(?:\.\d+)+)/i)
|
||
}
|
||
}
|
||
else if (windowsphone) {
|
||
result = {
|
||
name: 'Windows Phone'
|
||
, windowsphone: t
|
||
}
|
||
if (edgeVersion) {
|
||
result.msedge = t
|
||
result.version = edgeVersion
|
||
}
|
||
else {
|
||
result.msie = t
|
||
result.version = getFirstMatch(/iemobile\/(\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/msie|trident/i.test(ua)) {
|
||
result = {
|
||
name: 'Internet Explorer'
|
||
, msie: t
|
||
, version: getFirstMatch(/(?:msie |rv:)(\d+(\.\d+)?)/i)
|
||
}
|
||
} else if (chromeos) {
|
||
result = {
|
||
name: 'Chrome'
|
||
, chromeos: t
|
||
, chromeBook: t
|
||
, chrome: t
|
||
, version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
|
||
}
|
||
} else if (/chrome.+? edge/i.test(ua)) {
|
||
result = {
|
||
name: 'Microsoft Edge'
|
||
, msedge: t
|
||
, version: edgeVersion
|
||
}
|
||
}
|
||
else if (/vivaldi/i.test(ua)) {
|
||
result = {
|
||
name: 'Vivaldi'
|
||
, vivaldi: t
|
||
, version: getFirstMatch(/vivaldi\/(\d+(\.\d+)?)/i) || versionIdentifier
|
||
}
|
||
}
|
||
else if (sailfish) {
|
||
result = {
|
||
name: 'Sailfish'
|
||
, sailfish: t
|
||
, version: getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/seamonkey\//i.test(ua)) {
|
||
result = {
|
||
name: 'SeaMonkey'
|
||
, seamonkey: t
|
||
, version: getFirstMatch(/seamonkey\/(\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/firefox|iceweasel|fxios/i.test(ua)) {
|
||
result = {
|
||
name: 'Firefox'
|
||
, firefox: t
|
||
, version: getFirstMatch(/(?:firefox|iceweasel|fxios)[ \/](\d+(\.\d+)?)/i)
|
||
}
|
||
if (/\((mobile|tablet);[^\)]*rv:[\d\.]+\)/i.test(ua)) {
|
||
result.firefoxos = t
|
||
}
|
||
}
|
||
else if (silk) {
|
||
result = {
|
||
name: 'Amazon Silk'
|
||
, silk: t
|
||
, version : getFirstMatch(/silk\/(\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/phantom/i.test(ua)) {
|
||
result = {
|
||
name: 'PhantomJS'
|
||
, phantom: t
|
||
, version: getFirstMatch(/phantomjs\/(\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/slimerjs/i.test(ua)) {
|
||
result = {
|
||
name: 'SlimerJS'
|
||
, slimer: t
|
||
, version: getFirstMatch(/slimerjs\/(\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (/blackberry|\bbb\d+/i.test(ua) || /rim\stablet/i.test(ua)) {
|
||
result = {
|
||
name: 'BlackBerry'
|
||
, blackberry: t
|
||
, version: versionIdentifier || getFirstMatch(/blackberry[\d]+\/(\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (webos) {
|
||
result = {
|
||
name: 'WebOS'
|
||
, webos: t
|
||
, version: versionIdentifier || getFirstMatch(/w(?:eb)?osbrowser\/(\d+(\.\d+)?)/i)
|
||
};
|
||
/touchpad\//i.test(ua) && (result.touchpad = t)
|
||
}
|
||
else if (/bada/i.test(ua)) {
|
||
result = {
|
||
name: 'Bada'
|
||
, bada: t
|
||
, version: getFirstMatch(/dolfin\/(\d+(\.\d+)?)/i)
|
||
};
|
||
}
|
||
else if (tizen) {
|
||
result = {
|
||
name: 'Tizen'
|
||
, tizen: t
|
||
, version: getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.\d+)?)/i) || versionIdentifier
|
||
};
|
||
}
|
||
else if (/qupzilla/i.test(ua)) {
|
||
result = {
|
||
name: 'QupZilla'
|
||
, qupzilla: t
|
||
, version: getFirstMatch(/(?:qupzilla)[\s\/](\d+(?:\.\d+)+)/i) || versionIdentifier
|
||
}
|
||
}
|
||
else if (/chromium/i.test(ua)) {
|
||
result = {
|
||
name: 'Chromium'
|
||
, chromium: t
|
||
, version: getFirstMatch(/(?:chromium)[\s\/](\d+(?:\.\d+)?)/i) || versionIdentifier
|
||
}
|
||
}
|
||
else if (/chrome|crios|crmo/i.test(ua)) {
|
||
result = {
|
||
name: 'Chrome'
|
||
, chrome: t
|
||
, version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
|
||
}
|
||
}
|
||
else if (android) {
|
||
result = {
|
||
name: 'Android'
|
||
, version: versionIdentifier
|
||
}
|
||
}
|
||
else if (/safari|applewebkit/i.test(ua)) {
|
||
result = {
|
||
name: 'Safari'
|
||
, safari: t
|
||
}
|
||
if (versionIdentifier) {
|
||
result.version = versionIdentifier
|
||
}
|
||
}
|
||
else if (iosdevice) {
|
||
result = {
|
||
name : iosdevice == 'iphone' ? 'iPhone' : iosdevice == 'ipad' ? 'iPad' : 'iPod'
|
||
}
|
||
// WTF: version is not part of user agent in web apps
|
||
if (versionIdentifier) {
|
||
result.version = versionIdentifier
|
||
}
|
||
}
|
||
else if(/googlebot/i.test(ua)) {
|
||
result = {
|
||
name: 'Googlebot'
|
||
, googlebot: t
|
||
, version: getFirstMatch(/googlebot\/(\d+(\.\d+))/i) || versionIdentifier
|
||
}
|
||
}
|
||
else {
|
||
result = {
|
||
name: getFirstMatch(/^(.*)\/(.*) /),
|
||
version: getSecondMatch(/^(.*)\/(.*) /)
|
||
};
|
||
}
|
||
|
||
// set webkit or gecko flag for browsers based on these engines
|
||
if (!result.msedge && /(apple)?webkit/i.test(ua)) {
|
||
if (/(apple)?webkit\/537\.36/i.test(ua)) {
|
||
result.name = result.name || "Blink"
|
||
result.blink = t
|
||
} else {
|
||
result.name = result.name || "Webkit"
|
||
result.webkit = t
|
||
}
|
||
if (!result.version && versionIdentifier) {
|
||
result.version = versionIdentifier
|
||
}
|
||
} else if (!result.opera && /gecko\//i.test(ua)) {
|
||
result.name = result.name || "Gecko"
|
||
result.gecko = t
|
||
result.version = result.version || getFirstMatch(/gecko\/(\d+(\.\d+)?)/i)
|
||
}
|
||
|
||
// set OS flags for platforms that have multiple browsers
|
||
if (!result.windowsphone && !result.msedge && (android || result.silk)) {
|
||
result.android = t
|
||
} else if (!result.windowsphone && !result.msedge && iosdevice) {
|
||
result[iosdevice] = t
|
||
result.ios = t
|
||
} else if (mac) {
|
||
result.mac = t
|
||
} else if (xbox) {
|
||
result.xbox = t
|
||
} else if (windows) {
|
||
result.windows = t
|
||
} else if (linux) {
|
||
result.linux = t
|
||
}
|
||
|
||
// OS version extraction
|
||
var osVersion = '';
|
||
if (result.windowsphone) {
|
||
osVersion = getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i);
|
||
} else if (iosdevice) {
|
||
osVersion = getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i);
|
||
osVersion = osVersion.replace(/[_\s]/g, '.');
|
||
} else if (android) {
|
||
osVersion = getFirstMatch(/android[ \/-](\d+(\.\d+)*)/i);
|
||
} else if (result.webos) {
|
||
osVersion = getFirstMatch(/(?:web|hpw)os\/(\d+(\.\d+)*)/i);
|
||
} else if (result.blackberry) {
|
||
osVersion = getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i);
|
||
} else if (result.bada) {
|
||
osVersion = getFirstMatch(/bada\/(\d+(\.\d+)*)/i);
|
||
} else if (result.tizen) {
|
||
osVersion = getFirstMatch(/tizen[\/\s](\d+(\.\d+)*)/i);
|
||
}
|
||
if (osVersion) {
|
||
result.osversion = osVersion;
|
||
}
|
||
|
||
// device type extraction
|
||
var osMajorVersion = osVersion.split('.')[0];
|
||
if (
|
||
tablet
|
||
|| nexusTablet
|
||
|| iosdevice == 'ipad'
|
||
|| (android && (osMajorVersion == 3 || (osMajorVersion >= 4 && !mobile)))
|
||
|| result.silk
|
||
) {
|
||
result.tablet = t
|
||
} else if (
|
||
mobile
|
||
|| iosdevice == 'iphone'
|
||
|| iosdevice == 'ipod'
|
||
|| android
|
||
|| nexusMobile
|
||
|| result.blackberry
|
||
|| result.webos
|
||
|| result.bada
|
||
) {
|
||
result.mobile = t
|
||
}
|
||
|
||
// Graded Browser Support
|
||
// http://developer.yahoo.com/yui/articles/gbs
|
||
if (result.msedge ||
|
||
(result.msie && result.version >= 10) ||
|
||
(result.yandexbrowser && result.version >= 15) ||
|
||
(result.vivaldi && result.version >= 1.0) ||
|
||
(result.chrome && result.version >= 20) ||
|
||
(result.samsungBrowser && result.version >= 4) ||
|
||
(result.firefox && result.version >= 20.0) ||
|
||
(result.safari && result.version >= 6) ||
|
||
(result.opera && result.version >= 10.0) ||
|
||
(result.ios && result.osversion && result.osversion.split(".")[0] >= 6) ||
|
||
(result.blackberry && result.version >= 10.1)
|
||
|| (result.chromium && result.version >= 20)
|
||
) {
|
||
result.a = t;
|
||
}
|
||
else if ((result.msie && result.version < 10) ||
|
||
(result.chrome && result.version < 20) ||
|
||
(result.firefox && result.version < 20.0) ||
|
||
(result.safari && result.version < 6) ||
|
||
(result.opera && result.version < 10.0) ||
|
||
(result.ios && result.osversion && result.osversion.split(".")[0] < 6)
|
||
|| (result.chromium && result.version < 20)
|
||
) {
|
||
result.c = t
|
||
} else result.x = t
|
||
|
||
return result
|
||
}
|
||
|
||
var bowser = detect(typeof navigator !== 'undefined' ? navigator.userAgent || '' : '')
|
||
|
||
bowser.test = function (browserList) {
|
||
for (var i = 0; i < browserList.length; ++i) {
|
||
var browserItem = browserList[i];
|
||
if (typeof browserItem=== 'string') {
|
||
if (browserItem in bowser) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Get version precisions count
|
||
*
|
||
* @example
|
||
* getVersionPrecision("1.10.3") // 3
|
||
*
|
||
* @param {string} version
|
||
* @return {number}
|
||
*/
|
||
function getVersionPrecision(version) {
|
||
return version.split(".").length;
|
||
}
|
||
|
||
/**
|
||
* Array::map polyfill
|
||
*
|
||
* @param {Array} arr
|
||
* @param {Function} iterator
|
||
* @return {Array}
|
||
*/
|
||
function map(arr, iterator) {
|
||
var result = [], i;
|
||
if (Array.prototype.map) {
|
||
return Array.prototype.map.call(arr, iterator);
|
||
}
|
||
for (i = 0; i < arr.length; i++) {
|
||
result.push(iterator(arr[i]));
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* Calculate browser version weight
|
||
*
|
||
* @example
|
||
* compareVersions(['1.10.2.1', '1.8.2.1.90']) // 1
|
||
* compareVersions(['1.010.2.1', '1.09.2.1.90']); // 1
|
||
* compareVersions(['1.10.2.1', '1.10.2.1']); // 0
|
||
* compareVersions(['1.10.2.1', '1.0800.2']); // -1
|
||
*
|
||
* @param {Array<String>} versions versions to compare
|
||
* @return {Number} comparison result
|
||
*/
|
||
function compareVersions(versions) {
|
||
// 1) get common precision for both versions, for example for "10.0" and "9" it should be 2
|
||
var precision = Math.max(getVersionPrecision(versions[0]), getVersionPrecision(versions[1]));
|
||
var chunks = map(versions, function (version) {
|
||
var delta = precision - getVersionPrecision(version);
|
||
|
||
// 2) "9" -> "9.0" (for precision = 2)
|
||
version = version + new Array(delta + 1).join(".0");
|
||
|
||
// 3) "9.0" -> ["000000000"", "000000009"]
|
||
return map(version.split("."), function (chunk) {
|
||
return new Array(20 - chunk.length).join("0") + chunk;
|
||
}).reverse();
|
||
});
|
||
|
||
// iterate in reverse order by reversed chunks array
|
||
while (--precision >= 0) {
|
||
// 4) compare: "000000009" > "000000010" = false (but "9" > "10" = true)
|
||
if (chunks[0][precision] > chunks[1][precision]) {
|
||
return 1;
|
||
}
|
||
else if (chunks[0][precision] === chunks[1][precision]) {
|
||
if (precision === 0) {
|
||
// all version chunks are same
|
||
return 0;
|
||
}
|
||
}
|
||
else {
|
||
return -1;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Check if browser is unsupported
|
||
*
|
||
* @example
|
||
* bowser.isUnsupportedBrowser({
|
||
* msie: "10",
|
||
* firefox: "23",
|
||
* chrome: "29",
|
||
* safari: "5.1",
|
||
* opera: "16",
|
||
* phantom: "534"
|
||
* });
|
||
*
|
||
* @param {Object} minVersions map of minimal version to browser
|
||
* @param {Boolean} [strictMode = false] flag to return false if browser wasn't found in map
|
||
* @param {String} [ua] user agent string
|
||
* @return {Boolean}
|
||
*/
|
||
function isUnsupportedBrowser(minVersions, strictMode, ua) {
|
||
var _bowser = bowser;
|
||
|
||
// make strictMode param optional with ua param usage
|
||
if (typeof strictMode === 'string') {
|
||
ua = strictMode;
|
||
strictMode = void(0);
|
||
}
|
||
|
||
if (strictMode === void(0)) {
|
||
strictMode = false;
|
||
}
|
||
if (ua) {
|
||
_bowser = detect(ua);
|
||
}
|
||
|
||
var version = "" + _bowser.version;
|
||
for (var browser in minVersions) {
|
||
if (minVersions.hasOwnProperty(browser)) {
|
||
if (_bowser[browser]) {
|
||
if (typeof minVersions[browser] !== 'string') {
|
||
throw new Error('Browser version in the minVersion map should be a string: ' + browser + ': ' + String(minVersions));
|
||
}
|
||
|
||
// browser version and min supported version.
|
||
return compareVersions([version, minVersions[browser]]) < 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
return strictMode; // not found
|
||
}
|
||
|
||
/**
|
||
* Check if browser is supported
|
||
*
|
||
* @param {Object} minVersions map of minimal version to browser
|
||
* @param {Boolean} [strictMode = false] flag to return false if browser wasn't found in map
|
||
* @param {String} [ua] user agent string
|
||
* @return {Boolean}
|
||
*/
|
||
function check(minVersions, strictMode, ua) {
|
||
return !isUnsupportedBrowser(minVersions, strictMode, ua);
|
||
}
|
||
|
||
bowser.isUnsupportedBrowser = isUnsupportedBrowser;
|
||
bowser.compareVersions = compareVersions;
|
||
bowser.check = check;
|
||
|
||
/*
|
||
* Set our detect method to the main bowser object so we can
|
||
* reuse it to test other user agents.
|
||
* This is needed to implement future tests.
|
||
*/
|
||
bowser._detect = detect;
|
||
|
||
return bowser
|
||
});
|
||
|
||
|
||
/***/ },
|
||
/* 5 */
|
||
/***/ function(module, exports) {
|
||
|
||
module.exports = function() { throw new Error("define cannot be used indirect"); };
|
||
|
||
|
||
/***/ },
|
||
/* 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=crypto-pro.js.map
|