tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

AttributeCertificateInfoV2.ts (12033B)

      1 import * as asn1js from "asn1js";
      2 import * as pvutils from "pvutils";
      3 import { GeneralNames, GeneralNamesJson } from "../GeneralNames";
      4 import { AlgorithmIdentifier, AlgorithmIdentifierJson, AlgorithmIdentifierSchema } from "../AlgorithmIdentifier";
      5 import { Attribute, AttributeJson } from "../Attribute";
      6 import { Extensions, ExtensionsJson, ExtensionsSchema } from "../Extensions";
      7 import { AttCertValidityPeriod, AttCertValidityPeriodJson, AttCertValidityPeriodSchema } from "../AttributeCertificateV1";
      8 import { V2Form, V2FormJson } from "./V2Form";
      9 import { Holder, HolderJson, HolderSchema } from "./Holder";
     10 import * as Schema from "../Schema";
     11 import { PkiObject, PkiObjectParameters } from "../PkiObject";
     12 import { AsnError } from "../errors";
     13 import { EMPTY_STRING } from "../constants";
     14 
     15 const VERSION = "version";
     16 const HOLDER = "holder";
     17 const ISSUER = "issuer";
     18 const SIGNATURE = "signature";
     19 const SERIAL_NUMBER = "serialNumber";
     20 const ATTR_CERT_VALIDITY_PERIOD = "attrCertValidityPeriod";
     21 const ATTRIBUTES = "attributes";
     22 const ISSUER_UNIQUE_ID = "issuerUniqueID";
     23 const EXTENSIONS = "extensions";
     24 const CLEAR_PROPS = [
     25  VERSION,
     26  HOLDER,
     27  ISSUER,
     28  SIGNATURE,
     29  SERIAL_NUMBER,
     30  ATTR_CERT_VALIDITY_PERIOD,
     31  ATTRIBUTES,
     32  ISSUER_UNIQUE_ID,
     33  EXTENSIONS
     34 ];
     35 
     36 export interface IAttributeCertificateInfoV2 {
     37  version: number;
     38  holder: Holder;
     39  issuer: GeneralNames | V2Form;
     40  signature: AlgorithmIdentifier;
     41  serialNumber: asn1js.Integer;
     42  attrCertValidityPeriod: AttCertValidityPeriod;
     43  attributes: Attribute[];
     44  issuerUniqueID?: asn1js.BitString;
     45  extensions?: Extensions;
     46 }
     47 
     48 export type AttributeCertificateInfoV2Parameters = PkiObjectParameters & Partial<AttributeCertificateInfoV2>;
     49 
     50 export type AttributeCertificateInfoV2Schema = Schema.SchemaParameters<{
     51  version?: string;
     52  holder?: HolderSchema;
     53  issuer?: string;
     54  signature?: AlgorithmIdentifierSchema;
     55  serialNumber?: string;
     56  attrCertValidityPeriod?: AttCertValidityPeriodSchema;
     57  attributes?: string;
     58  issuerUniqueID?: string;
     59  extensions?: ExtensionsSchema;
     60 }>;
     61 
     62 export interface AttributeCertificateInfoV2Json {
     63  version: number;
     64  holder: HolderJson;
     65  issuer: GeneralNamesJson | V2FormJson;
     66  signature: AlgorithmIdentifierJson;
     67  serialNumber: asn1js.IntegerJson;
     68  attrCertValidityPeriod: AttCertValidityPeriodJson;
     69  attributes: AttributeJson[];
     70  issuerUniqueID?: asn1js.BitStringJson;
     71  extensions?: ExtensionsJson;
     72 }
     73 
     74 /**
     75 * Represents the AttributeCertificateInfoV2 structure described in [RFC5755](https://datatracker.ietf.org/doc/html/rfc5755)
     76 */
     77 export class AttributeCertificateInfoV2 extends PkiObject implements IAttributeCertificateInfoV2 {
     78 
     79  public static override CLASS_NAME = "AttributeCertificateInfoV2";
     80 
     81  public version!: number;
     82  public holder!: Holder;
     83  public issuer!: GeneralNames | V2Form;
     84  public signature!: AlgorithmIdentifier;
     85  public serialNumber!: asn1js.Integer;
     86  public attrCertValidityPeriod!: AttCertValidityPeriod;
     87  public attributes!: Attribute[];
     88  public issuerUniqueID?: asn1js.BitString;
     89  public extensions?: Extensions;
     90 
     91  /**
     92   * Initializes a new instance of the {@link AttributeCertificateInfoV2} class
     93   * @param parameters Initialization parameters
     94   */
     95  constructor(parameters: AttributeCertificateInfoV2Parameters = {}) {
     96    super();
     97 
     98    this.version = pvutils.getParametersValue(parameters, VERSION, AttributeCertificateInfoV2.defaultValues(VERSION));
     99    this.holder = pvutils.getParametersValue(parameters, HOLDER, AttributeCertificateInfoV2.defaultValues(HOLDER));
    100    this.issuer = pvutils.getParametersValue(parameters, ISSUER, AttributeCertificateInfoV2.defaultValues(ISSUER));
    101    this.signature = pvutils.getParametersValue(parameters, SIGNATURE, AttributeCertificateInfoV2.defaultValues(SIGNATURE));
    102    this.serialNumber = pvutils.getParametersValue(parameters, SERIAL_NUMBER, AttributeCertificateInfoV2.defaultValues(SERIAL_NUMBER));
    103    this.attrCertValidityPeriod = pvutils.getParametersValue(parameters, ATTR_CERT_VALIDITY_PERIOD, AttributeCertificateInfoV2.defaultValues(ATTR_CERT_VALIDITY_PERIOD));
    104    this.attributes = pvutils.getParametersValue(parameters, ATTRIBUTES, AttributeCertificateInfoV2.defaultValues(ATTRIBUTES));
    105    if (ISSUER_UNIQUE_ID in parameters) {
    106      this.issuerUniqueID = pvutils.getParametersValue(parameters, ISSUER_UNIQUE_ID, AttributeCertificateInfoV2.defaultValues(ISSUER_UNIQUE_ID));
    107    }
    108    if (EXTENSIONS in parameters) {
    109      this.extensions = pvutils.getParametersValue(parameters, EXTENSIONS, AttributeCertificateInfoV2.defaultValues(EXTENSIONS));
    110    }
    111 
    112    if (parameters.schema) {
    113      this.fromSchema(parameters.schema);
    114    }
    115  }
    116 
    117  /**
    118   * Returns default values for all class members
    119   * @param memberName String name for a class member
    120   * @returns Default value
    121   */
    122  public static override defaultValues(memberName: typeof VERSION): number;
    123  public static override defaultValues(memberName: typeof HOLDER): Holder;
    124  public static override defaultValues(memberName: typeof ISSUER): GeneralNames | V2Form;
    125  public static override defaultValues(memberName: typeof SIGNATURE): AlgorithmIdentifier;
    126  public static override defaultValues(memberName: typeof SERIAL_NUMBER): asn1js.Integer;
    127  public static override defaultValues(memberName: typeof ATTR_CERT_VALIDITY_PERIOD): AttCertValidityPeriod;
    128  public static override defaultValues(memberName: typeof ATTRIBUTES): Attribute[];
    129  public static override defaultValues(memberName: typeof ISSUER_UNIQUE_ID): asn1js.BitString;
    130  public static override defaultValues(memberName: typeof EXTENSIONS): Extensions;
    131  public static override defaultValues(memberName: string): any {
    132    switch (memberName) {
    133      case VERSION:
    134        return 1;
    135      case HOLDER:
    136        return new Holder();
    137      case ISSUER:
    138        return {};
    139      case SIGNATURE:
    140        return new AlgorithmIdentifier();
    141      case SERIAL_NUMBER:
    142        return new asn1js.Integer();
    143      case ATTR_CERT_VALIDITY_PERIOD:
    144        return new AttCertValidityPeriod();
    145      case ATTRIBUTES:
    146        return [];
    147      case ISSUER_UNIQUE_ID:
    148        return new asn1js.BitString();
    149      case EXTENSIONS:
    150        return new Extensions();
    151      default:
    152        return super.defaultValues(memberName);
    153    }
    154  }
    155 
    156  /**
    157   * @inheritdoc
    158   * @asn ASN.1 schema
    159   * ```asn
    160   * AttributeCertificateInfoV2 ::= SEQUENCE {
    161   *   version                 AttCertVersion, -- version is v2
    162   *   holder                  Holder,
    163   *   issuer                  AttCertIssuer,
    164   *   signature               AlgorithmIdentifier,
    165   *   serialNumber            CertificateSerialNumber,
    166   *   attrCertValidityPeriod  AttCertValidityPeriod,
    167   *   attributes              SEQUENCE OF Attribute,
    168   *   issuerUniqueID          UniqueIdentifier OPTIONAL,
    169   *   extensions              Extensions OPTIONAL
    170   * }
    171   *```
    172   */
    173  public static override schema(parameters: AttributeCertificateInfoV2Schema = {}): Schema.SchemaType {
    174    const names = pvutils.getParametersValue<NonNullable<typeof parameters.names>>(parameters, "names", {});
    175 
    176    return (new asn1js.Sequence({
    177      name: (names.blockName || EMPTY_STRING),
    178      value: [
    179        new asn1js.Integer({ name: (names.version || EMPTY_STRING) }),
    180        Holder.schema(names.holder || {}),
    181        new asn1js.Choice({
    182          value: [
    183            GeneralNames.schema({
    184              names: {
    185                blockName: (names.issuer || EMPTY_STRING)
    186              }
    187            }),
    188            new asn1js.Constructed({
    189              name: (names.issuer || EMPTY_STRING),
    190              idBlock: {
    191                tagClass: 3,
    192                tagNumber: 0 // [0]
    193              },
    194              value: V2Form.schema().valueBlock.value
    195            })
    196          ]
    197        }),
    198        AlgorithmIdentifier.schema(names.signature || {}),
    199        new asn1js.Integer({ name: (names.serialNumber || EMPTY_STRING) }),
    200        AttCertValidityPeriod.schema(names.attrCertValidityPeriod || {}),
    201        new asn1js.Sequence({
    202          name: (names.attributes || EMPTY_STRING),
    203          value: [
    204            new asn1js.Repeated({
    205              value: Attribute.schema()
    206            })
    207          ]
    208        }),
    209        new asn1js.BitString({
    210          optional: true,
    211          name: (names.issuerUniqueID || EMPTY_STRING)
    212        }),
    213        Extensions.schema(names.extensions || {}, true)
    214      ]
    215    }));
    216  }
    217 
    218  public fromSchema(schema: Schema.SchemaType): void {
    219    // Clear input data first
    220    pvutils.clearProps(schema, CLEAR_PROPS);
    221 
    222    // Check the schema is valid
    223    const asn1 = asn1js.compareSchema(schema,
    224      schema,
    225      AttributeCertificateInfoV2.schema({
    226        names: {
    227          version: VERSION,
    228          holder: {
    229            names: {
    230              blockName: HOLDER
    231            }
    232          },
    233          issuer: ISSUER,
    234          signature: {
    235            names: {
    236              blockName: SIGNATURE
    237            }
    238          },
    239          serialNumber: SERIAL_NUMBER,
    240          attrCertValidityPeriod: {
    241            names: {
    242              blockName: ATTR_CERT_VALIDITY_PERIOD
    243            }
    244          },
    245          attributes: ATTRIBUTES,
    246          issuerUniqueID: ISSUER_UNIQUE_ID,
    247          extensions: {
    248            names: {
    249              blockName: EXTENSIONS
    250            }
    251          }
    252        }
    253      })
    254    );
    255    AsnError.assertSchema(asn1, this.className);
    256 
    257    //#region Get internal properties from parsed schema
    258    this.version = asn1.result.version.valueBlock.valueDec;
    259    this.holder = new Holder({ schema: asn1.result.holder });
    260 
    261    switch (asn1.result.issuer.idBlock.tagClass) {
    262      case 3: // V2Form
    263        this.issuer = new V2Form({
    264          schema: new asn1js.Sequence({
    265            value: asn1.result.issuer.valueBlock.value
    266          })
    267        });
    268        break;
    269      case 1: // GeneralNames (should not be used)
    270      default:
    271        throw new Error("Incorrect value for 'issuer' in AttributeCertificateInfoV2");
    272    }
    273 
    274    this.signature = new AlgorithmIdentifier({ schema: asn1.result.signature });
    275    this.serialNumber = asn1.result.serialNumber;
    276    this.attrCertValidityPeriod = new AttCertValidityPeriod({ schema: asn1.result.attrCertValidityPeriod });
    277    this.attributes = Array.from(asn1.result.attributes.valueBlock.value, element => new Attribute({ schema: element }));
    278 
    279    if (ISSUER_UNIQUE_ID in asn1.result) {
    280      this.issuerUniqueID = asn1.result.issuerUniqueID;
    281    }
    282 
    283    if (EXTENSIONS in asn1.result) {
    284      this.extensions = new Extensions({ schema: asn1.result.extensions });
    285    }
    286    //#endregion
    287  }
    288 
    289  public toSchema(): asn1js.Sequence {
    290    const result = new asn1js.Sequence({
    291      value: [
    292        new asn1js.Integer({ value: this.version }),
    293        this.holder.toSchema(),
    294        new asn1js.Constructed({
    295          idBlock: {
    296            tagClass: 3,
    297            tagNumber: 0 // [0]
    298          },
    299          value: this.issuer.toSchema().valueBlock.value
    300        }),
    301        this.signature.toSchema(),
    302        this.serialNumber,
    303        this.attrCertValidityPeriod.toSchema(),
    304        new asn1js.Sequence({
    305          value: Array.from(this.attributes, o => o.toSchema())
    306        })
    307      ]
    308    });
    309 
    310    if (this.issuerUniqueID) {
    311      result.valueBlock.value.push(this.issuerUniqueID);
    312    }
    313    if (this.extensions) {
    314      result.valueBlock.value.push(this.extensions.toSchema());
    315    }
    316 
    317    return result;
    318  }
    319 
    320  public toJSON(): AttributeCertificateInfoV2Json {
    321    const result: AttributeCertificateInfoV2Json = {
    322      version: this.version,
    323      holder: this.holder.toJSON(),
    324      issuer: this.issuer.toJSON(),
    325      signature: this.signature.toJSON(),
    326      serialNumber: this.serialNumber.toJSON(),
    327      attrCertValidityPeriod: this.attrCertValidityPeriod.toJSON(),
    328      attributes: Array.from(this.attributes, o => o.toJSON())
    329    };
    330 
    331    if (this.issuerUniqueID) {
    332      result.issuerUniqueID = this.issuerUniqueID.toJSON();
    333    }
    334    if (this.extensions) {
    335      result.extensions = this.extensions.toJSON();
    336    }
    337 
    338    return result;
    339  }
    340 
    341 }