def test_json(self):
test_file = get_test_data_path("update.cslang")
automaton, containerbuilder = cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("update.cslang")))
automaton, datawords, _ = cslang_main(
Namespace(
mode="run",
format="jsonrpc",
json_path=get_test_data_path("update.json"),
automaton_path=get_test_data_path("update.auto"),
))
assert "update" in containerbuilder.builders
assert "test" in containerbuilder.builders
container = datawords[0].container
assert container["type"] == "update"
assert container["members"][0]["type"] == "Numeric"
assert container["members"][0]["members"] == [1]
assert container["members"][1]["type"] == "Numeric"
assert container["members"][1]["members"][0] == 2
container2 = datawords[2].container
assert container2["type"] == "update"
assert container2["members"][0]["members"][0] == 999
assert container2["members"][1]["members"][0] == 888
assert automaton.is_accepting
assert automaton.current_state == 3
def test_csv(self):
test_file = get_test_data_path("csv.cslang")
automaton, containerbuilder = cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("csv.cslang")))
automaton, datawords, _ = cslang_main(
Namespace(
mode="run",
format="csv",
csv_path=get_test_data_path("write.csv"),
automaton_path=get_test_data_path("csv.auto"),
))
assert "write" in containerbuilder.builders
container = datawords[0].container
assert container["type"] == "write"
assert container["members"][0]["type"] == "String"
assert container["members"][0]["members"][0] == "fd=999"
assert container["members"][1]["type"] == "String"
assert container["members"][1]["members"][0] == "data=what's up world"
assert automaton.is_accepting
assert automaton.current_state == 1
def test_NOT_variant(self):
automaton_path = get_test_data_path("variantreadnot.auto")
syscall_definitions = get_test_data_path("syscall_definitions.pickle")
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("variantreadnot.cslang")))
automaton_read, datawords_after_read, s2d_read = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("variantread.strace"),
syscall_definitions=syscall_definitions,
automaton_path=automaton_path,
))
automaton_recv, datawords_after_recv, s2d_recv = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("variantrecv.strace"),
syscall_definitions=syscall_definitions,
automaton_path=automaton_path,
))
# Make sure the automata have the correct number of states
assert len(automaton_read.states) == 3
assert len(automaton_recv.states) == 3
# Make sure the automata both end in the correct state (having accepted read/recv correctly)
assert not automaton_read.states[
automaton_read.current_state].is_accepting
assert not automaton_recv.states[
automaton_recv.current_state].is_accepting
def test_subtract(self):
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("registersub.cslang")))
automaton, datawords_after, _ = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("registersub.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"),
automaton_path=get_test_data_path("registersub.auto"),
))
assert automaton.registers["numnum"] == 1
assert automaton.registers["regnum"] == 1
assert automaton.registers["numreg"] == 1
assert automaton.registers["regreg"] == 0
assert automaton.registers["fnumnum"] == 0
assert automaton.registers["fregnum"] == 0
assert automaton.registers["fnumreg"] == 0
assert automaton.registers["fregreg"] == 0
assert automaton.registers["nnumnum"] == 0
assert automaton.registers["nregnum"] == 0
assert automaton.registers["nnumreg"] == 0
assert automaton.registers["nregreg"] == 0
def test_divide(self):
test_file = get_test_data_path("registerdiv.cslang")
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("registerdiv.cslang")))
automaton, datawords_after, _ = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("registerdiv.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"),
automaton_path=get_test_data_path("registerdiv.auto"),
))
assert automaton.registers["numnum"] == 3
assert automaton.registers["regnum"] == 1
assert automaton.registers["numreg"] == 1
assert automaton.registers["regreg"] == 1
assert automaton.registers["fnumnum"] == 3.5
assert automaton.registers["fregnum"] == 1.75
assert automaton.registers["fnumreg"] == 3.125
assert automaton.registers["fregreg"] == 1
assert automaton.registers["nnumnum"] == -5
assert automaton.registers["nregnum"] == -0.2
assert automaton.registers["nnumreg"] == -5
assert automaton.registers["nregreg"] == 5
def test_define(self):
test_file = get_test_data_path("define.cslang")
automaton, containerbuilder = cslang_main(
Namespace(mode="build", cslang_path=get_test_data_path("define.cslang"))
)
automaton, datawords, _ = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("define.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"
),
automaton_path=get_test_data_path("define.auto"),
)
)
assert "fstat" in containerbuilder.builders
assert "statbuf" in containerbuilder.builders
container = datawords[0].container
assert container["type"] == "fstat"
assert container["members"][0]["type"] == "Numeric"
assert container["members"][0]["members"] == [3]
assert container["members"][1]["type"] == "statbuf"
assert container["members"][1]["members"][0]["type"] == "String"
assert "makedev(0, 4)" in container["members"][1]["members"][0]["members"][0]
assert container["members"][1]["members"][1]["type"] == "String"
assert "402" in container["members"][1]["members"][1]["members"][0]
def test_definedup(self):
with self.assertRaises(CSlangError) as cm:
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("define_dup.cslang")))
assert "Illegal type redefinition" in str(cm.exception)
def test_badadd(self):
with self.assertRaises(CSlangError) as cm:
cslang_main(
Namespace(
mode="build",
cslang_path=get_test_data_path("register_badadd.cslang"),
))
assert "Type mismatch between registers" in str(cm.exception)
def test_ret(self):
with self.assertRaises(CSlangError) as cm:
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("ret.cslang")))
assert "A structure does not have return value position" in str(
cm.exception)
def test_definenonexistant(self):
with self.assertRaises(CSlangError) as cm:
cslang_main(
Namespace(
mode="build",
cslang_path=get_test_data_path("define_nonexistant.cslang"),
)
)
assert "definition contains undefined type" in str(cm.exception)
def test_skip(self):
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("open.cslang")))
automaton, datawords_after, _ = cslang_main(
Namespace(
mode="run",
format="strace",
skip=2,
strace_path=get_test_data_path("openclose.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"),
automaton_path=get_test_data_path("open.auto"),
))
assert len(datawords_after) == 1
def test_empty_dataword(self):
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("emptydataword.cslang")))
automaton, datawords_after, _ = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("emptydataword.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"),
automaton_path=get_test_data_path("emptydataword.auto"),
containerbuilder_path=get_test_data_path("emptydataword.cb"),
))
assert len(automaton.states) == 2
def test_stat_blk(self):
automaton, cb = cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("stat_blk.cslang")))
automaton, datawords_after, _ = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("stat_blk.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"),
automaton_path=get_test_data_path("stat_blk.auto"),
))
assert automaton
assert len(automaton.states) == 2
assert automaton.states[1].name == "stat"
def test_assign(self):
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("registerassign.cslang")))
automaton, datawords_after, _ = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("registerassign.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"),
automaton_path=get_test_data_path("registerassign.auto"),
))
assert automaton.registers["assignstr"] == "hel"
assert automaton.registers["assignnum"] == 5
assert automaton.registers["assignidn"] == 4
assert automaton.registers["assignids"] == "worked"
def test_concat(self):
test_file = get_test_data_path("registerconcat.cslang")
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("registerconcat.cslang")))
automaton, datawords_after, _ = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("registerconcat.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"),
automaton_path=get_test_data_path("registerconcat.auto"),
))
assert automaton.registers["numnum"] == "hello"
assert automaton.registers["regnum"] == "hello"
assert automaton.registers["numreg"] == "lohel"
assert automaton.registers["regreg"] == "helhel"
def test_checkfdtrue(self):
syscall_definitions = get_test_data_path(
"../cslang/syscall_definitions.pickle")
automaton_path = get_test_data_path("predicates.auto")
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("predicates.cslang")))
automaton, datawords_after, s2d = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("predicates.strace"),
syscall_definitions=syscall_definitions,
automaton_path=automaton_path,
))
assert automaton.current_state == 4
assert not automaton.is_accepting()
assert "foo, bar" in s2d.get_mutated_strace(datawords_after[2])
def test_open_fail_pred(self):
cslang_main(
Namespace(
mode="build",
format="strace",
cslang_path=get_test_data_path("open_fail_name.cslang"),
))
automaton, datawords_after, _ = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("open_fail_name.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"),
automaton_path=get_test_data_path("open_fail_name.auto"),
))
assert automaton.is_accepting
def test_variant_with_predicates(self):
automaton_path = get_test_data_path("variantreadpred.auto")
syscall_definitions = get_test_data_path("syscall_definitions.pickle")
cslang_main(
Namespace(
mode="build",
cslang_path=get_test_data_path("variantreadpred.cslang")))
automaton_read, datawords_after_read, s2d_read = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("variantread.strace"),
syscall_definitions=syscall_definitions,
automaton_path=automaton_path,
))
automaton_recv, datawords_after_recv, s2d_recv = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("variantrecv.strace"),
syscall_definitions=syscall_definitions,
automaton_path=automaton_path,
))
# Make sure the automata have the correct number of states
assert len(automaton_read.states) == 3
assert len(automaton_recv.states) == 3
# Make sure the automata both end in the correct state (having accepted read/recv correctly)
assert automaton_read.states[automaton_read.current_state].is_accepting
assert automaton_recv.states[automaton_recv.current_state].is_accepting
# Check register values are stored correctly
assert automaton_read.registers["name"] == "test.txt"
assert automaton_read.registers["fd"] == 3
assert automaton_recv.registers["name"] == "test.txt"
assert automaton_recv.registers["fd"] == 3
def test_exception_on_both_c_and_s(self):
with self.assertRaises(CSlangError) as cm:
ast = cslang_main(
Namespace(
mode="parse",
cslang_file="test/bad.cslang",
check=True,
string="""
type read {filedesc: Numeric@0};
bad <- 4;
NOT read({}) -> read({filedesc: ->bad});
""",
))
def test_no_output_on_not_datawords(self):
with self.assertRaises(CSlangError) as cm:
ast = cslang_main(
Namespace(
mode="parse",
check=True,
string="""
event read {filedesc: Numeric@0};
bad <- 4;
NOT read({}) -> read({filedesc: ->bad});
""",
)
)
def test_openclose(self):
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("openclose.cslang")))
automaton, datawords_after, _ = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("openclose.strace"),
syscall_definitions=get_test_data_path(
"../cslang/syscall_definitions.pickle"),
automaton_path=get_test_data_path("openclose.auto"),
containerbuilder_path=get_test_data_path("openclose.cb"),
))
assert datawords_after[0].is_interesting()
assert not datawords_after[1].is_interesting()
assert automaton.current_state == 3
assert automaton.is_accepting()
assert automaton.registers["fd"] == 3
assert automaton.registers["fn"] == "test.txt"
assert automaton.registers["retval"] == "-1"
def test_outputs(self):
syscall_definitions = get_test_data_path(
"../cslang/syscall_definitions.pickle")
automaton_path = get_test_data_path("outputs.auto")
cslang_main(
Namespace(mode="build",
cslang_path=get_test_data_path("outputs.cslang")))
automaton, datawords_after, s2d = cslang_main(
Namespace(
mode="run",
format="strace",
strace_path=get_test_data_path("outputs.strace"),
syscall_definitions=syscall_definitions,
automaton_path=automaton_path,
))
assert automaton.current_state == 4
assert "(10.0, " in s2d.get_mutated_strace(datawords_after[0])
assert "(15.0, " in s2d.get_mutated_strace(datawords_after[1])
assert "foo" in s2d.get_mutated_strace(datawords_after[2])
assert "bar" in s2d.get_mutated_strace(datawords_after[2])
assert "foo" not in s2d.get_mutated_strace(datawords_after[3])
assert "bar" not in s2d.get_mutated_strace(datawords_after[3])
def test_single_variant(self):
ast = cslang_main(
Namespace(
mode="parse",
check=True,
cslang_path=None,
string="""
type otherread {read filedesc: Numeric@0};
""",
))
assert ast[0][0] == "VARIANTDEF"
assert ast[0][1] == "otherread"
assert ast[0][2][0][0] == "read"
assert ast[0][2][0][1][0][0] == "Numeric"
assert ast[0][2][0][1][0][1] == "0"
assert ast[0][2][0][1][0][2] == "filedesc"
