Specify buffer sizes for clarity in implementation.

diff --git a/src/assembly/index.ts b/src/assembly/index.ts
index cc487902de921b921cf78b76c1ab95764ad490e2..7bbad5871c5b9b7d1d8568b08b2f80ba5699d53d 100644 (file)
--- 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)
 }