Fixing BLS

secure_enclave/BLSUtils.cpp

@@ -3,8 +3,9 @@
 //
 
 #define GMP_WITH_SGX
+#include <string.h>
+#include "../sgxd_common.h"
 
-#define  MAX_SIG_LEN 1024
 
 #include "BLSUtils.h"
 #include "libff/algebra/curves/alt_bn128/alt_bn128_init.hpp"
@@ -43,16 +44,15 @@ std::string *stringFromFq(libff::alt_bn128_Fq*_fq) {
 std::string *stringFromG1(libff::alt_bn128_G1 *_g1) {
 
 
+  _g1->to_affine_coordinates();
+
   auto sX = stringFromFq(&_g1->X);
   auto sY = stringFromFq(&_g1->Y);
-  auto sZ = stringFromFq(&_g1->Z);
-
 
-  auto sG1 = new std::string(*sX + ":" +  *sY + ":" + *sZ);
+  auto sG1 = new std::string(*sX + ":" +  *sY);
 
   delete(sX);
   delete(sY);
-  delete(sZ);
 
   return sG1;
 
@@ -97,14 +97,14 @@ bool check_key(const char *_keyString) {
 
 
 
-char* sign(const char *_keyString, const char* _hashXString, const char* _hashYString,
-           const char* _hashZString) {
+bool sign(const char *_keyString, const char* _hashXString, const char* _hashYString,
+       char sig[BUF_LEN]) {
 
          auto key = keyFromString(_keyString);
 
          libff::alt_bn128_Fq hashX(_hashXString);
          libff::alt_bn128_Fq hashY(_hashYString);
-         libff::alt_bn128_Fq hashZ(_hashZString);
+         libff::alt_bn128_Fq hashZ = 1;
 
 
          libff::alt_bn128_G1 hash(hashX, hashY, hashZ);
@@ -112,15 +112,18 @@ char* sign(const char *_keyString, const char* _hashXString, const char* _hashYS
 
          libff::alt_bn128_G1 sign = key->as_bigint() * hash;  // sign
 
-         auto r = stringFromG1(&sign);
+         sign.to_affine_coordinates();
 
-         char* result = (char*) calloc(r->size() + 1, 1);
+         auto r = stringFromG1(&sign);
 
+         memset(sig, 0, BUF_LEN);
 
-         strncpy(result, r->c_str(), MAX_SIG_LEN);
+         strncpy(sig, r->c_str(), BUF_LEN);
 
          delete r;
 
-         return result;
+         return true;
+
+
 
 }

secure_enclave/BLSUtils.h

@@ -15,8 +15,8 @@
 
 EXTERNC bool check_key(const char* _keyString);
 
-EXTERNC char * sign(const char *_keyString, const char* _hashXString, const char* _hashYString,
-           const char* _hashZString);
+EXTERNC bool sign(const char *_keyString, const char* _hashXString, const char* _hashYString,
+           char* _sig);
 
 
 #endif //SGXD_BLSUTILS_H

secure_enclave/secure_enclave.c

@@ -251,8 +251,23 @@ void decrypt_key(int *err_status, char *err_string, uint8_t *encrypted_key,
 
 
 void bls_sign_message(int *err_status, char *err_string,  uint8_t *encrypted_key,
-                        uint32_t enc_len, char *messageX,
-                        char* messageY, char *signature) {
+                        uint32_t enc_len, char *_hashX,
+                        char* _hashY, char *signature) {
+
+
+  char key[BUF_LEN];
+  char sig[BUF_LEN];
+
+  decrypt_key(err_status, err_string, encrypted_key, enc_len, key);
+
+  if (err_status != 0) {
+    return;
+  }
+
+  sign(key, _hashX, _hashY, sig );
+
+  strncpy(signature, sig, BUF_LEN);
+
 
 }
 

sgxd.c

@@ -144,11 +144,15 @@ int main(int argc, char *argv[]) {
 
   gmp_printf("Encrypt key completed with status: %d %s \n", err_status, errMsg);
 
-  char *result = carray2Hex(encryptedKey, enc_len);
+  char result[BUF_LEN];
+
+  carray2Hex(encryptedKey, enc_len, result);
 
   uint64_t dec_len;
 
-  uint8_t* bin = hex2carray(result, &dec_len);
+  uint8_t bin[BUF_LEN];
+
+  hex2carray(result, &dec_len, bin);
 
   if (dec_len != enc_len) {
     return 1;

sgxd_common.h

@@ -29,45 +29,42 @@ inline int char2int(char _input) {
 
 
 
-char *carray2Hex(const uint8_t *d, int _len) {
-    char *hex = (char*) calloc(2 * _len, 1);
+void carray2Hex(const unsigned char *d, int _len, char* _hexArray) {
 
     static char hexval[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
                               '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
     for (int j = 0; j < _len; j++) {
-        hex[j * 2] = hexval[((d[j] >> 4) & 0xF)];
-        hex[j * 2 + 1] = hexval[(d[j]) & 0x0F];
+        _hexArray[j * 2] = hexval[((d[j] >> 4) & 0xF)];
+        _hexArray[j * 2 + 1] = hexval[(d[j]) & 0x0F];
     }
 
-    return hex;
 }
 
 
-uint8_t* hex2carray(const char * _hex, uint64_t *_bin_len) {
+int hex2carray(const char * _hex, unsigned long long  *_bin_len,
+    unsigned char* _bin ) {
 
-    uint64_t len = strlen(_hex);
+    int len = strnlen(_hex, BUF_LEN);
 
 
     if (len == 0 && len % 2 == 1)
-        return  NULL;
+        return -1;
 
     *_bin_len = len / 2;
 
-    uint8_t* bin = (uint8_t*) calloc(len / 2, 1);
-
-    for (uint64_t i = 0; i < len / 2; i++) {
+    for (int i = 0; i < len / 2; i++) {
         int high = char2int((char)_hex[i * 2]);
         int low = char2int((char)_hex[i * 2 + 1]);
 
         if (high < 0 || low < 0) {
-            return NULL;
+            return -1;
         }
 
-        bin[i] = (uint8_t) (high * 16 + low);
+        _bin[i] = (unsigned char) (high * 16 + low);
     }
 
-    return bin;
+
 }