packages/srp/lib/passwords.test.ts

   1 import { binaryStringToArray } from '@proton/crypto/lib/utils';
   2
   3 import { hashedResult0, hashedResult2, hashedResult4, watResult } from '../test/passwords.data';
   4 import '../test/setup';
   5 import { releaseCryptoProxy, setupCryptoProxyForTesting } from '../test/setup';
   6 import { expandHash, hashPassword } from './passwords';
   7
   8 describe('passwords', () => {
   9     beforeAll(setupCryptoProxyForTesting);
  10     afterAll(releaseCryptoProxy);
  11
  12     it('should expand a hash', async () => {
  13         const result = await expandHash(binaryStringToArray('wat'));
  14         expect(result).toEqual(watResult);
  15     });
  16
  17     it('should hash password version 4', async () => {
  18         const hashed = await hashPassword({
  19             password: 'hello',
  20             username: 'user1',
  21             salt: '»¢põó<±Ò&',
  22             modulus: new Uint8Array(256),
  23             version: 4,
  24         });
  25         expect(hashed).toEqual(hashedResult4);
  26     });
  27
  28     it('should hash password version 3', async () => {
  29         const hashed = await hashPassword({
  30             password: 'hello',
  31             username: 'user1',
  32             salt: '»¢põó<±Ò&',
  33             modulus: new Uint8Array(256),
  34             version: 3,
  35         });
  36         expect(hashed).toEqual(hashedResult4);
  37     });
  38
  39     it('should hash password version 2', async () => {
  40         const hashed = await hashPassword({
  41             password: 'hello',
  42             username: 'user1',
  43             salt: '»¢põó<±Ò&',
  44             modulus: new Uint8Array(256),
  45             version: 2,
  46         });
  47         expect(hashed).toEqual(hashedResult2);
  48     });
  49
  50     it('should hash password version 1', async () => {
  51         const hashed = await hashPassword({
  52             password: 'hello',
  53             username: 'user1',
  54             salt: '»¢põó<±Ò&',
  55             modulus: new Uint8Array(256),
  56             version: 1,
  57         });
  58         expect(hashed).toEqual(hashedResult2);
  59     });
  60
  61     it('should hash password version 0', async () => {
  62         const hashed = await hashPassword({
  63             password: 'hello',
  64             username: 'user1',
  65             salt: '»¢põó<±Ò&',
  66             modulus: new Uint8Array(256),
  67             version: 0,
  68         });
  69         expect(hashed).toEqual(hashedResult0);
  70     });
  71 });