def verify_backup(self, host, dir_to_verify, logger):
verifier_obj = Verifier(host=host,
dir_to_verify=dir_to_verify,
logger=logger)
verifier_obj.setup()
return verifier_obj.verify()
class VerifyTalent(FunctionTalent):
def __init__(self, connection_string):
super(VerifyTalent, self).__init__('VerifyTalent', connection_string)
self.register_function('verify', self.__verify)
self.register_function('sign', self.__sign)
self.register_function('signerdid', self.__signerdid)
self.verifier = Verifier()
jwk_raw = os.getenv('JWK')
if jwk_raw and jwk_raw != '':
try:
self.key = jwk.JWK.from_json(jwk_raw)
self.logger.info('Successfully stored Key from JWK: {}'.format(
self.key))
# pylint: disable=broad-except
except Exception as ex:
self.logger.error('Could not import JWK: {}'.format(ex))
# pylint: disable=unused-argument
def __verify(self, payload, ev, evtctx):
self.logger.info(
'Received verification request for value {}'.format(payload))
result = self.verifier.verify(payload)
# If error message
if isinstance(result, str):
self.logger.error('Verify failed: {}'.format(result))
return result
else:
return self.verifier.verify(payload).decode('utf-8')
# pylint: disable=unused-argument
async def __sign(self, payload, ev, evtctx):
if self.key is None or self.key == '':
return 'no key given'
return await self.verifier.sign(payload, self.key)
# pylint: disable=unused-argument
async def __signerdid(self, payload, ev, evtctx):
return await self.verifier.signer_did(payload)
def test_adv_attack(self):
debug = True
src = 'testing/tests/data/master2_4s_1080.mp4'
rend_path = 'testing/tests/data/rend2_4s_1080_adv_attack.mp4'
verifier = Verifier(
10,
'http://storage.googleapis.com/verification-models/verification-metamodel-2020-07-06.tar.xz',
False, False, debug)
verification_result = verifier.verify(src, [{'uri': rend_path}])
print(verification_result)
assert verification_result[0]['tamper'] == 1
def verify_backup(self, host, dir_to_verify, logger):
verifier_obj = Verifier(host=host, dir_to_verify=dir_to_verify,
logger=logger)
backup_lock.acquire()
try:
verifier_obj.setup()
finally:
backup_lock.release()
return verifier_obj.verify()
def test_verifier(self):
verifier = Verifier(self.crs)
self.assertEqual(verifier.verify(self.ciphertexts, self.proof),
(True, True, True))
prevshuffle = self.proof['shuffled_ciphertexts']
g1 = self.crs.lff.gen1()
g2 = self.crs.lff.gen2()
self.proof['shuffled_ciphertexts'][3] = ((g1, g1, g1), (g2, g2, g2))
self.assertEqual(verifier.verify(self.ciphertexts, self.proof),
(True, False, False))
self.proof['shuffled_ciphertexts'] = prevshuffle
self.crs.g1alpha = self.crs.g1alpha * 2
verifier = Verifier(self.crs)
self.assertEqual(verifier.verify(self.ciphertexts, self.proof),
(False, False, False))
class AEGG(object):
def __init__(self, binary):
self.binary = os.path.abspath(binary)
self.payloads = []
self.bug_finder = BugFinder(self.binary)
self.analyzer = Analyzer(self.binary)
self.exploiter = Exploiter(self.binary)
self.verifier = Verifier(self.binary)
def _save(self, payload, file_name):
with open(file_name, 'w') as f:
f.write(payload)
def exploit_gen(self, path):
analysis = self.analyzer.analyze(path)
for payload in self.exploiter.generate(path, analysis):
if not payload:
break
if self.verifier.verify(payload):
self.payloads.append(payload)
l.info('Generated!')
return True
l.info('Can not generate any payload.')
return False
def hack(self, n=None, paths=None):
"""
n: number paths want to check
paths: angr path object
"""
n = 1 if n is None else n
paths = [] if paths is None else paths
l.info('Start hacking ...')
while len(paths) < n:
found_paths = self.bug_finder.find()
if found_paths is None:
break
paths.extend(found_paths)
for path in paths:
self.exploit_gen(path)
l.info('Completed.')
def save(self, file_name=None):
file_name = self.binary if file_name is None else file_name
if len(self.payloads) == 1:
ext = 'py' if self.payloads[0].ptype == 'script' else 'exp'
self._save(self.payloads[0].content, '%s.%s' % (file_name, ext))
else:
for i in xrange(len(self.payloads)):
ext = 'py' if self.payloads[0].ptype == 'script' else 'exp'
self._save(self.payloads[i].content,
'%s-%d.%s' % (file_name, i, ext))
def verify_backup(self, host, dir_to_verify, logger):
verifier_obj = Verifier(host=host,
dir_to_verify=dir_to_verify,
logger=logger)
backup_lock.acquire()
try:
verifier_obj.setup()
finally:
backup_lock.release()
return verifier_obj.verify()
def test_classification(self):
source_dir = '../data/renditions/1080p/'
rendition_dirs = [
('../data/renditions/720p_watermark/', True),
('../data/renditions/720p_60-24fps/', False),
]
files = None
debug = False
n_samples = 10
gpu = False
src_videos = sorted(glob.glob(source_dir + '/*'))
results = []
verifier = Verifier(
n_samples,
'http://storage.googleapis.com/verification-models/verification-metamodel-2020-07-06.tar.xz',
gpu, False, debug)
for src in tqdm.tqdm(src_videos):
filename = src.split(os.path.sep)[-1]
if files is not None and not filename in files:
continue
i = 0
for rendition_dir, tamper in rendition_dirs:
rendition_name = rendition_dir.strip(os.path.sep).split(
os.path.sep)[-1]
rend_path = rendition_dir + os.path.sep + filename
if not os.path.exists(rend_path):
continue
np.random.seed(123)
random.seed(123)
verification_result = verifier.verify(src, [{
'uri': rend_path
}])
score_meta = float(verification_result[0]["tamper"])
score_ul = float(verification_result[0]["tamper_ul"])
score_sl = float(verification_result[0]["tamper_sl"])
res = {
'score': score_meta,
'score_ul': score_ul,
'score_sl': score_sl
}
res['master_filename'] = filename
res['rendition_type'] = rendition_name
res['is_tamper'] = tamper
results.append(res)
df_res: pd.DataFrame = pd.DataFrame(results)
df_res.set_index(['master_filename', 'rendition_type'], inplace=True)
df_res.sort_index(inplace=True)
df_res['prediction'] = df_res['score'] > 0
print(df_res)
# assert accuracy
assert np.sum(
df_res.prediction == df_res.is_tamper) / len(df_res) >= 0.8
#'http://storage.googleapis.com/verification-models/verification-metamodel-fps2.tar.xz'
verifier = Verifier(10, 'http://storage.googleapis.com/verification-models/verification-metamodel-2020-07-06.tar.xz', False, False, debug)
outcsv = "accuracy" + datetime.datetime.now().strftime("%m%d%H%M%S") + ".csv"
fileout = open(outcsv, 'w', newline='')
wr = csv.writer(fileout)
wr.writerow(['source', 'rendition', 'infertarget'])
with open(infile, newline='') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
if row['target'] == '0':
wrow = []
srcfile = srcdir + "/" + row['source']
rendfile = renddir + "/" + row['id']
result = verifier.verify(srcfile, [{'uri': rendfile}])
wrow.append(row['id'])
wrow.append(row['source'])
wrow.append(result[0]['tamper'])
wr.writerow(wrow)
print( str(logcount) + " ---result :" + str(result[0]['tamper']))
logcount = logcount + 1
fileout.close()
print('Success calculation accuracy!')
'''
with open(infile, newline='') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
if(k.find("\n")):
k=k[:-1]
return m , k , inputString
if(flag==2):
bit=""
for t in range(len(inputString)):
if(inputString[t].isdigit()):
bit+=str(inputString[t])
return int(bit), inputString
# case of generator and verifier
if(counter==1):
m , k , inputString = getDataFromFile(1,inputString)
g = Generator(m, k)
printlongdiv(int(m, 2), int(k, 2))
genOutput = g.encode()
g.GeneratorDivisor = g.getDivisor()
v = Verifier(genOutput, g.GeneratorDivisor)
v.verify()
# case of generator, alter, and verifier
if(counter==2):
m , k , inputString = getDataFromFile(1,inputString)
g = Generator(m, k)
printlongdiv(int(m, 2), int(k, 2))
genOutput = g.encode()
g.GeneratorDivisor = g.getDivisor()
bit , inputString = getDataFromFile(2,inputString)
messageAltered = alter(bit, genOutput)
v = Verifier(messageAltered, g.GeneratorDivisor)
v.verify()
def verify_backup(self, host, dir_to_verify, logger):
verifier_obj = Verifier(host=host, dir_to_verify=dir_to_verify,
logger=logger)
verifier_obj.setup()
return verifier_obj.verify()
