tor-browser

SignedAndUnsignedAttributes.ts (6493B)

---

import * as asn1js from "asn1js";
import * as pvtsutils from "pvtsutils";
import * as pvutils from "pvutils";
import { Attribute, AttributeJson } from "./Attribute";
import { EMPTY_BUFFER, EMPTY_STRING } from "./constants";
import { AsnError } from "./errors";
import { PkiObject, PkiObjectParameters } from "./PkiObject";
import * as Schema from "./Schema";

const TYPE = "type";
const ATTRIBUTES = "attributes";
const ENCODED_VALUE = "encodedValue";
const CLEAR_PROPS = [
 ATTRIBUTES
];

export interface ISignedAndUnsignedAttributes {
 type: number;
 attributes: Attribute[];
 /**
  * Need to have it in order to successfully process with signature verification
  */
 encodedValue: ArrayBuffer;
}

export interface SignedAndUnsignedAttributesJson {
 type: number;
 attributes: AttributeJson[];
}

export type SignedAndUnsignedAttributesParameters = PkiObjectParameters & Partial<ISignedAndUnsignedAttributes>;

export type SignedAndUnsignedAttributesSchema = Schema.SchemaParameters<{
 tagNumber?: number;
 attributes?: string;
}>;

/**
* Represents the SignedAndUnsignedAttributes structure described in [RFC5652](https://datatracker.ietf.org/doc/html/rfc5652)
*/
export class SignedAndUnsignedAttributes extends PkiObject implements ISignedAndUnsignedAttributes {

 public static override CLASS_NAME = "SignedAndUnsignedAttributes";

 public type!: number;
 public attributes!: Attribute[];
 public encodedValue!: ArrayBuffer;

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

   this.type = pvutils.getParametersValue(parameters, TYPE, SignedAndUnsignedAttributes.defaultValues(TYPE));
   this.attributes = pvutils.getParametersValue(parameters, ATTRIBUTES, SignedAndUnsignedAttributes.defaultValues(ATTRIBUTES));
   this.encodedValue = pvutils.getParametersValue(parameters, ENCODED_VALUE, SignedAndUnsignedAttributes.defaultValues(ENCODED_VALUE));

   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 TYPE): number;
 public static override defaultValues(memberName: typeof ATTRIBUTES): Attribute[];
 public static override defaultValues(memberName: typeof ENCODED_VALUE): ArrayBuffer;
 public static override defaultValues(memberName: string): any {
   switch (memberName) {
     case TYPE:
       return (-1);
     case ATTRIBUTES:
       return [];
     case ENCODED_VALUE:
       return EMPTY_BUFFER;
     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
  */
 public static compareWithDefault(memberName: string, memberValue: any): boolean {
   switch (memberName) {
     case TYPE:
       return (memberValue === SignedAndUnsignedAttributes.defaultValues(TYPE));
     case ATTRIBUTES:
       return (memberValue.length === 0);
     case ENCODED_VALUE:
       return (memberValue.byteLength === 0);
     default:
       return super.defaultValues(memberName);
   }
 }

 /**
  * @inheritdoc
  * @asn ASN.1 schema
  * ```asn
  * SignedAttributes ::= SET SIZE (1..MAX) OF Attribute
  *
  * UnsignedAttributes ::= SET SIZE (1..MAX) OF Attribute
  *```
  */
 public static override schema(parameters: SignedAndUnsignedAttributesSchema = {}): Schema.SchemaType {
   const names = pvutils.getParametersValue<NonNullable<typeof parameters.names>>(parameters, "names", {});

   return (new asn1js.Constructed({
     name: (names.blockName || EMPTY_STRING),
     optional: true,
     idBlock: {
       tagClass: 3, // CONTEXT-SPECIFIC
       tagNumber: names.tagNumber || 0 // "SignedAttributes" = 0, "UnsignedAttributes" = 1
     },
     value: [
       new asn1js.Repeated({
         name: (names.attributes || EMPTY_STRING),
         value: Attribute.schema()
       })
     ]
   }));
 }

 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,
     SignedAndUnsignedAttributes.schema({
       names: {
         tagNumber: this.type,
         attributes: ATTRIBUTES
       }
     })
   );
   AsnError.assertSchema(asn1, this.className);

   // Get internal properties from parsed schema
   this.type = asn1.result.idBlock.tagNumber;
   this.encodedValue = pvtsutils.BufferSourceConverter.toArrayBuffer(asn1.result.valueBeforeDecodeView);

   //#region Change type from "[0]" to "SET" accordingly to standard
   const encodedView = new Uint8Array(this.encodedValue);
   encodedView[0] = 0x31;
   //#endregion

   if ((ATTRIBUTES in asn1.result) === false) {
     if (this.type === 0)
       throw new Error("Wrong structure of SignedUnsignedAttributes");
     else
       return; // Not so important in case of "UnsignedAttributes"
   }

   this.attributes = Array.from(asn1.result.attributes, element => new Attribute({ schema: element }));
   //#endregion
 }

 public toSchema(): asn1js.Sequence {
   if (SignedAndUnsignedAttributes.compareWithDefault(TYPE, this.type) || SignedAndUnsignedAttributes.compareWithDefault(ATTRIBUTES, this.attributes))
     throw new Error("Incorrectly initialized \"SignedAndUnsignedAttributes\" class");

   //#region Construct and return new ASN.1 schema for this object
   return (new asn1js.Constructed({
     optional: true,
     idBlock: {
       tagClass: 3, // CONTEXT-SPECIFIC
       tagNumber: this.type // "SignedAttributes" = 0, "UnsignedAttributes" = 1
     },
     value: Array.from(this.attributes, o => o.toSchema())
   }));
   //#endregion
 }

 public toJSON(): SignedAndUnsignedAttributesJson {
   if (SignedAndUnsignedAttributes.compareWithDefault(TYPE, this.type) || SignedAndUnsignedAttributes.compareWithDefault(ATTRIBUTES, this.attributes))
     throw new Error("Incorrectly initialized \"SignedAndUnsignedAttributes\" class");

   return {
     type: this.type,
     attributes: Array.from(this.attributes, o => o.toJSON())
   };
 }

}