1 /* asn1cms-2.0.6.js (c) 2013-2026 Kenji Urushima | kjur.github.io/jsrsasign/license 2 */ 3 /* 4 * asn1cms.js - ASN.1 DER encoder and verifier classes for Cryptographic Message Syntax(CMS) 5 * 6 * Copyright (c) 2013-2026 Kenji Urushima (kenji.urushima@gmail.com) 7 * 8 * This software is licensed under the terms of the MIT License. 9 * https://kjur.github.io/jsrsasign/license 10 * 11 * The above copyright and license notice shall be 12 * included in all copies or substantial portions of the Software. 13 */ 14 15 /** 16 * @fileOverview 17 * @name asn1cms-1.0.js 18 * @author Kenji Urushima kenji.urushima@gmail.com 19 * @version jsrsasign 10.5.16 asn1cms 2.0.5 (2022-Apr-08) 20 * @since jsrsasign 4.2.4 21 * @license <a href="https://kjur.github.io/jsrsasign/license/">MIT License</a> 22 */ 23 24 /** 25 * kjur's class library name space 26 * // already documented in asn1-1.0.js 27 * @name KJUR 28 * @namespace kjur's class library name space 29 */ 30 if (typeof KJUR == "undefined" || !KJUR) KJUR = {}; 31 32 /** 33 * kjur's ASN.1 class library name space 34 * // already documented in asn1-1.0.js 35 * @name KJUR.asn1 36 * @namespace 37 */ 38 if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) KJUR.asn1 = {}; 39 40 /** 41 * kjur's ASN.1 class for Cryptographic Message Syntax(CMS) 42 * <p> 43 * This name space provides 44 * <a href="https://tools.ietf.org/html/rfc5652">RFC 5652 45 * Cryptographic Message Syntax (CMS)</a> SignedData generator. 46 * 47 * <h4>FEATURES</h4> 48 * <ul> 49 * <li>easily generate CMS SignedData</li> 50 * <li>easily verify CMS SignedData</li> 51 * <li>APIs are very similar to BouncyCastle library ASN.1 classes. So easy to learn.</li> 52 * </ul> 53 * 54 * <h4>PROVIDED CLASSES</h4> 55 * <ul> 56 * <li>{@link KJUR.asn1.cms.SignedData}</li> 57 * <li>{@link KJUR.asn1.cms.SignerInfo}</li> 58 * <li>{@link KJUR.asn1.cms.AttributeList}</li> 59 * <li>{@link KJUR.asn1.cms.ContentInfo}</li> 60 * <li>{@link KJUR.asn1.cms.EncapsulatedContentInfo}</li> 61 * <li>{@link KJUR.asn1.cms.IssuerAndSerialNumber}</li> 62 * <li>{@link KJUR.asn1.cms.IssuerSerial}</li> 63 * <li>{@link KJUR.asn1.cms.CMSUtil}</li> 64 * <li>{@link KJUR.asn1.cms.Attribute}</li> 65 * <li>{@link KJUR.asn1.cms.ContentType}</li> 66 * <li>{@link KJUR.asn1.cms.MessageDigest}</li> 67 * <li>{@link KJUR.asn1.cms.SigningTime}</li> 68 * <li>{@link KJUR.asn1.cms.SigningCertificate}</li> 69 * <li>{@link KJUR.asn1.cms.SigningCertificateV2}</li> 70 * </ul> 71 * NOTE: Please ignore method summary and document of this namespace. 72 * This caused by a bug of jsdoc2. 73 * </p> 74 * @name KJUR.asn1.cms 75 * @namespace 76 */ 77 if (typeof KJUR.asn1.cms == "undefined" || !KJUR.asn1.cms) KJUR.asn1.cms = {}; 78 79 /** 80 * Attribute class for base of CMS attribute<br/> 81 * @name KJUR.asn1.cms.Attribute 82 * @class Attribute class for base of CMS attribute 83 * @param {Array} params JSON object for constructor 84 * @property {Array} params JSON object for ASN.1 encode 85 * @property {String} typeOid attribute type OID string 86 * @extends KJUR.asn1.ASN1Object 87 * @since jsrsasign 4.2.4 asn1cms 1.0.0 88 * 89 * @description 90 * This is an abstract class for CMS attribute 91 * ASN.1 encoder as defined in 92 * <a href="https://tools.ietf.org/html/rfc5652#section-5.3"> 93 * RFC 5652 CMS 5.3 SignerInfo</a>. 94 * <pre> 95 * Attributes ::= SET OF Attribute 96 * Attribute ::= SEQUENCE { 97 * type OBJECT IDENTIFIER, 98 * values AttributeSetValue } 99 * AttributeSetValue ::= SET OF ANY 100 * </pre> 101 */ 102 KJUR.asn1.cms.Attribute = function(params) { 103 var _Error = Error, 104 _KJUR = KJUR, 105 _KJUR_asn1 = _KJUR.asn1, 106 _DERSequence = _KJUR_asn1.DERSequence, 107 _DERSet = _KJUR_asn1.DERSet, 108 _DERObjectIdentifier = _KJUR_asn1.DERObjectIdentifier; 109 110 this.params = null; 111 this.typeOid = null; 112 113 this.setByParam = function(params) { 114 this.params = params; 115 }; 116 117 /** 118 * get ASN1Object array for Attributes<br/> 119 * @name getValueArray 120 * @memberOf KJUR.asn1.cms.Attribute# 121 * @function 122 * @return {Array} array of Attribute value ASN1Object 123 * 124 * @description 125 * This method shall be implemented in subclass. 126 */ 127 this.getValueArray = function() { 128 throw new _Error("not yet implemented abstract"); 129 }; 130 131 this.tohex = function() { 132 var dType = new _DERObjectIdentifier({oid: this.typeOid}); 133 var dValueSet = new _DERSet({array: this.getValueArray()}); 134 var seq = new _DERSequence({array: [dType, dValueSet]}); 135 return seq.tohex(); 136 }; 137 this.getEncodedHex = function() { return this.tohex(); }; 138 }; 139 extendClass(KJUR.asn1.cms.Attribute, KJUR.asn1.ASN1Object); 140 141 /** 142 * class for CMS ContentType attribute 143 * @name KJUR.asn1.cms.ContentType 144 * @class class for CMS ContentType attribute 145 * @param {Array} params associative array of parameters 146 * @extends KJUR.asn1.cms.Attribute 147 * @since jsrsasign 4.2.4 asn1cms 1.0.0 148 * 149 * @description 150 * This is an ASN.1 encoder for ContentType attribute 151 * defined in 152 * <a href="https://tools.ietf.org/html/rfc5652#section-11.1"> 153 * RFC 5652 CMS section 11.1</a>. 154 * <pre> 155 * Attribute ::= SEQUENCE { 156 * type OBJECT IDENTIFIER, 157 * values AttributeSetValue } 158 * AttributeSetValue ::= SET OF ANY 159 * ContentType ::= OBJECT IDENTIFIER 160 * </pre> 161 * Constructor may have following property in argument: 162 * <ul> 163 * <li>{String}type - name or OID string</li> 164 * </ul> 165 * 166 * @example 167 * o = new KJUR.asn1.cms.ContentType({type: 'data'}); 168 * o = new KJUR.asn1.cms.ContentType({type: '1.2.840.113549.1.9.16.1.4'}); 169 */ 170 KJUR.asn1.cms.ContentType = function(params) { 171 var _KJUR = KJUR, 172 _KJUR_asn1 = _KJUR.asn1; 173 174 _KJUR_asn1.cms.ContentType.superclass.constructor.call(this); 175 176 this.typeOid = "1.2.840.113549.1.9.3"; 177 178 this.getValueArray = function() { 179 var dOid = new _KJUR_asn1.DERObjectIdentifier(this.params.type); 180 return [dOid]; 181 }; 182 183 if (params != undefined) this.setByParam(params); 184 }; 185 extendClass(KJUR.asn1.cms.ContentType, KJUR.asn1.cms.Attribute); 186 187 /** 188 * class for CMS MessageDigest attribute 189 * @name KJUR.asn1.cms.MessageDigest 190 * @class class for CMS MessageDigest attribute 191 * @param {Array} params associative array of parameters 192 * @extends KJUR.asn1.cms.Attribute 193 * @since jsrsasign 4.2.4 asn1cms 1.0.0 194 * 195 * @description 196 * This is an ASN.1 encoder for ContentType attribute 197 * defined in 198 * <a href="https://tools.ietf.org/html/rfc5652#section-11.2"> 199 * RFC 5652 CMS section 11.2</a>. 200 * <pre> 201 * Attribute ::= SEQUENCE { 202 * type OBJECT IDENTIFIER, 203 * values AttributeSetValue } 204 * AttributeSetValue ::= SET OF ANY 205 * MessageDigest ::= OCTET STRING 206 * </pre> 207 * 208 * @example 209 * o = new KJUR.asn1.cms.MessageDigest({hex: 'a1a2a3a4...'}); 210 */ 211 KJUR.asn1.cms.MessageDigest = function(params) { 212 var _KJUR = KJUR, 213 _KJUR_asn1 = _KJUR.asn1, 214 _DEROctetString = _KJUR_asn1.DEROctetString, 215 _KJUR_asn1_cms = _KJUR_asn1.cms; 216 217 _KJUR_asn1_cms.MessageDigest.superclass.constructor.call(this); 218 219 this.typeOid = "1.2.840.113549.1.9.4"; 220 221 this.getValueArray = function() { 222 var dHash = new _DEROctetString(this.params); 223 return [dHash]; 224 }; 225 226 if (params != undefined) this.setByParam(params); 227 }; 228 extendClass(KJUR.asn1.cms.MessageDigest, KJUR.asn1.cms.Attribute); 229 230 /** 231 * class for CMS SigningTime attribute 232 * @name KJUR.asn1.cms.SigningTime 233 * @class class for CMS SigningTime attribute 234 * @param {Array} params associative array of parameters 235 * @extends KJUR.asn1.cms.Attribute 236 * @since jsrsasign 4.2.4 asn1cms 1.0.0 237 * 238 * @description 239 * This is an ASN.1 encoder for ContentType attribute 240 * defined in 241 * <a href="https://tools.ietf.org/html/rfc5652#section-11.3"> 242 * RFC 5652 CMS section 11.3</a>. 243 * <pre> 244 * Attribute ::= SEQUENCE { 245 * type OBJECT IDENTIFIER, 246 * values AttributeSetValue } 247 * AttributeSetValue ::= SET OF ANY 248 * SigningTime ::= Time 249 * Time ::= CHOICE { 250 * utcTime UTCTime, 251 * generalTime GeneralizedTime } 252 * </pre> 253 * 254 * @example 255 * o = new KJUR.asn1.cms.SigningTime(); // current time UTCTime by default 256 * o = new KJUR.asn1.cms.SigningTime({type: 'gen'}); // current time GeneralizedTime 257 * o = new KJUR.asn1.cms.SigningTime({str: '20140517093800Z'}); // specified GeneralizedTime 258 * o = new KJUR.asn1.cms.SigningTime({str: '140517093800Z'}); // specified UTCTime 259 */ 260 KJUR.asn1.cms.SigningTime = function(params) { 261 var _KJUR = KJUR, 262 _KJUR_asn1 = _KJUR.asn1; 263 264 _KJUR_asn1.cms.SigningTime.superclass.constructor.call(this); 265 266 this.typeOid = "1.2.840.113549.1.9.5"; 267 268 this.getValueArray = function() { 269 var dTime = new _KJUR_asn1.x509.Time(this.params); 270 return [dTime]; 271 }; 272 273 if (params != undefined) this.setByParam(params); 274 }; 275 extendClass(KJUR.asn1.cms.SigningTime, KJUR.asn1.cms.Attribute); 276 277 /** 278 * class for CMS SigningCertificate attribute<br/> 279 * @name KJUR.asn1.cms.SigningCertificate 280 * @class class for CMS SigningCertificate attribute 281 * @param {Array} params associative array of parameters 282 * @extends KJUR.asn1.cms.Attribute 283 * @since jsrsasign 4.5.1 asn1cms 1.0.1 284 * @see KJUR.asn1.cms.ESSCertID 285 * @see KJUR.asn1.cms.IssuerSerial 286 * 287 * @description 288 * This is an ASN.1 encoder for SigningCertificate attribute 289 * defined in 290 * <a href="https://tools.ietf.org/html/rfc5035#section-5"> 291 * RFC 5035 section 5</a>. 292 * <pre> 293 * Attribute ::= SEQUENCE { 294 * type OBJECT IDENTIFIER, 295 * values AttributeSetValue } 296 * AttributeSetValue ::= SET OF ANY 297 * SigningCertificate ::= SEQUENCE { 298 * certs SEQUENCE OF ESSCertID, 299 * policies SEQUENCE OF PolicyInformation OPTIONAL } 300 * ESSCertID ::= SEQUENCE { 301 * certHash Hash, 302 * issuerSerial IssuerSerial OPTIONAL } 303 * IssuerSerial ::= SEQUENCE { 304 * issuer GeneralNames, 305 * serialNumber CertificateSerialNumber } 306 * </pre> 307 * 308 * @example 309 * o = new KJUR.asn1.cms.SigningCertificate({array: [certPEM]}); 310 */ 311 KJUR.asn1.cms.SigningCertificate = function(params) { 312 var _Error = Error, 313 _KJUR = KJUR, 314 _KJUR_asn1 = _KJUR.asn1, 315 _DERSequence = _KJUR_asn1.DERSequence, 316 _KJUR_asn1_cms = _KJUR_asn1.cms, 317 _ESSCertID = _KJUR_asn1_cms.ESSCertID, 318 _KJUR_crypto = _KJUR.crypto; 319 320 _KJUR_asn1_cms.SigningCertificate.superclass.constructor.call(this); 321 this.typeOid = "1.2.840.113549.1.9.16.2.12"; 322 323 this.getValueArray = function() { 324 if (this.params == null || 325 this.params == undefined || 326 this.params.array == undefined) { 327 throw new _Error("parameter 'array' not specified"); 328 } 329 var aESSCertIDParam = this.params.array; 330 var aESSCertID = []; 331 for (var i = 0; i < aESSCertIDParam.length; i++) { 332 var idparam = aESSCertIDParam[i]; 333 334 if (params.hasis == false && 335 (typeof idparam == "string" && 336 (idparam.indexOf("-----BEGIN") != -1 || 337 ASN1HEX.isASN1HEX(idparam)))) { 338 idparam = {cert: idparam}; 339 } 340 341 if (idparam.hasis != false && params.hasis == false) { 342 idparam.hasis = false; 343 } 344 345 aESSCertID.push(new _ESSCertID(idparam)); 346 } 347 var dCerts = new _DERSequence({array: aESSCertID}); 348 var dSigningCertificate = new _DERSequence({array: [dCerts]}); 349 return [dSigningCertificate]; 350 }; 351 352 if (params != undefined) this.setByParam(params); 353 }; 354 extendClass(KJUR.asn1.cms.SigningCertificate, KJUR.asn1.cms.Attribute); 355 356 /** 357 * class for CMS ESSCertID ASN.1 encoder<br/> 358 * @name KJUR.asn1.cms.ESSCertID 359 * @class class for CMS ESSCertID ASN.1 encoder 360 * @param {Object} params PEM certificate string or JSON of parameters 361 * @extends KJUR.asn1.ASN1Object 362 * @since jsrsasign 10.0.0 asn1cms 2.0.0 363 * @see KJUR.asn1.cms.SigningCertificate 364 * @see KJUR.asn1.cms.IssuerSerial 365 * @see KJUR.asn1.cms.ESSCertIDv2 366 * @see KJUR.asn1.cades.OtherCertID 367 * 368 * @description 369 * This is an ASN.1 encoder for ESSCertID class 370 * defined in 371 * <a href="https://tools.ietf.org/html/rfc5035#section-6"> 372 * RFC 5035 section 6</a>. 373 * <pre> 374 * ESSCertID ::= SEQUENCE { 375 * certHash Hash, 376 * issuerSerial IssuerSerial OPTIONAL } 377 * IssuerSerial ::= SEQUENCE { 378 * issuer GeneralNames, 379 * serialNumber CertificateSerialNumber } 380 * </pre> 381 * 382 * @example 383 * new KJUR.asn1.cms.ESSCertID("-----BEGIN...") 384 * new KJUR.asn1.cms.ESSCertID({cert: "-----BEGIN..."}) 385 * new KJUR.asn1.cms.ESSCertID({cert: "-----BEGIN...", hasis: false}) 386 * new KJUR.asn1.cms.ESSCertID({ 387 * hash: "3f2d...", 388 * issuer: {str: "/C=JP/O=T1"}, 389 * serial: {hex: "12ab..."} 390 * }) 391 */ 392 KJUR.asn1.cms.ESSCertID = function(params) { 393 KJUR.asn1.cms.ESSCertID.superclass.constructor.call(this); 394 395 var _Error = Error, 396 _KJUR = KJUR, 397 _KJUR_asn1 = _KJUR.asn1, 398 _DEROctetString = _KJUR_asn1.DEROctetString, 399 _DERSequence = _KJUR_asn1.DERSequence, 400 _IssuerSerial = _KJUR_asn1.cms.IssuerSerial; 401 402 this.params = null; 403 404 this.getCertHash = function(params, defaultAlg) { 405 if (params.hash != undefined) return params.hash; 406 407 // hash 408 if (typeof params == "string" && 409 params.indexOf("-----BEGIN") == -1 && 410 ! ASN1HEX.isASN1HEX(params)) { 411 return params; 412 } 413 414 var certPEMorHex; 415 if (typeof params == "string") { 416 certPEMorHex = params; 417 } else if (params.cert != undefined) { 418 certPEMorHex = params.cert; 419 } else { 420 throw new _Error("hash nor cert unspecified"); 421 } 422 423 var hCert; 424 if (certPEMorHex.indexOf("-----BEGIN") != -1) { 425 hCert = pemtohex(certPEMorHex); 426 } else { 427 hCert = certPEMorHex; 428 } 429 430 431 if (typeof params == "string") { 432 if (params.indexOf("-----BEGIN") != -1) { 433 hCert = pemtohex(params); 434 } else if (ASN1HEX.isASN1HEX(params)) { 435 hCert = params; 436 } 437 } 438 439 var alg; 440 if (params.alg != undefined) { 441 alg = params.alg; 442 } else if (defaultAlg != undefined) { 443 alg = defaultAlg; 444 } else { 445 throw new _Error("hash alg unspecified"); 446 } 447 448 return _KJUR.crypto.Util.hashHex(hCert, alg); 449 }; 450 451 this.tohex = function() { 452 var params = this.params; 453 454 var hCertHash = this.getCertHash(params, 'sha1'); 455 456 var a = []; 457 a.push(new _DEROctetString({hex: hCertHash})); 458 if ((typeof params == "string" && 459 params.indexOf("-----BEGIN") != -1) || 460 (params.cert != undefined && 461 params.hasis != false) || 462 (params.issuer != undefined && 463 params.serial != undefined)) 464 a.push(new _IssuerSerial(params)); 465 var seq = new _DERSequence({array: a}); 466 return seq.tohex(); 467 }; 468 this.getEncodedHex = function() { return this.tohex(); }; 469 470 if (params != undefined) this.setByParam(params); 471 }; 472 extendClass(KJUR.asn1.cms.ESSCertID, KJUR.asn1.ASN1Object); 473 474 /** 475 * class for CMS SigningCertificateV2 attribute<br/> 476 * @name KJUR.asn1.cms.SigningCertificateV2 477 * @class class for CMS SigningCertificateV2 attribute 478 * @param {Array} params associative array of parameters 479 * @extends KJUR.asn1.cms.Attribute 480 * @since jsrsasign 4.5.1 asn1cms 1.0.1 481 * 482 * @description 483 * This is an ASN.1 encoder for SigningCertificateV2 attribute 484 * defined in 485 * <a href="https://tools.ietf.org/html/rfc5035#section-3"> 486 * RFC 5035 section 3</a>. 487 * <pre> 488 * oid-signingCertificateV2 = 1.2.840.113549.1.9.16.2.47 489 * Attribute ::= SEQUENCE { 490 * type OBJECT IDENTIFIER, 491 * values AttributeSetValue } 492 * AttributeSetValue ::= SET OF ANY 493 * SigningCertificateV2 ::= SEQUENCE { 494 * certs SEQUENCE OF ESSCertIDv2, 495 * policies SEQUENCE OF PolicyInformation OPTIONAL } 496 * ESSCertIDv2 ::= SEQUENCE { 497 * hashAlgorithm AlgorithmIdentifier 498 * DEFAULT {algorithm id-sha256}, 499 * certHash Hash, 500 * issuerSerial IssuerSerial OPTIONAL } 501 * Hash ::= OCTET STRING 502 * IssuerSerial ::= SEQUENCE { 503 * issuer GeneralNames, 504 * serialNumber CertificateSerialNumber } 505 * </pre> 506 * 507 * @example 508 * new KJUR.asn1.cms.SigningCertificateV2({array: [certPEM]}); // DEFAULT sha256 509 * new KJUR.asn1.cms.SigningCertificateV2({array: [certPEM], 510 * hashAlg: 'sha512'}); 511 * new KJUR.asn1.cms.SigningCertificateV2({ 512 * array: [ 513 * {cert: certPEM1, hashAlg: 'sha512'}, 514 * {cert: certPEM2, hashAlg: 'sha256'}, 515 * {cert: certPEM3}, // DEFAULT sha256 516 * certPEM4 // DEFAULT sha256 517 * ] 518 * }) 519 * new KJUR.asn1.cms.SigningCertificateV2({ 520 * array: [ 521 * {cert: certPEM1, hashAlg: 'sha512'}, 522 * {cert: certPEM2, hashAlg: 'sha256'}, 523 * {cert: certPEM3}, // DEFAULT sha256 524 * certPEM4 // DEFAULT sha256 525 * ] 526 * }) 527 */ 528 KJUR.asn1.cms.SigningCertificateV2 = function(params) { 529 var _Error = Error, 530 _KJUR = KJUR, 531 _KJUR_asn1 = _KJUR.asn1, 532 _DERSequence = _KJUR_asn1.DERSequence, 533 _KJUR_asn1_x509 = _KJUR_asn1.x509, 534 _KJUR_asn1_cms = _KJUR_asn1.cms, 535 _ESSCertIDv2 = _KJUR_asn1_cms.ESSCertIDv2, 536 _KJUR_crypto = _KJUR.crypto; 537 538 _KJUR_asn1_cms.SigningCertificateV2.superclass.constructor.call(this); 539 this.typeOid = "1.2.840.113549.1.9.16.2.47"; 540 541 this.getValueArray = function() { 542 if (this.params == null || 543 this.params == undefined || 544 this.params.array == undefined) { 545 throw new _Error("parameter 'array' not specified"); 546 } 547 var aESSCertIDv2Param = this.params.array; 548 var aESSCertIDv2 = []; 549 for (var i = 0; i < aESSCertIDv2Param.length; i++) { 550 var idparam = aESSCertIDv2Param[i]; 551 552 if ((params.alg != undefined || 553 params.hasis == false) && 554 (typeof idparam == "string" && 555 (idparam.indexOf("-----BEGIN") != -1 || 556 ASN1HEX.isASN1HEX(idparam)))) { 557 idparam = {cert: idparam}; 558 } 559 560 if (idparam.alg == undefined && params.alg != undefined) { 561 idparam.alg = params.alg; 562 } 563 564 if (idparam.hasis != false && params.hasis == false) { 565 idparam.hasis = false; 566 } 567 568 aESSCertIDv2.push(new _ESSCertIDv2(idparam)); 569 } 570 var dCerts = new _DERSequence({array: aESSCertIDv2}); 571 var dSigningCertificatev2 = new _DERSequence({array: [dCerts]}); 572 return [dSigningCertificatev2]; 573 }; 574 575 if (params != undefined) this.setByParam(params); 576 }; 577 extendClass(KJUR.asn1.cms.SigningCertificateV2, KJUR.asn1.cms.Attribute); 578 579 /** 580 * class for CMS ESSCertIDv2 ASN.1 encoder<br/> 581 * @name KJUR.asn1.cms.ESSCertIDv2 582 * @class class for CMS ESSCertIDv2 ASN.1 encoder 583 * @param {Object} params PEM certificate string or JSON of parameters 584 * @extends KJUR.asn1.ASN1Object 585 * @since jsrsasign 10.0.0 asn1cms 2.0.0 586 * @see KJUR.asn1.cms.SigningCertificate 587 * @see KJUR.asn1.cms.IssuerSerial 588 * @see KJUR.asn1.cms.ESSCertID 589 * 590 * @description 591 * This is an ASN.1 encoder for SigningCertificateV2 attribute 592 * defined in 593 * <a href="https://tools.ietf.org/html/rfc5035#section-4"> 594 * RFC 5035 section 4</a>. 595 * <pre> 596 * ESSCertIDv2 ::= SEQUENCE { 597 * hashAlgorithm AlgorithmIdentifier 598 * DEFAULT {algorithm id-sha256}, 599 * certHash Hash, 600 * issuerSerial IssuerSerial OPTIONAL } 601 * Hash ::= OCTET STRING 602 * IssuerSerial ::= SEQUENCE { 603 * issuer GeneralNames, 604 * serialNumber CertificateSerialNumber } 605 * </pre> 606 * 607 * @example 608 * new KJUR.asn1.cms.ESSCertIDv2("-----BEGIN...") 609 * new KJUR.asn1.cms.ESSCertIDv2({cert: "-----BEGIN..."}) 610 * new KJUR.asn1.cms.ESSCertIDv2({cert: "-----BEGIN...", hasis: false}) 611 * new KJUR.asn1.cms.ESSCertIDv2({ 612 * hash: "3f2d...", 613 * alg: "sha512", 614 * issuer: {str: "/C=JP/O=T1"}, 615 * serial: {hex: "12ab..."} 616 * }) 617 */ 618 KJUR.asn1.cms.ESSCertIDv2 = function(params) { 619 KJUR.asn1.cms.ESSCertIDv2.superclass.constructor.call(this); 620 621 var _Error = Error, 622 _KJUR = KJUR, 623 _KJUR_asn1 = _KJUR.asn1, 624 _DEROctetString = _KJUR_asn1.DEROctetString, 625 _DERSequence = _KJUR_asn1.DERSequence, 626 _IssuerSerial = _KJUR_asn1.cms.IssuerSerial, 627 _AlgorithmIdentifier = _KJUR_asn1.x509.AlgorithmIdentifier; 628 629 this.params = null; 630 631 this.tohex = function() { 632 var params = this.params; 633 634 var hCertHash = this.getCertHash(params, 'sha256'); 635 636 var a = []; 637 if (params.alg != undefined && params.alg != "sha256") 638 a.push(new _AlgorithmIdentifier({name: params.alg})); 639 a.push(new _DEROctetString({hex: hCertHash})); 640 if ((typeof params == "string" && 641 params.indexOf("-----BEGIN") != -1) || 642 (params.cert != undefined && 643 params.hasis != false) || 644 (params.issuer != undefined && 645 params.serial != undefined)) 646 a.push(new _IssuerSerial(params)); 647 var seq = new _DERSequence({array: a}); 648 return seq.tohex(); 649 }; 650 this.getEncodedHex = function() { return this.tohex(); }; 651 652 if (params != undefined) this.setByParam(params); 653 }; 654 extendClass(KJUR.asn1.cms.ESSCertIDv2, KJUR.asn1.cms.ESSCertID); 655 656 /** 657 * class for IssuerSerial ASN.1 structure for CMS<br/> 658 * @name KJUR.asn1.cms.IssuerSerial 659 * @class class for CMS IssuerSerial ASN.1 structure for CMS 660 * @param {Array} params associative array of parameters 661 * @extends KJUR.asn1.ASN1Object 662 * @since jsrsasign 8.0.24 asn1cms 1.0.8 663 * @see KJUR.asn1.cms.IssuerAndSerialNumber 664 * @see KJUR.asn1.cms.SigningCertificate 665 * @see KJUR.asn1.cms.SigningCertificateV2 666 * @see KJUR.asn1.cms.ESSCertID 667 * @see KJUR.asn1.cms.ESSCertIDv2 668 * @see KJUR.asn1.x509.GeneralNames 669 * @see KJUR.asn1.x509.X500Name 670 * 671 * @description 672 * This class represents IssuerSerial ASN.1 structure 673 * used by ESSCertID/v2 of SigningCertificate/V2 attribute 674 * defined in 675 * <a href="https://tools.ietf.org/html/rfc5035#page-6"> 676 * RFC 5034 section 4</a>. 677 * <pre> 678 * IssuerSerial ::= SEQUENCE { 679 * issuer GeneralNames, 680 * serialNumber CertificateSerialNumber } 681 * CertificateSerialNumber ::= INTEGER 682 * </pre> 683 * 684 * @example 685 * // specify by X500Name parameter and DERInteger 686 * o = new KJUR.asn1.cms.IssuerSerial( 687 * {issuer: {str: '/C=US/O=T1'}, serial {int: 3}}); 688 * // specify by PEM certificate 689 * o = new KJUR.asn1.cms.IssuerSerial({cert: certPEM}); 690 * o = new KJUR.asn1.cms.IssuerSerial(certPEM); // since 1.0.3 691 */ 692 KJUR.asn1.cms.IssuerSerial = function(params) { 693 var _Error = Error, 694 _KJUR = KJUR, 695 _KJUR_asn1 = _KJUR.asn1, 696 _DERInteger = _KJUR_asn1.DERInteger, 697 _DERSequence = _KJUR_asn1.DERSequence, 698 _KJUR_asn1_cms = _KJUR_asn1.cms, 699 _KJUR_asn1_x509 = _KJUR_asn1.x509, 700 _GeneralNames = _KJUR_asn1_x509.GeneralNames, 701 _X509 = X509; 702 703 _KJUR_asn1_cms.IssuerSerial.superclass.constructor.call(this); 704 705 this.setByParam = function(params) { 706 this.params = params; 707 }; 708 709 this.tohex = function() { 710 var params = this.params; 711 712 var pIssuer, pSerial; 713 if ((typeof params == "string" && 714 params.indexOf("-----BEGIN") != -1) || 715 params.cert != undefined) { 716 var pem; 717 718 if (params.cert != undefined) { 719 pem = params.cert; 720 } else { 721 pem = params; 722 } 723 724 var x = new _X509(); 725 x.readCertPEM(pem); 726 pIssuer = x.getIssuer(); 727 pSerial = {hex: x.getSerialNumberHex()}; 728 } else if (params.issuer != undefined && params.serial) { 729 pIssuer = params.issuer; 730 pSerial = params.serial; 731 } else { 732 throw new _Error("cert or issuer and serial parameter not specified"); 733 } 734 735 var dIssuer = new _GeneralNames([{dn: pIssuer}]); 736 var dSerial = new _DERInteger(pSerial); 737 var seq = new _DERSequence({array: [dIssuer, dSerial]}); 738 return seq.tohex(); 739 }; 740 this.getEncodedHex = function() { return this.tohex(); }; 741 742 if (params != undefined) this.setByParam(params); 743 }; 744 extendClass(KJUR.asn1.cms.IssuerSerial, KJUR.asn1.ASN1Object); 745 746 /** 747 * class for SignerIdentifier ASN.1 structure for CMS 748 * @name KJUR.asn1.cms.SignerIdentifier 749 * @class class for CMS SignerIdentifier ASN.1 structure for CMS 750 * @param {Array} params JSON object of parameters 751 * @extends KJUR.asn1.ASN1Object 752 * @since jsrsasign 10.0.0 asn1cms 2.0.0 753 * @see KJUR.asn1.cms.SignedData 754 * @see KJUR.asn1.cms.SignerInfo 755 * @see KJUR.asn1.cms.IssuerAndSerialNumber 756 * @see KJUR.asn1.cms.SubjectKeyIdentifier 757 * @see KJUR.asn1.x509.X500Name 758 * 759 * @description 760 * This is an ASN.1 encoder for SignerIdentifier 761 * ASN.1 structure defined in 762 * <a href="https://tools.ietf.org/html/rfc5652#section-5.3"> 763 * RFC 5652 CMS section 5.3</a>. 764 * <pre> 765 * SignerIdentifier ::= CHOICE { 766 * issuerAndSerialNumber IssuerAndSerialNumber, 767 * subjectKeyIdentifier [0] SubjectKeyIdentifier } 768 * </pre> 769 * Constructor argument can have following properties: 770 * <ul> 771 * <li>{String}type - "isssn" for IssuerAndSerialNumber or "skid" 772 * for SubjectKeyIdentifier</li> 773 * <li>{Array}issuer - {@link KJUR.asn1.x509.X500Name} parameter for issuer</li> 774 * <li>{Array}serial - {@link KJUR.asn1.DERInteger} parameter for serial number</li> 775 * <li>{String}skid - hexadecimal string of subject key identifier</li> 776 * <li>{String}cert - PEM certificate string for type "isssn" or "skid"</li> 777 * </ul> 778 * Constructor argument properties can have following combination: 779 * <ul> 780 * <li>type=isssn, issuer, serial - IssuerAndSerialNumber</li> 781 * <li>type=isssn, cert - IssuerAndSerialNumber</li> 782 * <li>type=skid, skid - SubjectKeyIdentifier</li> 783 * <li>type=skdi, cert - SubjectKeyIdentifier</li> 784 * </ul> 785 * 786 * @example 787 * new KJUR.asn1.cms.SignerIdentifier({ 788 * type: "isssn", 789 * issuer: {str: "/C=JP/O=T1"}, 790 * serial: {hex: "12ab..."} 791 * }) 792 * new KJUR.asn1.cms.SignerIdentifier({ 793 * type: "isssn", 794 * cert: "-----BEGIN..." 795 * }) 796 * new KJUR.asn1.cms.SignerIdentifier({ 797 * type: "skid", 798 * skid: "12ab..." 799 * }) 800 * new KJUR.asn1.cms.SignerIdentifier({ 801 * type: "skid", 802 * cert: "-----BEGIN..." 803 * }) 804 */ 805 KJUR.asn1.cms.SignerIdentifier = function(params) { 806 var _KJUR = KJUR, 807 _KJUR_asn1 = _KJUR.asn1, 808 _DERInteger = _KJUR_asn1.DERInteger, 809 _DERSequence = _KJUR_asn1.DERSequence, 810 _KJUR_asn1_cms = _KJUR_asn1.cms, 811 _IssuerAndSerialNumber = _KJUR_asn1_cms.IssuerAndSerialNumber, 812 _SubjectKeyIdentifier = _KJUR_asn1_cms.SubjectKeyIdentifier, 813 _KJUR_asn1_x509 = _KJUR_asn1.x509, 814 _X500Name = _KJUR_asn1_x509.X500Name, 815 _X509 = X509, 816 _Error = Error; 817 818 _KJUR_asn1_cms.SignerIdentifier.superclass.constructor.call(this); 819 820 this.params = null; 821 822 this.tohex = function() { 823 var params = this.params; 824 if (params.type == "isssn") { 825 var dISSSN = new _IssuerAndSerialNumber(params); 826 return dISSSN.tohex(); 827 } else if (params.type == "skid") { 828 var dSKID = new _SubjectKeyIdentifier(params); 829 return dSKID.tohex(); 830 } else { 831 throw new Error("wrong property for isssn or skid"); 832 } 833 }; 834 this.getEncodedHex = function() { return this.tohex(); }; 835 836 if (params != undefined) this.setByParam(params); 837 }; 838 extendClass(KJUR.asn1.cms.SignerIdentifier, KJUR.asn1.ASN1Object); 839 840 /** 841 * class for IssuerAndSerialNumber ASN.1 structure for CMS<br/> 842 * @name KJUR.asn1.cms.IssuerAndSerialNumber 843 * @class class for CMS IssuerAndSerialNumber ASN.1 structure for CMS 844 * @param {Array} params associative array of parameters 845 * @extends KJUR.asn1.ASN1Object 846 * @since jsrsasign 4.2.4 asn1cms 1.0.0 847 * @see KJUR.asn1.cms.IssuerSerial 848 * 849 * @description 850 * This class encodes IssuerAndSerialNumber ASN.1 structure defined in 851 * <a href="https://tools.ietf.org/html/rfc5652#section-10.2.4"> 852 * RFC 5662 CMS 10.2.4</a>. 853 * <pre> 854 * IssuerAndSerialNumber ::= SEQUENCE { 855 * issuer Name, 856 * serialNumber CertificateSerialNumber } 857 * CertificateSerialNumber ::= INTEGER 858 * </pre> 859 * Constructor of this class can have following parameters: 860 * <ul> 861 * <li>{String}cert (OPTION) - PEM certificate string to specify issuer and serial</li> 862 * <li>{Array}issuer (OPTION) - {@link KJUR.asn1.x509.X500Name} parameter for issuer name</li> 863 * <li>{Array}serial (OPTION) - {@link KJUR.asn1.DERInteger} parameter for serialNumber</li> 864 * </ul> 865 * 866 * @example 867 * // specify by X500Name and DERInteger 868 * o = new KJUR.asn1.cms.IssuerAndSerialNumber( 869 * {issuer: {str: '/C=US/O=T1'}, serial: {int: 3}}); 870 * // specify by PEM certificate 871 * o = new KJUR.asn1.cms.IssuerAndSerialNumber({cert: certPEM}); 872 * o = new KJUR.asn1.cms.IssuerAndSerialNumber(certPEM); // since 1.0.3 873 */ 874 KJUR.asn1.cms.IssuerAndSerialNumber = function(params) { 875 var _KJUR = KJUR, 876 _KJUR_asn1 = _KJUR.asn1, 877 _DERInteger = _KJUR_asn1.DERInteger, 878 _DERSequence = _KJUR_asn1.DERSequence, 879 _KJUR_asn1_cms = _KJUR_asn1.cms, 880 _KJUR_asn1_x509 = _KJUR_asn1.x509, 881 _X500Name = _KJUR_asn1_x509.X500Name, 882 _X509 = X509, 883 _Error = Error; 884 885 _KJUR_asn1_cms.IssuerAndSerialNumber.superclass.constructor.call(this); 886 887 this.params = null; 888 889 this.tohex = function() { 890 var params = this.params; 891 892 var pIssuer, pSerial; 893 if ((typeof params == "string" && params.indexOf("-----BEGIN") != -1) || 894 params.cert != undefined) { 895 var pem; 896 897 if (params.cert != undefined) { 898 pem = params.cert; 899 } else { 900 pem = params; 901 } 902 903 var x = new _X509(); 904 x.readCertPEM(pem); 905 pIssuer = x.getIssuer(); 906 pSerial = {hex: x.getSerialNumberHex()}; 907 } else if (params.issuer != undefined && params.serial) { 908 pIssuer = params.issuer; 909 pSerial = params.serial; 910 } else { 911 throw new _Error("cert or issuer and serial parameter not specified"); 912 } 913 914 var dIssuer = new _X500Name(pIssuer); 915 var dSerial = new _DERInteger(pSerial); 916 var seq = new _DERSequence({array: [dIssuer, dSerial]}); 917 return seq.tohex(); 918 }; 919 this.getEncodedHex = function() { return this.tohex(); }; 920 921 this.setByParam = function(params) { 922 this.params = params; 923 } 924 925 if (params != undefined) this.setByParam(params); 926 }; 927 extendClass(KJUR.asn1.cms.IssuerAndSerialNumber, KJUR.asn1.ASN1Object); 928 929 /** 930 * class for SubjectKeyIdentifier ASN.1 structure for CMS SignerInfo<br/> 931 * @name KJUR.asn1.cms.SubjectKeyIdentifier 932 * @class class for SubjectKeyIdentifier ASN.1 structure for CMS SignerInfo 933 * @param {Array} params JSON object of parameters 934 * @extends KJUR.asn1.ASN1Object 935 * @since jsrsasign 10.0.0 asn1cms 2.0.0 936 * 937 * @description 938 * This class encodes SubjectKeyIdentifier ASN.1 structure defined in 939 * <a href="https://tools.ietf.org/html/rfc5652#section-12.1"> 940 * RFC 5652 CMS 12.1</a>. 941 * <pre> 942 * SubjectKeyIdentifier ::= OCTET STRING 943 * </pre> 944 * 945 * @example 946 * new KJUR.asn1.cms.SubjectKeyIdentifier({cert: "-----BEGIN..."}) 947 * new KJUR.asn1.cms.SubjectKeyIdentifier({skid: "12ab..."}) 948 */ 949 KJUR.asn1.cms.SubjectKeyIdentifier = function(params) { 950 var _KJUR = KJUR, 951 _KJUR_asn1 = _KJUR.asn1, 952 _DERInteger = _KJUR_asn1.DERInteger, 953 _DERSequence = _KJUR_asn1.DERSequence, 954 _newObject = _KJUR_asn1.ASN1Util.newObject, 955 _KJUR_asn1_cms = _KJUR_asn1.cms, 956 _IssuerAndSerialName = _KJUR_asn1_cms.IssuerAndSerialName, 957 _SubjectKeyIdentifier = _KJUR_asn1_cms.SubjectKeyIdentifier, 958 _KJUR_asn1_x509 = _KJUR_asn1.x509, 959 _X500Name = _KJUR_asn1_x509.X500Name, 960 _X509 = X509, 961 _Error = Error; 962 963 _KJUR_asn1_cms.SubjectKeyIdentifier.superclass.constructor.call(this); 964 965 this.tohex = function() { 966 var params = this.params; 967 968 if (params.cert == undefined && params.skid == undefined) 969 throw new _Error("property cert nor skid undefined"); 970 971 var hSKID; 972 if (params.cert != undefined) { 973 var x = new _X509(params.cert); 974 var pSKID = x.getExtSubjectKeyIdentifier(); 975 hSKID = pSKID.kid.hex; 976 } else if (params.skid != undefined) { 977 hSKID = params.skid; 978 } 979 var dSKID = 980 _newObject({tag:{tage:"a0",obj:{octstr:{hex:hSKID}}}}); 981 return dSKID.tohex(); 982 }; 983 this.getEncodedHex = function() { return this.tohex(); }; 984 985 if (params != undefined) this.setByParam(params); 986 }; 987 extendClass(KJUR.asn1.cms.SubjectKeyIdentifier, KJUR.asn1.ASN1Object); 988 989 /** 990 * class for Attributes ASN.1 structure for CMS<br/> 991 * @name KJUR.asn1.cms.AttributeList 992 * @class class for Attributes ASN.1 structure for CMS 993 * @param {Array} params associative array of parameters 994 * @extends KJUR.asn1.ASN1Object 995 * @since jsrsasign 4.2.4 asn1cms 1.0.0 996 * 997 * @description 998 * <pre> 999 * Attributes ::= SET OF Attribute 1000 * Attribute ::= SEQUENCE { 1001 * type OBJECT IDENTIFIER, 1002 * values AttributeSetValue } 1003 * </pre> 1004 * 1005 * @example 1006 * new KJUR.asn1.cms.AttributeList({ 1007 * array: [{ 1008 * attr: "contentType", 1009 * type: "data" 1010 * }], 1011 * sortflag: false 1012 * }) 1013 */ 1014 KJUR.asn1.cms.AttributeList = function(params) { 1015 var _Error = Error, 1016 _KJUR = KJUR, 1017 _KJUR_asn1 = _KJUR.asn1, 1018 _DERSet = _KJUR_asn1.DERSet, 1019 _KJUR_asn1_cms = _KJUR_asn1.cms; 1020 1021 _KJUR_asn1_cms.AttributeList.superclass.constructor.call(this); 1022 1023 this.params = null; 1024 this.hTLV = null; 1025 1026 this.setByParam = function(params) { 1027 this.params = params; 1028 }; 1029 1030 this.tohex = function() { 1031 var params = this.params; 1032 if (this.hTLV != null) return this.hTLV; 1033 1034 var sortflag = true; 1035 if (params.sortflag != undefined) { 1036 sortflag = params.sortflag; 1037 } 1038 1039 var aAttrParam = params.array; 1040 var a = []; 1041 for (var i = 0; i < aAttrParam.length; i++) { 1042 var pAttr = aAttrParam[i]; 1043 var attrName = pAttr.attr; 1044 if (attrName == "contentType") { 1045 a.push(new _KJUR_asn1_cms.ContentType(pAttr)); 1046 } else if (attrName == "messageDigest") { 1047 a.push(new _KJUR_asn1_cms.MessageDigest(pAttr)); 1048 } else if (attrName == "signingTime") { 1049 a.push(new _KJUR_asn1_cms.SigningTime(pAttr)); 1050 } else if (attrName == "signingCertificate") { 1051 a.push(new _KJUR_asn1_cms.SigningCertificate(pAttr)); 1052 } else if (attrName == "signingCertificateV2") { 1053 a.push(new _KJUR_asn1_cms.SigningCertificateV2(pAttr)); 1054 } else if (attrName == "signaturePolicyIdentifier") { 1055 a.push(new KJUR.asn1.cades.SignaturePolicyIdentifier(pAttr)); 1056 } else if (attrName == "signatureTimeStamp" || 1057 attrName == "timeStampToken") { 1058 a.push(new KJUR.asn1.cades.SignatureTimeStamp(pAttr)); 1059 } else { 1060 throw new _Error("unknown attr: " + attrName); 1061 } 1062 } 1063 1064 var dSet = new _DERSet({array: a, sortflag: sortflag}); 1065 this.hTLV = dSet.tohex(); 1066 return this.hTLV; 1067 }; 1068 this.getEncodedHex = function() { return this.tohex(); }; 1069 1070 if (params != undefined) this.setByParam(params); 1071 }; 1072 extendClass(KJUR.asn1.cms.AttributeList, KJUR.asn1.ASN1Object); 1073 1074 /** 1075 * class for SignerInfo ASN.1 structure of CMS SignedData<br/> 1076 * @name KJUR.asn1.cms.SignerInfo 1077 * @class class for Attributes ASN.1 structure of CMS SigndData 1078 * @param {Array} params associative array of parameters 1079 * @extends KJUR.asn1.ASN1Object 1080 * @since jsrsasign 4.2.4 asn1cms 1.0.0 1081 * @see KJUR.asn1.cms.SignerIdentifier 1082 * @see KJUR.asn1.x509.AlgorithmIdentifier 1083 * @see KJUR.asn1.cms.AttributeList 1084 * 1085 * @description 1086 * This class is an ASN.1 encoder for SignerInfo structure 1087 * defined in 1088 * <a https://tools.ietf.org/html/rfc5652#section-5.3"> 1089 * RFC 5652 CMS section 5.3</a>. 1090 * <pre> 1091 * SignerInfo ::= SEQUENCE { 1092 * version CMSVersion, 1093 * sid SignerIdentifier, 1094 * digestAlgorithm DigestAlgorithmIdentifier, 1095 * signedAttrs [0] IMPLICIT SignedAttributes OPTIONAL, 1096 * signatureAlgorithm SignatureAlgorithmIdentifier, 1097 * signature SignatureValue, 1098 * unsignedAttrs [1] IMPLICIT UnsignedAttributes OPTIONAL } 1099 * </pre> 1100 * Constractor parameter can have following properties: 1101 * <ul> 1102 * <li>{Integer}version - version of SignerInfo. </li> 1103 * <li>{Array}id - {@link KJUR.asn1.cms.SignerIdentifier} parameter for sid</li> 1104 * <li>{String}hashalg - digestAlgorithm name string (ex. "sha256")</li> 1105 * <li>{Array}sattrs - {@link KJUR.asn1.cms.AttributeList} parameter for 1106 * signedAttributes</li> 1107 * <li>{String}sigalg - string for signatureAlgorithm name</a> 1108 * <li>{String}signkey (OPTION) - specifies signing private key. 1109 * Parameter "signkey" or "sighex" shall be specified. Following 1110 * values can be specified: 1111 * <ul> 1112 * <li>PKCS#1/5 or PKCS#8 PEM string of private key</li> 1113 * <li>RSAKey/DSA/ECDSA key object. {@link KEYUTIL.getKey} is useful 1114 * to generate a key object.</li> 1115 * </ul> 1116 * </li> 1117 * <li>{String}sighex (OPTION) - hexadecimal string of signature value 1118 * (i.e. ASN.1 value(V) of signatureValue BIT STRING without 1119 * unused bits)</li> 1120 * </ul> 1121 * 1122 * @example 1123 * new KJUR.asn1.cms.SignerInfo({ 1124 * version: 1, 1125 * id: {type: 'isssn', issuer: {str: '/C=US/O=T1'}, serial: {int: 1}}, 1126 * hashalg: "sha1", 1127 * sattrs: {array: [{ 1128 * attr: "contentType", 1129 * type: '1.2.840.113549.1.7.1' 1130 * },{ 1131 * attr: "messageDigest", 1132 * hex: 'a1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0' 1133 * }]}, 1134 * sigalg: "SHA1withRSA", 1135 * sighex: 'b1b2b...' 1136 * }) 1137 */ 1138 KJUR.asn1.cms.SignerInfo = function(params) { 1139 var _Error = Error, 1140 _KJUR = KJUR, 1141 _KJUR_asn1 = _KJUR.asn1, 1142 _DERInteger = _KJUR_asn1.DERInteger, 1143 _DEROctetString = _KJUR_asn1.DEROctetString, 1144 _DERSequence = _KJUR_asn1.DERSequence, 1145 _DERTaggedObject = _KJUR_asn1.DERTaggedObject, 1146 _KJUR_asn1_cms = _KJUR_asn1.cms, 1147 _SignerIdentifier = _KJUR_asn1_cms.SignerIdentifier, 1148 _AttributeList = _KJUR_asn1_cms.AttributeList, 1149 _ContentType = _KJUR_asn1_cms.ContentType, 1150 _EncapsulatedContentInfo = _KJUR_asn1_cms.EncapsulatedContentInfo, 1151 _MessageDigest = _KJUR_asn1_cms.MessageDigest, 1152 _SignedData = _KJUR_asn1_cms.SignedData, 1153 _KJUR_asn1_x509 = _KJUR_asn1.x509, 1154 _AlgorithmIdentifier = _KJUR_asn1_x509.AlgorithmIdentifier, 1155 _KJUR_crypto = _KJUR.crypto, 1156 _KEYUTIL = KEYUTIL; 1157 1158 _KJUR_asn1_cms.SignerInfo.superclass.constructor.call(this); 1159 1160 this.params = null; 1161 1162 /** 1163 * sign SignerInfo<br/> 1164 * @name sign 1165 * @memberOf KJUR.asn1.cms.SignerInfo# 1166 * @function 1167 * 1168 * @description 1169 * This method signs SignerInfo with a specified 1170 * private key and algorithm by 1171 * "params.signkey" and "params.sigalg" parameter. 1172 * In general, you don't need to call this method. 1173 * It will be called when tohex() method if necessary. 1174 * 1175 * @example 1176 * si = new KJUR.asn1.cms.SignerInfo({...}); 1177 * si.sign() 1178 */ 1179 this.sign = function() { 1180 var params = this.params; 1181 var sigalg = params.sigalg; 1182 1183 var hData = (new _AttributeList(params.sattrs)).tohex(); 1184 var prvkey = _KEYUTIL.getKey(params.signkey); 1185 var sig = new _KJUR_crypto.Signature({alg: sigalg}); 1186 sig.init(prvkey); 1187 sig.updateHex(hData); 1188 var hSig = sig.sign(); 1189 params.sighex = hSig; 1190 }; 1191 1192 this.tohex = function() { 1193 var params = this.params; 1194 1195 var a = []; 1196 a.push(new _DERInteger({"int": params.version})); 1197 a.push(new _SignerIdentifier(params.id)); 1198 a.push(new _AlgorithmIdentifier({name: params.hashalg})); 1199 if (params.sattrs != undefined) { 1200 var dList = new _AttributeList(params.sattrs); 1201 try { 1202 a.push(new _DERTaggedObject({tag: "a0", 1203 explicit: false, 1204 obj: dList})); 1205 } catch(ex) { 1206 throw new _Error("si sattr error: " + ex); 1207 } 1208 } 1209 1210 if (params.sigalgfield != undefined) { 1211 a.push(new _AlgorithmIdentifier({name: params.sigalgfield})); 1212 } else { 1213 a.push(new _AlgorithmIdentifier({name: params.sigalg})); 1214 } 1215 1216 if (params.sighex == undefined && 1217 params.signkey != undefined) { 1218 this.sign(); 1219 } 1220 a.push(new _DEROctetString({hex: params.sighex})); 1221 1222 if (params.uattrs != undefined) { 1223 var dList = new _AttributeList(params.uattrs); 1224 try { 1225 a.push(new _DERTaggedObject({tag: "a1", 1226 explicit: false, 1227 obj: dList})); 1228 } catch(ex) { 1229 throw new _Error("si uattr error: " + ex); 1230 } 1231 } 1232 1233 var seq = new _DERSequence({array: a}); 1234 return seq.tohex(); 1235 }; 1236 this.getEncodedHex = function() { return this.tohex(); }; 1237 1238 if (params != undefined) this.setByParam(params); 1239 }; 1240 extendClass(KJUR.asn1.cms.SignerInfo, KJUR.asn1.ASN1Object); 1241 1242 /** 1243 * class for EncapsulatedContentInfo ASN.1 structure for CMS<br/> 1244 * @name KJUR.asn1.cms.EncapsulatedContentInfo 1245 * @class class for EncapsulatedContentInfo ASN.1 structure for CMS 1246 * @param {Array} params associative array of parameters 1247 * @extends KJUR.asn1.ASN1Object 1248 * @since jsrsasign 4.2.4 asn1cms 1.0.0 1249 * 1250 * @description 1251 * <pre> 1252 * EncapsulatedContentInfo ::= SEQUENCE { 1253 * eContentType ContentType, 1254 * eContent [0] EXPLICIT OCTET STRING OPTIONAL } 1255 * ContentType ::= OBJECT IDENTIFIER 1256 * </pre> 1257 * 1258 * @example 1259 * new KJUR.asn1.cms.EncapsulatedContentInfo({ 1260 * type: "data", 1261 * content: {str: "aaa"} 1262 * }) 1263 * new KJUR.asn1.cms.EncapsulatedContentInfo({ 1264 * type: "data", 1265 * content: {hex: "616161"} 1266 * }) 1267 * new KJUR.asn1.cms.EncapsulatedContentInfo({ 1268 * type: "data", 1269 * content: {hex: "616161"}, 1270 * isDetached: true 1271 * }) 1272 * new KJUR.asn1.cms.EncapsulatedContentInfo({ 1273 * type: "tstinfo", 1274 * content: ...TSTInfo parameters... 1275 * }) 1276 */ 1277 KJUR.asn1.cms.EncapsulatedContentInfo = function(params) { 1278 var _KJUR = KJUR, 1279 _KJUR_asn1 = _KJUR.asn1, 1280 _DERTaggedObject = _KJUR_asn1.DERTaggedObject, 1281 _DERSequence = _KJUR_asn1.DERSequence, 1282 _DERObjectIdentifier = _KJUR_asn1.DERObjectIdentifier, 1283 _DEROctetString = _KJUR_asn1.DEROctetString, 1284 _KJUR_asn1_cms = _KJUR_asn1.cms; 1285 1286 _KJUR_asn1_cms.EncapsulatedContentInfo.superclass.constructor.call(this); 1287 1288 this.params = null; 1289 1290 this.tohex = function() { 1291 var params = this.params; 1292 1293 var a = []; 1294 1295 a.push(new _DERObjectIdentifier(params.type)); 1296 1297 if (params.content != undefined && 1298 (params.content.hex != undefined || 1299 params.content.str != undefined) && 1300 params.isDetached != true) { 1301 var dOctStr = new _DEROctetString(params.content); 1302 var dEContent = new _DERTaggedObject({tag: "a0", 1303 explicit: true, 1304 obj: dOctStr}); 1305 a.push(dEContent); 1306 } 1307 1308 var seq = new _DERSequence({array: a}); 1309 return seq.tohex(); 1310 }; 1311 this.getEncodedHex = function() { return this.tohex(); }; 1312 1313 this.setByParam = function(params) { 1314 this.params = params; 1315 }; 1316 1317 if (params != undefined) this.setByParam(params); 1318 }; 1319 extendClass(KJUR.asn1.cms.EncapsulatedContentInfo, KJUR.asn1.ASN1Object); 1320 1321 // - type 1322 // - obj 1323 /** 1324 * class for ContentInfo ASN.1 structure for CMS 1325 * @name KJUR.asn1.cms.ContentInfo 1326 * @class class for ContentInfo ASN.1 structure for CMS 1327 * @param {Array} params associative array of parameters 1328 * @extends KJUR.asn1.ASN1Object 1329 * @since jsrsasign 4.2.4 asn1cms 1.0.0 1330 * @description 1331 * <pre> 1332 * ContentInfo ::= SEQUENCE { 1333 * contentType ContentType, 1334 * content [0] EXPLICIT ANY DEFINED BY contentType } 1335 * ContentType ::= OBJECT IDENTIFIER 1336 * </pre> 1337 * @example 1338 * a = [new KJUR.asn1.DERInteger({int: 1}), 1339 * new KJUR.asn1.DERInteger({int: 2})]; 1340 * seq = new KJUR.asn1.DERSequence({array: a}); 1341 * o = new KJUR.asn1.cms.ContentInfo({type: 'data', obj: seq}); 1342 */ 1343 KJUR.asn1.cms.ContentInfo = function(params) { 1344 var _KJUR = KJUR, 1345 _KJUR_asn1 = _KJUR.asn1, 1346 _DERTaggedObject = _KJUR_asn1.DERTaggedObject, 1347 _DERSequence = _KJUR_asn1.DERSequence, 1348 _DERObjectIdentifier = _KJUR_asn1.DERObjectIdentifier, 1349 _KJUR_asn1_x509 = _KJUR_asn1.x509, 1350 _name2obj = _KJUR_asn1_x509.OID.name2obj; 1351 1352 KJUR.asn1.cms.ContentInfo.superclass.constructor.call(this); 1353 1354 this.params = null; 1355 1356 this.tohex = function() { 1357 var params = this.params; 1358 1359 var a = []; 1360 a.push(new _DERObjectIdentifier(params.type)); 1361 1362 var dContent0 = new _DERTaggedObject({ 1363 tag: "a0", 1364 explicit: true, 1365 obj: params.obj 1366 }); 1367 a.push(dContent0); 1368 1369 var seq = new _DERSequence({array: a}); 1370 return seq.tohex(); 1371 }; 1372 this.getEncodedHex = function() { return this.tohex(); }; 1373 1374 this.setByParam = function(params) { 1375 this.params = params; 1376 }; 1377 1378 if (params != undefined) this.setByParam(params); 1379 }; 1380 extendClass(KJUR.asn1.cms.ContentInfo, KJUR.asn1.ASN1Object); 1381 1382 /** 1383 * class for SignerInfo ASN.1 structure of CMS SignedData 1384 * @name KJUR.asn1.cms.SignedData 1385 * @class class for Attributes ASN.1 structure of CMS SigndData 1386 * @param {Array} params associative array of parameters 1387 * @extends KJUR.asn1.ASN1Object 1388 * @since jsrsasign 4.2.4 asn1cms 1.0.0 1389 * 1390 * @description 1391 * <pre> 1392 * ContentInfo ::= SEQUENCE { 1393 * contentType ContentType, 1394 * content [0] EXPLICIT ANY DEFINED BY contentType } 1395 * ContentType ::= OBJECT IDENTIFIER 1396 * SignedData ::= SEQUENCE { 1397 * version CMSVersion, 1398 * digestAlgorithms DigestAlgorithmIdentifiers, 1399 * encapContentInfo EncapsulatedContentInfo, 1400 * certificates [0] IMPLICIT CertificateSet OPTIONAL, 1401 * crls [1] IMPLICIT RevocationInfoChoices OPTIONAL, 1402 * signerInfos SignerInfos } 1403 * SignerInfos ::= SET OF SignerInfo 1404 * CertificateSet ::= SET OF CertificateChoices 1405 * DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier 1406 * CertificateSet ::= SET OF CertificateChoices 1407 * RevocationInfoChoices ::= SET OF RevocationInfoChoice 1408 * </pre> 1409 * 1410 * @example 1411 * sd = new KJUR.asn1.cms.SignedData({ 1412 * version: 1, 1413 * hashalgs: ["sha1"], 1414 * econtent: { 1415 * type: "data", 1416 * content: { 1417 * hex: "616161" 1418 * } 1419 * }, 1420 * certs: [PEM1,...], 1421 * revinfos: {array: [...]}, 1422 * sinfos: [{ 1423 * version: 1, 1424 * id: {type:'isssn', issuer: {str: '/C=US/O=T1'}, serial: {int: 1}}, 1425 * hashalg: "sha1", 1426 * sattrs: {array: [{ 1427 * attr: "contentType", 1428 * type: '1.2.840.113549.1.7.1' 1429 * },{ 1430 * attr: "messageDigest", 1431 * hex: 'abcd' 1432 * }]}, 1433 * sigalg: "SHA1withRSA", 1434 * signkey: PEMPRIVATEKEY 1435 * }] 1436 * }); 1437 * hex = sd.getContentInfoEncodedHex(); 1438 */ 1439 KJUR.asn1.cms.SignedData = function(params) { 1440 var _Error = Error, 1441 _KJUR = KJUR, 1442 _KJUR_asn1 = _KJUR.asn1, 1443 _ASN1Object = _KJUR_asn1.ASN1Object, 1444 _DERInteger = _KJUR_asn1.DERInteger, 1445 _DERSet = _KJUR_asn1.DERSet, 1446 _DERSequence = _KJUR_asn1.DERSequence, 1447 _DERTaggedObject = _KJUR_asn1.DERTaggedObject, 1448 _KJUR_asn1_cms = _KJUR_asn1.cms, 1449 _EncapsulatedContentInfo = _KJUR_asn1_cms.EncapsulatedContentInfo, 1450 _SignerInfo = _KJUR_asn1_cms.SignerInfo, 1451 _ContentInfo = _KJUR_asn1_cms.ContentInfo, 1452 _CertificateSet = _KJUR_asn1_cms.CertificateSet, 1453 _RevocationInfoChoices = _KJUR_asn1_cms.RevocationInfoChoices, 1454 _KJUR_asn1_x509 = _KJUR_asn1.x509, 1455 _AlgorithmIdentifier = _KJUR_asn1_x509.AlgorithmIdentifier; 1456 1457 KJUR.asn1.cms.SignedData.superclass.constructor.call(this); 1458 1459 this.params = null; 1460 1461 /** 1462 * fix fields before ASN.1 encode<br/> 1463 * @name checkAndFixParam 1464 * @memberOf KJUR.asn1.cms.SignedData# 1465 * @function 1466 * 1467 * @description 1468 * Update following values of "params" property 1469 * as defined in RFC 5652: 1470 * <ul> 1471 * <li>set "digestAlgorithms" field of "signedData" by 1472 * signerInfos</li> 1473 * <li>set all "contentType" signed attribute value to 1474 * the same value of eContent</li> 1475 * <li>set all "messageDigest" signed attribute value 1476 * to hash value of eContent contents value</li> 1477 * <li>all signerInfo version by their fields</li> 1478 * <li>signedData version by their fields</li> 1479 * </ul> 1480 * In general, you don't need to call this method. 1481 * It will be called automatically when 1482 * getEncodedHex() method is called. 1483 * <br> 1484 * NOTE: If you don't want to do such property value 1485 * update, set "params.fixed" property to "true". 1486 */ 1487 this.checkAndFixParam = function() { 1488 var sdparams = this.params; 1489 this._setDigestAlgs(sdparams); 1490 this._setContentTypeByEContent(sdparams); 1491 this._setMessageDigestByEContent(sdparams); 1492 this._setSignerInfoVersion(sdparams); 1493 this._setSignedDataVersion(sdparams); 1494 }; 1495 1496 /* 1497 * @description 1498 * Get params.sinfos[*].hashalg for all "signerInfo" 1499 * and set "params.hashalgs" of "signedData" as 1500 * array of hash algorithm names. 1501 */ 1502 this._setDigestAlgs = function(sdparams) { 1503 var pHash = {}; 1504 var sinfos = sdparams.sinfos; 1505 for (var i = 0; i < sinfos.length; i++) { 1506 var sinfo = sinfos[i]; 1507 pHash[sinfo.hashalg] = 1; 1508 } 1509 sdparams.hashalgs = Object.keys(pHash).sort(); 1510 }; 1511 1512 /* 1513 * @description 1514 * set "contentType" attribute value in 1515 * "params.sinfos[*].sattrs" to "params.econtent.type" 1516 * value. 1517 */ 1518 this._setContentTypeByEContent = function(sdparams) { 1519 var type = sdparams.econtent.type; 1520 var sinfos = sdparams.sinfos; 1521 for (var i = 0; i < sinfos.length; i++) { 1522 var sinfo = sinfos[i]; 1523 var ctParam = this._getAttrParamByName(sinfo, "contentType"); 1524 //console.log(ctParam.type + " > " + type); 1525 ctParam.type = type; 1526 } 1527 }; 1528 1529 /* 1530 * @description 1531 * set "messageDigest" attribute value in 1532 * "params.sinfos[*].sattrs" to a 1533 * calculated hash value by "econtent.content.hex" 1534 * with "params.sinfos[*].hashalg" algorithm. 1535 */ 1536 this._setMessageDigestByEContent = function(sdparams) { 1537 var econtent = sdparams.econtent; 1538 var type = sdparams.econtent.type; 1539 1540 var hContent = econtent.content.hex; 1541 if (hContent == undefined && 1542 econtent.type == "data" && 1543 econtent.content.str != undefined) { 1544 hContent = rstrtohex(econtent.content.str); 1545 } 1546 1547 var sinfos = sdparams.sinfos; 1548 for (var i = 0; i < sinfos.length; i++) { 1549 var sinfo = sinfos[i]; 1550 var hashalg = sinfo.hashalg; 1551 var mdParam = this._getAttrParamByName(sinfo, "messageDigest"); 1552 1553 var hNew = KJUR.crypto.Util.hashHex(hContent, hashalg); 1554 1555 //console.log(mdParam.hex + " > " + hNew); 1556 mdParam.hex = hNew; 1557 } 1558 }; 1559 1560 /* 1561 * @param {Array}siParam "signerInfo" JSON parameter reference 1562 * @param {String}attrName attribute name string 1563 * @return {Array} attribute JSON parameter reference 1564 * @description 1565 * Find signed attribute parameter from signerInfo parameter 1566 * by attribute name. 1567 */ 1568 this._getAttrParamByName = function(siParam, attrName) { 1569 var aSattrs = siParam.sattrs.array; 1570 for (var i = 0; i < aSattrs.length; i++) { 1571 if (aSattrs[i].attr == attrName) return aSattrs[i]; 1572 } 1573 }; 1574 1575 /* 1576 * @description 1577 * set signerInfo version "params.sinfos[*].version" 1578 * of all signerInfos by signerInfo parameter. 1579 * Version will be identified by "signerIdentifier" is 1580 * "skid" or not. 1581 */ 1582 this._setSignerInfoVersion = function(sdparams) { 1583 var sinfos = sdparams.sinfos; 1584 for (var i = 0; i < sinfos.length; i++) { 1585 var sinfo = sinfos[i]; 1586 var newVersion = 1; 1587 if (sinfo.id.type == "skid") newVersion = 3; 1588 sinfo.version = newVersion; 1589 } 1590 }; 1591 1592 /* 1593 * @description 1594 * set "signedData" version "params.version" 1595 * to value by _getSignedDataVersion() 1596 */ 1597 this._setSignedDataVersion = function(sdparams) { 1598 var newVersion = this._getSignedDataVersion(sdparams); 1599 //console.log("sd version: " + sdparams.version + " > " + newVersion); 1600 sdparams.version = newVersion; 1601 }; 1602 1603 /* 1604 * @description 1605 * get "signedData" version from parameters. 1606 * If "revinfos" "ocsp" exists, then version 5. 1607 * If "signerInfo" version 3 exists, then version 3. 1608 * If "params.econtent.type" is not "data" then version 3. 1609 * Otherwise version 1. 1610 */ 1611 this._getSignedDataVersion = function(sdparams) { 1612 //alert(JSON.stringify(sdparams)); 1613 1614 if (sdparams.revinfos != undefined) { 1615 var revinfos = sdparams.revinfos; 1616 for (var i = 0; i < revinfos.length; i++) { 1617 var revinfo = revinfos[i]; 1618 if (revinfo.ocsp != undefined) return 5; 1619 } 1620 } 1621 1622 var sinfos = sdparams.sinfos; 1623 for (var i = 0; i < sinfos.length; i++) { 1624 var sinfo = sdparams.sinfos[i]; 1625 if (sinfo.version == 3) return 3; 1626 } 1627 1628 if (sdparams.econtent.type != "data") return 3; 1629 return 1; 1630 }; 1631 1632 this.tohex = function() { 1633 var params = this.params; 1634 1635 if (this.getEncodedHexPrepare != undefined) { 1636 this.getEncodedHexPrepare(); 1637 } 1638 1639 if (params.fixed != true) { 1640 this.checkAndFixParam(); 1641 } 1642 1643 var a = []; 1644 1645 a.push(new _DERInteger({"int": params.version})); 1646 1647 var aHashAlg = []; 1648 for (var i = 0; i < params.hashalgs.length; i++) { 1649 var name = params.hashalgs[i]; 1650 aHashAlg.push(new _AlgorithmIdentifier({name: name})); 1651 } 1652 a.push(new _DERSet({array: aHashAlg})); 1653 1654 a.push(new _EncapsulatedContentInfo(params.econtent)); 1655 1656 if (params.certs != undefined) { 1657 a.push(new _CertificateSet(params.certs)); 1658 } 1659 1660 if (params.revinfos != undefined) { 1661 a.push(new _RevocationInfoChoices(params.revinfos)); 1662 } 1663 1664 var aSignerInfo = []; 1665 for (var i = 0; i < params.sinfos.length; i++) { 1666 var pSI = params.sinfos[i]; 1667 aSignerInfo.push(new _SignerInfo(pSI)); 1668 } 1669 a.push(new _DERSet({array: aSignerInfo})); 1670 1671 var seq = new _DERSequence({array: a}); 1672 return seq.tohex(); 1673 }; 1674 this.getEncodedHex = function() { return this.tohex(); }; 1675 1676 /** 1677 * get ContentInfo ASN.1 object concluding CMS SignedData<br/> 1678 * @name getContentInfo 1679 * @memberOf KJUR.asn1.cms.SignedData# 1680 * @function 1681 * @return {Object} ContentInfo of SigneData as {@link KJUR.asn1.ASN1Object} 1682 * @see KJUR.asn1.cms.ContentInfo 1683 * 1684 * @description 1685 * This method returns a {@link KJUR.asn1.ASN1Object} 1686 * of 1687 * ContentInfo concludes SignedData. 1688 * 1689 * @example 1690 * sd = new KJUR.asn1.cms.SignedData({...}); 1691 * sd.getContentInfo(); 1692 */ 1693 this.getContentInfo = function() { 1694 var dContentInfo = new _ContentInfo({ 1695 type: 'signed-data', 1696 obj: this 1697 }); 1698 return dContentInfo; 1699 }; 1700 1701 /** 1702 * get hex of entire ContentInfo of CMS SignedData<br/> 1703 * @name getContentInfoEncodedHex 1704 * @memberOf KJUR.asn1.cms.SignedData# 1705 * @function 1706 * @return {String} hexadecimal string of entire ContentInfo of CMS SignedData 1707 * @see KJUR.asn1.cms.SignedData#getContentInfo 1708 * @see KJUR.asn1.cms.ContentInfo 1709 * 1710 * @description 1711 * This method returns a hexadecimal string of 1712 * ContentInfo concludes SignedData. 1713 * 1714 * @example 1715 * sd = new KJUR.asn1.cms.SignedData({...}); 1716 * sd.getContentInfoEncodedHex() &rarr "3082..." 1717 */ 1718 this.getContentInfoEncodedHex = function() { 1719 return this.getContentInfo().tohex(); 1720 }; 1721 1722 if (params != undefined) this.setByParam(params); 1723 }; 1724 extendClass(KJUR.asn1.cms.SignedData, KJUR.asn1.ASN1Object); 1725 1726 /** 1727 * class for CertificateSet ASN.1 structure for CMS SignedData<br/> 1728 * @name KJUR.asn1.cms.CertificateSet 1729 * @class class for CertificateSet ASN.1 structure for CMS SignedData 1730 * @param {Array} params array of RevocationInfoChoice parameters 1731 * @extends KJUR.asn1.ASN1Object 1732 * @since jsrsasign 10.0.0 asn1cms 2.0.0 1733 * @see KJUR.asn1.cms.SignedData 1734 * @see KJUR.asn1.cms.RevocationInfoChoice 1735 * 1736 * @description 1737 * This is an ASN.1 encoder for CertificateSet 1738 * ASN.1 structure defined in 1739 * <a href="https://tools.ietf.org/html/rfc5652#section-10.2.3"> 1740 * RFC 5652 CMS section 10.2.3</a> and 1741 * <a href="https://tools.ietf.org/html/rfc5652#section-10.2.2"> 1742 * section 10.2.2</a>. 1743 * <pre> 1744 * CertificateSet ::= SET OF CertificateChoices 1745 * CertificateChoices ::= CHOICE { 1746 * certificate Certificate, 1747 * extendedCertificate [0] IMPLICIT ExtendedCertificate, -- Obsolete 1748 * v1AttrCert [1] IMPLICIT AttributeCertificateV1, -- Obsolete 1749 * v2AttrCert [2] IMPLICIT AttributeCertificateV2, 1750 * other [3] IMPLICIT OtherCertificateFormat } 1751 * OtherCertificateFormat ::= SEQUENCE { 1752 * otherCertFormat OBJECT IDENTIFIER, 1753 * otherCert ANY DEFINED BY otherCertFormat } 1754 * </pre> 1755 * Currently only "certificate" is supported in 1756 * CertificateChoices. 1757 * 1758 * @example 1759 * new KJUR.asn1.cms.CertificateSet([certpem1,certpem2,...]) 1760 * new KJUR.asn1.cms.CertificateSet({ 1761 * array: [certpem1,certpem2,...], 1762 * sortflag: false 1763 * }) 1764 */ 1765 KJUR.asn1.cms.CertificateSet = function(params) { 1766 KJUR.asn1.cms.CertificateSet.superclass.constructor.call(this); 1767 1768 var _Error = Error, 1769 _KJUR_asn1 = KJUR.asn1, 1770 _DERTaggedObject = _KJUR_asn1.DERTaggedObject, 1771 _DERSet = _KJUR_asn1.DERSet, 1772 _ASN1Object = _KJUR_asn1.ASN1Object; 1773 1774 this.params = null; 1775 1776 this.tohex = function() { 1777 var params = this.params; 1778 var a = []; 1779 1780 var aParam; 1781 if (params instanceof Array) { 1782 aParam = params; 1783 } else if (params.array != undefined) { 1784 aParam = params.array; 1785 } else { 1786 throw new _Error("cert array not specified"); 1787 } 1788 1789 for (var i = 0; i < aParam.length; i++) { 1790 var pem = aParam[i]; 1791 var hCert = pemtohex(pem); 1792 var dCert = new _ASN1Object(); 1793 dCert.hTLV = hCert; 1794 a.push(dCert); 1795 } 1796 var pSet = {array: a}; 1797 if (params.sortflag == false) pSet.sortflag = false; 1798 var dSet = new _DERSet(pSet); 1799 1800 var dTagObj = new _DERTaggedObject({ 1801 tag: "a0", 1802 explicit: false, 1803 obj: dSet 1804 }); 1805 return dTagObj.tohex(); 1806 }; 1807 this.getEncodedHex = function() { return this.tohex(); }; 1808 1809 if (params != undefined) this.setByParam(params); 1810 }; 1811 extendClass(KJUR.asn1.cms.CertificateSet, KJUR.asn1.ASN1Object); 1812 1813 /** 1814 * class for RevocationInfoChoices ASN.1 structure for CMS SignedData<br/> 1815 * @name KJUR.asn1.cms.RevocationInfoChoices 1816 * @class class for RevocationInfoChoices ASN.1 structure for CMS SignedData 1817 * @param {Array} params array of parameters 1818 * @extends KJUR.asn1.ASN1Object 1819 * @since jsrsasign 10.0.0 asn1cms 2.0.0 1820 * @see KJUR.asn1.cms.SignedData 1821 * 1822 * @description 1823 * This is an ASN.1 encoder for RevocationInfoChoices 1824 * ASN.1 structure defined in 1825 * <a href="https://tools.ietf.org/html/rfc5652#section-10.2.1"> 1826 * RFC 5652 CMS section 10.2.1</a>. 1827 * <pre> 1828 * RevocationInfoChoices ::= SET OF RevocationInfoChoice 1829 * RevocationInfoChoice ::= CHOICE { 1830 * crl CertificateList, 1831 * other [1] IMPLICIT OtherRevocationInfoFormat } 1832 * OtherRevocationInfoFormat ::= SEQUENCE { 1833 * otherRevInfoFormat OBJECT IDENTIFIER, 1834 * otherRevInfo ANY DEFINED BY otherRevInfoFormat } 1835 * </pre> 1836 * 1837 * @example 1838 * new KJUR.asn1.cms.RevocationInfoChoices([ 1839 * {crl: CRLPEMorHex1}, 1840 * {ocsp: OCSPResponseHex1}, 1841 * ... 1842 * ]}) 1843 */ 1844 KJUR.asn1.cms.RevocationInfoChoices = function(params) { 1845 KJUR.asn1.cms.RevocationInfoChoices.superclass.constructor.call(this); 1846 1847 this.params = null; 1848 1849 this.tohex = function() { 1850 var params = this.params; 1851 1852 if (! params instanceof Array) 1853 throw new Error("params is not array"); 1854 1855 var a = []; 1856 for (var i = 0; i < params.length; i++) { 1857 a.push(new KJUR.asn1.cms.RevocationInfoChoice(params[i])); 1858 } 1859 var dRevInfos = KJUR.asn1.ASN1Util.newObject({tag: {tagi:"a1",obj:{set:a}}}); 1860 return dRevInfos.tohex(); 1861 }; 1862 this.getEncodedHex = function() { return this.tohex(); }; 1863 1864 if (params != undefined) this.setByParam(params); 1865 }; 1866 extendClass(KJUR.asn1.cms.RevocationInfoChoices, KJUR.asn1.ASN1Object); 1867 1868 /** 1869 * class for RevocationInfoChoice ASN.1 structure for CMS SignedData<br/> 1870 * @name KJUR.asn1.cms.RevocationInfoChoice 1871 * @class class for RevocationInfoChoice ASN.1 structure for CMS SignedData 1872 * @param {Array} params array of parameters 1873 * @extends KJUR.asn1.ASN1Object 1874 * @since jsrsasign 10.0.0 asn1cms 2.0.0 1875 * @see KJUR.asn1.cms.SignedData 1876 * @see KJUR.asn1.cms.RevocationInfoChoices 1877 * 1878 * @description 1879 * This is an ASN.1 encoder for RevocationInfoChoice 1880 * ASN.1 structure defined in 1881 * <a href="https://tools.ietf.org/html/rfc5652#section-10.2.1"> 1882 * RFC 5652 CMS section 10.2.1</a>. 1883 * <pre> 1884 * RevocationInfoChoice ::= CHOICE { 1885 * crl CertificateList, 1886 * other [1] IMPLICIT OtherRevocationInfoFormat } 1887 * OtherRevocationInfoFormat ::= SEQUENCE { 1888 * otherRevInfoFormat OBJECT IDENTIFIER, 1889 * otherRevInfo ANY DEFINED BY otherRevInfoFormat } 1890 * </pre> 1891 * 1892 * @example 1893 * new KJUR.asn1.cms.RevocationInfoChoice({ 1894 * crl: CRLPEMorHex 1895 * }) 1896 * new KJUR.asn1.cms.RevocationInfoChoice({ 1897 * ocsp: OCSPResponseHex 1898 * }) 1899 */ 1900 KJUR.asn1.cms.RevocationInfoChoice = function(params) { 1901 KJUR.asn1.cms.RevocationInfoChoice.superclass.constructor.call(this); 1902 1903 this.params = null; 1904 1905 this.tohex = function() { 1906 var params = this.params; 1907 1908 if (params.crl != undefined && typeof params.crl == "string") { 1909 var hCRL = params.crl; 1910 if (params.crl.indexOf("-----BEGIN") != -1) { 1911 hCRL = pemtohex(params.crl); 1912 } 1913 return hCRL; 1914 } else if (params.ocsp != undefined) { 1915 var dTag1 = KJUR.asn1.ASN1Util.newObject({tag: { 1916 tagi: "a1", 1917 obj: new KJUR.asn1.cms.OtherRevocationFormat(params) 1918 }}); 1919 return dTag1.tohex(); 1920 } else { 1921 throw new Error("property crl or ocsp undefined"); 1922 } 1923 }; 1924 this.getEncodedHex = function() { return this.tohex(); }; 1925 1926 if (params != undefined) this.setByParam(params); 1927 }; 1928 extendClass(KJUR.asn1.cms.RevocationInfoChoice, KJUR.asn1.ASN1Object); 1929 1930 /** 1931 * class for OtherRevocationFormat ASN.1 structure for CMS SignedData<br/> 1932 * @name KJUR.asn1.cms.OtherRevocationFormat 1933 * @class class for OtherRevocationFormat ASN.1 structure for CMS SignedData 1934 * @param {Array} params array of parameters 1935 * @extends KJUR.asn1.ASN1Object 1936 * @since jsrsasign 10.0.0 asn1cms 2.0.0 1937 * @see KJUR.asn1.cms.SignedData 1938 * @see KJUR.asn1.cms.RevocationInfoChoices 1939 * @see KJUR.asn1.cms.RevocationInfoChoice 1940 * 1941 * @description 1942 * This is an ASN.1 encoder for OtherRevocationFormat 1943 * ASN.1 structure defined in 1944 * <a href="https://tools.ietf.org/html/rfc5940"> 1945 * RFC 5652</a>. 1946 * <pre> 1947 * OtherRevocationInfoFormat ::= SEQUENCE { 1948 * otherRevInfoFormat OBJECT IDENTIFIER, 1949 * otherRevInfo ANY DEFINED BY otherRevInfoFormat } 1950 * id-ri OBJECT IDENTIFIER ::= { iso(1) identified-organization(3) 1951 * dod(6) internet(1) security(5) mechanisms(5) pkix(7) ri(16) } 1952 * id-ri-ocsp-response OBJECT IDENTIFIER ::= { id-ri 2 } 1953 * -- id-ri-ocsp-response 1.3.6.1.5.5.7.16.2 1954 * </pre> 1955 * NOTE: Currently this class only supports "ocsp" 1956 * 1957 * @example 1958 * new KJUR.asn1.cms.OtherRevocationFormat({ 1959 * ocsp: OCSPResponseHex 1960 * }) 1961 */ 1962 KJUR.asn1.cms.OtherRevocationFormat = function(params) { 1963 KJUR.asn1.cms.OtherRevocationFormat.superclass.constructor.call(this); 1964 1965 var _Error = Error, 1966 _KJUR = KJUR, 1967 _KJUR_asn1 = _KJUR.asn1, 1968 _newObject = _KJUR_asn1.ASN1Util.newObject, 1969 _isHex = _KJUR.lang.String.isHex; 1970 1971 this.params = null; 1972 1973 this.tohex = function() { 1974 var params = this.params; 1975 if (params.ocsp == undefined) 1976 throw new _Error("property ocsp not specified"); 1977 if (! _isHex(params.ocsp) || 1978 ! ASN1HEX.isASN1HEX(params.ocsp)) 1979 throw new _Error("ocsp value not ASN.1 hex string"); 1980 1981 var dOtherRev = _newObject({ 1982 seq: [ 1983 {oid: "1.3.6.1.5.5.7.16.2"}, 1984 {asn1: {tlv: params.ocsp}} 1985 ] 1986 }); 1987 return dOtherRev.tohex(); 1988 }; 1989 this.getEncodedHex = function() { return this.tohex(); }; 1990 1991 if (params != undefined) this.setByParam(params); 1992 }; 1993 extendClass(KJUR.asn1.cms.OtherRevocationFormat, KJUR.asn1.ASN1Object); 1994 1995 /** 1996 * CMS utiliteis class 1997 * @name KJUR.asn1.cms.CMSUtil 1998 * @class CMS utilities class 1999 */ 2000 KJUR.asn1.cms.CMSUtil = new function() { 2001 }; 2002 2003 /** 2004 * generate SignedData object specified by JSON parameters (DEPRECATED)<br/> 2005 * @name newSignedData 2006 * @memberOf KJUR.asn1.cms.CMSUtil 2007 * @function 2008 * @param {Array} params JSON parameter to generate CMS SignedData 2009 * @return {KJUR.asn1.cms.SignedData} object just generated 2010 * @deprecated since jsrsasign 10.0.0 asn1cms 2.0.0. 2011 * 2012 * @description 2013 * This class generates {@link KJUR.asn1.cms.SignedData} object. 2014 * However this class is deprecated. 2015 * Please use {@link KJUR.asn1.cms.SignedData} class constructor 2016 * instead. As for "params" parameter, 2017 * {@link KJUR.asn1.cms.SignedData} parameters are available. 2018 */ 2019 KJUR.asn1.cms.CMSUtil.newSignedData = function(param) { 2020 return new KJUR.asn1.cms.SignedData(param); 2021 }; 2022 2023 /** 2024 * verify SignedData specified by JSON parameters 2025 * @name verifySignedData 2026 * @memberOf KJUR.asn1.cms.CMSUtil 2027 * @function 2028 * @param {Array} param JSON parameter to verify CMS SignedData 2029 * @return {Object} JSON data as the result of validation 2030 * @since jsrsasign 8.0.4 asn1cms 1.0.5 2031 * @description 2032 * This method provides validation for CMS SignedData. 2033 * Following parameters can be applied: 2034 * <ul> 2035 * <li>cms - hexadecimal data of DER CMS SignedData (aka. PKCS#7 or p7s)</li> 2036 * to verify (OPTION)</li> 2037 * </ul> 2038 * 2039 * If signerInfos is empty, "isValid" value of result will be false. 2040 * 2041 * @example 2042 * KJUR.asn1.cms.CMSUtil.verifySignedData({ cms: "3082058a..." }) 2043 * → 2044 * { 2045 * isValid: true, 2046 * parse: ... // parsed data 2047 * signerInfos: [ 2048 * { 2049 * } 2050 * ] 2051 * } 2052 */ 2053 KJUR.asn1.cms.CMSUtil.verifySignedData = function(param) { 2054 var _KJUR = KJUR, 2055 _KJUR_asn1 = _KJUR.asn1, 2056 _KJUR_asn1_cms = _KJUR_asn1.cms, 2057 _SignerInfo = _KJUR_asn1_cms.SignerInfo, 2058 _SignedData = _KJUR_asn1_cms.SignedData, 2059 _SigningTime = _KJUR_asn1_cms.SigningTime, 2060 _SigningCertificate = _KJUR_asn1_cms.SigningCertificate, 2061 _SigningCertificateV2 = _KJUR_asn1_cms.SigningCertificateV2, 2062 _KJUR_asn1_cades = _KJUR_asn1.cades, 2063 _SignaturePolicyIdentifier = _KJUR_asn1_cades.SignaturePolicyIdentifier, 2064 _isHex = _KJUR.lang.String.isHex, 2065 _ASN1HEX = ASN1HEX, 2066 _getVbyList = _ASN1HEX.getVbyList, 2067 _getTLVbyList = _ASN1HEX.getTLVbyList, 2068 _getIdxbyList = _ASN1HEX.getIdxbyList, 2069 _getChildIdx = _ASN1HEX.getChildIdx, 2070 _getTLV = _ASN1HEX.getTLV, 2071 _oidname = _ASN1HEX.oidname, 2072 _hashHex = _KJUR.crypto.Util.hashHex; 2073 2074 if (param.cms === undefined && 2075 ! _isHex(param.cms)) { 2076 } 2077 2078 var hCMS = param.cms; 2079 2080 var _findSignerInfos = function(hCMS, result) { 2081 var idx; 2082 for (var i = 3; i < 6; i++) { 2083 idx = _getIdxbyList(hCMS, 0, [1, 0, i]); 2084 if (idx !== undefined) { 2085 var tag = hCMS.substr(idx, 2); 2086 if (tag === "a0") result.certsIdx = idx; 2087 if (tag === "a1") result.revinfosIdx = idx; 2088 if (tag === "31") result.signerinfosIdx = idx; 2089 } 2090 } 2091 }; 2092 2093 var _parseSignerInfos = function(hCMS, result) { 2094 var idxSignerInfos = result.signerinfosIdx; 2095 if (idxSignerInfos === undefined) return; 2096 var idxList = _getChildIdx(hCMS, idxSignerInfos); 2097 result.signerInfoIdxList = idxList; 2098 for (var i = 0; i < idxList.length; i++) { 2099 var idxSI = idxList[i]; 2100 var info = { idx: idxSI }; 2101 _parseSignerInfo(hCMS, info); 2102 result.signerInfos.push(info); 2103 }; 2104 }; 2105 2106 var _parseSignerInfo = function(hCMS, info) { 2107 var idx = info.idx; 2108 2109 // 1. signer identifier 2110 info.signerid_issuer1 = _getTLVbyList(hCMS, idx, [1, 0], "30"); 2111 info.signerid_serial1 = _getVbyList(hCMS, idx, [1, 1], "02"); 2112 2113 // 2. hash alg 2114 info.hashalg = _oidname(_getVbyList(hCMS, idx, [2, 0], "06")); 2115 2116 // 3. [0] singedAtttrs 2117 var idxSignedAttrs = _getIdxbyList(hCMS, idx, [3], "a0"); 2118 info.idxSignedAttrs = idxSignedAttrs; 2119 _parseSignedAttrs(hCMS, info, idxSignedAttrs); 2120 2121 var aIdx = _getChildIdx(hCMS, idx); 2122 var n = aIdx.length; 2123 if (n < 6) throw "malformed SignerInfo"; 2124 2125 info.sigalg = _oidname(_getVbyList(hCMS, idx, [n - 2, 0], "06")); 2126 info.sigval = _getVbyList(hCMS, idx, [n - 1], "04"); 2127 //info.sigval = _getVbyList(hCMS, 0, [1, 0, 4, 0, 5], "04"); 2128 //info.sigval = hCMS; 2129 }; 2130 2131 var _parseSignedAttrs = function(hCMS, info, idx) { 2132 var aIdx = _getChildIdx(hCMS, idx); 2133 info.signedAttrIdxList = aIdx; 2134 for (var i = 0; i < aIdx.length; i++) { 2135 var idxAttr = aIdx[i]; 2136 var hAttrType = _getVbyList(hCMS, idxAttr, [0], "06"); 2137 var v; 2138 2139 if (hAttrType === "2a864886f70d010905") { // siging time 2140 v = hextoutf8(_getVbyList(hCMS, idxAttr, [1, 0])); 2141 info.saSigningTime = v; 2142 } else if (hAttrType === "2a864886f70d010904") { // message digest 2143 v = _getVbyList(hCMS, idxAttr, [1, 0], "04"); 2144 info.saMessageDigest = v; 2145 } 2146 } 2147 }; 2148 2149 var _parseSignedData = function(hCMS, result) { 2150 // check if signedData (1.2.840.113549.1.7.2) type 2151 if (_getVbyList(hCMS, 0, [0], "06") !== "2a864886f70d010702") { 2152 return result; 2153 } 2154 result.cmsType = "signedData"; 2155 2156 // find eContent data 2157 result.econtent = _getVbyList(hCMS, 0, [1, 0, 2, 1, 0]); 2158 2159 // find certificates,revInfos,signerInfos index 2160 _findSignerInfos(hCMS, result); 2161 2162 result.signerInfos = []; 2163 _parseSignerInfos(hCMS, result); 2164 }; 2165 2166 var _verify = function(hCMS, result) { 2167 var aSI = result.parse.signerInfos; 2168 var n = aSI.length; 2169 if (n > 0) { 2170 var isValid = true; 2171 for (var i = 0; i < n; i++) { 2172 var si = aSI[i]; 2173 _verifySignerInfo(hCMS, result, si, i); 2174 if (! si.isValid) 2175 isValid = false; 2176 } 2177 result.isValid = isValid; 2178 } else { 2179 result.isValid = false; 2180 } 2181 }; 2182 2183 /* 2184 * _findCert 2185 * 2186 * @param hCMS {String} hexadecimal string of CMS signed data 2187 * @param result {Object} JSON object of validation result 2188 * @param si {Object} JSON object of signerInfo in the result above 2189 * @param idx {Number} index of signerInfo??? 2190 */ 2191 var _findCert = function(hCMS, result, si, idx) { 2192 var certsIdx = result.parse.certsIdx; 2193 var aCert; 2194 2195 if (result.certs === undefined) { 2196 aCert = []; 2197 result.certkeys = []; 2198 var aIdx = _getChildIdx(hCMS, certsIdx); 2199 for (var i = 0; i < aIdx.length; i++) { 2200 var hCert = _getTLV(hCMS, aIdx[i]); 2201 var x = new X509(); 2202 x.readCertHex(hCert); 2203 aCert[i] = x; 2204 result.certkeys[i] = x.getPublicKey(); 2205 } 2206 result.certs = aCert; 2207 } else { 2208 aCert = result.certs; 2209 } 2210 2211 result.cccc = aCert.length; 2212 result.cccci = aIdx.length; 2213 2214 for (var i = 0; i < aCert.length; i++) { 2215 var issuer2 = x.getIssuerHex(); 2216 var serial2 = x.getSerialNumberHex(); 2217 if (si.signerid_issuer1 === issuer2 && 2218 si.signerid_serial1 === serial2) { 2219 si.certkey_idx = i; 2220 } 2221 } 2222 }; 2223 2224 var _verifySignerInfo = function(hCMS, result, si, idx) { 2225 si.verifyDetail = {}; 2226 2227 var _detail = si.verifyDetail; 2228 2229 var econtent = result.parse.econtent; 2230 2231 // verify MessageDigest signed attribute 2232 var hashalg = si.hashalg; 2233 var saMessageDigest = si.saMessageDigest; 2234 2235 // verify messageDigest 2236 _detail.validMessageDigest = false; 2237 //_detail._econtent = econtent; 2238 //_detail._hashalg = hashalg; 2239 //_detail._saMD = saMessageDigest; 2240 if (_hashHex(econtent, hashalg) === saMessageDigest) 2241 _detail.validMessageDigest = true; 2242 2243 // find signing certificate 2244 _findCert(hCMS, result, si, idx); 2245 //if (si.signerid_cert === undefined) 2246 // throw Error("can't find signer certificate"); 2247 2248 // verify signature value 2249 _detail.validSignatureValue = false; 2250 var sigalg = si.sigalg; 2251 var hSignedAttr = "31" + _getTLV(hCMS, si.idxSignedAttrs).substr(2); 2252 si.signedattrshex = hSignedAttr; 2253 var pubkey = result.certs[si.certkey_idx].getPublicKey(); 2254 var sig = new KJUR.crypto.Signature({alg: sigalg}); 2255 sig.init(pubkey); 2256 sig.updateHex(hSignedAttr); 2257 var isValid = sig.verify(si.sigval); 2258 _detail.validSignatureValue_isValid = isValid; 2259 if (isValid === true) 2260 _detail.validSignatureValue = true; 2261 2262 // verify SignerInfo totally 2263 si.isValid =false; 2264 if (_detail.validMessageDigest && 2265 _detail.validSignatureValue) { 2266 si.isValid = true; 2267 } 2268 }; 2269 2270 var _findSignerCert = function() { 2271 }; 2272 2273 var result = { isValid: false, parse: {} }; 2274 _parseSignedData(hCMS, result.parse); 2275 2276 _verify(hCMS, result); 2277 2278 return result; 2279 }; 2280 2281 /** 2282 * class for parsing CMS SignedData<br/> 2283 * @name KJUR.asn1.cms.CMSParser 2284 * @class CMS SignedData parser class 2285 * @since jsrsasign 10.1.0 asn1cms 2.0.1 2286 * 2287 * @description 2288 * This is an ASN.1 parser for CMS SignedData defined in 2289 * <a href="https://tools.ietf.org/html/rfc5652">RFC 5652 2290 * Cryptographic Message Syntax (CMS)</a>. 2291 * <pre> 2292 * ContentInfo ::= SEQUENCE { 2293 * contentType ContentType, 2294 * content [0] EXPLICIT ANY DEFINED BY contentType } 2295 * ContentType ::= OBJECT IDENTIFIER 2296 * SignedData ::= SEQUENCE { 2297 * version CMSVersion, 2298 * digestAlgorithms DigestAlgorithmIdentifiers, 2299 * encapContentInfo EncapsulatedContentInfo, 2300 * certificates [0] IMPLICIT CertificateSet OPTIONAL, 2301 * crls [1] IMPLICIT RevocationInfoChoices OPTIONAL, 2302 * signerInfos SignerInfos } 2303 * SignerInfos ::= SET OF SignerInfo 2304 * CertificateSet ::= SET OF CertificateChoices 2305 * DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier 2306 * CertificateSet ::= SET OF CertificateChoices 2307 * RevocationInfoChoices ::= SET OF RevocationInfoChoice 2308 * </pre> 2309 */ 2310 KJUR.asn1.cms.CMSParser = function() { 2311 var _Error = Error, 2312 _X509 = X509, 2313 _x509obj = new _X509(), 2314 _ASN1HEX = ASN1HEX, 2315 _getV = _ASN1HEX.getV, 2316 _getTLV = _ASN1HEX.getTLV, 2317 _getIdxbyList = _ASN1HEX.getIdxbyList, 2318 _getTLVbyList = _ASN1HEX.getTLVbyList, 2319 _getTLVbyListEx = _ASN1HEX.getTLVbyListEx, 2320 _getVbyList = _ASN1HEX.getVbyList, 2321 _getVbyListEx = _ASN1HEX.getVbyListEx, 2322 _getChildIdx = _ASN1HEX.getChildIdx; 2323 2324 /** 2325 * parse ASN.1 ContentInfo with SignedData<br/> 2326 * @name getCMSSignedData 2327 * @memberOf KJUR.asn1.cms.CMSParser# 2328 * @function 2329 * @param {String} h hexadecimal string of ASN.1 ContentInfo with SignedData 2330 * @return {Array} array of JSON object of SignedData parameter 2331 * @see KJUR.asn1.cms.SignedData 2332 * @see KJUR.asn1.cms.CMSParser#getSignedData 2333 * 2334 * @description 2335 * This method parses ASN.1 ContentInfo with SignedData defined in 2336 * RFC 5652 2337 * <a href="https://tools.ietf.org/html/rfc5652#section-3">section 3</a> 2338 * and 2339 * <a href="https://tools.ietf.org/html/rfc5652#section-5">section 5</a>. 2340 * The result parameter can be passed to 2341 * {@link KJUR.asn1.cms.SignedData} constructor. 2342 * 2343 * @example 2344 * parser = new KJUR.asn1.cms.CMSParser(); 2345 * parser.getCMSSignedData("30...") → 2346 * { 2347 * version: 1, 2348 * hashalgs: ["sha1"], 2349 * econtent: { 2350 * type: "data", 2351 * content: {hex:"616161"} 2352 * }, 2353 * certs: [PEM1,...], 2354 * sinfos: [{ 2355 * version: 1, 2356 * id: {type:'isssn',issuer:{str:'/C=US/O=T1'},serial:{int: 1}}, 2357 * hashalg: "sha1", 2358 * sattrs: {array: [{ 2359 * attr: "contentType", 2360 * type: '1.2.840.113549.1.7.1' 2361 * },{ 2362 * attr: "messageDigest", 2363 * hex: 'abcd' 2364 * }]}, 2365 * sigalg: "SHA1withRSA", 2366 * sighex: "1234abcd..." 2367 * }] 2368 * } 2369 */ 2370 this.getCMSSignedData = function(h) { 2371 var hSignedData = _getTLVbyList(h, 0, [1, 0]); 2372 var pResult = this.getSignedData(hSignedData); 2373 return pResult; 2374 }; 2375 2376 /** 2377 * parse ASN.1 SignedData<br/> 2378 * @name getSignedData 2379 * @memberOf KJUR.asn1.cms.CMSParser# 2380 * @function 2381 * @param {String} h hexadecimal string of ASN.1 SignedData 2382 * @return {Array} array of JSON object of SignedData parameter 2383 * @see KJUR.asn1.cms.SignedData 2384 * @see KJUR.asn1.cms.CMSParser#getSignedData 2385 * 2386 * @description 2387 * This method parses ASN.1 SignedData defined in 2388 * RFC 5652 2389 * <a href="https://tools.ietf.org/html/rfc5652#section-5">section 5</a>. 2390 * The result parameter can be passed to 2391 * {@link KJUR.asn1.cms.SignedData} constructor. 2392 * 2393 * @example 2394 * parser = new KJUR.asn1.cms.CMSParser(); 2395 * parser.getSignedData("30...") 2396 */ 2397 this.getSignedData = function(h) { 2398 var aIdx = _getChildIdx(h, 0); 2399 var pResult = {}; 2400 2401 var hVersion = _getV(h, aIdx[0]); 2402 var iVersion = parseInt(hVersion, 16); 2403 pResult.version = iVersion; 2404 2405 var hHashAlgs = _getTLV(h, aIdx[1]); 2406 pResult.hashalgs = this.getHashAlgArray(hHashAlgs); 2407 2408 var hEContent = _getTLV(h, aIdx[2]); 2409 pResult.econtent = this.getEContent(hEContent); 2410 2411 var hCerts = _getTLVbyListEx(h, 0, ["[0]"]); 2412 if (hCerts != null) { 2413 pResult.certs = this.getCertificateSet(hCerts); 2414 } 2415 2416 // RevocationInfoChoices not supported yet 2417 var hRevInfos = _getTLVbyListEx(h, 0, ["[1]"]); 2418 if (hRevInfos != null) { 2419 } 2420 2421 var hSignerInfos = _getTLVbyListEx(h, 0, [3]); 2422 pResult.sinfos = this.getSignerInfos(hSignerInfos); 2423 2424 return pResult; 2425 }; 2426 2427 /** 2428 * parse ASN.1 DigestAlgorithmIdentifiers<br/> 2429 * @name getHashAlgArray 2430 * @memberOf KJUR.asn1.cms.CMSParser# 2431 * @function 2432 * @param {String} h hexadecimal string of ASN.1 DigestAlgorithmIdentifiers 2433 * @return {Array} array of JSON object of digest algorithm names 2434 * @see KJUR.asn1.cms.SignedData 2435 * @see KJUR.asn1.cms.CMSParser#getSignedData 2436 * 2437 * @description 2438 * This method parses ASN.1 SignedData defined in 2439 * RFC 5652 2440 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2441 * section 5.1</a>. 2442 * 2443 * @example 2444 * parser = new KJUR.asn1.cms.CMSParser(); 2445 * parser.getHashAlgArray("30...") → ["sha256"] 2446 */ 2447 this.getHashAlgArray = function(h) { 2448 var aIdx = _getChildIdx(h, 0); 2449 var x = new _X509(); 2450 var a = []; 2451 for (var i = 0; i < aIdx.length; i++) { 2452 var hAlg = _getTLV(h, aIdx[i]); 2453 var sAlg = x.getAlgorithmIdentifierName(hAlg); 2454 a.push(sAlg); 2455 } 2456 return a; 2457 }; 2458 2459 /** 2460 * parse ASN.1 EncapsulatedContentInfo<br/> 2461 * @name getEContent 2462 * @memberOf KJUR.asn1.cms.CMSParser# 2463 * @function 2464 * @param {String} h hexadecimal string of ASN.1 EncapsulatedContentInfo 2465 * @return {Array} array of JSON object of EncapsulatedContentInfo parameter 2466 * @see KJUR.asn1.cms.EncapsulatedContentInfo 2467 * @see KJUR.asn1.cms.CMSParser#getSignedData 2468 * 2469 * @description 2470 * This method parses ASN.1 SignedData defined in 2471 * RFC 5652 2472 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2473 * section 5</a>. 2474 * The result parameter can be passed to 2475 * {@link KJUR.asn1.cms.EncapsulatedContentInfo} constructor. 2476 * 2477 * @example 2478 * parser = new KJUR.asn1.cms.CMSParser(); 2479 * parser.getEContent("30...") → 2480 * {type: "tstinfo", content: {hex: "30..."}} 2481 */ 2482 this.getEContent = function(h) { 2483 var pResult = {}; 2484 var hType = _getVbyList(h, 0, [0]); 2485 var hContent = _getVbyList(h, 0, [1, 0]); 2486 pResult.type = KJUR.asn1.x509.OID.oid2name(ASN1HEX.hextooidstr(hType)); 2487 pResult.content = {hex: hContent}; 2488 return pResult; 2489 }; 2490 2491 /** 2492 * parse ASN.1 SignerInfos<br/> 2493 * @name getSignerInfos 2494 * @memberOf KJUR.asn1.cms.CMSParser# 2495 * @function 2496 * @param {String} h hexadecimal string of ASN.1 SignerInfos 2497 * @return {Array} array of JSON object of SignerInfos parameter 2498 * @see KJUR.asn1.cms.SignerInfos 2499 * @see KJUR.asn1.cms.CMSParser#getSignedData 2500 * 2501 * @description 2502 * This method parses ASN.1 SignerInfos defined in 2503 * RFC 5652 2504 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2505 * section 5</a>. 2506 * 2507 * @example 2508 * parser = new KJUR.asn1.cms.CMSParser(); 2509 * parser.getSignerInfos("30...") → 2510 * [{ 2511 * version: 1, 2512 * id: {type: 'isssn', issuer: {str: '/C=US/O=T1'}, serial: {int: 1}}, 2513 * hashalg: "sha1", 2514 * sattrs: {array: [{ 2515 * attr: "contentType", 2516 * type: '1.2.840.113549.1.7.1' 2517 * },{ 2518 * attr: "messageDigest", 2519 * hex: 'a1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0' 2520 * }]}, 2521 * sigalg: "SHA1withRSA", 2522 * sighex: 'b1b2b...' 2523 * }] 2524 */ 2525 this.getSignerInfos = function(h) { 2526 var aResult = []; 2527 2528 var aIdx = _getChildIdx(h, 0); 2529 for (var i = 0; i < aIdx.length; i++) { 2530 var hSignerInfo = _getTLV(h, aIdx[i]); 2531 var pSignerInfo = this.getSignerInfo(hSignerInfo); 2532 aResult.push(pSignerInfo); 2533 } 2534 2535 return aResult; 2536 }; 2537 2538 /** 2539 * parse ASN.1 SignerInfo<br/> 2540 * @name getSignerInfo 2541 * @memberOf KJUR.asn1.cms.CMSParser# 2542 * @function 2543 * @param {String} h hexadecimal string of ASN.1 SignerInfo 2544 * @return {Array} array of JSON object of SignerInfo parameter 2545 * @see KJUR.asn1.cms.SignerInfo 2546 * @see KJUR.asn1.cms.CMSParser#getSignedData 2547 * 2548 * @description 2549 * This method parses ASN.1 SignerInfos defined in 2550 * RFC 5652 2551 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2552 * section 5</a>. 2553 * <pre> 2554 * SignerInfo ::= SEQUENCE { 2555 * version CMSVersion, 2556 * sid SignerIdentifier, 2557 * digestAlgorithm DigestAlgorithmIdentifier, 2558 * signedAttrs [0] IMPLICIT SignedAttributes OPTIONAL, 2559 * signatureAlgorithm SignatureAlgorithmIdentifier, 2560 * signature SignatureValue, 2561 * unsignedAttrs [1] IMPLICIT UnsignedAttributes OPTIONAL } 2562 * </pre> 2563 * The result parameter can be passed to 2564 * {@link KJUR.asn1.cms.SignerInfo} constructor. 2565 * 2566 * @example 2567 * parser = new KJUR.asn1.cms.CMSParser(); 2568 * parser.getSignerInfos("30...") → 2569 * [{ 2570 * version: 1, 2571 * id: {type: 'isssn', issuer: {str: '/C=US/O=T1'}, serial: {int: 1}}, 2572 * hashalg: "sha1", 2573 * sattrs: {array: [{ 2574 * attr: "contentType", 2575 * type: '1.2.840.113549.1.7.1' 2576 * },{ 2577 * attr: "messageDigest", 2578 * hex: 'a1a2a3a4a5a6a7a8a9a0a1a2a3a4a5a6a7a8a9a0' 2579 * }]}, 2580 * sigalg: "SHA1withRSA", 2581 * sighex: 'b1b2b...' 2582 * }] 2583 */ 2584 this.getSignerInfo = function(h) { 2585 var pResult = {}; 2586 var aIdx = _getChildIdx(h, 0); 2587 2588 var iVersion = _ASN1HEX.getInt(h, aIdx[0], -1); 2589 if (iVersion != -1) pResult.version = iVersion; 2590 2591 var hSI = _getTLV(h, aIdx[1]); 2592 var pSI = this.getIssuerAndSerialNumber(hSI); 2593 pResult.id = pSI; 2594 2595 var hAlg = _getTLV(h, aIdx[2]); 2596 //alert(hAlg); 2597 var sAlg = _x509obj.getAlgorithmIdentifierName(hAlg); 2598 pResult.hashalg = sAlg; 2599 2600 var hSattrs = _getTLVbyListEx(h, 0, ["[0]"]); 2601 if (hSattrs != null) { 2602 var aSattrs = this.getAttributeList(hSattrs); 2603 pResult.sattrs = aSattrs; 2604 } 2605 2606 var hSigAlg = _getTLVbyListEx(h, 0, [3]); 2607 var sSigAlg = _x509obj.getAlgorithmIdentifierName(hSigAlg); 2608 pResult.sigalg = sSigAlg; 2609 2610 var hSigHex = _getVbyListEx(h, 0, [4]); 2611 pResult.sighex = hSigHex; 2612 2613 var hUattrs = _getTLVbyListEx(h, 0, ["[1]"]); 2614 if (hUattrs != null) { 2615 var aUattrs = this.getAttributeList(hUattrs); 2616 pResult.uattrs = aUattrs; 2617 } 2618 2619 return pResult; 2620 }; 2621 2622 /** 2623 * parse ASN.1 SignerIdentifier<br/> 2624 * @name getSignerIdentifier 2625 * @memberOf KJUR.asn1.cms.CMSParser# 2626 * @function 2627 * @param {String} h hexadecimal string of ASN.1 SignerIdentifier 2628 * @return {Array} array of JSON object of SignerIdentifier parameter 2629 * @see KJUR.asn1.cms.SignerInfo 2630 * @see KJUR.asn1.cms.SignerIdentifier 2631 * @see KJUR.asn1.cms.CMSParser#getSignedData 2632 * 2633 * @description 2634 * This method parses ASN.1 SignerIdentifier defined in 2635 * RFC 5652 2636 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2637 * section 5</a>. 2638 * 2639 * @example 2640 * parser = new KJUR.asn1.cms.CMSParser(); 2641 * parser.getSignerIdentifier("30...") → 2642 * { type: "isssn", 2643 * issuer: { 2644 * array: [[{type:"C",value:"JP",ds:"prn"},...]] 2645 * str: '/C=US/O=T1' 2646 * }, 2647 * serial: {int: 1} } 2648 */ 2649 this.getSignerIdentifier = function(h) { 2650 if (h.substr(0, 2) == "30") { 2651 return this.getIssuerAndSerialNumber(h); 2652 } else { 2653 throw new Error("SKID of signerIdentifier not supported"); 2654 } 2655 }; 2656 2657 /** 2658 * parse ASN.1 IssuerAndSerialNumber<br/> 2659 * @name getIssuerAndSerialNumber 2660 * @memberOf KJUR.asn1.cms.CMSParser# 2661 * @function 2662 * @param {String} h hexadecimal string of ASN.1 IssuerAndSerialNumber 2663 * @return {Array} array of JSON object of IssuerAndSerialNumber parameter 2664 * @see KJUR.asn1.cms.SignerInfo 2665 * @see KJUR.asn1.cms.CMSParser#getSignedData 2666 * 2667 * @description 2668 * This method parses ASN.1 IssuerAndSerialNumber defined in 2669 * RFC 5652 2670 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2671 * section 5</a>. 2672 * 2673 * @example 2674 * parser = new KJUR.asn1.cms.CMSParser(); 2675 * parser.getIssuerAndSerialNumber("30...") → 2676 * { type: "isssn", 2677 * issuer: { 2678 * array: [[{type:"C",value:"JP",ds:"prn"},...]] 2679 * str: '/C=US/O=T1' 2680 * }, 2681 * serial: {int: 1} } 2682 */ 2683 this.getIssuerAndSerialNumber = function(h) { 2684 var pResult = {type: "isssn"}; 2685 2686 var aIdx = _getChildIdx(h, 0); 2687 2688 var hName = _getTLV(h, aIdx[0]); 2689 pResult.issuer = _x509obj.getX500Name(hName); 2690 2691 var hSerial = _getV(h, aIdx[1]); 2692 pResult.serial = {hex: hSerial}; 2693 2694 return pResult; 2695 }; 2696 2697 /** 2698 * parse ASN.1 SET OF Attributes<br/> 2699 * @name getAttributeList 2700 * @memberOf KJUR.asn1.cms.CMSParser# 2701 * @function 2702 * @param {String} h hexadecimal string of ASN.1 SET OF Attribute 2703 * @return {Array} array of JSON object of Attribute parameter 2704 * @see KJUR.asn1.cms.SignerInfo 2705 * @see KJUR.asn1.cms.CMSParser#getAttribute 2706 * 2707 * @description 2708 * This method parses ASN.1 SET OF Attribute defined in 2709 * RFC 5652 2710 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2711 * section 5</a>. 2712 * This can be used for SignedAttributes and UnsignedAttributes. 2713 * 2714 * @example 2715 * parser = new KJUR.asn1.cms.CMSParser(); 2716 * parser.getAttributeList("30...") → 2717 * [{attr: "contentType", type: "tstinfo"}, 2718 * {attr: "messageDigest", hex: "1234abcd..."}] 2719 */ 2720 this.getAttributeList = function(h) { 2721 var a = []; 2722 2723 var aIdx = _getChildIdx(h, 0); 2724 for (var i = 0; i < aIdx.length; i++) { 2725 var hAttr = _getTLV(h, aIdx[i]); 2726 var pAttr = this.getAttribute(hAttr); 2727 a.push(pAttr); 2728 } 2729 2730 return {array: a}; 2731 }; 2732 2733 /** 2734 * parse ASN.1 Attributes<br/> 2735 * @name getAttribute 2736 * @memberOf KJUR.asn1.cms.CMSParser# 2737 * @function 2738 * @param {String} h hexadecimal string of ASN.1 Attribute 2739 * @return {Array} array of JSON object of Attribute parameter 2740 * @see KJUR.asn1.cms.SignerInfo 2741 * @see KJUR.asn1.cms.CMSParser#getAttributeList 2742 * 2743 * @description 2744 * This method parses ASN.1 Attribute defined in 2745 * RFC 5652 2746 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2747 * section 5</a>. 2748 * Following attribute type are supported in the 2749 * latest version: 2750 * <ul> 2751 * <li>contentType - {@link KJUR.asn1.cms.CMSParser.setContentType}</li> 2752 * <li>messageDigest - {@link KJUR.asn1.cms.CMSParser.setMessageDigest}</li> 2753 * <li>signingTime - {@link KJUR.asn1.cms.CMSParser.setSigningTime}</li> 2754 * <li>signingCertificate - {@link KJUR.asn1.cms.CMSParser.setSigningCertificate}</li> 2755 * <li>signingCertificateV2 - {@link KJUR.asn1.cms.CMSParser.setSigningCertificateV2}</li> 2756 * </ul> 2757 * 2758 * @example 2759 * parser = new KJUR.asn1.cms.CMSParser(); 2760 * parser.getAttribute("30...") → 2761 * {attr: "contentType", type: "tstinfo"} 2762 */ 2763 this.getAttribute = function(h) { 2764 var pResult = {}; 2765 var aIdx = _getChildIdx(h, 0); 2766 2767 var attrTypeOID = _ASN1HEX.getOID(h, aIdx[0]); 2768 var attrType = KJUR.asn1.x509.OID.oid2name(attrTypeOID); 2769 pResult.attr = attrType; 2770 2771 var hSet = _getTLV(h, aIdx[1]); 2772 var aSetIdx = _getChildIdx(hSet, 0); 2773 if (aSetIdx.length == 1) { 2774 pResult.valhex = _getTLV(hSet, aSetIdx[0]); 2775 } else { 2776 var a = []; 2777 for (var i = 0; i < aSetIdx.length; i++) { 2778 a.push(_getTLV(hSet, aSetIdx[i])); 2779 } 2780 pResult.valhex = a; 2781 } 2782 2783 if (attrType == "contentType") { 2784 this.setContentType(pResult); 2785 } else if (attrType == "messageDigest") { 2786 this.setMessageDigest(pResult); 2787 } else if (attrType == "signingTime") { 2788 this.setSigningTime(pResult); 2789 } else if (attrType == "signingCertificate") { 2790 this.setSigningCertificate(pResult); 2791 } else if (attrType == "signingCertificateV2") { 2792 this.setSigningCertificateV2(pResult); 2793 } else if (attrType == "signaturePolicyIdentifier") { 2794 this.setSignaturePolicyIdentifier(pResult); 2795 } 2796 2797 return pResult; 2798 }; 2799 2800 /** 2801 * set ContentType attribute<br/> 2802 * @name setContentType 2803 * @memberOf KJUR.asn1.cms.CMSParser# 2804 * @function 2805 * @param {Array} pAttr JSON object of attribute parameter 2806 * @see KJUR.asn1.cms.CMSParser#getAttribute 2807 * 2808 * @description 2809 * This sets an attribute as ContentType defined in 2810 * RFC 5652 2811 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2812 * section 5</a>. 2813 * 2814 * @example 2815 * parser = new KJUR.asn1.cms.CMSParser(); 2816 * pAttr = { 2817 * attr: "contentType" 2818 * valhex: '060b2a864886f70d0109100104' 2819 * }; 2820 * parser.setContentInfo(pAttr); 2821 * pAttr → { 2822 * attr: "contentType" 2823 * type: "tstinfo" 2824 * } 2825 */ 2826 this.setContentType = function(pAttr) { 2827 var contentType = _ASN1HEX.getOIDName(pAttr.valhex, 0, null); 2828 if (contentType != null) { 2829 pAttr.type = contentType; 2830 delete pAttr.valhex; 2831 } 2832 }; 2833 2834 /** 2835 * set SigningTime attribute<br/> 2836 * @name setSigningTime 2837 * @memberOf KJUR.asn1.cms.CMSParser# 2838 * @function 2839 * @param {Array} pAttr JSON object of attribute parameter 2840 * @see KJUR.asn1.cms.CMSParser#getAttribute 2841 * 2842 * @description 2843 * This sets an attribute as SigningTime defined in 2844 * RFC 5652 2845 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2846 * section 5</a>. 2847 * 2848 * @example 2849 * parser = new KJUR.asn1.cms.CMSParser(); 2850 * pAttr = { 2851 * attr: "signingTime" 2852 * valhex: '170d3230313233313233353935395a' 2853 * }; 2854 * parser.setSigningTime(pAttr); 2855 * pAttr → { 2856 * attr: "signingTime", 2857 * str: "2012315959Z" 2858 * } 2859 */ 2860 this.setSigningTime = function(pAttr) { 2861 var hSigningTime = _getV(pAttr.valhex, 0); 2862 var signingTime = hextoutf8(hSigningTime); 2863 pAttr.str = signingTime; 2864 delete pAttr.valhex; 2865 }; 2866 2867 /** 2868 * set MessageDigest attribute<br/> 2869 * @name setMessageDigest 2870 * @memberOf KJUR.asn1.cms.CMSParser# 2871 * @function 2872 * @param {Array} pAttr JSON object of attribute parameter 2873 * @see KJUR.asn1.cms.CMSParser#getAttribute 2874 * 2875 * @description 2876 * This sets an attribute as SigningTime defined in 2877 * RFC 5652 2878 * <a href="https://tools.ietf.org/html/rfc5652#section-5.1"> 2879 * section 5</a>. 2880 * 2881 * @example 2882 * parser = new KJUR.asn1.cms.CMSParser(); 2883 * pAttr = { 2884 * attr: "messageDigest" 2885 * valhex: '0403123456' 2886 * }; 2887 * parser.setMessageDigest(pAttr); 2888 * pAttr → { 2889 * attr: "messageDigest", 2890 * hex: "123456" 2891 * } 2892 */ 2893 this.setMessageDigest = function(pAttr) { 2894 var hMD = _getV(pAttr.valhex, 0); 2895 pAttr.hex = hMD; 2896 delete pAttr.valhex; 2897 }; 2898 2899 /** 2900 * set SigningCertificate attribute<br/> 2901 * @name setSigningCertificate 2902 * @memberOf KJUR.asn1.cms.CMSParser# 2903 * @function 2904 * @param {Array} pAttr JSON object of attribute parameter 2905 * @see KJUR.asn1.cms.CMSParser#getAttribute 2906 * 2907 * @description 2908 * This sets an attribute as SigningCertificate defined in 2909 * <a href="https://tools.ietf.org/html/rfc5035#section-5"> 2910 * RFC 5035 section 5</a>. 2911 * 2912 * @example 2913 * parser = new KJUR.asn1.cms.CMSParser(); 2914 * pAttr = { 2915 * attr: "signingCertificate" 2916 * valhex: '...' 2917 * }; 2918 * parser.setSigningCertificate(pAttr); 2919 * pAttr → { 2920 * attr: "signingCertificate", 2921 * array: [{ 2922 * hash: "123456...", 2923 * issuer: { 2924 * array: [[{type:"C",value:"JP",ds:"prn"},...]], 2925 * str: "/C=JP/O=T1" 2926 * }, 2927 * serial: {hex: "123456..."} 2928 * }] 2929 * } 2930 */ 2931 this.setSigningCertificate = function(pAttr) { 2932 var aIdx = _getChildIdx(pAttr.valhex, 0); 2933 if (aIdx.length > 0) { 2934 var hCerts = _getTLV(pAttr.valhex, aIdx[0]); 2935 var aCertIdx = _getChildIdx(hCerts, 0); 2936 var a = []; 2937 for (var i = 0; i < aCertIdx.length; i++) { 2938 var hESSCertID = _getTLV(hCerts, aCertIdx[i]); 2939 var pESSCertID = this.getESSCertID(hESSCertID); 2940 a.push(pESSCertID); 2941 } 2942 pAttr.array = a; 2943 } 2944 2945 if (aIdx.length > 1) { 2946 var hPolicies = _getTLV(pAttr.valhex, aIdx[1]); 2947 pAttr.polhex = hPolicies; 2948 } 2949 delete pAttr.valhex; 2950 }; 2951 2952 /** 2953 * set SignaturePolicyIdentifier attribute<br/> 2954 * @name setSignaturePolicyIdentifier 2955 * @memberOf KJUR.asn1.cms.CMSParser# 2956 * @function 2957 * @param {Array} pAttr JSON object of attribute parameter 2958 * @since jsrsasign 10.1.5 asn1cms 2.0.4 2959 * @see KJUR.asn1.cms.CMSParser#getAttribute 2960 * @see KJUR.asn1.cades.SignaturePolicyIdentifier 2961 * 2962 * @description 2963 * This sets an attribute as SignaturePolicyIdentifier defined in 2964 * <a href="https://tools.ietf.org/html/rfc5126#section-5.8.1"> 2965 * RFC 5126 CAdES section 5.8.1</a>. 2966 * 2967 * @example 2968 * parser = new KJUR.asn1.cms.CMSParser(); 2969 * pAttr = { 2970 * attr: "signaturePolicyIdentifier" 2971 * valhex: '...' 2972 * }; 2973 * parser.setSignaturePolicyIdentifier(pAttr); 2974 * pAttr → { 2975 * attr: "signaturePolicyIdentifier", 2976 * oid: "1.2.3.4.5", 2977 * alg: "sha1", 2978 * hash: "1a2b..." 2979 * } 2980 */ 2981 this.setSignaturePolicyIdentifier = function(pAttr) { 2982 var aIdx = _getChildIdx(pAttr.valhex, 0); 2983 if (aIdx.length > 0) { 2984 var oid = _ASN1HEX.getOID(pAttr.valhex, aIdx[0]); 2985 pAttr.oid = oid; 2986 } 2987 if (aIdx.length > 1) { 2988 var x = new _X509(); 2989 var a2Idx = _getChildIdx(pAttr.valhex, aIdx[1]); 2990 var hAlg = _getTLV(pAttr.valhex, a2Idx[0]); 2991 var sAlg = x.getAlgorithmIdentifierName(hAlg); 2992 pAttr.alg = sAlg; 2993 2994 var hHash = _getV(pAttr.valhex, a2Idx[1]); 2995 pAttr.hash = hHash; 2996 } 2997 delete pAttr.valhex; 2998 }; 2999 3000 /** 3001 * set SigningCertificateV2 attribute<br/> 3002 * @name setSigningCertificateV2 3003 * @memberOf KJUR.asn1.cms.CMSParser# 3004 * @function 3005 * @param {Array} pAttr JSON object of attribute parameter 3006 * @since jsrsasign 10.1.2 asn1cms 2.0.3 3007 * @see KJUR.asn1.cms.CMSParser#getAttribute 3008 * @see KJUR.asn1.cms.CMSParser#getESSCertIDv2 3009 * @see KJUR.asn1.cms.SigningCertificateV2 3010 * @see KJUR.asn1.cms.ESSCertIDv2 3011 * 3012 * @description 3013 * This sets an attribute as SigningCertificateV2 defined in 3014 * <a href="https://tools.ietf.org/html/rfc5035#section-3"> 3015 * RFC 5035 section 3</a>. 3016 * 3017 * @example 3018 * parser = new KJUR.asn1.cms.CMSParser(); 3019 * pAttr = { 3020 * attr: "signingCertificateV2" 3021 * valhex: '...' 3022 * }; 3023 * parser.setSigningCertificateV2(pAttr); 3024 * pAttr → { 3025 * attr: "signingCertificateV2", 3026 * array: [{ 3027 * hash: "123456...", 3028 * alg: "sha256", 3029 * issuer: { 3030 * array: [[{type:"C",value:"JP",ds:"prn"},...]], 3031 * str: "/C=JP/O=T1" 3032 * }, 3033 * serial: {hex: "123456..."} 3034 * }] 3035 * } 3036 */ 3037 this.setSigningCertificateV2 = function(pAttr) { 3038 var aIdx = _getChildIdx(pAttr.valhex, 0); 3039 if (aIdx.length > 0) { 3040 var hCerts = _getTLV(pAttr.valhex, aIdx[0]); 3041 var aCertIdx = _getChildIdx(hCerts, 0); 3042 var a = []; 3043 for (var i = 0; i < aCertIdx.length; i++) { 3044 var hESSCertIDv2 = _getTLV(hCerts, aCertIdx[i]); 3045 var pESSCertIDv2 = this.getESSCertIDv2(hESSCertIDv2); 3046 a.push(pESSCertIDv2); 3047 } 3048 pAttr.array = a; 3049 } 3050 3051 if (aIdx.length > 1) { 3052 var hPolicies = _getTLV(pAttr.valhex, aIdx[1]); 3053 pAttr.polhex = hPolicies; 3054 } 3055 delete pAttr.valhex; 3056 }; 3057 3058 /** 3059 * parse ASN.1 ESSCertID<br/> 3060 * @name getESSCertID 3061 * @memberOf KJUR.asn1.cms.CMSParser# 3062 * @function 3063 * @param {String} h hexadecimal string of ASN.1 ESSCertID 3064 * @return {Array} array of JSON object of ESSCertID parameter 3065 * @see KJUR.asn1.cms.ESSCertID 3066 * 3067 * @description 3068 * This method parses ASN.1 ESSCertID defined in 3069 * <a href="https://tools.ietf.org/html/rfc5035#section-6"> 3070 * RFC 5035 section 6</a>. 3071 * <pre> 3072 * ESSCertID ::= SEQUENCE { 3073 * certHash Hash, 3074 * issuerSerial IssuerSerial OPTIONAL } 3075 * IssuerSerial ::= SEQUENCE { 3076 * issuer GeneralNames, 3077 * serialNumber CertificateSerialNumber } 3078 * </pre> 3079 * 3080 * @example 3081 * parser = new KJUR.asn1.cms.CMSParser(); 3082 * parser.getESSCertID("30...") → 3083 * { hash: "12ab...", 3084 * issuer: { 3085 * array: [[{type:"C",value:"JP",ds:"prn"}],...], 3086 * str: "/C=JP/O=T1" 3087 * }, 3088 * serial: {hex: "12ab..."} } 3089 */ 3090 this.getESSCertID = function(h) { 3091 var pResult = {}; 3092 var aIdx = _getChildIdx(h, 0); 3093 3094 if (aIdx.length > 0) { 3095 var hCertHash = _getV(h, aIdx[0]); 3096 pResult.hash = hCertHash; 3097 } 3098 3099 if (aIdx.length > 1) { 3100 var hIssuerSerial = _getTLV(h, aIdx[1]); 3101 var pIssuerSerial = 3102 this.getIssuerSerial(hIssuerSerial); 3103 3104 if (pIssuerSerial.serial != undefined) 3105 pResult.serial = pIssuerSerial.serial; 3106 3107 if (pIssuerSerial.issuer != undefined) 3108 pResult.issuer = pIssuerSerial.issuer; 3109 } 3110 3111 return pResult; 3112 }; 3113 3114 /** 3115 * parse ASN.1 ESSCertIDv2<br/> 3116 * @name getESSCertIDv2 3117 * @memberOf KJUR.asn1.cms.CMSParser# 3118 * @function 3119 * @param {String} h hexadecimal string of ASN.1 ESSCertIDv2 3120 * @return {Array} array of JSON object of ESSCertIDv2 parameter 3121 * @since jsrsasign 10.1.2 asn1cms 2.0.3 3122 * @see KJUR.asn1.cms.ESSCertIDv2 3123 * @see KJUR.asn1.cms.CMSParser.getESSCertID 3124 * 3125 * @description 3126 * This method parses ASN.1 ESSCertIDv2 defined in 3127 * <a href="https://tools.ietf.org/html/rfc5035#section-4"> 3128 * RFC 5035 section 4</a>. 3129 * <pre> 3130 * ESSCertIDv2 ::= SEQUENCE { 3131 * hashAlgorithm AlgorithmIdentifier 3132 * DEFAULT {algorithm id-sha256}, 3133 * certHash Hash, 3134 * issuerSerial IssuerSerial OPTIONAL } 3135 * Hash ::= OCTET STRING 3136 * IssuerSerial ::= SEQUENCE { 3137 * issuer GeneralNames, 3138 * serialNumber CertificateSerialNumber } 3139 * </pre> 3140 * 3141 * @example 3142 * parser = new KJUR.asn1.cms.CMSParser(); 3143 * parser.getESSCertID("30...") → 3144 * { 3145 * hash: "3f2d...", 3146 * alg: "sha512", 3147 * issuer: {str: "/C=JP/O=T1"}, 3148 * serial: {hex: "12ab..."} 3149 * } 3150 */ 3151 this.getESSCertIDv2 = function(h) { 3152 var aResult = {}; 3153 var aIdx = _getChildIdx(h, 0); 3154 3155 if (aIdx.length < 1 || 3 < aIdx.length) 3156 throw new _Error("wrong number of elements"); 3157 3158 var offset = 0; 3159 if (h.substr(aIdx[0], 2) == "30") { 3160 var hHashAlg = _getTLV(h, aIdx[0]); 3161 aResult.alg = 3162 _x509obj.getAlgorithmIdentifierName(hHashAlg); 3163 offset++; 3164 } else { 3165 aResult.alg = "sha256"; 3166 } 3167 3168 var hHash = _getV(h, aIdx[offset]); 3169 aResult.hash = hHash; 3170 3171 if (aIdx.length > offset + 1) { 3172 var hIssuerSerial = _getTLV(h, aIdx[offset + 1]); 3173 var pIssuerSerial = 3174 this.getIssuerSerial(hIssuerSerial); 3175 aResult.issuer = pIssuerSerial.issuer; 3176 aResult.serial = pIssuerSerial.serial; 3177 } 3178 3179 return aResult; 3180 }; 3181 3182 /** 3183 * parse ASN.1 IssuerSerial<br/> 3184 * @name getIssuerSerial 3185 * @memberOf KJUR.asn1.cms.CMSParser# 3186 * @function 3187 * @param {String} h hexadecimal string of ASN.1 IssuerSerial 3188 * @return {Array} array of JSON object of IssuerSerial parameter 3189 * @see KJUR.asn1.cms.IssuerSerial 3190 * @see KJUR.asn1.x509.X500Name 3191 * 3192 * @description 3193 * This method parses ASN.1 IssuerSerial defined in 3194 * <a href="https://tools.ietf.org/html/rfc5035#section-6"> 3195 * RFC 5035 section 6</a>. 3196 * <pre> 3197 * IssuerSerial ::= SEQUENCE { 3198 * issuer GeneralNames, 3199 * serialNumber CertificateSerialNumber } 3200 * </pre> 3201 * 3202 * @example 3203 * parser = new KJUR.asn1.cms.CMSParser(); 3204 * parser.getIssuerSerial("30...") → 3205 * { issuer: { 3206 * array: [[{type:"C",value:"JP",ds:"prn"}],...], 3207 * str: "/C=JP/O=T1", 3208 * }, 3209 * serial: {hex: "12ab..."} } 3210 */ 3211 this.getIssuerSerial = function(h) { 3212 var pResult = {}; 3213 var aIdx = _getChildIdx(h, 0); 3214 3215 var hIssuer = _getTLV(h, aIdx[0]); 3216 var pIssuerGN = _x509obj.getGeneralNames(hIssuer); 3217 var pIssuerName = pIssuerGN[0].dn; 3218 pResult.issuer = pIssuerName; 3219 3220 var hSerial = _getV(h, aIdx[1]); 3221 pResult.serial = {hex: hSerial}; 3222 3223 return pResult; 3224 }; 3225 3226 /** 3227 * parse ASN.1 CertificateSet<br/> 3228 * @name getCertificateSet 3229 * @memberOf KJUR.asn1.cms.CMSParser# 3230 * @function 3231 * @param {String} h hexadecimal string of ASN.1 CertificateSet 3232 * @return {Array} array of JSON object of CertificateSet parameter 3233 * @see KJUR.asn1.cms.CertificateSet 3234 * 3235 * @description 3236 * This method parses ASN.1 IssuerSerial defined in 3237 * <a href="https://tools.ietf.org/html/rfc5652#section-10.2.3"> 3238 * RFC 5652 CMS section 10.2.3</a> and 3239 * <a href="https://tools.ietf.org/html/rfc5652#section-10.2.2"> 3240 * section 10.2.2</a>. 3241 * <pre> 3242 * CertificateSet ::= SET OF CertificateChoices 3243 * CertificateChoices ::= CHOICE { 3244 * certificate Certificate, 3245 * extendedCertificate [0] IMPLICIT ExtendedCertificate, -- Obsolete 3246 * v1AttrCert [1] IMPLICIT AttributeCertificateV1, -- Obsolete 3247 * v2AttrCert [2] IMPLICIT AttributeCertificateV2, 3248 * other [3] IMPLICIT OtherCertificateFormat } 3249 * OtherCertificateFormat ::= SEQUENCE { 3250 * otherCertFormat OBJECT IDENTIFIER, 3251 * otherCert ANY DEFINED BY otherCertFormat } 3252 * </pre> 3253 * Currently only "certificate" is supported in 3254 * CertificateChoices. 3255 * 3256 * @example 3257 * parser = new KJUR.asn1.cms.CMSParser(); 3258 * parser.getCertificateSet("a0...") → 3259 * [ "-----BEGIN CERTIFICATE...", ... ] 3260 */ 3261 this.getCertificateSet = function(h) { 3262 var aIdx = _getChildIdx(h, 0); 3263 var a = []; 3264 for (var i = 0; i < aIdx.length; i++) { 3265 var hCert = _getTLV(h, aIdx[i]); 3266 if (hCert.substr(0, 2) == "30") { 3267 var pem = hextopem(hCert, "CERTIFICATE"); 3268 a.push(pem); 3269 } 3270 } 3271 return {array: a, sortflag: false}; 3272 }; 3273 }; 3274