def createMain(self):
#Main Function
#Declaration
z1 = c_ast.TypeDecl('args',[],c_ast.IdentifierType(['int']))
args = c_ast.Decl('args',[],[],[],z1,None,None)
z2= c_ast.PtrDecl([],c_ast.TypeDecl('argv',[],c_ast.IdentifierType(['char'])))
z3=c_ast.ArrayDecl(z2,None,[])
argv = c_ast.Decl('argv',[],[],[],z3,None,None)
params=c_ast.ParamList([args,argv])
mainDec=c_ast.FuncDecl(params,c_ast.TypeDecl('main',[],c_ast.IdentifierType(['int'])))
# insertTest(functionName,varVals,varTypes)
#Body
##Signal
sigalrm=c_ast.ID(name="14")
funcCast=c_ast.TypeDecl(declname = None,quals=[],type=c_ast.IdentifierType(['void']))
paramCast=c_ast.ParamList([c_ast.Typename(name=None,quals=[],type=c_ast.TypeDecl(declname = None,quals=[],type=c_ast.IdentifierType(['int'])))])
typeFunc=c_ast.PtrDecl(type=c_ast.FuncDecl(paramCast,funcCast),quals=[])
kchild=c_ast.Cast(to_type=c_ast.Typename(name=None, quals=[],type=typeFunc),expr=c_ast.ID(name="kill_child"))
expressList = [sigalrm,kchild]
signalStmt=c_ast.FuncCall(c_ast.ID(name="signal"),c_ast.ExprList(expressList))
##Return
returnStmt=c_ast.Return(c_ast.Constant(type="int",value="0"))
comp=c_ast.Compound([signalStmt,returnStmt])
return c_ast.FuncDef(mainDec,None,comp)
def make_klee_symbolic(variable_name, trackingName):
arg1 = c_ast.UnaryOp(op='&', expr=c_ast.ID(variable_name))
arg2 = c_ast.UnaryOp(op='sizeof', expr = c_ast.Typename(name=None, quals =[],
type= c_ast.TypeDecl(declname=None,quals=[],
type=c_ast.IdentifierType(names=['int']))))
arg3 = c_ast.Constant(type='string', value='\"'+ trackingName +'\"')
return c_ast.FuncCall(name=c_ast.ID(name = "klee_make_symbolic"), args=c_ast.ExprList(exprs=[arg1,arg2,arg3]))
def pre_argument(self, name):
commands = []
commands.append(
_generate_decl(
name + '_int',
c_ast.TypeDecl(name + '_int', [],
c_ast.IdentifierType(['unsigned', 'int']))))
commands.append(_generate_read(name + '_int'))
commands.append(
c_ast.Assignment('|=', c_ast.ID(name + '_int'),
c_ast.Constant('int', PTR_OFFSET)))
commands.append(
c_ast.Decl(
name, [], [], [],
c_ast.PtrDecl(
[],
c_ast.TypeDecl(name, [], c_ast.IdentifierType(['void'])),
),
c_ast.Cast(
c_ast.Typename(
None, [],
c_ast.PtrDecl([],
c_ast.TypeDecl(
None, [],
c_ast.IdentifierType(['void'])))),
c_ast.ID(name + '_int')), []))
return commands
def make_return_type(ast, owns, meta):
normalized = meta.normalize_type(ast)
if type(normalized.node) == c_ast.PtrDecl:
if type(normalized.next.node) == c_ast.Struct:
name = structName_to_className(normalized.next.node.name)
return '%s<%d-Owning*0>' % (name, bool(owns))
#if type(normalized.next.node) == c_ast.FuncDecl:
# return normalized.next.node.type.declname # TODO!!!!
#if AST_Is_Enum(ast, meta):
# # TODO: move enum to Xml:: and strip off Xml-Preifx
# return ast.type.names[0] # TODO: handle this better
#if AST_Is_Ptr_To_Unsigned_Char(ast, meta):
# return 'xmlChar* ' # TODO: handle const
#if type(normalized.node) is c_ast.IdentifierType and normalized.node.names == ['unsigned','char']:
# return 'xmlChar ' # TODO!!!!!!
ast = deepcopy(ast)
class ClearDeclname(c_ast.NodeVisitor):
def visit_TypeDecl(_, node):
node.declname = ''
ClearDeclname().visit(ast)
name = ast_to_c(c_ast.Typename('', [], ast))
return name
return strip_xml_prefix(name).replace(
'Ptr', '') # TODO: replace(Ptr) needed?! this line needed?
def castify(node):
'''c_ast -> c_ast'''
# NOTE mutates declname (changes ast)
#
# in order to make extern calls without warnings, we must cast our register
# arguments (which are just ints) to the argument types. this function
# takes ast nodes like these:
#
# ArrayDecl <type>: dim_quals=[]
# PtrDecl <type>: quals=[]
# TypeDecl <type>: declname=argv, quals=[]
# IdentifierType <type>: names=['char']
#
# TypeDecl <type>: declname=main, quals=[]
# IdentifierType <type>: names=['int']
#
# and produces these:
#
# Typename <params[1]>: quals=[]
# ArrayDecl <type>: dim_quals=[]
# PtrDecl <type>: quals=[]
# TypeDecl <type>: declname=None, quals=[]
# IdentifierType <type>: names=['char']
#
# Typename <to_type>: quals=[]
# TypeDecl <type>: declname=None, quals=[]
# IdentifierType <type>: names=['int']
#
# which are suitable for use with c_ast.Cast. (we have to make declname
# None or CGenerator().visit will include the name--bogus in a cast)
find_node(node, c_ast.TypeDecl).declname = None
return c_ast.Typename(node.quals, node)
def check_value(ast_tree, ext_index, bock_item_index, var_name, func_name):
Cast = c_ast.Cast(
c_ast.Typename(
None, [],
c_ast.PtrDecl([],
c_ast.TypeDecl(None, [],
c_ast.IdentifierType(['void'])))),
c_ast.ID(var_name))
func_call = c_ast.FuncCall(
c_ast.ID('check_value'),
c_ast.ExprList([
c_ast.UnaryOp('&', c_ast.ID('global_log')), Cast,
c_ast.Constant('string', '"' + var_name + '"'),
c_ast.Constant('string', '"' + func_name + '"'),
c_ast.Constant('int', str(len(var_name))),
c_ast.Constant('int', str(len(func_name)))
]))
new_node = c_ast.If(
c_ast.BinaryOp('==', func_call, c_ast.Constant('int', '0')),
c_ast.Compound([
c_ast.FuncCall(
c_ast.ID('printf'),
c_ast.ExprList([
c_ast.Constant('string', '"%s\\n"'),
c_ast.Constant('string', '"Attack Detected"')
])),
c_ast.FuncCall(c_ast.ID('exit'),
c_ast.ExprList([c_ast.Constant('int', '1')]))
]), None)
return merge_ast_tree(ast_tree, ext_index, bock_item_index, new_node,
"insert_before")
def anonymize_param(param: ca.Decl) -> ca.Typename:
param = copy.deepcopy(param)
param.name = None
set_decl_name(param)
return ca.Typename(name=None,
quals=param.quals,
type=param.type,
align=[])
def offsetof(self, struct_name, name):
return c_ast.FuncCall(
c_ast.ID('offsetof'),
c_ast.ExprList([
c_ast.Typename(
None, [],
c_ast.TypeDecl(None, [], c_ast.Struct(struct_name, None))),
c_ast.ID(name)
]))
def update_value(ast_tree, ext_index, bock_item_index, var_name, func_name,
var_size, func_size):
Cast = c_ast.Cast(
c_ast.Typename(
None, [],
c_ast.PtrDecl([],
c_ast.TypeDecl(None, [],
c_ast.IdentifierType(['void'])))),
c_ast.ID(var_name))
new_node = c_ast.FuncCall(
c_ast.ID('update_value'),
c_ast.ExprList([
c_ast.UnaryOp('&', c_ast.ID('global_log')), Cast,
c_ast.Constant('string', '"' + var_name + '"'),
c_ast.Constant('string', '"' + func_name + '"'),
c_ast.Constant('int', str(var_size)),
c_ast.Constant('int', str(func_size))
]))
return merge_ast_tree(ast_tree, ext_index, bock_item_index, new_node,
"insert_after")
def simple_cast(ty, expr, quals=[]):
return c_ast.Cast(c_ast.Typename(quals, ty), expr)
def callback(node: ca.Node, is_expr: bool) -> Optional[ca.Node]:
if node is expr:
typedecl = ca.TypeDecl(None, [], ca.IdentifierType(new_type))
return ca.Cast(ca.Typename(None, [], typedecl), expr)
return None
def MakeCast(identifier_type, node):
return c_ast.Cast(
c_ast.Typename(None, [], c_ast.TypeDecl(None, [], identifier_type)),
node)
def sizeof(self, type_decl):
anonymous_type_decl = self.anonymize_type_decl(type_decl)
return c_ast.UnaryOp('sizeof',
c_ast.Typename(None, [], anonymous_type_decl))
