diff --git a/include/dap_enc_key.h b/include/dap_enc_key.h
index 5c73591aa0aef1c80e3acae67d1c202e6000f519..0d47a9aa4a87cc005c7e83e99210e86ac33e62c0 100755
--- a/include/dap_enc_key.h
+++ b/include/dap_enc_key.h
@@ -143,6 +143,8 @@ typedef size_t (*dap_enc_callback_dataop_t)(struct dap_enc_key *key, const void
typedef size_t (*dap_enc_callback_dataop_na_t)(struct dap_enc_key *key, const void *in,
const size_t in_size,void * out, const size_t out_size_max);
+typedef size_t (*dap_enc_callback_dataop_na_ext_t)(struct dap_enc_key *key, const void *in,
+ const size_t in_size,void * out, const size_t out_size_max, const void *extra_param, const int extra_param_len);
typedef int (*dap_enc_callback_sign_op_t)(struct dap_enc_key *key, const void *in,
const size_t in_size,void * out, const size_t out_size_max);
@@ -180,6 +182,7 @@ typedef void (*dap_enc_callback_size_t)(struct dap_enc_key *, size_t);
typedef void (*dap_enc_callback_str_t)(struct dap_enc_key *, const char*);
typedef char* (*dap_enc_callback_r_str_t)(struct dap_enc_key *);
typedef size_t (*dap_enc_callback_calc_out_size)(const size_t);
+typedef size_t (*dap_enc_get_allpbkList) (struct dap_enc_key *b_key, const void *allpbkList, const int allpbknum);
typedef struct dap_enc_key {
size_t priv_key_data_size;
@@ -196,6 +199,7 @@ typedef struct dap_enc_key {
dap_enc_callback_dataop_t dec;
dap_enc_callback_dataop_na_t enc_na;
dap_enc_callback_dataop_na_t dec_na;
+ dap_enc_callback_dataop_na_ext_t dec_na_ext;
dap_enc_callback_sign_op_t sign_get;
dap_enc_callback_sign_op_t sign_verify;
@@ -203,6 +207,11 @@ typedef struct dap_enc_key {
dap_enc_gen_alice_shared_key gen_alice_shared_key;
dap_enc_gen_bob_shared_key gen_bob_shared_key;
+ void *pbkListdata;
+ size_t pbkListsize;
+ dap_enc_get_allpbkList getallpbkList;
+
+
void * _inheritor; // WARNING! Inheritor must have only serealizeble/deserializeble data (copy)
size_t _inheritor_size;
} dap_enc_key_t;
diff --git a/include/dap_enc_ringct20.h b/include/dap_enc_ringct20.h
index e3388126373444ef99c07fda7217b2c12c5d39ab..39cfef2e1b879742fce114dd6ed72fd8bfbfbedc 100644
--- a/include/dap_enc_ringct20.h
+++ b/include/dap_enc_ringct20.h
@@ -5,6 +5,7 @@
#include "dap_enc_key.h"
+size_t CRUTCH_gen_pbk_list(const ringct20_param_t *p, void **pbklist, const int pbknum);
void dap_enc_sig_ringct20_set_type(DAP_RINGCT20_SIGN_SECURITY type);
@@ -14,6 +15,11 @@ void dap_enc_sig_ringct20_key_new_generate(struct dap_enc_key * key, const void
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size);
+size_t dap_enc_sig_ringct20_get_sign_with_pbkList(struct dap_enc_key * key, const void * msg,
+ const size_t msg_size, void * signature, const size_t signature_size);
+size_t dap_enc_sig_ringct20_verify_sign_with_pbkList(struct dap_enc_key * key, const void * msg,
+ const size_t msg_size, void * signature, const size_t signature_size, const void *pbkList_buf, const int wpbkList);
+
size_t dap_enc_sig_ringct20_get_sign(struct dap_enc_key * key,const void * msg,
const size_t msg_size, void * signature, const size_t signature_size);
diff --git a/src/dap_enc_key.c b/src/dap_enc_key.c
index 3a44d7370e4de9454a11208040ed9c6a39ac7066..198a851c2bb391664f8a99c5b1e849c21d4f0aeb 100755
--- a/src/dap_enc_key.c
+++ b/src/dap_enc_key.c
@@ -48,6 +48,7 @@ struct dap_enc_key_callbacks{
dap_enc_callback_dataop_t dec;
dap_enc_callback_dataop_na_t enc_na;
dap_enc_callback_dataop_na_t dec_na;
+ dap_enc_callback_dataop_na_ext_t dec_na_ext;
dap_enc_callback_sign_op_t sign_get;
dap_enc_callback_sign_op_t sign_verify;
@@ -258,8 +259,9 @@ struct dap_enc_key_callbacks{
.name = "SIG_RINGCT20",
.enc = NULL,
.dec = NULL,
- .enc_na = dap_enc_sig_ringct20_get_sign,
+ .enc_na = dap_enc_sig_ringct20_get_sign_with_pbkList,//dap_enc_sig_ringct20_get_sign,
.dec_na = dap_enc_sig_ringct20_verify_sign,
+ .dec_na_ext = dap_enc_sig_ringct20_verify_sign_with_pbkList,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.gen_bob_shared_key = NULL,
@@ -275,7 +277,6 @@ struct dap_enc_key_callbacks{
};
const size_t c_callbacks_size = sizeof(s_callbacks) / sizeof(s_callbacks[0]);
-
/**
* @brief dap_enc_key_init
* @return
diff --git a/src/dap_enc_ringct20.c b/src/dap_enc_ringct20.c
index dd4b6050fb9f2df1a5a7a361e8a2a813a3f47964..ffaca3c5f32efecc1ceb61f7b5c621969bd9c286 100644
--- a/src/dap_enc_ringct20.c
+++ b/src/dap_enc_ringct20.c
@@ -85,22 +85,31 @@ void ringct20_unpack_pbk(const uint8_t *pbk, poly_ringct20 *a, const ringct20_pa
unpacked_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
-void ringct20_unpack_sig(const uint8_t *sig, poly_ringct20 *a_list,
- poly_ringct20 *c1, poly_ringct20 **t, poly_ringct20 *h, const ringct20_param_t *rct_p)
+void ringct20_unpack_sig(const uint8_t *sig, DAP_RINGCT20_SIGN_SECURITY *sec_kind, poly_ringct20 **a_list,
+ poly_ringct20 *c1, poly_ringct20 ***t, poly_ringct20 *h, const ringct20_param_t *rct_p, int *wLen)
{
uint32_t unpacked_size = 0;
+ //unpack sec_kind
+ memcpy(sec_kind, sig + unpacked_size, sizeof(DAP_RINGCT20_SIGN_SECURITY));
+ unpacked_size += sizeof(DAP_RINGCT20_SIGN_SECURITY);
+ //unpack wLen
+ memcpy(wLen, sig + unpacked_size, sizeof(*wLen));
+ unpacked_size += sizeof(*wLen);
//unpack a_list
- for(uint32_t i = 0; i < rct_p->wLen; ++i)
+ *a_list = malloc(rct_p->POLY_RINGCT20_SIZE* *wLen);
+ for(int i = 0; i < *wLen; ++i)
{
- poly_frombytes(a_list + i, sig + unpacked_size);
+ poly_frombytes(*a_list + i, sig + unpacked_size);
unpacked_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
//unpack t[W][M]
- for(uint32_t j = 0; j < rct_p->wLen; ++j)
+ *t = malloc(*wLen *sizeof(poly_ringct20*));
+ for(int j = 0; j < *wLen; ++j)
{
- for(uint32_t i = 0; i < rct_p->M; ++i)
+ (*t)[j] = malloc(rct_p->M*rct_p->POLY_RINGCT20_SIZE);
+ for(int i = 0; i < rct_p->M; ++i)
{
- poly_frombytes(t[j] + i, sig + unpacked_size);
+ poly_frombytes((*t)[j] + i, sig + unpacked_size);
unpacked_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
}
@@ -111,19 +120,28 @@ void ringct20_unpack_sig(const uint8_t *sig, poly_ringct20 *a_list,
poly_frombytes(c1, sig + unpacked_size);
unpacked_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
-
void ringct20_pack_sig(uint8_t *sig, const poly_ringct20 *a_list,
- poly_ringct20 *c1, poly_ringct20 **t, const poly_ringct20 *h, const ringct20_param_t *rct_p)
+ poly_ringct20 *c1, poly_ringct20 **t, const poly_ringct20 *h, const ringct20_param_t *rct_p, const int wLen)
{
uint32_t packed_size = 0;
+ //pack sec_kind
+ memcpy(sig + packed_size, &(rct_p->kind), sizeof(DAP_RINGCT20_SIGN_SECURITY));
+ packed_size += sizeof(DAP_RINGCT20_SIGN_SECURITY);
+ //pack wLen
+ memcpy(sig + packed_size, &(wLen), sizeof(wLen));
+ packed_size += sizeof(wLen);
//pack a_list
- for(uint32_t i = 0; i < rct_p->wLen; ++i)
+ for(uint32_t i = 0; i < wLen; ++i)
{
poly_tobytes(sig + packed_size, a_list + i);
packed_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
+// for(int i = 0; i < 16; ++i)
+// printf("%.2x ", sig[i]);
+// printf(" = sig\n"); fflush(stdout);
+
//pack t[W][M]
- for(uint32_t j = 0; j < rct_p->wLen; ++j)
+ for(uint32_t j = 0; j < wLen; ++j)
{
for(uint32_t i = 0; i < rct_p->M; ++i)
{
@@ -139,33 +157,106 @@ void ringct20_pack_sig(uint8_t *sig, const poly_ringct20 *a_list,
packed_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
-#define CRUTCH
-
-int get_pbk_list(poly_ringct20 *aList, const ringct20_param_t *p, const int Pi)
+int get_pbk_list(poly_ringct20 *aList, const ringct20_param_t *p, const int Pi, const int wLen,
+ const ringct20_public_key_t *allpbk, const int allpbknum)
{
-#ifndef CRUTCH
- return -1;//ЗдеÑÑŒ должно быть обращение за ÑпиÑком публичных ключей
- ringct20_public_key_t *pbk_list;
- // pbk_list = malloc()
-#else
+ if(allpbk == 0 || allpbknum == 0)
+ return -1;
+ if(wLen < allpbknum/2)
+ {
+ log_it(L_ERROR, "Too big wLen chosen");
+ return -1;
+ }
+ int *pos_pbk_ist = DAP_NEW_SIZE(int, sizeof(int)*wLen);
+ int try_count = 0;
+ for(int i = 0; i < wLen && try_count < 3*wLen; ++i)
+ {
+ if(i == Pi)
+ continue;
+ pos_pbk_ist[i] = -1;
+ do
+ {
+ pos_pbk_ist[i] = random_uint32_t(allpbknum);
+ pos_pbk_ist[i]++;
+ if(allpbk[pos_pbk_ist[i]].kind != p->kind)
+ pos_pbk_ist[i] = -1;
+ for(int j = 0; j < i && pos_pbk_ist[i] != -1; ++j)
+ if(j != Pi && pos_pbk_ist[j] == pos_pbk_ist[i])
+ pos_pbk_ist[i] = -1;
+ }while(pos_pbk_ist[i] != -1 && try_count < 3*wLen);
+ ringct20_unpack_pbk(allpbk[pos_pbk_ist[i]].data, aList + i, p);
+ if(try_count >= 3*wLen)
+ {
+ log_it(L_ERROR, "tired to choise so many pbk");
+ DAP_DELETE(pos_pbk_ist);
+ return -1;
+ }
+ }
+ DAP_DELETE(pos_pbk_ist);
+ return 0;//ЗдеÑÑŒ должно быть обращение за ÑпиÑком публичных ключей
+return 0;
+
+}
+
+size_t CRUTCH_gen_pbk_list(const ringct20_param_t *p, void **pbklist, const int pbknum)
+{
+ size_t size_pbkkey = p->RINGCT20_PBK_SIZE + sizeof (DAP_RINGCT20_SIGN_SECURITY);
+ size_t pbklistsize = size_pbkkey*pbknum;
//get a list of some pbk
{
+ poly_ringct20 pbk_poly;
poly_ringct20 *Stmp = malloc(p->POLY_RINGCT20_SIZE*p->mLen);
- for(uint32_t i = 0; i < p->wLen; ++i)
+ *pbklist = DAP_NEW_SIZE(uint8_t, size_pbkkey*pbknum);
+ for(int i = 0; i < pbknum; ++i)
{
- if(i == (uint32_t) Pi)
- continue;
LRCT_SampleKey(Stmp, p->mLen);
- LRCT_KeyGen(aList + i, p->A, Stmp, p->mLen);
+ LRCT_KeyGen(&pbk_poly, p->A, Stmp, p->mLen);
+ *(DAP_RINGCT20_SIGN_SECURITY*)((*pbklist) + size_pbkkey*i) = p->kind;
+ ringct20_pack_pbk(((*pbklist) + size_pbkkey*i + sizeof(DAP_RINGCT20_SIGN_SECURITY)), &pbk_poly, p);
}
free(Stmp);
}
-#endif
-return 0;
-
+ return pbklistsize;
}
+int CRUTCH_get_pbk_list(poly_ringct20 *aList, const ringct20_param_t *p, const int Pi, const int wLen)
+{
+ int allpbknum = 4*wLen;
+ ringct20_public_key_t *allpbk = DAP_NEW_SIZE(ringct20_public_key_t, sizeof(ringct20_public_key_t)*allpbknum);
+ void *allpbk_buf = NULL;
+ CRUTCH_gen_pbk_list(p, &allpbk_buf, allpbknum);
+ size_t size_pbkkey = p->RINGCT20_PBK_SIZE + sizeof (DAP_RINGCT20_SIGN_SECURITY);
+ for(int i = 0; i < allpbknum; ++i)
+ {
+ allpbk[i].kind = *(DAP_RINGCT20_SIGN_SECURITY*)(allpbk_buf + size_pbkkey*i);
+ allpbk[i].data = allpbk_buf + size_pbkkey*i + sizeof(DAP_RINGCT20_SIGN_SECURITY);
+ }
+// poly_ringct20 pbk_poly;
+// //get a list of some pbk
+// {
+// poly_ringct20 *Stmp = malloc(p->POLY_RINGCT20_SIZE*p->mLen);
+// for(int i = 0; i < allpbknum; ++i)
+// {
+// LRCT_SampleKey(Stmp, p->mLen);
+// LRCT_KeyGen(&pbk_poly, p->A, Stmp, p->mLen);
+// allpbk[i].kind = p->kind;
+// allpbk[i].data = DAP_NEW_SIZE(uint8_t,p->RINGCT20_PBK_SIZE);
+// ringct20_pack_pbk(allpbk[i].data, &pbk_poly, p);
+// }
+// free(Stmp);
+// }
+ int res = get_pbk_list(aList,p,Pi,wLen, allpbk,allpbknum);
+ //free the list of some pbk
+// for(int i = 0; i < allpbknum; ++i)
+// {
+// DAP_DELETE(allpbk[i].data);
+// }
+ DAP_DELETE(allpbk);
+ DAP_DELETE(allpbk_buf);
+
+ return res;
+}
int ringct20_crypto_sign( ringct20_signature_t *sig, const unsigned char *m, unsigned long long mlen, const ringct20_private_key_t *private_key)
{
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
@@ -183,8 +274,7 @@ int ringct20_crypto_sign( ringct20_signature_t *sig, const unsigned char *m, uns
LRCT_KeyGen(aList + Pi, p->A,S,p->mLen);
- get_pbk_list(aList, p, Pi);
-
+ CRUTCH_get_pbk_list(aList, p, Pi, p->mLen);
poly_ringct20 h;
poly_ringct20 *u = malloc(p->POLY_RINGCT20_SIZE*p->M);
@@ -217,15 +307,15 @@ int ringct20_crypto_sign( ringct20_signature_t *sig, const unsigned char *m, uns
LRCT_SigGen(&c1, t, &h, p->A, p->H, S, u, p->mLen, aList, p->wLen, Pi, m, mlen);
sig->sig_len = p->RINGCT20_SIG_SIZE;// + mlen;
sig->sig_data = malloc(sig->sig_len);
-// memcpy(sig->sig_data,m,mlen);//TOCORRECT
- ringct20_pack_sig(sig->sig_data,aList,&c1, t, &h, p);
+// memcpy(sig->sig_data,m,mlen);//TOCORRECT
+ ringct20_pack_sig(sig->sig_data, aList,&c1, t, &h, p, p->wLen);
free(aList);
free(S);
free(u);
- for(uint32_t i = 0; i < p->wLen; ++i)
+ for(int i = 0; i < p->wLen; ++i)
free(t[i]);
free(t);
@@ -238,8 +328,104 @@ void ringct20_signature_delete(ringct20_signature_t *sig){
free(sig->sig_data);
sig->sig_data = NULL;
}
+
+/**
+ * @brief check msg[msg_size] sig with pbkList[wpbkList]
+ * @param msg
+ * @param msg_size
+ * @param sig
+ * @param pbkList
+ * @param wpbkList
+ * @return 0 if sign ckeck with pbkList[wpbkList]
+ */
+int ringct20_crypto_sign_open_with_pbkList(const unsigned char * msg, const unsigned long long msg_size,
+ const ringct20_signature_t * sig, const void *pbkList_buf, const int wpbkList)
+//const ringct20_public_key_t* pbkList)
+{
+
+ int wLenSig;
+ if(sig->sig_len < sizeof(DAP_RINGCT20_SIGN_SECURITY) + sizeof(wLenSig))
+ return -1;
+ DAP_RINGCT20_SIGN_SECURITY sec_kind = *(DAP_RINGCT20_SIGN_SECURITY*)sig->sig_data;
+ wLenSig = *(typeof (&wLenSig))(sig->sig_data + sizeof(DAP_RINGCT20_SIGN_SECURITY));
+
+ if(wpbkList != 0 && wLenSig != wpbkList)
+ {
+ return -1;
+ }
+ ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
+ if (! ringct20_params_init( p, sec_kind))
+ {
+ ringct20_params_free(p);
+ return -1;
+ }
+
+ if(sig->sig_len < p->RINGCT20_SIG_SIZE)
+ {
+ ringct20_params_free(p);
+ return -1;
+ }
+
+ poly_ringct20 *aList = NULL;
+ poly_ringct20 h;
+ poly_ringct20 c1;
+ poly_ringct20** t = NULL;//[w][M]//TOCORRECT to *t;
+ ringct20_unpack_sig(sig->sig_data, &sec_kind, &aList,&c1, &t, &h, p, &wLenSig);
+
+ if(wpbkList)
+ {
+ ringct20_public_key_t* pbkList = DAP_NEW_SIZE(ringct20_public_key_t, sizeof(ringct20_public_key_t)*wpbkList);
+ size_t size_pbkkey = p->RINGCT20_PBK_SIZE + sizeof (DAP_RINGCT20_SIGN_SECURITY);
+
+ for(int i = 0; i < wpbkList; i++)
+ {
+ pbkList[i].kind = *(DAP_RINGCT20_SIGN_SECURITY*)(pbkList_buf+size_pbkkey*i);
+ pbkList[i].data = (uint8_t*)(pbkList_buf+size_pbkkey*i + sizeof(DAP_RINGCT20_SIGN_SECURITY));
+ //printf("i = %d secKind = %d, kind = %d\n",i, sec_kind , pbkList[i].kind);fflush(stdout);
+ if(sec_kind != pbkList[i].kind)
+ {
+ if(aList)
+ free(aList);
+ if(t)
+ {
+ for(int i = 0; i < wLenSig; ++i)
+ free(t[i]);
+ free(t);
+ }
+ ringct20_params_free(p);
+ DAP_DELETE(pbkList);
+ return -1;
+ }
+ }
+
+ for(int i = 0; i < wLenSig; ++i)
+ ringct20_unpack_pbk(pbkList[i].data, aList + i, p);
+ DAP_DELETE(pbkList);
+ }
+ int result = 1;
+
+ result = 1 ^ LRCT_SigVer(&c1, t, p->A, p->H, p->mLen, &h, aList, wLenSig, msg, msg_size);
+
+ if(aList)
+ free(aList);
+ if(t)
+ {
+ for(int i = 0; i < wLenSig; ++i)
+ free(t[i]);
+ free(t);
+ }
+ ringct20_params_free(p);
+ return result;
+}
+
+
int ringct20_crypto_sign_open( const unsigned char * msg, const unsigned long long msg_size, const ringct20_signature_t * sig, const ringct20_public_key_t* public_key)
{
+ if(sig->sig_len < sizeof(DAP_RINGCT20_SIGN_SECURITY))
+ return -1;
+ DAP_RINGCT20_SIGN_SECURITY sec_kind = *(DAP_RINGCT20_SIGN_SECURITY*)sig->sig_data;
+ if(sec_kind != public_key->kind)
+ return -1;
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
if (! ringct20_params_init( p, public_key->kind)){
ringct20_params_free(p);
@@ -247,23 +433,21 @@ int ringct20_crypto_sign_open( const unsigned char * msg, const unsigned long lo
}
if(sig->sig_len < p->RINGCT20_SIG_SIZE)
{
+ ringct20_params_free(p);
return -1;
}
- poly_ringct20 *aList = malloc(p->POLY_RINGCT20_SIZE*p->wLen);
-
+ poly_ringct20 *aList = NULL;
poly_ringct20 h;
poly_ringct20 c1;
- poly_ringct20** t;//[w][M]//TOCORRECT to *t;
- t = malloc(p->wLen*sizeof(poly_ringct20*));
- for(uint32_t i = 0; i < p->wLen; ++i)
- t[i] = malloc(p->M*p->POLY_RINGCT20_SIZE);
- ringct20_unpack_sig(sig->sig_data,aList,&c1, t, &h, p);
- //CRUTCH ADD test pbk in aList
+ poly_ringct20** t = NULL;//[w][M]//TOCORRECT to *t;
+ int wLenSig = 0;
+ ringct20_unpack_sig(sig->sig_data, &sec_kind, &aList,&c1, &t, &h, p, &wLenSig);
+
int pbk_in_aList = 0;
poly_ringct20 a_pi;
ringct20_unpack_pbk(public_key->data, &a_pi, p);
- for(uint32_t i = 0; i < p->wLen; ++i)
+ for(int i = 0; i < wLenSig; ++i)
{
if(poly_equal(&a_pi, aList + i))
{
@@ -275,14 +459,16 @@ int ringct20_crypto_sign_open( const unsigned char * msg, const unsigned long lo
int result = 1;
if(pbk_in_aList)
- result = 1 ^ LRCT_SigVer(&c1, t, p->A, p->H, p->mLen, &h, aList, p->wLen, msg, msg_size);
+ result = 1 ^ LRCT_SigVer(&c1, t, p->A, p->H, p->mLen, &h, aList, wLenSig, msg, msg_size);
-
- free(aList);
-
- for(uint32_t i = 0; i < p->wLen; ++i)
- free(t[i]);
- free(t);
+ if(aList)
+ free(aList);
+ if(t)
+ {
+ for(int i = 0; i < wLenSig; ++i)
+ free(t[i]);
+ free(t);
+ }
ringct20_params_free(p);
return result;
}
@@ -378,31 +564,32 @@ void dap_enc_sig_ringct20_set_type(DAP_RINGCT20_SIGN_SECURITY type)
{
_ringct20_type = type;
}
-
+size_t dap_enc_sig_ringct20_getallpbk(dap_enc_key_t *key, const void *allpbkList, const int allpbknum);
void dap_enc_sig_ringct20_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_RINGCT20;
key->enc = NULL;
- key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_ringct20_get_sign;
+ key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_ringct20_get_sign_with_pbkList;//dap_enc_sig_ringct20_get_sign;
key->dec_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_ringct20_verify_sign;
-// key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key) dap_enc_sig_ringct20_get_sign;
-// key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key) dap_enc_sig_ringct20_verify_sign;
-}
+ key->dec_na_ext = (dap_enc_callback_dataop_na_ext_t) dap_enc_sig_ringct20_verify_sign_with_pbkList;//dap_enc_sig_ringct20_verify_sign;
+ key->getallpbkList = (dap_enc_get_allpbkList) dap_enc_sig_ringct20_getallpbk;
+ key->pbkListsize = 0;
+ key->pbkListdata = NULL;
-// generation key pair for sign Alice
-// OUTPUT:
-// a_key->data --- Alice's public key
-// alice_priv --- Alice's private key
-// alice_msg_len --- Alice's private key length
+}
+size_t dap_enc_sig_ringct20_getallpbk(dap_enc_key_t *key, const void *allpbkList, const int allpbkListsize)
+{
+ key->pbkListdata = DAP_NEW_SIZE(uint8_t, allpbkListsize);
+ memcpy(key->pbkListdata, allpbkList, allpbkListsize);
+ key->pbkListsize= allpbkListsize;
+ return 0;
+}
void dap_enc_sig_ringct20_key_new_generate(struct dap_enc_key * key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
-// (void) kex_buf;
-// (void) kex_size;
-// (void) key_size;
int32_t retcode;
@@ -410,7 +597,6 @@ void dap_enc_sig_ringct20_key_new_generate(struct dap_enc_key * key, const void
dap_enc_sig_ringct20_set_type(ringct20_type);
- //int32_t type = 2;
key->priv_key_data_size = sizeof(ringct20_private_key_t);
key->pub_key_data_size = sizeof(ringct20_public_key_t);
key->priv_key_data = malloc(key->priv_key_data_size);
@@ -426,6 +612,108 @@ void dap_enc_sig_ringct20_key_new_generate(struct dap_enc_key * key, const void
}
}
+int ringct20_crypto_sign_with_pbkList( ringct20_signature_t *sig, const unsigned char *m,
+ unsigned long long mlen, const ringct20_private_key_t *private_key, const void *allpbk_buf, const int allpbk_size)
+{
+
+ ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
+ if (! ringct20_params_init( p, private_key->kind)){
+ ringct20_params_free(p);
+ return -1;
+ }
+ const int wLen = p->wLen;
+
+ int Pi = random_uint32_t(wLen);
+ poly_ringct20 *aList = malloc(p->POLY_RINGCT20_SIZE*wLen);
+ poly_ringct20 *S = malloc(p->POLY_RINGCT20_SIZE*p->mLen);
+ ringct20_unpack_prk(private_key->data,S,p);
+
+ LRCT_KeyGen(aList + Pi, p->A,S,p->mLen);
+
+ //CRUTCH_get_pbk_list(aList, p, Pi, p->mLen);
+ size_t size_pbkkey = p->RINGCT20_PBK_SIZE + sizeof (DAP_RINGCT20_SIGN_SECURITY);
+ int filled_pbk_num = 0, sizeused = 0;
+ for(; filled_pbk_num < wLen && sizeused < allpbk_size;++filled_pbk_num)
+ {
+ if(filled_pbk_num == Pi)
+ continue;
+ DAP_RINGCT20_SIGN_SECURITY curkind = *(DAP_RINGCT20_SIGN_SECURITY*)(allpbk_buf + sizeused);
+ if(curkind != p->kind)
+ break;
+ ringct20_unpack_pbk((allpbk_buf + sizeused + sizeof(DAP_RINGCT20_SIGN_SECURITY)), aList + filled_pbk_num, p);
+ sizeused += size_pbkkey;
+ }
+ if(filled_pbk_num < wLen)
+ {
+ log_it(L_ERROR, "RINGCT20: not enough pbkeys use CRUTCH_gen_pbk_list and key->getallpbkList");
+ DAP_DELETE(aList);
+ DAP_DELETE(S);
+ return -1;
+ }
+
+
+ poly_ringct20 h;
+ poly_ringct20 *u = malloc(p->POLY_RINGCT20_SIZE*p->M);
+ poly_ringct20 c1;
+ poly_ringct20** t;//[w][M]//TOCORRECT to *t;
+ t = malloc(wLen*sizeof(poly_ringct20*));
+ for(int i = 0; i < wLen; ++i)
+ t[i] = malloc(p->M*p->POLY_RINGCT20_SIZE);
+
+ unsigned char *bt = malloc(NEWHOPE_POLYBYTES);
+
+ for (int i = 0; i < wLen; i++)
+ {
+ for (int k = 0; k < p->M; k++)
+ {
+ poly_init(t[i] + k);
+ }
+
+ }
+
+ for (int k = 0; k < p->M; k++)
+ {
+ randombytes(bt, NEWHOPE_POLYBYTES);
+ poly_frombytes(u + k, bt);
+ poly_serial(u + k);
+ //poly_print(u+k);
+ }
+
+ free(bt);
+ LRCT_SigGen(&c1, t, &h, p->A, p->H, S, u, p->mLen, aList, wLen, Pi, m, mlen);
+ sig->sig_len = p->RINGCT20_SIG_SIZE;// + mlen;
+ sig->sig_data = malloc(sig->sig_len);
+// memcpy(sig->sig_data,m,mlen);//TOCORRECT
+ ringct20_pack_sig(sig->sig_data, aList,&c1, t, &h, p, wLen);
+
+
+ free(aList);
+ free(S);
+ free(u);
+
+ for(int i = 0; i < wLen; ++i)
+ free(t[i]);
+ free(t);
+
+ ringct20_params_free(p);
+ return 0;
+}
+
+size_t dap_enc_sig_ringct20_get_sign_with_pbkList(struct dap_enc_key * key, const void * msg,
+ const size_t msg_size, void * signature, const size_t signature_size)
+{
+ if(signature_size < sizeof(ringct20_signature_t)) {
+ log_it(L_ERROR, "bad signature size");
+ return 0;
+ }
+
+ if(!ringct20_crypto_sign_with_pbkList((ringct20_signature_t *) signature, (const unsigned char *) msg, msg_size, key->priv_key_data, key->pbkListdata, key->pbkListsize))
+ return signature_size;
+ else
+ return 0;
+}
+
+
size_t dap_enc_sig_ringct20_get_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
@@ -445,14 +733,30 @@ size_t dap_enc_sig_ringct20_verify_sign(struct dap_enc_key * key, const void * m
{
if(signature_size < sizeof(ringct20_signature_t)) {
log_it(L_ERROR, "bad signature size");
- return 0;
+ return 1;
}
return (ringct20_crypto_sign_open( (unsigned char *) msg, msg_size, (ringct20_signature_t *) signature, key->pub_key_data));
}
+size_t dap_enc_sig_ringct20_verify_sign_with_pbkList(struct dap_enc_key * key, const void * msg,
+ const size_t msg_size, void * signature, const size_t signature_size, const void *pbkList_buf, const int wpbkList)
+{
+ if(signature_size < sizeof(ringct20_signature_t)) {
+ log_it(L_ERROR, "bad signature size");
+ return 1;
+ }
+
+ return ringct20_crypto_sign_open_with_pbkList( (unsigned char *) msg, msg_size, (ringct20_signature_t *) signature, pbkList_buf, wpbkList);
+}
+
void dap_enc_sig_ringct20_key_delete(struct dap_enc_key * key)
{
+ if(key->pbkListsize)
+ {
+ DAP_DELETE(key->pbkListdata);
+ key->pbkListsize = 0;
+ }
ringct20_private_and_public_keys_delete((ringct20_private_key_t *) key->priv_key_data,
(ringct20_public_key_t *) key->pub_key_data);
}
diff --git a/src/ringct20/ringct20_params.c b/src/ringct20/ringct20_params.c
index 89455e6752197630d9d49ae25adec18cddb3fb26..c55598f55b96e82fb0db8f6b46af2813ca8bbe01 100644
--- a/src/ringct20/ringct20_params.c
+++ b/src/ringct20/ringct20_params.c
@@ -77,7 +77,7 @@ uint8_t H_bpoly_MAXSEC[14][NEWHOPE_POLYBYTES] = {
#error "NEWHOPE_N must be either 512 or 1024..
#endif
-bool ringct20_params_init(ringct20_param_t *ringct20_p, DAP_RINGCT20_SIGN_SECURITY kind)
+bool ringct20_params_init(ringct20_param_t *ringct20_p, DAP_RINGCT20_SIGN_SECURITY kind)//, const int wLen)
{
// static int first_init = 1;//CRUTCH
// if(first_init)
@@ -128,7 +128,7 @@ bool ringct20_params_init(ringct20_param_t *ringct20_p, DAP_RINGCT20_SIGN_SECURI
}
ringct20_p->RINGCT20_PBK_SIZE = ringct20_p->POLY_RINGCT20_SIZE_PACKED;
ringct20_p->RINGCT20_PRK_SIZE = ringct20_p->mLen*ringct20_p->POLY_RINGCT20_SIZE_PACKED;
- ringct20_p->RINGCT20_SIG_SIZE = (ringct20_p->wLen +
+ ringct20_p->RINGCT20_SIG_SIZE = sizeof(ringct20_p->wLen)+sizeof(DAP_RINGCT20_SIGN_SECURITY) + (ringct20_p->wLen +
ringct20_p->M*ringct20_p->wLen + 1 +1)*ringct20_p->POLY_RINGCT20_SIZE_PACKED;
diff --git a/src/ringct20/ringct20_params.h b/src/ringct20/ringct20_params.h
index a7c7e2ac0db47019a5e9df58ecff321487b3a9af..b02bcd3af91ead36d659dbcb868faaf0b4000349 100644
--- a/src/ringct20/ringct20_params.h
+++ b/src/ringct20/ringct20_params.h
@@ -19,20 +19,29 @@ typedef enum {
RINGCT20_MINSEC = 0, RINGCT20_MIDSEC, RINGCT20_MAXSEC
}DAP_RINGCT20_SIGN_SECURITY;
+typedef struct {
+ DAP_RINGCT20_SIGN_SECURITY kind; /* the kind of ringct20 */
+ unsigned char *data;
+}ringct20_public_key_t;
+
+
typedef struct {
DAP_RINGCT20_SIGN_SECURITY kind; // the kind of Dilithium (i.e. *this* choice of parameters)
- uint32_t M;
- uint32_t mLen;
- uint32_t wLen;//number of public key
- uint32_t Pi;//number of our key//known prk
+ int M;
+ int mLen;
+ int wLen;//number of public key
+ int Pi;//number of our key//known prk
poly_ringct20 *A;//fixed PubParams
poly_ringct20 *H;//fixed PubParams
- uint32_t POLY_RINGCT20_SIZE_PACKED;
- uint32_t POLY_RINGCT20_SIZE;
- uint32_t RINGCT20_PBK_SIZE;
- uint32_t RINGCT20_PRK_SIZE;
- uint32_t RINGCT20_SIG_SIZE;
+ ringct20_public_key_t *allpbk;
+ int allpbknum;
+
+ size_t POLY_RINGCT20_SIZE_PACKED;
+ size_t POLY_RINGCT20_SIZE;
+ size_t RINGCT20_PBK_SIZE;
+ size_t RINGCT20_PRK_SIZE;
+ size_t RINGCT20_SIG_SIZE;
/* uint32_t PARAM_K;
uint32_t PARAM_L;
@@ -60,11 +69,6 @@ typedef struct {
unsigned char *data;
} ringct20_private_key_t;
-typedef struct {
- DAP_RINGCT20_SIGN_SECURITY kind; /* the kind of ringct20 */
- unsigned char *data;
-} ringct20_public_key_t;
-
typedef struct {
DAP_RINGCT20_SIGN_SECURITY kind; /* the kind of ringct20 */
unsigned char *sig_data;
diff --git a/test/crypto/dap_enc_ringct20_test.c b/test/crypto/dap_enc_ringct20_test.c
index ba0fdaa5ff80ae8001afcc0626f90b3e8f65ad33..24d7b6cfc37df06b66564c99f03823bdf92b521e 100644
--- a/test/crypto/dap_enc_ringct20_test.c
+++ b/test/crypto/dap_enc_ringct20_test.c
@@ -3,8 +3,114 @@
#include "ringct20/ringct20_params.h"
#include "rand/dap_rand.h"
+
+static void test_signing_verifying2(void)
+{
+ size_t source_size = 1 + random_uint32_t(20);
+ uint8_t * source = DAP_NEW_SIZE(uint8_t, source_size);
+ randombytes(source, source_size);
+ size_t seed_size = sizeof(uint8_t);
+ uint8_t seed[seed_size];
+
+ randombytes(seed, seed_size);
+
+ dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_SIG_RINGCT20, NULL, 0, seed, seed_size, 0);
+
+ const int allpbknum = 100;
+ void *allpbk_buf = NULL;
+ ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
+ if (! ringct20_params_init( p, RINGCT20_MINSEC))
+ {
+ ringct20_params_free(p);
+ return;
+ }
+
+ size_t allpbk_size = CRUTCH_gen_pbk_list(p, &allpbk_buf, allpbknum);
+ key->getallpbkList(key, allpbk_buf,allpbk_size);
+
+ size_t max_signature_size = dap_enc_ringct20_calc_signature_size();
+ uint8_t* sig = calloc(max_signature_size, 1);
+
+
+
+ size_t siglen = key->enc_na(key, source, source_size, sig, max_signature_size);
+ dap_assert_PIF(siglen > 0, "Signing message");
+
+//Extract aList//CRUTCH
+ uint8_t *sigdata = (uint8_t*)*(int*)(sig + 4);
+// for(int i = 0; i < 16; ++i)
+// printf("%.2x ", sigdata[i]);
+// printf(" = sig_extract\n"); fflush(stdout);
+ uint32_t unpacked_size = 0;
+ //unpack sec_kind
+ //memcpy(sec_kind, sigdata + unpacked_size, sizeof(DAP_RINGCT20_SIGN_SECURITY));
+ unpacked_size += sizeof(DAP_RINGCT20_SIGN_SECURITY);
+ //unpack wLen
+ int wLen;
+ memcpy(&wLen, sigdata + unpacked_size, sizeof(wLen));
+// printf("wLen = %x\n", wLen);fflush(stdout);
+ unpacked_size += sizeof(wLen);
+ //unpack a_list
+ size_t poly_size = 896;
+ size_t pbk_size = 4 + poly_size;
+ uint8_t *pbkList_buf = DAP_NEW_SIZE(uint8_t, pbk_size*wLen);
+ for(int i = 0; i < wLen; ++i)
+ {
+ *(int*)(pbkList_buf + i*pbk_size + 0) = 0;//kind CRUTCH
+ memcpy(pbkList_buf + i*pbk_size + 4, sigdata + unpacked_size, poly_size);
+ unpacked_size += poly_size;
+ }
+//Extrackt aList
+
+ // size_t verify = key->dec_na(key, source, source_size, sig, siglen);
+// for(int i = 0; i < 32; ++i)
+// printf("%.2x ", pbkList_buf[i]);
+// printf(" = pbkList_buf\n"); fflush(stdout);
+// for(int i = 0; i < 32; ++i)
+// printf("%.2x ", pbkList_buf[pbk_size+i]);
+// printf(" = pbkList_buf\n"); fflush(stdout);
+// for(int i = 0; i < 32; ++i)
+// printf("%.2x ", pbkList_buf[pbk_size*2+i]);
+// printf(" = pbkList_buf\n"); fflush(stdout);
+
+ size_t verify = key->dec_na_ext(key, source, source_size, sig, siglen,pbkList_buf,wLen);
+//Corrupt pbkList
+ int numpbk = 3;
+// for(int i = 0; i < 32; ++i)
+// printf("%.2x ", ((uint8_t*)allpbk_buf)[numpbk*pbk_size + i]);
+// printf(" = allpbk\n"); fflush(stdout);
+ memcpy(pbkList_buf, allpbk_buf + numpbk*pbk_size, pbk_size);//Replace first pbk key with random pbk key
+
+//Corrupt pbkList
+
+// for(int i = 0; i < 32; ++i)
+// printf("%.2x ", pbkList_buf[i]);
+// printf(" = corrupt pbkList_buf\n"); fflush(stdout);
+// for(int i = 0; i < 32; ++i)
+// printf("%.2x ", pbkList_buf[i+pbk_size]);
+// printf(" = corrupt pbkList_buf\n"); fflush(stdout);
+// for(int i = 0; i < 32; ++i)
+// printf("%.2x ", pbkList_buf[i+2*pbk_size]);
+// printf(" = corrupt pbkList_buf\n"); fflush(stdout);
+ size_t verify_corrupt_sign = key->dec_na_ext(key, source, source_size, sig, siglen,pbkList_buf,wLen);
+
+ //printf("verify = %d, verify_corrupt_sign = %d\n", verify, verify_corrupt_sign);fflush(stdout);
+ dap_assert_PIF(!verify, "Verifying signature");
+ dap_assert_PIF(verify_corrupt_sign, "to Reject Corrupt signature");
+
+ ringct20_signature_delete((ringct20_signature_t*)sig);
+
+ DAP_DELETE(allpbk_buf);
+ ringct20_params_free(p);
+ DAP_DELETE(source);
+ free(sig);
+ dap_enc_key_delete(key);
+}
+
+//DEBUG TO USE IT get back:dap_enc_sig_ringct20_get_sign_with_pbkList,//dap_enc_sig_ringct20_get_sign,
static void test_signing_verifying(void)
{
+
size_t source_size = 1 + random_uint32_t(20);
uint8_t * source = DAP_NEW_SIZE(uint8_t, source_size);
randombytes(source, source_size);
@@ -51,7 +157,7 @@ void dap_enc_ringct20_tests_run(const int times)
char print_buf[512];
sprintf_s(print_buf, 512, "Signing and verifying message %d time", times);
- benchmark_mgs_time(print_buf, benchmark_test_time(test_signing_verifying, times));
+ benchmark_mgs_time(print_buf, benchmark_test_time(test_signing_verifying2, times));
cleanup_test_case();
}
diff --git a/test/crypto/dap_enc_test.c b/test/crypto/dap_enc_test.c
index 2f65e109ec777f1f8de440af9d03bc94b8e2cdf7..94b09beaa439a6848ed70c806e6ba61b60cb0d79 100755
--- a/test/crypto/dap_enc_test.c
+++ b/test/crypto/dap_enc_test.c
@@ -12,7 +12,7 @@
#include "dap_enc.h"
#define TEST_SER_FILE_NAME "keystorage.txt"
-void test_encode_decode(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size)
+void test_encypt_decrypt(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size)
{
dap_print_module_name(dap_enc_get_type_name(key_type));
@@ -75,7 +75,7 @@ void test_encode_decode(int count_steps, const dap_enc_key_type_t key_type, cons
dap_pass_msg("Encode and decode");
}
-void test_encode_decode_fast(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size)
+void test_encypt_decrypt_fast(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size)
{
const size_t buf_size = 4096;
char buf_encrypt_out[buf_size];
diff --git a/test/crypto/dap_enc_test.h b/test/crypto/dap_enc_test.h
index 5b375d1d2cdaf685d9f6d26b149e85dbc940581e..7a5036dd20d84eaeb496481497554ed3ca2b127a 100755
--- a/test/crypto/dap_enc_test.h
+++ b/test/crypto/dap_enc_test.h
@@ -1,6 +1,6 @@
#pragma once
#include "dap_enc_key.h"
-void test_encode_decode(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size);
-void test_encode_decode_fast(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size);
+void test_encypt_decrypt(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size);
+void test_encypt_decrypt_fast(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size);
void dap_enc_tests_run(void);
diff --git a/test/crypto/main.c b/test/crypto/main.c
index 98a06898b19a36ebe248d66b31099fba861805bf..208592653d7d8ad09be2b01d819bd71e4a4ce865 100755
--- a/test/crypto/main.c
+++ b/test/crypto/main.c
@@ -12,26 +12,25 @@
#include "rand/dap_rand.h"
#include "dap_common.h"
-void dap_enc_bf_tests_run();
int main(void)
{
// switch off debug info from library
dap_log_level_set(L_CRITICAL);
+ dap_enc_ringct20_tests_run(10);return 0;
dap_enc_tests_run();
- dap_enc_ringct20_tests_run(1000);
- test_encode_decode (1000, DAP_ENC_KEY_TYPE_BF_CBC,0);
- test_encode_decode_fast (1000, DAP_ENC_KEY_TYPE_BF_CBC,0);
- test_encode_decode (1000, DAP_ENC_KEY_TYPE_BF_OFB,0);
- test_encode_decode_fast (1000, DAP_ENC_KEY_TYPE_BF_OFB,0);
- test_encode_decode (1000, DAP_ENC_KEY_TYPE_GOST_OFB,32);
- test_encode_decode_fast (1000, DAP_ENC_KEY_TYPE_GOST_OFB,32);
- test_encode_decode (1000, DAP_ENC_KEY_TYPE_IAES,32);
- test_encode_decode_fast (1000, DAP_ENC_KEY_TYPE_IAES,32);
- test_encode_decode (1000, DAP_ENC_KEY_TYPE_OAES,32);
- test_encode_decode_fast (1000, DAP_ENC_KEY_TYPE_OAES,32);
+ test_encypt_decrypt (1000, DAP_ENC_KEY_TYPE_BF_CBC, 0);
+ test_encypt_decrypt_fast (1000, DAP_ENC_KEY_TYPE_BF_CBC, 0);
+ test_encypt_decrypt (1000, DAP_ENC_KEY_TYPE_BF_OFB, 0);
+ test_encypt_decrypt_fast (1000, DAP_ENC_KEY_TYPE_BF_OFB, 0);
+ test_encypt_decrypt (1000, DAP_ENC_KEY_TYPE_GOST_OFB, 32);
+ test_encypt_decrypt_fast (1000, DAP_ENC_KEY_TYPE_GOST_OFB, 32);
+ test_encypt_decrypt (1000, DAP_ENC_KEY_TYPE_IAES, 32);
+ test_encypt_decrypt_fast (1000, DAP_ENC_KEY_TYPE_IAES, 32);
+ test_encypt_decrypt (1000, DAP_ENC_KEY_TYPE_OAES, 32);
+ test_encypt_decrypt_fast (1000, DAP_ENC_KEY_TYPE_OAES, 32);
dap_enc_picnic_tests_run();
dap_enc_sig_bliss_tests_run();