aegis-aead 0.2.0 → 0.2.1

package/src/aegis128x.ts

@@ -224,6 +224,35 @@ export class Aegis128XState {
 		return out;
 	}
 
+	/**
+	 * Encrypts a plaintext block in-place.
+	 * @param block - Buffer (plaintext in, ciphertext out), size 32*degree bytes
+	 */
+	encInPlace(block: Uint8Array): void {
+		this.computeZ();
+		const z0 = this.z0;
+		const z1 = this.z1;
+
+		const halfRateBytes = this.rate / 16;
+		const rateBytes = this.rate / 8;
+
+		this.update(
+			block.subarray(0, halfRateBytes),
+			block.subarray(halfRateBytes, rateBytes),
+		);
+
+		for (let i = 0; i < halfRateBytes; i++) block[i] ^= z0[i]!;
+		for (let i = 0; i < halfRateBytes; i++) block[halfRateBytes + i] ^= z1[i]!;
+	}
+
+	/**
+	 * Decrypts a ciphertext block in-place.
+	 * @param block - Buffer (ciphertext in, plaintext out), size 32*degree bytes
+	 */
+	decInPlace(block: Uint8Array): void {
+		this.decTo(block, block);
+	}
+
 	/**
 	 * Decrypts a partial (final) ciphertext block.
 	 * @param cn - Partial ciphertext block (smaller than 32*degree bytes)
@@ -487,6 +516,145 @@ export function aegis128XDecryptDetached(
 	return msg;
 }
 
+/**
+ * Encrypts a message in-place using AEGIS-128X (detached mode).
+ * The input buffer is modified to contain the ciphertext.
+ * @param data - Buffer containing plaintext (will be overwritten with ciphertext)
+ * @param ad - Associated data (authenticated but not encrypted)
+ * @param key - 16-byte encryption key
+ * @param nonce - 16-byte nonce (must be unique per message with the same key)
+ * @param tagLen - Authentication tag length: 16 or 32 bytes (default: 16)
+ * @param degree - Parallelism degree (default: 2)
+ * @returns Authentication tag
+ */
+export function aegis128XEncryptDetachedInPlace(
+	data: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	tagLen: 16 | 32 = 16,
+	degree: number = 2,
+): Uint8Array {
+	const state = new Aegis128XState(degree);
+	const rateBytes = (256 * degree) / 8;
+
+	state.init(key, nonce);
+
+	const adPadded = zeroPad(ad, rateBytes);
+	for (let i = 0; i + rateBytes <= adPadded.length; i += rateBytes) {
+		state.absorb(adPadded.subarray(i, i + rateBytes));
+	}
+
+	const msgLen = data.length;
+	const fullBlocksLen = Math.floor(msgLen / rateBytes) * rateBytes;
+
+	for (let i = 0; i < fullBlocksLen; i += rateBytes) {
+		state.encInPlace(data.subarray(i, i + rateBytes));
+	}
+
+	if (msgLen > fullBlocksLen) {
+		const lastPartial = data.subarray(fullBlocksLen);
+		const lastBlock = zeroPad(lastPartial, rateBytes);
+		const encBlock = state.enc(lastBlock);
+		lastPartial.set(encBlock.subarray(0, lastPartial.length));
+	}
+
+	return state.finalize(BigInt(ad.length * 8), BigInt(msgLen * 8), tagLen);
+}
+
+/**
+ * Decrypts a message in-place using AEGIS-128X (detached mode).
+ * The input buffer is modified to contain the plaintext (or zeroed on failure).
+ * @param data - Buffer containing ciphertext (will be overwritten with plaintext)
+ * @param tag - Authentication tag (16 or 32 bytes)
+ * @param ad - Associated data (must match what was used during encryption)
+ * @param key - 16-byte encryption key
+ * @param nonce - 16-byte nonce (must match what was used during encryption)
+ * @param degree - Parallelism degree (default: 2)
+ * @returns True if authentication succeeds, false otherwise
+ */
+export function aegis128XDecryptDetachedInPlace(
+	data: Uint8Array,
+	tag: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	degree: number = 2,
+): boolean {
+	const tagLen = tag.length as 16 | 32;
+	const state = new Aegis128XState(degree);
+	const rateBytes = (256 * degree) / 8;
+
+	state.init(key, nonce);
+
+	const adPadded = zeroPad(ad, rateBytes);
+	for (let i = 0; i + rateBytes <= adPadded.length; i += rateBytes) {
+		state.absorb(adPadded.subarray(i, i + rateBytes));
+	}
+
+	const msgLen = data.length;
+	const fullBlocksLen = Math.floor(msgLen / rateBytes) * rateBytes;
+
+	for (let i = 0; i < fullBlocksLen; i += rateBytes) {
+		state.decInPlace(data.subarray(i, i + rateBytes));
+	}
+
+	if (msgLen > fullBlocksLen) {
+		const lastPartial = data.subarray(fullBlocksLen);
+		const decrypted = state.decPartial(lastPartial);
+		lastPartial.set(decrypted);
+	}
+
+	const expectedTag = state.finalize(
+		BigInt(ad.length * 8),
+		BigInt(msgLen * 8),
+		tagLen,
+	);
+
+	if (!constantTimeEqual(tag, expectedTag)) {
+		data.fill(0);
+		return false;
+	}
+
+	return true;
+}
+
+/** AEGIS-128X2 in-place encryption - detached mode (degree=2). */
+export const aegis128X2EncryptDetachedInPlace = (
+	data: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	tagLen: 16 | 32 = 16,
+) => aegis128XEncryptDetachedInPlace(data, ad, key, nonce, tagLen, 2);
+
+/** AEGIS-128X2 in-place decryption - detached mode (degree=2). */
+export const aegis128X2DecryptDetachedInPlace = (
+	data: Uint8Array,
+	tag: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+) => aegis128XDecryptDetachedInPlace(data, tag, ad, key, nonce, 2);
+
+/** AEGIS-128X4 in-place encryption - detached mode (degree=4). */
+export const aegis128X4EncryptDetachedInPlace = (
+	data: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	tagLen: 16 | 32 = 16,
+) => aegis128XEncryptDetachedInPlace(data, ad, key, nonce, tagLen, 4);
+
+/** AEGIS-128X4 in-place decryption - detached mode (degree=4). */
+export const aegis128X4DecryptDetachedInPlace = (
+	data: Uint8Array,
+	tag: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+) => aegis128XDecryptDetachedInPlace(data, tag, ad, key, nonce, 4);
+
 /** Nonce size for AEGIS-128X in bytes. */
 export const AEGIS_128X_NONCE_SIZE = 16;
 

package/src/aegis256-bs.ts

@@ -210,6 +210,22 @@ export class Aegis256BsState {
 		return out;
 	}
 
+	/**
+	 * Encrypts a 16-byte plaintext block in-place.
+	 * @param block - 16-byte buffer (plaintext in, ciphertext out)
+	 */
+	encInPlace(block: Uint8Array): void {
+		this.encTo(block, block);
+	}
+
+	/**
+	 * Decrypts a 16-byte ciphertext block in-place.
+	 * @param block - 16-byte buffer (ciphertext in, plaintext out)
+	 */
+	decInPlace(block: Uint8Array): void {
+		this.decTo(block, block);
+	}
+
 	/**
 	 * Decrypts a partial (final) ciphertext block smaller than 16 bytes.
 	 * @param cn - Partial ciphertext block (1-15 bytes)
@@ -393,6 +409,97 @@ export function aegis256BsDecryptDetached(
 	return msg;
 }
 
+/**
+ * Encrypts a message in-place using bitsliced AEGIS-256 (detached mode).
+ * The input buffer is modified to contain the ciphertext.
+ * @param data - Buffer containing plaintext (will be overwritten with ciphertext)
+ * @param ad - Associated data (authenticated but not encrypted)
+ * @param key - 32-byte encryption key
+ * @param nonce - 32-byte nonce (must be unique per message with the same key)
+ * @param tagLen - Authentication tag length: 16 or 32 bytes (default: 16)
+ * @returns Authentication tag
+ */
+export function aegis256BsEncryptDetachedInPlace(
+	data: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	tagLen: 16 | 32 = 16,
+): Uint8Array {
+	const state = new Aegis256BsState();
+	state.init(key, nonce);
+
+	const adPadded = zeroPad(ad, RATE);
+	for (let i = 0; i + RATE <= adPadded.length; i += RATE) {
+		state.absorb(adPadded.subarray(i, i + RATE));
+	}
+
+	const msgLen = data.length;
+	const fullBlocksLen = Math.floor(msgLen / RATE) * RATE;
+
+	for (let i = 0; i < fullBlocksLen; i += RATE) {
+		state.encInPlace(data.subarray(i, i + RATE));
+	}
+
+	if (msgLen > fullBlocksLen) {
+		const lastPartial = data.subarray(fullBlocksLen);
+		const lastBlock = zeroPad(lastPartial, RATE);
+		const encBlock = state.enc(lastBlock);
+		lastPartial.set(encBlock.subarray(0, lastPartial.length));
+	}
+
+	return state.finalize(ad.length, msgLen, tagLen);
+}
+
+/**
+ * Decrypts a message in-place using bitsliced AEGIS-256 (detached mode).
+ * The input buffer is modified to contain the plaintext (or zeroed on failure).
+ * @param data - Buffer containing ciphertext (will be overwritten with plaintext)
+ * @param tag - Authentication tag (16 or 32 bytes)
+ * @param ad - Associated data (must match what was used during encryption)
+ * @param key - 32-byte encryption key
+ * @param nonce - 32-byte nonce (must match what was used during encryption)
+ * @returns True if authentication succeeds, false otherwise
+ */
+export function aegis256BsDecryptDetachedInPlace(
+	data: Uint8Array,
+	tag: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+): boolean {
+	const tagLen = tag.length as 16 | 32;
+	const state = new Aegis256BsState();
+	state.init(key, nonce);
+
+	const adPadded = zeroPad(ad, RATE);
+	for (let i = 0; i + RATE <= adPadded.length; i += RATE) {
+		state.absorb(adPadded.subarray(i, i + RATE));
+	}
+
+	const msgLen = data.length;
+	const fullBlocksLen = Math.floor(msgLen / RATE) * RATE;
+
+	for (let i = 0; i < fullBlocksLen; i += RATE) {
+		state.decInPlace(data.subarray(i, i + RATE));
+	}
+
+	if (msgLen > fullBlocksLen) {
+		const lastPartial = data.subarray(fullBlocksLen);
+		const decrypted = state.decPartial(lastPartial);
+		lastPartial.set(decrypted);
+	}
+
+	const expectedTag = state.finalize(ad.length, msgLen, tagLen);
+
+	if (!constantTimeEqual(tag, expectedTag)) {
+		data.fill(0);
+		return false;
+	}
+
+	return true;
+}
+
 export const AEGIS_256_BS_NONCE_SIZE = 32;
 export const AEGIS_256_BS_KEY_SIZE = 32;
 

package/src/aegis256.ts

@@ -173,6 +173,22 @@ export class Aegis256State {
 		return out;
 	}
 
+	/**
+	 * Encrypts a 16-byte plaintext block in-place.
+	 * @param block - 16-byte buffer (plaintext in, ciphertext out)
+	 */
+	encInPlace(block: Uint8Array): void {
+		this.encTo(block, block);
+	}
+
+	/**
+	 * Decrypts a 16-byte ciphertext block in-place.
+	 * @param block - 16-byte buffer (ciphertext in, plaintext out)
+	 */
+	decInPlace(block: Uint8Array): void {
+		this.decTo(block, block);
+	}
+
 	/**
 	 * Decrypts a partial (final) ciphertext block smaller than 16 bytes.
 	 * @param cn - Partial ciphertext block (1-15 bytes)
@@ -335,6 +351,101 @@ export function aegis256DecryptDetached(
 	return msg;
 }
 
+/**
+ * Encrypts a message in-place using AEGIS-256 (detached mode).
+ * The input buffer is modified to contain the ciphertext.
+ * @param data - Buffer containing plaintext (will be overwritten with ciphertext)
+ * @param ad - Associated data (authenticated but not encrypted)
+ * @param key - 32-byte encryption key
+ * @param nonce - 32-byte nonce (must be unique per message with the same key)
+ * @param tagLen - Authentication tag length: 16 or 32 bytes (default: 16)
+ * @returns Authentication tag
+ */
+export function aegis256EncryptDetachedInPlace(
+	data: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	tagLen: 16 | 32 = 16,
+): Uint8Array {
+	const state = new Aegis256State();
+	state.init(key, nonce);
+
+	const adPadded = zeroPad(ad, 16);
+	for (let i = 0; i + 16 <= adPadded.length; i += 16) {
+		state.absorb(adPadded.subarray(i, i + 16));
+	}
+
+	const msgLen = data.length;
+	const fullBlocksLen = Math.floor(msgLen / 16) * 16;
+
+	for (let i = 0; i < fullBlocksLen; i += 16) {
+		state.encInPlace(data.subarray(i, i + 16));
+	}
+
+	if (msgLen > fullBlocksLen) {
+		const lastPartial = data.subarray(fullBlocksLen);
+		const lastBlock = zeroPad(lastPartial, 16);
+		const encBlock = state.enc(lastBlock);
+		lastPartial.set(encBlock.subarray(0, lastPartial.length));
+	}
+
+	return state.finalize(BigInt(ad.length * 8), BigInt(msgLen * 8), tagLen);
+}
+
+/**
+ * Decrypts a message in-place using AEGIS-256 (detached mode).
+ * The input buffer is modified to contain the plaintext (or zeroed on failure).
+ * @param data - Buffer containing ciphertext (will be overwritten with plaintext)
+ * @param tag - Authentication tag (16 or 32 bytes)
+ * @param ad - Associated data (must match what was used during encryption)
+ * @param key - 32-byte encryption key
+ * @param nonce - 32-byte nonce (must match what was used during encryption)
+ * @returns True if authentication succeeds, false otherwise
+ */
+export function aegis256DecryptDetachedInPlace(
+	data: Uint8Array,
+	tag: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+): boolean {
+	const tagLen = tag.length as 16 | 32;
+	const state = new Aegis256State();
+	state.init(key, nonce);
+
+	const adPadded = zeroPad(ad, 16);
+	for (let i = 0; i + 16 <= adPadded.length; i += 16) {
+		state.absorb(adPadded.subarray(i, i + 16));
+	}
+
+	const msgLen = data.length;
+	const fullBlocksLen = Math.floor(msgLen / 16) * 16;
+
+	for (let i = 0; i < fullBlocksLen; i += 16) {
+		state.decInPlace(data.subarray(i, i + 16));
+	}
+
+	if (msgLen > fullBlocksLen) {
+		const lastPartial = data.subarray(fullBlocksLen);
+		const decrypted = state.decPartial(lastPartial);
+		lastPartial.set(decrypted);
+	}
+
+	const expectedTag = state.finalize(
+		BigInt(ad.length * 8),
+		BigInt(msgLen * 8),
+		tagLen,
+	);
+
+	if (!constantTimeEqual(tag, expectedTag)) {
+		data.fill(0);
+		return false;
+	}
+
+	return true;
+}
+
 /** Nonce size for AEGIS-256 in bytes. */
 export const AEGIS_256_NONCE_SIZE = 32;
 

package/src/aegis256x.ts

@@ -220,6 +220,22 @@ export class Aegis256XState {
 		return out;
 	}
 
+	/**
+	 * Encrypts a plaintext block in-place.
+	 * @param block - Buffer (plaintext in, ciphertext out), size 16*degree bytes
+	 */
+	encInPlace(block: Uint8Array): void {
+		this.encTo(block, block);
+	}
+
+	/**
+	 * Decrypts a ciphertext block in-place.
+	 * @param block - Buffer (ciphertext in, plaintext out), size 16*degree bytes
+	 */
+	decInPlace(block: Uint8Array): void {
+		this.decTo(block, block);
+	}
+
 	/**
 	 * Decrypts a partial (final) ciphertext block.
 	 * @param cn - Partial ciphertext block (smaller than 16*degree bytes)
@@ -461,6 +477,145 @@ export function aegis256XDecryptDetached(
 	return msg;
 }
 
+/**
+ * Encrypts a message in-place using AEGIS-256X (detached mode).
+ * The input buffer is modified to contain the ciphertext.
+ * @param data - Buffer containing plaintext (will be overwritten with ciphertext)
+ * @param ad - Associated data (authenticated but not encrypted)
+ * @param key - 32-byte encryption key
+ * @param nonce - 32-byte nonce (must be unique per message with the same key)
+ * @param tagLen - Authentication tag length: 16 or 32 bytes (default: 16)
+ * @param degree - Parallelism degree (default: 2)
+ * @returns Authentication tag
+ */
+export function aegis256XEncryptDetachedInPlace(
+	data: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	tagLen: 16 | 32 = 16,
+	degree: number = 2,
+): Uint8Array {
+	const state = new Aegis256XState(degree);
+	const rateBytes = (128 * degree) / 8;
+
+	state.init(key, nonce);
+
+	const adPadded = zeroPad(ad, rateBytes);
+	for (let i = 0; i + rateBytes <= adPadded.length; i += rateBytes) {
+		state.absorb(adPadded.subarray(i, i + rateBytes));
+	}
+
+	const msgLen = data.length;
+	const fullBlocksLen = Math.floor(msgLen / rateBytes) * rateBytes;
+
+	for (let i = 0; i < fullBlocksLen; i += rateBytes) {
+		state.encInPlace(data.subarray(i, i + rateBytes));
+	}
+
+	if (msgLen > fullBlocksLen) {
+		const lastPartial = data.subarray(fullBlocksLen);
+		const lastBlock = zeroPad(lastPartial, rateBytes);
+		const encBlock = state.enc(lastBlock);
+		lastPartial.set(encBlock.subarray(0, lastPartial.length));
+	}
+
+	return state.finalize(BigInt(ad.length * 8), BigInt(msgLen * 8), tagLen);
+}
+
+/**
+ * Decrypts a message in-place using AEGIS-256X (detached mode).
+ * The input buffer is modified to contain the plaintext (or zeroed on failure).
+ * @param data - Buffer containing ciphertext (will be overwritten with plaintext)
+ * @param tag - Authentication tag (16 or 32 bytes)
+ * @param ad - Associated data (must match what was used during encryption)
+ * @param key - 32-byte encryption key
+ * @param nonce - 32-byte nonce (must match what was used during encryption)
+ * @param degree - Parallelism degree (default: 2)
+ * @returns True if authentication succeeds, false otherwise
+ */
+export function aegis256XDecryptDetachedInPlace(
+	data: Uint8Array,
+	tag: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	degree: number = 2,
+): boolean {
+	const tagLen = tag.length as 16 | 32;
+	const state = new Aegis256XState(degree);
+	const rateBytes = (128 * degree) / 8;
+
+	state.init(key, nonce);
+
+	const adPadded = zeroPad(ad, rateBytes);
+	for (let i = 0; i + rateBytes <= adPadded.length; i += rateBytes) {
+		state.absorb(adPadded.subarray(i, i + rateBytes));
+	}
+
+	const msgLen = data.length;
+	const fullBlocksLen = Math.floor(msgLen / rateBytes) * rateBytes;
+
+	for (let i = 0; i < fullBlocksLen; i += rateBytes) {
+		state.decInPlace(data.subarray(i, i + rateBytes));
+	}
+
+	if (msgLen > fullBlocksLen) {
+		const lastPartial = data.subarray(fullBlocksLen);
+		const decrypted = state.decPartial(lastPartial);
+		lastPartial.set(decrypted);
+	}
+
+	const expectedTag = state.finalize(
+		BigInt(ad.length * 8),
+		BigInt(msgLen * 8),
+		tagLen,
+	);
+
+	if (!constantTimeEqual(tag, expectedTag)) {
+		data.fill(0);
+		return false;
+	}
+
+	return true;
+}
+
+/** AEGIS-256X2 in-place encryption - detached mode (degree=2). */
+export const aegis256X2EncryptDetachedInPlace = (
+	data: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	tagLen: 16 | 32 = 16,
+) => aegis256XEncryptDetachedInPlace(data, ad, key, nonce, tagLen, 2);
+
+/** AEGIS-256X2 in-place decryption - detached mode (degree=2). */
+export const aegis256X2DecryptDetachedInPlace = (
+	data: Uint8Array,
+	tag: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+) => aegis256XDecryptDetachedInPlace(data, tag, ad, key, nonce, 2);
+
+/** AEGIS-256X4 in-place encryption - detached mode (degree=4). */
+export const aegis256X4EncryptDetachedInPlace = (
+	data: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+	tagLen: 16 | 32 = 16,
+) => aegis256XEncryptDetachedInPlace(data, ad, key, nonce, tagLen, 4);
+
+/** AEGIS-256X4 in-place decryption - detached mode (degree=4). */
+export const aegis256X4DecryptDetachedInPlace = (
+	data: Uint8Array,
+	tag: Uint8Array,
+	ad: Uint8Array,
+	key: Uint8Array,
+	nonce: Uint8Array,
+) => aegis256XDecryptDetachedInPlace(data, tag, ad, key, nonce, 4);
+
 /** Nonce size for AEGIS-256X in bytes. */
 export const AEGIS_256X_NONCE_SIZE = 32;
 

package/src/index.ts

@@ -5,8 +5,10 @@ export {
 	aegis128LCreateNonce,
 	aegis128LDecrypt,
 	aegis128LDecryptDetached,
+	aegis128LDecryptDetachedInPlace,
 	aegis128LEncrypt,
 	aegis128LEncryptDetached,
+	aegis128LEncryptDetachedInPlace,
 	aegis128LMac,
 	aegis128LMacVerify,
 } from "./aegis128l.js";
@@ -18,8 +20,10 @@ export {
 	aegis128LBsCreateNonce,
 	aegis128LBsDecrypt,
 	aegis128LBsDecryptDetached,
+	aegis128LBsDecryptDetachedInPlace,
 	aegis128LBsEncrypt,
 	aegis128LBsEncryptDetached,
+	aegis128LBsEncryptDetachedInPlace,
 	aegis128LBsMac,
 	aegis128LBsMacVerify,
 } from "./aegis128l-bs.js";
@@ -30,24 +34,30 @@ export {
 	aegis128X2CreateNonce,
 	aegis128X2Decrypt,
 	aegis128X2DecryptDetached,
+	aegis128X2DecryptDetachedInPlace,
 	aegis128X2Encrypt,
 	aegis128X2EncryptDetached,
+	aegis128X2EncryptDetachedInPlace,
 	aegis128X2Mac,
 	aegis128X2MacVerify,
 	aegis128X4CreateKey,
 	aegis128X4CreateNonce,
 	aegis128X4Decrypt,
 	aegis128X4DecryptDetached,
+	aegis128X4DecryptDetachedInPlace,
 	aegis128X4Encrypt,
 	aegis128X4EncryptDetached,
+	aegis128X4EncryptDetachedInPlace,
 	aegis128X4Mac,
 	aegis128X4MacVerify,
 	aegis128XCreateKey,
 	aegis128XCreateNonce,
 	aegis128XDecrypt,
 	aegis128XDecryptDetached,
+	aegis128XDecryptDetachedInPlace,
 	aegis128XEncrypt,
 	aegis128XEncryptDetached,
+	aegis128XEncryptDetachedInPlace,
 	aegis128XMac,
 	aegis128XMacVerify,
 } from "./aegis128x.js";
@@ -58,8 +68,10 @@ export {
 	aegis256CreateNonce,
 	aegis256Decrypt,
 	aegis256DecryptDetached,
+	aegis256DecryptDetachedInPlace,
 	aegis256Encrypt,
 	aegis256EncryptDetached,
+	aegis256EncryptDetachedInPlace,
 	aegis256Mac,
 	aegis256MacVerify,
 } from "./aegis256.js";
@@ -71,8 +83,10 @@ export {
 	aegis256BsCreateNonce,
 	aegis256BsDecrypt,
 	aegis256BsDecryptDetached,
+	aegis256BsDecryptDetachedInPlace,
 	aegis256BsEncrypt,
 	aegis256BsEncryptDetached,
+	aegis256BsEncryptDetachedInPlace,
 	aegis256BsMac,
 	aegis256BsMacVerify,
 } from "./aegis256-bs.js";
@@ -83,24 +97,30 @@ export {
 	aegis256X2CreateNonce,
 	aegis256X2Decrypt,
 	aegis256X2DecryptDetached,
+	aegis256X2DecryptDetachedInPlace,
 	aegis256X2Encrypt,
 	aegis256X2EncryptDetached,
+	aegis256X2EncryptDetachedInPlace,
 	aegis256X2Mac,
 	aegis256X2MacVerify,
 	aegis256X4CreateKey,
 	aegis256X4CreateNonce,
 	aegis256X4Decrypt,
 	aegis256X4DecryptDetached,
+	aegis256X4DecryptDetachedInPlace,
 	aegis256X4Encrypt,
 	aegis256X4EncryptDetached,
+	aegis256X4EncryptDetachedInPlace,
 	aegis256X4Mac,
 	aegis256X4MacVerify,
 	aegis256XCreateKey,
 	aegis256XCreateNonce,
 	aegis256XDecrypt,
 	aegis256XDecryptDetached,
+	aegis256XDecryptDetachedInPlace,
 	aegis256XEncrypt,
 	aegis256XEncryptDetached,
+	aegis256XEncryptDetachedInPlace,
 	aegis256XMac,
 	aegis256XMacVerify,
 } from "./aegis256x.js";