@h3ravel/hashing 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,435 @@
+/// <reference path="./app.globals.d.ts" />
+//#region src/Contracts/ManagerContract.d.ts
+type HashAlgorithm = 'bcrypt' | 'argon' | 'argon2id';
+interface Configuration {
+  [key: string]: any;
+  /**
+   * Default Hash Driver
+   * -------------------
+   * This option controls the default hash driver that will be used to hash
+   * passwords for your application. By default, the bcrypt algorithm is
+   * used; however, you remain free to modify this option if you wish.
+   */
+  driver: HashAlgorithm;
+  /**
+   * Bcrypt Options
+   * --------------
+   * Here you may specify the configuration options that should be used when
+   * passwords are hashed using the Bcrypt algorithm. This will allow you
+   * to control the amount of time it takes to hash the given password.
+   */
+  bcrypt: {
+    rounds: number;
+    verify: boolean;
+    limit: number | null;
+  };
+  /**
+   * Argon Options
+   * -------------
+   * Here you may specify the configuration options that should be used when
+   * passwords are hashed using the Argon algorithm. These will allow you
+   * to control the amount of time it takes to hash the given password.
+   */
+  argon: {
+    memory: number;
+    threads: number;
+    time: number;
+    verify: boolean;
+  };
+}
+type Options = Partial<Configuration['bcrypt'] & Configuration['argon']>;
+interface BcryptOptions {
+  cost: number;
+}
+interface Argon2Options {
+  memoryCost: number;
+  timeCost: number;
+  threads: number;
+}
+interface UnknownOptions {
+  [key: string]: any;
+}
+interface Info {
+  algo: number;
+  algoName: HashAlgorithm;
+  options: {
+    cost?: number | undefined;
+    memoryCost?: number | undefined;
+    timeCost?: number | undefined;
+    threads?: number | undefined;
+    [key: string]: number | undefined;
+  };
+}
+//#endregion
+//#region src/Drivers/AbstractHasher.d.ts
+declare abstract class AbstractHasher {
+  /**
+   * Get information about the given hashed value.
+   *
+   * @param  hashedValue
+   * @returns
+   */
+  info(hashedValue: string): Info;
+}
+//#endregion
+//#region src/Drivers/Argon2idHasher.d.ts
+declare class Argon2idHasher extends AbstractHasher {
+  private memory;
+  private verifyAlgorithm;
+  private threads;
+  private time;
+  constructor(options?: Configuration["argon"]);
+  /**
+   * Hash the given value using Argon2id.
+   */
+  make(value: string, options?: Configuration["argon"]): Promise<string>;
+  /**
+   * Check the given plain value against a hash.
+   */
+  check(value: string, hashedValue?: string | null, _options?: Configuration["argon"]): Promise<boolean>;
+  /**
+   * Get information about the given hashed value.
+   */
+  info(hashedValue: string): Info;
+  /**
+   * Check if the given hash needs to be rehashed based on current options.
+   */
+  needsRehash(hashedValue: string, options?: Configuration["argon"]): boolean;
+  /**
+   * Verify that the hash configuration does not exceed the configured limits.
+   */
+  verifyConfiguration(hashedValue: string): boolean;
+  /**
+   * Verify the hashed value's options.
+   */
+  protected isUsingValidOptions(hashedValue: string): boolean;
+  /**
+   * Verify the hashed value's algorithm.
+   */
+  protected isUsingCorrectAlgorithm(hashedValue: string): boolean;
+  /**
+   * Extract Argon parameters from the hash.
+   */
+  protected parseInfo(hashedValue: string): Record<string, number | undefined>;
+}
+//#endregion
+//#region src/Drivers/ArgonHasher.d.ts
+declare class ArgonHasher extends AbstractHasher {
+  private memory;
+  private verifyAlgorithm;
+  private threads;
+  private time;
+  constructor(options?: Configuration["argon"]);
+  /**
+   * Hash the given value using Argon2i.
+   */
+  make(value: string, options?: Configuration["argon"]): Promise<string>;
+  /**
+   * Check the given plain value against a hash.
+   */
+  check(value: string, hashedValue?: string | null, _options?: Configuration["argon"]): Promise<boolean>;
+  /**
+   * Get information about the given hashed value.
+   */
+  info(hashedValue: string): Info;
+  /**
+   * Check if the given hash needs to be rehashed based on current options.
+   */
+  needsRehash(hashedValue: string, options?: Configuration["argon"]): boolean;
+  /**
+   * Verify that the hash configuration does not exceed the configured limits.
+   */
+  verifyConfiguration(hashedValue: string): boolean;
+  /**
+   * Verify the hashed value's options.
+   */
+  protected isUsingValidOptions(hashedValue: string): boolean;
+  /**
+   * Verify the hashed value's algorithm.
+   */
+  protected isUsingCorrectAlgorithm(hashedValue: string): boolean;
+  /**
+   * Extract Argon parameters from the hash.
+   */
+  protected parseInfo(hashedValue: string): Record<string, number | undefined>;
+}
+//#endregion
+//#region src/Drivers/BcryptHasher.d.ts
+declare class BcryptHasher extends AbstractHasher {
+  private rounds;
+  private verifyAlgorithm;
+  private limit;
+  constructor(options?: Configuration["bcrypt"]);
+  /**
+   * Hash the given value.
+   *
+   * @param  value
+   * @param  options
+   *
+   * @return {String}
+   */
+  make(value: string, options?: Configuration["bcrypt"]): Promise<string>;
+  /**
+   * Check the given plain value against a hash.
+   *
+   * @param  value
+   * @param  hashedValue
+   * @param  options
+   * @returns
+   */
+  check(value: string, hashedValue?: string | null, _options?: Configuration["bcrypt"]): Promise<boolean>;
+  /**
+   * Get information about the given hashed value.
+   *
+   * @param  hashedValue
+   *
+   * @return {Object}
+   */
+  info(hashedValue: string): Info;
+  /**
+   * Check if the given hash has been hashed using the given options.
+   *
+   * @param  hashedValue
+   * @param  options
+   *
+   * @return {Boolean}
+   */
+  needsRehash(hashedValue: string, options?: Configuration["bcrypt"]): boolean;
+  /**
+   * Verify the hashed value's options.
+   *
+   * @param  hashedValue
+   * @return
+   */
+  protected isUsingValidOptions(hashedValue: string): boolean;
+  /**
+   * Verifies that the configuration is less than or equal to what is configured.
+   *
+   * @private
+   */
+  verifyConfiguration(value: string): boolean;
+  /**
+   * Verify the hashed value's algorithm.
+   *
+   * @param  hashedValue
+   *
+   * @returns
+   */
+  protected isUsingCorrectAlgorithm(hashedValue: string): boolean;
+  /**
+   * Extract the cost value from the options object.
+   *
+   * @param  options
+   * @return int
+   */
+  protected cost(options?: Configuration["bcrypt"]): number;
+}
+//#endregion
+//#region src/Utils/Manager.d.ts
+declare abstract class Manager {
+  config: Configuration;
+  constructor(config?: Configuration);
+  abstract driver(): BcryptHasher | ArgonHasher | Argon2idHasher;
+  createBcryptDriver?(): BcryptHasher;
+  createArgonDriver?(): ArgonHasher;
+  createArgon2idDriver?(): Argon2idHasher;
+  /**
+   * Get the default driver name.
+   *
+   * @return string
+   */
+  getDefaultDriver(): HashAlgorithm;
+  protected createDriver(driver: HashAlgorithm): BcryptHasher | ArgonHasher | Argon2idHasher;
+  /**
+   * Determine if a given string is already hashed.
+   *
+   * @param  value
+   * @returns
+   */
+  isHashed(value: string): boolean;
+  /**
+   * Autoload config and initialize library
+   *
+   * @returns
+   */
+  init(basePath?: string): Promise<this>;
+}
+//#endregion
+//#region src/HashManager.d.ts
+declare class HashManager extends Manager {
+  private drivers;
+  /**
+   * Create an instance of the Bcrypt hash Driver.
+   *
+   * @return BcryptHasher
+   */
+  createBcryptDriver(): BcryptHasher;
+  /**
+   * Create an instance of the Argon hash Driver.
+   *
+   * @return ArgonHasher
+   */
+  createArgonDriver(): ArgonHasher;
+  /**
+   * Create an instance of the Argon2id hash Driver.
+   *
+   * @return Argon2idHasher
+   */
+  createArgon2idDriver(): Argon2idHasher;
+  /**
+   * Hash the given value.
+   *
+   * @param  value
+   * @param options
+   *
+   * @returns
+   */
+  make(value: string, options?: Options): Promise<string>;
+  /**
+   * Get information about the given hashed value.
+   *
+   * @param  hashedValue
+   * @returns
+   */
+  info(hashedValue: string): Info;
+  /**
+   * Check the given plain value against a hash.
+   *
+   * @param  value
+   * @param  hashedValue
+   * @param options
+   * @returns
+   */
+  check(value: string, hashedValue?: string, options?: Options): Promise<boolean>;
+  /**
+   * Check if the given hash has been hashed using the given options.
+   *
+   * @param  hashedValue
+   * @param options
+   * @returns
+   */
+  needsRehash(hashedValue: string, options?: Options): boolean;
+  /**
+   * Determine if a given string is already hashed.
+   *
+   * @param  string  value
+   * @returns
+   */
+  isHashed(value: string): boolean;
+  /**
+   * Verifies that the configuration is less than or equal to what is configured.
+   *
+   * @param  value
+   * @return bool
+   *
+   * @internal
+   */
+  verifyConfiguration(value: string): boolean;
+  /**
+   * Get a driver instance.
+   *
+   * @param  driver
+   *
+   * @returns
+   *
+   * @throws InvalidArgumentException
+   */
+  driver(driver?: HashAlgorithm): BcryptHasher | ArgonHasher | Argon2idHasher;
+}
+declare const defineConfig: (config: Configuration) => Configuration;
+//#endregion
+//#region src/Helpers.d.ts
+declare class Hash {
+  /**
+   * Hash the given value.
+   *
+   * @param  value
+   * @param options
+   *
+   * @returns
+   */
+  static make(value: string, options?: Options): any;
+  /**
+   * Get information about the given hashed value.
+   *
+   * @param  hashedValue
+   * @returns
+   */
+  static info(hashedValue: string): any;
+  /**
+   * Check the given plain value against a hash.
+   *
+   * @param  value
+   * @param  hashedValue
+   * @param options
+   * @returns
+   */
+  static check(value: string, hashedValue?: string, options?: Options): any;
+  /**
+   * Check if the given hash has been hashed using the given options.
+   *
+   * @param  hashedValue
+   * @param options
+   * @returns
+   */
+  static needsRehash(hashedValue: string, options?: Options): any;
+  /**
+   * Determine if a given string is already hashed.
+   *
+   * @param  string  value
+   * @returns
+   */
+  static isHashed(value: string): any;
+  /**
+   * Verifies that the configuration is less than or equal to what is configured.
+   *
+   * @param  value
+   * @return bool
+   *
+   * @internal
+   */
+  static verifyConfiguration(value: string): any;
+  /**
+   * Get a driver instance.
+   *
+   * @param  driver
+   *
+   * @returns
+   *
+   * @throws InvalidArgumentException
+   */
+  static driver(): any;
+}
+//#endregion
+//#region src/Providers/HashingServiceProvider.d.ts
+/**
+ * Register HashManager.
+ */
+declare class HashingServiceProvider {
+  private app;
+  static priority: number;
+  constructor(app: any);
+  register(): void;
+}
+//#endregion
+//#region src/Utils/ParseInfo.d.ts
+declare class ParseInfo {
+  static getInfo(hashed: string, algo?: HashAlgorithm): {
+    [key: string]: number | undefined;
+    cost?: number | undefined;
+    memoryCost?: number | undefined;
+    timeCost?: number | undefined;
+    threads?: number | undefined;
+  };
+  static argon2(hashed: string): {
+    [key: string]: number | undefined;
+    cost?: number | undefined;
+    memoryCost?: number | undefined;
+    timeCost?: number | undefined;
+    threads?: number | undefined;
+  };
+  static bcrypt(hashed: string): Info['options'];
+}
+//#endregion
+export { AbstractHasher, Argon2Options, Argon2idHasher, ArgonHasher, BcryptHasher, BcryptOptions, Configuration, Hash, HashAlgorithm, HashManager, HashingServiceProvider, Info, Manager, Options, ParseInfo, UnknownOptions, defineConfig };
+//# sourceMappingURL=index.d.ts.map