tor-browser

ECPublicKey.ts (5974B)

---

import * as asn1js from "asn1js";
import { BufferSourceConverter } from "pvtsutils";
import * as pvutils from "pvutils";
import { EMPTY_BUFFER, EMPTY_STRING } from "./constants";
import { ECNamedCurves } from "./ECNamedCurves";
import { ParameterError } from "./errors";
import { PkiObject, PkiObjectParameters } from "./PkiObject";
import * as Schema from "./Schema";

const X = "x";
const Y = "y";
const NAMED_CURVE = "namedCurve";

export interface IECPublicKey {
 namedCurve: string;
 x: ArrayBuffer;
 y: ArrayBuffer;
}

export interface ECPublicKeyJson {
 crv: string;
 x: string;
 y: string;
}

export type ECPublicKeyParameters = PkiObjectParameters & Partial<IECPublicKey> & { json?: ECPublicKeyJson; };

/**
* Represents the PrivateKeyInfo structure described in [RFC5480](https://datatracker.ietf.org/doc/html/rfc5480)
*/
export class ECPublicKey extends PkiObject implements IECPublicKey {

 public static override CLASS_NAME = "ECPublicKey";

 public namedCurve!: string;
 public x!: ArrayBuffer;
 public y!: ArrayBuffer;

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

   this.x = pvutils.getParametersValue(parameters, X, ECPublicKey.defaultValues(X));
   this.y = pvutils.getParametersValue(parameters, Y, ECPublicKey.defaultValues(Y));
   this.namedCurve = pvutils.getParametersValue(parameters, NAMED_CURVE, ECPublicKey.defaultValues(NAMED_CURVE));

   if (parameters.json) {
     this.fromJSON(parameters.json);
   }

   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 NAMED_CURVE): string;
 public static override defaultValues(memberName: typeof X | typeof Y): ArrayBuffer;
 public static override defaultValues(memberName: string): any {
   switch (memberName) {
     case X:
     case Y:
       return EMPTY_BUFFER;
     case NAMED_CURVE:
       return EMPTY_STRING;
     default:
       return super.defaultValues(memberName);
   }
 }


 /**
  * Compare values with default values for all class members
  * @param memberName String name for a class member
  * @param memberValue Value to compare with default value
  */
 static compareWithDefault<T>(memberName: string, memberValue: T): memberValue is T {
   switch (memberName) {
     case X:
     case Y:
       return memberValue instanceof ArrayBuffer &&
         (pvutils.isEqualBuffer(memberValue, ECPublicKey.defaultValues(memberName)));
     case NAMED_CURVE:
       return typeof memberValue === "string" &&
         memberValue === ECPublicKey.defaultValues(memberName);
     default:
       return super.defaultValues(memberName);
   }
 }

 /**
  * Returns value of pre-defined ASN.1 schema for current class
  * @param parameters Input parameters for the schema
  * @returns ASN.1 schema object
  */
 public static override schema(): Schema.SchemaType {
   return new asn1js.RawData();
 }

 public fromSchema(schema1: BufferSource): any {
   //#region Check the schema is valid

   const view = BufferSourceConverter.toUint8Array(schema1);
   if (view[0] !== 0x04) {
     throw new Error("Object's schema was not verified against input data for ECPublicKey");
   }
   //#endregion

   //#region Get internal properties from parsed schema
   const namedCurve = ECNamedCurves.find(this.namedCurve);
   if (!namedCurve) {
     throw new Error(`Incorrect curve OID: ${this.namedCurve}`);
   }
   const coordinateLength = namedCurve.size;

   if (view.byteLength !== (coordinateLength * 2 + 1)) {
     throw new Error("Object's schema was not verified against input data for ECPublicKey");
   }

   this.namedCurve = namedCurve.name;
   this.x = view.slice(1, coordinateLength + 1).buffer;
   this.y = view.slice(1 + coordinateLength, coordinateLength * 2 + 1).buffer;
   //#endregion
 }

 public toSchema(): asn1js.RawData {
   return new asn1js.RawData({
     data: pvutils.utilConcatBuf(
       (new Uint8Array([0x04])).buffer,
       this.x,
       this.y
     )
   });
 }

 public toJSON(): ECPublicKeyJson {
   const namedCurve = ECNamedCurves.find(this.namedCurve);

   return {
     crv: namedCurve ? namedCurve.name : this.namedCurve,
     x: pvutils.toBase64(pvutils.arrayBufferToString(this.x), true, true, false),
     y: pvutils.toBase64(pvutils.arrayBufferToString(this.y), true, true, false)
   };
 }

 /**
  * Converts JSON value into current object
  * @param json JSON object
  */
 public fromJSON(json: any): void {
   ParameterError.assert("json", json, "crv", "x", "y");

   let coordinateLength = 0;
   const namedCurve = ECNamedCurves.find(json.crv);
   if (namedCurve) {
     this.namedCurve = namedCurve.id;
     coordinateLength = namedCurve.size;
   }

   // TODO Simplify Base64url encoding
   const xConvertBuffer = pvutils.stringToArrayBuffer(pvutils.fromBase64(json.x, true));

   if (xConvertBuffer.byteLength < coordinateLength) {
     this.x = new ArrayBuffer(coordinateLength);
     const view = new Uint8Array(this.x);
     const convertBufferView = new Uint8Array(xConvertBuffer);
     view.set(convertBufferView, 1);
   } else {
     this.x = xConvertBuffer.slice(0, coordinateLength);
   }

   // TODO Simplify Base64url encoding
   const yConvertBuffer = pvutils.stringToArrayBuffer(pvutils.fromBase64(json.y, true));

   if (yConvertBuffer.byteLength < coordinateLength) {
     this.y = new ArrayBuffer(coordinateLength);
     const view = new Uint8Array(this.y);
     const convertBufferView = new Uint8Array(yConvertBuffer);
     view.set(convertBufferView, 1);
   } else {
     this.y = yConvertBuffer.slice(0, coordinateLength);
   }
 }

}