def __init__(self, sdl, vars, equation, library):
self.sdl_data = sdl
self.vars = vars
self.verify = equation
self.debug = False
self.techMap = { 2:Technique2, 3:Technique3, 4:Technique4, 7:Technique7, 8:Technique8 }
# a quick way to test that a particular technique will transform the equation (pre-check)
self.techMap2 = { 5:DotProdInstanceFinder, 6:PairInstanceFinder }
global curve, param_id
curve, param_id = getBenchmarkInfo(library)
def __init__(self, sdl, vars, equation, library):
self.sdl_data = sdl
self.vars = vars
self.verify = equation
self.debug = False
self.techMap = {
2: Technique2,
3: Technique3,
4: Technique4,
7: Technique7,
8: Technique8
}
# a quick way to test that a particular technique will transform the equation (pre-check)
self.techMap2 = {5: DotProdInstanceFinder, 6: PairInstanceFinder}
global curve, param_id
curve, param_id = getBenchmarkInfo(library)
def run_main(opts, start=None, stop=None):
"""main entry point for generating batch verification algorithms"""
global singleVE, crypto_library, curve, param_id, assignInfo, varTypes, global_count, delta_count, applied_technique_list
verbose = opts['verbose']
statement = opts['test_stmt']
file = opts['sdl_file']
crypto_library = opts['library']
proof_flag = opts['proof']
benchmark_batcher = opts['benchmark']
curve, param_id = getBenchmarkInfo(crypto_library)
if statement:
debug = levels.all
parser = SDLParser()
final = parser.parse(statement)
print("Final statement(%s): '%s'" % (type(final), final))
sys.exit(0)
else:
# Parse the SDL file into binary tree
# ast_struct = parseFile(file)
parseFile(file, verbose, ignoreCloudSourcing=True)
setting = SDLSetting(verbose)
setting.parse(getAssignInfo(), getVarTypes()) # check for errors and pass on to user before continuing
# process single or multiple equations
verify_eq, N = [], None
#for n in ast_struct[ OTHER ]:
if len(setting.getVerifyEq()) == 0:
print(setting.getVerifyEq())
sys.exit("Could not locate the individual verification equation. Please edit SDL file.\n");
verifyEqDict = setting.getVerifyEq()
verifyEqUpdated = {}
isSingleEquation = {}
verifyList = list(verifyEqDict.keys())
verifyList.sort()
for k in verifyList:
# print("k := ", k, ", v := ", verifyEqDict[k])
if VERIFY in k:
(result, singleEq) = handleVerifyEq(verifyEqDict[k].get(VERIFY), delta_count, setting, verbose)
delta_count += 1 # where we do actual verification on # of eqs
verifyEqUpdated[ k ] = result
isSingleEquation[ k ] = singleEq
# santiy checks to verify setting makes sense for given equation
variables = setting.getTypes()
for k,v in verifyEqUpdated.items():
bte = BasicTypeExist( variables )
ASTVisitor( bte ).preorder( v )
bte.report( v )
#sys.exit(0)
# initiate the proof generator
if benchmark_batcher and type(start) == list: start[0] = time.clock()
print("Single verification equation: ", singleVE)
genProof = GenerateProof(singleVE)
# process settings
i = 1
finalVerifyList = []
types = setting.getTypes()
if len(verifyList) == 2:
batch_precompute = {}
sdlOutFile = None
for k in verifyList:
loopDetails = None
if verifyEqDict[ k ][ hasLoop ]:
try:
endValue = str(eval(verifyEqDict[k][endVal], setting.getTypes()))
# updates the types section to store the value for estimation purposes
setting.getTypes()[verifyEqDict[k][endVal]] = endValue
except:
print("Could not determine loop end value. Please define: ", verifyEqDict[k][endVal])
sys.exit(0)
loopDetails = (verifyEqDict[k][loopVar], verifyEqDict[k][startVal], endValue)
genProof.setPrefix('EQ' + str(i + 1))
(sdlOutFile, sdl_data, verify2, batch_precompute0, var_count) = runBatcher2(opts, genProof, file + str(i), verifyEqUpdated[k], setting, loopDetails, i)
genProof.changeMode( isSingleEquation[ k ] )
i += 1
# print("BATCH EQUATION: ", verify2)
finalVerifyList.append(verify2)
# print("FINAL VERIFY LIST: ", finalVerifyList)
# sdl_data.update(sdl_data0)
# types.update(types0)
batch_precompute.update(batch_precompute0)
eq1, eq2 = finalVerifyList
finalEq = CombineEqWithoutNewDelta(eq1, eq2)
if verbose: print("FINAL BATCH EQUATION:\n", finalEq)
if proof_flag:
genProof.setPrefix('')
genProof.setNextStep('Combine equations 1 and 2, then pairings within final equation (technique 6)', finalEq)
# buildSDLBatchVerifier(sdlOutFile, sdl_data, types, finalEq, batch_precompute, global_count, setting)
else:
for k in verifyList:
loopDetails = None
if verifyEqDict[ k ][ hasLoop ]:
try:
endValue = str(eval(verifyEqDict[k][endVal], setting.getTypes()))
setting.getTypes()[verifyEqDict[k][endVal]] = endValue
except:
print("Could not determine loop end value. Please define: ", verifyEqDict[k][endVal])
sys.exit(0)
loopDetails = (verifyEqDict[k][loopVar], verifyEqDict[k][startVal], endValue)
(sdlOutFile, sdl_data, verify2, batch_precompute, global_count) = runBatcher2(opts, genProof, file, verifyEqUpdated[k], setting, loopDetails)
finalEq = verify2
#buildSDLBatchVerifier(sdlOutFile, sdl_data, types, finalEq, batch_precompute, global_count, setting)
if proof_flag:
genProof.setNextStep('finalbatcheq', None)
latex_file = types['name'].upper()
if verbose: print("Generated the proof written to file: verification_gen%s.tex" % latex_file)
genProof.compileProof(opts['path'], latex_file)
# last step:construct SDL batch verifier
#print("technique list: ", applied_technique_list)
stopTime = time.clock() # in case we're benchmarking
if benchmark_batcher and stop and type(stop) == list: stop[0] = stopTime
return buildSDLBatchVerifier(opts, sdlOutFile, sdl_data, types, finalEq, batch_precompute, global_count, setting)
