tor-browser

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

AttributeCertificateInfoV1.ts (14098B)

      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 "./AttCertValidityPeriod";
      8 import { IssuerSerial, IssuerSerialJson } from "./IssuerSerial";
      9 import * as Schema from "../Schema";
     10 import { PkiObject, PkiObjectParameters } from "../PkiObject";
     11 import { AsnError } from "../errors";
     12 import { EMPTY_STRING } from "../constants";
     13 
     14 const VERSION = "version";
     15 const BASE_CERTIFICATE_ID = "baseCertificateID";
     16 const SUBJECT_NAME = "subjectName";
     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  BASE_CERTIFICATE_ID,
     27  SUBJECT_NAME,
     28  ISSUER,
     29  SIGNATURE,
     30  SERIAL_NUMBER,
     31  ATTR_CERT_VALIDITY_PERIOD,
     32  ATTRIBUTES,
     33  ISSUER_UNIQUE_ID,
     34  EXTENSIONS,
     35 ];
     36 
     37 export interface IAttributeCertificateInfoV1 {
     38  /**
     39   * The version field MUST have the value of v2
     40   */
     41  version: number;
     42  baseCertificateID?: IssuerSerial;
     43  subjectName?: GeneralNames;
     44  issuer: GeneralNames;
     45  /**
     46   * Contains the algorithm identifier used to validate the AC signature
     47   */
     48  signature: AlgorithmIdentifier;
     49  serialNumber: asn1js.Integer;
     50  /**
     51   * Specifies the period for which the AC issuer certifies that the binding between
     52   * the holder and the attributes fields will be valid
     53   */
     54  attrCertValidityPeriod: AttCertValidityPeriod;
     55  /**
     56   * The attributes field gives information about the AC holder
     57   */
     58  attributes: Attribute[];
     59 
     60  /**
     61   * Issuer unique identifier
     62   */
     63  issuerUniqueID?: asn1js.BitString;
     64  /**
     65   * The extensions field generally gives information about the AC as opposed
     66   * to information about the AC holder
     67   */
     68  extensions?: Extensions;
     69 }
     70 
     71 export interface AttributeCertificateInfoV1Json {
     72  version: number;
     73  baseCertificateID?: IssuerSerialJson;
     74  subjectName?: GeneralNamesJson;
     75  issuer: GeneralNamesJson;
     76  signature: AlgorithmIdentifierJson;
     77  serialNumber: asn1js.IntegerJson;
     78  attrCertValidityPeriod: AttCertValidityPeriodJson;
     79  attributes: AttributeJson[];
     80  issuerUniqueID: asn1js.BitStringJson;
     81  extensions: ExtensionsJson;
     82 }
     83 
     84 export type AttributeCertificateInfoV1Parameters = PkiObjectParameters & Partial<IAttributeCertificateInfoV1>;
     85 
     86 export type AttributeCertificateInfoV1Schema = Schema.SchemaParameters<{
     87  version?: string;
     88  baseCertificateID?: string;
     89  subjectName?: string;
     90  signature?: AlgorithmIdentifierSchema;
     91  issuer?: string;
     92  attrCertValidityPeriod?: AttCertValidityPeriodSchema;
     93  serialNumber?: string;
     94  attributes?: string;
     95  issuerUniqueID?: string;
     96  extensions?: ExtensionsSchema;
     97 }>;
     98 
     99 /**
    100 * Represents the AttributeCertificateInfoV1 structure described in [RFC5755](https://datatracker.ietf.org/doc/html/rfc5755)
    101 */
    102 export class AttributeCertificateInfoV1 extends PkiObject implements IAttributeCertificateInfoV1 {
    103 
    104  public static override CLASS_NAME = "AttributeCertificateInfoV1";
    105 
    106  version!: number;
    107  baseCertificateID?: IssuerSerial;
    108  subjectName?: GeneralNames;
    109  issuer!: GeneralNames;
    110  signature!: AlgorithmIdentifier;
    111  serialNumber!: asn1js.Integer;
    112  attrCertValidityPeriod!: AttCertValidityPeriod;
    113  attributes!: Attribute[];
    114  issuerUniqueID?: asn1js.BitString;
    115  extensions?: Extensions;
    116 
    117  /**
    118   * Initializes a new instance of the {@link AttributeCertificateInfoV1} class
    119   * @param parameters Initialization parameters
    120   */
    121  constructor(parameters: AttributeCertificateInfoV1Parameters = {}) {
    122    super();
    123 
    124    this.version = pvutils.getParametersValue(parameters, VERSION, AttributeCertificateInfoV1.defaultValues(VERSION));
    125    if (BASE_CERTIFICATE_ID in parameters) {
    126      this.baseCertificateID = pvutils.getParametersValue(parameters, BASE_CERTIFICATE_ID, AttributeCertificateInfoV1.defaultValues(BASE_CERTIFICATE_ID));
    127    }
    128    if (SUBJECT_NAME in parameters) {
    129      this.subjectName = pvutils.getParametersValue(parameters, SUBJECT_NAME, AttributeCertificateInfoV1.defaultValues(SUBJECT_NAME));
    130    }
    131    this.issuer = pvutils.getParametersValue(parameters, ISSUER, AttributeCertificateInfoV1.defaultValues(ISSUER));
    132    this.signature = pvutils.getParametersValue(parameters, SIGNATURE, AttributeCertificateInfoV1.defaultValues(SIGNATURE));
    133    this.serialNumber = pvutils.getParametersValue(parameters, SERIAL_NUMBER, AttributeCertificateInfoV1.defaultValues(SERIAL_NUMBER));
    134    this.attrCertValidityPeriod = pvutils.getParametersValue(parameters, ATTR_CERT_VALIDITY_PERIOD, AttributeCertificateInfoV1.defaultValues(ATTR_CERT_VALIDITY_PERIOD));
    135    this.attributes = pvutils.getParametersValue(parameters, ATTRIBUTES, AttributeCertificateInfoV1.defaultValues(ATTRIBUTES));
    136    if (ISSUER_UNIQUE_ID in parameters)
    137      this.issuerUniqueID = pvutils.getParametersValue(parameters, ISSUER_UNIQUE_ID, AttributeCertificateInfoV1.defaultValues(ISSUER_UNIQUE_ID));
    138 
    139    if (EXTENSIONS in parameters) {
    140      this.extensions = pvutils.getParametersValue(parameters, EXTENSIONS, AttributeCertificateInfoV1.defaultValues(EXTENSIONS));
    141    }
    142 
    143    if (parameters.schema) {
    144      this.fromSchema(parameters.schema);
    145    }
    146  }
    147 
    148  /**
    149   * Returns default values for all class members
    150   * @param memberName String name for a class member
    151   * @returns Default value
    152   */
    153  public static override defaultValues(memberName: typeof VERSION): number;
    154  public static override defaultValues(memberName: typeof BASE_CERTIFICATE_ID): IssuerSerial;
    155  public static override defaultValues(memberName: typeof SUBJECT_NAME): GeneralNames;
    156  public static override defaultValues(memberName: typeof ISSUER): GeneralNames;
    157  public static override defaultValues(memberName: typeof SIGNATURE): AlgorithmIdentifier;
    158  public static override defaultValues(memberName: typeof SERIAL_NUMBER): asn1js.Integer;
    159  public static override defaultValues(memberName: typeof ATTR_CERT_VALIDITY_PERIOD): AttCertValidityPeriod;
    160  public static override defaultValues(memberName: typeof ATTRIBUTES): Attribute[];
    161  public static override defaultValues(memberName: typeof ISSUER_UNIQUE_ID): asn1js.BitString;
    162  public static override defaultValues(memberName: typeof EXTENSIONS): Extensions;
    163  public static override defaultValues(memberName: string): any {
    164    switch (memberName) {
    165      case VERSION:
    166        return 0;
    167      case BASE_CERTIFICATE_ID:
    168        return new IssuerSerial();
    169      case SUBJECT_NAME:
    170        return new GeneralNames();
    171      case ISSUER:
    172        return new GeneralNames();
    173      case SIGNATURE:
    174        return new AlgorithmIdentifier();
    175      case SERIAL_NUMBER:
    176        return new asn1js.Integer();
    177      case ATTR_CERT_VALIDITY_PERIOD:
    178        return new AttCertValidityPeriod();
    179      case ATTRIBUTES:
    180        return [];
    181      case ISSUER_UNIQUE_ID:
    182        return new asn1js.BitString();
    183      case EXTENSIONS:
    184        return new Extensions();
    185      default:
    186        return super.defaultValues(memberName);
    187    }
    188  }
    189 
    190  /**
    191   * @inheritdoc
    192   * @asn ASN.1 schema
    193   * ```asn
    194   * AttributeCertificateInfo ::= SEQUENCE {
    195   *   version Version DEFAULT v1,
    196   *   subject CHOICE {
    197   *     baseCertificateID [0] IssuerSerial, -- associated with a Public Key Certificate
    198   *     subjectName [1] GeneralNames }, -- associated with a name
    199   *   issuer GeneralNames, -- CA issuing the attribute certificate
    200   *   signature AlgorithmIdentifier,
    201   *   serialNumber CertificateSerialNumber,
    202   *   attrCertValidityPeriod AttCertValidityPeriod,
    203   *   attributes SEQUENCE OF Attribute,
    204   *   issuerUniqueID UniqueIdentifier OPTIONAL,
    205   *   extensions Extensions OPTIONAL
    206   * }
    207   *```
    208   */
    209  public static override schema(parameters: AttributeCertificateInfoV1Schema = {}): Schema.SchemaType {
    210    const names = pvutils.getParametersValue<NonNullable<typeof parameters.names>>(parameters, "names", {});
    211 
    212    return (new asn1js.Sequence({
    213      name: (names.blockName || EMPTY_STRING),
    214      value: [
    215        new asn1js.Integer({ name: (names.version || EMPTY_STRING) }),
    216        new asn1js.Choice({
    217          value: [
    218            new asn1js.Constructed({
    219              name: (names.baseCertificateID || EMPTY_STRING),
    220              idBlock: {
    221                tagClass: 3,
    222                tagNumber: 0 // [0]
    223              },
    224              value: IssuerSerial.schema().valueBlock.value
    225            }),
    226            new asn1js.Constructed({
    227              name: (names.subjectName || EMPTY_STRING),
    228              idBlock: {
    229                tagClass: 3,
    230                tagNumber: 1 // [2]
    231              },
    232              value: GeneralNames.schema().valueBlock.value
    233            }),
    234          ]
    235        }),
    236        GeneralNames.schema({
    237          names: {
    238            blockName: (names.issuer || EMPTY_STRING)
    239          }
    240        }),
    241        AlgorithmIdentifier.schema(names.signature || {}),
    242        new asn1js.Integer({ name: (names.serialNumber || EMPTY_STRING) }),
    243        AttCertValidityPeriod.schema(names.attrCertValidityPeriod || {}),
    244        new asn1js.Sequence({
    245          name: (names.attributes || EMPTY_STRING),
    246          value: [
    247            new asn1js.Repeated({
    248              value: Attribute.schema()
    249            })
    250          ]
    251        }),
    252        new asn1js.BitString({
    253          optional: true,
    254          name: (names.issuerUniqueID || EMPTY_STRING)
    255        }),
    256        Extensions.schema(names.extensions || {}, true)
    257      ]
    258    }));
    259  }
    260 
    261  public fromSchema(schema: Schema.SchemaType): void {
    262    // Clear input data first
    263    pvutils.clearProps(schema, CLEAR_PROPS);
    264    //#region Check the schema is valid
    265    const asn1 = asn1js.compareSchema(schema,
    266      schema,
    267      AttributeCertificateInfoV1.schema({
    268        names: {
    269          version: VERSION,
    270          baseCertificateID: BASE_CERTIFICATE_ID,
    271          subjectName: SUBJECT_NAME,
    272          issuer: ISSUER,
    273          signature: {
    274            names: {
    275              blockName: SIGNATURE
    276            }
    277          },
    278          serialNumber: SERIAL_NUMBER,
    279          attrCertValidityPeriod: {
    280            names: {
    281              blockName: ATTR_CERT_VALIDITY_PERIOD
    282            }
    283          },
    284          attributes: ATTRIBUTES,
    285          issuerUniqueID: ISSUER_UNIQUE_ID,
    286          extensions: {
    287            names: {
    288              blockName: EXTENSIONS
    289            }
    290          }
    291        }
    292      })
    293    );
    294 
    295    AsnError.assertSchema(asn1, this.className);
    296    //#endregion
    297 
    298    //#region Get internal properties from parsed schema
    299    this.version = asn1.result.version.valueBlock.valueDec;
    300 
    301    if (BASE_CERTIFICATE_ID in asn1.result) {
    302      this.baseCertificateID = new IssuerSerial({
    303        schema: new asn1js.Sequence({
    304          value: asn1.result.baseCertificateID.valueBlock.value
    305        })
    306      });
    307    }
    308 
    309    if (SUBJECT_NAME in asn1.result) {
    310      this.subjectName = new GeneralNames({
    311        schema: new asn1js.Sequence({
    312          value: asn1.result.subjectName.valueBlock.value
    313        })
    314      });
    315    }
    316 
    317    this.issuer = asn1.result.issuer;
    318    this.signature = new AlgorithmIdentifier({ schema: asn1.result.signature });
    319    this.serialNumber = asn1.result.serialNumber;
    320    this.attrCertValidityPeriod = new AttCertValidityPeriod({ schema: asn1.result.attrCertValidityPeriod });
    321    this.attributes = Array.from(asn1.result.attributes.valueBlock.value, element => new Attribute({ schema: element }));
    322 
    323    if (ISSUER_UNIQUE_ID in asn1.result) {
    324      this.issuerUniqueID = asn1.result.issuerUniqueID;
    325    }
    326 
    327    if (EXTENSIONS in asn1.result) {
    328      this.extensions = new Extensions({ schema: asn1.result.extensions });
    329    }
    330    //#endregion
    331  }
    332 
    333  public toSchema(): asn1js.Sequence {
    334    const result = new asn1js.Sequence({
    335      value: [new asn1js.Integer({ value: this.version })]
    336    });
    337 
    338    if (this.baseCertificateID) {
    339      result.valueBlock.value.push(new asn1js.Constructed({
    340        idBlock: {
    341          tagClass: 3,
    342          tagNumber: 0 // [0]
    343        },
    344        value: this.baseCertificateID.toSchema().valueBlock.value
    345      }));
    346    }
    347 
    348    if (this.subjectName) {
    349      result.valueBlock.value.push(new asn1js.Constructed({
    350        idBlock: {
    351          tagClass: 3,
    352          tagNumber: 1 // [1]
    353        },
    354        value: this.subjectName.toSchema().valueBlock.value
    355      }));
    356    }
    357 
    358    result.valueBlock.value.push(this.issuer.toSchema());
    359    result.valueBlock.value.push(this.signature.toSchema());
    360    result.valueBlock.value.push(this.serialNumber);
    361    result.valueBlock.value.push(this.attrCertValidityPeriod.toSchema());
    362    result.valueBlock.value.push(new asn1js.Sequence({
    363      value: Array.from(this.attributes, o => o.toSchema())
    364    }));
    365 
    366    if (this.issuerUniqueID) {
    367      result.valueBlock.value.push(this.issuerUniqueID);
    368    }
    369 
    370    if (this.extensions) {
    371      result.valueBlock.value.push(this.extensions.toSchema());
    372    }
    373 
    374    return result;
    375  }
    376 
    377  public toJSON(): AttributeCertificateInfoV1Json {
    378    const result = {
    379      version: this.version
    380    } as AttributeCertificateInfoV1Json;
    381 
    382    if (this.baseCertificateID) {
    383      result.baseCertificateID = this.baseCertificateID.toJSON();
    384    }
    385 
    386    if (this.subjectName) {
    387      result.subjectName = this.subjectName.toJSON();
    388    }
    389 
    390    result.issuer = this.issuer.toJSON();
    391    result.signature = this.signature.toJSON();
    392    result.serialNumber = this.serialNumber.toJSON();
    393    result.attrCertValidityPeriod = this.attrCertValidityPeriod.toJSON();
    394    result.attributes = Array.from(this.attributes, o => o.toJSON());
    395 
    396    if (this.issuerUniqueID) {
    397      result.issuerUniqueID = this.issuerUniqueID.toJSON();
    398    }
    399 
    400    if (this.extensions) {
    401      result.extensions = this.extensions.toJSON();
    402    }
    403 
    404    return result;
    405  }
    406 
    407 }