def modify_control_flow_1_post_func(program, arg):
if isinstance(program, Statements):
if shouldi(arg=arg):
vardeclist, name = genVarNotIn(arg["ident_present"])
old = program.statements_list
if len(old) != 0 and not is_break_inside(program):
li = []
we, wgt = generate_expr_for_compare(name)
for index in range(len(old)):
e, gt = generate_expr_for_compare(name)
cb = CaseBlock(Statements([old[index]]), e)
li.append((cb, e, gt))
(cb, e, gt) = li[0]
ini = gt
(cb1, e1, gt1) = li[0]
for i in range(len(li) - 1):
(cb, e, gt) = li[i]
(cb1, e1, gt1) = li[i + 1]
cb.statement.append(gt1)
b = Break()
cb.statement.append(b)
cb1.statement.append(wgt)
b = Break()
cb1.statement.append(b)
sw = Switch(Expr([Ident(name)]), list(zip(*li)[0]))
wh = While(Expr([we, "!=", Ident(name)]), Statements([sw]))
program.replaceall([vardeclist, ini, wh])
return [], arg
def duplicate_function_func_post(program, arg):
if program.__class__ == Function:
if shouldi(arg=arg):
if program.ident != None:
newfunc = deepcopy(program)
statement, pos = get_upper_statement_and_pos(program)
statement.insert(
jshadobf_random.randint(0,
len(statement.statements_list) -
1), newfunc)
sl = newfunc.statements.statements_list
if len(sl) > 0:
for i in range(max(1, len(sl) / 3)):
del sl[jshadobf_random.randint(0, len(sl) - 1)]
i = 0
newname = program.ident.name
n = newname
while newname in arg["ident_present"]:
i = i + 1
newname = program.ident.name + format(i)
n += " " + newname
print red(n)
arg["ident_present"].append(newname)
newfunc.replace_ident(Ident(newname))
return [], arg
def rename_variables_func(parse_tree, args):
if parse_tree.__class__ in [Function, Program]:
args["switcher"].append([])
examine = examine_function_vars(parse_tree)
for k in examine["local_var"].keys():
ret = get_tuple_by_name_from_database(k, args["switcher"])
if ret:
kk, newname = ret
for i in examine["local_var"][k][1:]:
i.name = newname
else:
if shouldi(arg=args):
newname = getnewname(args["idents"])
for i in examine["local_var"][k][1:]:
i.name = newname
args["switcher"][-1].append((k, newname))
d = examine["var_global_ref"]
for k in examine["var_global_set"].keys():
if d.has_key(k):
d[k] += examine["var_global_set"][k][1:]
else:
d[k] = examine["var_global_set"][k][1:]
for k in d.keys():
ret = get_tuple_by_name_from_database(k, args["switcher"])
if ret:
dummy, n = ret
for i in d[k][1:]:
i.name = n
return [], args
def add_if_statement_func_post(program, arg):
if program.__class__ == Statements:
if shouldi(arg=arg):
ie = If(genPredicate(program), Statements([EmptyStatement()]),
Statements([EmptyStatement()]))
# print GREEN,"gen " , ie.__class__ , "%x"% id(ie),BLACK
program.insert(
jshadobf_random.randint(0, len(program.statements_list)), ie)
return [], arg
def add_dummy_var_func_post(program, arg):
if program.__class__ == Statements:
if shouldi(arg=arg):
dummyvar, name = genVarNotIn(arg["ident_present"])
dummyvar.dummy = True
program.insert(
jshadobf_random.randint(0, len(program.statements_list)),
dummyvar)
return [], arg
def change_str_func(program, arg):
if isinstance(program, String):
if len(program.value) > 1:
list_upper_statements = get_all_upper_statements_and_pos(program)
if list_upper_statements != [] and (not isinstance(
program.parent,
PropertyName)): # and program != program.parent.name):
if shouldi(arg=arg):
depth = jshadobf_random.randint(
0,
len(list_upper_statements) - 1)
s = list_upper_statements[depth][0]
maxi = list_upper_statements[depth][1]
mylist = []
after_escape = False
i = 0
oi = 0
l = program.value
sel = range(len(l))
jshadobf_random.shuffle(sel)
sel2 = sel[:3]
sel2.sort()
for index in sel2 + [None]:
i = 0
if index:
while ord(l[index - i]) >= 128:
print index - i
i += 1
if index - i == oi:
break
if not (i % 2):
index -= 1
vardeclist, name = genVarNotIn(
arg["ident_present"],
Expr([String(repr(l[oi:index].encode("utf-8")))]))
pos = jshadobf_random.randint(0, maxi)
maxi = maxi + 1
s.insert(pos, vardeclist)
mylist.append(name)
oi = index
#
varlist = map(lambda x: Ident(x), mylist)
[
varlist.insert(i * 2 - 1, "+")
for i in range(1, len(varlist))
]
expr = Expr([
Functioncall(Expr([Ident("eval")]),
Listarguments([Expr(varlist)]))
])
if program.parent.__class__ in [
Expr, VarDeclaration, PropertyName
]:
program.parent.replace_item(program, expr)
return [], arg
def change_list_func_post(program, arg):
if isinstance(program, List):
if len(program.value) > 1:
list_upper_statements = get_all_upper_statements_and_pos(program)
if list_upper_statements != [] and (not isinstance(
program.parent,
PropertyName)) and not is_functioncall_inside(
program): # and program != program.parent.name):
if shouldi(arg=arg):
ident_inside = count_object(program, [Ident])
if ident_inside:
depth = 0
else:
depth = jshadobf_random.randrange(
0, len(list_upper_statements))
s = list_upper_statements[depth][0]
maxi = list_upper_statements[depth][1]
mini = 0
mylist = []
if ident_inside:
mini = maxi
after_escape = False
i = 0
oi = 0
l = program.value
while len(l) != i:
i = oi + int(abs(jshadobf_random.gauss(
0,
len(l) / 3))) + 1
i = min(len(l), i)
vardeclist, name = genVarNotIn(arg["ident_present"],
Expr([List(l[oi:i])]))
pos = jshadobf_random.randint(mini, maxi)
maxi = maxi + 1
s.insert(pos, vardeclist)
mylist.append(name)
oi = i
varlist = map(lambda x: Ident(x), mylist)
if len(varlist) > 1:
callexprsuffix = CallExpressionSuffix(
sum([[
Property(Ident("concat")),
Listarguments([Expr([varlist[i]])])
] for i in range(2, len(varlist))], []))
expr = Expr([
Functioncall(
MemberExpr(Expr([varlist[0]]),
[Property(Ident("concat"))]),
Listarguments([varlist[1]]), callexprsuffix)
])
else:
expr = Expr(varlist)
program.parent.replace_item(program, expr)
return [], arg
def modify_data_flow_1_post_func(program,arg):
if isinstance(program,Assignment):
if shouldi(arg=arg):
s,pos = get_upper_statement_and_pos(program)
s2,pos2 = get_upper_expression_statement_and_pos(program)
if pos2 == None and s != None:
if not is_functioncall_inside(program):# and position_in_exprstatement(program) == 0: # TODO check position_in_exprstatement is working
vardeclist,name=genVarNotIn(arg["ident_present"])
s.insert(pos,Assignment(Expr([Ident(name)]),"=",program.expr))
s.insert(0,vardeclist)
program.expr = Ident(name)
program.expr.parent = program
return [] , arg
def modify_data_flow_2_func(program,arg):
if isinstance(program,Number):
if shouldi(arg=arg):
s,pos = get_upper_statement_and_pos(program)
if s != None:
whereto = jshadobf_random.randint(0,pos)
newp = deepcopy(program)
vardeclist,name=genVarNotIn(arg["ident_present"],newp)
program.parent.replace_item(program, Ident(name))
s.insert(whereto,vardeclist)
if isinstance(program,List):
if shouldi(arg=arg):
s,pos = get_upper_statement_and_pos(program)
if s != None and not is_functioncall_inside(program):
whereto = jshadobf_random.randint(0,pos)
if count_object(program,[Ident] ):
whereto = pos
newp = deepcopy(program)
vardeclist,name=genVarNotIn(arg["ident_present"],newp)
program.parent.replace_item(program, Ident(name))
s.insert(whereto,vardeclist)
return [] , arg
def add_dummy_exprs_func(parse_tree,arg):
if parse_tree.__class__ in [Function,Program,Statements]:
arg["dummyvars"].append([])
arg["ident_ass"].append([])
if isinstance(parse_tree,Assignment):
if isinstance(parse_tree.var,Expr):
if len(parse_tree.var.exprs) == 1 and isinstance(parse_tree.var.exprs[0],Ident):
arg["ident_ass"][-1].append(parse_tree.var.exprs[0].name)
if isinstance(parse_tree,VarDeclaration):
if parse_tree.dummy:
arg["dummyvars"][-1].append(parse_tree.var.name)
if parse_tree.__class__ == Statements:
if shouldi(arg=arg):
vartoass =None
ident_ass= reduce(lambda x,y : x+ y , arg["ident_ass"] )
if shouldi(2):
dummyvars= reduce(lambda x,y : x+ y , arg["dummyvars"] )
if len(dummyvars ) > 0:
vartoass = pick_one(dummyvars)
expr = gen_dummy_expr(vartoass,ident_ass)
parse_tree.insert(jshadobf_random.randint(0,len(parse_tree.statements_list)),expr)
return [],arg
def evalification_func(program, arg):
#~ print
if isinstance(program, Statements):
for s in program.statements_list:
if not is_return_inside(s) and not is_break_inside_weak(s):
if shouldi(arg=arg):
ss = repr(s.oneline_str().encode("utf-8"))
program.replace_item(
s,
Expr([
Functioncall(Expr([Ident("eval")]),
Listarguments([String(ss)]))
]))
return [], arg
def add_if_statement_2_func_post(program, arg):
if program.__class__ == Statements:
if shouldi(arg=arg) and not is_function_inside(program):
o = program.statements_list
if len(o) > 0:
ifrom = jshadobf_random.randint(0, len(o) - 1)
ito = jshadobf_random.randint(ifrom, len(o))
s1 = deepcopy(o[ifrom:ito])
s2 = deepcopy(o[ifrom:ito])
for i in range(len(s2), 0, -1):
if jshadobf_random.randint(0, 4) == 0:
del s2[i - 1]
flipcoin = jshadobf_random.randint(0, 1)
if not flipcoin:
s1, s2 = s2, s1
ie = If(genPredicate(program, flipcoin), Statements(s1),
Statements(s2))
program.replaceall(o[:ifrom])
program.append(ie)
program.append_list(o[ito:])
return [], arg
def outlining_post_func(program, arg):
if isinstance(program, Statements):
if shouldi(arg=arg) and len(program.statements_list) != 0:
f = jshadobf_random.randint(0, len(program.statements_list) - 1)
t = jshadobf_random.randint(f + 1, len(program.statements_list))
outline = program.statements_list[f:t]
if not is_return_inside(outline) and not is_function_inside(
outline):
funcobj, funcname = genVarNotIn(arg["ident_present"])
presence = detect_presence(outline)
if not (presence["arguments"] or presence["this_present"] or
presence["break_present"] or presence["eval_present"]):
examine_outline = examine_function_vars(outline)
upfunc = get_upper_function(program)
examine_before = examine_function_vars(
upfunc, program.statements_list[f])
examine_func = examine_function_vars(upfunc)
if isinstance(upfunc, Function):
for v in upfunc.args_dec.args_list:
include_ident(examine_before["local_var"], v)
nameargs ,varout,vardecout , vardec,todec= [],[],[],[],[]
if all_function_call_are_functionnal(outline):
for k in examine_outline["local_var"].keys():
if examine_before["local_var"].has_key(
k) and examine_before["local_var"][k][0][
"has_been_assigned"]:
nameargs.append(k)
for k in examine_outline["var_global_ref"].keys():
if examine_before["local_var"].has_key(k):
nameargs.append(k)
elif examine_func["local_var"].has_key(k):
todec.append(k)
elif examine_before["var_global_set"].has_key(k):
nameargs.append(k)
for k in examine_outline["var_global_set"].keys():
if examine_before["local_var"].has_key(k):
nameargs.append(k)
elif examine_func["local_var"].has_key(k):
todec.append(k)
for k in examine_outline["local_var"].keys():
vardecout.append(k)
for k in examine_outline["local_var"].keys():
if examine_outline["local_var"][k][0][
"has_been_assigned"]:
varout.append(k)
for k in examine_outline["var_global_set"].keys():
varout.append(k)
movable = all([
k in nameargs + vardecout
for k in examine_outline["local_var"].keys() +
examine_outline["var_global_ref"].keys()
] + [examine_outline["var_global_set"].keys() == []])
elif len(examine_outline["local_var"]) == 0:
nameargs, varout, vardecout = [], [], []
movable = False
else:
return [], arg
vardecout = list(set(vardecout))
varout = list(set(varout))
nameargs = list(set(nameargs))
rem = range(f, t)
rem.reverse()
for i in rem:
del program.statements_list[i]
outline = [
Var([VarDeclaration(Ident(n))]) for n in vardec
] + outline
outline += [
Return(Expr([List([Ident(n) for n in varout])]))
]
listarg = Listarguments([Ident(n) for n in nameargs])
listretobj, listretname = genVarNotIn(arg["ident_present"])
i = 0
for n in varout:
program.insert(
f,
Assignment(
Ident(n), "=",
MemberExpr(Expr([Ident(listretname)]),
[Index(Expr([Number(str(i))]))])))
i = i + 1
for n in vardecout:
program.insert(f, Var([VarDeclaration(Ident(n))]))
i = i + 1
for n in todec:
outline.insert(0, Var([VarDeclaration(Ident(n))]))
program.insert(
f,
Var([
VarDeclaration(
Ident(listretname),
Functioncall(Ident(funcname), listarg))
]))
uppers = []
if movable:
uppers = get_all_upper_statement_and_pos(program)
uppers = uppers + [(program, f)]
upper, pos = uppers[jshadobf_random.randint(
0,
len(uppers) - 1)]
outline_statement = Statements(outline)
l1 = deepcopy(listarg)
upper.insert(
pos, Function(Ident(funcname), l1, outline_statement))
return [], arg
