def prompt_userinfo():
master_password, signing_password = prompt_password()
human_container_name, fs_container_name, api_token = get_dccinfo(
master_password, signing_password)
password_data = read_passwd(api_token, fs_container_name, signing_password)
return (get_key(master_password, password_data['encryption_key']),
get_key(signing_password, password_data['signing_key']), api_token,
human_container_name, fs_container_name)
def setup(*args, **kwargs):
master_password, signing_password = generate_password()
password_data = dict(encryption_key=make_key(master_password),
signing_key=make_key(signing_password))
container_name, api_token = make_dccfile(master_password, signing_password)
save_passwd(api_token, container_name, password_data, signing_password)
save_vfs(api_token, container_name, VFS(),
get_key(master_password, password_data['encryption_key']),
get_key(signing_password, password_data['signing_key']))
return 0
def setup(*args, **kwargs):
master_password, signing_password = generate_password()
password_data = dict( encryption_key=make_key(master_password), signing_key=make_key(signing_password) )
container_name, api_token = make_dccfile(master_password, signing_password)
save_passwd(api_token, container_name, password_data, signing_password)
save_vfs(api_token, container_name, VFS(), get_key(master_password, password_data['encryption_key']), get_key(signing_password, password_data['signing_key']))
return 0
def test_get_key_good(self, symm_key):
symm_keys = self.ring.encrypt(symm_key)
for kp in self.alice, self.bob, self.carol, self.derek:
got_symm_key = encryption.get_key(symm_keys, kp.privkey)
self.assertIsNotNone(got_symm_key)
self.assertEqual(symm_key, got_symm_key)
def recv(ip):
private_key = encryption.get_key()
u = upnp_handler.new_upnp()
upnp_handler.forward_port(u, 25565)
s = socket.socket()
s.connect((ip, 25565))
public_key = encryption.get_public_key()
s.send(public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
))
encryptedmetajson = s.recv(1024)
metajson = encryption.decrypt(private_key, encryptedmetajson).decode('utf-8')
metadata = json.loads(metajson)
filename = metadata['filename']
size = metadata['size']
checksum = metadata['checksum']
fernet_key = metadata['fernet_key'].encode('utf-8')
if (input("Recieve " + filename + ", a " + filesize.size(
size, system = filesize.alternative) + "byte file? [Y/n] \n").upper() in
['N', 'NO']):
print('Abort.')
s.send("nosend".encode('utf-8'))
upnp_handler.close_port(u, 25565)
sys.exit()
s.send("send it".encode('utf-8'))
encryptedtoken = b""
while True:
data = s.recv(1024)
if (len(data)):
encryptedtoken += data
else:
break
s.close()
upnp_handler.close_port(u, 25565)
with open(filename, 'w+b') as f:
f.truncate(0)
f.write(encryption.decrypt_fernet(fernet_key, encryptedtoken))
f = open(filename, 'rb')
if (sha256(f.read()).hexdigest() != checksum):
print("WARNING! Something happened to the file! Checksums do not match!")
print(sha256(repr(f.read).encode('utf-8')).hexdigest())
def download_and_decrypt_user_data(token, password):
encrypted_data = get_user_data(token)
encrypted_master_key = encrypted_data['master_key']
master_key = decrypt(get_key(password), encrypted_master_key)
encryption_key = get_key(master_key)
passwords = []
for entry_id in encrypted_data['passwords']:
entry = encrypted_data['passwords'][entry_id]
entry['name'] = decrypt(encryption_key, entry['name'])
entry['site'] = decrypt(encryption_key, entry['site'])
entry['username'] = decrypt(encryption_key, entry['username'])
entry['password'] = decrypt(encryption_key, entry['password'])
passwords.append(Password(relative_id=Password.count, id_=entry_id, name=entry['name'], site=entry['site'],
username=entry['username'], password=entry['password']))
Password.count += 1
secure_notes = []
for entry_id in encrypted_data['secure_notes']:
entry = encrypted_data['secure_notes'][entry_id]
entry['name'] = decrypt(encryption_key, entry['name'])
entry['content'] = decrypt(encryption_key, entry['content'])
secure_notes.append(SecureNote(relative_id=SecureNote.count, id_=entry_id, name=entry['name'],
content=entry['content']))
SecureNote.count += 1
credit_cards = []
for entry_id in encrypted_data['credit_cards']:
entry = encrypted_data['credit_cards'][entry_id]
entry['name'] = decrypt(encryption_key, entry['name'])
entry['number'] = decrypt(encryption_key, entry['number'])
entry['expiration_date'] = decrypt(encryption_key, entry['expiration_date'])
entry['cvv'] = decrypt(encryption_key, entry['cvv'])
entry['cardholder_name'] = decrypt(encryption_key, entry['cardholder_name'])
credit_cards.append(CreditCard(relative_id=CreditCard.count, id_=entry_id, name=entry['name'],
number=entry['number'], expiration_date=entry['expiration_date'],
cvv=entry['cvv'], cardholder_name=entry['cardholder_name']))
CreditCard.count += 1
decrypted_data = {'passwords': passwords, 'secure_notes': secure_notes, 'credit_cards': credit_cards}
return encryption_key, decrypted_data
def decrypt(self):
password = settings.read('api', 'password')
key = encryption.get_key(password, get_salt())
message_decoded = encryption.decrypt(key, self.data.ciphertext)
push_data = json.loads(message_decoded.decode(settings.read('general', 'encoding')))
for i, value in enumerate(self.pushData):
if value in push_data:
setattr(self.data, value, push_data[value])
else:
setattr(self.data, value, '')
def get_video_attrs(html, removeLongResult=True):
"""
get video attributes from html
"""
result = {}
# get video id and description
regex = 'yt\-lockup\-title.*?href.*?watch\?v\=(.*?[^\"]+)'
regex += '.*? title\=\"(.*?[^\"]+)'
temp = re.findall(regex, html)
if len(temp) and len(temp[0]) == 2:
result['id'] = temp[0][0]
result['title'] = html_unescape(temp[0][1].decode('utf-8'))
# length
length_regex = 'video\-time.*?\>([^\<]+)'
temp = re.findall(length_regex, html)
if len(temp) > 0:
result['length'] = temp[0].strip()
# uploader
upl_regex = 'yt\-lockup\-byline.*?\>.*?\>([^\<]+)'
temp = re.findall(upl_regex, html)
if len(temp) > 0:
result['uploader'] = temp[0].strip()
# time ago
time_regex = 'yt\-lockup\-meta\-info.*?\>.*?\>([^\<]+).*?([0-9\,]+)'
temp = re.findall(time_regex, html)
if len(temp) and len(temp[0]) == 2:
result['time'] = temp[0][0]
result['views'] = temp[0][1]
# thumbnail
if 'id' in result:
thumb = 'http://img.youtube.com/vi/%s/0.jpg' % result['id']
result['thumb'] = thumb
else:
return None
# Description
desc_regex = 'yt-lockup-description.*?>(.*?)<'
temp = re.findall(desc_regex, html)
if len(temp) > 0:
result['description'] = temp[0]
else:
result['description'] = ''
# check if all items present. If not present, usually some problem in parsing
if len(result) != 8:
return None
# check length
if removeLongResult and extends_length(result['length'], 20 * 60):
return None
# return
result['get_url'] = '/g?url=' + encode_data(
get_key(), id=result['id'],
title=result['title'], length=result['length']
)
result['stream_url'] = result['get_url'].replace('/g?', '/stream?', 1)
return result
def retrieve_key(password, path):
keymatter = ''
try:
f = open(path, 'r')
keymatter = f.read()
f.close()
except IOError:
keymatter = make_key(password)
f = open(path, 'w')
f.write(keymatter)
f.close()
return get_key(password, keymatter)
def retrieve_key(password, path):
keymatter = ''
try:
f = open(path, 'r')
keymatter = f.read()
f.close()
except IOError:
keymatter = make_key(password)
f = open(path, 'w')
f.write(keymatter)
f.close()
return get_key(password, keymatter)
def get_suggestions(vid_id, get_url_prefix='/api/v1'):
url = "https://www.youtube.com/watch?v=" + vid_id
raw_html = open_page(url)
area_of_concern_regex = r'<div class=\"watch-sidebar-section\"(.*?)<div id=\"watch7-hidden-extras\"'
area_of_concern = ' '.join(re.findall(area_of_concern_regex, raw_html, re.DOTALL))
videos_html_regex = r'class=\"video-list-item.*?a href=\"/watch\?v=(.*?)\" class.*? class=\"title.*?>(.*?)</span>' \
r'.*?Duration: (.*?)\..*?<span class=\"g-hovercard.*?>(.*?)</span>.*?view-count\">(.*?) ' \
r'views.*?<li '
videos_html = re.findall(videos_html_regex, area_of_concern, re.DOTALL)
ret_list = []
for video in videos_html:
_id = video[0]
if '&list=' in _id:
continue
title = video[1].strip('\n\t ')
duration = video[2]
uploader = video[3]
views = video[4]
get_url = get_url_prefix + '/g?url=' + encode_data(get_key(), id=_id, title=title, length=duration)
stream_url = get_url.replace('/g?', '/stream?', 1)
suggest_url = get_url.replace('/g?', '/suggest?', 1)
if extends_length(duration, 20*60):
continue
ret_list.append(
{
"id": _id,
"title": html_unescape(title.decode('utf-8')),
"length": duration,
"uploader": uploader,
"thumb": 'http://img.youtube.com/vi/%s/0.jpg' % _id,
"get_url": get_url,
"stream_url": stream_url,
"views": views,
"suggest_url": suggest_url
}
)
return ret_list
def get_trending_videos(html):
"""
Get trending youtube videos from html
"""
regex = '<tr.*?data-video-id="(.*?)".*?src="(.*?)".*?<a cl.*?>(.*?)</a>.*?by.*?>(.*?)</a>.*?<span .*?>(.*?)</'
raw_results = re.findall(
regex, html,
re.DOTALL)[:int(environ.get('PLAYLIST_VIDEOS_LIMIT', 100))]
vids = []
for raw_result in raw_results:
try:
url = 'https://www.youtube.com/watch?v=' + raw_result[0]
html = open_page(url)
vids.append({
'id':
raw_result[0],
'thumb':
'https://img.youtube.com/vi/{0}/0.jpg'.format(raw_result[0]),
'title':
html_unescape(raw_result[2].strip().decode('utf-8')),
'uploader':
raw_result[3].decode('utf8'),
'length':
raw_result[4],
'views':
get_views(html),
'get_url':
encode_data(get_key(),
id=raw_result[0],
title=raw_result[2].strip(),
length=raw_result[4]),
'description':
html_unescape(get_description(html))
})
except Exception as e:
logger.info(
'Getting trending video failed. Message: %s, Video: %s' %
(str(e), raw_result[0]))
return vids
def get_suggestions(vid_id, get_url_prefix='/api/v1'):
url = "https://www.youtube.com/watch?v=" + vid_id
raw_html = open_page(url)
area_of_concern = ' '.join(
area_of_concern_regex.findall(raw_html, re.DOTALL))
videos_html = videos_html_regex.findall(area_of_concern, re.DOTALL)
ret_list = []
for video in videos_html:
try:
_id = single_video_regex['id'].findall(video)[0]
if '&list=' in _id:
continue
title = single_video_regex['title'].findall(video)[0]
duration = single_video_regex['duration'].findall(video)[0]
uploader = single_video_regex['uploader'].findall(video)[0]
views = single_video_regex['views'].findall(video)[0]
get_url = get_url_prefix + '/g?url=' + encode_data(
get_key(), id=_id, title=title, length=duration)
stream_url = get_url.replace('/g?', '/stream?', 1)
suggest_url = get_url.replace('/g?', '/suggest?', 1)
ret_list.append({
"id": _id,
"title": html_unescape(title.decode('utf-8')),
"length": duration,
"uploader": uploader,
"thumb": 'https://img.youtube.com/vi/%s/0.jpg' % _id,
"get_url": get_url,
"stream_url": stream_url,
"views": views,
"suggest_url": suggest_url
})
except Exception:
print('Error while getting suggestion at video \n' + video)
traceback.print_exc()
return ret_list
def get_key(self, key_name):
return encryption.get_key(key_name, self.get_token(), True)
def test_get_key_bad(self, symm_key):
symm_keys = self.ring.encrypt(symm_key)
bad_privkey = asymmetric.gen_keypair().privkey
got_symm_key = encryption.get_key(symm_keys, bad_privkey)
self.assertIsNone(got_symm_key)
def prompt_userinfo():
master_password, signing_password = prompt_password()
human_container_name, fs_container_name, api_token = get_dccinfo(master_password, signing_password)
password_data = read_passwd(api_token, fs_container_name, signing_password)
return ( get_key(master_password, password_data['encryption_key']), get_key(signing_password, password_data['signing_key']), api_token, human_container_name, fs_container_name )
cr_list = layer_decryption(Cr_byte_stream,
key,
en_rank,
Q=Qc,
dc_func=huffman_to_cdc,
ac_func=huffman_to_cac,
alpha=alpha)
print("解密完成！合并8*8矩阵...")
y = loadimage.img_merge(y_list, shape=shape[:2])
cb = loadimage.img_merge(cb_list, shape=shape[:2])
cr = loadimage.img_merge(cr_list, shape=shape[:2])
print("合并8*8矩阵成功！")
print("YCbCr图像转bgr图像...")
img = loadimage.get_bgr(y, cb, cr)
print("图像解密完成！大小为：", img.shape)
image = Image.fromarray(img)
image.show()
return img[:shape[0], :shape[1]]
if __name__ == "__main__":
read_path = "data/encryption.jpg"
key_len = 64
en_rank = 2
key = get_key(key_len)
wrong_key = get_key(key_len)
print("key:", key)
print("wrong key:", wrong_key)
img = jpeg_decryption(read_path, key, en_rank, alpha=alpha)
img2 = jpeg_decryption(read_path, wrong_key, en_rank, alpha=alpha)
