- Modified some scripts, in particular to get compareheuristics to work
with the new versions of Scyther.
This commit is contained in:
ccremers
parent
41e797413c
commit
494d02a524
@ -1,6 +1,6 @@
|
||||
#!/usr/bin/python
|
||||
#
|
||||
# Compare heuristics
|
||||
# Compare heuristics
|
||||
#
|
||||
import sys
|
||||
from optparse import OptionParser
|
||||
@ -9,169 +9,173 @@ import scythertest
|
||||
|
||||
# Parse
|
||||
def parse(scout):
|
||||
"""Parse Scyther output for heuristics tests
|
||||
"""Parse Scyther output for heuristics tests
|
||||
|
||||
in:
|
||||
A single Scyther output string (including newlines)
|
||||
out:
|
||||
ra: number of failed claims
|
||||
rb: number of bounded proofs of claims
|
||||
rc: number of complete proofs of claims
|
||||
nc: number of processed claims (should be the sum of the previous)
|
||||
st: number of states traversed
|
||||
"""
|
||||
in:
|
||||
A single Scyther output string (including newlines)
|
||||
out:
|
||||
ra: number of failed claims
|
||||
rb: number of bounded proofs of claims
|
||||
rc: number of complete proofs of claims
|
||||
nc: number of processed claims (should be the sum of the previous)
|
||||
st: number of states traversed
|
||||
"""
|
||||
|
||||
ra = 0
|
||||
rb = 0
|
||||
rp = 0
|
||||
nc = 0
|
||||
st = 0
|
||||
for l in scout.splitlines():
|
||||
data = l.split()
|
||||
if len(data) > 6 and data[0] == 'claim':
|
||||
tag = data[6]
|
||||
if tag == 'failed:':
|
||||
ra = ra + 1
|
||||
nc = nc + 1
|
||||
elif tag == 'correct:':
|
||||
nc = nc + 1
|
||||
if l.rfind("complete_proof") != -1:
|
||||
rp = rp + 1
|
||||
else:
|
||||
rb = rb + 1
|
||||
elif data[0] == 'states':
|
||||
st = int(data[1])
|
||||
return (ra,rb,rp,nc,st)
|
||||
ra = 0
|
||||
rb = 0
|
||||
rp = 0
|
||||
nc = 0
|
||||
st = 0
|
||||
for l in scout.splitlines():
|
||||
data = l.split()
|
||||
if len(data) > 4 and data[0] == 'claim':
|
||||
# determine claim status
|
||||
tag = data[4]
|
||||
if tag == 'Fail':
|
||||
ra = ra + 1
|
||||
nc = nc + 1
|
||||
elif tag == 'Ok':
|
||||
nc = nc + 1
|
||||
if l.rfind("proof of correctness") != -1:
|
||||
rp = rp + 1
|
||||
else:
|
||||
rb = rb + 1
|
||||
# now count the states
|
||||
for d in data:
|
||||
if d.startswith("states="):
|
||||
st = st + int(d[7:])
|
||||
|
||||
return (ra,rb,rp,nc,st)
|
||||
|
||||
|
||||
def test_goal_selector(goalselector, options):
|
||||
"""Test with a given goal selector
|
||||
"""Test with a given goal selector
|
||||
|
||||
in:
|
||||
goalselector: as in Scyther docs.
|
||||
options: options record (formatted as in optparse module)
|
||||
out:
|
||||
(attacks,bounds,proofs,claims,np,states)
|
||||
attacks: number of failed claims
|
||||
bounds: number of bounded proofs
|
||||
proofs: number of complete proofs
|
||||
np: number of protocols tested
|
||||
states: total number of states explored.
|
||||
"""
|
||||
in:
|
||||
goalselector: as in Scyther docs.
|
||||
options: options record (formatted as in optparse module)
|
||||
out:
|
||||
(attacks,bounds,proofs,claims,np,states)
|
||||
attacks: number of failed claims
|
||||
bounds: number of bounded proofs
|
||||
proofs: number of complete proofs
|
||||
np: number of protocols tested
|
||||
states: total number of states explored.
|
||||
"""
|
||||
|
||||
import protocollist
|
||||
import protocollist
|
||||
|
||||
scythertest.set_extra_parameters("--goal-select=" + str(goalselector))
|
||||
result = str(goalselector)
|
||||
plist = protocollist.from_literature()
|
||||
np = len(plist)
|
||||
scythertest.set_extra_parameters("--count-states --heuristic=" + str(goalselector))
|
||||
result = str(goalselector)
|
||||
plist = protocollist.from_literature()
|
||||
np = len(plist)
|
||||
|
||||
attacks = 0
|
||||
bounds = 0
|
||||
proofs = 0
|
||||
claims = 0
|
||||
states = 0
|
||||
for p in plist:
|
||||
(status,scout) = scythertest.default_test([p], \
|
||||
int(options.match), \
|
||||
int(options.bounds))
|
||||
(ra,rb,rp,nc,st) = parse(scout)
|
||||
attacks = attacks + ra
|
||||
bounds = bounds + rb
|
||||
proofs = proofs + rp
|
||||
claims = claims + nc
|
||||
states = states + st
|
||||
attacks = 0
|
||||
bounds = 0
|
||||
proofs = 0
|
||||
claims = 0
|
||||
states = 0
|
||||
for p in plist:
|
||||
(status,scout) = scythertest.default_test([p], \
|
||||
int(options.match), \
|
||||
int(options.bounds))
|
||||
(ra,rb,rp,nc,st) = parse(scout)
|
||||
attacks = attacks + ra
|
||||
bounds = bounds + rb
|
||||
proofs = proofs + rp
|
||||
claims = claims + nc
|
||||
states = states + st
|
||||
|
||||
return (attacks,bounds,proofs,claims,np,states)
|
||||
return (attacks,bounds,proofs,claims,np,states)
|
||||
|
||||
# Max
|
||||
class maxor:
|
||||
"""Class for a dynamic maximum determination and corresponding formatting
|
||||
"""
|
||||
"""Class for a dynamic maximum determination and corresponding formatting
|
||||
"""
|
||||
|
||||
def __init__(self,dir=0,mymin=99999999, mymax=-99999999):
|
||||
"""Init
|
||||
def __init__(self,dir=0,mymin=99999999, mymax=-99999999):
|
||||
"""Init
|
||||
|
||||
in:
|
||||
dir: bit 0 is set : notify of increase
|
||||
bit 1 is set : notify of decrease
|
||||
mymin: initial minimum
|
||||
mymax: initial maximum
|
||||
"""
|
||||
in:
|
||||
dir: bit 0 is set : notify of increase
|
||||
bit 1 is set : notify of decrease
|
||||
mymin: initial minimum
|
||||
mymax: initial maximum
|
||||
"""
|
||||
|
||||
self.dir = dir
|
||||
self.min = mymin
|
||||
self.max = mymax
|
||||
self.dir = dir
|
||||
self.min = mymin
|
||||
self.max = mymax
|
||||
|
||||
def reg(self,data):
|
||||
"""Store a new data element
|
||||
def reg(self,data):
|
||||
"""Store a new data element
|
||||
|
||||
in:
|
||||
element to be stored
|
||||
out:
|
||||
formatted element, plus increase/decrease
|
||||
notifications according to initial settings.
|
||||
"""
|
||||
in:
|
||||
element to be stored
|
||||
out:
|
||||
formatted element, plus increase/decrease
|
||||
notifications according to initial settings.
|
||||
"""
|
||||
|
||||
res = ""
|
||||
if self.min >= data:
|
||||
self.min = data
|
||||
if (self.dir & 2):
|
||||
res = res + "-"
|
||||
if self.max <= data:
|
||||
self.max = data
|
||||
if (self.dir & 1):
|
||||
res = res + "+"
|
||||
if res == "":
|
||||
return res
|
||||
else:
|
||||
return "[" + res + "]"
|
||||
res = ""
|
||||
if self.min >= data:
|
||||
self.min = data
|
||||
if (self.dir & 2):
|
||||
res = res + "-"
|
||||
if self.max <= data:
|
||||
self.max = data
|
||||
if (self.dir & 1):
|
||||
res = res + "+"
|
||||
if res == "":
|
||||
return res
|
||||
else:
|
||||
return "[" + res + "]"
|
||||
|
||||
# Main code
|
||||
def main():
|
||||
parser = OptionParser()
|
||||
scythertest.default_options(parser)
|
||||
(options, args) = parser.parse_args()
|
||||
scythertest.process_default_options(options)
|
||||
parser = OptionParser()
|
||||
scythertest.default_options(parser)
|
||||
(options, args) = parser.parse_args()
|
||||
scythertest.process_default_options(options)
|
||||
|
||||
print "G-sel\tAttack\tBound\tProof\tClaims\tScore1\tScore2\tStates\tBnd*Sts"
|
||||
print
|
||||
print "G-sel\tAttack\tBound\tProof\tClaims\tScore1\tScore2\tStates\tBnd*Sts"
|
||||
print
|
||||
|
||||
ramax = maxor(1)
|
||||
rbmax = maxor(2)
|
||||
rpmax = maxor(1)
|
||||
score1max = maxor(1)
|
||||
score2max = maxor(1)
|
||||
statesmax = maxor(2)
|
||||
boundstatesmax = maxor(2)
|
||||
ramax = maxor(1)
|
||||
rbmax = maxor(2)
|
||||
rpmax = maxor(1)
|
||||
score1max = maxor(1)
|
||||
score2max = maxor(1)
|
||||
statesmax = maxor(2)
|
||||
boundstatesmax = maxor(2)
|
||||
|
||||
for g in range(1,31):
|
||||
if (g & 8) == 0:
|
||||
(ra,rb,rp,nc,np,st) = test_goal_selector(g, options)
|
||||
for g in range(1,63):
|
||||
if (g & 8) == 0 and (g & 4) == 0 :
|
||||
(ra,rb,rp,nc,np,st) = test_goal_selector(g, options)
|
||||
|
||||
# Scores: bounds are negative
|
||||
score1 = ra + rp - rb
|
||||
score2 = ra + (3 * rp) - (2 * rb)
|
||||
boundstates = rb * st
|
||||
# Scores: bounds are negative
|
||||
score1 = ra + rp - rb
|
||||
score2 = ra + (3 * rp) - (2 * rb)
|
||||
boundstates = rb * st
|
||||
|
||||
res = str(g)
|
||||
res = str(g)
|
||||
|
||||
def shows (res, mx, data):
|
||||
return res + "\t" + str(data) + mx.reg(data)
|
||||
def shows (res, mx, data):
|
||||
return res + "\t" + str(data) + mx.reg(data)
|
||||
|
||||
res = shows (res, ramax, ra)
|
||||
res = shows (res, rbmax, rb)
|
||||
res = shows (res, rpmax, rp)
|
||||
res = res + "\t" + str(nc)
|
||||
res = shows (res, score1max, score1)
|
||||
res = shows (res, score2max, score2)
|
||||
res = shows (res, statesmax, st)
|
||||
res = shows (res, boundstatesmax, boundstates)
|
||||
res = shows (res, ramax, ra)
|
||||
res = shows (res, rbmax, rb)
|
||||
res = shows (res, rpmax, rp)
|
||||
res = res + "\t" + str(nc)
|
||||
res = shows (res, score1max, score1)
|
||||
res = shows (res, score2max, score2)
|
||||
res = shows (res, statesmax, st)
|
||||
res = shows (res, boundstatesmax, boundstates)
|
||||
|
||||
print res
|
||||
print
|
||||
print "Goal selector scan completed."
|
||||
print res
|
||||
print
|
||||
print "Goal selector scan completed."
|
||||
|
||||
# Only if main stuff
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
main()
|
||||
|
||||
@ -1,98 +1,105 @@
|
||||
#!/usr/bin/python
|
||||
#
|
||||
# protocol list
|
||||
# protocol list
|
||||
#
|
||||
#
|
||||
import os;
|
||||
|
||||
def list_ppfix(list, prefix, postfix):
|
||||
newlist = []
|
||||
for i in list:
|
||||
newlist.append(prefix + i + postfix)
|
||||
return newlist
|
||||
return [ prefix + i + postfix for i in list]
|
||||
|
||||
def from_good_literature():
|
||||
list = [ \
|
||||
"ccitt509-1c.spdl",
|
||||
"ccitt509-1.spdl",
|
||||
"ccitt509-3.spdl",
|
||||
"ccitt509-ban3.spdl",
|
||||
"denning-sacco-lowe.spdl",
|
||||
"denning-sacco.spdl",
|
||||
"kaochow.spdl",
|
||||
"kaochow-v2.spdl",
|
||||
"kaochow-v3.spdl",
|
||||
"ksl-lowe.spdl",
|
||||
"ksl.spdl",
|
||||
"needham-schroeder-lowe.spdl",
|
||||
"needham-schroeder-sk-amend.spdl",
|
||||
"needham-schroeder-sk.spdl",
|
||||
"neumannstub-hwang.spdl",
|
||||
"neumannstub.spdl",
|
||||
"otwayrees.spdl",
|
||||
"smartright.spdl",
|
||||
"splice-as-cj.spdl",
|
||||
"splice-as-hc.spdl",
|
||||
"splice-as.spdl",
|
||||
"woo-lam-pi-f.spdl",
|
||||
"woo-lam-pi.spdl",
|
||||
"woo-lam.spdl",
|
||||
"yahalom-lowe.spdl",
|
||||
"yahalom-paulson.spdl" ]
|
||||
list = [ \
|
||||
"ccitt509-1c.spdl",
|
||||
"ccitt509-1.spdl",
|
||||
"ccitt509-3.spdl",
|
||||
"ccitt509-ban3.spdl",
|
||||
"denning-sacco-lowe.spdl",
|
||||
"denning-sacco.spdl",
|
||||
"kaochow.spdl",
|
||||
"kaochow-v2.spdl",
|
||||
"kaochow-v3.spdl",
|
||||
"ksl-lowe.spdl",
|
||||
"ksl.spdl",
|
||||
"needham-schroeder-lowe.spdl",
|
||||
"needham-schroeder-sk-amend.spdl",
|
||||
"needham-schroeder-sk.spdl",
|
||||
"neumannstub-hwang.spdl",
|
||||
"neumannstub.spdl",
|
||||
"otwayrees.spdl",
|
||||
"smartright.spdl",
|
||||
"splice-as-cj.spdl",
|
||||
"splice-as-hc.spdl",
|
||||
"splice-as.spdl",
|
||||
"woo-lam-pi-f.spdl",
|
||||
"woo-lam-pi.spdl",
|
||||
"woo-lam.spdl",
|
||||
"yahalom-lowe.spdl",
|
||||
"yahalom-paulson.spdl" ]
|
||||
|
||||
return list_ppfix(list, "../spdl/SPORE/","")
|
||||
return list_ppfix(list, "/home/cas/svn/ecss/protocols/spdl/SPORE/","")
|
||||
|
||||
def from_bad_literature():
|
||||
list = [ \
|
||||
"andrew-ban-concrete.spdl",
|
||||
"andrew-ban.spdl",
|
||||
"andrew-lowe-ban.spdl",
|
||||
"andrew.spdl",
|
||||
"needham-schroeder.spdl",
|
||||
"tmn.spdl",
|
||||
"wmf-lowe.spdl",
|
||||
"wmf.spdl",
|
||||
"woo-lam-pi-1.spdl",
|
||||
"woo-lam-pi-2.spdl",
|
||||
"woo-lam-pi-3.spdl",
|
||||
"yahalom-ban.spdl",
|
||||
"yahalom.spdl" ]
|
||||
list = [ \
|
||||
"andrew-ban-concrete.spdl",
|
||||
"andrew-ban.spdl",
|
||||
"andrew-lowe-ban.spdl",
|
||||
"andrew.spdl",
|
||||
"needham-schroeder.spdl",
|
||||
"tmn.spdl",
|
||||
"wmf-lowe.spdl",
|
||||
"wmf.spdl",
|
||||
"woo-lam-pi-1.spdl",
|
||||
"woo-lam-pi-2.spdl",
|
||||
"woo-lam-pi-3.spdl",
|
||||
"yahalom-ban.spdl",
|
||||
"yahalom.spdl" ]
|
||||
|
||||
return list_ppfix(list, "../spdl/SPORE/","")
|
||||
return list_ppfix(list, "/home/cas/svn/ecss/protocols/spdl/SPORE/","")
|
||||
|
||||
def from_literature():
|
||||
return from_good_literature() + from_bad_literature()
|
||||
|
||||
def spdlfiletype (fn):
|
||||
return fn.endswith(".spdl")
|
||||
|
||||
spdldir = "/home/cas/svn/ecss/protocols/spdl/SPORE/"
|
||||
sl = os.listdir (spdldir)
|
||||
sld = [ spdldir + i for i in filter (spdlfiletype, sl)]
|
||||
##print sld
|
||||
return sld
|
||||
|
||||
def from_others():
|
||||
list = [ \
|
||||
]
|
||||
list = [ \
|
||||
]
|
||||
|
||||
return list_ppfix(list, "../spdl/","")
|
||||
return list_ppfix(list, "../spdl/","")
|
||||
|
||||
def from_all():
|
||||
return from_literature() + from_others()
|
||||
return from_literature() + from_others()
|
||||
|
||||
def select(type):
|
||||
n = int(type)
|
||||
if n == 0:
|
||||
# 0 means all protocols
|
||||
return from_all()
|
||||
elif n == 1:
|
||||
# 1 means from literature
|
||||
return from_literature()
|
||||
elif n == 2:
|
||||
# 2 means from literature, no known attacks
|
||||
return from_good_literature()
|
||||
else:
|
||||
# Otherwise empty list
|
||||
return []
|
||||
n = int(type)
|
||||
if n == 0:
|
||||
# 0 means all protocols
|
||||
return from_all()
|
||||
elif n == 1:
|
||||
# 1 means from literature
|
||||
return from_literature()
|
||||
elif n == 2:
|
||||
# 2 means from literature, no known attacks
|
||||
return from_good_literature()
|
||||
else:
|
||||
# Otherwise empty list
|
||||
return []
|
||||
|
||||
|
||||
|
||||
|
||||
def main():
|
||||
for l in [from_literature(), from_others()]:
|
||||
for p in l:
|
||||
print p
|
||||
print
|
||||
for l in [from_literature(), from_others()]:
|
||||
for p in l:
|
||||
print p
|
||||
print
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
main()
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
#!/usr/bin/python
|
||||
#
|
||||
# Scyther wrapper
|
||||
# Scyther wrapper
|
||||
#
|
||||
# Standard tests
|
||||
# Standard tests
|
||||
#
|
||||
import sys
|
||||
from optparse import OptionParser
|
||||
@ -20,29 +20,29 @@ g_extra = ""
|
||||
|
||||
# status
|
||||
def error_status(status):
|
||||
if status == 1 or status < 0:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
if status == 1 or status < 0:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
# Parse output
|
||||
def parse(scout):
|
||||
results = {}
|
||||
lines = scout.splitlines()
|
||||
for line in lines:
|
||||
data = line.split()
|
||||
if len(data) > 6 and data[0] == 'claim':
|
||||
claim = " ".join(data[1:4])
|
||||
tag = data[6]
|
||||
value = -1
|
||||
if tag == 'failed:':
|
||||
value = 0
|
||||
if tag == 'correct:':
|
||||
value = 1
|
||||
if value == -1:
|
||||
raise IOError, 'Scyther output for ' + commandline + ', line ' + line + ' cannot be parsed.'
|
||||
results[claim] = value
|
||||
return results
|
||||
results = {}
|
||||
lines = scout.splitlines()
|
||||
for line in lines:
|
||||
data = line.split()
|
||||
if len(data) > 4 and data[0] == 'claim':
|
||||
claim = ",".join(data[1:2])
|
||||
tag = data[5]
|
||||
value = -1
|
||||
if tag == 'Fail':
|
||||
value = 0
|
||||
if tag == 'Ok':
|
||||
value = 1
|
||||
if value == -1:
|
||||
raise IOError, 'Scyther output for ' + commandline + ', line ' + line + ' cannot be parsed.'
|
||||
results[claim] = value
|
||||
return results
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
# Default tests
|
||||
@ -50,131 +50,131 @@ def parse(scout):
|
||||
|
||||
# Yield default protocol list (from any other one)
|
||||
def default_protocols(plist):
|
||||
plist.sort()
|
||||
return ['../spdl/spdl-defaults.inc'] + plist
|
||||
plist.sort()
|
||||
return ['/home/cas/svn/ecss/protocols/spdl/spdl-defaults.inc'] + plist
|
||||
|
||||
# Get the extra parameters
|
||||
def get_extra_parameters():
|
||||
global g_extra
|
||||
global g_extra
|
||||
|
||||
return g_extra
|
||||
return g_extra
|
||||
|
||||
# Set the extra parameters
|
||||
def set_extra_parameters(args):
|
||||
global g_extra
|
||||
global g_extra
|
||||
|
||||
g_extra = args
|
||||
g_extra = args
|
||||
|
||||
# Add the extra parameters
|
||||
def add_extra_parameters(args):
|
||||
global g_extra
|
||||
global g_extra
|
||||
|
||||
if args != "":
|
||||
if g_extra != "":
|
||||
g_extra = g_extra + " "
|
||||
g_extra = g_extra + args
|
||||
if args != "":
|
||||
if g_extra != "":
|
||||
g_extra = g_extra + " "
|
||||
g_extra = g_extra + args
|
||||
|
||||
# Yield arguments, given a bound type:
|
||||
# 0: fast
|
||||
# 1: thorough
|
||||
# 0: fast
|
||||
# 1: thorough
|
||||
#
|
||||
def default_arguments(plist,match,bounds):
|
||||
n = 2 + bounds
|
||||
# These bounds assume at least two protocols, otherwise
|
||||
# stuff breaks.
|
||||
if n < 2:
|
||||
nmin = 2
|
||||
else:
|
||||
nmin = n
|
||||
timer = 1
|
||||
maxruns = 2
|
||||
maxlength = 10
|
||||
if bounds == 0:
|
||||
timer = 10 * (nmin**2)
|
||||
maxruns = 2*nmin
|
||||
maxlength = 2 + maxruns * 4
|
||||
elif bounds == 1:
|
||||
timer = 10 * (nmin**3)
|
||||
maxruns = 3*nmin
|
||||
maxlength = 4 + maxruns * 6
|
||||
elif bounds == 2:
|
||||
timer = 20 * 60 # 20 minutes
|
||||
maxruns = 3*nmin
|
||||
maxlength = 4 + maxruns * 6
|
||||
else:
|
||||
print "Don't know bounds method", bounds
|
||||
sys.exit()
|
||||
n = 2 + bounds
|
||||
# These bounds assume at least two protocols, otherwise
|
||||
# stuff breaks.
|
||||
if n < 2:
|
||||
nmin = 2
|
||||
else:
|
||||
nmin = n
|
||||
timer = 1
|
||||
maxruns = 2
|
||||
maxlength = 10
|
||||
if bounds == 0:
|
||||
timer = 10 * (nmin**2)
|
||||
maxruns = 2*nmin
|
||||
maxlength = 2 + maxruns * 4
|
||||
elif bounds == 1:
|
||||
timer = 10 * (nmin**3)
|
||||
maxruns = 3*nmin
|
||||
maxlength = 4 + maxruns * 6
|
||||
elif bounds == 2:
|
||||
timer = 20 * 60 # 20 minutes
|
||||
maxruns = 3*nmin
|
||||
maxlength = 4 + maxruns * 6
|
||||
else:
|
||||
print "Don't know bounds method", bounds
|
||||
sys.exit()
|
||||
|
||||
args = "--arachne"
|
||||
if timer > 0:
|
||||
args = args + " --timer=%i" % timer
|
||||
args = args + " --max-runs=%i --max-length=%i" % (maxruns, maxlength)
|
||||
matching = "--match=" + str(match)
|
||||
args = "--summary " + matching + " " + args
|
||||
args = ""
|
||||
if timer > 0:
|
||||
args = args + " --timer=%i" % timer
|
||||
args = args + " --max-runs=%i --max-length=%i" % (maxruns, maxlength)
|
||||
matching = "--match=" + str(match)
|
||||
args = "--plain " + matching + " " + args
|
||||
|
||||
extra = get_extra_parameters()
|
||||
if extra != "":
|
||||
args = extra + " " + args
|
||||
return args
|
||||
extra = get_extra_parameters()
|
||||
if extra != "":
|
||||
args = extra + " " + args
|
||||
return args
|
||||
|
||||
# Yield test results
|
||||
def default_test(plist, match, bounds):
|
||||
pl = default_protocols(plist)
|
||||
args = default_arguments(plist,match,bounds)
|
||||
pl = default_protocols(plist)
|
||||
args = default_arguments(plist,match,bounds)
|
||||
|
||||
input = ""
|
||||
for fn in pl:
|
||||
if len(fn) > 0:
|
||||
f = open(fn, "r")
|
||||
input = input + f.read()
|
||||
f.close()
|
||||
input = ""
|
||||
for fn in pl:
|
||||
if len(fn) > 0:
|
||||
f = open(fn, "r")
|
||||
input = input + f.read()
|
||||
f.close()
|
||||
|
||||
# Use Scyther
|
||||
(status,scout) = evaluate(args,input)
|
||||
return (status,scout)
|
||||
# Use Scyther
|
||||
(status,scout) = evaluate(args,input)
|
||||
return (status,scout)
|
||||
|
||||
# Test, check for status, yield parsed results
|
||||
def default_parsed(plist, match, bounds):
|
||||
(status,scout) = default_test(plist, match, bounds)
|
||||
if error_status(status):
|
||||
# Something went wrong
|
||||
print "*** Error when checking [", plist, match, bounds, "]"
|
||||
print
|
||||
sys.exit()
|
||||
return parse(scout)
|
||||
(status,scout) = default_test(plist, match, bounds)
|
||||
if error_status(status):
|
||||
# Something went wrong
|
||||
print "*** Error when checking [", plist, match, bounds, "]"
|
||||
print
|
||||
sys.exit()
|
||||
return parse(scout)
|
||||
|
||||
# Some default options for the scyther wrapper
|
||||
def default_options(parser):
|
||||
parser.add_option("-m","--match", dest="match",
|
||||
default = 0,
|
||||
help = "select matching method (0: no type flaws, 2: \
|
||||
full type flaws")
|
||||
parser.add_option("-b","--bounds", dest="bounds",
|
||||
default = 0,
|
||||
help = "bound type selection (0: quickscan, 1:thorough, 2: no time limit)")
|
||||
parser.add_option("-x","--extra", dest="extra",
|
||||
default = "",
|
||||
help = "add arguments to pass to Scyther")
|
||||
parser.add_option("-P","--program", dest="program",
|
||||
default = "",
|
||||
help = "define alternative scyther executable")
|
||||
parser.add_option("-N","--no-cache", dest="nocache",
|
||||
default = False,
|
||||
action = "store_true",
|
||||
help = "do not use cache mechanism")
|
||||
parser.add_option("-m","--match", dest="match",
|
||||
default = 0,
|
||||
help = "select matching method (0: no type flaws, 2: \
|
||||
full type flaws")
|
||||
parser.add_option("-b","--bounds", dest="bounds",
|
||||
default = 0,
|
||||
help = "bound type selection (0: quickscan, 1:thorough, 2: no time limit)")
|
||||
parser.add_option("-x","--extra", dest="extra",
|
||||
default = "",
|
||||
help = "add arguments to pass to Scyther")
|
||||
parser.add_option("-P","--program", dest="program",
|
||||
default = "",
|
||||
help = "define alternative scyther executable")
|
||||
parser.add_option("-N","--no-cache", dest="nocache",
|
||||
default = False,
|
||||
action = "store_true",
|
||||
help = "do not use cache mechanism")
|
||||
|
||||
# Process the default options
|
||||
def process_default_options(options):
|
||||
if options.program != "":
|
||||
scytheroverride(options.program)
|
||||
print "Using", options.program, "as Scyther executable."
|
||||
if options.extra != "":
|
||||
add_extra_parameters(options.extra)
|
||||
print "Added extra options, now:", get_extra_parameters()
|
||||
if options.nocache:
|
||||
# Do not use cache
|
||||
print "Warning: Disabling cache"
|
||||
cacheoverride ()
|
||||
if options.program != "":
|
||||
scytheroverride(options.program)
|
||||
print "Using", options.program, "as Scyther executable."
|
||||
if options.extra != "":
|
||||
add_extra_parameters(options.extra)
|
||||
print "Added extra options, now:", get_extra_parameters()
|
||||
if options.nocache:
|
||||
# Do not use cache
|
||||
print "Warning: Disabling cache"
|
||||
cacheoverride ()
|
||||
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
@ -182,131 +182,131 @@ def process_default_options(options):
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
def all_unless_given(plist):
|
||||
if plist == []:
|
||||
# Get the list
|
||||
import protocollist
|
||||
return protocollist.from_all()
|
||||
else:
|
||||
return plist
|
||||
if plist == []:
|
||||
# Get the list
|
||||
import protocollist
|
||||
return protocollist.from_all()
|
||||
else:
|
||||
return plist
|
||||
|
||||
# Scan for compilation errors or stuff like that
|
||||
# Scan for compilation errors or stuff like that
|
||||
|
||||
def scan_for_results(options,args):
|
||||
# Select specific list
|
||||
plist = all_unless_given(args)
|
||||
# Now check all things in the list
|
||||
for p in plist:
|
||||
# Test and gather output
|
||||
(status,scout) = default_test([p], 0, 0)
|
||||
print scout
|
||||
# Select specific list
|
||||
plist = all_unless_given(args)
|
||||
# Now check all things in the list
|
||||
for p in plist:
|
||||
# Test and gather output
|
||||
(status,scout) = default_test([p], 0, 0)
|
||||
print scout
|
||||
|
||||
print
|
||||
print "Scan complete."
|
||||
print
|
||||
print "Scan complete."
|
||||
|
||||
def scan_for_errors(options,args):
|
||||
# Select specific list
|
||||
plist = all_unless_given(args)
|
||||
# Now check all things in the list
|
||||
errorcount = 0
|
||||
for p in plist:
|
||||
# Test and gather output
|
||||
(status,scout) = default_test([p], 0, 0)
|
||||
error = False
|
||||
if error_status(status):
|
||||
error = True
|
||||
else:
|
||||
if scout.rfind("ERROR") != -1:
|
||||
error = True
|
||||
if scout.rfind("error") != -1:
|
||||
error = True
|
||||
if error:
|
||||
print "There is an error in the output for", p
|
||||
errorcount = errorcount + 1
|
||||
# Select specific list
|
||||
plist = all_unless_given(args)
|
||||
# Now check all things in the list
|
||||
errorcount = 0
|
||||
for p in plist:
|
||||
# Test and gather output
|
||||
(status,scout) = default_test([p], 0, 0)
|
||||
error = False
|
||||
if error_status(status):
|
||||
error = True
|
||||
else:
|
||||
if scout.rfind("ERROR") != -1:
|
||||
error = True
|
||||
if scout.rfind("error") != -1:
|
||||
error = True
|
||||
if error:
|
||||
print "There is an error in the output for", p
|
||||
errorcount = errorcount + 1
|
||||
|
||||
if errorcount > 0:
|
||||
print
|
||||
print "Scan complete. Found", errorcount, "error(s) in", len(plist), "files."
|
||||
if errorcount > 0:
|
||||
print
|
||||
print "Scan complete. Found", errorcount, "error(s) in", len(plist), "files."
|
||||
|
||||
# Scan for timeout protocols
|
||||
# Scan for timeout protocols
|
||||
#
|
||||
# The idea is that some things will generate a timeout, and we would like
|
||||
# to know which ones. However, this can just be a problem of the time
|
||||
# limit, and might not be caused by a loop at all. Therefore, some
|
||||
# scanning is needed.
|
||||
# The idea is that some things will generate a timeout, and we would like
|
||||
# to know which ones. However, this can just be a problem of the time
|
||||
# limit, and might not be caused by a loop at all. Therefore, some
|
||||
# scanning is needed.
|
||||
|
||||
def scan_for_timeouts(options,args):
|
||||
|
||||
def parse_timeout(status,scout):
|
||||
if not error_status(status):
|
||||
if scout.rfind("time=") != -1:
|
||||
return True
|
||||
return False
|
||||
def parse_timeout(status,scout):
|
||||
if not error_status(status):
|
||||
if scout.rfind("time=") != -1:
|
||||
return True
|
||||
return False
|
||||
|
||||
def check_for_timeout(p):
|
||||
# First a simple test
|
||||
(status,scout) = default_test([p], 0, 1)
|
||||
if not parse_timeout(status,scout):
|
||||
# Well if there is no timeout here...
|
||||
return False
|
||||
def check_for_timeout(p):
|
||||
# First a simple test
|
||||
(status,scout) = default_test([p], 0, 1)
|
||||
if not parse_timeout(status,scout):
|
||||
# Well if there is no timeout here...
|
||||
return False
|
||||
|
||||
# More testing...
|
||||
# More testing...
|
||||
|
||||
return True
|
||||
return True
|
||||
|
||||
# Select specific list
|
||||
plist = all_unless_given(args)
|
||||
# Now check all things in the list
|
||||
errorcount = 0
|
||||
for p in plist:
|
||||
# Test and gather output
|
||||
if check_for_timeout(p):
|
||||
print "There is a timeout for", p
|
||||
errorcount = errorcount + 1
|
||||
# Select specific list
|
||||
plist = all_unless_given(args)
|
||||
# Now check all things in the list
|
||||
errorcount = 0
|
||||
for p in plist:
|
||||
# Test and gather output
|
||||
if check_for_timeout(p):
|
||||
print "There is a timeout for", p
|
||||
errorcount = errorcount + 1
|
||||
|
||||
if errorcount > 0:
|
||||
print
|
||||
print "Scan complete. Found", errorcount, "timeout(s) in", len(plist), "files."
|
||||
if errorcount > 0:
|
||||
print
|
||||
print "Scan complete. Found", errorcount, "timeout(s) in", len(plist), "files."
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
# Standalone usage
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
def main():
|
||||
parser = OptionParser()
|
||||
default_options(parser)
|
||||
parser.add_option("-e","--errors", dest="errors",
|
||||
default = False,
|
||||
action = "store_true",
|
||||
help = "detect compilation errors for all protocols [in list_all]")
|
||||
parser.add_option("-r","--results", dest="results",
|
||||
default = False,
|
||||
action = "store_true",
|
||||
help = "scan for results for all protocols [in list_all]")
|
||||
parser.add_option("-t","--timeouts", dest="timeouts",
|
||||
default = False,
|
||||
action = "store_true",
|
||||
help = "scan for timeout errors for all protocols [in list_all]")
|
||||
(options, args) = parser.parse_args()
|
||||
parser = OptionParser()
|
||||
default_options(parser)
|
||||
parser.add_option("-e","--errors", dest="errors",
|
||||
default = False,
|
||||
action = "store_true",
|
||||
help = "detect compilation errors for all protocols [in list_all]")
|
||||
parser.add_option("-r","--results", dest="results",
|
||||
default = False,
|
||||
action = "store_true",
|
||||
help = "scan for results for all protocols [in list_all]")
|
||||
parser.add_option("-t","--timeouts", dest="timeouts",
|
||||
default = False,
|
||||
action = "store_true",
|
||||
help = "scan for timeout errors for all protocols [in list_all]")
|
||||
(options, args) = parser.parse_args()
|
||||
|
||||
# Globals
|
||||
process_default_options(options)
|
||||
# Globals
|
||||
process_default_options(options)
|
||||
|
||||
# Subcases
|
||||
if options.errors:
|
||||
scan_for_errors(options,args)
|
||||
elif options.results:
|
||||
scan_for_results(options,args)
|
||||
elif options.timeouts:
|
||||
scan_for_timeouts(options,args)
|
||||
else:
|
||||
# Not any other switch: just test the list then
|
||||
if args == []:
|
||||
print "Scyther default test needs at least one input file."
|
||||
sys.exit()
|
||||
(status,scout) = default_test(args, options.match, options.bounds)
|
||||
print "Status:", status
|
||||
print scout
|
||||
# Subcases
|
||||
if options.errors:
|
||||
scan_for_errors(options,args)
|
||||
elif options.results:
|
||||
scan_for_results(options,args)
|
||||
elif options.timeouts:
|
||||
scan_for_timeouts(options,args)
|
||||
else:
|
||||
# Not any other switch: just test the list then
|
||||
if args == []:
|
||||
print "Scyther default test needs at least one input file."
|
||||
sys.exit()
|
||||
(status,scout) = default_test(args, options.match, options.bounds)
|
||||
print "Status:", status
|
||||
print scout
|
||||
|
||||
# Only if main stuff
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
main()
|
||||
|
||||
Loading…
Reference in New Issue
Block a user