{
  "version": 3,
  "sources": ["../src/util.ts"],
  "sourcesContent": ["import { webcrypto } from '@bicycle-codes/one-webcrypto'\nimport { fromString, concat, toString as uToString } from 'uint8arrays'\nimport type {\n    DID,\n    Msg,\n    HashAlg,\n    SymmKeyOpts,\n    SymmKey\n} from './types.js'\nimport {\n    KeyUse,\n    CharSize,\n} from './types.js'\nimport {\n    BASE58_DID_PREFIX,\n    RSA_SIGN_ALGORITHM,\n    RSA_ALGORITHM,\n    DEFAULT_HASH_ALGORITHM,\n    DEFAULT_CHAR_SIZE,\n    SALT_LENGTH,\n    RSA_HASHING_ALGORITHM,\n    RSA_DID_PREFIX,\n    KEY_TYPE,\n    EDWARDS_DID_PREFIX,\n    BLS_DID_PREFIX,\n    DEFAULT_SYMM_ALGORITHM,\n    DEFAULT_SYMM_LENGTH\n} from './constants.js'\n\n/**\n * Using the key type as the record property name (ie. string = key type)\n *\n * The magic bytes are the `code` found in {@link https://github.com/multiformats/multicodec/blob/master/table.csv}\n * encoded as a variable integer (more info about that at {@link https://github.com/multiformats/unsigned-varint)}.\n *\n * The key type is also found in that table.\n * It's the name of the codec minus the `-pub` suffix.\n *\n * Example\n * -------\n * Ed25519 public key\n * Key type: \"ed25519\"\n * Magic bytes: [ 0xed, 0x01 ]\n */\ntype KeyTypes = Record<string, {\n    magicBytes:Uint8Array\n    verify:(args:{\n        message: Uint8Array\n        publicKey: Uint8Array\n        signature: Uint8Array\n    }) => Promise<boolean>\n}>\n\nexport const did:{ keyTypes:KeyTypes } = {\n    keyTypes: {\n        'bls12-381': {\n            magicBytes: new Uint8Array([0xea, 0x01]),\n            verify: () => { throw new Error('Not implemented') },\n        },\n        rsa: {\n            magicBytes: new Uint8Array([0x00, 0xf5, 0x02]),\n            verify: rsaVerify,\n        },\n    }\n}\n\n/**\n * Create a 32 character, DNS-friendly hash of the given DID.\n *\n * @param {DID} did String representation of the DID for the device\n * @returns {string} The 32 character, DNS friendly hash\n */\nexport async function createDeviceName (did:DID):Promise<string> {\n    const normalizedDid = did.normalize('NFD')\n    const hashedUsername = await sha256(\n        new TextEncoder().encode(normalizedDid)\n    )\n    return uToString(hashedUsername, 'base32').slice(0, 32)\n}\n\nexport async function sha256 (bytes:Uint8Array):Promise<Uint8Array> {\n    return new Uint8Array(await webcrypto.subtle.digest('sha-256', bytes))\n}\n\n/**\n * Convert a public key to a DID format string.\n *\n * @param {Uint8Array|CryptoKey|CryptoKeyPair} publicKey Public key as Uint8Array\n * @param {'rsa'} [keyType] 'rsa' only\n * @returns {DID} A DID format string\n */\nexport async function publicKeyToDid (\n    _publicKey:Uint8Array|CryptoKey,\n    keyType = 'rsa'\n):Promise<DID> {\n    const publicKey = ((_publicKey instanceof CryptoKey) ?\n        new Uint8Array(await getPublicKeyAsArrayBuffer(_publicKey)) :\n        _publicKey\n    )\n\n    // Prefix public-write key\n    const prefix = did.keyTypes[keyType]?.magicBytes\n    if (!prefix) {\n        throw new Error(`Key type '${keyType}' not supported, ` +\n            `available types: ${Object.keys(did.keyTypes).join(', ')}`)\n    }\n\n    const prefixedBuf = concat([prefix, publicKey])\n\n    return (BASE58_DID_PREFIX + uToString(prefixedBuf, 'base58btc')) as DID\n}\n\nexport const rsaOperations = {\n    verify: async function rsaVerify (\n        msg:Msg,\n        sig:Msg,\n        publicKey:string|CryptoKey,\n        charSize:CharSize = DEFAULT_CHAR_SIZE,\n        hashAlg:HashAlg = DEFAULT_HASH_ALGORITHM\n    ):Promise<boolean> {\n        return webcrypto.subtle.verify(\n            {\n                name: RSA_SIGN_ALGORITHM,\n                saltLength: SALT_LENGTH\n            },\n            (typeof publicKey === 'string' ?\n                await importPublicKey(publicKey, hashAlg, KeyUse.Sign) :\n                publicKey),\n            normalizeBase64ToBuf(sig),\n            normalizeUnicodeToBuf(msg, charSize)\n        )\n    },\n\n    sign: async function sign (\n        msg:Msg,\n        privateKey:CryptoKey,\n        charSize:CharSize = DEFAULT_CHAR_SIZE\n    ):Promise<ArrayBuffer> {\n        return webcrypto.subtle.sign(\n            { name: RSA_SIGN_ALGORITHM, saltLength: SALT_LENGTH },\n            privateKey,\n            normalizeUnicodeToBuf(msg, charSize)\n        )\n    },\n\n    /**\n     * Encrypt the given AES key *to* a given public key.\n     */\n    encrypt: async function rsaEncrypt (\n        msg:Msg,\n        publicKey:string|CryptoKey|Uint8Array,\n        charSize:CharSize = DEFAULT_CHAR_SIZE,\n        hashAlg:HashAlg = DEFAULT_HASH_ALGORITHM\n    ):Promise<ArrayBuffer> {\n        let pubKey:CryptoKey\n        if (typeof publicKey === 'string') {\n            pubKey = await importPublicKey(publicKey, hashAlg, KeyUse.Encrypt)\n        } else {\n            pubKey = publicKey instanceof Uint8Array ?\n                await importPublicKey(publicKey, hashAlg, KeyUse.Encrypt) :\n                publicKey\n        }\n\n        return webcrypto.subtle.encrypt(\n            { name: RSA_ALGORITHM },\n            pubKey,\n            normalizeUnicodeToBuf(msg, charSize)\n        )\n    },\n\n    /**\n     * Use RSA to decrypt the given data.\n     */\n    decrypt: async function rsaDecrypt (\n        _data:Uint8Array|string|ArrayBuffer,\n        privateKey:CryptoKey|Uint8Array|ArrayBuffer\n    ):Promise<Uint8Array> {\n        const key = isCryptoKey(privateKey) ?\n            privateKey :\n            await importRsaKey(privateKey, ['decrypt'])\n\n        let data:Uint8Array|ArrayBuffer\n        if (typeof _data === 'string') {\n            data = fromString(_data, 'base64pad')\n        } else {\n            data = _data\n        }\n\n        const arrayBuffer = await webcrypto.subtle.decrypt(\n            { name: RSA_ALGORITHM },\n            key,\n            data\n        )\n\n        const arr = new Uint8Array(arrayBuffer)\n\n        return arr\n    }\n}\n\nexport async function rsaVerify ({\n    message,\n    publicKey,\n    signature\n}:{\n    message: Uint8Array\n    publicKey: Uint8Array\n    signature: Uint8Array\n}):Promise<boolean> {\n    return rsaOperations.verify(\n        message,\n        signature,\n        await webcrypto.subtle.importKey(\n            'spki',\n            publicKey,\n            { name: RSA_SIGN_ALGORITHM, hash: RSA_HASHING_ALGORITHM },\n            false,\n            ['verify']\n        ),\n        8\n    )\n}\n\nexport async function importPublicKey (\n    base64Key:string|ArrayBuffer,\n    hashAlg:HashAlg,\n    use:KeyUse\n):Promise<CryptoKey> {\n    checkValidKeyUse(use)\n    const alg = (use === KeyUse.Encrypt ? RSA_ALGORITHM : RSA_SIGN_ALGORITHM)\n    const uses:KeyUsage[] = use === KeyUse.Encrypt ?\n        ['encrypt'] :\n        ['verify']\n    const buf = typeof base64Key === 'string' ?\n        base64ToArrBuf(stripKeyHeader(base64Key)) :\n        base64Key\n\n    return webcrypto.subtle.importKey('spki', buf, {\n        name: alg,\n        hash: { name: hashAlg }\n    }, true, uses)\n}\n\nexport const InvalidKeyUse = new Error(\"Invalid key use. Please use 'encryption' or 'signing\")\nexport const InvalidMaxValue = new Error('Max must be less than 256 and greater than 0')\n\nexport function checkValidKeyUse (use:KeyUse):void {\n    checkValid(use, [KeyUse.Sign, KeyUse.Encrypt], InvalidKeyUse)\n}\n\nfunction checkValid<T> (toCheck: T, opts: T[], error: Error): void {\n    const match = opts.some(opt => opt === toCheck)\n    if (!match) {\n        throw error\n    }\n}\n\nfunction stripKeyHeader (base64Key:string):string {\n    return base64Key\n        .replace('-----BEGIN PUBLIC KEY-----\\n', '')\n        .replace('\\n-----END PUBLIC KEY-----', '')\n}\n\nexport function base64ToArrBuf (string:string):ArrayBuffer {\n    return fromString(string, 'base64pad').buffer\n}\n\nexport const normalizeToBuf = (\n    msg:Msg,\n    strConv:(str:string)=>ArrayBuffer\n):ArrayBuffer => {\n    if (typeof msg === 'string') {\n        return strConv(msg)\n    } else if (typeof msg === 'object' && msg.byteLength !== undefined) {\n        // this is the best runtime check I could find for ArrayBuffer/Uint8Array\n        const temp = new Uint8Array(msg)\n        return temp.buffer\n    } else {\n        throw new Error('Improper value. Must be a string, ArrayBuffer, Uint8Array')\n    }\n}\n\nexport function normalizeBase64ToBuf (msg:Msg):ArrayBuffer {\n    return normalizeToBuf(msg, base64ToArrBuf)\n}\n\nexport const normalizeUtf8ToBuf = (msg:Msg): ArrayBuffer => {\n    return normalizeToBuf(msg, (str) => strToArrBuf(str, CharSize.B8))\n}\n\nexport function strToArrBuf (str:string, charSize:CharSize):ArrayBuffer {\n    const view = charSize === 8 ?\n        new Uint8Array(str.length) :\n        new Uint16Array(str.length)\n\n    for (let i = 0, strLen = str.length; i < strLen; i++) {\n        view[i] = str.charCodeAt(i)\n    }\n\n    return view.buffer\n}\n\nexport const normalizeUtf16ToBuf = (msg:Msg): ArrayBuffer => {\n    return normalizeToBuf(msg, (str) => strToArrBuf(str, CharSize.B16))\n}\n\nexport function normalizeUnicodeToBuf (msg:Msg, charSize:CharSize) {\n    switch (charSize) {\n        case 8: return normalizeUtf8ToBuf(msg)\n        default: return normalizeUtf16ToBuf(msg)\n    }\n}\n\nexport function importRsaKey (\n    key:Uint8Array|ArrayBuffer,\n    keyUsages:KeyUsage[]\n):Promise<CryptoKey> {\n    return webcrypto.subtle.importKey(\n        'spki',\n        key,\n        { name: RSA_ALGORITHM, hash: RSA_HASHING_ALGORITHM },\n        false,\n        keyUsages\n    )\n}\n\nexport function isCryptoKey (val:unknown):val is CryptoKey {\n    return (\n        hasProp(val, 'algorithm') &&\n        hasProp(val, 'extractable') &&\n        hasProp(val, 'type')\n    )\n}\n\nfunction hasProp<K extends PropertyKey> (\n    data:unknown,\n    prop:K\n): data is Record<K, unknown> {\n    return (typeof data === 'object' && data != null && prop in data)\n}\n\nexport async function getPublicKeyAsArrayBuffer (\n    keypair:CryptoKeyPair|CryptoKey\n):Promise<ArrayBuffer> {\n    const spki = (keypair instanceof CryptoKey ?\n        await webcrypto.subtle.exportKey(\n            'spki',\n            keypair\n        ) :\n        await webcrypto.subtle.exportKey(\n            'spki',\n            keypair.publicKey\n        )\n    )\n\n    return spki\n}\n\nexport async function getPublicKeyAsUint8Array (\n    keypair:CryptoKeyPair|CryptoKey\n):Promise<Uint8Array> {\n    const arr = await getPublicKeyAsArrayBuffer(keypair)\n    return new Uint8Array(arr)\n}\n\nexport function didToPublicKey (did:string):({\n    publicKey:Uint8Array,\n    type:'rsa' | 'ed25519' | 'bls12-381'\n}) {\n    if (!did.startsWith(BASE58_DID_PREFIX)) {\n        throw new Error(\n            'Please use a base58-encoded DID formatted `did:key:z...`')\n    }\n\n    const didWithoutPrefix = ('' + did.substring(BASE58_DID_PREFIX.length))\n    const magicalBuf = fromString(didWithoutPrefix, 'base58btc')\n    const { keyBuffer, type } = parseMagicBytes(magicalBuf)\n\n    return {\n        publicKey: new Uint8Array(keyBuffer),\n        type\n    }\n}\n\n/**\n * Parse magic bytes on prefixed key-buffer\n * to determine cryptosystem & the unprefixed key-buffer.\n */\nfunction parseMagicBytes (prefixedKey:ArrayBuffer) {\n    // RSA\n    if (hasPrefix(prefixedKey, RSA_DID_PREFIX)) {\n        return {\n            keyBuffer: prefixedKey.slice(RSA_DID_PREFIX.byteLength),\n            type: KEY_TYPE.RSA\n        }\n    // EDWARDS\n    } else if (hasPrefix(prefixedKey, EDWARDS_DID_PREFIX)) {\n        return {\n            keyBuffer: prefixedKey.slice(EDWARDS_DID_PREFIX.byteLength),\n            type: KEY_TYPE.Edwards\n        }\n    // BLS\n    } else if (hasPrefix(prefixedKey, BLS_DID_PREFIX)) {\n        return {\n            keyBuffer: prefixedKey.slice(BLS_DID_PREFIX.byteLength),\n            type: KEY_TYPE.BLS\n        }\n    }\n\n    throw new Error('Unsupported key algorithm. Try using RSA.')\n}\n\nconst arrBufs = {\n    equal: (aBuf:ArrayBuffer, bBuf:ArrayBuffer) => {\n        const a = new Uint8Array(aBuf)\n        const b = new Uint8Array(bBuf)\n        if (a.length !== b.length) return false\n        for (let i = 0; i < a.length; i++) {\n            if (a[i] !== b[i]) return false\n        }\n        return true\n    }\n}\n\nfunction hasPrefix (prefixedKey:ArrayBuffer, prefix:ArrayBuffer) {\n    return arrBufs.equal(prefix, prefixedKey.slice(0, prefix.byteLength))\n}\n\nexport function toBase64 (arr:Uint8Array|ArrayBuffer) {\n    return uToString(\n        arr instanceof ArrayBuffer ?\n            new Uint8Array(arr) :\n            arr,\n        'base64pad'\n    )\n}\n\nexport function fromBase64 (str:string) {\n    return fromString(str, 'base64pad')\n}\n\nexport async function importKey (\n    key:string|Uint8Array,\n    opts?:Partial<SymmKeyOpts>\n):Promise<SymmKey> {\n    const buf = typeof key === 'string' ? base64ToArrBuf(key) : key\n\n    return webcrypto.subtle.importKey(\n        'raw',\n        buf,\n        {\n            name: opts?.alg || DEFAULT_SYMM_ALGORITHM,\n            length: opts?.length || DEFAULT_SYMM_LENGTH,\n        },\n        true,\n        ['encrypt', 'decrypt']\n    )\n}\n\nexport function randomBuf (\n    length:number,\n    { max }:{ max:number } = { max: 255 }\n):ArrayBuffer {\n    if (max < 1 || max > 255) {\n        throw InvalidMaxValue\n    }\n\n    const arr = new Uint8Array(length)\n\n    if (max === 255) {\n        webcrypto.getRandomValues(arr)\n        return arr.buffer\n    }\n\n    let index = 0\n    const interval = max + 1\n    const divisibleMax = Math.floor(256 / interval) * interval\n    const tmp = new Uint8Array(1)\n\n    while (index < arr.length) {\n        webcrypto.getRandomValues(tmp)\n        if (tmp[0] < divisibleMax) {\n            arr[index] = tmp[0] % interval\n            index++\n        }\n    }\n\n    return arr.buffer\n}\n\nexport function joinBufs (fst:ArrayBuffer, snd:ArrayBuffer):ArrayBuffer {\n    const view1 = new Uint8Array(fst)\n    const view2 = new Uint8Array(snd)\n    const joined = new Uint8Array(view1.length + view2.length)\n    joined.set(view1)\n    joined.set(view2, view1.length)\n    return joined.buffer\n}\n"],
  "mappings": "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",
  "names": ["rsaVerify", "rsaVerify", "did", "uToString"]
}