From: Chris Duncan <chris@codecow.com>
Date: Mon, 17 Aug 2026 15:55:07 +0000 (-0700)
Subject: Specify buffer sizes for clarity in implementation.
X-Git-Url: https://git.codecow.com/?a=commitdiff_plain;h=7a9b5cfe410aa2bf749001bc3b5bbe88099e4e2f;p=nano25519.git

Specify buffer sizes for clarity in implementation.
---

diff --git a/src/assembly/index.ts b/src/assembly/index.ts
index cc48790..7bbad58 100644
--- a/src/assembly/index.ts
+++ b/src/assembly/index.ts
@@ -11,12 +11,14 @@ const PRIVATEKEY_BYTES: i32 = 32
 const PUBLICKEY_BYTES: i32 = 32
 const SECRETKEY_BYTES: i32 = PRIVATEKEY_BYTES + PUBLICKEY_BYTES
 const SIGNATURE_BYTES: i32 = 64
-const SIGNEDMESSAGE_BYTES: i32 = SIGNATURE_BYTES + MESSAGE_BYTES
 
 // Static I/O buffers
-const OUTPUT_BUFFER = memory.data(64)
-const INPUT_BUFFER = memory.data(128)
-const MESSAGE_BUFFER = memory.data(32768)
+const INPUT_BUFFER_BYTES: i32 = SIGNATURE_BYTES + MESSAGE_BYTES
+const OUTPUT_BUFFER_BYTES: i32 = SIGNATURE_BYTES
+const MESSAGE_BUFFER_BYTES: i32 = 32768
+const INPUT_BUFFER = memory.data(INPUT_BUFFER_BYTES)
+const OUTPUT_BUFFER = memory.data(OUTPUT_BUFFER_BYTES)
+const MESSAGE_BUFFER = memory.data(MESSAGE_BUFFER_BYTES)
 
 // crypto_hash function
 const blake2b = new Blake2b()
@@ -159,19 +161,18 @@ export function getMessagePointer (): usize {
 export function derive (): void {
 	const pk = changetype<StaticArray<u8>>(OUTPUT_BUFFER)
 	const seed = changetype<StaticArray<u8>>(INPUT_BUFFER)
-	memory.fill(OUTPUT_BUFFER, 0, SECRETKEY_BYTES)
+	memory.fill(OUTPUT_BUFFER, 0, OUTPUT_BUFFER_BYTES)
 	crypto_derive(pk, seed)
-	memory.fill(INPUT_BUFFER, 0, PRIVATEKEY_BYTES)
+	memory.fill(INPUT_BUFFER, 0, INPUT_BUFFER_BYTES)
 }
 
-const sign_s = new StaticArray<u8>(SIGNEDMESSAGE_BYTES)
+const sign_s = new StaticArray<u8>(SIGNATURE_BYTES)
 /**
- * Sign a message using a private key. The signature is written to the static
- * output buffer. This mirrors the functionality of `nacl.sign.detached()`.
+ * Retrieve up to 32 KiB of data from the message buffer and a 64-byte secret
+ * key from the input buffer, and then sign the message using a secret key. The
+ * signature is detached from the message and written to the output buffer.
  *
- * @param {u64} m - Message to sign (variable byte length up to 32 KiB)
- * @param {i32} mlen - Byte length of message
- * @param {u64} sk - 64-byte secret key (32-byte private key + 32-byte public key)
+ * @param {i32} mlen - Byte length of message, up to 32768
  */
 export function sign (mlen: i32): void {
 	if (mlen < 0 || mlen > 32768) throw new Error()
@@ -179,10 +180,10 @@ export function sign (mlen: i32): void {
 	const m = MESSAGE_BUFFER
 	const sk = changetype<StaticArray<u8>>(INPUT_BUFFER)
 
-	memory.fill(OUTPUT_BUFFER, 0, SIGNATURE_BYTES)
+	memory.fill(OUTPUT_BUFFER, 0, OUTPUT_BUFFER_BYTES)
 	crypto_sign(s, m, mlen, sk)
 	memory.copy(OUTPUT_BUFFER, changetype<usize>(s), SIGNATURE_BYTES)
-	memory.fill(INPUT_BUFFER, 0, SECRETKEY_BYTES)
+	memory.fill(INPUT_BUFFER, 0, INPUT_BUFFER_BYTES)
 }
 
 const verify_s = new StaticArray<u8>(SIGNATURE_BYTES)
@@ -202,6 +203,6 @@ export function verify (mlen: i32): i32 {
 
 	memory.copy(changetype<usize>(s), INPUT_BUFFER, SIGNATURE_BYTES)
 	memory.copy(changetype<usize>(k), INPUT_BUFFER + SIGNATURE_BYTES, PUBLICKEY_BYTES)
-	memory.fill(INPUT_BUFFER, 0, SIGNATURE_BYTES)
+	memory.fill(INPUT_BUFFER, 0, INPUT_BUFFER_BYTES)
 	return crypto_verify(s, m, mlen, k)
 }