static bool trans_c_addi4spn(DisasContext *ctx, arg_c_addi4spn *a)
{
if (a->nzuimm == 0) {
/* Reserved in ISA */
return false;
}
arg_addi arg = { .rd = a->rd, .rs1 = 2, .imm = a->nzuimm };
return trans_addi(ctx, &arg);
}
static bool trans_c_fld(DisasContext *ctx, arg_c_fld *a)
{
arg_fld arg = { .rd = a->rd, .rs1 = a->rs1, .imm = a->uimm };
return trans_fld(ctx, &arg);
}
static bool trans_c_lw(DisasContext *ctx, arg_c_lw *a)
{
arg_lw arg = { .rd = a->rd, .rs1 = a->rs1, .imm = a->uimm };
return trans_lw(ctx, &arg);
}
static bool trans_c_flw_ld(DisasContext *ctx, arg_c_flw_ld *a)
{
#ifdef TARGET_RISCV32
/* C.FLW ( RV32FC-only ) */
REQUIRE_FPU;
REQUIRE_EXT(ctx, RVF);
arg_c_lw tmp;
decode_insn16_extract_cl_w(&tmp, ctx->opcode);
arg_flw arg = { .rd = tmp.rd, .rs1 = tmp.rs1, .imm = tmp.uimm };
return trans_flw(ctx, &arg);
#else
/* C.LD ( RV64C/RV128C-only ) */
arg_c_fld tmp;
decode_insn16_extract_cl_d(&tmp, ctx->opcode);
arg_ld arg = { .rd = tmp.rd, .rs1 = tmp.rs1, .imm = tmp.uimm };
return trans_ld(ctx, &arg);
#endif
}
static bool trans_c_fsd(DisasContext *ctx, arg_c_fsd *a)
{
arg_fsd arg = { .rs1 = a->rs1, .rs2 = a->rs2, .imm = a->uimm };
return trans_fsd(ctx, &arg);
}
static bool trans_c_sw(DisasContext *ctx, arg_c_sw *a)
{
arg_sw arg = { .rs1 = a->rs1, .rs2 = a->rs2, .imm = a->uimm };
return trans_sw(ctx, &arg);
}
static bool trans_c_fsw_sd(DisasContext *ctx, arg_c_fsw_sd *a)
{
#ifdef TARGET_RISCV32
/* C.FSW ( RV32FC-only ) */
REQUIRE_FPU;
REQUIRE_EXT(ctx, RVF);
arg_c_sw tmp;
decode_insn16_extract_cs_w(&tmp, ctx->opcode);
arg_fsw arg = { .rs1 = tmp.rs1, .rs2 = tmp.rs2, .imm = tmp.uimm };
return trans_fsw(ctx, &arg);
#else
/* C.SD ( RV64C/RV128C-only ) */
arg_c_fsd tmp;
decode_insn16_extract_cs_d(&tmp, ctx->opcode);
arg_sd arg = { .rs1 = tmp.rs1, .rs2 = tmp.rs2, .imm = tmp.uimm };
return trans_sd(ctx, &arg);
#endif
}
static bool trans_c_addi(DisasContext *ctx, arg_c_addi *a)
{
if (a->imm == 0) {
/* Hint: insn is valid but does not affect state */
return true;
}
arg_addi arg = { .rd = a->rd, .rs1 = a->rd, .imm = a->imm };
return trans_addi(ctx, &arg);
}
static bool trans_c_jal_addiw(DisasContext *ctx, arg_c_jal_addiw *a)
{
#ifdef TARGET_RISCV32
/* C.JAL */
arg_c_j tmp;
decode_insn16_extract_cj(&tmp, ctx->opcode);
arg_jal arg = { .rd = 1, .imm = tmp.imm };
return trans_jal(ctx, &arg);
#else
/* C.ADDIW */
arg_addiw arg = { .rd = a->rd, .rs1 = a->rd, .imm = a->imm };
return trans_addiw(ctx, &arg);
#endif
}
static bool trans_c_li(DisasContext *ctx, arg_c_li *a)
{
if (a->rd == 0) {
/* Hint: insn is valid but does not affect state */
return true;
}
arg_addi arg = { .rd = a->rd, .rs1 = 0, .imm = a->imm };
return trans_addi(ctx, &arg);
}
static bool trans_c_addi16sp_lui(DisasContext *ctx, arg_c_addi16sp_lui *a)
{
if (a->rd == 2) {
/* C.ADDI16SP */
arg_addi arg = { .rd = 2, .rs1 = 2, .imm = a->imm_addi16sp };
return trans_addi(ctx, &arg);
} else if (a->imm_lui != 0) {
/* C.LUI */
if (a->rd == 0) {
/* Hint: insn is valid but does not affect state */
return true;
}
arg_lui arg = { .rd = a->rd, .imm = a->imm_lui };
return trans_lui(ctx, &arg);
}
return false;
}
static bool trans_c_srli(DisasContext *ctx, arg_c_srli *a)
{
int shamt = a->shamt;
if (shamt == 0) {
/* For RV128 a shamt of 0 means a shift by 64 */
shamt = 64;
}
/* Ensure, that shamt[5] is zero for RV32 */
if (shamt >= TARGET_LONG_BITS) {
return false;
}
arg_srli arg = { .rd = a->rd, .rs1 = a->rd, .shamt = a->shamt };
return trans_srli(ctx, &arg);
}
static bool trans_c_srai(DisasContext *ctx, arg_c_srai *a)
{
int shamt = a->shamt;
if (shamt == 0) {
/* For RV128 a shamt of 0 means a shift by 64 */
shamt = 64;
}
/* Ensure, that shamt[5] is zero for RV32 */
if (shamt >= TARGET_LONG_BITS) {
return false;
}
arg_srai arg = { .rd = a->rd, .rs1 = a->rd, .shamt = a->shamt };
return trans_srai(ctx, &arg);
}
static bool trans_c_andi(DisasContext *ctx, arg_c_andi *a)
{
arg_andi arg = { .rd = a->rd, .rs1 = a->rd, .imm = a->imm };
return trans_andi(ctx, &arg);
}
static bool trans_c_sub(DisasContext *ctx, arg_c_sub *a)
{
arg_sub arg = { .rd = a->rd, .rs1 = a->rd, .rs2 = a->rs2 };
return trans_sub(ctx, &arg);
}
static bool trans_c_xor(DisasContext *ctx, arg_c_xor *a)
{
arg_xor arg = { .rd = a->rd, .rs1 = a->rd, .rs2 = a->rs2 };
return trans_xor(ctx, &arg);
}
static bool trans_c_or(DisasContext *ctx, arg_c_or *a)
{
arg_or arg = { .rd = a->rd, .rs1 = a->rd, .rs2 = a->rs2 };
return trans_or(ctx, &arg);
}
static bool trans_c_and(DisasContext *ctx, arg_c_and *a)
{
arg_and arg = { .rd = a->rd, .rs1 = a->rd, .rs2 = a->rs2 };
return trans_and(ctx, &arg);
}
static bool trans_c_subw(DisasContext *ctx, arg_c_subw *a)
{
#ifdef TARGET_RISCV64
arg_subw arg = { .rd = a->rd, .rs1 = a->rd, .rs2 = a->rs2 };
return trans_subw(ctx, &arg);
#else
return false;
#endif
}
static bool trans_c_addw(DisasContext *ctx, arg_c_addw *a)
{
#ifdef TARGET_RISCV64
arg_addw arg = { .rd = a->rd, .rs1 = a->rd, .rs2 = a->rs2 };
return trans_addw(ctx, &arg);
#else
return false;
#endif
}
static bool trans_c_j(DisasContext *ctx, arg_c_j *a)
{
arg_jal arg = { .rd = 0, .imm = a->imm };
return trans_jal(ctx, &arg);
}
static bool trans_c_beqz(DisasContext *ctx, arg_c_beqz *a)
{
arg_beq arg = { .rs1 = a->rs1, .rs2 = 0, .imm = a->imm };
return trans_beq(ctx, &arg);
}
static bool trans_c_bnez(DisasContext *ctx, arg_c_bnez *a)
{
arg_bne arg = { .rs1 = a->rs1, .rs2 = 0, .imm = a->imm };
return trans_bne(ctx, &arg);
}
static bool trans_c_slli(DisasContext *ctx, arg_c_slli *a)
{
int shamt = a->shamt;
if (shamt == 0) {
/* For RV128 a shamt of 0 means a shift by 64 */
shamt = 64;
}
/* Ensure, that shamt[5] is zero for RV32 */
if (shamt >= TARGET_LONG_BITS) {
return false;
}
arg_slli arg = { .rd = a->rd, .rs1 = a->rd, .shamt = a->shamt };
return trans_slli(ctx, &arg);
}
static bool trans_c_fldsp(DisasContext *ctx, arg_c_fldsp *a)
{
arg_fld arg = { .rd = a->rd, .rs1 = 2, .imm = a->uimm };
return trans_fld(ctx, &arg);
}
static bool trans_c_lwsp(DisasContext *ctx, arg_c_lwsp *a)
{
arg_lw arg = { .rd = a->rd, .rs1 = 2, .imm = a->uimm };
return trans_lw(ctx, &arg);
}
static bool trans_c_flwsp_ldsp(DisasContext *ctx, arg_c_flwsp_ldsp *a)
{
#ifdef TARGET_RISCV32
/* C.FLWSP */
arg_flw arg_flw = { .rd = a->rd, .rs1 = 2, .imm = a->uimm_flwsp };
return trans_flw(ctx, &arg_flw);
#else
/* C.LDSP */
arg_ld arg_ld = { .rd = a->rd, .rs1 = 2, .imm = a->uimm_ldsp };
return trans_ld(ctx, &arg_ld);
#endif
return false;
}
static bool trans_c_jr_mv(DisasContext *ctx, arg_c_jr_mv *a)
{
if (a->rd != 0 && a->rs2 == 0) {
/* C.JR */
arg_jalr arg = { .rd = 0, .rs1 = a->rd, .imm = 0 };
return trans_jalr(ctx, &arg);
} else if (a->rd != 0 && a->rs2 != 0) {
/* C.MV */
arg_add arg = { .rd = a->rd, .rs1 = 0, .rs2 = a->rs2 };
return trans_add(ctx, &arg);
}
return false;
}
static bool trans_c_ebreak_jalr_add(DisasContext *ctx, arg_c_ebreak_jalr_add *a)
{
if (a->rd == 0 && a->rs2 == 0) {
/* C.EBREAK */
arg_ebreak arg = { };
return trans_ebreak(ctx, &arg);
} else if (a->rd != 0) {
if (a->rs2 == 0) {
/* C.JALR */
arg_jalr arg = { .rd = 1, .rs1 = a->rd, .imm = 0 };
return trans_jalr(ctx, &arg);
} else {
/* C.ADD */
arg_add arg = { .rd = a->rd, .rs1 = a->rd, .rs2 = a->rs2 };
return trans_add(ctx, &arg);
}
}
return false;
}
static bool trans_c_fsdsp(DisasContext *ctx, arg_c_fsdsp *a)
{
arg_fsd arg = { .rs1 = 2, .rs2 = a->rs2, .imm = a->uimm };
return trans_fsd(ctx, &arg);
}
static bool trans_c_swsp(DisasContext *ctx, arg_c_swsp *a)
{
arg_sw arg = { .rs1 = 2, .rs2 = a->rs2, .imm = a->uimm };
return trans_sw(ctx, &arg);
}
static bool trans_c_fswsp_sdsp(DisasContext *ctx, arg_c_fswsp_sdsp *a)
{
#ifdef TARGET_RISCV32
/* C.FSWSP */
arg_fsw a_fsw = { .rs1 = 2, .rs2 = a->rs2, .imm = a->uimm_fswsp };
return trans_fsw(ctx, &a_fsw);
#else
/* C.SDSP */
arg_sd a_sd = { .rs1 = 2, .rs2 = a->rs2, .imm = a->uimm_sdsp };
return trans_sd(ctx, &a_sd);
#endif
}
main()
{
int i,j,k=-1,g; // i= participant number , k= total points on EC , g= Base point of EC
printf("\n Initialization process ( Both user & chairperson ) \n ---------------------------------------------\n");
do {
printf("\n Choose a prime number : "); // Prime no. to define Finite Field Fp
scanf("%d",&p);
j=0;
for(i=2;i<p;i++) // Prime checking
if((p % i)==0)
j=1;
} while(j);
struct pair ecc[2*p*p],rp,bp; // Points on EC , Random point & Base point
while(4*a*a*a + 27*b*b == 0) // Singularity constraint on EC : 4a^3 + 27b^2 != 0
{
printf("\n\n Choose elliptic curve parameters a and b : ");
scanf("%d %d",&a,&b);
}
for(i=0;i<p;i++) // Generating points on EC
for(j=0;j<p;j++)
if( ((i*i*i+a*i+b) % p) == (j*j % p) ) // y^2 mod p = (x^3 + aX + b) mod p
{
ecc[++k].x=i;
ecc[k].y=j;
ecc[++k].x=i;
if(j != 0) // root of j^2 = +j & -j
ecc[k].y=p-j;
else
ecc[k].y=j;
break;
}
printf("\n\n Set of Sample Points on EC : ");
for(i=0;i<=k;i++)
printf("\t ( %d , %d )",ecc[i].x,ecc[i].y); // Points on EC within Finite Field Fp
bp=ecc[0];
for(j=0;j<=k;j++)
if((ecc[j].x+ecc[j].y)<(bp.x+bp.y)) // Choosing Base point with smallest co-ordinate on EC
bp=ecc[j];
printf("\n Base point G : ( %d , %d )\n",bp.x,bp.y);
printf("\n Enter no. of participants : "); // Total no of participants under chairPerson
scanf("%d",&i);
int par_pvt[i],chpr_pvt; // Private key of ChairPerson & each Participant
struct pair par_pub[i],chpr_pub,par_shared[i],encr_shared[i],decr_shared[i]; // Public keys, Shared keys
printf("\n\n Chairperson site \n ---------------- \n");
do {
printf("\n Choose private key of chairperson ( 0<key<p ) : ");
scanf("%d",&chpr_pvt); // 0 < ChairPerson Private key < p
} while((chpr_pvt >= p) || (chpr_pvt <= 0) );
chpr_pub=keygen(chpr_pvt,bp); // Generating Public key from Private key of ChairPerson
printf("\n Public key of chairperson : ( %d , %d ) \n",chpr_pub.x,chpr_pub.y);
printf("\n Participant site \n ---------------- \n");
for(j=0;j<i;j++)
{
do {
printf("\n Choose private key of participant[%d] ( 0<key<p ) : ",j);
scanf("%d",&par_pvt[j]); // 0 < Participant Private key < p
} while((par_pvt[j] >= p) || (par_pvt[j] <= 0) );
par_pub[j]=keygen(par_pvt[j],bp); // Generating Pulic key from Private key of Participant
printf("\n Public key of participant[%d] : ( %d , %d )",j,par_pub[j].x,par_pub[j].y);
par_shared[j]=keygen(par_pvt[j],chpr_pub); // Generating Shared key by each participant
printf("\n Shared key of participant[%d] : ( %d , %d )",j,par_shared[j].x,par_shared[j].y);
encr_shared[j]=trans_add(par_shared[j],keygen(par_pvt[j],chpr_pub)); // Encrypting Shared key by participant
printf("\n Encrypted Shared key of participant[%d] : ( %d , %d ) \n",j,encr_shared[j].x,encr_shared[j].y);
}
printf("\n Chairperson site \n ---------------- \n");
struct pair combine_key,group_key,encr_group_key[i],decr_group_key[i]; // Combine & Group key
while(1)
{
printf("\n Choose a random pair (any point on EC) : ");
scanf("%d %d",&rp.x,&rp.y);
for(j=0;j<=k;j++)
if((rp.x==ecc[j].x)&&(rp.y==ecc[j].y)) // Random Point choosen by chairperson need to be on EC
j=k+1;
if(j==k+2)
break;
}
printf("\n");
combine_key=rp; // combine key initialized with random point rp
for(j=0;j<i;j++)
{
decr_shared[j]=trans_sub(encr_shared[j],keygen(chpr_pvt,par_pub[j]));//Decrypting Shared key from participant
printf("\n Decrypted Shared key of participant[%d] : ( %d , %d )",j,decr_shared[j].x,decr_shared[j].y);
combine_key=trans_add(combine_key,decr_shared[j]); // Calculating Combine key
}
printf("\n\n Combine key : ( %d , %d )\n",combine_key.x,combine_key.y);
group_key=keygen(chpr_pvt,combine_key); // Generating Group key from Combine key
printf("\n Group key : ( %d , %d )\n",group_key.x,group_key.y);
printf("\n Participant site \n ------------------- \n");
for(j=0;j<i;j++)
{
encr_group_key[j]=trans_add(group_key,keygen(chpr_pvt,par_pub[j]));//Encrypted Groupkey to the participant
printf("\n Encrypted Group Key to participant[%d] : ( %d , %d )",j,encr_group_key[j].x,encr_group_key[j].y);
decr_group_key[j]=trans_sub(encr_group_key[j],keygen(par_pvt[j],chpr_pub));// Decryption to get Group key
printf("\n Decrypted Group Key for participant[%d]:( %d , %d )\n",j,decr_group_key[j].x,decr_group_key[j].y);
}
} // Group Key ready to use
