node-apk/build/lib/certificate.js

A library to parse Android application manifest and signature

"use strict";
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
/*
 * Copyright (c) 2021 XdevL. All rights reserved.
 *
 * This work is licensed under the terms of the MIT license.
 * For a copy, see <https://opensource.org/licenses/MIT>.
 */
var node_forge_1 = __importDefault(require("node-forge"));
var CertificateStore = /** @class */ (function () {
    function CertificateStore() {
        var certificates = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            certificates[_i] = arguments[_i];
        }
        var _this = this;
        this.store = new Map();
        certificates.forEach(function (cert) { return _this.store.set(cert.subject.hash, cert); });
    }
    CertificateStore.prototype.lookup = function (hash) {
        return this.store.get(hash);
    };
    CertificateStore.prototype.leaves = function () {
        var _this = this;
        var leaves = new Set(this.store.keys());
        this.store.forEach(function (cert) { return !cert.isIssuer(cert) && leaves.delete(cert.issuer.hash); });
        return Array.from(leaves).map(function (hash) { return _this.lookup(hash); });
    };
    CertificateStore.prototype.chain = function (certificate, create) {
        var issuer = this.lookup(certificate.issuer.hash);
        if (issuer == null || certificate.isIssuer(certificate)) {
            return create(certificate);
        }
        else {
            return create(certificate, this.chain(issuer, create));
        }
    };
    return CertificateStore;
}());
var Certificate = /** @class */ (function () {
    function Certificate(input, parent) {
        var certificate = input;
        this.serial = certificate.serialNumber;
        this.validFrom = certificate.validity.notBefore;
        this.validUntil = certificate.validity.notAfter;
        this.issuer = Certificate.attributesToMap(certificate.issuer.attributes);
        this.subject = Certificate.attributesToMap(certificate.subject.attributes);
        this.bytes = Certificate.certificateToBytes(certificate);
        this.parent = parent;
    }
    Certificate.fromPkcs7 = function (buffer) {
        var asn = node_forge_1.default.asn1.fromDer(buffer.toString("binary"));
        var certificates = node_forge_1.default.pkcs7.messageFromAsn1(asn)
            .certificates;
        return Certificate.from.apply(Certificate, certificates);
    };
    Certificate.fromDer = function () {
        var certificates = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            certificates[_i] = arguments[_i];
        }
        return Certificate.from.apply(Certificate, certificates.map(function (der) { return Certificate.certificateFromBytes(der); }));
    };
    Certificate.from = function () {
        var certificates = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            certificates[_i] = arguments[_i];
        }
        var store = new (CertificateStore.bind.apply(CertificateStore, __spreadArray([void 0], certificates, false)))();
        return store.leaves().map(function (leaf) { return store.chain(leaf, function (cert, parent) { return new Certificate(cert, parent); }); });
    };
    Certificate.attributesToMap = function (attributes) {
        return new Map(attributes
            .map(function (attr) { return [attr.shortName, attr.value]; })
            .filter(function (pair) { return !!pair[0] && !!pair[1]; }));
    };
    Certificate.certificateToBytes = function (certificate) {
        return Buffer.from(node_forge_1.default.asn1.toDer(node_forge_1.default.pki.certificateToAsn1(certificate))
            .getBytes(), "binary");
    };
    Certificate.certificateFromBytes = function (bytes) {
        return node_forge_1.default.pki.certificateFromAsn1(node_forge_1.default.asn1.fromDer(bytes.toString("binary")));
    };
    Object.defineProperty(Certificate.prototype, "chain", {
        get: function () {
            return this.parent ? this.parent.chain.concat(this) : [this];
        },
        enumerable: false,
        configurable: true
    });
    return Certificate;
}());
exports.default = Certificate;