void generateSupersingular(pairing_t *pairing,int rbits,int qbits){
pbc_param_t param;
pbc_param_init_a_gen(param,rbits,qbits);//using type a curve
pairing_init_pbc_param(*pairing,param);
pbc_param_clear(param);
return;
}
int main(void)
{
mpz_t p, q, N;
mpz_init(p);
mpz_init(q);
mpz_init(N);
// In a real application, p and q must be stored somewhere safe.
pbc_mpz_randomb(p, 512);
pbc_mpz_randomb(q, 512);
mpz_nextprime(p, p);
mpz_nextprime(q, q);
mpz_mul(N, p, q);
pbc_param_t param;
pbc_param_init_a1_gen(param, N);
pbc_param_out_str(stdout, param);
pbc_param_clear(param);
mpz_clear(p);
mpz_clear(q);
mpz_clear(N);
return 0;
}
void setupOrdinaryPairing(pairing_t *pairing){
int rbits = 224;
int qbits = 2048;
pbc_param_t param;
pbc_param_init_e_gen(param,rbits,qbits);
pairing_init_pbc_param(*pairing,param);
pbc_param_clear(param);
}
int main(int argc, char **argv) {
int rbits = argc > 1 ? atoi(argv[1]) : 160;
int qbits = argc > 2 ? atoi(argv[2]) : 512;
pbc_param_t par;
pbc_param_init_a_gen(par, rbits, qbits);
pbc_param_out_str(stdout, par);
pbc_param_clear(par);
return 0;
}
int pairing_init_set_buf(pairing_t pairing, const char *input, size_t len) {
pbc_param_t par;
int res = pbc_param_init_set_buf(par, input, len);
if (res) {
pbc_error("error initializing pairing");
return 1;
}
pairing_init_pbc_param(pairing, par);
pbc_param_clear(par);
return 0;
}
void generateOrdinary(pairing_t *pairing,int bits){
pbc_param_t param;
pbc_param_init_f_gen(param, bits);
pairing_init_pbc_param(*pairing,param);
pbc_param_clear(param);
}
// interactive curve generation
int xsgs_generate_curve(BYTE type, char** lpFilename) {
pbc_param_ptr param = NULL;
int ret = 0;
char* filename = NULL;
DWORD b = 0, d = 0;
switch (type) {
case CURVE_TYPE_D:
printf(
"\n\n+++ eXtremely Short Group Signature - Generate Type D Curve +++\n\n");
printf(
"Enter discriminant (must be 0 or 3 mod 4 and positive, e.g. 277699): ");
ret = scanf("%u", &d);
if (d <= 0 || (d % 4 != 0 && d % 4 != 3)) {
printf("%u %% 4 = %u\n", d, d % 4);
return 5;
}
printf("Enter count of at most bits for group order (e.g. 300): ");
ret = scanf("%u", &b);
param = xsgs_find_curve_d(d, b);
if (param == NULL) {
return 6;
}
filename = (char*) malloc(256);
memset(filename, 0, 256);
snprintf(filename, 255, "curves/xsgs_curve_d_%u_%u_%u.param", d,
(DWORD) mpz_sizeinbase(((d_param_ptr) param->data)->r, 2),
(DWORD) mpz_sizeinbase(((d_param_ptr) param->data)->q, 2));
ret = xsgs_param_export_file(filename, param);
pbc_param_clear(param);
if (ret) {
free(filename);
if (lpFilename != NULL) {
*lpFilename = NULL;
}
return 7;
}
printf("Curve saved to: %s\n", filename);
if (lpFilename != NULL) {
*lpFilename = filename;
}
break;
case CURVE_TYPE_F:
printf(
"\n\n+++ eXtremely Short Group Signature - Generate Type F Curve +++\n\n");
printf("Enter bit size of r and q (e.g. 160): ");
ret = scanf("%u", &b);
if (b == 0) {
return 8;
}
param = xsgs_find_curve_f(b);
if (param == NULL) {
return 9;
}
filename = (char*) malloc(256);
memset(filename, 0, 256);
snprintf(filename, 255, "curves/xsgs_curve_f_%u_%u.param",
(DWORD) mpz_sizeinbase(((f_param_ptr) param->data)->r, 2),
(DWORD) mpz_sizeinbase(((f_param_ptr) param->data)->q, 2));
ret = xsgs_param_export_file(filename, param);
pbc_param_clear(param);
if (ret) {
free(filename);
if (lpFilename != NULL) {
*lpFilename = NULL;
}
return 10;
}
printf("Curve saved to: %s\n", filename);
if (lpFilename != NULL) {
*lpFilename = filename;
}
break;
case CURVE_TYPE_G:
printf(
"\n\n+++ eXtremely Short Group Signature - Generate Type G Curve +++\n\n");
printf(
"Enter discriminant (must be 43 or 67 mod 120 and positive, e.g. 4543003): ");
ret = scanf("%u", &d);
if (d <= 0 || (d % 120 != 43 && d % 120 != 67)) {
printf("%u %% 120 = %u\n", d, d % 120);
return 5;
}
printf("Enter count of at most bits for group order (e.g. 300): ");
ret = scanf("%u", &b);
param = xsgs_find_curve_g(d, b);
if (param == NULL) {
return 6;
}
filename = (char*) malloc(256);
memset(filename, 0, 256);
snprintf(filename, 255, "curves/xsgs_curve_g_%u_%u_%u.param", d,
(DWORD) mpz_sizeinbase(((g_param_ptr) param->data)->r, 2),
(DWORD) mpz_sizeinbase(((g_param_ptr) param->data)->q, 2));
ret = xsgs_param_export_file(filename, param);
pbc_param_clear(param);
if (ret) {
free(filename);
if (lpFilename != NULL) {
*lpFilename = NULL;
}
return 7;
}
printf("Curve saved to: %s\n", filename);
if (lpFilename != NULL) {
*lpFilename = filename;
}
break;
default:
return -1;
}
return 0;
}
int main(int argc, char **argv) {
verbose = 0;
ifsize = 0;
int canrun =0;
clock_t start_t, end_t;
float total_t;
int user_num = 100;
int k;
int choose;
char *para1, *para2;
while ((choose = getopt (argc, argv, "vfn:hgs")) != -1) {
switch (choose) {
case 's':
ifsize = 1;
break;
case 'h':
usage();
exit(0);
break;
case 'v':
verbose = 1;
break;
case 'n':
user_num = atoi(optarg);
break;
case 'g':
//printf("Initializing pairing parameters...\n");
if(canrun) {
fprintf(stderr, "Pairing parameters have been set, \'-g\' should not set paring parameters again.\n");
break;
}
canrun = 1;
k=0;
for( ; optind<argc && !(*argv[optind] == '-'); optind++) k++;
if(k==2) {
int rbits = atoi(argv[optind-k]);
int qbits = atoi(argv[optind-k+1]);
pbc_param_t param;
// printf("rbits=%d qbits=%d\n",rbits,qbits);
pbc_param_init_a_gen(param, rbits, qbits);
pairing_init_pbc_param(pairing, param);
pairing_init_pbc_param(pairing2, param);
pbc_param_clear(param);
} else {
fprintf(stderr, "Input invalid!\n");
usage();
exit(-1);
}
break;
case 'f':
//printf("Initializing pairing parameters...\n");
if(canrun) {
fprintf(stderr, "Pairing parameters have been set, \'-f\' should not set paring parameters again.\n");
break;
}
canrun = 1;
k=0;
for( ; optind<argc && !(*argv[optind] == '-'); optind++) k++;
if(k==2) {
pbc_single_pairing_init(pairing, argc, argv[optind-k]);
pbc_single_pairing_init(pairing2, argc, argv[optind-k+1]);
}
else {
fprintf(stderr, "Input invalid!\n");
usage();
exit(-1);
}
break;
case '?':
fprintf(stderr, "Invalid parameters!\n");
usage();
exit(-1);
break;
default:
abort();
}
}
if(!canrun) {
printf("Please at least set \'-f\' or \'-g\'\n");
usage();
exit(-1);
}
//printf("Initializing system variable and public key....\n");
element_init_G2(g, pairing);
element_init_G2(X, pairing);
element_init_G2(Y, pairing);
element_init_Zr(x, pairing2);
element_init_Zr(y, pairing2);
element_random(x);
element_random(y);
printf("g=%lu X=%lu Y=%lu x=%lu y=%lu\n",sizeof(g),sizeof(X),sizeof(Y),sizeof(x),sizeof(y));
//system variable & public key generation
element_random(g);
if(verbose) element_printf("system parameter g = %B\n", g);
element_pow_zn(X, g, x);
element_pow_zn(Y, g, y);
// mpz_t mpz_g, mpz_X, mpz_Y;
// mpz_inits(mpz_g, mpz_X, mpz_Y, mpz_x, mpz_y, NULL);
// element_to_mpz(mpz_g, g);
// element_to_mpz(mpz_x, x);
// element_to_mpz(mpz_y, y);
// mpz_powm(mpz_X, mpz_g, mpz_x, pairing->r);
// element_set_mpz(X, mpz_X);
// //element_pow_zn(X, g, x);
// mpz_powm(mpz_Y, mpz_g, mpz_y, pairing->r);
// element_set_mpz(Y, mpz_Y);
// if(verbose) {
// gmp_printf("pair order %zd\n", pairing->r);
// gmp_printf("mpz g %zd\n", mpz_g);
// element_printf("x = %B\n", x);
// gmp_printf("mpz x %zd\n", mpz_x);
// gmp_printf("mpz y %zd\n", mpz_y);
// gmp_printf("mpz X %zd\n", mpz_X);
// element_printf("public key X = %B\n", X);
// element_printf("public key Y = %B\n", Y);
// }
// //element_pow_zn(Y, g, y);
// mpz_clear(mpz_g);mpz_clear(mpz_X);mpz_clear(mpz_Y);
unsigned char *a, *b, *c, *cu;
/*******Working********/
start_t = clock();
clock_t tmp_start;
clock_t bscurtotal = 0;
float bstotal;
clock_t tmp=0;
clock_t max;
clock_t min;
for(int i=0; i<user_num; i++) {
//printf("New user comes...\n");
UEActivity(&a, &b, &c, &cu);
tmp_start = clock();
BSActivity(a, b, c, cu);
tmp = clock() - tmp_start;
if(i==0) {min = tmp; max = tmp;}
else {
if(tmp > max) max = tmp;
if(tmp < min) min = tmp;
}
printf("Processing time for this user is %f ms \n",(float)tmp*1000 / CLOCKS_PER_SEC);
bscurtotal += tmp;
}
clock_t avg = bscurtotal / user_num;
printf("max single user time is %f ms \n",(float)max*1000 / CLOCKS_PER_SEC);
printf("min single user time is %f ms \n",(float)min*1000 / CLOCKS_PER_SEC);
printf("average single user time is %f ms \n",(float)avg*1000 / CLOCKS_PER_SEC);
//printf("************************\n");
end_t = clock();
total_t = (float)(end_t - start_t) / CLOCKS_PER_SEC;
bstotal = (float)bscurtotal / CLOCKS_PER_SEC;
//printf("User number: %d. \nTotal Generation & verification time taken by CPU: %f seconds.\n", user_num, total_t);
//printf("Total verification time at base station taken by CPU: %f seconds.\n", bstotal);
//printf("Exiting of the program...\n");
element_clear(g);
element_clear(X);
element_clear(Y);
element_clear(x);
element_clear(y);
return 0;
}
int main(int argc, char* argv[]) {
QTextStream err(stderr, QIODevice::WriteOnly);
if(argc != 2) {
err << "Usage: " << argv[0] << " qbits\n";
return 1;
}
int qbits;
QTextStream in(argv[1], QIODevice::ReadOnly);
in >> qbits;
if(qbits < 10) {
err << "qbits must be greater than 10\n";
return 1;
}
QTextStream out(stdout, QIODevice::WriteOnly);
out << "--- PBC Parameter Utility ---\n";
out << "r < q (for prime r and q)\n";
out << "Bits: " << qbits << "\n";
out << "\n\n";
out.flush();
pbc_param_t params;
pairing_t pairing;
const int rbits = qbits-8;
pbc_param_init_a_gen(params, rbits, qbits);
pbc_param_out_str(stdout, params);
pairing_init_pbc_param(pairing, params);
element_t gen1;
element_t neg1;
element_t gent;
element_t tmp, tmp2;
element_init_G1(tmp, pairing);
element_init_G1(tmp2, pairing);
element_init_Zr(neg1, pairing);
element_init_G1(gen1, pairing);
element_init_G1(gent, pairing);
// neg1 = 1
element_set1(neg1);
// neg1 = -1 mod r
element_neg(neg1, neg1);
do {
element_random(gen1);
// tmp = gen1^-1
element_pow_zn(tmp, gen1, neg1);
// tmp = (gen1^-1)*gen1 == gen1^r
element_mul(tmp2, tmp, gen1);
} while (!element_is1(tmp2));
element_fprintf(stdout, "g1 = %B\n", gen1);
do {
element_random(gent);
// tmp = gen1^-1
element_pow_zn(tmp, gent, neg1);
// tmp = (gen1^-1)*gen1 == gen1^r
element_mul(tmp2, tmp, gent);
} while (!element_is1(tmp2));
element_fprintf(stdout, "gT = %B\n", gent);
element_clear(gen1);
element_clear(gent);
element_clear(tmp);
element_clear(tmp2);
element_clear(neg1);
pbc_param_clear(params);
pairing_clear(pairing);
return 0;
}
