Skip to content

S
sgxwallet
Unverified Commit bf6cefc5 authored by kladko's avatar kladko
Browse files
Options

SKALE-3067-cleanup-sgx

parent e0ddaf50
Hide whitespace changes
Inline Side-by-side
Showing with 379 additions and 280 deletions
secure_enclave/DKGUtils.cpp
View file @ bf6cefc5
...@@ -26,7 +26,9 @@ ...@@ -26,7 +26,9 @@
#ifdef USER_SPACE #ifdef USER_SPACE
#include <gmp.h> #include <gmp.h>
#else #else
#include <../tgmp-build/include/sgx_tgmp.h> #include <../tgmp-build/include/sgx_tgmp.h>
#endif #endif
#include <../SCIPR/libff/algebra/curves/alt_bn128/alt_bn128_pp.hpp> #include <../SCIPR/libff/algebra/curves/alt_bn128/alt_bn128_pp.hpp>
...@@ -37,12 +39,16 @@ ...@@ -37,12 +39,16 @@
#include "EnclaveConstants.h" #include "EnclaveConstants.h"
#include <cstdio> #include <cstdio>
#include <stdio.h> #include <stdio.h>
#include "EnclaveCommon.h"
#include "DHDkg.h" #include "DHDkg.h"
using namespace std; using namespace std;
string stringFromFr(const libff::alt_bn128_Fr& _el) { string stringFromFr(const libff::alt_bn128_Fr &_el) {
try {
mpz_t t; mpz_t t;
mpz_init(t); mpz_init(t);
...@@ -54,280 +60,326 @@ string stringFromFr(const libff::alt_bn128_Fr& _el) { ...@@ -54,280 +60,326 @@ string stringFromFr(const libff::alt_bn128_Fr& _el) {
mpz_clear(t); mpz_clear(t);
return string(tmp); return string(tmp);
} catch (exception& e) {
LOG_ERROR(e.what());
return "";
} catch (...) {
LOG_ERROR("Unknown throwable");
return "";
}
} }
template<class T> string ConvertToString(const T& field_elem, int base = 10) { template<class T>
mpz_t t; string ConvertToString(const T &field_elem, int base = 10) {
mpz_init(t); try {
mpz_t t;
mpz_init(t);
field_elem.as_bigint().to_mpz(t);
field_elem.as_bigint().to_mpz(t); char arr[mpz_sizeinbase(t, base) + 2];
char arr[mpz_sizeinbase (t, base) + 2]; char *tmp = mpz_get_str(arr, base, t);
mpz_clear(t);
char * tmp = mpz_get_str(arr, base, t); string output = tmp;
mpz_clear(t);
string output = tmp; return output;
return output; } catch (exception &e) {
LOG_ERROR(e.what());
return "";
} catch (...) {
LOG_ERROR("Unknown throwable");
return "";
}
} }
string ConvertG2ToString(const libff::alt_bn128_G2 & elem, int base = 10, const string& delim = ":") { string ConvertG2ToString(const libff::alt_bn128_G2 &elem, int base = 10, const string &delim = ":") {
string result; try {
result += ConvertToString(elem.X.c0); string result;
result += delim; result += ConvertToString(elem.X.c0);
result += ConvertToString(elem.X.c1); result += delim;
result += delim; result += ConvertToString(elem.X.c1);
result += ConvertToString(elem.Y.c0); result += delim;
result += delim; result += ConvertToString(elem.Y.c0);
result += ConvertToString(elem.Y.c1); result += delim;
result += ConvertToString(elem.Y.c1);
return result;
return result;
} catch (exception &e) {
LOG_ERROR(e.what());
return nullptr;
} catch (...) {
LOG_ERROR("Unknown throwable");
return nullptr;
}
} }
vector<libff::alt_bn128_Fr> SplitStringToFr(const char* coeffs, const char symbol) { vector <libff::alt_bn128_Fr> SplitStringToFr(const char *coeffs, const char symbol) {
vector <libff::alt_bn128_Fr> tokens;
try {
string str(coeffs); string str(coeffs);
string delim; string delim;
delim.push_back(symbol); delim.push_back(symbol);
vector<libff::alt_bn128_Fr> tokens;
size_t prev = 0, pos = 0; size_t prev = 0, pos = 0;
do do {
{
pos = str.find(delim, prev); pos = str.find(delim, prev);
if (pos == string::npos) pos = str.length(); if (pos == string::npos) pos = str.length();
string token = str.substr(prev, pos-prev); string token = str.substr(prev, pos - prev);
if (!token.empty()) { if (!token.empty()) {
libff::alt_bn128_Fr coeff(token.c_str()); libff::alt_bn128_Fr coeff(token.c_str());
tokens.push_back(coeff); tokens.push_back(coeff);
} }
prev = pos + delim.length(); prev = pos + delim.length();
} } while (pos < str.length() && prev < str.length());
while (pos < str.length() && prev < str.length());
return tokens; return tokens;
} catch (exception& e) {
LOG_ERROR(e.what());
return tokens;
} catch (...) {
LOG_ERROR("Unknown throwable");
return tokens;
}
} }
int gen_dkg_poly( char* secret, unsigned _t ) { int gen_dkg_poly(char *secret, unsigned _t) {
libff::init_alt_bn128_params(); try {
string result; string result;
for (size_t i = 0; i < _t; ++i) { for (size_t i = 0; i < _t; ++i) {
libff::alt_bn128_Fr cur_coef = libff::alt_bn128_Fr::random_element(); libff::alt_bn128_Fr cur_coef = libff::alt_bn128_Fr::random_element();
while (i == _t - 1 && cur_coef == libff::alt_bn128_Fr::zero()) { while (i == _t - 1 && cur_coef == libff::alt_bn128_Fr::zero()) {
cur_coef = libff::alt_bn128_Fr::random_element(); cur_coef = libff::alt_bn128_Fr::random_element();
} }
result += stringFromFr(cur_coef); result += stringFromFr(cur_coef);
result += ":"; result += ":";
} }
strncpy(secret, result.c_str(), result.length() + 1); strncpy(secret, result.c_str(), result.length() + 1);
if (strlen(secret) == 0) { if (strlen(secret) == 0) {
return 1; return 1;
} }
return 0; return 0;
} catch (exception& e) {
LOG_ERROR(e.what());
return 1;
} catch (...) {
LOG_ERROR("Unknown throwable");
return 1;
}
} }
libff::alt_bn128_Fr PolynomialValue(const vector<libff::alt_bn128_Fr>& pol, libff::alt_bn128_Fr point, unsigned _t) { libff::alt_bn128_Fr PolynomialValue(const vector <libff::alt_bn128_Fr> &pol, libff::alt_bn128_Fr point, unsigned _t) {
libff::alt_bn128_Fr value = libff::alt_bn128_Fr::zero(); libff::alt_bn128_Fr value = libff::alt_bn128_Fr::zero();
libff::alt_bn128_Fr pow = libff::alt_bn128_Fr::one(); libff::alt_bn128_Fr pow = libff::alt_bn128_Fr::one();
for (unsigned i = 0; i < pol.size(); ++i) { for (unsigned i = 0; i < pol.size(); ++i) {
value += pol[i] * pow; value += pol[i] * pow;
pow *= point; pow *= point;
} }
return value; return value;
} }
void calc_secret_shares(const char* decrypted_coeffs, char * secret_shares, // calculates secret shares in base 10 to a string secret_shares, void calc_secret_shares(const char *decrypted_coeffs,
unsigned _t, unsigned _n) { // separated by ":" char *secret_shares, // calculates secret shares in base 10 to a string secret_shares,
// calculate for each node a list of secret values that will be used for verification unsigned _t, unsigned _n) { // separated by ":"
string result; // calculate for each node a list of secret values that will be used for verification
char symbol = ':'; string result;
vector<libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol); char symbol = ':';
vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
for (size_t i = 0; i < _n; ++i) {
libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(i + 1), _t); for (size_t i = 0; i < _n; ++i) {
result += ConvertToString(secret_share); libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(i + 1), _t);
result += ":"; result += ConvertToString(secret_share);
} result += ":";
strncpy(secret_shares, result.c_str(), result.length() + 1); }
strncpy(secret_shares, result.c_str(), result.length() + 1);
} }
int calc_secret_share(const char* decrypted_coeffs, char * s_share, int calc_secret_share(const char *decrypted_coeffs, char *s_share,
unsigned _t, unsigned _n, unsigned ind) { unsigned _t, unsigned _n, unsigned ind) {
libff::init_alt_bn128_params();
char symbol = ':'; char symbol = ':';
vector<libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol); vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
if ( poly.size() != _t) { if (poly.size() != _t) {
return 1; return 1;
} }
libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(ind), _t); libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(ind), _t);
string cur_share = ConvertToString(secret_share, 16); string cur_share = ConvertToString(secret_share, 16);
int n_zeroes = 64 - cur_share.size(); int n_zeroes = 64 - cur_share.size();
cur_share.insert(0, n_zeroes, '0'); cur_share.insert(0, n_zeroes, '0');
strncpy(s_share, cur_share.c_str(), cur_share.length() + 1); strncpy(s_share, cur_share.c_str(), cur_share.length() + 1);
return 0; return 0;
} }
void calc_secret_shareG2_old(const char* decrypted_coeffs, char * s_shareG2, void calc_secret_shareG2_old(const char *decrypted_coeffs, char *s_shareG2,
unsigned _t, unsigned ind) { unsigned _t, unsigned ind) {
libff::init_alt_bn128_params();
char symbol = ':'; char symbol = ':';
vector<libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol); vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(ind), _t); libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(ind), _t);
libff::alt_bn128_G2 secret_shareG2 = secret_share * libff::alt_bn128_G2::one(); libff::alt_bn128_G2 secret_shareG2 = secret_share * libff::alt_bn128_G2::one();
string secret_shareG2_str = ConvertG2ToString(secret_shareG2); string secret_shareG2_str = ConvertG2ToString(secret_shareG2);
strncpy(s_shareG2, secret_shareG2_str.c_str(), secret_shareG2_str.length() + 1); strncpy(s_shareG2, secret_shareG2_str.c_str(), secret_shareG2_str.length() + 1);
} }
int calc_secret_shareG2(const char* s_share, char * s_shareG2) { int calc_secret_shareG2(const char *s_share, char *s_shareG2) {
libff::init_alt_bn128_params();
mpz_t share;
mpz_init(share);
if (mpz_set_str(share, s_share, 16) == -1){
mpz_clear(share);
return 1;
}
char arr[mpz_sizeinbase (share, 10) + 2]; mpz_t share;
char * share_str = mpz_get_str(arr, 10, share); mpz_init(share);
if (mpz_set_str(share, s_share, 16) == -1) {
mpz_clear(share);
return 1;
}
char arr[mpz_sizeinbase(share, 10) + 2];
char *share_str = mpz_get_str(arr, 10, share);
libff::alt_bn128_Fr secret_share(share_str); libff::alt_bn128_Fr secret_share(share_str);
libff::alt_bn128_G2 secret_shareG2 = secret_share * libff::alt_bn128_G2::one(); libff::alt_bn128_G2 secret_shareG2 = secret_share * libff::alt_bn128_G2::one();
secret_shareG2.to_affine_coordinates(); secret_shareG2.to_affine_coordinates();
string secret_shareG2_str = ConvertG2ToString(secret_shareG2); string secret_shareG2_str = ConvertG2ToString(secret_shareG2);
strncpy(s_shareG2, secret_shareG2_str.c_str(), secret_shareG2_str.length() + 1); strncpy(s_shareG2, secret_shareG2_str.c_str(), secret_shareG2_str.length() + 1);
mpz_clear(share); mpz_clear(share);
return 0; return 0;
} }
int calc_public_shares(const char* decrypted_coeffs, char * public_shares, int calc_public_shares(const char *decrypted_coeffs, char *public_shares,
unsigned _t) { unsigned _t) {
libff::init_alt_bn128_params();
// calculate for each node a list of public shares // calculate for each node a list of public shares
string result; string result;
char symbol = ':'; char symbol = ':';
vector<libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol); vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
if (poly.size() != _t) { if (poly.size() != _t) {
return 1; return 1;
} }
for (size_t i = 0; i < _t; ++i) { for (size_t i = 0; i < _t; ++i) {
libff::alt_bn128_G2 pub_share = poly.at(i) * libff::alt_bn128_G2::one() ; libff::alt_bn128_G2 pub_share = poly.at(i) * libff::alt_bn128_G2::one();
pub_share.to_affine_coordinates(); pub_share.to_affine_coordinates();
string pub_share_str = ConvertG2ToString(pub_share); string pub_share_str = ConvertG2ToString(pub_share);
result += pub_share_str + ","; result += pub_share_str + ",";
} }
strncpy(public_shares, result.c_str(), result.length()); strncpy(public_shares, result.c_str(), result.length());
return 0; return 0;
} }
string ConvertHexToDec(string hex_str){ string ConvertHexToDec(string hex_str) {
mpz_t dec; mpz_t dec;
mpz_init(dec); mpz_init(dec);
if (mpz_set_str(dec, hex_str.c_str(), 16) == -1){ if (mpz_set_str(dec, hex_str.c_str(), 16) == -1) {
mpz_clear(dec); mpz_clear(dec);
return "false"; return "false";
} }
char arr[mpz_sizeinbase (dec, 10) + 2]; char arr[mpz_sizeinbase(dec, 10) + 2];
char * result = mpz_get_str(arr, 10, dec); char *result = mpz_get_str(arr, 10, dec);
mpz_clear(dec); mpz_clear(dec);
return result; return result;
} }
int Verification( char * public_shares, mpz_t decr_secret_share, int _t, int ind ) { int Verification(char *public_shares, mpz_t decr_secret_share, int _t, int ind) {
string pub_shares_str = public_shares; string pub_shares_str = public_shares;
libff::init_alt_bn128_params();
vector<libff::alt_bn128_G2> pub_shares;
uint64_t share_length = 256;
uint8_t coord_length = 64;
for (size_t i = 0; i < _t; ++i) { vector <libff::alt_bn128_G2> pub_shares;
libff::alt_bn128_G2 pub_share; uint64_t share_length = 256;
uint8_t coord_length = 64;
uint64_t pos0 = share_length * i; for (size_t i = 0; i < _t; ++i) {
string x_c0_str = ConvertHexToDec(pub_shares_str.substr(pos0, coord_length)); libff::alt_bn128_G2 pub_share;
string x_c1_str = ConvertHexToDec(pub_shares_str.substr(pos0 + coord_length, coord_length));
string y_c0_str = ConvertHexToDec(pub_shares_str.substr(pos0 + 2 * coord_length, coord_length)); uint64_t pos0 = share_length * i;
string y_c1_str = ConvertHexToDec(pub_shares_str.substr(pos0 + 3 * coord_length, coord_length)); string x_c0_str = ConvertHexToDec(pub_shares_str.substr(pos0, coord_length));
if (x_c0_str == "false" || x_c1_str == "false" || y_c0_str == "false" || y_c1_str == "false"){ string x_c1_str = ConvertHexToDec(pub_shares_str.substr(pos0 + coord_length, coord_length));
return 2; string y_c0_str = ConvertHexToDec(pub_shares_str.substr(pos0 + 2 * coord_length, coord_length));
} string y_c1_str = ConvertHexToDec(pub_shares_str.substr(pos0 + 3 * coord_length, coord_length));
pub_share.X.c0 = libff::alt_bn128_Fq(x_c0_str.c_str()); if (x_c0_str == "false" || x_c1_str == "false" || y_c0_str == "false" || y_c1_str == "false") {
pub_share.X.c1 = libff::alt_bn128_Fq(x_c1_str.c_str()); return 2;
pub_share.Y.c0 = libff::alt_bn128_Fq(y_c0_str.c_str()); }
pub_share.Y.c1 = libff::alt_bn128_Fq(y_c1_str.c_str()); pub_share.X.c0 = libff::alt_bn128_Fq(x_c0_str.c_str());
pub_share.Z = libff::alt_bn128_Fq2::one(); pub_share.X.c1 = libff::alt_bn128_Fq(x_c1_str.c_str());
pub_share.Y.c0 = libff::alt_bn128_Fq(y_c0_str.c_str());
pub_share.Y.c1 = libff::alt_bn128_Fq(y_c1_str.c_str());
pub_share.Z = libff::alt_bn128_Fq2::one();
pub_shares.push_back(pub_share); pub_shares.push_back(pub_share);
} }
libff::alt_bn128_G2 val = libff::alt_bn128_G2::zero(); libff::alt_bn128_G2 val = libff::alt_bn128_G2::zero();
for (int i = 0; i < _t; ++i) { for (int i = 0; i < _t; ++i) {
val = val + power(libff::alt_bn128_Fr(ind + 1), i) * pub_shares[i]; val = val + power(libff::alt_bn128_Fr(ind + 1), i) * pub_shares[i];
} }
char arr[mpz_sizeinbase (decr_secret_share, 10) + 2]; char arr[mpz_sizeinbase(decr_secret_share, 10) + 2];
char * tmp = mpz_get_str(arr, 10, decr_secret_share); char *tmp = mpz_get_str(arr, 10, decr_secret_share);
libff::alt_bn128_Fr sshare(tmp); libff::alt_bn128_Fr sshare(tmp);
libff::alt_bn128_G2 val2 = sshare * libff::alt_bn128_G2::one(); libff::alt_bn128_G2 val2 = sshare * libff::alt_bn128_G2::one();
memset(public_shares, 0, strlen(public_shares)); memset(public_shares, 0, strlen(public_shares));
strncpy(public_shares, tmp, strlen(tmp)); strncpy(public_shares, tmp, strlen(tmp));
val.to_affine_coordinates(); val.to_affine_coordinates();
val2.to_affine_coordinates(); val2.to_affine_coordinates();
strncpy(public_shares, ConvertToString(val.X.c0).c_str(), ConvertToString(val.X.c0).length()); strncpy(public_shares, ConvertToString(val.X.c0).c_str(), ConvertToString(val.X.c0).length());
strncpy(public_shares + ConvertToString(val.X.c0).length(), ":", 1); strncpy(public_shares + ConvertToString(val.X.c0).length(), ":", 1);
strncpy(public_shares + ConvertToString(val.X.c0).length() + 1, ConvertToString(val2.X.c0).c_str(), ConvertToString(val2.X.c0).length()); strncpy(public_shares + ConvertToString(val.X.c0).length() + 1, ConvertToString(val2.X.c0).c_str(),
ConvertToString(val2.X.c0).length());
return (val == sshare * libff::alt_bn128_G2::one()); return (val == sshare * libff::alt_bn128_G2::one());
} }
int calc_bls_public_key(char* skey_hex, char* pub_key) { int calc_bls_public_key(char *skey_hex, char *pub_key) {
libff::init_alt_bn128_params();
mpz_t skey;
mpz_init(skey);
if (mpz_set_str(skey, skey_hex, 16) == -1) {
mpz_clear(skey);
return 1;
}
char skey_dec[mpz_sizeinbase (skey, 10) + 2]; mpz_t skey;
mpz_get_str(skey_dec, 10, skey); mpz_init(skey);
if (mpz_set_str(skey, skey_hex, 16) == -1) {
mpz_clear(skey);
return 1;
}
char skey_dec[mpz_sizeinbase(skey, 10) + 2];
mpz_get_str(skey_dec, 10, skey);
libff::alt_bn128_Fr bls_skey(skey_dec); libff::alt_bn128_Fr bls_skey(skey_dec);
libff::alt_bn128_G2 public_key = bls_skey * libff::alt_bn128_G2::one(); libff::alt_bn128_G2 public_key = bls_skey * libff::alt_bn128_G2::one();
public_key.to_affine_coordinates(); public_key.to_affine_coordinates();
string result = ConvertG2ToString(public_key); string result = ConvertG2ToString(public_key);
strncpy(pub_key, result.c_str(), result.length()); strncpy(pub_key, result.c_str(), result.length());
mpz_clear(skey); mpz_clear(skey);
return 0; return 0;
} }
secure_enclave/EnclaveCommon.cpp
View file @ bf6cefc5
...@@ -36,66 +36,101 @@ ...@@ -36,66 +36,101 @@
using namespace std; using namespace std;
thread_local uint8_t decryptedDkgPoly[DKG_BUFER_LENGTH]; thread_local uint8_t decryptedDkgPoly[DKG_BUFER_LENGTH];
uint8_t* getThreadLocalDecryptedDkgPoly() {
uint8_t *getThreadLocalDecryptedDkgPoly() {
return decryptedDkgPoly; return decryptedDkgPoly;
} }
string *stringFromKey(libff::alt_bn128_Fr *_key) { string *stringFromKey(libff::alt_bn128_Fr *_key) {
mpz_t t; try {
mpz_init(t); mpz_t t;
mpz_init(t);
_key->as_bigint().to_mpz(t); _key->as_bigint().to_mpz(t);
char arr[mpz_sizeinbase(t, 10) + 2]; char arr[mpz_sizeinbase(t, 10) + 2];
char *tmp = mpz_get_str(arr, 10, t); char *tmp = mpz_get_str(arr, 10, t);
mpz_clear(t); mpz_clear(t);
return new string(tmp); return new string(tmp);
} catch (exception &e) {
LOG_ERROR(e.what());
return nullptr;
} catch (...) {
LOG_ERROR("Unknown throwable");
return nullptr;
}
} }
string *stringFromFq(libff::alt_bn128_Fq *_fq) { string *stringFromFq(libff::alt_bn128_Fq *_fq) {
mpz_t t; try {
mpz_init(t); mpz_t t;
mpz_init(t);
_fq->as_bigint().to_mpz(t); _fq->as_bigint().to_mpz(t);
char arr[mpz_sizeinbase(t, 10) + 2]; char arr[mpz_sizeinbase(t, 10) + 2];
char *tmp = mpz_get_str(arr, 10, t); char *tmp = mpz_get_str(arr, 10, t);
mpz_clear(t); mpz_clear(t);
return new string(tmp); return new string(tmp);
} catch (exception &e) {
LOG_ERROR(e.what());
return nullptr;
} catch (...) {
LOG_ERROR("Unknown throwable");
return nullptr;
}
} }
string *stringFromG1(libff::alt_bn128_G1 *_g1) { string *stringFromG1(libff::alt_bn128_G1 *_g1) {
_g1->to_affine_coordinates();
auto sX = stringFromFq(&_g1->X); try {
auto sY = stringFromFq(&_g1->Y); _g1->to_affine_coordinates();
auto sG1 = new string(*sX + ":" + *sY); auto sX = stringFromFq(&_g1->X);
auto sY = stringFromFq(&_g1->Y);
delete (sX); auto sG1 = new string(*sX + ":" + *sY);
delete (sY);
return sG1; delete (sX);
} delete (sY);
libff::alt_bn128_Fr *keyFromString(const char *_keyStringHex) { return sG1;
mpz_t skey;
mpz_init(skey);
mpz_set_str(skey, _keyStringHex, 16);
char skey_dec[mpz_sizeinbase (skey, 10) + 2]; } catch (exception &e) {
mpz_get_str(skey_dec, 10, skey); LOG_ERROR(e.what());
mpz_clear(skey); return nullptr;
} catch (...) {
LOG_ERROR("Unknown throwable");
return nullptr;
}
return new libff::alt_bn128_Fr(skey_dec); }
libff::alt_bn128_Fr *keyFromString(const char *_keyStringHex) {
try {
mpz_t skey;
mpz_init(skey);
mpz_set_str(skey, _keyStringHex, 16);
char skey_dec[mpz_sizeinbase(skey, 10) + 2];
mpz_get_str(skey_dec, 10, skey);
mpz_clear(skey);
return new libff::alt_bn128_Fr(skey_dec);
} catch (exception &e) {
LOG_ERROR(e.what());
return nullptr;
} catch (...) {
LOG_ERROR("Unknown throwable");
return nullptr;
}
} }
int inited = 0; int inited = 0;
...@@ -108,37 +143,47 @@ void enclave_init() { ...@@ -108,37 +143,47 @@ void enclave_init() {
} }
bool enclave_sign(const char *_keyString, const char *_hashXString, const char *_hashYString, bool enclave_sign(const char *_keyString, const char *_hashXString, const char *_hashYString,
char* sig) { char *sig) {
auto key = keyFromString(_keyString); try {
auto key = keyFromString(_keyString);
if (key == nullptr) { if (key == nullptr) {
throw exception(); throw invalid_argument("Null key");
} }
libff::alt_bn128_Fq hashX(_hashXString); libff::alt_bn128_Fq hashX(_hashXString);
libff::alt_bn128_Fq hashY(_hashYString); libff::alt_bn128_Fq hashY(_hashYString);
libff::alt_bn128_Fq hashZ = 1; libff::alt_bn128_Fq hashZ = 1;
libff::alt_bn128_G1 hash(hashX, hashY, hashZ); libff::alt_bn128_G1 hash(hashX, hashY, hashZ);
libff::alt_bn128_G1 sign = key->as_bigint() * hash; libff::alt_bn128_G1 sign = key->as_bigint() * hash;
delete key; delete key;
sign.to_affine_coordinates(); sign.to_affine_coordinates();
auto r = stringFromG1(&sign); auto r = stringFromG1(&sign);
memset(sig, 0, BUF_LEN); memset(sig, 0, BUF_LEN);
strncpy(sig, r->c_str(), BUF_LEN); strncpy(sig, r->c_str(), BUF_LEN);
delete r; delete r;
return true;
} catch (exception &e) {
LOG_ERROR(e.what());
return false;
} catch (...) {
LOG_ERROR("Unknown throwable");
return false;
}
return true;
} }
void carray2Hex(const unsigned char *d, int _len, char* _hexArray) { void carray2Hex(const unsigned char *d, int _len, char *_hexArray) {
char hexval[16] = {'0', '1', '2', '3', '4', '5', '6', '7', char hexval[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
...@@ -151,17 +196,17 @@ void carray2Hex(const unsigned char *d, int _len, char* _hexArray) { ...@@ -151,17 +196,17 @@ void carray2Hex(const unsigned char *d, int _len, char* _hexArray) {
} }
int char2int(char _input) { int char2int(char _input) {
if (_input >= '0' && _input <= '9') if (_input >= '0' && _input <= '9')
return _input - '0'; return _input - '0';
if (_input >= 'A' && _input <= 'F') if (_input >= 'A' && _input <= 'F')
return _input - 'A' + 10; return _input - 'A' + 10;
if (_input >= 'a' && _input <= 'f') if (_input >= 'a' && _input <= 'f')
return _input - 'a' + 10; return _input - 'a' + 10;
return -1; return -1;
} }
bool hex2carray2(const char * _hex, uint64_t *_bin_len, bool hex2carray2(const char *_hex, uint64_t *_bin_len,
uint8_t* _bin, const int _max_length ) { uint8_t *_bin, const int _max_length) {
int len = strnlen(_hex, _max_length); int len = strnlen(_hex, _max_length);
if (len == 0 && len % 2 == 1) if (len == 0 && len % 2 == 1)
...@@ -170,8 +215,8 @@ bool hex2carray2(const char * _hex, uint64_t *_bin_len, ...@@ -170,8 +215,8 @@ bool hex2carray2(const char * _hex, uint64_t *_bin_len,
*_bin_len = len / 2; *_bin_len = len / 2;
for (int i = 0; i < len / 2; i++) { for (int i = 0; i < len / 2; i++) {
int high = char2int((char)_hex[i * 2]); int high = char2int((char) _hex[i * 2]);
int low = char2int((char)_hex[i * 2 + 1]); int low = char2int((char) _hex[i * 2 + 1]);
if (high < 0 || low < 0) { if (high < 0 || low < 0) {
return false; return false;
...@@ -183,34 +228,36 @@ bool hex2carray2(const char * _hex, uint64_t *_bin_len, ...@@ -183,34 +228,36 @@ bool hex2carray2(const char * _hex, uint64_t *_bin_len,
return true; return true;
} }
bool hex2carray(const char * _hex, uint64_t *_bin_len, bool hex2carray(const char *_hex, uint64_t *_bin_len,
uint8_t* _bin ) { uint8_t *_bin) {
int len = strnlen(_hex, 2 * BUF_LEN); int len = strnlen(_hex, 2 * BUF_LEN);
if (len == 0 && len % 2 == 1) if (len == 0 && len % 2 == 1)
return false; return false;
*_bin_len = len / 2; *_bin_len = len / 2;
for (int i = 0; i < len / 2; i++) { for (int i = 0; i < len / 2; i++) {
int high = char2int((char)_hex[i * 2]); int high = char2int((char) _hex[i * 2]);
int low = char2int((char)_hex[i * 2 + 1]); int low = char2int((char) _hex[i * 2 + 1]);
if (high < 0 || low < 0) { if (high < 0 || low < 0) {
return false; return false;
} }
_bin[i] = (unsigned char) (high * 16 + low); _bin[i] = (unsigned char) (high * 16 + low);
} }
return true; return true;
} }
enum log_level {L_TRACE = 0, L_DEBUG = 1, L_INFO = 2, L_WARNING = 3, L_ERROR = 4 }; enum log_level {
L_TRACE = 0, L_DEBUG = 1, L_INFO = 2, L_WARNING = 3, L_ERROR = 4
};
uint32_t globalLogLevel_ = 2; uint32_t globalLogLevel_ = 2;
void logMsg(log_level _level, const char* _msg) { void logMsg(log_level _level, const char *_msg) {
if (_level < globalLogLevel_) if (_level < globalLogLevel_)
return; return;
...@@ -225,19 +272,19 @@ void logMsg(log_level _level, const char* _msg) { ...@@ -225,19 +272,19 @@ void logMsg(log_level _level, const char* _msg) {
} }
EXTERNC void LOG_INFO(const char* _msg) { EXTERNC void LOG_INFO(const char *_msg) {
logMsg(L_INFO, _msg); logMsg(L_INFO, _msg);
}; };
EXTERNC void LOG_WARN(const char* _msg) { EXTERNC void LOG_WARN(const char *_msg) {
logMsg(L_WARNING, _msg); logMsg(L_WARNING, _msg);
}; };
EXTERNC void LOG_ERROR(const char* _msg) { EXTERNC void LOG_ERROR(const char *_msg) {
logMsg(L_ERROR, _msg); logMsg(L_ERROR, _msg);
}; };
EXTERNC void LOG_DEBUG(const char* _msg) { EXTERNC void LOG_DEBUG(const char *_msg) {
logMsg(L_DEBUG, _msg); logMsg(L_DEBUG, _msg);
}; };
EXTERNC void LOG_TRACE(const char* _msg) { EXTERNC void LOG_TRACE(const char *_msg) {
logMsg(L_TRACE, _msg); logMsg(L_TRACE, _msg);
}; };
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment