@peculiar/certificates-viewer 3.0.4 → 3.2.0

package/dist/cjs/x509_attribute_certificate-cc325b70.js

@@ -0,0 +1,87 @@
+/*!
+ * © Peculiar Ventures https://peculiarventures.com/ - MIT License
+ */
+'use strict';
+
+const certification_request = require('./certification_request-cde57123.js');
+const index = require('./index-ff818d4d.js');
+const l10n = require('./l10n-a048a686.js');
+const csr = require('./csr-78378ed0.js');
+
+/**
+ * @license
+ * Copyright (c) Peculiar Ventures, LLC.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+class X509AttributeCertificate extends certification_request.AsnData {
+  constructor(raw) {
+    var _a;
+    super(certification_request.certificateRawToBuffer(raw), certification_request.AttributeCertificate);
+    this.thumbprints = {};
+    this.type = 'X.509 Attribute Certificate';
+    const { acinfo } = this.asn;
+    this.serialNumber = index.build.Convert.ToHex(acinfo.serialNumber);
+    this.version = acinfo.version;
+    const notBefore = acinfo.attrCertValidityPeriod.notBeforeTime;
+    if (!notBefore) {
+      throw new Error("Cannot get 'notBefore' value");
+    }
+    this.notBefore = notBefore;
+    const notAfter = acinfo.attrCertValidityPeriod.notAfterTime;
+    if (!notAfter) {
+      throw new Error("Cannot get 'notAfter' value");
+    }
+    this.notAfter = notAfter;
+    this.validity = l10n.dateDiff(this.notBefore, this.notAfter);
+    this.issuer = acinfo.issuer.v1Form || ((_a = acinfo.issuer.v2Form) === null || _a === void 0 ? void 0 : _a.issuerName);
+    this.holder = acinfo.holder;
+  }
+  get signature() {
+    const { signatureValue, signatureAlgorithm } = this.asn;
+    return {
+      value: signatureValue,
+      algorithm: signatureAlgorithm.algorithm,
+    };
+  }
+  parseExtensions() {
+    const { acinfo } = this.asn;
+    if (acinfo.extensions) {
+      this.extensions = acinfo.extensions
+        .map((e) => new certification_request.Extension(certification_request.AsnConvert.serialize(e)));
+    }
+  }
+  parseAttributes() {
+    const { acinfo } = this.asn;
+    if (acinfo.attributes) {
+      this.attributes = acinfo.attributes
+        .map((e) => new csr.Attribute(certification_request.AsnConvert.serialize(e)));
+    }
+  }
+  async getThumbprint(algorithm = 'SHA-1') {
+    try {
+      const thumbprint = await certification_request.getCertificateThumbprint(algorithm, this.raw);
+      if (thumbprint) {
+        this.thumbprints[algorithm['name'] || algorithm] = index.build.Convert.ToHex(thumbprint);
+      }
+    }
+    catch (error) {
+      console.error('Error thumbprint get:', error);
+    }
+  }
+  exportAsBase64() {
+    return index.build.Convert.ToBase64(this.raw);
+  }
+  exportAsHexFormatted() {
+    return certification_request.hexFormat(index.build.Convert.ToHex(this.raw));
+  }
+  exportAsPemFormatted() {
+    return `-----BEGIN ATTRIBUTE CERTIFICATE-----\n${certification_request.base64Format(this.exportAsBase64())}\n-----END ATTRIBUTE CERTIFICATE-----`;
+  }
+  get commonName() {
+    return `attribute-certificate-${this.thumbprints['SHA-1']}`;
+  }
+}
+
+exports.X509AttributeCertificate = X509AttributeCertificate;

package/dist/cjs/x509_certificate-51a97033.js

@@ -0,0 +1,139 @@
+/*!
+ * © Peculiar Ventures https://peculiarventures.com/ - MIT License
+ */
+'use strict';
+
+const certification_request = require('./certification_request-cde57123.js');
+const index = require('./index-ff818d4d.js');
+const l10n = require('./l10n-a048a686.js');
+
+/**
+ * @license
+ * Copyright (c) Peculiar Ventures, LLC.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+class X509Certificate extends certification_request.AsnData {
+  constructor(raw) {
+    super(certification_request.certificateRawToBuffer(raw), certification_request.Certificate);
+    this.thumbprints = {};
+    this.type = 'X.509 Certificate';
+    const { tbsCertificate } = this.asn;
+    this.serialNumber = index.build.Convert.ToHex(tbsCertificate.serialNumber);
+    this.subject = new certification_request.Name(tbsCertificate.subject).toJSON();
+    this.issuer = new certification_request.Name(tbsCertificate.issuer).toJSON();
+    this.version = tbsCertificate.version + 1;
+    const notBefore = tbsCertificate.validity.notBefore.utcTime
+      || tbsCertificate.validity.notBefore.generalTime;
+    if (!notBefore) {
+      throw new Error("Cannot get 'notBefore' value");
+    }
+    this.notBefore = notBefore;
+    const notAfter = tbsCertificate.validity.notAfter.utcTime
+      || tbsCertificate.validity.notAfter.generalTime;
+    if (!notAfter) {
+      throw new Error("Cannot get 'notAfter' value");
+    }
+    this.notAfter = notAfter;
+    this.validity = l10n.dateDiff(this.notBefore, this.notAfter);
+  }
+  parseExtensions() {
+    const { tbsCertificate } = this.asn;
+    if (tbsCertificate.extensions) {
+      this.extensions = tbsCertificate.extensions
+        .map((e) => new certification_request.Extension(certification_request.AsnConvert.serialize(e)));
+    }
+  }
+  get publicKey() {
+    const { subjectPublicKey, algorithm } = this.asn.tbsCertificate.subjectPublicKeyInfo;
+    let params;
+    if (algorithm.algorithm === certification_request.id_ecPublicKey && algorithm.parameters) {
+      params = certification_request.AsnConvert.parse(algorithm.parameters, certification_request.ECParameters);
+    }
+    if (algorithm.algorithm === certification_request.id_rsaEncryption) {
+      params = certification_request.AsnConvert.parse(subjectPublicKey, certification_request.RSAPublicKey);
+    }
+    const spki = certification_request.AsnConvert.serialize(this.asn.tbsCertificate.subjectPublicKeyInfo);
+    return {
+      params,
+      value: spki,
+      algorithm: algorithm.algorithm,
+    };
+  }
+  get signature() {
+    const { signatureValue, signatureAlgorithm } = this.asn;
+    return {
+      value: signatureValue,
+      algorithm: signatureAlgorithm.algorithm,
+    };
+  }
+  exportAsBase64() {
+    return index.build.Convert.ToBase64(this.raw);
+  }
+  exportAsHexFormatted() {
+    return certification_request.hexFormat(index.build.Convert.ToHex(this.raw));
+  }
+  exportAsPemFormatted() {
+    return `-----BEGIN CERTIFICATE-----\n${certification_request.base64Format(this.exportAsBase64())}\n-----END CERTIFICATE-----`;
+  }
+  async getThumbprint(algorithm = 'SHA-1') {
+    try {
+      const thumbprint = await certification_request.getCertificateThumbprint(algorithm, this.raw);
+      if (thumbprint) {
+        this.thumbprints[algorithm['name'] || algorithm] = index.build.Convert.ToHex(thumbprint);
+      }
+    }
+    catch (error) {
+      console.error('Error thumbprint get:', error);
+    }
+  }
+  get commonName() {
+    if (!this.subject) {
+      return '';
+    }
+    for (let i = 0; i < this.subject.length; i += 1) {
+      const name = this.subject[i];
+      if (name.shortName === 'CN' || name.shortName === 'E' || name.shortName === 'O') {
+        return name.value;
+      }
+    }
+    return '';
+  }
+  get issuerCommonName() {
+    if (!this.issuer) {
+      return '';
+    }
+    for (let i = 0; i < this.issuer.length; i += 1) {
+      const name = this.issuer[i];
+      if (name.shortName === 'CN') {
+        return name.value;
+      }
+      if (name.shortName === 'E') {
+        return name.value;
+      }
+    }
+    return '';
+  }
+  get isRoot() {
+    return JSON.stringify(this.issuer) === JSON.stringify(this.subject);
+  }
+  subjectToString() {
+    if (!this.subject) {
+      return '';
+    }
+    return this.subject
+      .map((name) => (`${name.shortName}=${name.value}`))
+      .join(', ');
+  }
+  issuerToString() {
+    if (!this.issuer) {
+      return '';
+    }
+    return this.issuer
+      .map((name) => (`${name.shortName}=${name.value}`))
+      .join(', ');
+  }
+}
+
+exports.X509Certificate = X509Certificate;

package/dist/collection/components/certificate-decoder/certificate-decoder.js

@@ -8,8 +8,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { Component, Host, h, State, Prop, } from '@stencil/core';
-import { validator, history, readAsBinaryString } from '../../utils';
+import { Component, Host, h, State, Prop, Event, } from '@stencil/core';
+import { validator, readAsBinaryString } from '../../utils';
 import { X509Certificate, X509AttributeCertificate, CSR } from '../../crypto';
 export class CertificateDecoder {
   constructor() {
@@ -48,27 +48,22 @@ export class CertificateDecoder {
     };
   }
   componentDidLoad() {
-    const parsedHash = history.parseHash(window.location.search);
-    if (parsedHash.cert) {
+    if (this.defaultCertificate) {
       /**
        * Prevent Stencil warning about re-render
        */
-      setTimeout(() => this.decode(parsedHash.cert), 100);
+      setTimeout(() => this.decode(this.defaultCertificate), 100);
     }
   }
   clearValue() {
     this.inputPaste.value = '';
     this.certificateDecoded = null;
-    history.replace({ search: '' });
+    this.clearCertificate.emit();
   }
   setValue(value) {
     this.certificateDecoded = value;
     this.inputPaste.value = value.exportAsPemFormatted();
-    history.replace({
-      search: history.queryStringify({
-        cert: value.exportAsBase64(),
-      }),
-    });
+    this.successParse.emit(value.exportAsBase64());
   }
   decode(certificate) {
     const isPem = validator.isPem(certificate);
@@ -168,9 +163,57 @@ export class CertificateDecoder {
       },
       "attribute": "certificate-example",
       "reflect": false
+    },
+    "defaultCertificate": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": true,
+      "docs": {
+        "tags": [],
+        "text": "The default certificate value for decode and show details. Use PEM or DER."
+      },
+      "attribute": "default-certificate",
+      "reflect": false
     }
   }; }
   static get states() { return {
     "certificateDecoded": {}
   }; }
+  static get events() { return [{
+      "method": "successParse",
+      "name": "successParse",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": "Emitted when the certificate has been successfully parsed."
+      },
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      }
+    }, {
+      "method": "clearCertificate",
+      "name": "clearCertificate",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": "Emitted when the certificate has been removed."
+      },
+      "complexType": {
+        "original": "void",
+        "resolved": "void",
+        "references": {}
+      }
+    }]; }
 }

package/dist/collection/constants/oids.js

@@ -2171,6 +2171,7 @@ export const OIDs = {
   '2.16.840.1.114412.31.4.31.1': 'Digi Cert Grid Host Cert',
   '2.16.840.1.114413.1.7.23.3': 'Go Daddy EV policy',
   '2.16.840.1.114414.1.7.23.3': 'Starfield EV policy',
+  '2.16.840.1.114569.1.1.3': 'SHAKEN/STIR Certificate Policy v1.3',
   '2.23.42.0': 'Content Type',
   '2.23.42.0.0': 'Pan Data',
   '2.23.42.0.1': 'Pan Token',

package/dist/collection/utils/index.js

@@ -2,7 +2,6 @@
  * © Peculiar Ventures https://peculiarventures.com/ - MIT License
  */
 import * as validator from './validator';
-export { default as history } from './history';
 export * from './read_file';
 export * from './date_formatter';
 export * from './l10n';

package/dist/collection/www-copy/index.js

@@ -0,0 +1,80 @@
+(() => {
+  // Constants.
+  const CERTIFICATE_EXAMPLE = `-----BEGIN CERTIFICATE-----
+  MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+  TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+  cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+  WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+  ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+  MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+  h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+  0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+  A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+  T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+  B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+  B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+  KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+  OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+  jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+  qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+  rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+  HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+  hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+  ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+  3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+  NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+  ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+  TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+  jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+  oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+  4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+  mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+  emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+  -----END CERTIFICATE-----`;
+  const CERTIFICATE_DECODER_ELEMENT = document.createElement('peculiar-certificate-decoder');
+  const HISTORY = window.HistoryLibrary.createBrowserHistory();
+  const searchParams = new URLSearchParams(window.location.search);
+
+  // Listeners.
+  CERTIFICATE_DECODER_ELEMENT.addEventListener('successParse', (event) => {
+    HISTORY.replace(`?cert=${encodeURIComponent(event.detail)}`);
+
+    setTimeout(() => {
+      window.scrollTo({
+        top: 460,
+        behavior: 'smooth',
+      });
+    }, 50);
+  });
+  CERTIFICATE_DECODER_ELEMENT.addEventListener('clearCertificate', () => {
+    HISTORY.replace('/');
+  });
+
+  // Default props.
+  CERTIFICATE_DECODER_ELEMENT.certificateExample = CERTIFICATE_EXAMPLE;
+
+  if (searchParams.get('certurl')) {
+    window.fetch(searchParams.get('certurl'))
+      .then((body) => {
+        if (body.status >= 200 && body.status < 300) {
+          return body.text();
+        }
+
+        return Promise.reject();
+      })
+      .then((response) => {
+        CERTIFICATE_DECODER_ELEMENT.defaultCertificate = response;
+      })
+      .catch(() => {
+        alert('Failed to load certificate. Please use another file or check CORS policy.');
+      })
+      .finally(() => {
+        // Init.
+        content.appendChild(CERTIFICATE_DECODER_ELEMENT);
+      });
+  } else {
+    CERTIFICATE_DECODER_ELEMENT.defaultCertificate = searchParams.get('cert') || undefined;
+    // Init.
+    content.appendChild(CERTIFICATE_DECODER_ELEMENT);
+  }
+})();