tor-browser

PBKDF2Params.ts (6603B)

---

import * as asn1js from "asn1js";
import * as pvutils from "pvutils";
import { AlgorithmIdentifier, AlgorithmIdentifierJson, AlgorithmIdentifierSchema } from "./AlgorithmIdentifier";
import { EMPTY_STRING } from "./constants";
import { AsnError } from "./errors";
import { PkiObject, PkiObjectParameters } from "./PkiObject";
import * as Schema from "./Schema";

const SALT = "salt";
const ITERATION_COUNT = "iterationCount";
const KEY_LENGTH = "keyLength";
const PRF = "prf";
const CLEAR_PROPS = [
 SALT,
 ITERATION_COUNT,
 KEY_LENGTH,
 PRF
];

export interface IPBKDF2Params {
 salt: any;
 iterationCount: number;
 keyLength?: number;
 prf?: AlgorithmIdentifier;
}

export interface PBKDF2ParamsJson {
 salt: any;
 iterationCount: number;
 keyLength?: number;
 prf?: AlgorithmIdentifierJson;
}

export type PBKDF2ParamsParameters = PkiObjectParameters & Partial<IPBKDF2Params>;

/**
* Represents the PBKDF2Params structure described in [RFC2898](https://www.ietf.org/rfc/rfc2898.txt)
*/
export class PBKDF2Params extends PkiObject implements IPBKDF2Params {

 public static override CLASS_NAME = "PBKDF2Params";

 public salt: any;
 public iterationCount!: number;
 public keyLength?: number;
 public prf?: AlgorithmIdentifier;

 /**
  * Initializes a new instance of the {@link PBKDF2Params} class
  * @param parameters Initialization parameters
  */
 constructor(parameters: PBKDF2ParamsParameters = {}) {
   super();

   this.salt = pvutils.getParametersValue(parameters, SALT, PBKDF2Params.defaultValues(SALT));
   this.iterationCount = pvutils.getParametersValue(parameters, ITERATION_COUNT, PBKDF2Params.defaultValues(ITERATION_COUNT));
   if (KEY_LENGTH in parameters) {
     this.keyLength = pvutils.getParametersValue(parameters, KEY_LENGTH, PBKDF2Params.defaultValues(KEY_LENGTH));
   }
   if (PRF in parameters) {
     this.prf = pvutils.getParametersValue(parameters, PRF, PBKDF2Params.defaultValues(PRF));
   }

   if (parameters.schema) {
     this.fromSchema(parameters.schema);
   }
 }

 /**
  * Returns default values for all class members
  * @param memberName String name for a class member
  * @returns Default value
  */
 public static override defaultValues(memberName: typeof SALT): any;
 public static override defaultValues(memberName: typeof ITERATION_COUNT): number;
 public static override defaultValues(memberName: typeof KEY_LENGTH): number;
 public static override defaultValues(memberName: typeof PRF): AlgorithmIdentifier;
 public static override defaultValues(memberName: string): any {
   switch (memberName) {
     case SALT:
       return {};
     case ITERATION_COUNT:
       return (-1);
     case KEY_LENGTH:
       return 0;
     case PRF:
       return new AlgorithmIdentifier({
         algorithmId: "1.3.14.3.2.26", // SHA-1
         algorithmParams: new asn1js.Null()
       });
     default:
       return super.defaultValues(memberName);
   }
 }

 /**
  * @inheritdoc
  * @asn ASN.1 schema
  * ```asn
  * PBKDF2-params ::= SEQUENCE {
  *    salt CHOICE {
  *        specified OCTET STRING,
  *        otherSource AlgorithmIdentifier },
  *  iterationCount INTEGER (1..MAX),
  *  keyLength INTEGER (1..MAX) OPTIONAL,
  *  prf AlgorithmIdentifier
  *    DEFAULT { algorithm hMAC-SHA1, parameters NULL } }
  *```
  */
 public static override schema(parameters: Schema.SchemaParameters<{
   saltPrimitive?: string;
   saltConstructed?: AlgorithmIdentifierSchema;
   iterationCount?: string;
   keyLength?: string;
   prf?: AlgorithmIdentifierSchema;
 }> = {}): Schema.SchemaType {
   const names = pvutils.getParametersValue<NonNullable<typeof parameters.names>>(parameters, "names", {});

   return (new asn1js.Sequence({
     name: (names.blockName || EMPTY_STRING),
     value: [
       new asn1js.Choice({
         value: [
           new asn1js.OctetString({ name: (names.saltPrimitive || EMPTY_STRING) }),
           AlgorithmIdentifier.schema(names.saltConstructed || {})
         ]
       }),
       new asn1js.Integer({ name: (names.iterationCount || EMPTY_STRING) }),
       new asn1js.Integer({
         name: (names.keyLength || EMPTY_STRING),
         optional: true
       }),
       AlgorithmIdentifier.schema(names.prf || {
         names: {
           optional: true
         }
       })
     ]
   }));
 }

 public fromSchema(schema: Schema.SchemaType): void {
   // Clear input data first
   pvutils.clearProps(schema, CLEAR_PROPS);

   // Check the schema is valid
   const asn1 = asn1js.compareSchema(schema,
     schema,
     PBKDF2Params.schema({
       names: {
         saltPrimitive: SALT,
         saltConstructed: {
           names: {
             blockName: SALT
           }
         },
         iterationCount: ITERATION_COUNT,
         keyLength: KEY_LENGTH,
         prf: {
           names: {
             blockName: PRF,
             optional: true
           }
         }
       }
     })
   );
   AsnError.assertSchema(asn1, this.className);

   // Get internal properties from parsed schema
   this.salt = asn1.result.salt;
   this.iterationCount = asn1.result.iterationCount.valueBlock.valueDec;
   if (KEY_LENGTH in asn1.result)
     this.keyLength = asn1.result.keyLength.valueBlock.valueDec;
   if (PRF in asn1.result)
     this.prf = new AlgorithmIdentifier({ schema: asn1.result.prf });
 }

 public toSchema(): asn1js.Sequence {
   //#region Create array for output sequence
   const outputArray = [];

   outputArray.push(this.salt);
   outputArray.push(new asn1js.Integer({ value: this.iterationCount }));

   if (KEY_LENGTH in this) {
     if (PBKDF2Params.defaultValues(KEY_LENGTH) !== this.keyLength)
       outputArray.push(new asn1js.Integer({ value: this.keyLength }));
   }

   if (this.prf) {
     if (PBKDF2Params.defaultValues(PRF).isEqual(this.prf) === false)
       outputArray.push(this.prf.toSchema());
   }
   //#endregion

   //#region Construct and return new ASN.1 schema for this object
   return (new asn1js.Sequence({
     value: outputArray
   }));
   //#endregion
 }

 public toJSON(): PBKDF2ParamsJson {
   const res: PBKDF2ParamsJson = {
     salt: this.salt.toJSON(),
     iterationCount: this.iterationCount
   };

   if (KEY_LENGTH in this) {
     if (PBKDF2Params.defaultValues(KEY_LENGTH) !== this.keyLength)
       res.keyLength = this.keyLength;
   }

   if (this.prf) {
     if (PBKDF2Params.defaultValues(PRF).isEqual(this.prf) === false)
       res.prf = this.prf.toJSON();
   }

   return res;
 }

}