本文整理汇总了Python中triton.TritonContext.getAstContext方法的典型用法代码示例。如果您正苦于以下问题:Python TritonContext.getAstContext方法的具体用法?Python TritonContext.getAstContext怎么用?Python TritonContext.getAstContext使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类triton.TritonContext
的用法示例。
在下文中一共展示了TritonContext.getAstContext方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: TestAstDictionaries
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
class TestAstDictionaries(unittest.TestCase):
"""Testing the AST_DICTIONARIES."""
def setUp(self):
"""Define the arch."""
self.Triton = TritonContext()
self.Triton.setArchitecture(ARCH.X86_64)
self.Triton.enableMode(MODE.AST_DICTIONARIES, True)
self.astCtxt = self.Triton.getAstContext()
def test_dictionaries(self):
# d is empty
d = self.Triton.getAstDictionariesStats()
for k, v in d.items():
self.assertEqual(v, 0)
bv1 = self.astCtxt.bv(1, 8)
bv2 = self.astCtxt.bv(2, 8)
d = self.Triton.getAstDictionariesStats()
self.assertEqual(d['bv'], 2)
self.assertEqual(d['decimal'], 3)
self.assertEqual(d['allocatedDictionaries'], 5)
self.assertEqual(d['allocatedNodes'], 6)
# Same allocation
bv1 = self.astCtxt.bv(1, 8)
bv2 = self.astCtxt.bv(2, 8)
d = self.Triton.getAstDictionariesStats()
self.assertEqual(d['bv'], 2)
self.assertEqual(d['decimal'], 3)
self.assertEqual(d['allocatedDictionaries'], 5)
self.assertEqual(d['allocatedNodes'], 12)
示例2: TestPathConstraint
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
class TestPathConstraint(unittest.TestCase):
"""Testing path constraint."""
def setUp(self):
"""Define the arch."""
self.ctx = TritonContext()
self.ctx.setArchitecture(ARCH.X86)
trace = [
"\x25\xff\xff\xff\x3f", # and eax, 0x3fffffff
"\x81\xe3\xff\xff\xff\x3f", # and ebx, 0x3fffffff
"\x31\xd1", # xor ecx, edx
"\x31\xfa", # xor edx, edi
"\x31\xD8", # xor eax, ebx
"\x0F\x84\x55\x00\x00\x00", # je 0x55
]
self.ctx.convertRegisterToSymbolicVariable(self.ctx.registers.eax)
self.ctx.convertRegisterToSymbolicVariable(self.ctx.registers.ebx)
for opcodes in trace:
self.ctx.processing(Instruction(opcodes))
def test_getPathConstraintsAst(self):
"""Test getPathConstraintsAst"""
astCtx = self.ctx.getAstContext()
crst = self.ctx.getPathConstraintsAst()
self.assertNotEqual(len(self.ctx.getModel(crst)), 0)
self.assertNotEqual(len(self.ctx.getModel(astCtx.lnot(crst))), 0)
def test_getPathConstraints(self):
"""Test getPathConstraints"""
pco = self.ctx.getPathConstraints()
self.assertEqual(len(pco), 1)
def test_isMultipleBranches(self):
pc = self.ctx.getPathConstraints()[0]
self.assertTrue(pc.isMultipleBranches())
def test_getTakenPathConstraintAst(self):
pc = self.ctx.getPathConstraints()[0]
self.assertEqual(pc.getTakenPathConstraintAst().evaluate(), 1)
def test_getTakenAddress(self):
pc = self.ctx.getPathConstraints()[0]
self.assertEqual(pc.getTakenAddress(), 91)
def test_getBranchConstraints(self):
pc = self.ctx.getPathConstraints()[0].getBranchConstraints()
self.assertTrue(pc[0]['isTaken'])
self.assertFalse(pc[1]['isTaken'])
self.assertEqual(pc[0]['srcAddr'], pc[1]['srcAddr'])
self.assertEqual(pc[0]['dstAddr'], 91)
self.assertEqual(pc[1]['dstAddr'], 23)
示例3: test4
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
def test4():
Triton = TritonContext()
Triton.setArchitecture(ARCH.X86)
astCtxt = Triton.getAstContext()
x = Triton.newSymbolicVariable(8)
c = astCtxt.variable(x) * astCtxt.variable(x) - 1 == 0x20
print 'Test 4:', Triton.getModels(c, 10)
return
示例4: test2
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
def test2():
Triton = TritonContext()
Triton.setArchitecture(ARCH.X86)
astCtxt = Triton.getAstContext()
x = Triton.newSymbolicVariable(32)
c = ((astCtxt.variable(x) ^ 0x40) - 1 == 0x10)
print 'Test 2:', Triton.getModel(c)[0]
return
示例5: test3
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
def test3():
Triton = TritonContext()
Triton.setArchitecture(ARCH.X86)
astCtxt = Triton.getAstContext()
x = Triton.newSymbolicVariable(8)
c = astCtxt.land([
astCtxt.variable(x) * astCtxt.variable(x) - 1 == 0x20,
astCtxt.variable(x) != 0x11
])
print 'Test 3:', Triton.getModel(c)[0]
return
示例6: test1
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
def test1():
Triton = TritonContext()
Triton.setArchitecture(ARCH.X86)
astCtxt = Triton.getAstContext()
x = Triton.newSymbolicVariable(32)
c = astCtxt.equal(
astCtxt.bvsub(
astCtxt.bvxor(
astCtxt.variable(x),
astCtxt.bv(0x40, 32)
),
astCtxt.bv(1, 32)
),
astCtxt.bv(0x10, 32)
)
print 'Test 1:', Triton.getModel(c)[0]
return
示例7: test5
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
def test5():
Triton = TritonContext()
Triton.setArchitecture(ARCH.X86)
astCtxt = Triton.getAstContext()
# rax is now symbolic
Triton.convertRegisterToSymbolicVariable(Triton.registers.eax)
# process instruction
Triton.processing(Instruction("\x83\xc0\x07")) # add eax, 0x7
# get rax ast
eaxAst = Triton.getAstFromId(Triton.getSymbolicRegisterId(Triton.registers.eax))
# constraint
c = eaxAst ^ 0x11223344 == 0xdeadbeaf
print 'Test 5:', Triton.getModel(c)[0]
return
示例8: TestSymbolicBuilding
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
class TestSymbolicBuilding(unittest.TestCase):
"""Testing symbolic building."""
def setUp(self):
"""Define the arch."""
self.Triton = TritonContext()
self.Triton.setArchitecture(ARCH.X86_64)
self.astCtxt = self.Triton.getAstContext()
def test_build_immediate(self):
"""Check symbolic immediate has correct size and evaluation."""
node = self.Triton.buildSymbolicImmediate(Immediate(0x10, CPUSIZE.BYTE))
self.assertEqual(node.evaluate(), 0x10)
self.assertEqual(node.getBitvectorSize(), CPUSIZE.BYTE_BIT)
def test_build_register(self):
"""Check symbolic register has correct size and location."""
expr1 = self.Triton.newSymbolicExpression(self.astCtxt.bv(0x1122334455667788, CPUSIZE.QWORD_BIT))
self.Triton.assignSymbolicExpressionToRegister(expr1, self.Triton.registers.rax)
node = self.Triton.buildSymbolicRegister(self.Triton.registers.rax)
self.assertEqual(node.evaluate(), 0x1122334455667788)
self.assertEqual(node.getBitvectorSize(), CPUSIZE.QWORD_BIT)
node = self.Triton.buildSymbolicRegister(self.Triton.registers.eax)
self.assertEqual(node.evaluate(), 0x55667788)
self.assertEqual(node.getBitvectorSize(), CPUSIZE.DWORD_BIT)
node = self.Triton.buildSymbolicRegister(self.Triton.registers.ax)
self.assertEqual(node.evaluate(), 0x7788)
self.assertEqual(node.getBitvectorSize(), CPUSIZE.WORD_BIT)
node = self.Triton.buildSymbolicRegister(self.Triton.registers.ah)
self.assertEqual(node.evaluate(), 0x77)
self.assertEqual(node.getBitvectorSize(), CPUSIZE.BYTE_BIT)
node = self.Triton.buildSymbolicRegister(self.Triton.registers.al)
self.assertEqual(node.evaluate(), 0x88)
self.assertEqual(node.getBitvectorSize(), CPUSIZE.BYTE_BIT)
示例9: TestAstReference
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
class TestAstReference(unittest.TestCase):
"""Testing the AST reference."""
def setUp(self):
"""Define the arch."""
self.Triton = TritonContext()
self.Triton.setArchitecture(ARCH.X86_64)
self.astCtxt = self.Triton.getAstContext()
def test_ssa_ref(self):
v0 = self.astCtxt.variable(self.Triton.newSymbolicVariable(8))
v1 = self.astCtxt.variable(self.Triton.newSymbolicVariable(8))
exp0 = self.Triton.newSymbolicExpression(v0, "exp v1")
exp1 = self.Triton.newSymbolicExpression(v1, "exp v2")
ref0 = self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(0))
ref1 = self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(1))
ref2 = self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(0)) + 2
ref3 = self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(0)) + self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(1))
self.assertEqual(str(ref0), "ref!0")
self.assertEqual(str(ref1), "ref!1")
self.assertEqual(str(ref2), "(bvadd ref!0 (_ bv2 8))")
self.assertEqual(str(ref3), "(bvadd ref!0 ref!1)")
def test_unroll_ssa_ref(self):
v0 = self.astCtxt.variable(self.Triton.newSymbolicVariable(8))
v1 = self.astCtxt.variable(self.Triton.newSymbolicVariable(8))
exp0 = self.Triton.newSymbolicExpression(v0, "exp v1")
exp1 = self.Triton.newSymbolicExpression(v1, "exp v2")
ref0 = self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(0))
ref1 = self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(1))
ref2 = self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(0)) + 2
ref3 = self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(0)) + self.astCtxt.reference(self.Triton.getSymbolicExpressionFromId(1))
self.assertEqual(str(self.Triton.unrollAst(ref0)), "SymVar_0")
self.assertEqual(str(self.Triton.unrollAst(ref1)), "SymVar_1")
self.assertEqual(str(self.Triton.unrollAst(ref2)), "(bvadd SymVar_0 (_ bv2 8))")
self.assertEqual(str(self.Triton.unrollAst(ref3)), "(bvadd SymVar_0 SymVar_1)")
示例10:
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
if c1_not.equalTo(~c2_nonNot) and c2_not.equalTo(~c1_nonNot):
return c1_nonNot ^ c2_nonNot
return node
if __name__ == "__main__":
# Set arch to init engines
Triton.setArchitecture(ARCH.X86_64)
# Record simplifications
Triton.addCallback(xor_1, CALLBACK.SYMBOLIC_SIMPLIFICATION)
Triton.addCallback(xor_2, CALLBACK.SYMBOLIC_SIMPLIFICATION)
astCtxt = Triton.getAstContext()
a = astCtxt.bv(1, 8)
b = astCtxt.bv(2, 8)
# Example 1
c = a ^ a
print 'Expr: ', c
c = Triton.simplify(c)
print 'Simp: ', c
print
# Example 2 - forme A
c = (a & ~b) | (~a & b)
print 'Expr: ', c
示例11: TestAstConversion
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
class TestAstConversion(unittest.TestCase):
"""Testing the AST conversion Triton <-> z3."""
def setUp(self):
"""Define the arch."""
self.Triton = TritonContext()
self.Triton.setArchitecture(ARCH.X86_64)
self.astCtxt = self.Triton.getAstContext()
self.sv1 = self.Triton.newSymbolicVariable(8)
self.sv2 = self.Triton.newSymbolicVariable(8)
self.v1 = self.astCtxt.variable(self.sv1)
self.v2 = self.astCtxt.variable(self.sv2)
def test_binop(self):
"""
Check python binary operation.
Fuzz int8/uint8 binop values and check triton/z3 and python results.
"""
# No simplification available
# This only going to test Triton <-> z3 AST conversions.
binop = [
# Overloaded operators
operator.and_,
operator.add,
operator.sub,
operator.xor,
operator.or_,
operator.mul,
operator.lshift,
operator.rshift,
operator.eq,
operator.ne,
operator.le,
operator.ge,
operator.lt,
operator.gt,
operator.div,
operator.mod,
]
for _ in xrange(100):
cv1 = random.randint(0, 255)
cv2 = random.randint(0, 255)
self.Triton.setConcreteVariableValue(self.sv1, cv1)
self.Triton.setConcreteVariableValue(self.sv2, cv2)
for op in binop:
n = op(self.v1, self.v2)
if op == operator.div and cv2 == 0:
ref = 255
elif op == operator.mod and cv2 == 0:
ref = cv1
else:
ref = op(cv1, cv2) % (2 ** 8)
self.assertEqual(ref, n.evaluate(),
"ref = {} and triton value = {} with operator {}"
" operands were {} and {}".format(ref,
n.evaluate(),
op,
cv1,
cv2))
self.assertEqual(ref, self.Triton.evaluateAstViaZ3(n))
self.assertEqual(ref, self.Triton.simplify(n, True).evaluate())
def test_unop(self):
"""
Check python unary operation.
Fuzz int8/uint8 binop values and check triton/z3 and python results.
"""
# No simplification available
# This only going to test Triton <-> z3 AST conversions.
unop = [
operator.invert,
operator.neg,
]
for cv1 in xrange(0, 256):
self.Triton.setConcreteVariableValue(self.sv1, cv1)
for op in unop:
n = op(self.v1)
ref = op(cv1) % (2 ** 8)
self.assertEqual(ref, n.evaluate(),
"ref = {} and triton value = {} with operator "
"{} operands was {}".format(ref,
n.evaluate(),
op,
cv1))
self.assertEqual(ref, self.Triton.evaluateAstViaZ3(n))
self.assertEqual(ref, self.Triton.simplify(n, True).evaluate())
def test_smtbinop(self):
"""
Check smt binary operation.
Fuzz int8/uint8 binop values and check triton/z3 and python results.
#.........这里部分代码省略.........
示例12: TestAstSimplification
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
class TestAstSimplification(unittest.TestCase):
"""Testing AST simplification."""
def setUp(self):
self.Triton = TritonContext()
self.Triton.setArchitecture(ARCH.X86_64)
self.Triton.addCallback(self.xor_1, CALLBACK.SYMBOLIC_SIMPLIFICATION)
self.Triton.addCallback(self.xor_2, CALLBACK.SYMBOLIC_SIMPLIFICATION)
self.astCtxt = self.Triton.getAstContext()
def test_simplification(self):
a = self.astCtxt.bv(1, 8)
b = self.astCtxt.bv(2, 8)
# Example 1
c = a ^ a
c = self.Triton.simplify(c)
self.assertEqual(str(c), "(_ bv0 8)")
c = a ^ b
c = self.Triton.simplify(c)
self.assertEqual(str(c), "(bvxor (_ bv1 8) (_ bv2 8))")
c = (a & ~b) | (~a & b)
c = self.Triton.simplify(c)
self.assertEqual(str(c), "(bvxor (_ bv1 8) (_ bv2 8))")
# Example 2 - forme B
c = (~b & a) | (~a & b)
c = self.Triton.simplify(c)
self.assertEqual(str(c), "(bvxor (_ bv1 8) (_ bv2 8))")
# Example 2 - forme C
c = (~b & a) | (b & ~a)
c = self.Triton.simplify(c)
self.assertEqual(str(c), "(bvxor (_ bv1 8) (_ bv2 8))")
# Example 2 - forme D
c = (b & ~a) | (~b & a)
c = self.Triton.simplify(c)
self.assertEqual(str(c), "(bvxor (_ bv2 8) (_ bv1 8))")
return
# a ^ a -> a = 0
@staticmethod
def xor_1(api, node):
if node.getKind() == AST_NODE.BVXOR:
if node.getChildren()[0].equalTo(node.getChildren()[1]):
return api.getAstContext().bv(0, node.getBitvectorSize())
return node
# ((a & ~b) | (~a & b)) -> (a ^ b)
@staticmethod
def xor_2(api, node):
def getNot(node):
a = node.getChildren()[0]
b = node.getChildren()[1]
if a.getKind() == AST_NODE.BVNOT and b.getKind() != AST_NODE.BVNOT:
return a
if b.getKind() == AST_NODE.BVNOT and a.getKind() != AST_NODE.BVNOT:
return b
return None
def getNonNot(node):
a = node.getChildren()[0]
b = node.getChildren()[1]
if a.getKind() != AST_NODE.BVNOT and b.getKind() == AST_NODE.BVNOT:
return a
if b.getKind() != AST_NODE.BVNOT and a.getKind() == AST_NODE.BVNOT:
return b
return None
if node.getKind() == AST_NODE.BVOR:
c1 = node.getChildren()[0]
c2 = node.getChildren()[1]
if c1.getKind() == AST_NODE.BVAND and c2.getKind() == AST_NODE.BVAND:
c1_not = getNot(c1)
c2_not = getNot(c2)
c1_nonNot = getNonNot(c1)
c2_nonNot = getNonNot(c2)
if c1_not.equalTo(~c2_nonNot) and c2_not.equalTo(~c1_nonNot):
return c1_nonNot ^ c2_nonNot
return node
示例13: TestAstDuplication
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
class TestAstDuplication(unittest.TestCase):
"""Testing the AST duplication."""
def setUp(self):
"""Define the arch."""
self.Triton = TritonContext()
self.Triton.setArchitecture(ARCH.X86_64)
self.astCtxt = self.Triton.getAstContext()
self.v1 = self.astCtxt.variable(self.Triton.newSymbolicVariable(8))
self.v2 = self.astCtxt.variable(self.Triton.newSymbolicVariable(8))
self.ref = self.Triton.newSymbolicExpression(self.v1 + self.v2, "ref test")
self.node = [
# Overloaded operators
(self.v1 & self.v2),
(self.v1 + self.v2),
(self.v1 - self.v2),
(self.v1 ^ self.v2),
(self.v1 | self.v2),
(self.v1 * self.v2),
(self.v1 / self.v2),
(self.v1 % self.v2),
(self.v1 << self.v2),
(self.v1 >> self.v2),
(~self.v1),
(-self.v1),
(self.v1 == self.v2),
(self.v1 != self.v2),
(self.v1 <= self.v2),
(self.v1 >= self.v2),
(self.v1 < self.v2),
(self.v1 > self.v2),
# AST api
self.astCtxt.bv(2, 8),
self.astCtxt.bvashr(self.v1, self.v2),
self.astCtxt.bvfalse(),
self.astCtxt.bvnand(self.v1, self.v2),
self.astCtxt.bvnor(self.v1, self.v2),
self.astCtxt.bvrol(3, self.v1),
self.astCtxt.bvror(2, self.v2),
self.astCtxt.bvsdiv(self.v1, self.v2),
self.astCtxt.bvsge(self.v1, self.v2),
self.astCtxt.bvsgt(self.v1, self.v2),
self.astCtxt.bvsle(self.v1, self.v2),
self.astCtxt.bvslt(self.v1, self.v2),
self.astCtxt.bvsmod(self.v1, self.v2),
self.astCtxt.bvtrue(),
self.astCtxt.bvurem(self.v1, self.v2),
self.astCtxt.bvxnor(self.v1, self.v2),
self.astCtxt.concat([self.v1, self.v2]),
self.astCtxt.distinct(self.v1, self.v2),
self.astCtxt.equal(self.v1, self.v2),
self.astCtxt.extract(4, 2, self.v1),
self.astCtxt.extract(7, 0, self.v1),
self.astCtxt.ite(self.v1 == 2, self.v1, self.v2),
self.astCtxt.land([self.v1 == 1, self.v2 == 2]),
self.astCtxt.let("alias", self.v1, self.v2),
self.astCtxt.lnot(self.v1 == 0),
self.astCtxt.lor([self.v1 >= 0, self.v2 <= 10]),
self.astCtxt.reference(self.ref),
self.astCtxt.string("test"),
self.astCtxt.sx(8, self.v1),
self.astCtxt.zx(8, self.v1),
]
def test_duplication(self):
for n in self.node:
self.assertEqual(n.getHash(), self.astCtxt.duplicate(n).getHash())
示例14: TestAstRepresentation
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
class TestAstRepresentation(unittest.TestCase):
"""Testing the AST Representation."""
def setUp(self):
"""Define the arch."""
self.Triton = TritonContext()
self.Triton.setArchitecture(ARCH.X86_64)
self.astCtxt = self.Triton.getAstContext()
self.v1 = self.astCtxt.variable(self.Triton.newSymbolicVariable(8))
self.v2 = self.astCtxt.variable(self.Triton.newSymbolicVariable(8))
self.ref = self.Triton.newSymbolicExpression(self.v1 + self.v2, "ref test")
# Default
self.assertEqual(self.Triton.getAstRepresentationMode(), AST_REPRESENTATION.SMT)
self.node = [
# Overloaded operators # SMT # Python
((self.v1 & self.v2), "(bvand SymVar_0 SymVar_1)", "(SymVar_0 & SymVar_1)"),
((self.v1 + self.v2), "(bvadd SymVar_0 SymVar_1)", "((SymVar_0 + SymVar_1) & 0xFF)"),
((self.v1 - self.v2), "(bvsub SymVar_0 SymVar_1)", "((SymVar_0 - SymVar_1) & 0xFF)"),
((self.v1 ^ self.v2), "(bvxor SymVar_0 SymVar_1)", "(SymVar_0 ^ SymVar_1)"),
((self.v1 | self.v2), "(bvor SymVar_0 SymVar_1)", "(SymVar_0 | SymVar_1)"),
((self.v1 * self.v2), "(bvmul SymVar_0 SymVar_1)", "((SymVar_0 * SymVar_1) & 0xFF)"),
((self.v1 / self.v2), "(bvudiv SymVar_0 SymVar_1)", "(SymVar_0 / SymVar_1)"),
((self.v1 % self.v2), "(bvurem SymVar_0 SymVar_1)", "(SymVar_0 % SymVar_1)"),
((self.v1 << self.v2), "(bvshl SymVar_0 SymVar_1)", "((SymVar_0 << SymVar_1) & 0xFF)"),
((self.v1 >> self.v2), "(bvlshr SymVar_0 SymVar_1)", "(SymVar_0 >> SymVar_1)"),
((~self.v1), "(bvnot SymVar_0)", "(~(SymVar_0) & 0xFF)"),
((-self.v1), "(bvneg SymVar_0)", "-SymVar_0"),
((self.v1 == self.v2), "(= SymVar_0 SymVar_1)", "(SymVar_0 == SymVar_1)"),
((self.v1 != self.v2), "(not (= SymVar_0 SymVar_1))", "not (SymVar_0 == SymVar_1)"),
((self.v1 <= self.v2), "(bvule SymVar_0 SymVar_1)", "(SymVar_0 <= SymVar_1)"),
((self.v1 >= self.v2), "(bvuge SymVar_0 SymVar_1)", "(SymVar_0 >= SymVar_1)"),
((self.v1 < self.v2), "(bvult SymVar_0 SymVar_1)", "(SymVar_0 < SymVar_1)"),
((self.v1 > self.v2), "(bvugt SymVar_0 SymVar_1)", "(SymVar_0 > SymVar_1)"),
# AST api # SMT # Python
(self.astCtxt.assert_(self.v1 == 0), "(assert (= SymVar_0 (_ bv0 8)))", "assert_((SymVar_0 == 0x0))"),
(self.astCtxt.bv(2, 8), "(_ bv2 8)", "0x2"),
(self.astCtxt.bvashr(self.v1, self.v2), "(bvashr SymVar_0 SymVar_1)", "(SymVar_0 >> SymVar_1)"),
(self.astCtxt.bvfalse(), "(_ bv0 1)", "0x0"),
(self.astCtxt.bvnand(self.v1, self.v2), "(bvnand SymVar_0 SymVar_1)", "(~(SymVar_0 & SymVar_1) & 0xFF)"),
(self.astCtxt.bvnor(self.v1, self.v2), "(bvnor SymVar_0 SymVar_1)", "(~(SymVar_0 | SymVar_1) & 0xFF)"),
(self.astCtxt.bvrol(3, self.v1), "((_ rotate_left 3) SymVar_0)", "rol(0x3, SymVar_0)"),
(self.astCtxt.bvror(2, self.v2), "((_ rotate_right 2) SymVar_1)", "ror(0x2, SymVar_1)"),
(self.astCtxt.bvsdiv(self.v1, self.v2), "(bvsdiv SymVar_0 SymVar_1)", "(SymVar_0 / SymVar_1)"),
(self.astCtxt.bvsge(self.v1, self.v2), "(bvsge SymVar_0 SymVar_1)", "(SymVar_0 >= SymVar_1)"),
(self.astCtxt.bvsgt(self.v1, self.v2), "(bvsgt SymVar_0 SymVar_1)", "(SymVar_0 > SymVar_1)"),
(self.astCtxt.bvsle(self.v1, self.v2), "(bvsle SymVar_0 SymVar_1)", "(SymVar_0 <= SymVar_1)"),
(self.astCtxt.bvslt(self.v1, self.v2), "(bvslt SymVar_0 SymVar_1)", "(SymVar_0 < SymVar_1)"),
(self.astCtxt.bvsmod(self.v1, self.v2), "(bvsmod SymVar_0 SymVar_1)", "(SymVar_0 % SymVar_1)"),
(self.astCtxt.bvsrem(self.v1, self.v2), "(bvsrem SymVar_0 SymVar_1)", "(SymVar_0 % SymVar_1)"),
(self.astCtxt.bvtrue(), "(_ bv1 1)", "0x1"),
(self.astCtxt.bvurem(self.v1, self.v2), "(bvurem SymVar_0 SymVar_1)", "(SymVar_0 % SymVar_1)"),
(self.astCtxt.bvxnor(self.v1, self.v2), "(bvxnor SymVar_0 SymVar_1)", "(~(SymVar_0 ^ SymVar_1) & 0xFF)"),
(self.astCtxt.compound([self.v1, self.v2]), "SymVar_0\nSymVar_1", "SymVar_0\nSymVar_1"),
(self.astCtxt.concat([self.v1, self.v2]), "(concat SymVar_0 SymVar_1)", "((SymVar_0) << 8 | SymVar_1)"),
(self.astCtxt.declare(self.v1), "(declare-fun SymVar_0 () (_ BitVec 8))", "SymVar_0 = 0xdeadbeef"),
(self.astCtxt.distinct(self.v1, self.v2), "(distinct SymVar_0 SymVar_1)", "(SymVar_0 != SymVar_1)"),
(self.astCtxt.equal(self.v1, self.v2), "(= SymVar_0 SymVar_1)", "(SymVar_0 == SymVar_1)"),
(self.astCtxt.extract(4, 2, self.v1), "((_ extract 4 2) SymVar_0)", "((SymVar_0 >> 2) & 0x7)"),
(self.astCtxt.extract(6, 0, self.v1), "((_ extract 6 0) SymVar_0)", "(SymVar_0 & 0x7F)"),
(self.astCtxt.extract(7, 0, self.v1), "SymVar_0", "SymVar_0"),
(self.astCtxt.ite(self.v1 == 1, self.v1, self.v2), "(ite (= SymVar_0 (_ bv1 8)) SymVar_0 SymVar_1)", "(SymVar_0 if (SymVar_0 == 0x1) else SymVar_1)"),
(self.astCtxt.land([self.v1 == 1, self.v2 == 2]), "(and (= SymVar_0 (_ bv1 8)) (= SymVar_1 (_ bv2 8)))", "((SymVar_0 == 0x1) and (SymVar_1 == 0x2))"),
(self.astCtxt.let("alias", self.v1, self.v2), "(let ((alias SymVar_0)) SymVar_1)", "SymVar_1"),
(self.astCtxt.lnot(self.v1 == 0), "(not (= SymVar_0 (_ bv0 8)))", "not (SymVar_0 == 0x0)"),
(self.astCtxt.lor([self.v1 >= 0, self.v2 <= 10]), "(or (bvuge SymVar_0 (_ bv0 8)) (bvule SymVar_1 (_ bv10 8)))", "((SymVar_0 >= 0x0) or (SymVar_1 <= 0xA))"),
(self.astCtxt.reference(self.ref), "ref!0", "ref_0"),
(self.astCtxt.string("test"), "test", "test"),
(self.astCtxt.sx(8, self.v1), "((_ sign_extend 8) SymVar_0)", "sx(0x8, SymVar_0)"),
(self.astCtxt.zx(8, self.v1), "((_ zero_extend 8) SymVar_0)", "SymVar_0"),
]
def test_smt_representation(self):
self.Triton.setAstRepresentationMode(AST_REPRESENTATION.SMT)
self.assertEqual(self.Triton.getAstRepresentationMode(), AST_REPRESENTATION.SMT)
for n in self.node:
self.assertEqual(str(n[0]), n[1])
def test_python_representation(self):
self.Triton.setAstRepresentationMode(AST_REPRESENTATION.PYTHON)
self.assertEqual(self.Triton.getAstRepresentationMode(), AST_REPRESENTATION.PYTHON)
for n in self.node:
self.assertEqual(str(n[0]), n[2])
示例15: TestSymbolicExpression
# 需要导入模块: from triton import TritonContext [as 别名]
# 或者: from triton.TritonContext import getAstContext [as 别名]
class TestSymbolicExpression(unittest.TestCase):
"""Testing symbolic expression."""
def setUp(self):
"""Define the arch."""
self.ctx = TritonContext()
self.ctx.setArchitecture(ARCH.X86_64)
self.inst1 = Instruction("\x48\x31\xd8") # xor rax, rbx
self.ctx.setConcreteRegisterValue(self.ctx.registers.al, 0x10)
self.ctx.setConcreteRegisterValue(self.ctx.registers.bl, 0x55)
self.inst2 = Instruction("\x48\x89\x03") # mov [rbx], rax
self.ctx.processing(self.inst1)
self.ctx.processing(self.inst2)
self.expr1 = self.inst1.getSymbolicExpressions()[0]
self.expr2 = self.inst2.getSymbolicExpressions()[8]
def test_expressions(self):
"""Test expressions"""
self.assertEqual(len(self.inst1.getSymbolicExpressions()), 7)
def test_getAst(self):
"""Test getAst"""
self.assertEqual(self.expr1.getAst().evaluate(), 0x45)
def test_getComment(self):
"""Test getComment"""
self.assertEqual(self.expr1.getComment(), "XOR operation")
def test_getId(self):
"""Test getId"""
self.assertEqual(self.expr1.getId(), 0)
def test_getKind(self):
"""Test getKind"""
self.assertEqual(self.expr1.getKind(), SYMEXPR.REG)
self.assertEqual(self.expr2.getKind(), SYMEXPR.MEM)
def test_getNewAst(self):
"""Test getNewAst"""
self.assertTrue(self.expr1.getAst().equalTo(self.expr1.getNewAst()))
def test_getOrigin(self):
"""Test getOrigin"""
self.assertEqual(self.expr1.getOrigin().getId(), REG.X86_64.RAX)
self.assertEqual(str(self.expr1.getOrigin()), "rax:64 bv[63..0]")
self.assertEqual(str(self.expr2.getOrigin()), "[@0x55]:64 bv[63..0]")
def test_isMemory(self):
"""Test isMemory"""
self.assertFalse(self.expr1.isMemory())
def test_isRegister(self):
"""Test isRegister"""
self.assertTrue(self.expr1.isRegister())
def test_isSymbolized(self):
"""Test isSymbolized"""
self.assertFalse(self.expr1.isSymbolized())
def test_isTainted(self):
"""Test isTainted"""
self.assertFalse(self.expr1.isTainted())
def test_setAst(self):
"""Test setAst"""
self.expr1.setAst(self.ctx.getAstContext().bv(1, 64))
self.assertEqual(str(self.expr1.getAst()), "(_ bv1 64)")
def test_setComment(self):
"""Test setComment"""
self.expr1.setComment("test")
self.assertEqual(self.expr1.getComment(), "test")