@alkimia/framework 0.1.0

package/components/mocked-services/node_modules/@otplib/core/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Gerald Yeo <contact@fusedthought.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/components/mocked-services/node_modules/@otplib/core/README.md

@@ -0,0 +1,131 @@
+# @otplib/core
+
+> Provides core methods for hotp, totp and authenticator.
+
+<!-- TOC depthFrom:2 -->
+
+- [Getting Started](#getting-started)
+  - [Install the Package](#install-the-package)
+  - [Choose Your Plugins](#choose-your-plugins)
+    - [Adding Crypto](#adding-crypto)
+    - [Adding Base32](#adding-base32)
+  - [Initialise your Instance](#initialise-your-instance)
+    - [Using Classes](#using-classes)
+    - [Using Functions](#using-functions)
+- [Available Options](#available-options)
+- [License](#license)
+
+<!-- /TOC -->
+
+## Getting Started
+
+This is the full setup guide for installing, configuring and customising
+your dependencies for the library.
+
+> Check out the [Quick Start Guide][docs-quick-start] instead for easier
+> setup especially if you do not need to use any custom base32 / crypto libraries.
+
+### Install the Package
+
+```bash
+npm install @otplib/core
+```
+
+### Choose Your Plugins
+
+#### Adding Crypto
+
+The crypto modules are used to generate the digest used to derive the OTP tokens from.
+By default, Node.js has inbuilt `crypto` functionality, but you might want to replace it
+for certain environments that do not support it.
+
+Currently there are a few crypto plugins available from this project.
+Install one of them. eg: `npm install @otplib/plugin-crypto`
+
+Refer to the [crypto plugins list][docs-plugins-crypto],
+or search for [otplib-plugin crypto][link-npm-search-crypto] on `npm`.
+
+#### Adding Base32
+
+If you're using `Google Authenticator`, you'll need a base32 module for
+encoding and decoding your secrets.
+
+Currently, there are a few base32 plugins available from this project.
+Install one of them. eg: `npm install @otplib/plugin-thirty-two`
+
+Refer to the [base32 plugin list][docs-plugins-base32],
+or search for [otplib-plugin base32][link-npm-search-base32] on `npm`.
+
+### Initialise your Instance
+
+#### Using Classes
+
+```js
+import { HOTP, TOTP, Authenticator } from '@otplib/core';
+
+import { keyDecoder, keyEncoder } from '@otplib/plugin-thirty-two'; // use your chosen base32 plugin
+import { createDigest, createRandomBytes } from '@otplib/plugin-crypto'; // use your chosen crypto plugin
+
+// Setup an OTP instance which you need
+const hotp = new HOTP({ createDigest });
+const totp = new TOTP({ createDigest });
+const authenticator = new Authenticator({
+  createDigest,
+  createRandomBytes,
+  keyDecoder,
+  keyEncoder
+});
+
+// Go forth and generate tokens
+const token = hotp.generate(YOUR_SECRET, 0);
+const token = totp.generate(YOUR_SECRET);
+const token = authenticator.generate(YOUR_SECRET);
+```
+
+#### Using Functions
+
+Alternatively, if you are using the functions directly instead of the classes,
+pass these as options into the functions.
+
+```js
+import {
+  hotpOptions,
+  hotpToken,
+  totpOptions,
+  totpToken,
+  authenticatorOptions,
+  authenticatorToken
+} from 'otplib/core';
+
+// As with classes, import your desired Base32 Plugin and Crypto Plugin.
+// import ...
+
+// Go forth and generate tokens
+const token = hotpToken(YOUR_SECRET, 0, hotpOptions({ createDigest }));
+const token = totpToken(YOUR_SECRET, totpOptions({ createDigest }));
+const token = authenticatorToken(
+  YOUR_SECRET,
+  authenticatorOptions({
+    createDigest,
+    createRandomBytes,
+    keyDecoder,
+    keyEncoder
+  })
+);
+```
+
+## Available Options
+
+Please refer to the [Options Guide][docs-options].
+
+## License
+
+`@otplib/core` is [MIT licensed][project-license]
+
+[link-npm-search-base32]: https://www.npmjs.com/search?q=otplib-plugin%20base32
+[link-npm-search-crypto]: https://www.npmjs.com/search?q=otplib-plugin%20crypto
+[docs-options]: https://github.com/yeojz/otplib/blob/master/README.md#available-options
+[docs-plugins-base32]: https://github.com/yeojz/otplib/blob/master/packages/README.md#plugins---base32
+[docs-plugins-crypto]: https://github.com/yeojz/otplib/blob/master/packages/README.md#plugins---crypto
+[docs-quick-start]: https://github.com/yeojz/otplib/blob/master/README.md#quick-start
+[project-license]: https://github.com/yeojz/otplib/blob/master/LICENSE

package/components/mocked-services/node_modules/@otplib/core/authenticator.d.ts

@@ -0,0 +1,145 @@
+import { KeyEncodings, SecretKey } from './utils';
+import { TOTP, TOTPOptions } from './totp';
+/**
+ * RFC4648 / RFC3548 Base32 String.
+ *
+ * Other Base32 encoding methods like Crockford's Base32
+ * will not be compatible with Google Authenticator.
+ */
+export declare type Base32SecretKey = SecretKey;
+/**
+ * Interface method for [[AuthenticatorOptions.keyEncoder]].
+ */
+export interface KeyEncoder<T = Base32SecretKey> {
+    (secret: SecretKey, encoding: KeyEncodings): T;
+}
+/**
+ * Interface method for [[AuthenticatorOptions.keyDecoder]].
+ */
+export interface KeyDecoder<T = SecretKey> {
+    (encodedSecret: Base32SecretKey, encoding: KeyEncodings): T;
+}
+/**
+ * Interface method for [[AuthenticatorOptions.createRandomBytes]].
+ */
+export interface CreateRandomBytes<T = string> {
+    (size: number, encoding: KeyEncodings): T;
+}
+/**
+ * Interface for options used in Authenticator.
+ *
+ * Contains additional options in addition to
+ * those within TOTP.
+ */
+export interface AuthenticatorOptions<T = string> extends TOTPOptions<T> {
+    /**
+     * Encodes a secret key into a Base32 string before it is
+     * sent to the user (in QR Code etc).
+     */
+    keyEncoder: KeyEncoder<T>;
+    /**
+     * Decodes the Base32 string given by the user into a secret.
+     * */
+    keyDecoder: KeyDecoder<T>;
+    /**
+     * Creates a random string containing the defined number of
+     * bytes to be used in generating a secret key.
+     */
+    createRandomBytes: CreateRandomBytes<T>;
+}
+/**
+ * Validates the given [[AuthenticatorOptions]].
+ */
+export declare function authenticatorOptionValidator<T extends AuthenticatorOptions<unknown> = AuthenticatorOptions<unknown>>(options: Partial<T>): void;
+/**
+ * Returns a set of default options for authenticator at the current epoch.
+ */
+export declare function authenticatorDefaultOptions<T extends AuthenticatorOptions<unknown> = AuthenticatorOptions<unknown>>(): Partial<T>;
+/**
+ * Takes an Authenticator Option object and provides presets for
+ * some of the missing required Authenticator option fields and validates
+ * the resultant options.
+ */
+export declare function authenticatorOptions<T extends AuthenticatorOptions<unknown> = AuthenticatorOptions<unknown>>(opt: Partial<T>): Readonly<T>;
+/**
+ * Encodes a given secret key into a Base32 secret
+ * using a [[KeyEncoder]] method set in the options.
+ *
+ * @param secret - The [[SecretKey]] to encode into a [[Base32SecretKey]]
+ * @param options - An [[AuthenticatorOptions]] object
+ */
+export declare function authenticatorEncoder<T extends AuthenticatorOptions<unknown> = AuthenticatorOptions<unknown>>(secret: SecretKey, options: Pick<T, 'keyEncoder' | 'encoding'>): ReturnType<T['keyEncoder']>;
+/**
+ * Decodes a given Base32 secret to a secret key
+ * using a [[KeyDecoder]] method set in the options.
+ *
+ * @param secret - The [[Base32SecretKey]] to decode
+ * @param options - An [[AuthenticatorOptions]] object
+ */
+export declare function authenticatorDecoder<T extends AuthenticatorOptions<unknown> = AuthenticatorOptions<unknown>>(secret: Base32SecretKey, options: Pick<T, 'keyDecoder' | 'encoding'>): ReturnType<T['keyDecoder']>;
+/**
+ * Generates a random Base32 Secret Key.
+ *
+ * @param numberOfBytes - Number of bytes per secret key
+ * @param options.createRandomBytes
+ * @param options.encoding
+ * @param options.keyEncoder
+ */
+export declare function authenticatorGenerateSecret<T extends AuthenticatorOptions = AuthenticatorOptions>(numberOfBytes: number, options: Pick<T, 'keyEncoder' | 'encoding' | 'createRandomBytes'>): Base32SecretKey;
+/**
+ * Generates the Authenticator based token.
+ *
+ * tl;dr: Authenticator = TOTP + Base32 Secret
+ *
+ * **References**
+ *
+ * -   https://en.wikipedia.org/wiki/Google_Authenticator
+ *
+ * @param secret - [[Base32SecretKey]]
+ * @param options - An [[AuthenticatorOptions]] object.
+ */
+export declare function authenticatorToken<T extends AuthenticatorOptions = AuthenticatorOptions>(secret: Base32SecretKey, options: Readonly<T>): string;
+/**
+ * Decodes the encodedSecret and passes it to [[totpCheckWithWindow]]
+ *
+ * @param token - The token to check
+ * @param secret - The [[Base32SecretKey]]
+ * @param options - An [[AuthenticatorOptions]] object.
+ */
+export declare function authenticatorCheckWithWindow<T extends AuthenticatorOptions = AuthenticatorOptions>(token: string, secret: Base32SecretKey, options: Readonly<T>): number | null;
+/**
+ * A class wrapper containing all Authenticator methods.
+ */
+export declare class Authenticator<T extends AuthenticatorOptions<string> = AuthenticatorOptions<string>> extends TOTP<T> {
+    /**
+     * Creates a new instance with all defaultOptions and options reset.
+     */
+    create(defaultOptions?: Partial<T>): Authenticator<T>;
+    /**
+     * Returns a set of options at the current moment,
+     * polyfilled with some of the missing required options.
+     *
+     * Refer to [[authenticatorOptions]]
+     */
+    allOptions(): Readonly<T>;
+    /**
+     * Reference: [[authenticatorToken]]
+     */
+    generate(secret: Base32SecretKey): string;
+    /**
+     * Reference: [[authenticatorCheckWithWindow]]
+     */
+    checkDelta(token: string, secret: Base32SecretKey): number | null;
+    /**
+     * Reference: [[authenticatorEncoder]]
+     */
+    encode(secret: SecretKey): Base32SecretKey;
+    /**
+     * Reference: [[authenticatorDecoder]]
+     */
+    decode(secret: Base32SecretKey): SecretKey;
+    /**
+     * Reference: [[authenticatorGenerateSecret]]
+     */
+    generateSecret(numberOfBytes?: number): Base32SecretKey;
+}

package/components/mocked-services/node_modules/@otplib/core/hotp.d.ts

@@ -0,0 +1,128 @@
+import { CreateDigest, CreateHmacKey, HashAlgorithms, HexString, KeyEncodings, OTP, OTPOptions, SecretKey } from './utils';
+/**
+ * Interface for options used in HOTP.
+ */
+export interface HOTPOptions<T = string> extends OTPOptions {
+    /**
+     * Creates the digest which token is derived from.
+     */
+    createDigest: CreateDigest<T>;
+    /**
+     * Formats the secret into a HMAC key, applying transformations (like padding) where needed
+     */
+    createHmacKey: CreateHmacKey<T>;
+    /**
+     * The algorithm used for calculating the HMAC.
+     */
+    algorithm: HashAlgorithms;
+    /**
+     * **USE WITH CAUTION:** Given the same digest, the same token will be received.
+     *
+     * This is provided for unique use cases. For example, digest generation might
+     * depend on an async API.
+     */
+    digest?: HexString;
+    /**
+     * The number of digits a token will have. Usually 6 or 8.
+     */
+    digits: number;
+    /**
+     * The encoding that was used on the secret.
+     */
+    encoding: KeyEncodings;
+}
+/**
+ * Validates the given [[HOTPOptions]]
+ */
+export declare function hotpOptionsValidator<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(options: Readonly<Partial<T>>): void;
+/**
+ * Takes a HOTP secret and derives the HMAC key
+ * for use in token generation.
+ *
+ * @param algorithm - Reference: [[HOTPOptions.algorithm]]
+ * @param secret
+ * @param encoding - Reference: [[HOTPOptions.encoding]]
+ */
+export declare const hotpCreateHmacKey: CreateHmacKey;
+/**
+ * Returns the default options for HOTP
+ */
+export declare function hotpDefaultOptions<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(): Partial<T>;
+/**
+ * Takes an HOTP Option object and provides presets for
+ * some of the missing required HOTP option fields and validates
+ * the resultant options.
+ */
+export declare function hotpOptions<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(opt: Readonly<Partial<T>>): Readonly<T>;
+/**
+ * Formats a given counter into a string counter.
+ */
+export declare function hotpCounter(counter: number): HexString;
+/**
+ * Converts a digest to a token of a specified length.
+ */
+export declare function hotpDigestToToken(hexDigest: HexString, digits: number): string;
+/**
+ * Generates a HMAC-based One-time Token (HOTP)
+ *
+ * **References**
+ *
+ * -   http://en.wikipedia.org/wiki/HMAC-based_One-time_Password_Algorithm
+ * -   http://tools.ietf.org/html/rfc4226
+ *
+ * **Note**: If options.digest is provided, it will skip digest generation.
+ * Use options.digest with caution. Same digest = Same token.
+ *
+ * @param secret - Your secret key.
+ * @param counter - the OTP counter (usually it's an incremental count)
+ * @param options - A HOTPOptions object.
+ */
+export declare function hotpToken<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(secret: SecretKey, counter: number, options: Readonly<T>): string;
+/**
+ * Checks the given token against the system generated token.
+ *
+ * **Note**: Token is valid only if it is a number string
+ */
+export declare function hotpCheck<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(token: string, secret: SecretKey, counter: number, options: Readonly<T>): boolean;
+/**
+ * Generates a [keyuri](../#keyuri) from options provided
+ * and it's type set to HOTP.
+ */
+export declare function hotpKeyuri<T extends HOTPOptions<unknown> = HOTPOptions<unknown>>(accountName: string, issuer: string, secret: SecretKey, counter: number, options: Readonly<T>): string;
+/**
+ * A class wrapper containing all HOTP methods.
+ */
+export declare class HOTP<T extends HOTPOptions = HOTPOptions> extends OTP<T> {
+    /**
+     * Creates a new instance with all defaultOptions and options reset.
+     */
+    create(defaultOptions?: Partial<T>): HOTP<T>;
+    /**
+     * Returns class options polyfilled with some of
+     * the missing required options.
+     *
+     * Reference: [[hotpOptions]]
+     */
+    allOptions(): Readonly<T>;
+    /**
+     * Reference: [[hotpToken]]
+     */
+    generate(secret: SecretKey, counter: number): string;
+    /**
+     * Reference: [[hotpCheck]]
+     */
+    check(token: string, secret: SecretKey, counter: number): boolean;
+    /**
+     * Same as [[check]] but accepts a single object based argument.
+     */
+    verify(opts: {
+        token: string;
+        secret: SecretKey;
+        counter: number;
+    }): boolean;
+    /**
+     * Calls [keyuri](../#keyuri) with class options and type
+     * set to HOTP.
+     */
+    keyuri(accountName: string, issuer: string, secret: SecretKey, counter: number): string;
+}

package/components/mocked-services/node_modules/@otplib/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from './utils';
+export * from './hotp';
+export * from './totp';
+export * from './authenticator';