core-3nweb-client-lib 0.40.1 → 0.41.1

package/build/lib-common/mailerid-sigs/index.d.ts

@@ -0,0 +1,44 @@
+type JsonKey = web3n.keys.JsonKey;
+type Key = web3n.keys.Key;
+type SignedLoad = web3n.keys.SignedLoad;
+type MailerIdException = web3n.mailerid.MailerIdException;
+/**
+ * This enumerates MailerId's different use-roles of keys, involved in
+ * establishing a trust.
+ */
+export declare const KEY_USE: {
+    /**
+     * This is a MailerId trust root.
+     * It signs certificate for itself, and it signs certificates for provider
+     * keys, which have shorter life span, than the root.
+     * Root may revoke itself, and may revoke provider key.
+     */
+    ROOT: string;
+    /**
+     * This is a provider key, which is used to certify users' signing keys.
+     */
+    PROVIDER: string;
+    /**
+     * With this key, MailerId user signs assertions and mail keys.
+     */
+    SIGN: string;
+};
+export declare function makeMailerIdException(flags: Partial<MailerIdException>, params: Partial<MailerIdException>): MailerIdException;
+export declare function makeMalformedCertsException(message: string, cause?: any): MailerIdException;
+export interface Keypair {
+    pkey: JsonKey;
+    skey: Key;
+}
+export interface AssertionLoad {
+    user: string;
+    rpDomain: string;
+    sessionId: string;
+    issuedAt: number;
+    expiresAt: number;
+}
+export interface CertsChain {
+    user: SignedLoad;
+    prov: SignedLoad;
+    root: SignedLoad;
+}
+export {};

package/build/lib-common/mailerid-sigs/index.js

@@ -0,0 +1,50 @@
+"use strict";
+/*
+ Copyright (C) 2015 - 2017, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_USE = void 0;
+exports.makeMailerIdException = makeMailerIdException;
+exports.makeMalformedCertsException = makeMalformedCertsException;
+const runtime_1 = require("../exceptions/runtime");
+/**
+ * This enumerates MailerId's different use-roles of keys, involved in
+ * establishing a trust.
+ */
+exports.KEY_USE = {
+    /**
+     * This is a MailerId trust root.
+     * It signs certificate for itself, and it signs certificates for provider
+     * keys, which have shorter life span, than the root.
+     * Root may revoke itself, and may revoke provider key.
+     */
+    ROOT: "mid-root",
+    /**
+     * This is a provider key, which is used to certify users' signing keys.
+     */
+    PROVIDER: "mid-provider",
+    /**
+     * With this key, MailerId user signs assertions and mail keys.
+     */
+    SIGN: "mid-sign",
+};
+Object.freeze(exports.KEY_USE);
+function makeMailerIdException(flags, params) {
+    return (0, runtime_1.makeRuntimeException)('mailerid', params, flags);
+}
+function makeMalformedCertsException(message, cause) {
+    return makeMailerIdException({ certMalformed: true }, { message, cause });
+}

package/build/lib-common/mailerid-sigs/relying-party.d.ts

@@ -0,0 +1,59 @@
+import { arrays } from "ecma-nacl";
+import { CertsChain } from "./index";
+type JsonKey = web3n.keys.JsonKey;
+type Key = web3n.keys.Key;
+type SignedLoad = web3n.keys.SignedLoad;
+/**
+ * @param certs is a chain of certificate to be verified.
+ * @param rootAddr is MailerId service's domain.
+ * @param validAt is an epoch time moment (in second), at which user
+ * certificate must be valid. Provider certificate must be valid at
+ * creation of user's certificate. Root certificate must be valid at
+ * creation of provider's certificate.
+ * @return user's MailerId signing key with user's address.
+ */
+export declare function verifyChainAndGetUserKey(certs: CertsChain, rootAddr: string, validAt: number, arrFactory?: arrays.Factory): {
+    pkey: Key;
+    address: string;
+};
+export interface AssertionInfo {
+    relyingPartyDomain: string;
+    sessionId: string;
+    user: string;
+}
+export declare function verifyAssertion(midAssertion: SignedLoad, certChain: CertsChain, rootAddr: string, validAt: number, arrFactory?: arrays.Factory): AssertionInfo;
+/**
+ * This function does verification of a single certificate with known
+ * signing key.
+ * If your task requires verification starting with principal's MailerId,
+ * use verifyPubKey function that also accepts and checks MailerId
+ * certificates chain.
+ * @param keyCert is a certificate that should be checked
+ * @param principalAddress is an expected principal's address in a given
+ * certificate. Exception is thrown, if certificate does not match this
+ * expectation.
+ * @param signingKey is a public key, with which given certificate is
+ * validated cryptographically. Exception is thrown, if crypto-verification
+ * fails.
+ * @param validAt is an epoch time moment (in second), for which verification
+ * should be done.
+ * @param arrFactory is an optional array factory.
+ * @return a key from a given certificate.
+ */
+export declare function verifyKeyCert(keyCert: SignedLoad, principalAddress: string, signingKey: Key, validAt: number, arrFactory?: arrays.Factory): JsonKey;
+/**
+ * @param pubKeyCert certificate with a public key, that needs to be
+ * verified.
+ * @param principalAddress is an expected principal's address in both key
+ * certificate, and in MailerId certificate chain. Exception is thrown,
+ * if certificate does not match this expectation.
+ * @param certChain is MailerId certificate chain for named principal.
+ * @param rootAddr is MailerId root's domain.
+ * @param validAt is an epoch time moment (in second), for which key
+ * certificate verification should be done.
+ * @param arrFactory is an optional array factory.
+ * @return a key from a given certificate.
+ */
+export declare function verifyPubKey(pubKeyCert: SignedLoad, principalAddress: string, certChain: CertsChain, rootAddr: string, validAt: number, arrFactory?: arrays.Factory): JsonKey;
+export declare function verifySignature(root: SignedLoad, prov: SignedLoad, user: SignedLoad, signature: SignedLoad, arrFactory?: arrays.Factory): boolean;
+export {};

package/build/lib-common/mailerid-sigs/relying-party.js

@@ -0,0 +1,237 @@
+"use strict";
+/*
+ Copyright (C) 2015 - 2017, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyChainAndGetUserKey = verifyChainAndGetUserKey;
+exports.verifyAssertion = verifyAssertion;
+exports.verifyKeyCert = verifyKeyCert;
+exports.verifyPubKey = verifyPubKey;
+exports.verifySignature = verifySignature;
+const ecma_nacl_1 = require("ecma-nacl");
+const jwkeys_1 = require("../jwkeys");
+const buffer_utils_1 = require("../buffer-utils");
+const index_1 = require("./index");
+function makeTimeMismatchException(message) {
+    return (0, index_1.makeMailerIdException)({ timeMismatch: true }, { message });
+}
+function makeCertsMismatchException(message) {
+    return (0, index_1.makeMailerIdException)({ certsMismatch: true }, { message });
+}
+function makeSigVerifException(message) {
+    return (0, index_1.makeMailerIdException)({ sigVerificationFails: true }, { message });
+}
+const minValidityPeriodForCert = 20 * 60;
+function verifyCertAndGetPubKey(signedCert, use, validAt, arrFactory, issuer, issuerPKey) {
+    const cert = (0, jwkeys_1.getKeyCert)(signedCert);
+    if ((validAt < (cert.issuedAt - minValidityPeriodForCert))
+        || (cert.expiresAt <= validAt)) {
+        throw (0, index_1.makeMailerIdException)({ timeMismatch: true }, { message: `Certificate is not valid at a given moment ${validAt}, cause it is issued at ${cert.issuedAt}, and expires at ${cert.expiresAt}` });
+    }
+    if (issuer) {
+        if (!issuerPKey) {
+            throw new Error(`No issuer key given.`);
+        }
+        if ((cert.issuer !== issuer) || (signedCert.kid !== issuerPKey.kid)) {
+            throw makeCertsMismatchException(`Certificate is not signed by issuer key.`);
+        }
+    }
+    let pkey;
+    let sig;
+    let load;
+    try {
+        pkey = (0, jwkeys_1.keyFromJson)(cert.cert.publicKey, use, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.PUBLIC_KEY_LENGTH);
+        sig = buffer_utils_1.base64.open(signedCert.sig);
+        load = buffer_utils_1.base64.open(signedCert.load);
+    }
+    catch (err) {
+        throw (0, index_1.makeMalformedCertsException)(`Cannot read certificate`, err);
+    }
+    const pk = (issuer ? issuerPKey.k : pkey.k);
+    const certOK = ecma_nacl_1.signing.verify(sig, load, pk, arrFactory);
+    if (!certOK) {
+        throw makeSigVerifException(`Certificate ${use} failed validation.`);
+    }
+    return { pkey: pkey, address: cert.cert.principal.address };
+}
+/**
+ * @param certs is a chain of certificate to be verified.
+ * @param rootAddr is MailerId service's domain.
+ * @param validAt is an epoch time moment (in second), at which user
+ * certificate must be valid. Provider certificate must be valid at
+ * creation of user's certificate. Root certificate must be valid at
+ * creation of provider's certificate.
+ * @return user's MailerId signing key with user's address.
+ */
+function verifyChainAndGetUserKey(certs, rootAddr, validAt, arrFactory) {
+    // root certificate must be valid when provider's certificate was issued
+    let rootValidityMoment;
+    try {
+        rootValidityMoment = (0, jwkeys_1.getKeyCert)(certs.prov).issuedAt;
+    }
+    catch (err) {
+        throw (0, index_1.makeMalformedCertsException)(`Provider's certificate is malformed`, err);
+    }
+    // check root and get the key
+    const root = verifyCertAndGetPubKey(certs.root, index_1.KEY_USE.ROOT, rootValidityMoment, arrFactory);
+    if (rootAddr !== root.address) {
+        throw makeCertsMismatchException(`Root certificate address ${root.address} doesn't match expected address ${rootAddr}`);
+    }
+    // provider's certificate must be valid when user's certificate was issued
+    let provValidityMoment;
+    try {
+        provValidityMoment = (0, jwkeys_1.getKeyCert)(certs.user).issuedAt;
+    }
+    catch (err) {
+        throw (0, index_1.makeMalformedCertsException)(`User's certificate is malformed`, err);
+    }
+    // check provider and get the key
+    const provider = verifyCertAndGetPubKey(certs.prov, index_1.KEY_USE.PROVIDER, provValidityMoment, arrFactory, root.address, root.pkey);
+    // check that provider cert comes from the same issuer as root
+    if (root.address !== provider.address) {
+        throw makeCertsMismatchException(`Provider's certificate address ${provider.address} doesn't match expected address ${root.address}.`);
+    }
+    // check user certificate and get the key
+    return verifyCertAndGetPubKey(certs.user, index_1.KEY_USE.SIGN, validAt, arrFactory, provider.address, provider.pkey);
+}
+function verifyAssertion(midAssertion, certChain, rootAddr, validAt, arrFactory) {
+    const userInfo = verifyChainAndGetUserKey(certChain, rootAddr, validAt, arrFactory);
+    let loadBytes;
+    let sigBytes;
+    let assertion;
+    try {
+        loadBytes = buffer_utils_1.base64.open(midAssertion.load);
+        sigBytes = buffer_utils_1.base64.open(midAssertion.sig);
+        assertion = JSON.parse(buffer_utils_1.utf8.open(loadBytes));
+    }
+    catch (err) {
+        throw (0, index_1.makeMalformedCertsException)(`Cannot read assertion`, err);
+    }
+    if (!ecma_nacl_1.signing.verify(sigBytes, loadBytes, userInfo.pkey.k, arrFactory)) {
+        throw makeSigVerifException(`Assertion fails verification.`);
+    }
+    if (assertion.user !== userInfo.address) {
+        throw (0, index_1.makeMalformedCertsException)(`Assertion is for one user, while chain is for another.`);
+    }
+    if (!assertion.sessionId) {
+        throw (0, index_1.makeMalformedCertsException)(`Assertion doesn't have session id.`);
+    }
+    // Note that assertion can be valid before issue time, to counter
+    // some mis-synchronization of clocks.
+    // It can be some fixed value, like minimum validity period of certs.
+    if (Math.abs(validAt - assertion.issuedAt) > (assertion.expiresAt - assertion.issuedAt)) {
+        throw makeTimeMismatchException(`Assertion is not valid at ${validAt}, being issued at ${assertion.expiresAt} and expiring at ${assertion.expiresAt}.`);
+    }
+    return {
+        sessionId: assertion.sessionId,
+        relyingPartyDomain: assertion.rpDomain,
+        user: userInfo.address
+    };
+}
+/**
+ * This function does verification of a single certificate with known
+ * signing key.
+ * If your task requires verification starting with principal's MailerId,
+ * use verifyPubKey function that also accepts and checks MailerId
+ * certificates chain.
+ * @param keyCert is a certificate that should be checked
+ * @param principalAddress is an expected principal's address in a given
+ * certificate. Exception is thrown, if certificate does not match this
+ * expectation.
+ * @param signingKey is a public key, with which given certificate is
+ * validated cryptographically. Exception is thrown, if crypto-verification
+ * fails.
+ * @param validAt is an epoch time moment (in second), for which verification
+ * should be done.
+ * @param arrFactory is an optional array factory.
+ * @return a key from a given certificate.
+ */
+function verifyKeyCert(keyCert, principalAddress, signingKey, validAt, arrFactory) {
+    let sigBytes;
+    let loadBytes;
+    try {
+        sigBytes = buffer_utils_1.base64.open(keyCert.sig);
+        loadBytes = buffer_utils_1.base64.open(keyCert.load);
+    }
+    catch (err) {
+        throw (0, index_1.makeMalformedCertsException)(`Cannot read certificate`, err);
+    }
+    if (!ecma_nacl_1.signing.verify(sigBytes, loadBytes, signingKey.k, arrFactory)) {
+        throw makeSigVerifException(`Key certificate fails verification.`);
+    }
+    let cert;
+    try {
+        cert = (0, jwkeys_1.getKeyCert)(keyCert);
+    }
+    catch (err) {
+        throw (0, index_1.makeMalformedCertsException)(`Cannot read certificate`, err);
+    }
+    if (cert.cert.principal.address !== principalAddress) {
+        throw makeCertsMismatchException(`Key certificate is for user ${cert.cert.principal.address}, while expected address is ${principalAddress}`);
+    }
+    if ((cert.expiresAt - cert.issuedAt) <= minValidityPeriodForCert) {
+        if (Math.abs(cert.issuedAt - validAt) > minValidityPeriodForCert) {
+            throw makeTimeMismatchException(`Certificate is not valid at ${validAt} being issued at ${cert.issuedAt} and applying minimum validity period window of ${minValidityPeriodForCert} seconds`);
+        }
+    }
+    else {
+        if ((validAt < (cert.issuedAt - minValidityPeriodForCert)) || (cert.expiresAt <= validAt)) {
+            throw makeTimeMismatchException(`Certificate is not valid at ${validAt} being issued at ${cert.issuedAt} and expiring at ${cert.expiresAt}`);
+        }
+    }
+    return cert.cert.publicKey;
+}
+/**
+ * @param pubKeyCert certificate with a public key, that needs to be
+ * verified.
+ * @param principalAddress is an expected principal's address in both key
+ * certificate, and in MailerId certificate chain. Exception is thrown,
+ * if certificate does not match this expectation.
+ * @param certChain is MailerId certificate chain for named principal.
+ * @param rootAddr is MailerId root's domain.
+ * @param validAt is an epoch time moment (in second), for which key
+ * certificate verification should be done.
+ * @param arrFactory is an optional array factory.
+ * @return a key from a given certificate.
+ */
+function verifyPubKey(pubKeyCert, principalAddress, certChain, rootAddr, validAt, arrFactory) {
+    // time moment, for which user's certificate chain must be valid
+    let chainValidityMoment;
+    try {
+        chainValidityMoment = (0, jwkeys_1.getKeyCert)(pubKeyCert).issuedAt;
+    }
+    catch (err) {
+        throw (0, index_1.makeMalformedCertsException)(`Cannot read certificate`, err);
+    }
+    const principalInfo = verifyChainAndGetUserKey(certChain, rootAddr, chainValidityMoment, arrFactory);
+    if (principalInfo.address !== principalAddress) {
+        throw makeCertsMismatchException(`MailerId certificate chain is for user ${principalInfo.address}, while expected address is ${principalAddress}`);
+    }
+    return verifyKeyCert(pubKeyCert, principalAddress, principalInfo.pkey, validAt, arrFactory);
+}
+function verifySignature(root, prov, user, signature, arrFactory) {
+    try {
+        const rootAddr = (0, jwkeys_1.getKeyCert)(root).cert.principal.address;
+        const validAt = (0, jwkeys_1.getKeyCert)(user).issuedAt + 60;
+        const signee = verifyChainAndGetUserKey({ prov, root, user }, rootAddr, validAt, arrFactory);
+        const sigBytes = buffer_utils_1.base64.open(signature.sig);
+        const loadBytes = buffer_utils_1.base64.open(signature.load);
+        return ecma_nacl_1.signing.verify(sigBytes, loadBytes, signee.pkey.k, arrFactory);
+    }
+    catch (err) {
+        return false;
+    }
+}

package/build/lib-common/mailerid-sigs/user.d.ts

@@ -0,0 +1,60 @@
+import { GetRandom, arrays } from "ecma-nacl";
+import { Keypair } from "./index";
+type JsonKey = web3n.keys.JsonKey;
+type Key = web3n.keys.Key;
+type SignedLoad = web3n.keys.SignedLoad;
+/**
+ * This is used by user of MailerId to create assertion that prove user's
+ * identity.
+ */
+export interface MailerIdSigner {
+    address: string;
+    userCert: SignedLoad;
+    providerCert: SignedLoad;
+    issuer: string;
+    certExpiresAt: number;
+    validityPeriod: number;
+    /**
+     * @param rpDomain relying party domain. If there is an explicit port,
+     * this should domain:port, which is a hostname part of url parsing.
+     * @param sessionId
+     * @param validFor (optional)
+     * @returns signed assertion with a given sessionId string.
+     */
+    generateAssertionFor(rpDomain: string, sessionId: string, validFor?: number): SignedLoad;
+    /**
+     * @param pkey
+     * @param validFor
+     * @returns signed certificate with a given public key.
+     */
+    certifyPublicKey(pkey: JsonKey, validFor: number): SignedLoad;
+    /**
+     * Makes this AssertionSigner not usable by wiping its secret key.
+     */
+    destroy(): void;
+    /**
+     * @param payload
+     * @returns
+     */
+    sign(payload: Uint8Array): {
+        provCert: SignedLoad;
+        signeeCert: SignedLoad;
+        signature: SignedLoad;
+    };
+}
+export declare const KID_BYTES_LENGTH = 9;
+export declare const MAX_SIG_VALIDITY: number;
+export declare function generateSigningKeyPair(random: GetRandom, arrFactory?: arrays.Factory): Keypair;
+/**
+ * @param signKey which will be used to sign assertions/keys. Note that
+ * this key shall be wiped, when signer is destroyed, as key is neither
+ * long-living, nor should be shared.
+ * @param cert is user's certificate, signed by identity provider.
+ * @param provCert is provider's certificate, signed by respective mid root.
+ * @param assertionValidity is an assertion validity period in seconds
+ * @param arrFactory is an optional array factory
+ * @return signer for user of MailerId to generate assertions, and to sign
+ * keys.
+ */
+export declare function makeMailerIdSigner(signKey: Key, userCert: SignedLoad, provCert: SignedLoad, assertionValidity?: number, arrFactory?: arrays.Factory): MailerIdSigner;
+export {};

package/build/lib-common/mailerid-sigs/user.js

@@ -0,0 +1,149 @@
+"use strict";
+/*
+ Copyright (C) 2015 - 2017, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SIG_VALIDITY = exports.KID_BYTES_LENGTH = void 0;
+exports.generateSigningKeyPair = generateSigningKeyPair;
+exports.makeMailerIdSigner = makeMailerIdSigner;
+const ecma_nacl_1 = require("ecma-nacl");
+const jwkeys_1 = require("../jwkeys");
+const buffer_utils_1 = require("../buffer-utils");
+const json_utils_1 = require("../json-utils");
+const utils_NaCl_Ed_1 = require("./utils-NaCl-Ed");
+const index_1 = require("./index");
+function correlateSKeyWithItsCert(skey, cert) {
+    const pkey = (0, jwkeys_1.keyFromJson)(cert.cert.publicKey, skey.use, ecma_nacl_1.signing.JWK_ALG_NAME, ecma_nacl_1.signing.PUBLIC_KEY_LENGTH);
+    if ((pkey.kid !== skey.kid) || (pkey.use !== skey.use) || (pkey.alg !== skey.alg)
+        || !(0, ecma_nacl_1.compareVectors)(ecma_nacl_1.signing.extract_pkey(skey.k), pkey.k)) {
+        throw new Error("Key does not correspond to certificate.");
+    }
+}
+exports.KID_BYTES_LENGTH = 9;
+exports.MAX_SIG_VALIDITY = 30 * 60;
+function generateSigningKeyPair(random, arrFactory) {
+    return (0, utils_NaCl_Ed_1.genSignKeyPair)(index_1.KEY_USE.SIGN, exports.KID_BYTES_LENGTH, random, arrFactory);
+}
+/**
+ * @param signKey which will be used to sign assertions/keys. Note that
+ * this key shall be wiped, when signer is destroyed, as key is neither
+ * long-living, nor should be shared.
+ * @param cert is user's certificate, signed by identity provider.
+ * @param provCert is provider's certificate, signed by respective mid root.
+ * @param assertionValidity is an assertion validity period in seconds
+ * @param arrFactory is an optional array factory
+ * @return signer for user of MailerId to generate assertions, and to sign
+ * keys.
+ */
+function makeMailerIdSigner(signKey, userCert, provCert, assertionValidity = exports.MAX_SIG_VALIDITY, arrFactory) {
+    const certificate = (0, jwkeys_1.getKeyCert)(userCert);
+    if (signKey.use !== index_1.KEY_USE.SIGN) {
+        throw new Error(`Given key ${signKey.kid} has incorrect use: ${signKey.use}`);
+    }
+    correlateSKeyWithItsCert(signKey, certificate);
+    if ((typeof assertionValidity !== 'number') || (assertionValidity < 1)
+        || (assertionValidity > exports.MAX_SIG_VALIDITY)) {
+        throw new Error(`Given assertion validity is illegal: ${assertionValidity}`);
+    }
+    if (!arrFactory) {
+        arrFactory = ecma_nacl_1.arrays.makeFactory();
+    }
+    function ensureSignerCanBeUsed() {
+        if (!signKey) {
+            throw new Error("Signer is already destroyed.");
+        }
+    }
+    const signer = {
+        address: certificate.cert.principal.address,
+        userCert: userCert,
+        providerCert: provCert,
+        issuer: certificate.issuer,
+        certExpiresAt: certificate.expiresAt,
+        validityPeriod: assertionValidity,
+        generateAssertionFor: (rpDomain, sessionId, validFor) => {
+            ensureSignerCanBeUsed();
+            if (typeof validFor === 'number') {
+                if (validFor > assertionValidity) {
+                    validFor = assertionValidity;
+                }
+                else if (validFor < 0) {
+                    new Error(`Given assertion validity is illegal: ${validFor}`);
+                }
+            }
+            else {
+                validFor = assertionValidity;
+            }
+            let now = Math.floor(Date.now() / 1000);
+            if (now <= certificate.issuedAt) {
+                now = certificate.issuedAt + 1;
+            }
+            if (now >= certificate.expiresAt) {
+                throw new Error(`Signing key has already expiried at ${certificate.expiresAt} and now is ${now}`);
+            }
+            const assertion = {
+                rpDomain: rpDomain,
+                sessionId: sessionId,
+                user: certificate.cert.principal.address,
+                issuedAt: now,
+                expiresAt: now + validFor
+            };
+            const assertionBytes = buffer_utils_1.utf8.pack(JSON.stringify(assertion));
+            const sigBytes = ecma_nacl_1.signing.signature(assertionBytes, signKey.k, arrFactory);
+            return {
+                alg: signKey.alg,
+                kid: signKey.kid,
+                sig: buffer_utils_1.base64.pack(sigBytes),
+                load: buffer_utils_1.base64.pack(assertionBytes)
+            };
+        },
+        certifyPublicKey: (pkey, validFor) => {
+            ensureSignerCanBeUsed();
+            if (validFor < 0) {
+                new Error(`Given certificate validity is illegal: ${validFor}`);
+            }
+            const now = Math.floor(Date.now() / 1000);
+            if (now >= certificate.expiresAt) {
+                throw new Error(`Signing key has already expiried at ${certificate.expiresAt} and now is ${now}`);
+            }
+            return (0, utils_NaCl_Ed_1.makeCert)(pkey, certificate.cert.principal.address, certificate.cert.principal.address, now, now + validFor, signKey, arrFactory);
+        },
+        destroy: () => {
+            if (!signKey) {
+                return;
+            }
+            ecma_nacl_1.arrays.wipe(signKey.k);
+            signKey = undefined;
+            arrFactory.wipeRecycled();
+            arrFactory = undefined;
+        },
+        sign: payload => {
+            ensureSignerCanBeUsed();
+            const sigBytes = ecma_nacl_1.signing.signature(payload, signKey.k, arrFactory);
+            return {
+                signature: {
+                    alg: signKey.alg,
+                    kid: signKey.kid,
+                    sig: buffer_utils_1.base64.pack(sigBytes),
+                    load: buffer_utils_1.base64.pack(payload)
+                },
+                provCert: (0, json_utils_1.copy)(provCert),
+                signeeCert: (0, json_utils_1.copy)(userCert)
+            };
+        }
+    };
+    Object.freeze(signer);
+    return signer;
+}

package/build/lib-common/mailerid-sigs/utils-NaCl-Ed.d.ts

@@ -0,0 +1,8 @@
+import { GetRandom, arrays } from "ecma-nacl";
+import { Keypair } from "./index";
+type JsonKey = web3n.keys.JsonKey;
+type Key = web3n.keys.Key;
+type SignedLoad = web3n.keys.SignedLoad;
+export declare function genSignKeyPair(use: string, kidLen: number, random: GetRandom, arrFactory?: arrays.Factory): Keypair;
+export declare function makeCert(pkey: JsonKey, principalAddr: string, issuer: string, issuedAt: number, expiresAt: number, signKey: Key, arrFactory?: arrays.Factory): SignedLoad;
+export {};

package/build/lib-common/mailerid-sigs/utils-NaCl-Ed.js

@@ -0,0 +1,61 @@
+"use strict";
+/*
+ Copyright (C) 2015 - 2017, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genSignKeyPair = genSignKeyPair;
+exports.makeCert = makeCert;
+const ecma_nacl_1 = require("ecma-nacl");
+const buffer_utils_1 = require("../buffer-utils");
+const index_1 = require("./index");
+function genSignKeyPair(use, kidLen, random, arrFactory) {
+    const pair = ecma_nacl_1.signing.generate_keypair(random(ecma_nacl_1.signing.SEED_LENGTH), arrFactory);
+    const pkey = {
+        use: use,
+        alg: ecma_nacl_1.signing.JWK_ALG_NAME,
+        kid: buffer_utils_1.base64.pack(random(kidLen)),
+        k: buffer_utils_1.base64.pack(pair.pkey)
+    };
+    const skey = {
+        use: pkey.use,
+        alg: pkey.alg,
+        kid: pkey.kid,
+        k: pair.skey
+    };
+    return { pkey, skey };
+}
+function makeCert(pkey, principalAddr, issuer, issuedAt, expiresAt, signKey, arrFactory) {
+    if (signKey.alg !== ecma_nacl_1.signing.JWK_ALG_NAME) {
+        throw (0, index_1.makeMailerIdException)({ algMismatch: true }, { message: `Given signing key is used with unknown algorithm ${signKey.alg}` });
+    }
+    const cert = {
+        cert: {
+            publicKey: pkey,
+            principal: { address: principalAddr }
+        },
+        issuer: issuer,
+        issuedAt: issuedAt,
+        expiresAt: expiresAt
+    };
+    const certBytes = buffer_utils_1.utf8.pack(JSON.stringify(cert));
+    const sigBytes = ecma_nacl_1.signing.signature(certBytes, signKey.k, arrFactory);
+    return {
+        alg: signKey.alg,
+        kid: signKey.kid,
+        sig: buffer_utils_1.base64.pack(sigBytes),
+        load: buffer_utils_1.base64.pack(certBytes)
+    };
+}