void PRE_IO_rekey2file( char *file,PRE_REKEY *rekey,EC_GROUP *G )
{
FILE *fp;
if( NULL == (fp = fopen( file,"wb")) )exit(1);
/*Write order：
* v->U->W
*/
BN_CTX *ctx = BN_CTX_new();
char *v = BN_bn2hex(rekey->v);
char *U = EC_POINT_point2hex(G,rekey->U,PRE_POINT_CONVERSION,ctx);
char *W = EC_POINT_point2hex(G,rekey->W,PRE_POINT_CONVERSION,ctx);
int strlenOfV = strlen(v);
int strlenOfU = strlen(U);
int strlenOfW = strlen(W);
fwrite(&strlenOfV,sizeOfInt,1,fp);
fwrite(&strlenOfU,sizeOfInt,1,fp);
fwrite(&strlenOfW,sizeOfInt,1,fp);
fwrite(v,strlenOfV,1,fp);
fwrite(U,strlenOfU,1,fp);
fwrite(W,strlenOfW,1,fp);
BN_CTX_free(ctx);
fclose(fp);
}
void PRE_IO_key2file(char* dir,char* fileName,unsigned char *key,PRE_KEY *key1,PRE_KEY *key2)
{
FILE *fp;
if( 0 == PRE_mkdir(dir) ||
NULL == ( fp = fopen(fileName,"wb+") ))
exit(1);
/*Write order：
* E->F->U->W
*/
PRE_REKEY *reKey = new PRE_REKEY(key1,key2->pk);
Cipher *C = Encrypt(key1->pk,key);
Cipher_REKEY *C_r = ReEncrypt(reKey,C);
BN_CTX *ctx = BN_CTX_new();
char *F = EC_POINT_point2hex(params->G,C_r->F,PRE_POINT_CONVERSION,ctx);
char *U = EC_POINT_point2hex(params->G,C_r->U,PRE_POINT_CONVERSION,ctx);
char *W = EC_POINT_point2hex(params->G,C_r->W,PRE_POINT_CONVERSION,ctx);
int strlenOfE = 128;//strlen(C_r->E);
int strlenOfF = strlen(F);
int strlenOfU = strlen(U);
int strlenOfW = strlen(W);
fwrite(&strlenOfE,sizeOfInt,1,fp);
fwrite(&strlenOfF,sizeOfInt,1,fp);
fwrite(&strlenOfU,sizeOfInt,1,fp);
fwrite(&strlenOfW,sizeOfInt,1,fp);
fwrite(C_r->E,strlenOfE,1,fp);
fwrite( F,strlenOfF, 1,fp);
fwrite( U,strlenOfU, 1,fp);
fwrite( W,strlenOfW, 1,fp);
fclose(fp);
}
static pubkeybatch_t *
pubkeybatch_avl_search(avl_root_t *rootp, const EC_POINT *pubkey,
const EC_GROUP *pgroup)
{
char *pubkey_hex;
pubkeybatch_t *vp;
avl_item_t *itemp = rootp->ar_root;
pubkey_hex = EC_POINT_point2hex(pgroup,
pubkey,
POINT_CONVERSION_UNCOMPRESSED,
NULL);
while (itemp) {
int cmpres;
vp = avl_item_entry(itemp, pubkeybatch_t, avlent);
cmpres = strcmp(pubkey_hex, vp->pubkey_hex);
if (cmpres > 0) {
itemp = itemp->ai_left;
} else {
if (cmpres < 0) {
itemp = itemp->ai_right;
} else {
OPENSSL_free(pubkey_hex);
return vp;
}
}
}
OPENSSL_free(pubkey_hex);
return NULL;
}
void PRE_IO_Cipher2file(Cipher_REKEY *C,EC_GROUP *G,char *file)
{
FILE *fp;
if ( NULL == (fp = fopen( file,"wb")) )exit(1);
BN_CTX *ctx = BN_CTX_new();
char *F = EC_POINT_point2hex(G,C->F,PRE_POINT_CONVERSION,ctx);
char *U = EC_POINT_point2hex(G,C->U,PRE_POINT_CONVERSION,ctx);
char *W = EC_POINT_point2hex(G,C->W,PRE_POINT_CONVERSION,ctx);
fwrite(C->E,sizeof(C->E),1,fp);
fwrite( F,sizeof(F), 1,fp);
fwrite( U,sizeof(U), 1,fp);
fwrite( W,sizeof(W), 1,fp);
BN_CTX_free(ctx);
fclose(fp);
}
void PRE_IO_prekey2file(PRE_KEY *key,EC_GROUP *G,char *file)
{
FILE *fp;
if ( NULL == (fp = fopen( file,"wb")) )exit(1);
BN_CTX *ctx = BN_CTX_new();
char *pk1 = EC_POINT_point2hex(G,key->pk->pk1,POINT_CONVERSION_UNCOMPRESSED,ctx);
char *pk2 = EC_POINT_point2hex(G,key->pk->pk2,POINT_CONVERSION_UNCOMPRESSED,ctx);
char *sk1 = BN_bn2hex(key->sk->x1);
char *sk2 = BN_bn2hex(key->sk->x2);
int sizeOfPk1 = sizeof(pk1);
int sizeOfPk2 = sizeof(pk2);
int sizeOfSk1 = sizeof(sk1);
int sizeOfSk2 = sizeof(sk2);
fwrite(&sizeOfPk1,sizeOfInt,1,fp);fwrite(pk1,sizeof(pk1),1,fp);
fwrite(&sizeOfPk2,sizeOfInt,1,fp);fwrite(pk2,sizeof(pk2),1,fp);
fwrite(&sizeOfSk1,sizeOfInt,1,fp);fwrite(sk1,sizeof(sk1),1,fp);
fwrite(&sizeOfSk2,sizeOfInt,1,fp);fwrite(sk2,sizeof(sk2),1,fp);
BN_CTX_free(ctx);
fclose(fp);
}
int VNEcdsa_ORG_DumpPubKey( const VNAsymCryptCtx_t * ctx,
struct vn_iovec * hexPubKey )
{
char * tmp = NULL;
const EC_POINT * point = NULL;
const VNEcdsa_ORG_Ctx_t * orgCtx = VN_CONTAINER_OF( ctx, VNEcdsa_ORG_Ctx_t, mCtx );
assert( VN_TYPE_VNEcdsaSign_ORG == ctx->mType );
point = EC_KEY_get0_public_key( orgCtx->mEcKey );
tmp = EC_POINT_point2hex( EC_KEY_get0_group( orgCtx->mEcKey ),
point, POINT_CONVERSION_UNCOMPRESSED, NULL );
hexPubKey->i.iov_len = strlen( tmp );
hexPubKey->i.iov_base = strdup( tmp );
OPENSSL_free( tmp );
return 0;
}
int
server_context_submit_solution(server_context_t *ctxp,
workitem_t *work,
const char *privkey)
{
char urlbuf[8192];
char *pubhex;
CURL *creq;
CURLcode res;
pubhex = EC_POINT_point2hex(EC_KEY_get0_group(ctxp->dummy_key),
work->pubkey,
POINT_CONVERSION_UNCOMPRESSED,
NULL);
snprintf(urlbuf, sizeof(urlbuf),
"%s?key=%s%%3A%s&privateKey=%s&bitcoinAddress=%s",
ctxp->submit,
work->pattern,
pubhex,
privkey,
ctxp->credit_addr);
OPENSSL_free(pubhex);
creq = curl_easy_init();
if (curl_easy_setopt(creq, CURLOPT_URL, urlbuf) ||
curl_easy_setopt(creq, CURLOPT_VERBOSE, ctxp->verbose > 1) ||
curl_easy_setopt(creq, CURLOPT_FOLLOWLOCATION, 1)) {
fprintf(stderr, "Failed to set up libcurl\n");
exit(1);
}
res = curl_easy_perform(creq);
if (res != CURLE_OK) {
fprintf(stderr, "Submission failed: %s\n",
curl_easy_strerror(res));
curl_easy_cleanup(creq);
return -1;
}
curl_easy_cleanup(creq);
return 0;
}
int
server_workitem_add(server_request_t *reqp, workitem_t *wip)
{
workitem_t *xwip;
pubkeybatch_t *pbatch = NULL;
pbatch = pubkeybatch_avl_search(&reqp->items, wip->pubkey, reqp->group);
if (pbatch == NULL) {
pbatch = (pubkeybatch_t *) malloc(sizeof(*pbatch));
if (pbatch == NULL)
return -1;
memset(pbatch, 0, sizeof(*pbatch));
avl_item_init(&pbatch->avlent);
avl_root_init(&pbatch->items);
pbatch->total_value = 0;
pbatch->pubkey = wip->pubkey;
pbatch->pubkey_hex = EC_POINT_point2hex(reqp->group,
wip->pubkey,
POINT_CONVERSION_UNCOMPRESSED,
NULL);
pubkeybatch_avl_insert(&reqp->items, pbatch);
reqp->nitems++;
}
/* Make sure there isn't an overlap */
xwip = workitem_avl_insert(&pbatch->items, wip);
if (xwip)
return -1;
if (wip->pubkey && wip->pubkey != pbatch->pubkey)
EC_POINT_free(wip->pubkey);
wip->pubkey = pbatch->pubkey;
pbatch->nitems++;
pbatch->total_value += wip->value;
return 0;
}
int SM2_CIPHERTEXT_VALUE_print(BIO *out, const EC_GROUP *ec_group,
const SM2_CIPHERTEXT_VALUE *cv, int indent, unsigned long flags)
{
int ret = 0;
char *hex = NULL;
BN_CTX *ctx = BN_CTX_new();
int i;
if (!ctx) {
goto end;
}
if (!(hex = EC_POINT_point2hex(ec_group, cv->ephem_point,
POINT_CONVERSION_UNCOMPRESSED, ctx))) {
goto end;
}
BIO_printf(out, "SM2_CIPHERTEXT_VALUE.ephem_point: %s\n", hex);
BIO_printf(out, "SM2_CIPHERTEXT_VALUE.ciphertext : ");
for (i = 0; i < cv->ciphertext_size; i++) {
BIO_printf(out, "%02X", cv->ciphertext[i]);
}
BIO_printf(out, "\n");
BIO_printf(out, "SM2_CIPHERTEXT_VALUE.mactag :");
for (i = 0; i < cv->mactag_size; i++) {
BIO_printf(out, "%02X", cv->mactag[i]);
}
BIO_printf(out, "\n");
ret = 1;
end:
OPENSSL_free(hex);
BN_CTX_free(ctx);
return 0;
}
void printPoint(const polypseud_ctx *ctx, EC_POINT *point) {
printf("%s\n", EC_POINT_point2hex(ctx->ec_group, point, POINT_CONVERSION_UNCOMPRESSED, ctx->bn_ctx));
}
int main(int argc, const char *argv[])
{
int r;
int ok = 0;
char *prog = "ecc";
// libpopt var
poptContext popt_ctx;
const char **rest;
int command = 0;
char *curve_name = "secp192k1";
int point_compressed = 0;
point_conversion_form_t point_form;
struct poptOption options[] = {
{"curve-name", 'c', POPT_ARG_STRING, &curve_name, 0, "elliptic curve name", "NAME"},
{"point-compressed", 'z', POPT_ARG_NONE, &point_compressed, 0, "point format, compress or uncompress", NULL},
{"print-curve", 'p', POPT_ARG_VAL, &command, ECC_PRINT, "print elliptic curve parameters", NULL},
{"random-private-key", 0, POPT_ARG_VAL, &command, ECC_RAND_SKEY, "random generate a private key\n", NULL},
{"random-keypair", 0, POPT_ARG_VAL, &command, ECC_RAND_KEYPAIR, "generate a random key pair\n", NULL},
{"check-point", 'e', POPT_ARG_VAL, &command, ECC_CHECK_POINT, "check if point is valid\n", NULL},
{"point-add", 'a', POPT_ARG_VAL, &command, ECC_ADD, "elliptic curve point addition", NULL},
{"point-double", 'b', POPT_ARG_VAL, &command, ECC_DOUBLE, "elliptic curve point double", NULL},
{"point-mul", 'x', POPT_ARG_VAL, &command, ECC_MUL, "k*G", NULL},
{"point-mul-generator", 'X', POPT_ARG_VAL, &command, ECC_MUL_G, "elliptic curve point scalar multiply", NULL},
{"point-invert", 'i', POPT_ARG_VAL, &command, ECC_INVERT, "elliptic curve point inverse", NULL},
{"ecdsa-sign", 's', POPT_ARG_VAL, &command, ECC_SIGN, "ecdsa sign", NULL},
{"ecdsa-verify", 'v', POPT_ARG_VAL, &command, ECC_VERIFY, "ecdsa verify", NULL},
POPT_AUTOHELP
POPT_TABLEEND
};
// openssl var
EC_GROUP *ec_group = NULL;
EC_POINT *P = NULL;
EC_POINT *Q = NULL;
EC_POINT *R = NULL;
BIGNUM *k = BN_new();
BN_CTX *bn_ctx = BN_CTX_new();
// argument parsing
popt_ctx = poptGetContext(argv[0], argc, argv, options, 0);
if ((r = poptGetNextOpt(popt_ctx)) < -1) {
fprintf(stderr, "%s: bad argument %s: %s\n", argv[0],
poptBadOption(popt_ctx, POPT_BADOPTION_NOALIAS),
poptStrerror(r));
goto exit;
}
rest = poptGetArgs(popt_ctx);
// check arguments
ec_group = EC_GROUP_new_by_curve_name(OBJ_txt2nid(curve_name));
if (ec_group == NULL) {
fprintf(stderr, "%s: unknown curve name\n", prog);
goto exit;
}
P = EC_POINT_new(ec_group);
Q = EC_POINT_new(ec_group);
R = EC_POINT_new(ec_group);
point_form = point_compressed ? POINT_CONVERSION_COMPRESSED : POINT_CONVERSION_UNCOMPRESSED;
switch (command) {
case ECC_PRINT:
{
BIGNUM *p = BN_new();
BIGNUM *a = BN_new();
BIGNUM *b = BN_new();
char *generator;
BIGNUM *order = BN_new();
BIGNUM *cofactor = BN_new();
EC_GROUP_get_curve_GFp(ec_group, p, a, b, bn_ctx);
generator = EC_POINT_point2hex(ec_group, EC_GROUP_get0_generator(ec_group), point_form, bn_ctx);
EC_GROUP_get_order(ec_group, order, bn_ctx);
EC_GROUP_get_cofactor(ec_group, cofactor, bn_ctx);
fprintf(stdout, "Name : %s\n", OBJ_nid2sn(EC_GROUP_get_curve_name(ec_group)));
fprintf(stdout, "FieldType : %s\n", "PrimeField");
fprintf(stdout, "Prime : %s\n", BN_bn2hex(p));
fprintf(stdout, "A : %s\n", BN_bn2hex(a));
fprintf(stdout, "B : %s\n", BN_bn2hex(b));
fprintf(stdout, "Generator : %s\n", generator);
fprintf(stdout, "Order : %s\n", BN_bn2hex(order));
fprintf(stdout, "Cofactor : %s\n", BN_bn2hex(cofactor));
BN_free(p);
BN_free(a);
BN_free(b);
BN_free(order);
BN_free(cofactor);
break;
}
case ECC_CHECK_POINT:
{
if (!rest) {
fprintf(stderr, "%s: short of point\n", prog);
goto exit;
}
if (!rest[0]) {
fprintf(stderr, "%s: short of point\n", prog);
goto exit;
}
if (EC_POINT_hex2point(ec_group, rest[0], P, bn_ctx))
fprintf(stdout, "ture\n");
else
fprintf(stdout, "false\n");
break;
}
case ECC_RAND_SKEY:
{
EC_KEY *ec_key = EC_KEY_new();
EC_KEY_set_group(ec_key, ec_group);
EC_KEY_generate_key(ec_key);
fprintf(stdout, "%s\n", BN_bn2hex(EC_KEY_get0_private_key(ec_key)));
EC_KEY_free(ec_key);
break;
}
case ECC_RAND_KEYPAIR:
{
EC_KEY *ec_key = EC_KEY_new();
EC_KEY_set_group(ec_key, ec_group);
EC_KEY_generate_key(ec_key);
fprintf(stdout, "%s\n", BN_bn2hex(EC_KEY_get0_private_key(ec_key)));
fprintf(stdout, "%s\n", EC_POINT_point2hex(ec_group, EC_KEY_get0_public_key(ec_key), point_form, bn_ctx));
EC_KEY_free(ec_key);
break;
}
case ECC_ADD:
{
if (!rest) {
fprintf(stderr, "%s: short of point\n", prog);
goto exit;
}
if (!rest[0] || !rest[1]) {
fprintf(stderr, "%s: short of point\n", prog);
goto exit;
}
if (!EC_POINT_hex2point(ec_group, rest[1], P, bn_ctx)) {
fprintf(stderr, "%s: first point invalid\n", prog);
goto exit;
}
if (!EC_POINT_hex2point(ec_group, rest[1], Q, bn_ctx)) {
fprintf(stderr, "%s: second point invalid\n", prog);
goto exit;
}
EC_POINT_add(ec_group, R, P, Q, bn_ctx);
fprintf(stdout, "%s\n", EC_POINT_point2hex(ec_group, R, point_form, bn_ctx));
break;
}
case ECC_DOUBLE:
{
EC_POINT_dbl(ec_group, R, P, bn_ctx);
fprintf(stdout, "%s\n", EC_POINT_point2hex(ec_group, R, point_form, bn_ctx));
break;
}
case ECC_MUL:
{
BIGNUM *order = NULL;
if (!BN_hex2bn(&k, rest[0])) {
fprintf(stderr, "%s: integer invalid\n", prog);
goto exit;
}
order = BN_new();
EC_GROUP_get_order(ec_group, order, bn_ctx);
if (BN_cmp(k, order) >= 0) {
fprintf(stderr, "%s: integer value invalid\n", prog);
BN_free(order);
goto exit;
}
BN_free(order);
if (!EC_POINT_hex2point(ec_group, rest[1], P, bn_ctx)) {
fprintf(stderr, "%s: point invalid\n", prog);
goto exit;
}
EC_POINT_mul(ec_group, R, k, P, NULL, bn_ctx);
fprintf(stdout, "%s\n", EC_POINT_point2hex(ec_group, R, point_form, bn_ctx));
break;
}
case ECC_MUL_G:
{
BIGNUM *order = NULL;
if (!BN_hex2bn(&k, rest[0])) {
fprintf(stderr, "%s: integer format invalid\n", prog);
goto exit;
}
order = BN_new();
EC_GROUP_get_order(ec_group, order, bn_ctx);
if (BN_cmp(k, order) >= 0) {
fprintf(stderr, "%s: integer value invalid\n", prog);
BN_free(order);
goto exit;
}
BN_free(order);
EC_POINT_mul(ec_group, R, k, EC_GROUP_get0_generator(ec_group), NULL, bn_ctx);
fprintf(stdout, "%s\n", EC_POINT_point2hex(ec_group, R, point_form, bn_ctx));
break;
}
default:
fprintf(stderr, "%s: command is required\n", prog);
break;
}
ok = 1;
exit:
if (ec_group) EC_GROUP_free(ec_group);
if (P) EC_POINT_free(P);
if (k) BN_free(k);
if (bn_ctx) BN_CTX_free(bn_ctx);
return ok ? 0 : -1;
}
int initialiseRingSigs()
{
if (fDebugRingSig)
LogPrintf("initialiseRingSigs()\n");
if (!(ecGrp = EC_GROUP_new_by_curve_name(NID_secp256k1)))
return errorN(1, "initialiseRingSigs(): EC_GROUP_new_by_curve_name failed.");
if (!(bnCtx = BN_CTX_new()))
return errorN(1, "initialiseRingSigs(): BN_CTX_new failed.");
BN_CTX_start(bnCtx);
//Create a new EC group for the keyImage with all of the characteristics of ecGrp.
if(!(ecGrpKi = EC_GROUP_dup(ecGrp))){
return errorN(1, "initialiseRingSigs(): EC_GROUP_dup failed.");
}
// get order and cofactor
bnOrder = BN_new();
if(!EC_GROUP_get_order(ecGrp, bnOrder, bnCtx)){
return errorN(1, "initialiseRingSigs(): EC_GROUP_get_order failed.");
}
BIGNUM *bnCofactor = BN_CTX_get(bnCtx);
if(!EC_GROUP_get_cofactor(ecGrp, bnCofactor, bnCtx)){
return errorN(1, "initialiseRingSigs(): EC_GROUP_get_cofactor failed.");
}
// get the original generator
EC_POINT *ptBase = const_cast<EC_POINT*>(EC_GROUP_get0_generator(ecGrp)); //PS: never clear this point
// create key image basepoint variable
EC_POINT *ptBaseKi = EC_POINT_new(ecGrpKi);
BIGNUM *bnBaseKi = BN_CTX_get(bnCtx);
// get original basepoint in BIG NUMS.
EC_POINT_point2bn(ecGrp, ptBase, POINT_CONVERSION_COMPRESSED, bnBaseKi, bnCtx);
//create "1" in BIG NUMS
BIGNUM *bnBaseKiAdd = BN_CTX_get(bnCtx);
std::string num_str = "1";
BN_dec2bn(&bnBaseKiAdd, num_str.c_str());
// add 1 to original base point and store in key image basepoint (BIG NUMS)
BN_add(bnBaseKi, bnBaseKi, bnBaseKiAdd);
// key image basepoint from bignum to point in ptBaseKi
if(!EC_POINT_bn2point(ecGrp, bnBaseKi, ptBaseKi, bnCtx))
return errorN(1, "initialiseRingSigs(): EC_POINT_bn2point failed.");
// set generator of ecGrpKi
if(!EC_GROUP_set_generator(ecGrpKi, ptBaseKi, bnOrder, bnCofactor)){
return errorN(1, "initialiseRingSigs(): EC_GROUP_set_generator failed.");
}
if (fDebugRingSig)
{
// Debugging...
const EC_POINT *generator = EC_GROUP_get0_generator(ecGrp);
const EC_POINT *generatorKi = EC_GROUP_get0_generator(ecGrpKi);
char *genPoint = EC_POINT_point2hex(ecGrp, generator, POINT_CONVERSION_UNCOMPRESSED, bnCtx);
char *genPointKi = EC_POINT_point2hex(ecGrpKi, generatorKi, POINT_CONVERSION_UNCOMPRESSED, bnCtx);
LogPrintf("generator ecGrp: %s\ngenerator ecGrpKi: %s\n", genPoint, genPointKi);
}
EC_POINT_free(ptBaseKi);
BN_CTX_end(bnCtx);
return 0;
};
int getPublicKeyFromPem(char *pemstring, char **pubkey) {
EC_KEY *eckey = NULL;
EC_KEY *key = NULL;
EC_POINT *pub_key = NULL;
BIO *in = NULL;
const EC_GROUP *group = NULL;
char *hexPoint = NULL;
char xval[65] = "";
char yval[65] = "";
char *oddNumbers = "13579BDF";
BIGNUM start;
const BIGNUM *res;
BN_CTX *ctx;
BN_init(&start);
ctx = BN_CTX_new();
res = &start;
const char *cPem = pemstring;
in = BIO_new(BIO_s_mem());
BIO_puts(in, cPem);
key = PEM_read_bio_ECPrivateKey(in, NULL, NULL, NULL);
res = EC_KEY_get0_private_key(key);
eckey = EC_KEY_new_by_curve_name(NID_secp256k1);
group = EC_KEY_get0_group(eckey);
pub_key = EC_POINT_new(group);
EC_KEY_set_private_key(eckey, res);
if (!EC_POINT_mul(group, pub_key, res, NULL, NULL, ctx)) {
return ERROR;
}
EC_KEY_set_public_key(eckey, pub_key);
hexPoint = EC_POINT_point2hex(group, pub_key, 4, ctx);
char *hexPointxInit = hexPoint + 2;
memcpy(xval, hexPointxInit, 64);
char *hexPointyInit = hexPoint + 66;
memcpy(yval, hexPointyInit, 64);
char *lastY = hexPoint + 129;
hexPoint[130] = '\0';
char *buildCompPub = calloc(67, sizeof(char));
if (strstr(oddNumbers, lastY) != NULL) {
sprintf(buildCompPub, "03%s", xval);
buildCompPub[66] = '\0';
memcpy(*pubkey, buildCompPub, 67);
} else {
sprintf(buildCompPub, "02%s", xval);
buildCompPub[66] = '\0';
memcpy(*pubkey, buildCompPub, 67);
}
free(buildCompPub);
BN_CTX_free(ctx);
EC_KEY_free(eckey);
EC_KEY_free(key);
EC_POINT_free(pub_key);
BIO_free(in);
return NOERROR;
};
