core-3nweb-client-lib 0.49.6 → 0.49.8

package/build/core/keyring/correspondent-keys.js

@@ -1,403 +0,0 @@
-"use strict";
-/*
- Copyright (C) 2015 - 2018, 2022, 2026 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.CorrespondentKeys = void 0;
-exports.msgMasterDecryptor = msgMasterDecryptor;
-/**
- * This file contains functionality, used inside keyring.
- */
-const common_1 = require("./common");
-const ecma_nacl_1 = require("ecma-nacl");
-const buffer_utils_1 = require("../../lib-common/buffer-utils");
-const error_1 = require("../../lib-common/exceptions/error");
-const async_cryptor_wrap_1 = require("../../lib-common/async-cryptor-wrap");
-const cryptor_work_labels_1 = require("../../lib-client/cryptor-work-labels");
-const rng_def_1 = require("../../lib-common/rng-def");
-async function generatePids(random) {
-    const pids = [];
-    for (let i = 0; i < 5; i += 1) {
-        pids[i] = await (0, rng_def_1.stringOfB64UrlSafeChars)(common_1.PID_LENGTH, random);
-    }
-    return pids;
-}
-function msgMasterDecryptor(cryptor, skey, pkey) {
-    const msgMasterKey = calcMsgMasterKey(skey, pkey);
-    const workLabel = cryptor_work_labels_1.cryptoWorkLabels.makeRandom('asmail');
-    const masterDecr = (0, async_cryptor_wrap_1.makeDecryptor)(cryptor, workLabel, msgMasterKey);
-    msgMasterKey.fill(0);
-    return masterDecr;
-}
-function calcMsgMasterKey(skey, pkey) {
-    if (skey.alg === ecma_nacl_1.box.JWK_ALG_NAME) {
-        const sk = (0, common_1.extractSKeyBytes)(skey);
-        const pk = (0, common_1.extractKeyBytes)(pkey);
-        const dhShared = ecma_nacl_1.box.calc_dhshared_key(pk, sk);
-        sk.fill(0);
-        pk.fill(0);
-        return dhShared;
-    }
-    throw new Error(`Unsupported algorithm ${skey.alg}`);
-}
-function calcMsgMasterKeyB64(skey, pkey) {
-    return buffer_utils_1.base64.pack(calcMsgMasterKey(skey, pkey));
-}
-const MIN_PERIOD_FOR_PAIR = 15 * 60 * 1000;
-class CorrespondentKeys {
-    get correspondent() {
-        return this.keys.correspondent;
-    }
-    /**
-     * @param keyring in which these keys are hanging.
-     * @param address of this correspondent.
-     * Either serialData, or an address should be defined, not both.
-     * @param serialData from which this object should be reconstructed.
-     * Either serialData, or an address should be defined, not both.
-     */
-    constructor(keyring, random, address, serialData) {
-        this.keyring = keyring;
-        this.random = random;
-        this.keys = undefined;
-        if (address) {
-            this.keys = {
-                correspondent: address,
-                sendingPair: null,
-                receptionPairs: {
-                    suggested: null,
-                    inUse: null,
-                    old: null
-                }
-            };
-        }
-        else {
-            const data = JSON.parse(serialData);
-            // TODO checks of deserialized json data
-            this.keys = data;
-        }
-        Object.seal(this);
-    }
-    /**
-     * This attaches all keys into ring's maps.
-     * Theis method should be called only once, and only on a deserialized
-     * object.
-     */
-    mapAllKeysIntoRing() {
-        // index key pairs
-        const pairs = [
-            this.keys.receptionPairs.suggested,
-            this.keys.receptionPairs.inUse,
-            this.keys.receptionPairs.old
-        ];
-        const email = this.correspondent;
-        pairs.forEach(pair => {
-            if (!pair) {
-                return;
-            }
-            pair.pids.forEach(pid => this.keyring.pairIdToEmailMap.addPair(pid, email));
-        });
-    }
-    /**
-     * @return json object for serialization.
-     */
-    serialForm() {
-        return JSON.stringify(this.keys);
-    }
-    /**
-     * This function generates new suggested reception pair, but only if there
-     * is currently none.
-     * If there is previous suggested pair, it shall be returned.
-     */
-    async suggestPair() {
-        // reuse previously suggested pair
-        if (this.keys.receptionPairs.suggested) {
-            return toSuggestedPair(this.keys.receptionPairs.suggested);
-        }
-        if (!this.shouldSuggestNewPair()) {
-            return;
-        }
-        // generate new suggested pair
-        const corrPKey = this.keys.sendingPair.recipientPKey;
-        const isSenderIntroKey = (this.keys.sendingPair.type === 'intro');
-        const recipientKey = await (0, common_1.generateKeyPair)(this.random);
-        const msgMasterKey = calcMsgMasterKeyB64(recipientKey.skey, corrPKey);
-        const pair = {
-            pids: await generatePids(this.random),
-            recipientKey,
-            senderPKey: corrPKey,
-            isSenderIntroKey,
-            msgMasterKey,
-            timestamp: Date.now()
-        };
-        this.keys.receptionPairs.suggested = pair;
-        // add pair to index
-        this.keyring.pairIdToEmailMap.addPairs(pair.pids, this.correspondent);
-        this.keyring.saveChanges();
-        return toSuggestedPair(this.keys.receptionPairs.suggested);
-    }
-    shouldSuggestNewPair() {
-        if (!this.keys.sendingPair) {
-            throw new Error("Sending pair should be set before calling this function.");
-        }
-        if (this.keys.sendingPair.type === 'intro') {
-            return true;
-        }
-        if (!this.keys.sendingPair.sentMsgs) {
-            return false;
-        }
-        const now = Date.now();
-        if ((this.keys.sendingPair.timestamp + MIN_PERIOD_FOR_PAIR) > now) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * This marks suggested reception pair as being in use.
-     * Suggested pair is moved into category in-use, while in-use pair is
-     * reclassified as old.
-     * @param pair
-     */
-    markPairAsInUse(pair) {
-        if (this.keys.receptionPairs.suggested !== pair) {
-            return;
-        }
-        const mp = this.keys.receptionPairs.inUse;
-        this.keys.receptionPairs.inUse = this.keys.receptionPairs.suggested;
-        this.keys.receptionPairs.suggested = null;
-        if (mp) {
-            const dp = this.keys.receptionPairs.old;
-            this.keys.receptionPairs.old = mp;
-            if (dp) {
-                this.tryToRemovePIDsFromIndex(dp.pids);
-            }
-        }
-    }
-    tryToRemovePIDsFromIndex(pids) {
-        const pidSet = new Set(pids);
-        for (const pair of Object.values(this.keys.receptionPairs)) {
-            if (!pair) {
-                continue;
-            }
-            pair.pids.forEach(pid => pidSet.delete(pid));
-        }
-        for (const pid of pidSet) {
-            this.keyring.pairIdToEmailMap.removePair(pid, this.correspondent);
-        }
-    }
-    /**
-     * This function is used internally in this.setSendingPair(p) function.
-     * @param kid
-     * @return a key for receiving, corresponding to given key id.
-     */
-    findReceptionKey(kid) {
-        for (const fieldName of Object.keys(this.keys.receptionPairs)) {
-            const rp = this.keys.receptionPairs[fieldName];
-            if (!rp) {
-                continue;
-            }
-            if (rp.recipientKey.skey.kid === kid) {
-                return rp.recipientKey;
-            }
-        }
-        const err = new Error("Key cannot be found");
-        err.unknownKid = true;
-        throw err;
-    }
-    /**
-     * This checks given pair and sets a new sending pair.
-     * @param pair
-     * @param usedPublishedIntro
-     */
-    ratchetUpSendingPair(pair, usedPublishedIntro) {
-        if (this.keys.sendingPair) {
-            const existingPair = this.keys.sendingPair;
-            if (existingPair.type === 'ratcheted') {
-                if ((existingPair.recipientPKey.k === pair.recipientPKey.k)
-                    && (existingPair.senderKey.pkey.kid === pair.senderKid)) {
-                    return;
-                }
-                if (existingPair.timestamp > pair.timestamp) {
-                    return;
-                }
-            }
-        }
-        let senderKey;
-        if (pair.isSenderIntroKey) {
-            if (!usedPublishedIntro) {
-                throw new Error(`Missing a published intro key, referenced in the pair`);
-            }
-            senderKey = usedPublishedIntro;
-        }
-        else {
-            senderKey = this.findReceptionKey(pair.senderKid);
-        }
-        try {
-            const msgMasterKey = calcMsgMasterKeyB64(senderKey.skey, pair.recipientPKey);
-            this.keys.sendingPair = {
-                type: 'ratcheted',
-                pids: pair.pids,
-                recipientPKey: pair.recipientPKey,
-                senderKey: senderKey,
-                msgMasterKey,
-                timestamp: pair.timestamp
-            };
-        }
-        catch (err) {
-            throw (0, error_1.errWithCause)(err, "Public key in a given pair cannot be used");
-        }
-    }
-    /**
-     * @param pid
-     * @return pair for receiving messages and a role of a given pair.
-     * Undefined is returned when no pair were found.
-     */
-    getReceivingPair(pid) {
-        const pairs = this.keys.receptionPairs;
-        if (pairs.suggested && (pairs.suggested.pids.indexOf(pid) >= 0)) {
-            return {
-                pair: pairs.suggested,
-                role: 'suggested'
-            };
-        }
-        else if (pairs.inUse && (pairs.inUse.pids.indexOf(pid) >= 0)) {
-            return {
-                pair: pairs.inUse,
-                role: 'in_use'
-            };
-        }
-        else if (pairs.old && (pairs.old.pids.indexOf(pid) >= 0)) {
-            return {
-                pair: pairs.old,
-                role: 'old'
-            };
-        }
-        return; // explicit return of undefined
-    }
-    async getSendingPair(recipientIntroPKey) {
-        if (!this.keys.sendingPair) {
-            if (!recipientIntroPKey) {
-                throw new Error(`Sending pair for ${this.correspondent} is not set.`);
-            }
-            this.keys.sendingPair = {
-                type: 'intro',
-                recipientPKey: recipientIntroPKey
-            };
-        }
-        const p = this.keys.sendingPair;
-        let currentPair;
-        let msgMasterKey;
-        let msgCount;
-        if (p.type === 'intro') {
-            const senderKey = await (0, common_1.generateKeyPair)(this.random);
-            msgMasterKey = calcMsgMasterKey(senderKey.skey, p.recipientPKey);
-            currentPair = {
-                senderPKey: senderKey.pkey,
-                recipientKid: p.recipientPKey.kid
-            };
-            msgCount = 1;
-        }
-        else {
-            msgMasterKey = buffer_utils_1.base64.open(p.msgMasterKey);
-            msgCount = updateMsgCountInRatchetedSendingPair(p);
-            currentPair = { pid: selectPid(p) };
-        }
-        return { msgMasterKey, msgCount, currentPair };
-    }
-    toInfo() {
-        const { sendingPair: sp, receptionPairs: rp } = this.keys;
-        return {
-            sendingPair: (sp ? turnSendingPairToInfo(sp) : null),
-            receptionPairs: {
-                inUse: (rp.inUse ? turnReceptionPairToInfo(rp.inUse) : null),
-                old: (rp.old ? turnReceptionPairToInfo(rp.old) : null),
-                suggested: (rp.suggested ? turnReceptionPairToInfo(rp.suggested) : null)
-            }
-        };
-    }
-}
-exports.CorrespondentKeys = CorrespondentKeys;
-Object.freeze(CorrespondentKeys.prototype);
-Object.freeze(CorrespondentKeys);
-function toSuggestedPair(pair) {
-    const nextKeyPair = {
-        pids: pair.pids,
-        senderKid: pair.senderPKey.kid,
-        recipientPKey: pair.recipientKey.pkey,
-        isSenderIntroKey: pair.isSenderIntroKey,
-        timestamp: pair.timestamp
-    };
-    return nextKeyPair;
-}
-function selectPid(pair) {
-    if (pair.pids.length < 1) {
-        throw new Error("There are no pair ids in array.");
-    }
-    const i = Math.round((pair.pids.length - 1) * Math.random());
-    return pair.pids[i];
-}
-/**
- * This function updates message count and a timestamp in a given sending pair,
- * returning a message count to use for sending a new message.
- * @param p is a sending pair, in which changes should be done.
- */
-function updateMsgCountInRatchetedSendingPair(p) {
-    const lastTS = Date.now();
-    if (p.sentMsgs) {
-        p.sentMsgs.count += 1;
-        p.sentMsgs.lastTS = lastTS;
-    }
-    else {
-        p.sentMsgs = {
-            count: 1,
-            lastTS
-        };
-    }
-    return p.sentMsgs.count;
-}
-function turnSendingPairToInfo(sp) {
-    if (sp.type === 'ratcheted') {
-        const { pids, timestamp, sentMsgs } = sp;
-        return {
-            type: 'ratcheted',
-            recipientKId: sp.recipientPKey.kid,
-            senderKId: sp.senderKey.pkey.kid,
-            alg: sp.senderKey.pkey.alg,
-            pids,
-            timestamp,
-            sentMsgs
-        };
-    }
-    else if (sp.type === 'intro') {
-        return {
-            type: 'intro',
-            recipientKId: sp.recipientPKey.kid,
-            alg: sp.recipientPKey.alg
-        };
-    }
-    else {
-        return null;
-    }
-}
-function turnReceptionPairToInfo(rp) {
-    const { pids, timestamp, receivedMsgs, isSenderIntroKey } = rp;
-    return {
-        pids, timestamp, receivedMsgs, isSenderIntroKey,
-        alg: rp.recipientKey.pkey.alg,
-        recipientKId: rp.recipientKey.pkey.kid,
-        senderKId: rp.senderPKey.kid
-    };
-}
-Object.freeze(exports);

package/build/core/keyring/id-to-email-map.d.ts

@@ -1,38 +0,0 @@
-/**
- * This file contains functionality, used inside keyring.
- */
-/**
- * This is a one-to-many, one way map from string ids to string emails in a
- * canonical form.
- */
-export declare class IdToEmailMap {
-    private idToEmail;
-    constructor();
-    /**
-     * @param id
-     * @return undefined, if id is not known, or string with email, if there is
-     * one email registered for a given id, or an array of string emails, if
-     * more than one email registered for a given id.
-     */
-    getEmails(id: string): string[] | undefined;
-    /**
-     * @param id
-     * @param email
-     * @return true, if given id-email pair is successfully registered,
-     * and false, if such registration already existed.
-     */
-    addPair(id: string, email: string): boolean;
-    /**
-     * @param ids is an array of string ids, associated with a given email
-     * @param email
-     */
-    addPairs(ids: string[], email: string): void;
-    /**
-     * This removes given id-email pair.
-     * @param id
-     * @param email
-     * @return true, if pair was found and removed, and false, otherwise.
-     */
-    removePair(id: string, email: string): boolean;
-    removePairs(ids: string[], email: string): void;
-}

package/build/core/keyring/id-to-email-map.js

@@ -1,105 +0,0 @@
-"use strict";
-/*
- Copyright (C) 2015 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.IdToEmailMap = void 0;
-/**
- * This file contains functionality, used inside keyring.
- */
-/**
- * This is a one-to-many, one way map from string ids to string emails in a
- * canonical form.
- */
-class IdToEmailMap {
-    constructor() {
-        this.idToEmail = new Map();
-        Object.seal(this);
-    }
-    /**
-     * @param id
-     * @return undefined, if id is not known, or string with email, if there is
-     * one email registered for a given id, or an array of string emails, if
-     * more than one email registered for a given id.
-     */
-    getEmails(id) {
-        const emails = this.idToEmail.get(id);
-        if (emails) {
-            return emails.concat([]);
-        }
-        else {
-            return;
-        } // undefined in explicit statement
-    }
-    /**
-     * @param id
-     * @param email
-     * @return true, if given id-email pair is successfully registered,
-     * and false, if such registration already existed.
-     */
-    addPair(id, email) {
-        const emails = this.idToEmail.get(id);
-        if (emails) {
-            if (emails.includes(email)) {
-                return false;
-            }
-            emails.push(email);
-        }
-        else {
-            this.idToEmail.set(id, [email]);
-        }
-        return true;
-    }
-    /**
-     * @param ids is an array of string ids, associated with a given email
-     * @param email
-     */
-    addPairs(ids, email) {
-        for (let i = 0; i < ids.length; i += 1) {
-            this.addPair(ids[i], email);
-        }
-    }
-    /**
-     * This removes given id-email pair.
-     * @param id
-     * @param email
-     * @return true, if pair was found and removed, and false, otherwise.
-     */
-    removePair(id, email) {
-        let emails = this.idToEmail.get(id);
-        if (!emails) {
-            return false;
-        }
-        const emailInd = emails.indexOf(email);
-        if (emailInd < 0) {
-            return false;
-        }
-        emails = emails.splice(emailInd, 1);
-        if (emails.length === 0) {
-            this.idToEmail.delete(id);
-        }
-        return true;
-    }
-    removePairs(ids, email) {
-        for (let i = 0; i < ids.length; i += 1) {
-            this.removePair(ids[i], email);
-        }
-    }
-}
-exports.IdToEmailMap = IdToEmailMap;
-Object.freeze(IdToEmailMap);
-Object.freeze(IdToEmailMap.prototype);
-Object.freeze(exports);

package/build/core/keyring/keyring-storage.d.ts

@@ -1,9 +0,0 @@
-type WritableFS = web3n.files.WritableFS;
-export interface KeyringStorage {
-    load(): Promise<string | undefined>;
-    save(serialForm: string): void;
-    start(): Promise<void>;
-    close(): Promise<void>;
-}
-export declare function makeKeyringStorage(fs: WritableFS): KeyringStorage;
-export {};

package/build/core/keyring/keyring-storage.js

@@ -1,54 +0,0 @@
-"use strict";
-/*
- Copyright (C) 2018 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.makeKeyringStorage = makeKeyringStorage;
-const synced_1 = require("../../lib-common/processes/synced");
-const KEYRING_FNAME = 'keyring.json';
-function makeKeyringStorage(fs) {
-    const proc = new synced_1.SingleProc();
-    // initialization for code that works only with version 1
-    proc.start(async () => {
-        fs = await checkAndUpgradeDataToV1(fs);
-    });
-    const storage = {
-        save: (serialForm) => proc.startOrChain(() => fs.writeTxtFile(KEYRING_FNAME, serialForm)),
-        close: () => fs.close(),
-        start: async () => {
-            // XXX start watching keyring file
-        },
-        load: () => proc.startOrChain(() => fs.readTxtFile(KEYRING_FNAME).catch(notFoundOrReThrow))
-    };
-    return Object.freeze(storage);
-}
-/**
- * This is a catch callback, which returns undefined on file(folder) not found
- * exception, and re-throws all other exceptions/errors.
- */
-function notFoundOrReThrow(exc) {
-    if (!exc.notFound) {
-        throw exc;
-    }
-    return;
-}
-const VERSION_1_FOLDER_NAME = 'v1';
-async function checkAndUpgradeDataToV1(krFS) {
-    const v1FS = await krFS.writableSubRoot(VERSION_1_FOLDER_NAME);
-    // XXX can we have an upgrade from no version to version 1 ?
-    return v1FS;
-}
-Object.freeze(exports);

package/build/core/keyring/published-intro-key.d.ts

@@ -1,45 +0,0 @@
-import { ParamOnServer } from '../../lib-client/asmail/service-config';
-import { AsyncRNG } from '../../lib-common/rng-def';
-import { GetSigner } from '../id-manager';
-import { JWKeyPair, MsgKeyRole } from './common';
-type WritableFile = web3n.files.WritableFile;
-type IntroKeyCAP = web3n.keys.Keyrings['introKeyOnASMailServer'];
-export declare class PublishedIntroKey {
-    private readonly getSigner;
-    private readonly random;
-    private pkeyOnServer;
-    private published;
-    private readonly fileProc;
-    private periodicExpiryCheck;
-    private constructor();
-    static makeAndInit(file: WritableFile, getSigner: GetSigner, random: AsyncRNG, pkeyOnServer: ParamOnServer<'init-pub-key'>): Promise<PublishedIntroKey>;
-    private startExpiryCheckProcess;
-    close(): Promise<void>;
-    private onFileEvent;
-    private setFromJSON;
-    private toFileJSON;
-    private absorbRemoteChanges;
-    private makeNewIntroKey;
-    private update;
-    private retireCurrent;
-    /**
-     * This looks for a published key with a given key id. If it is found, an
-     * object is returned with following fields:
-     * - pair is JWK key pair;
-     * - role of a found key pair;
-     * - replacedAt field is present for a previously published key pair,
-     * telling, in milliseconds, when this key was superseded a newer one.
-     * Undefined is returned, when a key is not found.
-     * @param kid
-     * @return if key is found, object with following fields is returned:
-     */
-    find(kid: string): {
-        role: MsgKeyRole;
-        pair: JWKeyPair;
-        replacedAt?: number;
-    } | undefined;
-    makeIntroKeyCAP(): IntroKeyCAP;
-    private getCurrent;
-    private removeCurrent;
-}
-export {};