Static bytesConverts a raw private key in bytes to its corresponding JSON Web Key (JWK) format.
The parameters for the symmetric key conversion.
The raw symmetric key as a Uint8Array.
A Promise that resolves to the symmetric key in JWK format.
This method takes a symmetric key represented as a byte array (Uint8Array) and converts it into a JWK object for use with the XChaCha20 symmetric encryption algorithm. The conversion process involves encoding the key into base64url format and setting the appropriate JWK parameters.
The resulting JWK object includes the following properties:
kty: Key Type, set to 'oct' for Octet Sequence (representing a symmetric key).k: The symmetric key, base64url-encoded.kid: Key ID, generated based on the JWK thumbprint.const privateKeyBytes = new Uint8Array([...]); // Replace with actual symmetric key bytes
const privateKey = await XChaCha20.bytesToPrivateKey({ privateKeyBytes });
Static decryptDecrypts the provided data using XChaCha20.
The parameters for the decryption operation.
The encrypted data to decrypt, represented as a Uint8Array.
The key to use for decryption, represented in JWK format.
The nonce used during the encryption process.
A Promise that resolves to the decrypted data as a Uint8Array.
This method performs XChaCha20 decryption on the given encrypted data using the specified key and nonce. The nonce should be the same as used in the encryption process and must be 24 bytes long. The method returns the decrypted data as a Uint8Array.
const encryptedData = new Uint8Array([...]); // Encrypted data
const nonce = new Uint8Array(24); // 24-byte nonce used during encryption
const key = { ... }; // A Jwk object representing the XChaCha20 key
const decryptedData = await XChaCha20.decrypt({
data: encryptedData,
nonce,
key
});
Static encryptEncrypts the provided data using XChaCha20.
A Promise that resolves to the encrypted data as a Uint8Array.
This method performs XChaCha20 encryption on the given data using the specified key and nonce. The nonce must be 24 bytes long, ensuring a high level of security through a vast nonce space, reducing the risks associated with nonce reuse. The method returns the encrypted data as a Uint8Array.
const data = new TextEncoder().encode('Messsage');
const nonce = utils.randomBytes(24); // 24-byte nonce for XChaCha20
const key = { ... }; // A Jwk object representing an XChaCha20 key
const encryptedData = await XChaCha20.encrypt({
data,
nonce,
key
});
Static generateGenerates a symmetric key for XChaCha20 in JSON Web Key (JWK) format.
A Promise that resolves to the generated symmetric key in JWK format.
This method creates a new symmetric key suitable for use with the XChaCha20 encryption algorithm. The key is generated using cryptographically secure random number generation to ensure its uniqueness and security. The XChaCha20 algorithm requires a 256-bit key (32 bytes), and this method adheres to that specification.
Key components included in the JWK:
kty: Key Type, set to 'oct' for Octet Sequence.k: The symmetric key component, base64url-encoded.kid: Key ID, generated based on the JWK thumbprint.const privateKey = await XChaCha20.generateKey();
Static privateConverts a private key from JSON Web Key (JWK) format to a raw byte array (Uint8Array).
A Promise that resolves to the symmetric key as a Uint8Array.
This method takes a symmetric key in JWK format and extracts its raw byte representation. It decodes the 'k' parameter of the JWK value, which represents the symmetric key in base64url encoding, into a byte array.
const privateKey = { ... }; // A symmetric key in JWK format
const privateKeyBytes = await XChaCha20.privateKeyToBytes({ privateKey });
The
XChaCha20class provides a comprehensive suite of utilities for cryptographic operations using the XChaCha20 symmetric encryption algorithm. This class includes methods for key generation, encryption, decryption, and conversions between raw byte arrays and JSON Web Key (JWK) formats. XChaCha20 is an extended nonce variant of ChaCha20, a stream cipher designed for high-speed encryption with substantial security margins.The XChaCha20 algorithm is particularly well-suited for encrypting large volumes of data or data streams, especially where random access is required. The class adheres to standard cryptographic practices, ensuring robustness and security in its implementations.
Key Features:
The methods in this class are asynchronous, returning Promises to accommodate various JavaScript environments.
Example