TEST(NodeToStringTests, PairSingle)
{
Node node;
Node pair;
pair.addChild(IntLeaf(1));
pair.addChild(IntLeaf(2));
node.addChild(pair);
node.addChild(IntLeaf(3));
EXPECT_EQ(node.toString(), "((1, 2), 3)");
}
TEST(NodeToStringTests, PairVector)
{
Node node;
for(unsigned int i=0; i<7; i++)
{
Node pair;
pair.addChild(IntLeaf(i));
pair.addChild(IntLeaf(10+i));
node.addChild(pair);
}
EXPECT_EQ(node.toString(), "((0, 10), (1, 11), (2, 12), (3, 13), (4, 14), (5, 15), (6, 16))");
}
bool isElemOfGq(const Node &group, const IntLeaf &elem)
{
// For convenience
const IntLeaf &p = group.getIntLeafChild(0);
const IntLeaf &q = group.getIntLeafChild(1);
// Make sure elem is in allowed range for elements in Gq
if(!(elem < p) || (elem < IntLeaf(1)))
return false;
// A group element raised to the group order equals identity
if(elem.expMod(q, p) != IntLeaf(1))
return false;
return true;
}
bool isElemOfZn(const IntLeaf &n, const IntLeaf &elem)
{
// Need only test to make sure elem is within allowed range
if(!(elem < n) || elem < IntLeaf(0))
return false;
return true;
}
static void FixupC99MainReturn( SYM_HANDLE func_result, struct return_info *info )
{
TREEPTR tree;
TYPEPTR main_type;
/* In C99 mode, return statement need not be explicit for main()... */
main_type = CurFunc->sym_type->object;
SKIP_TYPEDEFS( main_type );
/* ... as long as return type is compatible with int */
if( main_type->decl_type == TYPE_INT ) {
tree = IntLeaf( 0 ); /* zero is the default return value */
tree = ExprNode( 0, OPR_RETURN, tree );
tree->expr_type = main_type;
tree->op.sym_handle = func_result;
AddStmt( tree );
info->with_expr = TRUE;
}
}
local void InitStructVar( unsigned base, SYMPTR sym, SYM_HANDLE sym_handle, TYPEPTR typ)
{
TYPEPTR typ2;
TREEPTR opnd;
TREEPTR value;
FIELDPTR field;
TOKEN token;
for( field = typ->u.tag->u.field_list; field; ) {
token = CurToken;
if( token == T_LEFT_BRACE ) NextToken(); //allow {}, and extra {expr}..}
typ2 = field->field_type;
SKIP_TYPEDEFS( typ2 );
if( CurToken == T_RIGHT_BRACE ) {
value = IntLeaf( 0 );
} else {
value = CommaExpr();
}
opnd = VarLeaf( sym, sym_handle );
if( typ2->decl_type == TYPE_UNION ) {
FIELDPTR ufield;
ufield = typ2->u.tag->u.field_list;
typ2 = ufield->field_type;
SKIP_TYPEDEFS( typ2 );
}
opnd = ExprNode( opnd, OPR_DOT, UIntLeaf( base + field->offset ) );
opnd->expr_type = typ2;
opnd->op.result_type = typ2;
AddStmt( AsgnOp( opnd, T_ASSIGN_LAST, value ) );
if( token == T_LEFT_BRACE ) MustRecog( T_RIGHT_BRACE );
if( CurToken == T_EOF ) break;
field = field->next_field;
if( field == NULL ) break;
if( CurToken != T_RIGHT_BRACE ) {
MustRecog( T_COMMA );
}
}
}
local void InitArrayVar( SYMPTR sym, SYM_HANDLE sym_handle, TYPEPTR typ )
{
unsigned i;
unsigned n;
TYPEPTR typ2;
SYM_HANDLE sym2_handle;
SYM_ENTRY sym2;
TREEPTR opnd;
TREEPTR value;
TOKEN token;
typ2 = typ->object;
SKIP_TYPEDEFS( typ2 );
switch( typ2->decl_type ) {
case TYPE_CHAR:
case TYPE_UCHAR:
case TYPE_SHORT:
case TYPE_USHORT:
case TYPE_INT:
case TYPE_UINT:
case TYPE_LONG:
case TYPE_ULONG:
case TYPE_LONG64:
case TYPE_ULONG64:
case TYPE_FLOAT:
case TYPE_DOUBLE:
case TYPE_POINTER:
case TYPE_LONG_DOUBLE:
case TYPE_FIMAGINARY:
case TYPE_DIMAGINARY:
case TYPE_LDIMAGINARY:
case TYPE_BOOL:
NextToken(); // skip over T_LEFT_BRACE
if( CharArray( typ->object ) ) {
sym2_handle = MakeNewSym( &sym2, 'X', typ, SC_STATIC );
sym2.flags |= SYM_INITIALIZED;
if( sym2.u.var.segment == 0 ) { /* 01-dec-91 */
SetFarHuge( &sym2, 0 );
SetSegment( &sym2 );
SetSegAlign( &sym2 ); /* 02-feb-92 */
}
SymReplace( &sym2, sym2_handle );
GenStaticDataQuad( sym2_handle );
InitCharArray( typ );
AssignAggregate( VarLeaf( sym, sym_handle ),
VarLeaf( &sym2, sym2_handle ), typ );
} else if( WCharArray( typ->object ) ) {
sym2_handle = MakeNewSym( &sym2, 'X', typ, SC_STATIC );
sym2.flags |= SYM_INITIALIZED;
if( sym2.u.var.segment == 0 ) { /* 01-dec-91 */
SetFarHuge( &sym2, 0 );
SetSegment( &sym2 );
SetSegAlign( &sym2 ); /* 02-feb-92 */
}
SymReplace( &sym2, sym2_handle );
GenStaticDataQuad( sym2_handle );
InitWCharArray( typ );
AssignAggregate( VarLeaf( sym, sym_handle ),
VarLeaf( &sym2, sym2_handle ), typ );
} else {
n = typ->u.array->dimension;
i = 0;
for( ;; ) { // accept some C++ { {1},.. }
token = CurToken;
if( token == T_LEFT_BRACE ) NextToken();
opnd = VarLeaf( sym, sym_handle );
value = CommaExpr();
opnd = ExprNode( opnd, OPR_INDEX, IntLeaf( i ) );
opnd->expr_type = typ2;
opnd->op.result_type = typ2;
AddStmt( AsgnOp( opnd, T_ASSIGN_LAST, value ) );
if( token == T_LEFT_BRACE ) MustRecog( T_RIGHT_BRACE );
++i;
if( CurToken == T_EOF ) break;
if( CurToken == T_RIGHT_BRACE )break;
MustRecog( T_COMMA );
if( CurToken == T_RIGHT_BRACE )break;
if( i == n ) {
CErr1( ERR_TOO_MANY_INITS );
}
}
if( typ->u.array->unspecified_dim ) {
typ->u.array->dimension = i;
} else {
while( i < n ) {
value = IntLeaf( 0 );
opnd = VarLeaf( sym, sym_handle );
opnd = ExprNode( opnd, OPR_INDEX, IntLeaf( i ) );
opnd->expr_type = typ2;
opnd->op.result_type = typ2;
AddStmt( AsgnOp( opnd, T_ASSIGN_LAST, value ) );
++i;
}
}
}
MustRecog( T_RIGHT_BRACE );
break;
case TYPE_FCOMPLEX:
case TYPE_DCOMPLEX:
case TYPE_LDCOMPLEX:
case TYPE_STRUCT:
case TYPE_UNION:
if( SimpleStruct( typ2 ) ) {
unsigned base;
unsigned size;
NextToken(); // skip over T_LEFT_BRACE
n = typ->u.array->dimension;
i = 0;
base = 0;
size = SizeOfArg( typ2 );
for( ;; ) {
token = CurToken;
if( token == T_LEFT_BRACE ) {
NextToken();
}
InitStructVar( base, sym, sym_handle, typ2 );
if( token == T_LEFT_BRACE ) {
MustRecog( T_RIGHT_BRACE );
}
++i;
if( CurToken == T_EOF ) break;
if( CurToken == T_RIGHT_BRACE ) break;
MustRecog( T_COMMA );
if( CurToken == T_RIGHT_BRACE ) break;
if( i == n ) {
CErr1( ERR_TOO_MANY_INITS );
}
base += size;
}
if( typ->u.array->unspecified_dim ) {
typ->u.array->dimension = i;
} else {
while( i < n ) { // mop up
base += size;
InitStructVar( base, sym, sym_handle, typ2 );
++i;
}
}
NextToken(); // skip over T_RIGHT_BRACE
break;
}
default:
AggregateVarDeclEquals( sym, sym_handle );
break;
}
}
bool DecryptionVerifier(const proofStruct &ps, const Node L, const Node m) {
IntLeaf p = ps.Gq.getIntLeafChild(0);
//Step 1
Node f, tauDec, sigmaDec;
try
{
for (unsigned int l = 1; l <= ps.lambda; l++)
{
char filename[FILENAME_BUFFER_SIZE];
sprintf(filename, DECRYPTION_FACTORS_FILE_TMPL.c_str(), l);
Node f_l = Node(ps.directory + "/proofs/" + filename);
f.addChild(f_l);
sprintf(filename, DECR_FACT_COMMITMENT_FILE_TMPL.c_str(), l);
Node tauDec_l = Node(ps.directory + "/proofs/" + filename);
tauDec.addChild(tauDec_l);
sprintf(filename, DECR_FACT_REPLY_FILE_TMPL.c_str(), l);
std::ifstream sigmaDec_l_file((ps.directory + "/proofs/" + filename).c_str(), std::fstream::in | std::fstream::binary);
IntLeaf sigmaDec_l = IntLeaf(sigmaDec_l_file);
sigmaDec.addChild(sigmaDec_l);
print_debug("DecryptionVerifier: f", l, f_l.serialize());
}
}
catch(...)
{
return false;
}
//Step 2
bool result = DecryptionFactorsVerifier(0, ps, f, tauDec, sigmaDec, L);
if(!result) {
//Step 3
for (int l = 0; l < f.getLength(); l++)
{
result = DecryptionFactorsVerifier(l+1, ps, f, tauDec, sigmaDec, L);
IntLeaf xL = ps.x.getIntLeafChild(l);
if(!result && (xL == BOTTOM || f.getIntLeafChild(l) != PDec(xL, L.getIntLeafChild(l), p))) {
return false;
}
}
}
//Step 4
IntLeaf x = f.prod();
for(int i = 0; i < L.getLength(); i++) {
if(m.getIntLeafChild(i) != TDec(L.getIntLeafChild(i), x, p)) {
return false;
}
}
return true;
}
