def GetObfuscatedCode(self, const_name, const_value, indentation=0, headers=False, comment=""):
"""
Returns a string containing the offuscated code to write
'const_name = const_value' as an opaque constant.
"""
operator = op.Operator(self.bit)
def indent(times=0):
tabs = ""
for i in range(indentation + times):
tabs += "\t"
return tabs
if comment != "":
comment = "# " + comment + "\n"
else:
comment = "\n"
if self.first_start or headers:
# added only on first code generated, or when requested with "headers=True"
imports = "from SimpleConstantObfuscator import operator\n" + indent() + "import numpy\n" + indent() + "import numpy.random\n"
header = imports
else:
header = ""
self.first_start = False
k = self.encode(const_value)
zero_str = "zero = " + str(k["zero"]) + "\n"
one_str = "one = " + str(k["one"]) + "\n"
set1_str = "set_ones = " + str(operator.binary(k["set1"])) + "\n"
set0_str = "set_zeros = " + str(operator.binary(k["set0"])) + "\n"
init_str = "operator = operator.Operator(" + str(self.bit) + ")\n" + indent() + "binRandom = numpy.random.randint(2, size=" + str(self.bit) + ")\n" + indent() + const_name + " = operator.binary(0)\n"
init_block = zero_str + indent() + one_str + indent() + set1_str + indent() + set0_str + indent() + indent() + comment + init_str
for_clause = "for i in range("+ str(self.bit) + "):\n"
if_0 = "if (binRandom[i] == 0):\n" + indent(times=2) + "z_i = zero[i]\n" + indent(times=2) + "xor = operator.binary(z_i)\n"
if_1 = "else:\n" + indent(times=2) + "o_i = one[i]\n" + indent(times=2) + "xor = operator.binary(o_i)\n"
xor_str = "for b in range(" + str(self.bit) + "):\n" + indent(times=2) + const_name + "[b] =operator.lxor([" + const_name + "[b], xor[b]])\n"
for_block = for_clause + indent(times=1) + if_0 + indent(times=1) + if_1 + indent(times=1) + xor_str + "\n"
or_str = "for i in range(" + str(self.bit) + "):\n" + indent(times=1) + const_name + "[i] = " + const_name + "[i] or set_ones[i]\n"
and_str = "for i in range(" + str(self.bit) + "):\n" + indent(times=1) + const_name + "[i] = " + const_name + "[i] and set_zeros[i]\n"
end_block = or_str + indent() + and_str + indent() + const_name + "= operator.decimal(" + const_name + ")\n"
full_code = indent() + header + indent() + init_block + indent() + for_block + indent() + end_block
return full_code
def hello(request):
operator = op.Operator()
numStr = str(request.GET.get('num'))
if numStr != 'None':
num = int(numStr)
else:
num = 0
pros = operator.getResult(num, ('a1699186','1699186a'))
return render(request, 'main.html', {'pros': pros})
def decode(self, k, verbose=False):
"""
Decodes and returns the obfuscated constant
"""
operator = op.Operator(self.bit)
zero = k["zero"]
one = k["one"]
set_ones = operator.binary(k["set1"])
set_zeros = operator.binary(k["set0"])
binRandom = r.randint(2, size=self.bit)
binConstant = operator.binary(0)
for i in range(self.bit):
if (binRandom[i] == 0):
z_i = zero[i]
xor = operator.binary(z_i)
else:
o_i = one[i]
xor = operator.binary(o_i)
if (verbose):
print binConstant, xor, "\n"
# applying xor to the bits of the constant to be decoded
for b in range(self.bit):
binConstant[b] = operator.lxor([binConstant[b], xor[b]])
if (verbose):
print binConstant, "\n\n"
for i in range(self.bit):
binConstant[i] = binConstant[i] or set_ones[i]
if (verbose):
print binConstant, "\n"
for i in range(self.bit):
binConstant[i] = binConstant[i] and set_zeros[i]
if (verbose):
print binConstant, "\n"
return operator.decimal(binConstant)
def encode(self, const):
"""
Obfuscates the "const" integer by dividing bit indexes in two groups (I and II);
it obscures the constant and returns a dictionary containing:
"zero" : the zero[] list as seen in decode()
"one" : the one[] list as seen in decode()
"set0" : the value which defines the bits of group II which need to be set to 0
"set1" : the value which defines the bits of group II which need to be set to 1
"""
operator = op.Operator(self.bit)
indexes = range(self.bit)
r.shuffle(indexes)
# dividing "indexes" in 2 groups:
positive_offset = r.randint(self.bit / 8)
negative_offset = r.randint(self.bit / 8)
m = self.bit / 2 + positive_offset - negative_offset
m = min(self.bit, max(0, m)) # check that m is not out of bound
I = indexes[:m]
II = indexes[m:]
bconst = operator.binary(const)
zero = []
one = []
for i in range(self.bit):
#initialize zero and one to random values
z_i = r.randint(2 ** self.bit, dtype=np.int64)
z_i = operator.binary(z_i)
zero.insert(i, z_i)
o_i = r.randint(2 ** self.bit, dtype=np.int64)
o_i = operator.binary(o_i)
one.insert(i, o_i)
for b in I:
# consider the b-th bit of every element in z:
sequence = []
for k in range(self.bit):
sequence.append(zero[k][b])
# the 'xor' of all those bits must be equal to bconst[b];
# the following code calculates the 'xor' of all elements
# in sequence except the last one:
all_except_one = operator.lxor(sequence[:len(sequence) - 1])
# ...then adjust the last bit accordingly:
if bconst[b] == 0:
zero[self.bit - 1][b] = all_except_one
else:
zero[self.bit - 1][b] = int( not all_except_one )
# copy values of bits which are in group I from zero to one:
for i in range(self.bit):
for b in I:
one[i][b] = zero[i][b]
# turn zero and one back to decimal
for i in range(self.bit):
zero[i] = operator.decimal(zero[i])
one[i] = operator.decimal(one[i])
# now fixing 0s and 1s of group II
set0 = []
set1 = []
for i in range(self.bit):
set0.append(1)
set1.append(0)
for b in II:
if bconst[b] == 0:
set0[b] = 0
if bconst[b] == 1:
set1[b] = 1
set0 = operator.decimal(set0)
set1 = operator.decimal(set1)
return {"zero": zero, "one": one, "set0":set0, "set1":set1}
def add_numbers():
# a = request.args.get('a')
operator = op.Operator()
pros = operator.getResult(('a1699186', '1699186a'))
return jsonify(result=pros)
def newmain(number):
operator = op.Operator()
pros = operator.getResult(('a1699186', '1699186a'))
return render_template('main.html', pros=pros)
# box_roi_pool=roi_pooler,
# # mask_roi_pool=mask_roi_pooler
# )
weight_path = "./weight/test_model.pt"
if os.path.exists(weight_path):
if torch.cuda.is_available():
model.load_state_dict(torch.load(weight_path), strict=True)
else:
model.load_state_dict(torch.load(weight_path, map_location='cpu'), strict=True)
print("="*6, "\nModel loaded, start retraining", "\n"+"="*6)
else:
print("="*6, "\nModel isn't found, train the network from begining.","\n"+"="*6)
operator = op.Operator(model)
operator.trainer(FLAGS.img_path, FLAGS.gt_path, FLAGS.bsize, FLAGS.lr, FLAGS.epoch)
if FLAGS.predict:
num_classes = 6
model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)
in_features = model.roi_heads.box_predictor.cls_score.in_features
model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)
in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels
hidden_layer = 512
model.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask,
hidden_layer,
num_classes)
print(model)
def newmain(number):
# auth=(username,password)
operator = op.Operator()
pros = operator.getResult(number, ('a1699186', '1699186a'))
return render_template('main.html', pros=pros)
param.requires_grad = False
else:
if os.path.exists("./weight/model.pt"):
if torch.cuda.is_available():
netG.load_state_dict(torch.load("./weight/model.pt"), strict=True)
else:
netG.load_state_dict(torch.load("./weight/model.pt", map_location='cpu'), strict=True)
print("="*6, "\nModel loaded, start retraining", "\n"+"="*6)
else:
print("="*6, "\nModel isn't found, train the network from begining.","\n"+"="*6)
writer = SummaryWriter("./logs/")
operator = op.Operator(netG)
operator.trainer(FLAGS.img_path, FLAGS.gt_path, FLAGS.bsize, FLAGS.lr, FLAGS.epoch, writer = writer)
writer.close()
if FLAGS.eval:
netG = UNet(in_channels = 3, out_channels = 8)
# netG = nn.DataParallel(netG).to(device)
print(netG)
if os.path.exists("./weight/model.pt"):
if torch.cuda.is_available():
netG.load_state_dict(torch.load("./weight/model.pt"), strict=True)
else:
netG.load_state_dict(torch.load("./weight/model.pt", map_location='cpu'), strict=True)
print("="*6, "\nModel loaded, start evaluation", "\n"+"="*6)