Clean up

Author: chrismcgregor

.idea/.name

@@ -1,4 +1,4 @@
-<project name="outside" basedir=".">
+<project name="dispatch-labs-java-sdk" basedir=".">
 
     <!-- Target release -->
     <target name="release">

.idea/workspace.xml

@@ -84,17 +84,6 @@ public static void main(String args[]) {
             Account toAccount = Account.create();
             */
 
-
-            byte[] msg = new byte[32];
-            for (int i=0; i<32; i++) {
-                msg[i] = (byte)0xcc;
-            }
-
-
-            NativeSecp256k1.sign(Utils.toByteArray("2093fde230170efc92b2c122b8b831b30f916dd5568b50a427caa76e13e7effd"), msg);
-
-
-
             Sdk sdk = new Sdk("10.0.1.2");
 
             List<Contact> contacts = sdk.getDelegates();

build.xml

@@ -12,17 +12,12 @@ public class Crypto {
     /**
      *
      * @param privateKey
-     * @param bytes
+     * @param hash
      * @return
      * @throws Exception
      */
-    public static byte[] sign(byte[] privateKey, byte[] bytes) throws Exception {
-        /*
-        byte[] signature = NativeSecp256k1.Sign(bytes, privateKey);
-        signature = Arrays.copyOfRange(signature, 5, signature.length);
-        return signature;
-        */
-        return null;
+    public static byte[] sign(byte[] privateKey, byte[] hash) throws Exception {
+        return NativeSecp256k1.sign(privateKey, hash);
     }
 
     /**

src/main/java/dispatchlabs/Sdk.java

@@ -17,32 +17,32 @@
 
 package org.bitcoin;
 
-import dispatchlabs.utils.Utils;
-
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 /**
- * <p>This class holds native methods to handle ECDSA verification.</p>
- *
- * <p>You can find an example library that can be used for this at https://github.com/bitcoin/secp256k1</p>
  *
- * <p>To build secp256k1 for use with bitcoinj, run
- * `./configure --enable-jni --enable-experimental --enable-module-ecdh`
- * and `make` then copy `.libs/libsecp256k1.so` to your system library path
- * or point the JVM to the folder containing it with -Djava.library.path
- * </p>
  */
 public class NativeSecp256k1 {
 
-    private static final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
-    private static final Lock r = rwl.readLock();
-    private static final Lock w = rwl.writeLock();
+    /**
+     * Class level-declarations.
+     */
+    private static final ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
+    private static final Lock readLock = reentrantReadWriteLock.readLock();
+    private static final Lock writeLock = reentrantReadWriteLock.writeLock();
     private static ThreadLocal<ByteBuffer> nativeECDSABuffer = new ThreadLocal<ByteBuffer>();
 
+    /**
+     *
+      * @param privateKey
+     * @param hash
+     * @return
+     * @throws Exception
+     */
     public static byte[] sign(byte[] privateKey, byte[] hash) throws Exception {
         ByteBuffer byteBuff = nativeECDSABuffer.get();
         if (byteBuff == null || byteBuff.capacity() < 64) {
@@ -54,20 +54,19 @@ public static byte[] sign(byte[] privateKey, byte[] hash) throws Exception {
         byteBuff.put(privateKey);
         byteBuff.put(hash);
 
-        r.lock();
+        readLock.lock();
         try {
-            byte[] ret = secp256k1_ecdsa_sign_recoverable(byteBuff, Secp256k1Context.getContext());
-
-            System.out.println(Utils.toHexString(ret));
-
-            int fook =0;
+            return secp256k1_sign_and_serialize_compact(byteBuff, Secp256k1Context.getContext());
         } finally {
-            r.unlock();
+            readLock.unlock();
         }
-
-        return null;
     }
 
-    private static native byte[] secp256k1_ecdsa_sign_recoverable(ByteBuffer byteBuff, long context);
-    private static native byte[] secp256k1_ecdsa_recoverable_signature_serialize_compact(ByteBuffer byteBuff, long context);
+    /**
+     *
+     * @param byteBuff
+     * @param context
+     * @return
+     */
+    private static native byte[] secp256k1_sign_and_serialize_compact(ByteBuffer byteBuff, long context);
 }

src/main/java/dispatchlabs/crypto/Crypto.java

@@ -17,35 +17,51 @@
 package org.bitcoin;
 
 /**
- * This class holds the context reference used in native methods 
+ * This class holds the context reference used in native methods
  * to handle ECDSA operations.
  */
 public class Secp256k1Context {
-  private static final boolean enabled; //true if the library is loaded
-  private static final long context; //ref to pointer to context obj
 
-  static { //static initializer
-      boolean isEnabled = true;
-      long contextRef = -1;
-      try {
-          System.loadLibrary("secp256k1");
-          contextRef = secp256k1_init_context();
-      } catch (UnsatisfiedLinkError e) {
-          System.out.println("UnsatisfiedLinkError: " + e.toString());
-          isEnabled = false;
-      }
-      enabled = isEnabled;
-      context = contextRef;
-  }
+    /**
+     * Class level-declarations.
+     */
+    private static boolean enabled;
+    private static long context = -1;
 
-  public static boolean isEnabled() {
-     return enabled;
-  }
+    /**
+     *
+     */
+    static {
+        try {
+            System.loadLibrary("secp256k1");
+            context = secp256k1_init_context();
+            enabled = true;
+        } catch (UnsatisfiedLinkError e) {
+            System.out.println(e.toString());
+            System.out.println("make sure to set -Djava.library.path to the the secp256k1 library path");
+            enabled = false;
+        }
+    }
 
-  public static long getContext() {
-     if(!enabled) return -1; //sanity check
-     return context;
-  }
+    /**
+     *
+     * @return
+     */
+    public static boolean isEnabled() {
+        return enabled;
+    }
 
-  private static native long secp256k1_init_context();
+    /**
+     *
+     * @return
+     */
+    public static long getContext() {
+        return context;
+    }
+
+    /**
+     *
+     * @return
+     */
+    private static native long secp256k1_init_context();
 }

src/main/java/org/bitcoin/NativeSecp256k1.java

@@ -0,0 +1,37 @@
+#include <jni.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include "org_bitcoin_NativeSecp256k1.h"
+#include "include/secp256k1.h"
+#include "include/secp256k1_ecdh.h"
+#include "include/secp256k1_recovery.h"
+#include "scalar_impl.h"
+
+/*
+ * Class:     org_bitcoin_NativeSecp256k1
+ * Method:    secp256k1_sign_and_serialize_compact
+ * Signature: (Ljava/nio/ByteBuffer;J)[B
+ */
+JNIEXPORT jbyteArray JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1sign_1and_1serialize_1compact(JNIEnv *env, jclass jClass, jobject byteBufferObject, jlong contextObject)
+{
+  secp256k1_context *context = (secp256k1_context*)(uintptr_t)contextObject;
+  unsigned char* buffer = (unsigned char*) (*env)->GetDirectBufferAddress(env, byteBufferObject);
+  const unsigned char* privateKey = (unsigned char*) buffer;
+  const unsigned char* hash = (unsigned char*) (buffer + 32);
+
+  // Create signature.
+  secp256k1_ecdsa_recoverable_signature sigstruct;
+  int ret = secp256k1_ecdsa_sign_recoverable(context, &sigstruct, hash, privateKey, NULL, NULL);
+
+  // Serialize and compact signature.
+  unsigned char signature[65];
+  int recid;
+  secp256k1_ecdsa_recoverable_signature_serialize_compact(context, &signature[0], &recid, &sigstruct);
+  signature[64] = recid;
+
+  jbyteArray jByteArray = (*env)->NewByteArray(env, 65);
+  (*env)->SetByteArrayRegion(env, jByteArray, 0, 65, (jbyte*)signature);
+  return jByteArray;
+}