@bsv/wallet-toolbox 1.7.16 → 1.7.17

package/mobile/node_modules/@bsv/sdk/src/totp/__tests/totp.test.ts

@@ -1,81 +0,0 @@
-import { toArray } from '../../primitives/utils'
-import { TOTP } from '../../totp/totp'
-
-const secret = toArray('48656c6c6f21deadbeef', 'hex')
-const period = 30 // sec
-const periodMS = 30 * 1000 // ms
-const options = {
-  digits: 6,
-  period,
-  algorithm: 'SHA-1' as const
-}
-
-describe('totp generation and validation', () => {
-  beforeEach(() => jest.useFakeTimers())
-  afterEach(() => jest.resetAllMocks())
-
-  test.each([
-    {
-      time: 0,
-      expected: '282760',
-      description: 'should generate token at Unix epoch start'
-    },
-    {
-      time: 1465324707000,
-      expected: '341128',
-      description: 'should generate token for a specific timestamp in 2016'
-    },
-    {
-      time: 1665644340000 + 1,
-      expected: '886842',
-      description: 'should generate correct token at the start of the cycle'
-    },
-    {
-      time: 1665644340000 - 1,
-      expected: '134996',
-      description: 'should generate correct token at the end of the cycle'
-    },
-    {
-      time: 1365324707000,
-      expected: '089029',
-      description: 'should generate token with a leading zero'
-    }
-  ])('$description', async ({ time, expected }) => {
-    jest.setSystemTime(time)
-
-    // check if expected passcode is generated
-    const passcode = TOTP.generate(secret, options)
-    expect(passcode).toEqual(expected)
-
-    expect(TOTP.validate(secret, '000000', options)).toEqual(false) // this passcode should not be valid for any of above test cases
-
-    // should not be valid for only a part of passcode
-    expect(TOTP.validate(secret, passcode.slice(1), options)).toEqual(false)
-
-    expect(TOTP.validate(secret, passcode, options)).toEqual(true)
-
-    const checkAdjacentWindow = (
-      timeOfGeneration: number,
-      expected: boolean
-    ): void => {
-      jest.setSystemTime(timeOfGeneration)
-      const adjacentTimewindowPasscode = TOTP.generate(secret, options)
-
-      jest.setSystemTime(time)
-      expect(
-        TOTP.validate(secret, adjacentTimewindowPasscode, options)
-      ).toEqual(expected)
-    }
-
-    // because the 'skew' is '1' by default, the passcode for the next window also should be valid
-    checkAdjacentWindow((time as number) + periodMS, true)
-
-    checkAdjacentWindow(time - periodMS, true)
-
-    // for 'skew': 1, other passcodes for further timewindows should not be valid
-    for (let i = 2; i < 10; i++) {
-      checkAdjacentWindow((time as number) + i * periodMS, false)
-      checkAdjacentWindow(time - i * periodMS, false)
-    }
-  })
-})

package/mobile/node_modules/@bsv/sdk/src/totp/index.ts

@@ -1 +0,0 @@
-export * from './totp.js'

package/mobile/node_modules/@bsv/sdk/src/totp/totp.ts

@@ -1,138 +0,0 @@
-import { SHA1HMAC, SHA256HMAC, SHA512HMAC } from '../primitives/Hash.js'
-import BigNumber from '../primitives/BigNumber.js'
-
-export type TOTPAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-512'
-
-/**
- * Options for TOTP generation.
- * @param {number} [digits=6] - The number of digits in the OTP.
- * @param {TOTPAlgorithm} [algorithm="SHA-1"] - Algorithm used for hashing.
- * @param {number} [period=30] - The time period for OTP validity in seconds.
- * @param {number} [timestamp=Date.now()] - The current timestamp.
- */
-export interface TOTPOptions {
-  digits?: number
-  algorithm?: TOTPAlgorithm
-  period?: number
-  timestamp?: number
-}
-
-/**
- * Options for TOTP validation.
- * @param {number} [skew=1] - The number of time periods to check before and after the current time period.
- */
-export type TOTPValidateOptions = TOTPOptions & {
-  skew?: number
-}
-
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export class TOTP {
-  /**
-   * Generates a Time-based One-Time Password (TOTP).
-   * @param {number[]} secret - The secret key for TOTP.
-   * @param {TOTPOptions} options - Optional parameters for TOTP.
-   * @returns {string} The generated TOTP.
-   */
-  static generate (secret: number[], options?: TOTPOptions): string {
-    const _options = this.withDefaultOptions(options)
-
-    const counter = this.getCounter(_options.timestamp, _options.period)
-    const otp = generateHOTP(secret, counter, _options)
-    return otp
-  }
-
-  /**
-   * Validates a Time-based One-Time Password (TOTP).
-   * @param {number[]} secret - The secret key for TOTP.
-   * @param {string} passcode - The passcode to validate.
-   * @param {TOTPValidateOptions} options - Optional parameters for TOTP validation.
-   * @returns {boolean} A boolean indicating whether the passcode is valid.
-   */
-  static validate (
-    secret: number[],
-    passcode: string,
-    options?: TOTPValidateOptions
-  ): boolean {
-    const _options = this.withDefaultValidateOptions(options)
-    passcode = passcode.trim()
-    if (passcode.length !== _options.digits) {
-      return false
-    }
-
-    const counter = this.getCounter(_options.timestamp, _options.period)
-
-    const counters = [counter]
-    for (let i = 1; i <= _options.skew; i++) {
-      counters.push(counter + i)
-      counters.push(counter - i)
-    }
-
-    for (const c of counters) {
-      if (passcode === generateHOTP(secret, c, _options)) {
-        return true
-      }
-    }
-
-    return false
-  }
-
-  private static getCounter (timestamp: number, period: number): number {
-    const epochSeconds = Math.floor(timestamp / 1000)
-    const counter = Math.floor(epochSeconds / period)
-    return counter
-  }
-
-  private static withDefaultOptions (
-    options?: TOTPOptions
-  ): Required<TOTPOptions> {
-    return {
-      digits: 2,
-      algorithm: 'SHA-1',
-      period: 30,
-      timestamp: Date.now(),
-      ...options
-    }
-  }
-
-  private static withDefaultValidateOptions (
-    options?: TOTPValidateOptions
-  ): Required<TOTPValidateOptions> {
-    return { skew: 1, ...this.withDefaultOptions(options) }
-  }
-}
-
-function generateHOTP (
-  secret: number[],
-  counter: number,
-  options: Required<TOTPOptions>
-): string {
-  const timePad = new BigNumber(counter).toArray('be', 8)
-  const hmac = calcHMAC(secret, timePad, options.algorithm)
-  const signature = hmac.digest()
-
-  // RFC 4226 https://datatracker.ietf.org/doc/html/rfc4226#section-5.4
-  const offset = signature[signature.length - 1] & 0x0f // offset is the last byte in the hmac
-  const fourBytesRange = signature.slice(offset, offset + 4) // starting from offset, get 4 bytes
-  const mask = 0x7fffffff // 32-bit number with a leading 0 followed by 31 ones [0111 (...) 1111]
-  const masked = new BigNumber(fourBytesRange).toNumber() & mask
-
-  const otp = masked.toString().slice(-options.digits)
-  return otp
-}
-
-function calcHMAC (
-  secret: number[],
-  timePad: number[],
-  algorithm: TOTPAlgorithm
-): SHA1HMAC | SHA256HMAC | SHA512HMAC {
-  switch (algorithm) {
-    case 'SHA-1':
-      return new SHA1HMAC(secret).update(timePad)
-    case 'SHA-256':
-      return new SHA256HMAC(secret).update(timePad)
-    case 'SHA-512':
-      return new SHA512HMAC(secret).update(timePad)
-    default:
-      throw new Error('unsupported HMAC algorithm')
-  }
-}