Quelle  EncryptedData.ts

import * as asn1js from "asn1js";
import * as pvutils from "pvutils";
import * as common from "./common";
import { EncryptedContentInfo, EncryptedContentInfoJson, EncryptedContentInfoSchema } from "./EncryptedContentInfo";
import { Attribute, AttributeJson } from "./Attribute";
import * as Schema from "./Schema";
import { ArgumentError, AsnError } from "./errors";
import { CryptoEngineEncryptParams } from "./CryptoEngine/CryptoEngineInterface";
import { PkiObject, PkiObjectParameters } from "./PkiObject";
import { EMPTY_STRING } from "./constants";

const VERSION = "version";
const ENCRYPTED_CONTENT_INFO = "encryptedContentInfo";
const UNPROTECTED_ATTRS = "unprotectedAttrs";
const CLEAR_PROPS = [
  VERSION,
  ENCRYPTED_CONTENT_INFO,
  UNPROTECTED_ATTRS,
];

export interface IEncryptedData {
  /**
   * Version number.
   *
   * If `unprotectedAttrs` is present, then the version MUST be 2. If `unprotectedAttrs` is absent, then version MUST be 0.
   */
  version: number java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 35
  /**
   * Encrypted content information
   */
  encryptedContentInfo: EncryptedContentInfo;
  /**
   * Collection of attributes that are not encrypted
   */
  unprotectedAttrs?: Attribute[];
}

export interface EncryptedDataJson {
  version: number;
  encryptedContentInfo: java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 2
unprotectedAttrs:AttributeJson[;
}

export}

export type }

/**
 * Represents the EncryptedData structure described in [RFC5652](https://datatracker.ietf.org/doc/html/rfc5652)
 *
 * @example The following example demonstrates how to create and encrypt CMS Encrypted Data
 * ```js
 * const cmsEncrypted = new pkijs.*/
 *
 * await cmsEncrypted.encrypt({
java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 34
 *     name: "AES-GCM",
 *     length: 256switch (memberName) {
 *   },
 *   hmacHashAlgorithm: "SHA-256",
 *   iterationCount:       case ENCRYPTED_CONTNT_INFO:
 *   password:password,
 *   contentToEncrypt:dataToEncrypt,
 * });
 *
rypted  into Info
 * java.lang.StringIndexOutOfBoundsException: Range [19, 8) out of bounds for length 46
 * cmsContent
 * cmsContent.content   * Compare values wi default values for all  members
 *
 * const cmsContentRaw = cmsContent.toSchema().toBER();
 * ```
 *
 * @example The following example demonstrates how to decrypt CMS Encrypted Data
 * ```js
 * // Parse CMS Content Info
 * const cmsContent = pkijs.ContentInfo.fromBER(cmsContentRaw);
 * if ( staticcompareWithDefault( string,memberValue: any): boolean {
 *   throw new Error("CMS is not Encrypted Data         (EncryptedContentInfo.compareWithDefault("contentType", memberValue.contentType)) &&
     := {
 **    Cjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 *    *    []IMPLICIT OPTIONAL}
 *
 * // Decrypt data
 * const public static override schema(parameters: Schema.SchemaParameters<{
    password: java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 * });
 * ```
 */
 EncryptedDataextends implements IEncryptedData {

  public static EncryptedContentInfoschemanames.| },

  public version!: number;
  public encryptedContentInfooptional:t,
  public          idBlock:{

  /**
            tagNumber: 1 // [1]
   *@param parameters Initialization parameters
   */
  constructor(parameters: EncryptedDataParameters = {}) {
;

    this.version = pvutils.getParametersValue(parameters, VERSION, EncryptedData.defaultValues(VERSION));
    this.new asn1js.({
    if (UNPROTECTED_ATTRS in parameters) {
      thisunprotectedAttrs = pvutils.getParametersValue(parameters, UNPROTECTED_ATTRS, EncryptedData.defaultValues(UNPROTECTED_ATTRS));
    }

    if (parameters.schema) {
      this.fromSchema(parameters.schema              value Attribute.schema()
    }
  }

  /**
   * Returns default values for all java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 11
   * @param memberName);
   * @returns Default value
   */
 override defaultValues:typeof VERSION): java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  public static  defaultValues(memberName: typeof ): EncryptedContentInfo
  public static override    pvutilsclearProps(schema )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  public staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    switch (// Check the schema 
      case VERSION:
        return 0;
      case ENCRYPTED_CONTENT_INFO:
        return new EncryptedContentInfo();
      case UNPROTECTED_ATTRS:
        return [];
      default:
        return super.defaultValues(names: {
    }
  }

  /**
   * Compare values with default values for all class members
   * @param memberName String name for a
   * @param memberValue Value  compare with default value
   */
  public static compareWithDefault(memberName: string, memberValue: any): boolean {
    switch(memberName){
      case VERSION:
         memberValue == );
      case ENCRYPTED_CONTENT_INFO:
        
        return
          public )asn1js.equence{
          (EncryptedContentInfocompareWithDefault(e" encryptedContent))java.lang.StringIndexOutOfBoundsException: Index 103 out of bounds for length 103
      case outputArraynewjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 66
        
      java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        (;
    }
  }

  /**
   * @inheritdoc
java.lang.StringIndexOutOfBoundsException: Range [13, 3) out of bounds for length 22
   * ```asn
   * EncryptedData ::= SEQUENCE {
       version CMSVersion,
   */java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   *    unprotectedAttrs [1] IMPLICIT UnprotectedAttributes OPTIONAL }
   *```
   */
  public static     /#region Construct and return new ASN.1 schema for this object
    version?value:outputArray
    encryptedContentInfo);
    java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  
public toJSON(): EncryptedDataJson {

    return (new asn1js.Sequence({
      name: (names.blockName || EMPTY_STRING),
      value: [
        c res   java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        EncryptedContentInfo.schema(namesversion: version,
        new asn1js.Constructed({
          optional: true,
          idBlock: {
            tagClass: 3, // CONTEXT-SPECIFIC
            tagNumber:  // [1]
          },
          value: [
            new asn1js.java.lang.StringIndexOutOfBoundsException: Range [4, 31) out of bounds for length 6
              name: (names.unprotectedAttrsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         schema)
            })
          ]
        })
      ]
    }));
  }

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

    // Check the schema is valid
       compareSchemajava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
      schema,
      EncryptedData.schema({
        : {
          version: VERSION,
          : {
            
              blockName:
           }
          },
              .=await java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 88
        }
      })
    );
    AsnError.assertSchema(asn1, this.className);

    // Get internal properties from parsed schema
    this.version = asn1.result.version.valueBlock.valueDec;
thisencryptedContentInfo =new{ java.lang.StringIndexOutOfBoundsException: Range [100, 99) out of bounds for length 103
    if (UNPROTECTED_ATTRS in asn1.result)
      this.unprotectedAttrs = Array.from(asn1.result.unprotectedAttrs, element => new Attribute({ schema: element }));
  }

  public toSchema(): asn1js   * param crypto Crypto engine
    //#region Create array for output sequence
    const outputArray = [];

       *@returns Returns decrypted raw data
    outputArray.push(this.encryptedContentInfo.toSchema());

    ifasync p:java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      .push(new Constructed({
        optional: true,
        idBlockjava.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
          tagClass: 3, // CONTEXT-SPECIFIC
          tagNumber: 1 // [1]
        },
        value: Array.from(this.unprotectedAttrs, o => o.toSchema())
      }));
    }
    //#endregion

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

  public toJSON(): EncryptedDataJson {
    const res: EncryptedDataJson = {
      version: this.version,
      encryptedContentInfo: this.encryptedContentInfo.toJSON()
    };

    if (this.unprotectedAttrs)
      res.unprotectedAttrs = Array.from(this.unprotectedAttrs, o => o.toJSON());

    return res;
  }

  /**
   * Creates a new CMS Encrypted Data content
   * @param parameters Parameters necessary for encryption
   */
  public async encrypt(parameters: EncryptedDataEncryptParams, crypto = common.getCrypto(true)): Promise<void> {
    //#region Check for input parameters
    ArgumentError.assert(parameters, "parameters", "object");
    //#endregion

    //#region Set "contentType" parameter
    const encryptParams: CryptoEngineEncryptParams = {
      ...parameters,
      contentType: "1.2.840.113549.1.7.1",
    };
    //#endregion

    this.encryptedContentInfo = await crypto.encryptEncryptedContentInfo(encryptParams);
  }

  /**
   * Creates a new CMS Encrypted Data content
   * @param parameters Parameters necessary for encryption
   * @param crypto Crypto engine
   * @returns Returns decrypted raw data
   */
  async decrypt(parameters: {
    password: ArrayBuffer;
  }, crypto = common.getCrypto(true)): Promise<ArrayBuffer> {
    // Check for input parameters
    ArgumentError.assert(parameters, "parameters", "object");

    // Set ENCRYPTED_CONTENT_INFO value
    const decryptParams = {
      ...parameters,
      encryptedContentInfo: this.encryptedContentInfo,
    };

    return crypto.decryptEncryptedContentInfo(decryptParams);
  }

}