xotp/dist/secret.js

One-Time Password (HOTP/TOTP) library for Node.js, Deno and Bun, with support for Google Authenticator.

"use strict";
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var _Secret_instances, _Secret_buffer, _Secret_getRecommendedSizeFor;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Secret = void 0;
const node_crypto_1 = require("node:crypto");
const encoding_1 = require("./encoding");
class Secret {
    constructor({ data, algorithm, size = 160 / 8, } = {}) {
        _Secret_instances.add(this);
        _Secret_buffer.set(this, void 0);
        let buffer;
        if (data) {
            buffer = data;
        }
        else if (algorithm || size) {
            buffer = (0, node_crypto_1.randomBytes)((algorithm && __classPrivateFieldGet(this, _Secret_instances, "m", _Secret_getRecommendedSizeFor).call(this, algorithm)) || size);
        }
        else {
            throw new TypeError("Constructor arguments are not valid.");
        }
        __classPrivateFieldSet(this, _Secret_buffer, buffer, "f");
    }
    get buffer() {
        return __classPrivateFieldGet(this, _Secret_buffer, "f");
    }
    static for(algorithm) {
        return new Secret({ algorithm });
    }
    static from(data, encoding = "utf-8") {
        if (typeof data == "string") {
            if (encoding == "base32") {
                const bytes = (0, encoding_1.base32Decode)(data);
                return new Secret({ data: Buffer.from(bytes) });
            }
            return new Secret({ data: Buffer.from(data, encoding) });
        }
        return new Secret({ data });
    }
    toString(encoding = "base32") {
        if (encoding == "base32")
            return (0, encoding_1.base32Encode)(__classPrivateFieldGet(this, _Secret_buffer, "f"));
        return __classPrivateFieldGet(this, _Secret_buffer, "f").toString(encoding);
    }
}
exports.Secret = Secret;
_Secret_buffer = new WeakMap(), _Secret_instances = new WeakSet(), _Secret_getRecommendedSizeFor = function _Secret_getRecommendedSizeFor(algorithm) {
    let size = 256 / 8;
    // As defined in RFC 2104, the length of secret key should not be less than
    // the digest size but the extra length would not significantly increase
    // the function strength. See https://tools.ietf.org/html/rfc4226
    switch (algorithm) {
        case "sha1":
            size = 160 / 8;
            break;
        case "sha224":
        case "sha-512/224":
        case "sha3-224":
            size = 224 / 8;
            break;
        case "sha256":
        case "sha-512/256":
        case "sha3-256":
            size = 256 / 8;
            break;
        case "sha384":
        case "sha3-384":
            size = 384 / 8;
            break;
        case "sha512":
        case "sha3-512":
            size = 512 / 8;
            break;
    }
    return size;
};