Returns a section of an ArrayBuffer.
diff --git a/interfaces/sha_shared.Sha256ArrayBuffer.html b/interfaces/sha_shared.Sha256ArrayBuffer.html index 0c831e3d..2803f654 100644 --- a/interfaces/sha_shared.Sha256ArrayBuffer.html +++ b/interfaces/sha_shared.Sha256ArrayBuffer.html @@ -1,4 +1,4 @@ -Returns a section of an ArrayBuffer.
diff --git a/interfaces/sha_shared.Sha384ArrayBuffer.html b/interfaces/sha_shared.Sha384ArrayBuffer.html index 61ef6c3b..7f9afc63 100644 --- a/interfaces/sha_shared.Sha384ArrayBuffer.html +++ b/interfaces/sha_shared.Sha384ArrayBuffer.html @@ -1,4 +1,4 @@ -Returns a section of an ArrayBuffer.
diff --git a/interfaces/sha_shared.Sha512ArrayBuffer.html b/interfaces/sha_shared.Sha512ArrayBuffer.html index 88c913f6..3f5f21b3 100644 --- a/interfaces/sha_shared.Sha512ArrayBuffer.html +++ b/interfaces/sha_shared.Sha512ArrayBuffer.html @@ -1,4 +1,4 @@ -Returns a section of an ArrayBuffer.
diff --git a/modules/aes.html b/modules/aes.html index e12f7b4e..d5910cdc 100644 --- a/modules/aes.html +++ b/modules/aes.html @@ -1,3 +1,3 @@ -All AES related modes and functions
-Code related to AES_CBC mode
-Decrypt data with an AES_CBC key
exampleconst plaintextBytes = await AES_CBC.decrypt(
{ iv },
key.self,
ciphertextBytes
);
exampleconst plaintextBytes = await key.decrypt(
{ iv },
ciphertextBytes
);
Encrypt payload with an AES_CBC key
exampleconst key = await AES_CBC.generateKey();
const iv = await IV.generate();
const ciphertextBytes = await AES_CBC.encrypt(
{ iv },
key.self,
new TextEncoder().encode('message')
);
exampleconst key = await AES_CBC.generateKey();
const iv = await IV.generate();
const ciphertextBytes = await key.encrypt(
{ iv },
new TextEncoder().encode('message')
);
Export an AES_CBC key
exampleconst key = await AES_CBC.generateKey();
const jwk = await AES_CBC.exportKey("jwk", key.self);
exampleconst key = await AES_CBC.generateKey();
const jwk = await key.exportKey("jwk");
Generate a new AES_CBC key
exampleconst key = await AES_CBC.generateKey();
Import an AES_CBC key
exampleconst jwk = await AES_CBC.importKey("jwk", jwk, {
length: 256,
});
Unwrap a wrapped key using the key encryption key
exampleconst wrappedKey = await AES_CBC.wrapKey("raw", dek.self, kek.self, {
iv,
});
const unwrappedKey = await AES_CBC.unwrapKey(
"raw",
wrappedKey,
{ name: Alg.Mode.AES_CBC },
kek.self,
{ iv }
);
exampleconst wrappedKey = await AES_CBC.wrapKey("raw", dek.self, kek.self, {
iv,
});
const unwrappedKey = await kek.unwrapKey(
"raw",
wrappedKey,
{ name: Alg.Mode.AES_CBC },
{ iv }
);
Wrap another key with an AES_CBC key
exampleconst kek = await AES_CBC.generateKey({ length: 256 }, true, [
"wrapKey",
"unwrapKey",
]);
const dek: AesCbcCryptoKey = await AES_CBC.generateKey({
length: 256,
});
const iv = await IV.generate();
const wrappedKey = await AES_CBC.wrapKey("raw", dek, kek, {
iv,
});
Code related to AES_CTR mode
-Decrypt with an AES_CTR key
exampleconst data = await AES_CTR.decrypt({length, counter}, key.self, data);
exampleconst data = await key.decrypt({length, counter}, data);
Encrypt with an AES_CTR key
exampleconst key = await AES_CTR.generateKey();
const message = new TextEncoder().encode("a message");
const length = 8;
const counter = await AES_CTR.generateCounter(length);
const data = await AES_CTR.encrypt({length, counter}, key.self, message);
exampleconst key = await AES_CTR.generateKey();
const message = new TextEncoder().encode("a message");
const length = 8;
const counter = await AES_CTR.generateCounter(length);
const data = await key.encrypt({length, counter}, message);
Export an AES_CTR key into the specified format
exampleconst key = await AES_CTR.generateKey();
const jwk = await AES_CTR.exportKey("jwk", key.self);
exampleconst key = await AES_CTR.generateKey();
const jwk = await key.exportKey("jwk");
Generate a new AES_CTR key
exampleconst key = await AES_CTR.generateKey();
Import an AES_CTR key from the specified format
exampleconst key = await AES_CTR.importKey("jwk", jwk, { length: 256 });
Unwrap a wrapped key using the key encryption key
exampleconst dek = await AES_CTR.unwrapKey("raw", wrappedKey, {name: "AES_CTR"}, kek.self, {length, counter});
exampleconst dek = await kek.unwrapKey("raw", wrappedKey, {name: "AES_CTR"}, {length, counter});
Wrap another key with an AES_CTR key
exampleconst kek = await AES_CTR.generateKey({length: 256}, true, ['wrapKey', 'unwrapKey']);
const dek = await AES_CTR.generateKey();
const length = 8;
const counter = await AES_CTR.generateCounter(length);
const wrappedKey = await AES_CTR.wrapKey("raw", dek.self, kek.self, {length, counter});
Code related to AES_GCM mode
-Decrypt with an AES_GCM key
exampleconst key = await AES_GCM.generateKey();
const data = await AES_GCM.decrypt({iv}, key.self, data);
exampleconst key = await AES_GCM.generateKey();
const data = await key.decrypt({iv}, data);
Encrypt with an AES_GCM key
exampleconst iv = await Random.IV.generate();
const key = await AES_GCM.generateKey();
const message = new TextEncoder().encode("a message");
const data = await AES_GCM.encrypt({iv}, key.self, message);
exampleconst iv = await Random.IV.generate();
const key = await AES_GCM.generateKey();
const message = new TextEncoder().encode("a message");
const data = await key.encrypt({iv}, message);
Export an AES_GCM key into the specified format
exampleconst key = await AES_GCM.generateKey();
const jwk = await AES_GCM.exportKey("jwk", key.self);
exampleconst key = await AES_GCM.generateKey();
const jwk = await key.exportKey("jwk");
Generate a new AES_GCM key
exampleconst key = await AES_GCM.generateKey();
Import an AES_GCM key from the specified format
exampleconst key = await AES_GCM.importKey("jwk", jwk, { length: 256 });
Unwrap a wrapped key using the key encryption key
exampleconst dek = await AES_GCM.unwrapKey("raw", wrappedKey, {name: "AES_GCM"}, kek, {iv});
exampleconst dek = await kek.unwrapKey("raw", wrappedKey, {name: "AES_GCM"}, {iv});
Wrap another key with an AES_GCM key
exampleconst iv = await Random.IV.generate();
const kek = await AES_GCM.generateKey({length: 256}, true, ['wrapKey', 'unwrapKey']);
const dek = await AES_GCM.generateKey();
const wrappedKey = await AES_GCM.wrapKey("raw", dek.self, kek.self, {iv});
Code related to AES_KW mode
-Export an AES_KW key into the specified format
exampleconst jwk = await AES_KW.exportKey("jwk", key.self);
exampleconst jwk = await key.exportKey("jwk");
Generate a new AES_KW key
exampleconst key = await AES_KW.generateKey();
Import an AES_KW key from the specified format
exampleconst key = await AES_KW.importKey("jwk", jwk);
Unwrap a wrapped key using the key encryption key
exampleconst dek = await AES_KW.unwrapKey("raw", wrappedKey, {name: "AES_GCM"}, kek.self);
exampleconst dek = await kek.unwrapKey("raw", wrappedKey, {name: "AES_GCM"});
Wrap another key with an AES_KW key
exampleconst kek = await AES_KW.generateKey({length: 256}, true, ['wrapKey', 'unwrapKey']);
const dek = await AES_GCM.generateKey();
const wrappedKey = await AES_KW.wrapKey("raw", dek.self, kek.self);
Shared code for AES
-All elliptic curve algorithms
-Code related to ECDH
-Derive a shared bits between two ECDH key pairs
exampleconst keyPair = await ECDH.generateKey();
const otherKeyPair = await ECDH.generateKey();
const bits = await ECDH.deriveBits(
{ public: otherKeyPair.publicKey.self },
keyPair.privateKey.self,
128
);
exampleconst keyPair = await ECDH.generateKey();
const otherKeyPair = await ECDH.generateKey();
const bits = await keyPair.privateKey.deriveBits(
{ public: otherKeyPair.publicKey.self },
128
);
Derive a shared key between two ECDH key pairs
exampleconst keyPair = await ECDH.generateKey();
const otherKeyPair = await ECDH.generateKey();
const hmacParams: params.EnforcedHmacKeyGenParams = {
name: Authentication.Alg.Code.HMAC,
hash: SHA.Alg.Variant.SHA_512,
length: 512,
};
let key = await ECDH.deriveKey(
{ public: otherKeyPair.publicKey.self },
keyPair.privateKey.self,
hmacParams
);
exampleconst keyPair = await ECDH.generateKey();
const otherKeyPair = await ECDH.generateKey();
const hmacParams: params.EnforcedHmacKeyGenParams = {
name: Authentication.Alg.Code.HMAC,
hash: SHA.Alg.Variant.SHA_512,
length: 512,
};
let key = await keyPair.privateKey.deriveKey(
{ public: otherKeyPair.publicKey.self },
hmacParams
);
Export an ECDH public or private key
exampleconst pubKeyJwk = await ECDH.exportKey("jwk", keyPair.publicKey.self);
exampleconst privKeyJwk = await keyPair.privateKey.exportKey("jwk");
Generate a new ECDH keypair
exampleconst keyPair = await ECDH.generateKey();
exampleconst keyPair = await ECDH.generateKey({ namedCurve: "P-256" }, true, ['deriveKey', 'deriveBits']);
Generate a new ECDH keypair
aliasgenerateKey
exampleconst keyPair = await ECDH.generateKeyPair();
@@ -39,7 +39,7 @@
exampleconst keyPair = await ECDH.generateKeyPair({ namedCurve: "P-256" }, true, ['deriveKey', 'deriveBits']);
Import an ECDH public or private key
exampleconst pubKey = await ECDH.importKey("jwk", pubKeyJwk, { namedCurve: "P-521" }, true, []);
Code related to ECDSA
-Export an ECDSA public or private key
exampleconst pubKeyJwk = await ECDSA.exportKey("jwk", keyPair.publicKey.self);
exampleconst privKeyJwk = await keyPair.privateKey.exportKey("jwk");
Generate a new ECDSA keypair
exampleconst keyPair = await ECDSA.generateKey();
exampleconst keyPair = await ECDSA.generateKey({ namedCurve: "P-256" }, true, ['sign', 'verify']);
Generate a new ECDSA keypair
aliasgenerateKey
exampleconst keyPair = await ECDSA.generateKeyPair();
@@ -27,19 +27,19 @@
exampleconst keyPair = await ECDSA.generateKeyPair({ namedCurve: "P-256" }, true, ['sign', 'verify']);
Import an ECDSA public or private key
exampleconst pubKey = await ECDSA.importKey("jwk", pubKeyJwk, { namedCurve: "P-521" }, true, ['verify']);
exampleconst privKey = await ECDSA.importKey("jwk", privKeyJwk, { namedCurve: "P-521" }, true, ['sign']);
Sign a given payload
exampleconst message = new TextEncoder().encode("a message");
const signature = await ECDSA.sign({hash: "SHA-512"}, keyPair.privateKey.self, message);
exampleconst message = new TextEncoder().encode("a message");
const signature = await keyPair.privateKey.sign({hash: "SHA-512"}, message);
Verify a given signature
exampleconst message = new TextEncoder().encode("a message");
const isVerified = await ECDSA.verify({hash: "SHA-512"}, keyPair.publicKey.self, signature, message);
Shared code for EC
-Code related to HMAC
-Export an HMAC key into the specified format
exampleconst jwk = await HMAC.exportKey("jwk", key.self);
exampleconst jwk = await key.exportKey("jwk");
Generate a new HMAC key
exampleconst key = await HMAC.generateKey();
Import an HMAC key from the specified format
exampleconst key = await HMAC.importKey("jwk", jwk, {hash: "SHA-512"});
Sign a given payload
exampleconst message = new TextEncoder().encode("a message");
const signature = await HMAC.sign(key.self, message);
const message = new TextEncoder().encode("a message");
const signature = await key.sign(message);
Verify a given signature
exampleconst isVerified = await HMAC.verify(key, signature, message);
All key derivation functions
-Code related to HKDF
-Derive a number bits with a given key material
exampleconst salt = await Random.Salt.generate();
const info = await Random.getValues(6);
const bits = await HKDF.deriveBits(
{ salt, info, hash: "SHA-512" },
keyMaterial,
128
);
exampleconst salt = await Random.Salt.generate();
const info = await Random.getValues(6);
const bits = await keyMaterial.deriveBits(
{ salt, info, hash: "SHA-512" },
128
);
Derive a shared key from HKDF key material
exampleconst hmacParams: params.EnforcedHmacKeyGenParams = {
name: Authentication.Alg.Code.HMAC,
hash: SHA.Alg.Variant.SHA_512,
length: 512,
};
const salt = await Random.Salt.generate();
const info = await Random.getValues(6);
let key = await HKDF.deriveKey(
{ salt, info, hash: "SHA-512" },
keyMaterial,
hmacParams
);
exampleconst hmacParams: params.EnforcedHmacKeyGenParams = {
name: Authentication.Alg.Code.HMAC,
hash: SHA.Alg.Variant.SHA_512,
length: 512,
};
const salt = await Random.Salt.generate();
const info = await Random.getValues(6);
let key = await keyMaterial.deriveKey(
{ salt, info, hash: "SHA-512" },
hmacParams
);
Generate key material for deriving
exampleconst keyMaterial = await HKDF.generateKeyMaterial("raw", new TextEncoder().encode("lots_of_entropy"));
Code related to PBKDF2
-Derive a number bits with a given key material
exampleconst bits = await PBKDF2.deriveBits(
{ hash: "SHA-512" },
keyMaterial,
128
);
exampleconst bits = await keyMaterial.deriveBits(
{ hash: "SHA-512" },
128
);
Derive a shared key from PBKDF2 key material
exampleconst hmacParams: params.EnforcedHmacKeyGenParams = {
name: Authentication.Alg.Code.HMAC,
hash: SHA.Alg.Variant.SHA_512,
length: 512,
};
let key = await PBKDF2.deriveKey(
{ hash: "SHA512" },
keyMaterial,
hmacParams
);
exampleconst hmacParams: params.EnforcedHmacKeyGenParams = {
name: Authentication.Alg.Code.HMAC,
hash: SHA.Alg.Variant.SHA_512,
length: 512,
};
let key = await keyMaterial.deriveKey(
{ hash: "SHA512" },
hmacParams
);
Generate key material for deriving
exampleconst keyMaterial = await PBKDF2.generateKeyMaterial("raw", new TextEncoder().encode("could_be_a_little_entropy"));
Shared code for KDF
Key usages and allowed formats
-Given a algorithm, return the most likely key usage pair.
Enforced parameters for algorithms
-Code related to proxying CryptoKey and CryptoKeyPair
-Initialization Vectors
-Generate an initialization vector. Defaults to 16 bytes.
exampleconst iv = await Random.IV.generate();
Salts
-Generate a salt. Defaults to 16 bytes.
exampleconst salt = await Random.Salt.generate();
UUID
-Generate a UUID.
exampleconst uuid = await Random.UUID.generate();
Cryptographically strong random values.
-Generate random values
exampleconst values = await Random.getValues(16);
All RSA algorithms
-Code related to RSA_OAEP
-Decrypt with an RSA_OAEP private key
exampleconst data = await RSA_OAEP.decrypt({label}, keyPair.privateKey.self, data);
exampleconst data = await keyPair.privateKey.decrypt({label}, data);
Encrypt with an RSA_OAEP public key
exampleconst message = new TextEncoder().encode("a message");
const data = await RSA_OAEP.encrypt({label}, keyPair.publicKey.self, message);
exampleconst message = new TextEncoder().encode("a message");
const data = await keyPair.publicKey.encrypt({label}, message);
Export an RSA_OAEP public or private key
exampleconst pubKeyJwk = await RSA_OAEP.exportKey("jwk", keyPair.publicKey.self);
exampleconst pubKeyJwk = await keyPair.publicKey.exportKey("jwk");
const privKeyJwk = await keyPair.privateKey.exportKey("jwk");
Generate a new RSA_OAEP keypair
exampleconst keyPair = await RSA_OAEP.generateKey();
Generate a new RSA_OAEP keypair
aliasgenerateKey
exampleconst keyPair = await RSA_OAEP.generateKeyPair();
Import an RSA_OAEP public or private key
exampleconst key = await RSA_OAEP.importKey("jwk", pubKey, { hash: "SHA-512" }, true, ['encrypt']);
Unwrap a wrapped key using the key encryption key
exampleconst wrappedKey = await RSA_OAEP.wrapKey("raw", dek.self, kek.self);
const unwrappedKey = await RSA_OAEP.unwrapKey(
"raw",
wrappedKey,
{ name: Alg.Mode.RSA_OAEP },
kek.self,
);
const wrappedKey = await kek.wrapKey("raw", dek.self);
const unwrappedKey = await kek.unwrapKey(
"raw",
wrappedKey,
{ name: Alg.Mode.RSA_OAEP },
);
Wrap another key with an RSA_OAEP public key
exampleconst kek = await RSA_OAEP.generateKey(undefined, true, ['wrapKey', 'unwrapKey']);
const dek = await RSA_OAEP.generateKey();
const label = await Random.getValues(8);
const wrappedKey = await RSA_OAEP.wrapKey("raw", dek.self, kek.self, {label});
Code related to RSA_PSS
-Export an RSA_PSS public or private key
exampleconst pubKeyJwk = await RSA_PSS.importKey("jwk", keyPair.publicKey.self);
exampleconst pubKeyJwk = await keyPair.publicKey.importKey("jwk");
Generate a new RSA_PSS keypair
exampleconst keyPair = await RSA_PSS.generateKey();
Generate a new RSA_PSS keypair
aliasgenerateKey
exampleconst keyPair = await RSA_PSS.generateKeyPair();
Import an RSA_PSS public or private key
exampleconst key = await RSA_PSS.importKey("jwk", pubKey, { hash: "SHA-512" }, true, ['verify']);
Sign a given payload
exampleconst message = new TextEncoder().encode("a message");
const signature = await RSA_PSS.sign(128, keyPair.privateKey.self, message);
exampleconst message = new TextEncoder().encode("a message");
const signature = await keyPair.privateKey.sign(128, message);
Verify a given signature
exampleconst message = new TextEncoder().encode("a message");
const isVerified = await ECDSA.verify(128, keyPair.publicKey.self, signature, message);
Code related to RSASSA_PKCS1_v1_5
-Export an RSASSA_PKCS1_v1_5 public or private key
exampleconst pubKeyJwk = await RSASSA_PKCS1_v1_5.importKey("jwk", keyPair.publicKey.self);
exampleconst pubKeyJwk = await keyPair.publicKey.importKey("jwk");
Generate a new RSASSA_PKCS1_v1_5 keypair
exampleconst keyPair = await RSASSA_PKCS1_v1_5.generateKey();
Generate a new RSASSA_PKCS1_v1_5 keypair
aliasgenerateKey
exampleconst keyPair = await RSASSA_PKCS1_v1_5.generateKeyPair();
Import an RSASSA_PKCS1_v1_5 public or private key
exampleconst key = await RSASSA_PKCS1_v1_5.importKey("jwk", pubKey, { hash: "SHA-512" }, true, ['verify']);
Sign a given payload
exampleconst message = new TextEncoder().encode("a message");
const signature = await RSASSA_PKCS1_v1_5.sign(keyPair.privateKey.self, message);
exampleconst message = new TextEncoder().encode("a message");
const signature = await keyPair.privateKey.sign(message);
Verify a given signature
exampleconst message = new TextEncoder().encode("a message");
const isVerified = await RSASSA_PKCS1_v1_5.verify(keyPair.publicKey.self, signature, message);
Shared code for RSA
-All SHA algorithms
-Code related to SHA_1
-Get the digest of the buffer
exampleconst buffer = new TextEncoder().encode("a file");
const digest = SHA_1.digest(buffer);
Get the hex string of the digest
exampleconst hash = SHA_1.hexify(digest);
Code related to SHA_256
-Get the digest of the buffer
exampleconst buffer = new TextEncoder().encode("a file");
const digest = SHA_256.digest(buffer);
Get the hex string of the digest
exampleconst hash = SHA_256.hexify(digest);
Code related to SHA_384
-Get the digest of the buffer
exampleconst buffer = new TextEncoder().encode("a file");
const digest = SHA_384.digest(buffer);
Get the hex string of the digest
exampleconst hash = SHA_384.hexify(digest);
Code related to SHA_512
-Get the digest of the buffer
exampleconst buffer = new TextEncoder().encode("a file");
const digest = SHA_512.digest(buffer);
Get the hex string of the digest
exampleconst hash = SHA_512.hexify(digest);
Shared code for SHA
-