add init keyed and init derive_key

.gitignore

@@ -3,3 +3,4 @@
 *.o
 *.class
 target/
+*.log

src/main/c/org_scash_JNI.c

@@ -36,6 +36,37 @@ JNIEXPORT void JNICALL Java_org_scash_JNI_blake3_1hasher_1init
         return;
   }
 
+JNIEXPORT void JNICALL Java_org_scash_JNI_blake3_1hasher_1init_1keyed
+  (JNIEnv *env, jclass classObject, jlong hp, jobject byteBuffer)
+  {
+        blake3_hasher *hasher = (blake3_hasher*)(uintptr_t)hp;
+        uint8_t *key = (uint8_t*) (*env)->GetDirectBufferAddress(env, byteBuffer);
+
+        uint8_t keyarr[BLAKE3_KEY_LEN];
+
+        for (size_t i = 0; i < BLAKE3_KEY_LEN; i++) {
+            keyarr[i] = key[i];
+        }
+
+        blake3_hasher_init_keyed(hasher, keyarr);
+
+        (void)classObject;
+        return;
+  }
+
+JNIEXPORT void JNICALL Java_org_scash_JNI_blake3_1hasher_1init_1derive_1key
+  (JNIEnv *env, jclass classObject, jlong hp, jstring ctx)
+  {
+        blake3_hasher *hasher = (blake3_hasher*)(uintptr_t)hp;
+
+        const char *context = (*env)->GetStringUTFChars(env, ctx, 0);
+
+        blake3_hasher_init_derive_key(hasher, context);
+
+        (*env)->ReleaseStringUTFChars(env, ctx, context);
+        (void)classObject;
+  }
+
 JNIEXPORT void JNICALL Java_org_scash_JNI_blake3_1hasher_1update
   (JNIEnv *env, jclass classObject, jlong hp, jobject byteBuffer, jint input_len)
   {
@@ -49,20 +80,16 @@ JNIEXPORT void JNICALL Java_org_scash_JNI_blake3_1hasher_1update
         return;
   }
 
-JNIEXPORT jbyteArray JNICALL Java_org_scash_JNI_blake3_1hasher_1finalize
-  (JNIEnv *env, jclass classObject, jlong hp, jint output_len)
+JNIEXPORT void JNICALL Java_org_scash_JNI_blake3_1hasher_1finalize
+  (JNIEnv *env, jclass classObject, jlong hp, jobject byteBuffer, jint output_len)
   {
         blake3_hasher *hasher = (blake3_hasher*)(uintptr_t)hp;
 
-        jbyteArray retArray;
-        uint8_t output[output_len];
+        uint8_t *output = (uint8_t*) (*env)->GetDirectBufferAddress(env, byteBuffer);
 
         blake3_hasher_finalize(hasher, output, output_len);
 
-        retArray = (*env)->NewByteArray(env, output_len);
-        (*env)->SetByteArrayRegion(env, retArray, 0, output_len, (jbyte*)output);
-
         (void)classObject;
 
-        return retArray;
+        return;
   }

src/main/java/org/scash/JNI.java

@@ -9,7 +9,11 @@ class JNI {
 
     static native void blake3_hasher_init(long hasher);
 
-    static native void blake3_hasher_update(long hasher, ByteBuffer byteBuff, long input_len);
+    static native void blake3_hasher_init_keyed(long hasher, ByteBuffer byteBuff);
 
-    static native byte[] blake3_hasher_finalize(long hasher, long out_len);
+    static native void blake3_hasher_init_derive_key(long hasher, String context);
+
+    static native void blake3_hasher_update(long hasher, ByteBuffer byteBuff, int input_len);
+
+    static native void blake3_hasher_finalize(long hasher, ByteBuffer byteBuff, int out_len);
 }

src/main/java/org/scash/NativeBLAKE3.java

@@ -44,7 +44,15 @@ public static boolean isEnabled() {
 
     public NativeBLAKE3() throws IllegalStateException {
         checkState(enabled);
-        long initHasher = JNI.create_hasher();
+        long initHasher;
+
+        w.lock();
+        try {
+            initHasher = JNI.create_hasher();
+        } finally {
+            w.unlock();
+        }
+
         checkState(initHasher != 0);
         hasher = initHasher;
     }
@@ -68,7 +76,35 @@ public void initDefault() {
         }
     }
 
-    public void update(byte[] data) {
+    public void initKeyed(byte[] key) {
+        checkArgument(key.length == KEY_LEN);
+        ByteBuffer byteBuff = nativeByteBuffer.get();
+        if (byteBuff == null || byteBuff.capacity() < key.length) {
+            byteBuff = ByteBuffer.allocateDirect(key.length);
+            byteBuff.order(ByteOrder.nativeOrder());
+            nativeByteBuffer.set(byteBuff);
+        }
+        byteBuff.rewind();
+        byteBuff.put(key);
+
+        w.lock();
+        try {
+            JNI.blake3_hasher_init_keyed(getHasher(), byteBuff);
+        } finally {
+            w.unlock();
+        }
+    }
+
+    public void initDeriveKey(String context) {
+        w.lock();
+        try {
+            JNI.blake3_hasher_init_derive_key(getHasher(), context);
+        } finally {
+            w.unlock();
+        }
+    }
+
+    public void update(byte[] data) throws InvalidNativeOutput {
         ByteBuffer byteBuff = nativeByteBuffer.get();
 
         if (byteBuff == null || byteBuff.capacity() < data.length) {
@@ -86,19 +122,34 @@ public void update(byte[] data) {
         }
     }
 
-    public byte[] getOutput() throws Exception {
+    public byte[] getOutput() throws InvalidNativeOutput {
         return getOutput(OUT_LEN);
     }
 
-    public byte[] getOutput(int outputLength) throws Exception {
-        byte[] retByteArray;
+    public byte[] getOutput(int outputLength) throws InvalidNativeOutput {
+        ByteBuffer byteBuff = nativeByteBuffer.get();
+
+        if (byteBuff == null || byteBuff.capacity() < outputLength) {
+            byteBuff = ByteBuffer.allocateDirect(outputLength);
+            byteBuff.order(ByteOrder.nativeOrder());
+            nativeByteBuffer.set(byteBuff);
+        }
+        byteBuff.rewind();
+
         r.lock();
         try {
-            retByteArray = JNI.blake3_hasher_finalize(getHasher(), outputLength);
+            JNI.blake3_hasher_finalize(getHasher(), byteBuff, outputLength);
         } finally {
             r.unlock();
         }
+
+        byte[] retByteArray = new byte[outputLength];
+        byteBuff.get(retByteArray);
+
+        nativeByteBuffer.set(byteBuff.clear());
+
         checkOutput(retByteArray.length == outputLength, "Output size produced by lib doesnt match:" + retByteArray.length + " expected:" + outputLength);
+
         return retByteArray;
     }