eteres 0.0.1-security → 6.7.1

package/src.ts/wallet/utils.ts

@@ -0,0 +1,147 @@
+/**
+ *  @_ignore
+ */
+
+import {
+    getBytesCopy, assertArgument, toUtf8Bytes
+} from "../utils/index.js";
+
+export function looseArrayify(hexString: string): Uint8Array {
+    if (typeof(hexString) === "string" && !hexString.startsWith("0x")) {
+        hexString = "0x" + hexString;
+    }
+    return getBytesCopy(hexString);
+}
+
+export function zpad(value: String | number, length: number): String {
+    value = String(value);
+    while (value.length < length) { value = '0' + value; }
+    return value;
+}
+
+export function getPassword(password: string | Uint8Array): Uint8Array {
+    if (typeof(password) === 'string') {
+        return toUtf8Bytes(password, "NFKC");
+    }
+    return getBytesCopy(password);
+}
+
+export function spelunk<T>(object: any, _path: string): T {
+
+    const match = _path.match(/^([a-z0-9$_.-]*)(:([a-z]+))?(!)?$/i);
+    assertArgument(match != null, "invalid path", "path", _path);
+
+    const path = match[1];
+    const type = match[3];
+    const reqd = (match[4] === "!");
+
+    let cur = object;
+    for (const comp of path.toLowerCase().split('.')) {
+
+        // Search for a child object with a case-insensitive matching key
+        if (Array.isArray(cur)) {
+            if (!comp.match(/^[0-9]+$/)) { break; }
+            cur = cur[parseInt(comp)];
+
+        } else if (typeof(cur) === "object") {
+            let found: any = null;
+            for (const key in cur) {
+                 if (key.toLowerCase() === comp) {
+                     found = cur[key];
+                     break;
+                 }
+            }
+            cur = found;
+
+        } else {
+            cur = null;
+        }
+
+        if (cur == null) { break; }
+    }
+
+    assertArgument(!reqd || cur != null, "missing required value", "path", path);
+
+    if (type && cur != null) {
+        if (type === "int") {
+            if (typeof(cur) === "string" && cur.match(/^-?[0-9]+$/)) {
+                return <T><unknown>parseInt(cur);
+            } else if (Number.isSafeInteger(cur)) {
+                return cur;
+            }
+        }
+
+        if (type === "number") {
+            if (typeof(cur) === "string" && cur.match(/^-?[0-9.]*$/)) {
+                return <T><unknown>parseFloat(cur);
+            }
+        }
+
+        if (type === "data") {
+            if (typeof(cur) === "string") { return <T><unknown>looseArrayify(cur); }
+        }
+
+        if (type === "array" && Array.isArray(cur)) { return <T><unknown>cur; }
+        if (type === typeof(cur)) { return cur; }
+
+        assertArgument(false, `wrong type found for ${ type } `, "path", path);
+    }
+
+    return cur;
+}
+/*
+export function follow(object: any, path: string): null | string {
+    let currentChild = object;
+
+    for (const comp of path.toLowerCase().split('/')) {
+
+        // Search for a child object with a case-insensitive matching key
+        let matchingChild = null;
+        for (const key in currentChild) {
+             if (key.toLowerCase() === comp) {
+                 matchingChild = currentChild[key];
+                 break;
+             }
+        }
+
+        if (matchingChild === null) { return null; }
+
+        currentChild = matchingChild;
+    }
+
+    return currentChild;
+}
+
+// "path/to/something:type!"
+export function followRequired(data: any, path: string): string {
+    const value = follow(data, path);
+    if (value != null) { return value; }
+    return logger.throwArgumentError("invalid value", `data:${ path }`,
+    JSON.stringify(data));
+}
+*/
+// See: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4)
+/*
+export function uuidV4(randomBytes: BytesLike): string {
+    const bytes = getBytes(randomBytes, "randomBytes");
+
+    // Section: 4.1.3:
+    // - time_hi_and_version[12:16] = 0b0100
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+
+    // Section 4.4
+    // - clock_seq_hi_and_reserved[6] = 0b0
+    // - clock_seq_hi_and_reserved[7] = 0b1
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+
+    const value = hexlify(bytes);
+
+    return [
+       value.substring(2, 10),
+       value.substring(10, 14),
+       value.substring(14, 18),
+       value.substring(18, 22),
+       value.substring(22, 34),
+    ].join("-");
+}
+*/

package/src.ts/wallet/wallet.ts

@@ -0,0 +1,163 @@
+import { SigningKey } from "../crypto/index.js";
+import { assertArgument } from "../utils/index.js";
+
+import { BaseWallet } from "./base-wallet.js";
+import { HDNodeWallet } from "./hdwallet.js";
+import { decryptCrowdsaleJson, isCrowdsaleJson  } from "./json-crowdsale.js";
+import {
+    decryptKeystoreJson, decryptKeystoreJsonSync,
+    encryptKeystoreJson, encryptKeystoreJsonSync,
+    isKeystoreJson
+} from "./json-keystore.js";
+import { Mnemonic } from "./mnemonic.js";
+
+import type { ProgressCallback } from "../crypto/index.js";
+import type { Provider } from "../providers/index.js";
+
+import type { CrowdsaleAccount } from "./json-crowdsale.js";
+import type { KeystoreAccount } from "./json-keystore.js";
+
+
+function stall(duration: number): Promise<void> {
+    return new Promise((resolve) => { setTimeout(() => { resolve(); }, duration); });
+}
+
+/**
+ *  A **Wallet** manages a single private key which is used to sign
+ *  transactions, messages and other common payloads.
+ *
+ *  This class is generally the main entry point for developers
+ *  that wish to use a private key directly, as it can create
+ *  instances from a large variety of common sources, including
+ *  raw private key, [[link-bip-39]] mnemonics and encrypte JSON
+ *  wallets.
+ */
+export class Wallet extends BaseWallet {
+
+    /**
+     *  Create a new wallet for the private %%key%%, optionally connected
+     *  to %%provider%%.
+     */
+    constructor(key: string | SigningKey, provider?: null | Provider) {
+        if (typeof(key) === "string" && !key.startsWith("0x")) {
+            key = "0x" + key;
+        }
+
+        let signingKey = (typeof(key) === "string") ? new SigningKey(key): key;
+        super(signingKey, provider);
+    }
+
+    connect(provider: null | Provider): Wallet {
+        return new Wallet(this.signingKey, provider);
+    }
+
+    /**
+     *  Resolves to a [JSON Keystore Wallet](json-wallets) encrypted with
+     *  %%password%%.
+     *
+     *  If %%progressCallback%% is specified, it will receive periodic
+     *  updates as the encryption process progreses.
+     */
+    async encrypt(password: Uint8Array | string, progressCallback?: ProgressCallback): Promise<string> {
+        const account = { address: this.address, privateKey: this.privateKey };
+        return await encryptKeystoreJson(account, password, { progressCallback });
+    }
+
+    /**
+     *  Returns a [JSON Keystore Wallet](json-wallets) encryped with
+     *  %%password%%.
+     *
+     *  It is preferred to use the [async version](encrypt) instead,
+     *  which allows a [[ProgressCallback]] to keep the user informed.
+     *
+     *  This method will block the event loop (freezing all UI) until
+     *  it is complete, which may be a non-trivial duration.
+     */
+    encryptSync(password: Uint8Array | string): string {
+        const account = { address: this.address, privateKey: this.privateKey };
+        return encryptKeystoreJsonSync(account, password);
+    }
+
+    static #fromAccount(account: null | CrowdsaleAccount | KeystoreAccount): HDNodeWallet | Wallet {
+        assertArgument(account, "invalid JSON wallet", "json", "[ REDACTED ]");
+
+        if ("mnemonic" in account && account.mnemonic && account.mnemonic.locale === "en") {
+            const mnemonic = Mnemonic.fromEntropy(account.mnemonic.entropy);
+            const wallet = HDNodeWallet.fromMnemonic(mnemonic, account.mnemonic.path);
+            if (wallet.address === account.address && wallet.privateKey === account.privateKey) {
+                return wallet;
+            }
+            console.log("WARNING: JSON mismatch address/privateKey != mnemonic; fallback onto private key");
+        }
+
+        const wallet = new Wallet(account.privateKey);
+
+        assertArgument(wallet.address === account.address,
+            "address/privateKey mismatch", "json", "[ REDACTED ]");
+
+        return wallet;
+    }
+
+    /**
+     *  Creates (asynchronously) a **Wallet** by decrypting the %%json%%
+     *  with %%password%%.
+     *
+     *  If %%progress%% is provided, it is called periodically during
+     *  decryption so that any UI can be updated.
+     */
+    static async fromEncryptedJson(json: string, password: Uint8Array | string, progress?: ProgressCallback): Promise<HDNodeWallet | Wallet> {
+        let account: null | CrowdsaleAccount | KeystoreAccount = null;
+        if (isKeystoreJson(json)) {
+            account = await decryptKeystoreJson(json, password, progress);
+
+        } else if (isCrowdsaleJson(json)) {
+            if (progress) { progress(0); await stall(0); }
+            account = decryptCrowdsaleJson(json, password);
+            if (progress) { progress(1); await stall(0); }
+
+        }
+
+        return Wallet.#fromAccount(account);
+    }
+
+    /**
+     *  Creates a **Wallet** by decrypting the %%json%% with %%password%%.
+     *
+     *  The [[fromEncryptedJson]] method is preferred, as this method
+     *  will lock up and freeze the UI during decryption, which may take
+     *  some time.
+     */
+    static fromEncryptedJsonSync(json: string, password: Uint8Array | string): HDNodeWallet | Wallet {
+        let account: null | CrowdsaleAccount | KeystoreAccount = null;
+        if (isKeystoreJson(json)) {
+            account = decryptKeystoreJsonSync(json, password);
+        } else if (isCrowdsaleJson(json)) {
+            account = decryptCrowdsaleJson(json, password);
+        } else {
+            assertArgument(false, "invalid JSON wallet", "json", "[ REDACTED ]");
+        }
+
+        return Wallet.#fromAccount(account);
+    }
+
+    /**
+     *  Creates a new random [[HDNodeWallet]] using the avavilable
+     *  [cryptographic random source](randomBytes).
+     *
+     *  If there is no crytographic random source, this will throw.
+     */
+    static createRandom(provider?: null | Provider): HDNodeWallet {
+        const wallet = HDNodeWallet.createRandom();
+        if (provider) { return wallet.connect(provider); }
+        return wallet;
+    }
+
+    /**
+     *  Creates a [[HDNodeWallet]] for %%phrase%%.
+     */
+    static fromPhrase(phrase: string, provider?: Provider): HDNodeWallet {
+        const wallet = HDNodeWallet.fromPhrase(phrase);
+        if (provider) { return wallet.connect(provider); }
+        return wallet;
+    }
+}

package/src.ts/wordlists/bit-reader.ts

@@ -0,0 +1,35 @@
+const Base64 = ")!@#$%^&*(ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_";
+
+/**
+ *  @_ignore
+ */
+export function decodeBits(width: number, data: string): Array<number> {
+    const maxValue = (1 << width) - 1;
+    const result: Array<number> = [ ];
+    let accum = 0, bits = 0, flood = 0;
+    for (let i = 0; i < data.length; i++) {
+
+        // Accumulate 6 bits of data
+        accum = ((accum << 6) | Base64.indexOf(data[i]));
+        bits += 6;
+
+        // While we have enough for a word...
+        while (bits >= width) {
+            // ...read the word
+            const value = (accum >> (bits - width));
+            accum &= (1 << (bits - width)) - 1;
+            bits -= width;
+
+            // A value of 0 indicates we exceeded maxValue, it
+            // floods over into the next value
+            if (value === 0) {
+                flood += maxValue;
+            } else {
+                result.push(value + flood);
+                flood = 0;
+            }
+        }
+    }
+
+    return result;
+}

package/src.ts/wordlists/decode-owl.ts

@@ -0,0 +1,58 @@
+import { assertArgument } from "../utils/index.js";
+
+
+const subsChrs = " !#$%&'()*+,-./<=>?@[]^_`{|}~";
+const Word = /^[a-z]*$/i;
+
+function unfold(words: Array<string>, sep: string): Array<string> {
+    let initial = 97;
+    return words.reduce((accum, word) => {
+        if (word === sep) {
+            initial++;
+        } else if (word.match(Word)) {
+            accum.push(String.fromCharCode(initial) + word);
+        } else {
+            initial = 97;
+            accum.push(word);
+        }
+        return accum;
+    }, <Array<string>>[]);
+}
+
+/**
+ *  @_ignore
+ */
+export function decode(data: string, subs: string): Array<string> {
+
+    // Replace all the substitutions with their expanded form
+    for (let i = subsChrs.length - 1; i >= 0; i--) {
+        data = data.split(subsChrs[i]).join(subs.substring(2 * i, 2 * i + 2));
+    }
+
+    // Get all tle clumps; each suffix, first-increment and second-increment
+    const clumps: Array<string> = [ ];
+    const leftover = data.replace(/(:|([0-9])|([A-Z][a-z]*))/g, (all, item, semi, word) => {
+        if (semi) {
+            for (let i = parseInt(semi); i >= 0; i--) { clumps.push(";"); }
+        } else {
+            clumps.push(item.toLowerCase());
+        }
+        return "";
+    });
+    /* c8 ignore start */
+    if (leftover) { throw new Error(`leftovers: ${ JSON.stringify(leftover) }`); }
+    /* c8 ignore stop */
+
+    return unfold(unfold(clumps, ";"), ":");
+}
+
+/**
+ *  @_ignore
+ */
+export function decodeOwl(data: string): Array<string> {
+    assertArgument(data[0] === "0", "unsupported auwl data", "data", data);
+
+    return decode(
+        data.substring(1 + 2 * subsChrs.length),
+        data.substring(1, 1 + 2 * subsChrs.length));
+}

package/src.ts/wordlists/decode-owla.ts

@@ -0,0 +1,33 @@
+import { assertArgument } from "../utils/index.js";
+
+import { decodeBits } from "./bit-reader.js";
+import { decodeOwl } from "./decode-owl.js";
+
+/**
+ *  @_ignore
+ */
+export function decodeOwlA(data: string, accents: string): Array<string> {
+    let words = decodeOwl(data).join(",");
+
+    // Inject the accents
+    accents.split(/,/g).forEach((accent) => {
+
+        const match = accent.match(/^([a-z]*)([0-9]+)([0-9])(.*)$/);
+        assertArgument(match !== null, "internal error parsing accents", "accents", accents);
+
+        let posOffset = 0;
+        const positions = decodeBits(parseInt(match[3]), match[4]);
+        const charCode = parseInt(match[2]);
+        const regex = new RegExp(`([${ match[1] }])`, "g");
+        words = words.replace(regex, (all, letter) => {
+            const rem = --positions[posOffset];
+            if (rem === 0) {
+                letter = String.fromCharCode(letter.charCodeAt(0), charCode);
+                posOffset++;
+            }
+            return letter;
+        });
+    });
+
+    return words.split(",");
+}