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 );
}
/** Calculates M = inv(I + S' * S) [transpose = 0] or M = inv(I + S * S')
** [transpose = 1].
* @param p - size(S, 1)
* @param m - size(S, 2)
* @param transpose - flag: whether to transpose S
* @param S - input, p x m
* @param M - output, m x m [transpose = 0], p x p [transpose = 1]
* @return lapack_info (0 = success)
*/
static int calc_M(int p, int m, int transpose, double** S, double** M)
{
int i;
double a = 1.0;
double b = 0.0;
int lapack_info;
assert(p > 0);
if (!transpose) {
/*
* M = S' * S
*/
dgemm_(&doT, &noT, &m, &m, &p, &a, S[0], &p, S[0], &p, &b, M[0], &m);
/*
* M = I + S' * S
*/
for (i = 0; i < m; ++i)
M[i][i] += 1.0;
/*
* M = inv(I + S' * S)
*/
lapack_info = invm(m, M);
} else {
/*
* M = S * S'
*/
dgemm_(&noT, &doT, &p, &p, &m, &a, S[0], &p, S[0], &p, &b, M[0], &p);
/*
* M = I + S * S'
*/
for (i = 0; i < p; ++i)
M[i][i] += 1.0;
lapack_info = invm(p, M);
}
return lapack_info;
}
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 );
}
