def payload_encryption_test():
password = b'testpwd'
payload = {'ccnum': '1111222233334444', 'expdate': '09/13/2018', 'cvc': '123', 'notes': 'adding user notes'}
salt = Encrypt.generate_salt()
print('ENCRYPT\TEST: salt: ', salt)
sym_key_box = Encrypt.generate_key(password, salt)
print('ENCRYPT\TEST: sym_key_box: ', sym_key_box)
sym_key = Encrypt.decrypt_key(sym_key_box, password, salt)
print('ENCRYPT\TEST: sym_key: ', sym_key)
# Payload encryption (encrypt the payload)
json_payload_string = json.dumps(payload)
print('JSON PAYLOAD:', json_payload_string)
encrypted_payload = Encrypt.encrypt_payload(sym_key, json_payload_string.encode())
print('ENCRYPT\TEST: encrypted_payload: ', encrypted_payload)
decrypted_payload = Encrypt.decrypt_payload(sym_key, encrypted_payload)
print('ENCRYPT\TEST: decrypted_payload: ', decrypted_payload)
payload_dict = json.loads(decrypted_payload)
print(payload_dict)
print(payload_dict["ccnum"])
print(payload_dict["expdate"])
print(payload_dict["cvc"])
print(payload_dict["notes"])
def searchbyName(self, name):
encrypt = Encrypt()
text_dir = {
"hlpretag": "<span class=\"s-fc7\">",
"hlposttag": "</span>",
"s": name,
"type": "1",
"offset": "0",
"total": "true",
"limit": "30",
"csrf_token": ""
}
text = str(text_dir)
data = encrypt.getParamsAndSecKey(text)
searchUrl = 'https://music.163.com/weapi/cloudsearch/get/web?csrf_token='
try:
response = requests.post(url=searchUrl,
data=data,
headers=self.headers)
response.raise_for_status()
response.encoding = 'utf-8'
return response.json()
except Exception as err:
print(err)
return '请求异常'
def post(self):
clue = self.request.get('clue')
mobileNumber = "+44" + self.request.get('mobilenumber')
query = PasswordStore.query(
ndb.AND(
PasswordStore.clue == clue,
PasswordStore.mobileNumber == mobileNumber,
PasswordStore.confirmed == 1)).order(-PasswordStore.created)
result = query.fetch(1)
if result:
encrypt = Encrypt()
#logging.info('found: ' + clue + " - " + mobileNumber)
sms = SendSMS()
sms.sendPassword(
mobileNumber,
encrypt.decryptString(result[0].encryptedPassword,
mobileNumber))
#else:
#logging.info('not found: ' + clue + " - " + mobileNumber)
template_values = {'nav': 'retrieve'}
template = JINJA_ENVIRONMENT.get_template('templates/success.html')
self.response.write(template.render(template_values))
class TestDecrypt(unittest.TestCase):
def setUp(self):
self.encrypt_instance = Encrypt()
self.decrypt_instance = Decrypt()
def test_can_load_private_key(self):
private_key = self.decrypt_instance.load_privatekey_from_file()
self.assertTrue(private_key)
def test_can_decrypt_single_value(self):
self.encrypt_instance.load_publickey_from_file()
self.decrypt_instance.load_privatekey_from_file()
card_number = "5001222244446666"
encrypted_card_number = self.encrypt_instance.encrypt_value(card_number)
decrypted_card_number = self.decrypt_instance.decrypt_value(
encrypted_card_number)
self.assertEqual(card_number, decrypted_card_number)
def test_can_apply_full_decrypt(self):
number = "5001222244446666"
holder = "Teste Ferreira da Silva"
cvv = "988"
encrypted_card_data = encrypt_card_data(holder, number, cvv)
enc_holder = encrypted_card_data['holder']
enc_number = encrypted_card_data['number']
enc_cvv = encrypted_card_data['cvv']
decrypted_card_data = decrypt_card_data(enc_holder, enc_number, enc_cvv)
self.assertEqual(number, decrypted_card_data['number'])
self.assertEqual(holder, decrypted_card_data['holder'])
self.assertEqual(cvv, decrypted_card_data['cvv'])
def index():
print('Opening index/login')
# Wipe session on opening
session.pop('username', None)
if request.method == 'POST':
user = request.form['username']
pwd = request.form['password']
# TODO: Session validation, password shouldn't be stored anywhere
try:
symmetric_box = base64.b64decode(db.get_symmetric_box(user))
salt = base64.b64decode(db.get_salt(user))
except:
print('SERVER/LOG: Username not found')
return redirect("/")
if Encrypt.decrypt_key(symmetric_box, pwd.encode(), salt) == -1:
print('SERVER/LOG: Incorrect password')
return redirect("/")
print('SERVER/LOG: Login OK')
session['symkey'] = Encrypt.decrypt_key(symmetric_box, pwd.encode(),
salt)
session['username'] = request.form['username']
Logger.log("Login from " + session['username'])
return redirect('/cards')
return render_template('login.html')
def get(self):
if isDev(self.request.host):
logging.info("creating test password records")
for i in xrange(1, 11):
created = datetime.now() - timedelta(days=i)
mobileNumber = "+" + str(447700000000 + i)
clue = "clue" + str(i)
password = "******" + str(i)
encrypt = Encrypt()
e = encrypt.encryptString(password, mobileNumber)
passwordStorerecord = PasswordStore()
passwordStorerecord.clue = clue
passwordStorerecord.mobileNumber = mobileNumber
passwordStorerecord.encryptedPassword = e
passwordStorerecord.confirmed = random.choice([0, 1])
passwordStorerecord.created = created
passwordStorerecord.put()
logging.info("creating test verification records")
for i in xrange(1, 11):
created = datetime.now() - timedelta(days=i)
verificationRecord = Verification()
verificationRecord.action = random.choice(['delete', 'add'])
verificationRecord.confirmed = random.choice([0, 1])
verificationRecord.passwordStoreId = 1000 + i * 17
verificationRecord.created = created
verificationRecord.put()
self.response.write("done")
logging.warning("Tried to activate CleanUpTest not in dev")
def test_encryption():
# Define intputs to check
mobile = "+447740193397"
password_input = "456"
password_encrypted = "LfrpS0GQHWrK7Bf3hymo2lY53xZVcIxthjTG92E5s97DpBgwIq0le5CkwxS5gy/r"
verification_id_input = "5240822173794304"
verification_id_encrypted = "5RCQVvDLFeIkbOKUkXq4xUfLOUJbF5piAtoLRtvFKhUbtJvvO7wV9cQXhtsQj5jq"
# Create test object
encrypt = Encrypt()
# Test
print('Test that a key has been loaded')
assert len(encrypt.key) > 10
# Test
print('test encryption without a salt')
e = encrypt.encryptString(verification_id_input)
assert verification_id_encrypted == e
# Test
print('test encryption with a salt')
e = encrypt.encryptString(password_input, mobile)
assert password_encrypted == e
print("Success")
def add_peer_cert(self, cert: str) -> bool:
try:
self.peer_cert = load_pem_x509_certificate(str.encode(cert),
default_backend())
Encrypt.verify_key_chain(self.peer_cert)
return True
except:
traceback.print_exc()
return False
def editEntry(ow, ou, op, nw, nu, np):
"""Update database with new data for specific entry."""
encryptObj = Encrypt()
nw = encryptObj.encrypt(nw)
nu = encryptObj.encrypt(nu)
np = encryptObj.encrypt(np)
dbq.updateEntry(ow, ou, op, nw, nu, np)
def loadMethod(self):
if os.path.exists("./code.txt"):
f = open('./code.txt', 'r')
code = f.readline()
self.e = Encrypt()
self.e.setCode(code)
self.displayText["text"] = "code: " + self.e.getCode()
else:
self.displayText["text"] = "Load denied!!"
def updateFile(self, filepath, contents, organisation, password):
# self function can be used when the user chooses to save their work
# get the key for the provided organisation
key = self.getOrganisationKey(organisation, password)
enc = Encrypt(key)
encrypted_file = open(filepath, 'wb')
encrypted_contents = enc.encrypt_string(contents)
encrypted_file.write(encrypted_contents)
encrypted_file.close()
def __init__(self, IP, port):
self.__IP = IP
self.__port = port
self.__add = (self.__IP, self.__port)
self.__sock = None
self.__isBusy = False
self.__encryption = Encrypt()
self.lock = threading.Lock()
self.image = None
self.text = None
def readFile(self, filepath, organisation, password):
# get the key for the provided organisation
key = self.getOrganisationKey(organisation, password)
enc = Encrypt(key)
encrypted_file = open(filepath, 'rb')
encrypted_contents = encrypted_file.read()
encrypted_file.close()
decrypted_contents = enc.decrypt_string(encrypted_contents)
return decrypted_contents
def test():
p1 = 790383132652258876190399065097
q1 = 662503581792812531719955475509
p2 = 656917682542437675078478868539
q2 = 1263581691331332127259083713503
n1 = p1 * q1
n2 = p2 * q2
ciphertext1 = Encrypt("attack", n1, 2)
ciphertext2 = Encrypt("attack", n2, 2)
message = DecipherHastad(ciphertext1, n1, ciphertext2, n2)
print(message)
def post(self):
# Step 1 - retrieve and verify user input
clue = self.request.get('clue').strip()
mobileNumber = "+44" + self.request.get('mobilenumber').strip()
# Step 2 - get the password record
query = PasswordStore.query(
ndb.AND(PasswordStore.clue == clue, PasswordStore.mobileNumber ==
mobileNumber)).order(-PasswordStore.created)
passwordStorerecord = query.fetch(1)
if passwordStorerecord:
#logging.info('found: ' + clue + " - " + mobileNumber)
passwordStorerecord = passwordStorerecord[0]
passwordStoreId = passwordStorerecord.key.id(
) # the id of the record just created
# Step 3 - store verification record
verificationRecord = Verification()
verificationRecord.action = 'delete'
verificationRecord.confirmed = 0
verificationRecord.passwordStoreId = passwordStoreId
verificationRecord.put()
verificationRecordId = verificationRecord.key.id(
) # the id of the record just created
logging.info('storing verification id: ' +
str(verificationRecordId))
# Step 4 - send SMS with encrypted verification
encrypt = Encrypt()
i = str(verificationRecordId)
e = encrypt.encryptString(i)
d = encrypt.decryptString(e)
sms = SendSMS()
sms.verifyDelete(mobileNumber, e)
logging.info('sending delete verification: ' + " - " + i + " - " +
e + " - " + d)
#else:
#logging.info('not found: ' + clue + " - " + mobileNumber)
# Step 5 - render reply
template_values = {'nav': 'delete', 'id': e}
template = JINJA_ENVIRONMENT.get_template(
'templates/check_phone_success.html')
self.response.write(template.render(template_values))
def __init__(self, IP, port, retryTimes=3, timeout=10):
self.__IP = IP
self.__port = port
self.__add = (self.__IP, self.__port)
self.__sock = None
self.__isBusy = False
self.__errLimit = retryTimes
self.__timeout = timeout
self.__encryption = Encrypt()
self.image = None
self.text = None
def lm(self):
# 先測試檔案是否存在
if os.path.exists("./code.txt"):
# 檔案存在就進行載入工作
f = open('./code.txt', 'r')
code = f.readline()
self.e = Encrypt(code)
s = str("".join(self.e.code))
m = "密碼表： " + s
self.app.dt["text"] = m
else:
m = "無法載入！"
self.app.dt["text"] = m
def post(self):
# Step 1 - retrieve and verify user input
clue = self.request.get('clue').strip()
mobileNumber = "+44" + self.request.get('mobilenumber').strip()
password = self.request.get('pass').strip()
# Step 2 - store the password
encrypt = Encrypt()
e = encrypt.encryptString(password, mobileNumber)
passwordStorerecord = PasswordStore()
passwordStorerecord.clue = clue
passwordStorerecord.mobileNumber = mobileNumber
passwordStorerecord.encryptedPassword = e
passwordStorerecord.confirmed = 0
passwordStorerecord.put()
passwordStoreId = passwordStorerecord.key.id(
) # the id of the record just created
logging.info('storing password id: ' + str(passwordStoreId))
# Step 3 - store verification record
verificationRecord = Verification()
verificationRecord.action = 'add'
verificationRecord.confirmed = 0
verificationRecord.passwordStoreId = passwordStoreId
verificationRecord.put()
verificationRecordId = verificationRecord.key.id(
) # the id of the record just created
logging.info('storing verification id: ' + str(verificationRecordId))
# Step 4 - send SMS with encrypted verification
i = str(verificationRecordId)
e = encrypt.encryptString(i)
d = encrypt.decryptString(e)
sms = SendSMS()
sms.verifyPasswordAdd(mobileNumber, e)
logging.info('sending verification: ' + " - " + i + " - " + e + " - " +
d)
# Step 5 - render reply
template_values = {'nav': 'store', 'id': e}
template = JINJA_ENVIRONMENT.get_template(
'templates/check_phone_success.html')
self.response.write(template.render(template_values))
def __init__(self, IP, port):
self.__IP = IP
self.__port = port
self.__add = (self.__IP, self.__port)
self.__encryption = Encrypt()
self.image = None
self.text = None
self.__s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.__s.bind((self.__IP, self.__port))
self.__s.listen(2)
self.__cli = None
self.lock = threading.Lock()
def pushEntry(web, user, passwd):
"""Encrypt data and send to database."""
encryptObj = Encrypt()
if web != '':
web = encryptObj.encrypt(web)
user = encryptObj.encrypt(user)
passwd = encryptObj.encrypt(passwd)
dbq.addEntry(web, user, passwd)
return True
else:
return False
def pushSignup(password, question, answer):
"""Hash and encrypt all data and send to database."""
encryptObj = Encrypt()
if passwordRules(password) and answer != '':
password = hashIt(password)
question = encryptObj.encrypt(question)
answer = encryptObj.encrypt(answer)
key = dbq.selectKey()[0]
dbq.updateMasterInfo(password[0], password[1], question, answer)
return True
else:
return False
def test():
# Example usage with common prime p and different second primes q1 and q2
p = 101
q1 = 1829897073254110
q2 = 1000000007
first_modulo = p * q1
second_modulo = p * q2
first_exponent = 239
second_exponent = 17
first_ciphertext = Encrypt("attack", first_modulo, first_exponent)
second_ciphertext = Encrypt("wait", second_modulo, second_exponent)
print(
DecipherCommonDivisor(first_ciphertext, first_modulo, first_exponent,
second_ciphertext, second_modulo,
second_exponent))
def get(self):
template = 'error.html'
template_values = {'nav': 'none'}
if (self.request.get('id')):
encrypt = Encrypt()
verificationId = int(encrypt.decryptString(self.request.get('id')))
verificationRecord = Verification.get_by_id(verificationId)
logging.info(verificationRecord)
if verificationRecord:
passwordStorerecord = PasswordStore.get_by_id(
verificationRecord.passwordStoreId)
if passwordStorerecord:
# Handle the add verification step
if verificationRecord.action == 'add':
passwordStorerecord.confirmed = 1
passwordStorerecord.put()
verificationRecord.key.delete()
logging.info(
'Updated records - verification (deleted) and passwordStore (updated)'
)
template = 'success.html'
# Handle the delete verification step
if verificationRecord.action == 'delete':
passwordStorerecord.key.delete()
verificationRecord.key.delete()
logging.info(
'Updated records - verification (deleted) and passwordStore (deleted)'
)
template = 'success.html'
else:
logging.info(
'Failed to retrieve Verification record id: ' +
str(verificationId))
else:
logging.info(
'Failed to retrieve PasswordStore record id: ' +
str(verificationRecord.passwordStoreId))
else:
template = 'error.html'
template = JINJA_ENVIRONMENT.get_template('templates/' + template)
self.response.write(template.render(template_values))
def secCmp(answer):
"""Compare security question answer against database answer."""
if Encrypt().secQCmp(answer):
return True
else:
return False
def __init__(self, builtinDataDir, serverCfg, encryptCfg, crawlerCfg):
self.encryptTool = Encrypt(encryptCfg)
self.dao = DAO(serverCfg.get('database'))
self.db = CrawlerDB(self.dao, builtinDataDir)
self.crawlerQueryBuilder = self.__initialize_crawler__(
builtinDataDir, crawlerCfg)
self.worker = BlockingScheduler()
def attempt_login(self) -> str:
if not self.name or not self.password:
print("Enter name and password")
return ""
payload = {
"name": self.name,
"password": self.password,
}
ciphertext = Encrypt.get_root_pub_key().encrypt(
json.dumps(payload).encode('utf-8'),
padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None))
data = {
"payload": base64.b64encode(ciphertext).decode('utf-8'),
"public_key": self.pub_key,
}
try:
resp = requests.post(LoginHandler.AUTH_SERVER_URL + '/verify',
data=json.dumps(data))
except Exception: # This is the correct syntax
traceback.print_exc()
print("Auth Server Connection Error")
return ""
if resp.status_code != 200:
print("Unauthorized")
return ""
return resp.text.strip()
def cards():
print('SERVER/LOG: Opening cards page')
user_cards = []
# TODO: Decryption logic for cards
if request.method == 'POST':
print("SERVER/LOG: Headers:\n", request.headers)
print("SERVER/LOG: Data:\n", request.data)
try:
print("SERVER/LOG: Form:\n", request.form['cardId'])
db.delete_card(request.form['cardId'])
return redirect("/cards")
except:
print("SERVER/FAIL: Unable to edit/delete card:\n")
try:
if 'username' in session:
print('SERVER/LOG: Logged in as', session['username'])
try:
# payloads = db.get_payloads(session['username'])
id_payloads = db.get_id_payload(session['username'])
print(id_payloads)
for payload in id_payloads:
user_cards.append((json.loads(
Encrypt.decrypt_payload(
session['symkey'],
base64.b64decode(payload["payload"]))),
payload["id"]))
except:
print('SERVER/FAIL: No cards found for', session['username'])
else:
return redirect("/")
except:
return redirect("/")
return render_template('cards.html', user_cards=user_cards)
def getEntries():
"""Get rows of encrypted data and decrypted data for gui. The encrypted
data is used in other functions for the gui buttons."""
encryptObj = Encrypt()
rows = dbq.selectEntries()
decryptedRows = [[] for i in range(len(rows))]
i = 0
for row in rows:
web = encryptObj.decrypt(row[0])
user = encryptObj.decrypt(row[1])
passwd = encryptObj.decrypt(row[2])
decryptedRows[i].extend((web, user, passwd))
i += 1
return (decryptedRows, rows)
def register():
print('SERVER/LOG: Opening registration page')
if request.method == 'POST':
user = request.form['username']
email = request.form['email']
pwd = request.form['password']
create_date = str(timestamp)
print('SERVER/LOG: Account created by ', user, ' at ', create_date)
# TODO: Server side logic to salt and encrypt password
salt = Encrypt.generate_salt()
session_key = Encrypt.generate_session_key()
sym_key_box = Encrypt.generate_key(pwd.encode(), salt)
values = (user, email, create_date, base64.b64encode(salt),
base64.b64encode(session_key), base64.b64encode(sym_key_box))
db.insert_user(values)
return render_template('register.html')
def loadMethod(self):
if os.path.exists("./code.txt"):
f = open('./code.txt', 'r')
code = f.readline()
self.e = Encrypt()
self.e.setCode(code)
self.displayText["text"] = "code: " + self.e.getCode()
else:
self.displayText["text"] = "Load denied!!"
def importFile(self, filepath, organisation, password, savepath=None):
# first check if the organisation is is a new one
if self.isNewOrganisation(organisation):
self.createOrganisation(organisation, password)
# read the file they provided, encrypt the contents and save it
original_file = open(filepath, 'r')
original_contents = original_file.read()
original_file.close()
# load the key for the organisation
key = self.getOrganisationKey(organisation, password)
enc = Encrypt(key)
encrypted_contents = enc.encrypt_string(original_contents)
savepath = savepath + '.enc' if savepath == None else savepath
encrypted_file = open(savepath, 'wb')
encrypted_file.write(encrypted_contents)
encrypted_file.close()
def lm(self):
if os.path.exists("./code.txt"):
f = open('./code.txt', 'r')
code = f.readline()
self.e = Encrypt(code)
s = str("".join(self.e.code))
m = "code: " + s
self.dt["text"] = m
else:
m = "Load denied!!"
self.dt["text"] = m
def main(argv, gateway=GATEWAY, uuid=UUID, f_hex=HEX):
help_msg = argv[0] + ' -g <gateway> -u <uuid>'
try:
opts, args = getopt.getopt(argv[1:], "hxg:u:", ["gateway=", "uuid="])
except getopt.GetoptError:
print help_msg
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print help_msg
sys.exit()
elif opt in ("-g", "--gateway"):
gateway = arg
elif opt in ("-u", "--uuid"):
uuid = arg
elif opt in ("-x", "--hex"):
f_hex = True
register = REQ_PHONE_ID.format(uuid=uuid)
print register
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((gateway, TCP_PORT))
s.send(register)
data = s.recv(BUFFER_SIZE)
print '[HANDSHAKE]', data
if len(data) != 11:
print 'Incorrect message'
sys.exit(1)
e = Encrypt(uuid=uuid, phone_id=data[4])
while True:
data = s.recv(BUFFER_SIZE)
if not data or len(data) < 1:
s.close()
print 'Disconnected'
sys.exit()
print "[RECV %s]" % (strftime("%H:%M:%S", localtime())), len(data), \
remove_newline(data[:2] + e.decrypt(data))
if f_hex:
print_hex(data, True)
def __init__(self, master=None):
Frame.__init__(self, master)
self.grid()
self.createWidgets()
self.e = None
self.userinput = ""
self.result = ""
self.isRecv = False
self.isAuth = False
self.recvKey = ""
self.e = Encrypt()
self.displayText["text"] = self.e
print("Current key is: " + self.e.key)
class EncryptGUI(Frame):
def __init__(self,master = None):
Frame.__init__(self,master)
self.grid()
self.createWidgets()
self.e = None
self.userinput = ""
self.result = ""
def createWidgets(self):
self.it = Label(self)
self.it["text"] = "Input:"
self.it.grid(row = 0, column = 0)
self.ifd = Entry(self)
self.ifd["width"] = 60
self.ifd.grid(row = 0, column = 1,
columnspan = 6)
self.ot = Label(self)
self.ot["text"] = "Output:"
self.ot.grid(row = 1,column = 0)
self.ofd = Entry(self)
self.ofd["width"] = 60
self.ofd.grid(row = 1, column = 1,
columnspan = 6)
self.nb = Button(self)
self.nb["text"] = "New"
self.nb.grid(row = 2, column = 0)
self.nb["command"] = self.nm
self.lb = Button(self)
self.lb["text"] = "Load"
self.lb.grid(row = 2, column = 1)
self.lb["command"] = self.lm
self.sb = Button(self)
self.sb["text"] = "Save"
self.sb.grid(row = 2, column = 2)
self.sb["command"] = self.sm
self.eb = Button(self)
self.eb["text"] = "Encode"
self.eb.grid(row = 2, column = 3)
self.eb["command"] = self.em
self.db = Button(self)
self.db["text"] = "Decode"
self.db.grid(row = 2, column = 4)
self.db["command"] = self.dm
self.cb = Button(self)
self.cb["text"] = "Clear"
self.cb.grid(row = 2, column = 5)
self.cb["command"] = self.cm
self.cb2 = Button(self)
self.cb2["text"] = "Copy"
self.cb2.grid(row = 2, column = 6)
self.cb2["command"] = self.cm2
self.dt = Label(self)
m = "something happend"
self.dt["text"] = m
self.dt.grid(row = 3, column = 0,
columnspan = 7)
def nm(self):
self.e = Encrypt()
self.dt["text"] = self.e
def lm(self):
if os.path.exists("./code.txt"):
f = open('./code.txt', 'r')
code = f.readline()
self.e = Encrypt(code)
s = str("".join(self.e.code))
m = "code: " + s
self.dt["text"] = m
else:
m = "Load denied!!"
self.dt["text"] = m
def sm(self):
if self.e == None:
m = "It can not save!!"
self.dt["text"] = m
else:
f = open('./code.txt','w')
f.write("".join(self.e.code))
f.close()
self.dt["text"] = "It's Done."
def em(self):
self.userinput = self.ifd.get()
if self.userinput == "":
m = "No input string!!!"
self.dt["text"] = m
else:
if self.e == None:
m = "No encrypt object!!"
self.dt["text"] = m
else:
s = self.userinput
r = self.e.toEncode(s)
self.result = r
self.ofd.delete(0, 200)
self.ofd.insert(0, r)
m = "Encoding success!!"
self.dt["text"] = m
def dm(self):
self.userinput = self.ifd.get()
if self.userinput == "":
m = "No input string!!"
self.dt["text"] = m
else:
if self.e == None:
m = "No encrypt object!!"
self.dt["text"] = m
else:
s = self.userinput
r = self.e.toDecode(s)
self.result = r
self.ofd.delete(0, 200)
self.ofd.insert(0, r)
m = "Decoding success!!"
self.dt["text"] = m
def cm(self):
self.e = None
self.userinput = ""
self.result = ""
self.ifd.delete(0, 200)
self.ofd.delete(0,200)
self.dt["text"] = "Clear all!!!"
def cm2(self):
if self.result == "":
m = "Copy denied!!"
self.dt["text"] = m
else:
self.cliphorad_clear()
r = self.result
self.cliphorad_clear(r)
m = "It is copied."
self.dt["text"] = m
print "Created Work Dir: %s" % fileDirectory
else:
print "Work Dir: %s" % fileDirectory
desktopFile = glob.glob1(path, "*.desktop")
for dpFile in desktopFile:
print "copying %s --> /etc/xdg/autostart" % dpFile
os.system("cp %s /etc/xdg/autostart" % dpFile)
pyFile = glob.glob1(path, "*.py")
for pyFile in pyFile:
print "copying %s --> /usr/bin" % pyFile
os.system("cp %s /usr/bin" % pyFile)
mail = raw_input("Your Mail: ")
encryp = Encrypt()
password = raw_input("Your Mail Password: "******"\nTwitter status is read and command is sent to the computer\nTwitter Commands: PC:Close and PC:Open"
twitter_name = raw_input("Twitter Name: ")
twitter_file = open("%s/usernames" % fileDirectory, "w")
twitter_file.write("%s\n%s" % (mail, twitter_name))
twitter_file.close()
file = open("%s/wykey" % fileDirectory, "w")
file.write(pwd)
file.close()
user = os.listdir("/home/")
class EncryptGUI(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.grid()
self.createWidgets()
self.e = None
self.userinput = ""
self.result = ""
self.isRecv = False
self.isAuth = False
self.recvKey = ""
self.e = Encrypt()
self.displayText["text"] = self.e
print("Current key is: " + self.e.key)
def createWidgets(self):
self.inputText = Label(self)
self.inputText["text"] = "Input:"
self.inputText.grid(row=0, column=0)
self.inputField = Entry(self)
self.inputField["width"] = 80
self.inputField.grid(row=0, column=1, columnspan=6)
# self.outputText = Label(self)
# self.outputText["text"] = "Output:"
# self.outputText.grid(row=1, column=0)
# self.outputField = Entry(self)
# self.outputField["width"] = 50
# self.outputField.grid(row=1, column=1, columnspan=6)
# self.new = Button(self)
# self.new["text"] = "Load EncrytFunction"
# self.new.grid(row=2, column=0)
# self.new["command"] = self.newMethod
self.load = Button(self)
self.load["text"] = "Load from server"
self.load.grid(row=2, column=1)
self.load["command"] = self.loadMethod
self.save = Button(self)
self.save["text"] = "Save to Server"
self.save.grid(row=2, column=2)
self.save["command"] = self.saveMethod
self.encode = Button(self)
self.encode["text"] = "Encode"
self.encode.grid(row=2, column=3)
self.encode["command"] = self.encodeMethod
self.decode = Button(self)
self.decode["text"] = "Decode from files"
self.decode.grid(row=2, column=4)
self.decode["command"] = self.decodeMethod
self.clear = Button(self)
self.clear["text"] = "Clear"
self.clear.grid(row=2, column=5)
self.clear["command"] = self.clearMethod
self.copy = Button(self)
self.copy["text"] = "Copy"
self.copy.grid(row=2, column=6)
self.copy["command"] = self.copyMethod
self.auth = Button(self)
self.auth["text"] = "Auth"
self.auth.grid(row=2, column=7)
self.auth["command"] = self.authFromServer
self.displayText = Label(self)
self.displayText["text"] = "something will happen."
self.displayText.grid(row=3, column=0, columnspan=7)
def newMethod(self):
self.e = Encrypt()
self.displayText["text"] = self.e
def loadMethod(self):
if os.path.exists("./data/tag.txt"):
f = open('./data/tag.txt', 'r')
code = f.readline()
#self.e = Encrypt()
self.e.setTag(code)
self.displayText["text"] = "Tag includeed!"
if os.path.exists("./data/ciphertext.txt"):
f = open('./data/ciphertext.txt', 'r')
code = f.readline()
self.e.setCiphertext(code)
self.displayText["text"] = "Ciphertext includeed!"
else:
self.displayText["text"] = "Load denied!!"
self.getCiphertextTag()
self.e.setKey(self.recvKey)
def saveMethod(self):
if self.e == None:
self.displayText["text"] = "No Encrypt object can save!!"
else:
f = open('./data/ciphertext.txt', 'w')
f.write(self.e.getCiphertext())
f.closed
f = open('./data/tag.txt', 'w')
f.write(self.e.getTag())
f.closed
self.displayText["text"] = "The code is saved."
self.sendCiphertextTag(self.e.getCiphertext(), self.e.getTag())
def encodeMethod(self):
self.userinput = self.inputField.get()
if self.userinput == "":
self.displayText["text"] = "No input string!!"
else:
if self.e == None:
self.displayText["text"] = "No encrypt object!!"
else:
self.result = self.e.toEncode(self.userinput)
self.displayText["text"] = "Encrypt successful!!"
def decodeMethod(self):
self.userinput = self.inputField.get()
if self.userinput == "":
if self.isRecv:
self.result = self.e.toDecode(self.e.ciphertext, self.e.tag)
self.displayText["text"] = self.result
else :
self.displayText["text"] = "No input string!!"
else:
if self.e == None:
self.displayText["text"] = "No encrypt object!!"
else:
self.result = self.e.toDecode(self.e.ciphertext, self.e.tag)
self.displayText["text"] = self.result
def clearMethod(self):
self.e = None
self.userinput = ""
self.result = ""
self.inputField.delete(0, 200)
#self.outputField.delete(0, 200)
self.displayText["text"] = "It's done."
def copyMethod(self):
if self.result == "":
self.displayText["text"] = "Copy denied!!"
else:
self.clipboard_clear()
self.clipboard_append(self.result)
self.displayText["text"] = "It is already copied to the clipboard."
def getCiphertextTag(self):
if self.isAuth:
TCP_IP = "140.118.155.49"
TCP_PORT = 9000
BUFFER_SIZE = 1024
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((TCP_IP, TCP_PORT))
with open('data/ciphertext.txt', 'wb') as f:
print 'file opened'
while True:
#print('receiving data...')
data = s.recv(BUFFER_SIZE)
print('data=%s', (data))
if not data:
f.close()
print 'file close()'
break
# write data to a file
f.write(data)
s.close()
print('Successfully get the ciphertext file, connection closed...')
TCP_PORT = 9001
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((TCP_IP, TCP_PORT))
with open('data/tag.txt', 'wb') as f:
print 'file opened'
while True:
#print('receiving data...')
data = s.recv(BUFFER_SIZE)
print('data=%s', (data))
if not data:
f.close()
print 'file close()'
break
# write data to a file
f.write(data)
s.close()
print('Successfully get the tag file, connection closed...')
self.isRecv = True
else :
self.displayText["text"] = "You don't have the right to use."
def sendCiphertextTag(self, s1, s2):
if self.isAuth:
s = socket.socket() # Create a socket object
host = '140.118.155.49' # Get local machine name
port = 9002 # Reserve a port for your service.
s.connect((host, port))
s.send(s1)
s.close()
print('Successfully send the ciphertext file, connection closed...')
s = socket.socket() # Create a socket object
host = '140.118.155.49' # Get local machine name
port = 9003 # Reserve a port for your service.
s.connect((host, port))
s.send(s2)
s.close()
print('Successfully send the tag file, connection closed...')
self.sendKeyToServer()
else :
self.displayText["text"] = "You don't have the right to use."
def authFromServer(self):
TCP_IP = "140.118.155.49"
TCP_PORT = 9004
BUFFER_SIZE = 1024
header = self.e.header
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((TCP_IP, TCP_PORT))
s.send(header)
data = s.recv(1024)
print(data)
if data != "Not Authenticated":
self.displayText["text"] = "Authenticated!!"
self.recvKey = data
self.isAuth = True
else :
self.displayText["text"] = "You are a bad guy!!"
s.close()
print("Current key is: " + self.e.key)
def sendKeyToServer(self):
s = socket.socket() # Create a socket object
host = '140.118.155.49' # Get local machine name
port = 9005 # Reserve a port for your service.
s.connect((host, port))
s.send(self.e.key)
msg = s.recv(1024)
s.close()
print(msg)
from encrypt import Encrypt
unchanged_sentence = raw_input('Type some words to encrypt\n')
our_encryptor = Encrypt()
encrypted_text = our_encryptor.encrypt( unchanged_sentence )
print encrypted_text
decrypted_message = our_encryptor.decrypt(encrypted_text)
if decrypted_message == unchanged_sentence:
print 'it worked'
print decrypted_message
def newMethod(self):
self.e = Encrypt()
self.displayText["text"] = self.e
class EncryptGUI(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.grid()
self.createWidgets()
self.e = None
self.userinput = ""
self.result = ""
def createWidgets(self):
self.inputText = Label(self)
self.inputText["text"] = "Input:"
self.inputText.grid(row=0, column=0)
self.inputField = Entry(self)
self.inputField["width"] = 50
self.inputField.grid(row=0, column=1, columnspan=6)
self.outputText = Label(self)
self.outputText["text"] = "Output:"
self.outputText.grid(row=1, column=0)
self.outputField = Entry(self)
self.outputField["width"] = 50
self.outputField.grid(row=1, column=1, columnspan=6)
self.new = Button(self)
self.new["text"] = "New"
self.new.grid(row=2, column=0)
self.new["command"] = self.newMethod
self.load = Button(self)
self.load["text"] = "Load"
self.load.grid(row=2, column=1)
self.load["command"] = self.loadMethod
self.save = Button(self)
self.save["text"] = "Save"
self.save.grid(row=2, column=2)
self.save["command"] = self.saveMethod
self.encode = Button(self)
self.encode["text"] = "Encode"
self.encode.grid(row=2, column=3)
self.encode["command"] = self.encodeMethod
self.decode = Button(self)
self.decode["text"] = "Decode"
self.decode.grid(row=2, column=4)
self.decode["command"] = self.decodeMethod
self.clear = Button(self)
self.clear["text"] = "Clear"
self.clear.grid(row=2, column=5)
self.clear["command"] = self.clearMethod
self.copy = Button(self)
self.copy["text"] = "Copy"
self.copy.grid(row=2, column=6)
self.copy["command"] = self.copyMethod
self.displayText = Label(self)
self.displayText["text"] = "something happened"
self.displayText.grid(row=3, column=0, columnspan=7)
def newMethod(self):
self.e = Encrypt()
self.displayText["text"] = self.e
def loadMethod(self):
self.displayText["text"] = "This is Load Button."
def saveMethod(self):
self.displayText["text"] = "This is Save Button."
def encodeMethod(self):
self.userinput = self.inputField.get()
if self.userinput == "":
self.displayText["text"] = "No input string!!"
else:
self.result = self.e.toEncode(self.userinput)
self.outputField.delete(0, 200)
self.outputField.insert(0, self.result)
self.displayText["text"] = "Encoding success!!"
def decodeMethod(self):
self.userinput = self.inputField.get()
if self.userinput == "":
self.displayText["text"] = "No input string!!"
else:
self.result = self.e.toDecode(self.userinput)
self.outputField.delete(0, 200)
self.outputField.insert(0, self.result)
self.displayText["text"] = "Decoding success!!"
def clearMethod(self):
self.displayText["text"] = "This is Clear Button."
def copyMethod(self):
self.displayText["text"] = "This is Copy Button."
from email.MIMEText import MIMEText
from email import Encoders
from encrypt import Encrypt
locale.setlocale(locale.LC_ALL, "tr_TR.UTF-8")
TIME = time.strftime("%X")
DATE = time.strftime("%d.%m.%Y")
DATETIME = DATE, TIME
MINUTE = int("30")
AMOUNT = int("2")
fileDirectory = "/tmp/whoyou"
VIDEO_X = "video0"
encryp = Encrypt()
key = open("%s/wykey" % fileDirectory).read()
openPass = encryp.xor(key, False)
MAIL_PASSWORD = encryp.decrypt(openPass)
MAIL = open("%s/usernames" % fileDirectory).readlines()[0]
tweet_user = open("%s/usernames" % fileDirectory).readlines()[1]
SUBJECT = "-*-whoyou-*-"
VALUEURL = "http://twitter.com/%s" % tweet_user # command: PC:Close and PC:Open
TEXT = """
Merhaba %s,\n%s tarhinde sisteminize giriş yapıldı.
Bilgisayarınız ile ilgili işlem yapmak için verdiğiniz adrese (%s) bir değer giriniz. Aksi halde bilgisayarınız açık kalacaktır.
İlgili görsellere "%s" dizininden bakabilirsiniz.""" % (MAIL.split("@")[0], DATETIME, VALUEURL, fileDirectory)
class EncryptGUI(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.grid()
self.createWidgets()
self.e = None
self.userinput = ""
self.result = ""
def createWidgets(self):
self.inputText = Label(self)
self.inputText["text"] = "Input:"
self.inputText.grid(row=0, column=0)
self.inputField = Entry(self)
self.inputField["width"] = 50
self.inputField.grid(row=0, column=1, columnspan=6)
self.outputText = Label(self)
self.outputText["text"] = "Output:"
self.outputText.grid(row=1, column=0)
self.outputField = Entry(self)
self.outputField["width"] = 50
self.outputField.grid(row=1, column=1, columnspan=6)
self.new = Button(self)
self.new["text"] = "New"
self.new.grid(row=2, column=0)
self.new["command"] = self.newMethod
self.load = Button(self)
self.load["text"] = "Load"
self.load.grid(row=2, column=1)
self.load["command"] = self.loadMethod
self.save = Button(self)
self.save["text"] = "Save"
self.save.grid(row=2, column=2)
self.save["command"] = self.saveMethod
self.encode = Button(self)
self.encode["text"] = "Encode"
self.encode.grid(row=2, column=3)
self.encode["command"] = self.encodeMethod
self.decode = Button(self)
self.decode["text"] = "Decode"
self.decode.grid(row=2, column=4)
self.decode["command"] = self.decodeMethod
self.clear = Button(self)
self.clear["text"] = "Clear"
self.clear.grid(row=2, column=5)
self.clear["command"] = self.clearMethod
self.copy = Button(self)
self.copy["text"] = "Copy"
self.copy.grid(row=2, column=6)
self.copy["command"] = self.copyMethod
self.displayText = Label(self)
self.displayText["text"] = "something happened"
self.displayText.grid(row=3, column=0, columnspan=7)
def newMethod(self):
self.e = Encrypt()
self.displayText["text"] = self.e
def loadMethod(self):
if os.path.exists("./code.txt"):
f = open('./code.txt', 'r')
code = f.readline()
self.e = Encrypt()
self.e.setCode(code)
self.displayText["text"] = "code: " + self.e.getCode()
else:
self.displayText["text"] = "Load denied!!"
def saveMethod(self):
if self.e == None:
self.displayText["text"] = "No Encrypt object can save!!"
else:
f = open('./code.txt', 'w')
f.write(self.e.getCode())
f.closed
self.displayText["text"] = "The code is saved."
def encodeMethod(self):
self.userinput = self.inputField.get()
if self.userinput == "":
self.displayText["text"] = "No input string!!"
else:
if self.e == None:
self.displayText["text"] = "No encrypt object!!"
else:
self.result = self.e.toEncode(self.userinput)
self.outputField.delete(0, 200)
self.outputField.insert(0, self.result)
self.displayText["text"] = "Encoding success!!"
def decodeMethod(self):
self.userinput = self.inputField.get()
if self.userinput == "":
self.displayText["text"] = "No input string!!"
else:
if self.e == None:
self.displayText["text"] = "No encrypt object!!"
else:
self.result = self.e.toDecode(self.userinput)
self.outputField.delete(0, 200)
self.outputField.insert(0, self.result)
self.displayText["text"] = "Decoding success!!"
def clearMethod(self):
self.e = None
self.userinput = ""
self.result = ""
self.inputField.delete(0, 200)
self.outputField.delete(0, 200)
self.displayText["text"] = "It's done."
def copyMethod(self):
if self.result == "":
self.displayText["text"] = "Copy denied!!"
else:
self.clipboard_clear()
self.clipboard_append(self.result)
self.displayText["text"] = "It is already copied to the clipboard."
def nm(self): self.e = Encrypt() self.dt["text"] = self.e
def main(argv, gateway=GATEWAY, uuid=UUID, f_hex=HEX):
q_gw_recv = Queue()
help_msg = argv[0] + "-h <host> -g <gateway> -u <uuid>"
local = HOST
try:
opts, args = getopt.getopt(argv[1:], "xh:g:u:", ["host", "gateway=", "uuid="])
except getopt.GetoptError:
print help_msg
sys.exit(2)
for opt, arg in opts:
if opt in ("-h", "--host"):
local = arg
elif opt in ("-g", "--gateway"):
gateway = arg
elif opt in ("-u", "--uuid"):
uuid = arg
elif opt == "-x":
f_hex = True
print "[VERSION]", __version__
print "[GATEWAY]", gateway, uuid
s = socket(AF_INET, SOCK_STREAM)
s.connect((gateway, TCP_PORT))
s.send(REQ_PHONE_ID.format(uuid=uuid))
data = s.recv(BUFFER_SIZE)
print "[HANDSHAKE]", data
if len(data) != 11:
print "Incorrect message"
sys.exit(1)
e = Encrypt(uuid=uuid, phone_id=data[6], only_compatible=ONLY)
t = Thread(target=listen_gateway, args=(s, q_gw_recv))
t.daemon = True
t.start()
host = socket(AF_INET, SOCK_STREAM)
host.bind((local, TCP_PORT))
host.listen(1)
print "[HOST]", local, TCP_PORT
conn, addr = host.accept()
conn.settimeout(TIMEOUT)
print "Connected by", addr
cnt = 0
while True:
try:
data = q_gw_recv.get(timeout=TIMEOUT)
dec = e.decrypt(data)
print "[RECV %s]" % (strftime("%H:%M:%S", localtime())), len(data), remove_newline(data[:2] + dec)
conn.sendall(data[:2])
# tm.sleep(0.5)
conn.sendall(data[2:])
if f_hex:
print_hex(data, True)
except Empty:
pass
try:
data = conn.recv(1024)
if REQ_UUID in data:
e.uuid = data[(data.index(REQ_UUID) + 6) :]
print "[ENC UUID]", e.uuid
if len(data) < 1:
print "[CLIENT] Disconnected"
conn, addr = host.accept()
conn.settimeout(TIMEOUT)
print "[CLIENT] Connected by", addr
continue
dec = e.decrypt(data)
print "[SENT %s]" % (strftime("%H:%M:%S", localtime())), len(data), remove_newline(data[:2] + dec)
s.sendall(data)
except timeout:
if cnt > 1000:
cnt = 0
print "tout"
conn.close()
