// def createCoordsProof(self, version, g2, g3, r):
void createCoordsProof( char* version, BIGNUM* g2, BIGNUM* g3, BIGNUM* r, BIGNUM* c, BIGNUM* d1, BIGNUM* d2 )
{
// r1 = createRandomExponent()
// r2 = createRandomExponent()
BIGNUM* r1 = createRandomExponent();
BIGNUM* r2 = createRandomExponent();
// tmp1 = pow(g3, r1, self.mod)
BIGNUM* tmp1 = my_pow( g3, r1, mod );
// tmp2 = mulm( pow(self.gen, r1, self.mod), pow(g2, r2, self.mod), self.mod)
// Step A = pow(self.gen, r1, self.mod)
BIGNUM* stepA = my_pow( gen, r1, mod );
// Step B = pow(g2, r2, self.mod)
BIGNUM* stepB = my_pow( g2, r2, mod );
// Step C = mulm( StepA, StepB, mod )
BIGNUM* tmp2 = mulm( stepA, stepB, mod );
// c = sha256(version + str(tmp1) + str(tmp2))
BIGNUM* tmp3 = sha_with_version( version, tmp1, tmp2 );
BN_copy( c, tmp3 );
// d1 = (r1 - mulm(r, c, self.modOrder)) % self.modOrder
BIGNUM* resultA = mulm( r, c, modOrder );
BIGNUM* d1_temp = subm( r1, resultA, modOrder );
BN_copy( d1, d1_temp );
// d2 = (r2 - mulm(self.secret, c, self.modOrder)) % self.modOrder
BIGNUM* resultB = mulm( secret, c, modOrder );
BIGNUM* d2_temp = subm( r2, resultB, modOrder );
BN_copy( d2, d2_temp );
// clean up
BN_clear_free( r1 );
BN_clear_free( r2 );
BN_clear_free( tmp1 );
BN_clear_free( stepA );
BN_clear_free( stepB );
BN_clear_free( tmp2 );
BN_clear_free( tmp3 );
BN_clear_free( resultA );
BN_clear_free( d1_temp );
BN_clear_free( resultB );
BN_clear_free( d2_temp );
// return (c, d1, d2)
}
void step5( unsigned char* buffer, int buflen )
{
BIGNUM* rb = BN_new();
BIGNUM* c8 = BN_new();
BIGNUM* d10 = BN_new();
// (rb, c8, d10) = unpackList(buffer)
unsigned char* ptr = simpleUnpack( buffer, rb );
ptr = simpleUnpack( ptr, c8);
ptr = simpleUnpack( ptr, d10);
// if not self.isValidArgument(rb):
// raise ValueError("Invalid rb values")
// if not self.checkEqualLogs('8', c8, d10, self.g3b, mulm(self.qa, self.invm(self.qb), self.mod), rb):
// raise ValueError("Proof 8 check failed")
// Step A: self.invm(self.qb)
// Step B: mulm(self.qa, Step A, self.mod)
// Step C: checkEqualLogs('8', c8, d10, self.g3b, Step B, rb):
BIGNUM* stepA = invm( qb, mod );
BIGNUM* stepB = mulm( qa, stepA, mod );
if ( checkEqualLogs( "8", c8, d10, g3b, stepB, rb ) != 1 )
printf( "Proof 8 check failed\n" );
BN_clear_free( stepA );
// rab = pow(rb, self.x3, self.mod)
BIGNUM* rab = my_pow( rb, x3, mod );
// inv = self.invm(self.pb)
BIGNUM* inv = invm( pb, mod );
// if rab == mulm(self.pa, inv, self.mod):
// self.match = True
stepA = mulm( pa, inv, mod );
if ( BN_cmp( rab, stepA ) == 0 )
match = 1;
// clean up
BN_clear_free( stepA );
BN_clear_free( stepB );
BN_clear_free( rab );
BN_clear_free( inv );
BN_clear_free( rb );
BN_clear_free( c8 );
BN_clear_free( d10 );
}
// def checkCoordsProof(self, version, c, d1, d2, g2, g3, p, q):
int checkCoordsProof( char* version, BIGNUM* c, BIGNUM* d1, BIGNUM* d2, BIGNUM* g2, BIGNUM* g3, BIGNUM* p, BIGNUM* q )
{
// tmp1 = mulm(pow(g3, d1, self.mod), pow(p, c, self.mod), self.mod)
// Step A = pow(g3, d1, self.mod)
BIGNUM* stepA = my_pow( g3, d1, mod );
// Step B = pow(p, c, self.mod)
BIGNUM* stepB = my_pow( p, c, mod );
// Step C = mulm( StepA, StepB, mod )
BIGNUM* tmp1 = mulm( stepA, stepB, mod );
// tmp2 = mulm(mulm(pow(self.gen, d1, self.mod), pow(g2, d2, self.mod), self.mod), pow(q, c, self.mod), self.mod)
// Step A = pow(self.gen, d1, self.mod)
stepA = my_pow( gen, d1, mod );
// Step B = pow(g2, d2, self.mod)
stepB = my_pow( g2, d2, mod );
// Step C = pow(q, c, self.mod)
BIGNUM* stepC = my_pow( q, c, mod );
// Step D = mulm( StepA, StepB, self.mod )
BIGNUM* stepD = mulm( stepA, stepB, mod );
// Step E = mulm( StepD, StepC, mod )
BIGNUM* tmp2 = mulm( stepD, stepC, mod );
// cprime = sha256(version + str(tmp1) + str(tmp2))
BIGNUM* cprime = sha_with_version( version, tmp1, tmp2 );
int ret = BN_cmp( c, cprime );
// clean up
BN_clear_free( stepA );
BN_clear_free( stepB );
BN_clear_free( tmp1 );
BN_clear_free( tmp2 );
BN_clear_free( stepC );
BN_clear_free( stepD );
BN_clear_free( cprime );
// return (c == cprime)
return ( ret == 0 );
}
// def checkEqualLogs(self, version, c, d, g3, qab, r):
int checkEqualLogs( char* version, BIGNUM* c, BIGNUM* d, BIGNUM* g3, BIGNUM* qab, BIGNUM* r )
{
// tmp1 = mulm(pow(self.gen, d, self.mod), pow(g3, c, self.mod), self.mod)
// Step A = pow(self.gen, d, self.mod)
BIGNUM* stepA = my_pow( gen, d, mod );
// Step B = pow(g3, c, self.mod)
BIGNUM* stepB = my_pow( g3, c, mod );
// Step C = mulm( StepA, StepB, mod )
BIGNUM* tmp1 = mulm( stepA, stepB, mod );
BN_clear_free( stepA );
BN_clear_free( stepB );
// tmp2 = mulm(pow(qab, d, self.mod), pow(r, c, self.mod), self.mod)
// Step A = pow(qab, d, self.mod)
stepA = my_pow( qab, d, mod );
// Step B = pow(r, c, self.mod)
stepB = my_pow( r, c, mod );
// Step C = mulm( StepA, StepB, mod )
BIGNUM* tmp2 = mulm( stepA, stepB, mod );
// cprime = sha256(version + str(tmp1) + str(tmp2))
BIGNUM* cprime = sha_with_version( version, tmp1, tmp2 );
int ret = ( BN_cmp( c, cprime ) == 0 );
// clean up
BN_clear_free( stepA );
BN_clear_free( stepB );
BN_clear_free( tmp1 );
BN_clear_free( tmp2 );
BN_clear_free( cprime );
// return (c == cprime)
return ret;
}
// def createEqualLogsProof(self, version, qa, qb, x):
void createEqualLogsProof( char* version, BIGNUM* qa, BIGNUM* qb, BIGNUM* x, /* out */BIGNUM* c, /* out */BIGNUM* d )
{
// r = createRandomExponent()
BIGNUM* r = createRandomExponent();
// tmp1 = pow(self.gen, r, self.mod)
BIGNUM* tmp1 = my_pow( gen, r, mod );
// qab = mulm(qa, qb, self.mod)
BIGNUM* qab = mulm( qa, qb, mod );
// tmp2 = pow(qab, r, self.mod)
BIGNUM* tmp2 = my_pow( qab, r, mod );
// c = sha256(version + str(tmp1) + str(tmp2))
BIGNUM* c_temp = sha_with_version( version, tmp1, tmp2 );
BN_copy( c, c_temp );
BN_clear_free( tmp1 );
// tmp1 = mulm(x, c, self.modOrder)
tmp1 = mulm( x, c, modOrder );
// d = (r - tmp1) % self.modOrder
BIGNUM* d_temp = subm( r, tmp1, modOrder );
BN_copy( d, d_temp );
// return (c, d)
// clean up
BN_clear_free( r );
BN_clear_free( tmp1 );
BN_clear_free( qab );
BN_clear_free( tmp2 );
BN_clear_free( c_temp );
BN_clear_free( d_temp );
}
void main()
{
clrscr();
int m,n,p,q,a[20][20],b[20][20],c[20][20];
cout<<"Enter no:of rows & columns of first matrix:";
cin>>m>>n;
cout<<"Enter no:of rows & columns of second matrix:";
cin>>p>>q;
if(m!=p||n!=q)
cout<<"Matrix addition and substraction not possible.\n";
else
{
cout<<"Enter elements of First matrix:\n";
getm(m,n,a);
cout<<"Enter elements of Second matrix:\n";
getm(p,q,b);
clrscr();
cout<<"First matrix:\n";
prim(m,n,a);
cout<<"Second matrix:\n";
prim(p,q,b);
cout<<"Matrix Sum:\n";
addm(m,n,a,b);
cout<<"Matrix Difference:\n";
subm(m,n,a,b);
}
if(m!=q)
cout<<"Matrix multiplication not possible.";
else
{
if(m!=p||n!=q)
{
cout<<"Enter elements of First matrix:\n";
getm(m,n,a);
cout<<"Enter elements of Second matrix:\n";
getm(p,q,b);
clrscr();
cout<<"First matrix:\n";
prim(m,n,a);
cout<<"Second matrix:\n";
prim(p,q,b);
}
cout<<"Matrix Product:\n";
mulm(m,n,q,a,b,c);
}
getch();
}
//def createLogProof(self, version, x):
void createLogProof( char* version, BIGNUM* x, BIGNUM* c, BIGNUM* d )
{
// randExponent = createRandomExponent()
BIGNUM* randExponent = createRandomExponent();
// c = sha256( version + str( pow( self.gen, randExponent, self.mod ) ) )
BIGNUM* exponPower = my_pow( gen, randExponent, mod );
BIGNUM* c_temp = sha_with_version( version, exponPower, NULL );
BN_copy( c, c_temp );
// d = ( randExponent - mulm( x, c, self.modOrder ) ) % self.modOrder
BIGNUM* tmp = mulm( x, c, modOrder );
BIGNUM* d_temp = subm( randExponent, tmp, modOrder );
BN_copy( d, d_temp );
// clean up
BN_clear_free( randExponent );
BN_clear_free( exponPower );
BN_clear_free( c_temp );
BN_clear_free( tmp );
BN_clear_free( d_temp );
}
// def checkLogProof(self, version, g, c, d):
int checkLogProof( char* version, BIGNUM* g, BIGNUM* c, BIGNUM* d )
{
// gd = pow( gen, d, mod )
BIGNUM* gd = my_pow( gen, d, mod );
// gc = pow( g, c, mod)
BIGNUM* gc = my_pow( g, c, mod );
// gdgc = gd * gc % self.mod
BIGNUM* gdgc = mulm( gd, gc, mod );
// return (sha256(version + str(gdgc)) == c)
BIGNUM* bnShaBytes = sha_with_version( version, gdgc, NULL );
int ret = BN_cmp( bnShaBytes, c );
// clean up
BN_clear_free( gd );
BN_clear_free( gc );
BN_clear_free( gdgc );
BN_clear_free( bnShaBytes );
return ( ret == 0 );
}
unsigned int step4( unsigned char* buffer, int buflen )
{
BIGNUM* pa = BN_new();
BIGNUM* qa = BN_new();
BIGNUM* ra = BN_new();
BIGNUM* c6 = BN_new();
BIGNUM* d7 = BN_new();
BIGNUM* d8 = BN_new();
BIGNUM* c7 = BN_new();
BIGNUM* d9 = BN_new();
// (g2b, g3b, pb, qb, c3, d3, c4, d4, c5, d5, d6) = unpackList(buffer)
unsigned char* ptr = simpleUnpack( buffer, pa );
ptr = simpleUnpack( ptr, qa);
ptr = simpleUnpack( ptr, ra);
ptr = simpleUnpack( ptr, c6);
ptr = simpleUnpack( ptr, d7);
ptr = simpleUnpack( ptr, d8);
ptr = simpleUnpack( ptr, c7);
ptr = simpleUnpack( ptr, d9);
// if not self.isValidArgument(pa) or not self.isValidArgument(qa) or not self.isValidArgument(ra):
// raise ValueError("Invalid pa/qa/ra values")
// if not self.checkCoordsProof('6', c6, d7, d8, self.gb2, self.gb3, pa, qa):
// raise ValueError("Proof 6 check failed")
if ( checkCoordsProof( "6", c6, d7, d8, gb2, gb3, pa, qa ) != 1 )
printf( "Proof 6 check failed" );
// if not self.checkEqualLogs('7', c7, d9, self.g3a, mulm(qa, self.invm(self.qb), self.mod), ra):
// raise ValueError("Proof 7 check failed")
// Step A: self.invm(self.qb)
// Step B: mulm(qa, StepA, self.mod )
// Step C: checkEqualLogs( '7',c7, d9, self.g3a, StepB, ra):
BIGNUM* stepA = invm( qb, mod );
BIGNUM* stepB = mulm( qa, stepA, mod );
if ( checkEqualLogs( "7", c7, d9, g3a, stepB, ra) != 1 )
printf( "Proof 7 check failed" );
// inv = self.invm(self.qb)
BIGNUM* inv = invm( qb, mod );
// rb = pow(mulm(qa, inv, self.mod), self.x3, self.mod)
// Step A = mulm(qa, inv, self.mod)
stepA = mulm( qa, inv, mod );
BIGNUM* rb = my_pow( stepA, x3, mod );
BN_clear_free( stepA );
// (c8, d10) = self.createEqualLogsProof('8', qa, inv, self.x3)
BIGNUM* c8 = BN_new();
BIGNUM* d10 = BN_new();
createEqualLogsProof( "8", qa, inv, x3, c8, d10 );
// rab = pow(ra, self.x3, self.mod)
BIGNUM* rab = my_pow( ra, x3, mod );
// inv = self.invm(self.pb)
inv = invm( pb, mod );
// if rab == mulm(pa, inv, self.mod):
// self.match = True
stepA = mulm( pa, inv, mod );
if ( BN_cmp( rab, stepA ) == 0 )
match = 1;
// # Send rb, c8, d10
// return packList(rb, c8, d10)
memset( buffer, 0x00, buflen );
unsigned char* next = simplePack( buffer, rb );
next = simplePack( next, c8 );
next = simplePack( next, d10 );
// clean up
BN_clear_free( stepB );
BN_clear_free( inv );
BN_clear_free( stepA );
BN_clear_free( rb );
BN_clear_free( c8 );
BN_clear_free( d10 );
BN_clear_free( rab );
BN_clear_free( pa );
BN_clear_free( qa );
BN_clear_free( ra );
BN_clear_free( c6 );
BN_clear_free( d7 );
BN_clear_free( d8 );
BN_clear_free( c7 );
BN_clear_free( d9 );
return ( unsigned int )( next - buffer );
}
unsigned int step3( unsigned char* buffer, int buflen )
{
BIGNUM* g2b_new = BN_new();
BIGNUM* g3b_new = BN_new();
BIGNUM* pb_new = BN_new();
BIGNUM* qb_new = BN_new();
BIGNUM* c3_new = BN_new();
BIGNUM* d3_new = BN_new();
BIGNUM* c4_new = BN_new();
BIGNUM* d4_new = BN_new();
BIGNUM* c5_new = BN_new();
BIGNUM* d5_new = BN_new();
BIGNUM* d6_new = BN_new();
// (g2b, g3b, pb, qb, c3, d3, c4, d4, c5, d5, d6) = unpackList(buffer)
unsigned char* ptr = simpleUnpack( buffer, g2b_new );
ptr = simpleUnpack( ptr, g3b_new);
ptr = simpleUnpack( ptr, pb_new);
ptr = simpleUnpack( ptr, qb_new);
ptr = simpleUnpack( ptr, c3_new);
ptr = simpleUnpack( ptr, d3_new);
ptr = simpleUnpack( ptr, c4_new);
ptr = simpleUnpack( ptr, d4_new);
ptr = simpleUnpack( ptr, c5_new);
ptr = simpleUnpack( ptr, d5_new);
ptr = simpleUnpack( ptr, d6_new);
// if not self.checkLogProof('3', g2b, c3, d3):
// raise ValueError("Proof 3 check failed")
if ( checkLogProof( "3", g2b_new, c3_new, d3_new ) != 1 )
printf( "Proof 3 check failed!\n" );
// if not self.checkLogProof('4', g3b, c4, d4):
// raise ValueError("Proof 4 check failed")
if ( checkLogProof( "4", g3b_new, c4_new, d4_new ) != 1 )
printf( "Proof 4 check failed!\n" );
// self.g2b = g2b
// self.g3b = g3b
g3b = g3b_new;
// self.ga2 = pow(self.g2b, self.x2, self.mod)
BIGNUM* ga2 = my_pow( g2b_new, x2, mod );
// self.ga3 = pow(self.g3b, self.x3, self.mod)
BIGNUM* ga3 = my_pow( g3b_new, x3, mod );
// if not self.checkCoordsProof('5', c5, d5, d6, self.ga2, self.ga3, pb, qb):
// raise ValueError("Proof 5 check failed")
if ( checkCoordsProof( "5", c5_new, d5_new, d6_new, ga2, ga3, pb_new, qb_new ) != 1 )
printf( "Proof 5 check failed!\n" );
// s = createRandomExponent()
BIGNUM* s = createRandomExponent();
qb = qb_new;
pb = pb_new;
// self.pa = pow(self.ga3, s, self.mod)
pa = my_pow( ga3, s, mod );
// self.qa = mulm(pow(self.gen, s, self.mod), pow(self.ga2, self.secret, self.mod), self.mod)
// Step A = pow(self.gen, s, self.mod)
// Step B = pow(self.ga2, self.secret, self.mod)
// Step C = mulm( StepA, StepB, self.mod)
BIGNUM* stepA = my_pow( gen, s, mod );
BIGNUM* stepB = my_pow( ga2, secret, mod );
qa = mulm( stepA, stepB, mod );
// (c6, d7, d8) = self.createCoordsProof('6', self.ga2, self.ga3, s)
BIGNUM* c6 = BN_new();
BIGNUM* d7 = BN_new();
BIGNUM* d8 = BN_new();
createCoordsProof( "6", ga2, ga3, s, c6, d7, d8 );
// inv = self.invm(qb)
BIGNUM* inv = invm( qb_new, mod );
// self.ra = pow(mulm(self.qa, inv, self.mod), self.x3, self.mod)
// Step A = mulm(self.qa, inv, self.mod)
stepA = mulm( qa, inv, mod );
BIGNUM* ra = my_pow( stepA, x3, mod );
// (c7, d9) = self.createEqualLogsProof('7', self.qa, inv, self.x3)
BIGNUM* c7 = BN_new();
BIGNUM* d9 = BN_new();
createEqualLogsProof( "7", qa, inv, x3, c7, d9 );
// # Sends pa, qa, ra, c6, d7, d8, c7, d9
// return packList(self.pa, self.qa, self.ra, c6, d7, d8, c7, d9)
memset( buffer, 0x00, buflen );
unsigned char* next = simplePack( buffer, pa );
next = simplePack( next, qa );
next = simplePack( next, ra );
next = simplePack( next, c6 );
next = simplePack( next, d7 );
next = simplePack( next, d8 );
next = simplePack( next, c7 );
next = simplePack( next, d9 );
// clean up
BN_clear_free( g2b_new );
BN_clear_free( c3_new );
BN_clear_free( d3_new );
BN_clear_free( c4_new );
BN_clear_free( d4_new );
BN_clear_free( c5_new );
BN_clear_free( d5_new );
BN_clear_free( d6_new );
BN_clear_free( ga2 );
BN_clear_free( ga3 );
BN_clear_free( s );
BN_clear_free( stepA );
BN_clear_free( stepB );
BN_clear_free( c6 );
BN_clear_free( d7 );
BN_clear_free( d8 );
BN_clear_free( inv );
BN_clear_free( ra );
BN_clear_free( c7 );
BN_clear_free( d9 );
return ( unsigned int )( next - buffer );
}
unsigned int step2( unsigned char* buffer, int buflen )
{
BIGNUM* g2a_new = BN_new();
BIGNUM* c1_new = BN_new();
BIGNUM* d1_new = BN_new();
BIGNUM* c2_new = BN_new();
BIGNUM* d2_new = BN_new();
// (g2a, g3a, c1, d1, c2, d2) = unpackList(buffer)
unsigned char* ptr = simpleUnpack( buffer, g2a_new);
ptr = simpleUnpack( ptr, g3a);
ptr = simpleUnpack( ptr, c1_new);
ptr = simpleUnpack( ptr, d1_new);
ptr = simpleUnpack( ptr, c2_new);
ptr = simpleUnpack( ptr, d2_new);
// if not self.checkLogProof('1', g2a, c1, d1):
// raise ValueError("Proof 1 check failed")
if ( checkLogProof( "1", g2a_new, c1_new, d1_new ) != 1 )
printf( "checkLogProof g2, c1, d1 failed!\n" );
// if not self.checkLogProof('2', g3a, c2, d2):
// raise ValueError("Proof 2 check failed")
if ( checkLogProof( "2", g3a, c2_new, d2_new ) != 1 )
printf( "checkLogProof g3, c2, d2 failed!\n" );
// self.x2 = createRandomExponent()
// self.x3 = createRandomExponent()
x2 = createRandomExponent();
x3 = createRandomExponent();
// self.g2 = pow(self.gen, self.x2, self.mod)
g2 = my_pow( gen, x2, mod );
// self.g3 = pow(self.gen, self.x3, self.mod)
g3 = my_pow( gen, x3, mod );
BIGNUM* c3_new = BN_new();
BIGNUM* d3_new = BN_new();
BIGNUM* c4_new = BN_new();
BIGNUM* d4_new = BN_new();
// (c3, d3) = self.createLogProof('3', self.x2)
// (c4, d4) = self.createLogProof('4', self.x3)
createLogProof( "3", x2, c3_new, d3_new );
createLogProof( "4", x3, c4_new, d4_new );
// self.gb2 = pow(self.g2a, self.x2, self.mod)
gb2 = my_pow( g2a_new, x2, mod );
// self.gb3 = pow(self.g3a, self.x3, self.mod)
gb3 = my_pow( g3a, x3, mod );
BIGNUM* r = createRandomExponent();
// self.pb = pow(self.gb3, r, self.mod)
pb = my_pow( gb3, r, mod );
// self.qb = mulm(pow(self.gen, r, self.mod), pow(self.gb2, self.secret, self.mod), self.mod)
// Step A: pow(self.gen, r, self.mod)
BIGNUM* stepA = my_pow( gen, r, mod );
// Step B: pow(self.gb2, self.secret, self.mod)
BIGNUM* stepB = my_pow( gb2, secret, mod );
// Step C: mulm( StepA, StepB, self.mod)
qb = mulm( stepA, stepB, mod );
// (c5, d5, d6) = self.createCoordsProof('5', self.gb2, self.gb3, r)
BIGNUM* c5 = BN_new();
BIGNUM* d5 = BN_new();
BIGNUM* d6 = BN_new();
createCoordsProof( "5", gb2, gb3, r, c5, d5, d6 );
// # Sends g2b, g3b, pb, qb, all the c's and d's
// return packList(self.g2, self.g3, self.pb, self.qb, c3, d3, c4, d4, c5, d5, d6)
memset( buffer, 0x00, buflen );
unsigned char* next = simplePack( buffer, g2 );
next = simplePack( next, g3 );
next = simplePack( next, pb );
next = simplePack( next, qb );
next = simplePack( next, c3_new );
next = simplePack( next, d3_new );
next = simplePack( next, c4_new );
next = simplePack( next, d4_new );
next = simplePack( next, c5 );
next = simplePack( next, d5 );
next = simplePack( next, d6 );
// clean up
BN_clear_free( g2a_new );
BN_clear_free( c1_new );
BN_clear_free( d1_new );
BN_clear_free( c2_new );
BN_clear_free( d2_new );
BN_clear_free( c3_new );
BN_clear_free( d3_new );
BN_clear_free( c4_new );
BN_clear_free( d4_new );
BN_clear_free( r );
BN_clear_free( stepA );
BN_clear_free( stepB );
BN_clear_free( c5 );
BN_clear_free( d5 );
BN_clear_free( d6 );
return ( unsigned int )( next - buffer );
}
