tor-browser

webcrypto.idl (6065B)

---

// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into webref
// (https://github.com/w3c/webref)
// Source: Web Cryptography API Level 2 (https://w3c.github.io/webcrypto/)

partial interface mixin WindowOrWorkerGlobalScope {
 [SameObject] readonly attribute Crypto crypto;
};

[Exposed=(Window,Worker)]
interface Crypto {
 [SecureContext] readonly attribute SubtleCrypto subtle;
 ArrayBufferView getRandomValues(ArrayBufferView array);
 [SecureContext] DOMString randomUUID();
};

typedef (object or DOMString) AlgorithmIdentifier;

typedef AlgorithmIdentifier HashAlgorithmIdentifier;

dictionary Algorithm {
 required DOMString name;
};

dictionary KeyAlgorithm {
 required DOMString name;
};

enum KeyType { "public", "private", "secret" };

[SecureContext,Exposed=(Window,Worker),Serializable]
interface CryptoKey {
 readonly attribute KeyType type;
 readonly attribute boolean extractable;
 readonly attribute object algorithm;
 readonly attribute object usages;
};

[SecureContext,Exposed=(Window,Worker)]
interface SubtleCrypto {
 Promise<ArrayBuffer> encrypt(
   AlgorithmIdentifier algorithm,
   CryptoKey key,
   BufferSource data
 );
 Promise<ArrayBuffer> decrypt(
   AlgorithmIdentifier algorithm,
   CryptoKey key,
   BufferSource data
 );
 Promise<ArrayBuffer> sign(
   AlgorithmIdentifier algorithm,
   CryptoKey key,
   BufferSource data
 );
 Promise<boolean> verify(
   AlgorithmIdentifier algorithm,
   CryptoKey key,
   BufferSource signature,
   BufferSource data
 );
 Promise<ArrayBuffer> digest(
   AlgorithmIdentifier algorithm,
   BufferSource data
 );

 Promise<(CryptoKey or CryptoKeyPair)> generateKey(
   AlgorithmIdentifier algorithm,
   boolean extractable,
   sequence<KeyUsage> keyUsages
 );
 Promise<CryptoKey> deriveKey(
   AlgorithmIdentifier algorithm,
   CryptoKey baseKey,
   AlgorithmIdentifier derivedKeyType,
   boolean extractable,
   sequence<KeyUsage> keyUsages
 );
 Promise<ArrayBuffer> deriveBits(
   AlgorithmIdentifier algorithm,
   CryptoKey baseKey,
   optional unsigned long? length = null
 );

 Promise<CryptoKey> importKey(
   KeyFormat format,
   (BufferSource or JsonWebKey) keyData,
   AlgorithmIdentifier algorithm,
   boolean extractable,
   sequence<KeyUsage> keyUsages
 );
 Promise<(ArrayBuffer or JsonWebKey)> exportKey(
   KeyFormat format,
   CryptoKey key
 );

 Promise<ArrayBuffer> wrapKey(
   KeyFormat format,
   CryptoKey key,
   CryptoKey wrappingKey,
   AlgorithmIdentifier wrapAlgorithm
 );
 Promise<CryptoKey> unwrapKey(
   KeyFormat format,
   BufferSource wrappedKey,
   CryptoKey unwrappingKey,
   AlgorithmIdentifier unwrapAlgorithm,
   AlgorithmIdentifier unwrappedKeyAlgorithm,
   boolean extractable,
   sequence<KeyUsage> keyUsages
 );
};

dictionary RsaOtherPrimesInfo {
 // The following fields are defined in Section 6.3.2.7 of JSON Web Algorithms
 DOMString r;
 DOMString d;
 DOMString t;
};

dictionary JsonWebKey {
 // The following fields are defined in Section 3.1 of JSON Web Key
 DOMString kty;
 DOMString use;
 sequence<DOMString> key_ops;
 DOMString alg;

 // The following fields are defined in JSON Web Key Parameters Registration
 boolean ext;

 // The following fields are defined in Section 6 of JSON Web Algorithms
 DOMString crv;
 DOMString x;
 DOMString y;
 DOMString d;
 DOMString n;
 DOMString e;
 DOMString p;
 DOMString q;
 DOMString dp;
 DOMString dq;
 DOMString qi;
 sequence<RsaOtherPrimesInfo> oth;
 DOMString k;
};

typedef Uint8Array BigInteger;

dictionary CryptoKeyPair {
 CryptoKey publicKey;
 CryptoKey privateKey;
};

dictionary RsaKeyGenParams : Algorithm {
 required [EnforceRange] unsigned long modulusLength;
 required BigInteger publicExponent;
};

dictionary RsaHashedKeyGenParams : RsaKeyGenParams {
 required HashAlgorithmIdentifier hash;
};

dictionary RsaKeyAlgorithm : KeyAlgorithm {
 required unsigned long modulusLength;
 required BigInteger publicExponent;
};

dictionary RsaHashedKeyAlgorithm : RsaKeyAlgorithm {
 required KeyAlgorithm hash;
};

dictionary RsaHashedImportParams : Algorithm {
 required HashAlgorithmIdentifier hash;
};

dictionary RsaPssParams : Algorithm {
 required [EnforceRange] unsigned long saltLength;
};

dictionary RsaOaepParams : Algorithm {
 BufferSource label;
};

dictionary EcdsaParams : Algorithm {
 required HashAlgorithmIdentifier hash;
};

typedef DOMString NamedCurve;

dictionary EcKeyGenParams : Algorithm {
 required NamedCurve namedCurve;
};

dictionary EcKeyAlgorithm : KeyAlgorithm {
 required NamedCurve namedCurve;
};

dictionary EcKeyImportParams : Algorithm {
 required NamedCurve namedCurve;
};

dictionary EcdhKeyDeriveParams : Algorithm {
 required CryptoKey public;
};

dictionary AesCtrParams : Algorithm {
 required BufferSource counter;
 required [EnforceRange] octet length;
};

dictionary AesKeyAlgorithm : KeyAlgorithm {
 required unsigned short length;
};

dictionary AesKeyGenParams : Algorithm {
 required [EnforceRange] unsigned short length;
};

dictionary AesDerivedKeyParams : Algorithm {
 required [EnforceRange] unsigned short length;
};

dictionary AesCbcParams : Algorithm {
 required BufferSource iv;
};

dictionary AesGcmParams : Algorithm {
 required BufferSource iv;
 BufferSource additionalData;
 [EnforceRange] octet tagLength;
};

dictionary HmacImportParams : Algorithm {
 required HashAlgorithmIdentifier hash;
 [EnforceRange] unsigned long length;
};

dictionary HmacKeyAlgorithm : KeyAlgorithm {
 required KeyAlgorithm hash;
 required unsigned long length;
};

dictionary HmacKeyGenParams : Algorithm {
 required HashAlgorithmIdentifier hash;
 [EnforceRange] unsigned long length;
};

dictionary HkdfParams : Algorithm {
 required HashAlgorithmIdentifier hash;
 required BufferSource salt;
 required BufferSource info;
};

dictionary Pbkdf2Params : Algorithm {
 required BufferSource salt;
 required [EnforceRange] unsigned long iterations;
 required HashAlgorithmIdentifier hash;
};