def applyBSTransform(sdl_file, config):
""" read sdl file to determine interfaces and variable types, etc"""
global assignInfo
sdl.parseFile(sdl_file, False, ignoreCloudSourcing=True)
assignInfo = sdl.getAssignInfo()
allTypes = sdl.getVarTypes()
varTypes = allTypes.get(sdl.TYPES_HEADER)
# 1. extract each function
inputSchemeApi = {keygenFuncName:None, signFuncName:None, verifyFuncName:None}
funcVars = set()
for i in config.functionOrder:
print("processing func: ", i)
inputSchemeApi[i], _funcVars = getInterface(assignInfo, i)
funcVars = funcVars.union(_funcVars)
funcVars = list(funcVars)
print("funcVars: ", funcVars)
schemeTypes = getInterfaceTypes(allTypes, funcVars)
name = sdl.assignInfo[sdl.NONE_FUNC_NAME][sdl.SDL_NAME].getAssignNode().getRight().getAttribute()
setting = sdl.assignInfo[sdl.NONE_FUNC_NAME][sdl.ALGEBRAIC_SETTING].getAssignNode().getRight().getAttribute()
schemeCalls = {}
funcInput = {}
funcOutput = {}
for i in config.functionOrder:
schemeCalls[i] = "%s.%s(%s)" % (name, i, getArgString(inputSchemeApi[i][inputKeyword]))
print("funcCall: ", schemeCalls[i])
funcInput[i] = inputSchemeApi[i][inputKeyword]
funcOutput[i] = inputSchemeApi[i][outputKeyword]
bsT = BSTransform(assignInfo, varTypes, schemeTypes, schemeCalls, funcInput, funcOutput)
bsT.setSchemeName(name)
bsT.setSetting(setting)
bsT.constructSDL(config)
return
def runAutoStrong(sdlFile, config, options, sdlVerbose=False):
sdl.parseFile(sdlFile, sdlVerbose, ignoreCloudSourcing=True)
global assignInfo
assignInfo = sdl.getAssignInfo()
setting = sdl.assignInfo[sdl.NONE_FUNC_NAME][ALGEBRAIC_SETTING].getAssignNode().getRight().getAttribute()
assert setting == sdl.SYMMETRIC_SETTING, "AutoStrong requires a symmetric scheme for simplicity."
origVarTypes = dict(sdl.getVarTypes().get(sdl.TYPES_HEADER))
# extract property 1 details...
generators = []
if hasattr(config, "setupFuncName"):
setupConfig = sdl.getVarInfoFuncStmts( config.setupFuncName )
theStmt, theTypes = setupConfig[0], setupConfig[1]
extractGenerators(theStmt, theTypes, generators)
if hasattr(config, "keygenFuncName"):
keygenConfig = sdl.getVarInfoFuncStmts( config.keygenFuncName )
theStmt, theTypes = keygenConfig[0], keygenConfig[1]
extractGenerators(theStmt, theTypes, generators)
signConfig = sdl.getVarInfoFuncStmts( config.signFuncName )
signStmts, signTypes = signConfig[0], signConfig[1]
extractGenerators(signStmts, signTypes, generators)
verifyConfig = sdl.getVarInfoFuncStmts( config.verifyFuncName )
theStmt, theTypes = verifyConfig[0], verifyConfig[1]
extractGenerators(theStmt, theTypes, generators)
assert len(generators) != 0, "signature scheme does not select any generators?"
baseGen = generators[0]
print("Base generator: ", baseGen)
generators.remove(baseGen)
print("Other generator: ", generators)
#get config parameters
msg = config.messageVar
msgList = traceMessage(signStmts, signTypes, msg)
if len(msgList) == 0:
# msg used directly
msgVar = msg
else:
# indirection on msg
msgList.append(msg)
msgVar = msgList
print("msgVar: ", msgVar)
sigVar = config.signatureVar
(name, varInf) = getVarNameEntryFromAssignInfo(assignInfo, sigVar)
if name != config.signFuncName:
sys.exit("runAutoStrong: '%s' not in the sign function." % sigVar)
#print("identified signature: ", varInf.getAssignNode())
listVars = varInf.getListNodesList()
if len(listVars) == 0:
listVars.append(sigVar) # probably just one element in signature
#print("list of possible vars: ", listVars)
sigma = property1Extract(config.signFuncName, assignInfo, listVars, msgVar)
#if testForSUCMA:
# quick test for whether scheme is SU-CMA secure already
# sigma['sigma1'] += sigma['sigma2']
# sigma['sigma2'] = []
if sdlVerbose:
print("sigma1 => ", sigma['sigma1'])
print("sigma2 => ", sigma['sigma2'])
prop2Result = property2Extract(config.verifyFuncName, assignInfo, baseGen, generators, sigma)
noSigma2Result = noSigma2Check(sigma)
if options.get(skipTransform): return "skip_transform"
if prop2Result and not noSigma2Result:
print("Applying BSW transformation...")
# extract types for all variables
varTypes = sdl.getVarTypes().get(TYPES_HEADER)
for i in config.functionOrder:
#print("Processing func: ", i)
varTypes.update( sdl.getVarTypes().get(i) )
#print("Type variables for all: ", varTypes.keys())
bsw = BSWTransform(assignInfo, origVarTypes, varTypes, msgVar, msgList)
newSDL = bsw.constructSDL(config, options, sigma)
return newSDL
elif prop2Result and noSigma2Result:
#print("Signature Scheme Already Strongly Unforgeable!")
sys.exit(0)
else:
print("Applying BS transformation...")
return applyBSTransform(sdlFile, config)
