def main():
while True:
print "Choose from job"
print "1.Key Generation"
print "2.Encrytion"
print "3.Decryption"
print "4.Exit"
choice = sys.stdin.readline()
if (choice == '1\n'):
myKeyGenerator = keyGenerator()
myKeyGenerator.keyGen()
print "Key Generation Finished\n"
elif (choice == '2\n'):
encryptor = Encryption()
encryptor.encrypt()
print "Encryption Finished\n"
elif (choice == '3\n'):
decryptor = Decryption()
decryptor.decrypt()
print "Decryption Finished\n"
elif (choice == '4\n'):
break;
else:
print "invalid input"
choice = sys.stdin.readline()
def main2():
p = Preprocessing()
keys = "11110111110000001010010111101001101111101000101000000000111111111111000000001111111011011100010101010010101101010101000010111111"
KEYS = p.Convert128_to_32bits(keys)
#plain_text = "00000001110101111011011011111011110000000111010111101101101111100010111110011101001101110010100001011000100000100111011001001110"
plain_text = "00000000000000000000000000000001010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
print(plain_text)
EI_S = p.Convert128_to_32bits(plain_text)
e = Encryption()
d = Decryption()
cypher_txt = e.Encrypt(EI_S, KEYS)
print("\ncypher_txt ", cypher_txt, "\n\n")
e1, e2, e3, e4 = d.Decrypt(cypher_txt, KEYS)
decrypted_txt = e1 + e2 + e3 + e4
print("Decrypted Txt : ", decrypted_txt, "\n\n")
print(decrypted_txt == plain_text)
count = 0
for i in range(128):
if decrypted_txt[i] != plain_text[i]:
print(i + 1)
count += 1
print(count)
def __init__(self, objCommon):
try:
self.common = objCommon
self.keyGeneration = KeyGeneration(objCommon)
self.encryption = Encryption(objCommon)
except Exception as ex:
print(
"An error occurred while initializing class Decryption. Error: ",
ex)
def decode_header(self, raw_header):
# assume raw_header is bytearray of values
salt_end = GCM.get_salt_length()
gcm_end = salt_end + GCM.get_iv_length()
password_salt = bytes(raw_header[:salt_end])
iv = bytes(raw_header[salt_end:gcm_end])
self._gcm = GCM(iv=iv, password_salt=password_salt)
self._gcm.make_key(self._password)
del self._password
def decrypt_cookies(cookies):
encryption = Encryption()
decrypted = {}
for key, value in cookies.iteritems():
Logger.d("Decrypting " + str((key, value)))
try:
decrypted[key] = encryption.decrypt(value)
except EncryptionError:
pass
return decrypted
def Receive_Message(self, encryptionNeeded, encryptionAlgorithm, key):
BUFFER_SIZE = 2048
receivedMessage = self.connection.recv(BUFFER_SIZE)
if (encryptionNeeded == True):
from Encryption import Encryption
receivedMessage = Encryption().Decrypt_Message(
key, receivedMessage[:512])
receivedMessage = receivedMessage.decode()
#print("Received message:", receivedMessage)
return (receivedMessage)
def test_encryption(card_public_key, door_public_key, card_loop_size,
door_loop_size, encryption_key):
card_loop_size1 = Encryption.calc_loop_size(card_public_key)
door_loop_size1 = Encryption.calc_loop_size(door_public_key)
assert (card_loop_size == card_loop_size1)
assert (door_loop_size == door_loop_size1)
private_key = Encryption.calc_private_key(door_public_key, card_loop_size1)
assert (private_key == encryption_key)
assert (encryption_key == Encryption.calc_private_key(
card_public_key, door_loop_size1))
def __init__(self):
try:
self.__usrInpt = -1
self.common = Common("KEY.txt", "ENC.txt")
self.keyGeneration = KeyGeneration(self.common)
self.encryption = Encryption(self.common)
self.decryption = Decryption(self.common)
self.breakEncryption = BreakEncryption(self.common)
except Exception as ex:
print("An error occurred while initializing class Main. Error: ",
ex)
def Crpyto_Encrytor(self, p_text):
# encrypt it so that it gives out cypher text. which is stored in image
plain_text = p_text # input("Enter a plain text : ")
plain_text += "#####"
#example : This World shall Know Pain
print(f"Entered plian Txt : {plain_text}")
preprocessor = Preprocessing()
#convert to binary
plain_2_binary_string = preprocessor.string_2_binary(plain_text)
#append the length in front of 25 bit
#prepended_binary_string = preprocessor.prepend_length_of_binary_string(plain_2_binary_string)
prepended_binary_string = plain_2_binary_string
#padding with zeroes that binary string so that it is a multiple of 128.
padded_binary_string = preprocessor.padding_of_text(
prepended_binary_string)
#ENCRYPTION
encryptor = Encryption()
print(f"Padded Binary string pt1_txt --> : {padded_binary_string}")
print('\n\n')
cipher_text = ""
pt1_txt = padded_binary_string
keys = key_generation()
KEYS = preprocessor.Convert128_to_32bits(keys)
for i in range(0, len(padded_binary_string), 128):
string_128_bit = padded_binary_string[i:i + 128]
#Encryption starts
EI_S = preprocessor.Convert128_to_32bits(string_128_bit)
#keys = "11110111110000001010010111101001101111101000101000000000111111111111000000001111111011011100010101010010101101010101000010111111"
C1, C2, C3, C4 = encryptor.Encrypt(EI_S, KEYS)
cipher_text += C1 + C2 + C3 + C4
print("cipher_text\n", cipher_text)
print('\n')
print("pt1_txt\n", pt1_txt)
print("\n\n")
return cipher_text, keys
def encrypt_set_cookies(set_cookies, wrap_key):
encryption = Encryption()
encrypted = []
for key, value, metadata in set_cookies:
Logger.d("Encrypting " + str((key, value, metadata)))
try:
encrypted_value = encryption.wrap(value, wrap_key)
except EncryptionError as e:
Logger.e("Couldn't encrypt key:%s - value:%s\n\t%s"
% (key, value, str(e)))
encrypted_value = value
encrypted.append((key, encrypted_value, metadata))
return encrypted
def execute(hash):
computer_list = config["hosts"]
log.info("The command is: %s" % hash)
enc=Encryption()
if hash == "start":
command="bash /home/user/startpoc/sp1_as_user.sh"
elif hash == "stop":
#command="killall poclbm.py"
command="screen -r \n exit"
else:
usage()
sys.exit(1)
for host in computer_list:
RC=BTControl(host["name"], host["user"], enc.decrypt(host["pass"]), command)
RC.start()
def encry(self):
hide_msg = self.msg_box.get('1.0', END).replace('\n', '')
if self.file_name == '':
if hide_msg == '':
self.msg_box.delete('1.0', END)
self.msg_box.insert(END, 'Please open a bitmap file first.')
return 0
elif hide_msg == '':
self.msg_box.insert(END, 'Input hidden message here.')
return 0
elif len(hide_msg) > self.available:
if self.msg_box.get('1.0', END) != '':
self.msg_box.delete('1.0', END)
self.msg_box.insert(
END, 'Input hidden message is larger than ' +
str(self.available) + ' bytes.')
return 0
else:
origin_file_name = self.file_name
# add 'hidden' to new image file name
new_file_name = self.file_name[:-4] + '_hidden' + self.file_name[
-4:]
encryption = Encryption(origin_file_name, new_file_name, hide_msg)
encryption.run()
global right_img
right_img = Image.open(self.file_name)
w, h = right_img.size
# resize img
scale_w = img_display_width / w
scale_h = img_display_height / h
scale = min(scale_w, scale_h)
new_w = math.ceil(scale * w)
new_h = math.ceil(scale * h)
img = right_img.resize((new_w, new_h), Image.NEAREST)
global right_photo
right_photo = ImageTk.PhotoImage(img)
self.right_img_canvas.create_image(img_display_width / 2,
img_display_height / 2,
anchor=CENTER,
image=right_photo)
if self.msg_box.get('1.0', END) != '':
self.msg_box.delete('1.0', END)
self.msg_box.insert(END,
'Saved new file into ' + new_file_name + '.')
class Main:
#Constructor for Main class
def __init__(self):
try:
self.__usrInpt = -1
self.common = Common("KEY.txt", "ENC.txt")
self.keyGeneration = KeyGeneration(self.common)
self.encryption = Encryption(self.common)
self.decryption = Decryption(self.common)
self.breakEncryption = BreakEncryption(self.common)
except Exception as ex:
print("An error occurred while initializing class Main. Error: ",
ex)
#String Representation
def __str__(self):
return "usrInpt: " + str(self.__usrInpt) + ", keyGeneration: " + str(self.keyGeneration) + ", common: " + str(self.common) + \
", encryption: " + str(self.encryption) + ", decryption: " + str(self.decryption) + ", breakEncryption: " + str(self.breakEncryption)
#User interface
def Start(self):
try:
while self.__usrInpt != 0:
print("\nMain Menu:\n",\
"\n1. Generate Keys (Elgamal Algorithm)",\
"\n2. Encrypt Message (Requires Reciever's Public Key)",\
"\n3. Decrypt Message (Requires Receiver's Private Key)",\
"\n4. Break Encryption & Decipher Message (Baby Step Giant Step Algorithm)",\
"\n0. Exit",\
"\nPlease enter a digit corresponding to the step")
userEntered = input("(e.g. 1/2/../0): ")
result = self.common.IsInteger(userEntered)
if result is False:
self.__usrInpt = -1
else:
self.__usrInpt = result
if self.__usrInpt == 1:
self.keyGeneration.GenerateAndStoreKeys()
elif self.__usrInpt == 2:
self.encryption.EncryptMessage()
elif self.__usrInpt == 3:
self.decryption.DecryptMessage()
elif self.__usrInpt == 4:
self.breakEncryption.BreakEncryptionGetMessage()
elif self.__usrInpt == 0:
print("\nExiting...")
else:
print("\nInvalid Input entered! Please retry.")
except Exception as ex:
print(
"An error occurred in function Main.Start while processing. Error: ",
ex)
finally:
print("\nThank you!", \
"\nPython project on Encryption, Decryption and Man-In-The-Middle attack implementation", \
"\nsubmitted by Aayush Garg [email protected]")
def decrypt_and_save_data(self, raw_data, destination_file):
decrypted = self._gcm.decrypt(
raw_data[self.get_header_length():-GCM.get_tag_length()])
# with open("temp", "wb") as f:
# f.write(decrypted)
self._gcm.decrypt_finalize()
with open(destination_file, "wb") as f:
f.write(decrypted)
def Send_Message(self, encryptionNeeded, encryptionAlgorithm, key,
message):
if encryptionNeeded == True:
from Encryption import Encryption
message = Encryption.Encrypt_Message(self, key, message)
try:
self.connection.send(message.encode())
except:
self.connection.send(message)
def __init__(self):
from Communication import Communication
from Encryption import Encryption
PORT_NUMBER = 12371
self.connections = []
# [1] Generate asymmetric key pair
strHostPrivateKey, strHostPublicKey = Encryption().Generate_RSA_Keys(
keySize=4096, exponent=65537)
self.Dump_Keys(strHostPrivateKey, strHostPublicKey, "host")
#hostPublicKey = self.Load_Key(keyName="Public", keyType="host")
hostPrivateKey = self.Load_Key("Private", "host")
blacklist = []
while True:
# [2] Listen for attempted client connections
clientConnection, address = self.Listen_For_Connection(PORT_NUMBER)
communication = Communication(clientConnection)
print(address[0], "has connected", end="\n\n")
if address[0] in blacklist:
print("Attempted connection from black listed source",
address[0],
end="\n\n")
communication.Close_Connection()
continue
# [3] Send unencrypted public key
communication.Send_Message(False, None, None, strHostPublicKey)
#self.Send_Message(connection=clientConnection, encryptionNeeded=False, encryptionAlgorithm=None, key=None, message=publicKey, messageType="key")
# [4] Receive client's public key and decrypt with host privatekey
strClientPublicKey = communication.Receive_Message(
False, None, None)
self.Dump_Keys(None, strClientPublicKey, "client")
clientPublicKey = self.Load_Key("Public", "client")
# [5] Ask User what they would like to do: signup / login .. Return the logged in user
# if user was unsuccessful at logging in, close connection and wait for new connection
userID = self.Get_User_Option(communication, clientPublicKey,
hostPrivateKey)
if userID is None:
print("No user logged in, looking for another connection")
blacklist.append(address[0])
print("Added", address[0], "to blacklist")
communication.Close_Connection()
else:
print("Starting blackjack")
from BlackJack_Host import BlackJack
hostBlackJack = BlackJack(communication, userID,
clientPublicKey, hostPrivateKey)
communication.Close_Connection()
def __init__(self):
self.lg = logging.getLogger(__name__)
self.conn = sqlite3.connect("passwords.db")
self.c = self.conn.cursor()
from Encryption import Encryption
self.en = Encryption()
pass
def get(self, request):
with connection.cursor() as cursor:
seller_id = request.session['user_id']
cursor.execute(
'''SELECT P.product_name, T.transaction_date, U.username
FROM transaction T, product P, user U WHERE T.seller_id = "{}"
AND P.product_id = T.product_id AND T.buyer_id = U.user_id'''
.format(seller_id))
orders_result = cursor.fetchall()
encryption = Encryption()
orders_result = [(order[0], order[1],
encryption.decrypt(order[2][2:-1].encode()))
for order in orders_result]
return render(request=request,
template_name=self.template_name,
context={'orders_result': orders_result})
class Encoder:
MODES = {'GCM': 8}
def __init__(self,
password,
source_image_folder_path,
destination_image_folder_path,
mode='GCM'):
self.mode = Encoder.MODES[mode]
self.source_image_folder_path = source_image_folder_path
self.destination_image_folder_path = destination_image_folder_path
if os.path.exists(self.destination_image_folder_path):
shutil.rmtree(self.destination_image_folder_path)
os.makedirs(self.destination_image_folder_path)
self.gcm = GCM()
self.gcm.make_key(password)
self.transcriber = Transcriber(self.mode, source_image_folder_path,
destination_image_folder_path)
def encode_file(self, file_path):
with open(file_path, 'rb') as source:
file_bytes = source.read()
encrypted = self.gcm.encrypt(file_bytes)
tag = self.gcm.encrypt_finalize()
header = self.gcm.password_salt + self.gcm.iv
full_length = len(header) + len(encrypted) + len(tag)
# if not self.transcriber.can_fit_bytes(full_length):
# print("Not enough images to store the necessary data")
# exit()
self.transcriber.choose_needed_images(full_length)
print("full length", full_length, full_length * 8)
self.transcriber.set_encoding(header + encrypted + tag)
# with open("encode-test", "wb") as f:
# f.write(header + encrypted + tag)
self.transcriber.finish_encoding()
class Decoder:
MODES = {'GCM': 8}
MODE_LENGTH = 1
def __init__(self, password, image_folder_path):
self.image_folder_path = image_folder_path
self.mode = None
self._gcm = None
self._password = password
self._data_length = 0
self.extractor = Extractor(image_folder_path)
def get_header_length(self):
return GCM.get_iv_length() + GCM.get_salt_length()
def decode_header(self, raw_header):
# assume raw_header is bytearray of values
salt_end = GCM.get_salt_length()
gcm_end = salt_end + GCM.get_iv_length()
password_salt = bytes(raw_header[:salt_end])
iv = bytes(raw_header[salt_end:gcm_end])
self._gcm = GCM(iv=iv, password_salt=password_salt)
self._gcm.make_key(self._password)
del self._password
def get_tag(self, raw_data):
tag = bytes(raw_data[-GCM.get_tag_length():])
self._gcm.set_tag(tag)
def decrypt_and_save_data(self, raw_data, destination_file):
decrypted = self._gcm.decrypt(
raw_data[self.get_header_length():-GCM.get_tag_length()])
# with open("temp", "wb") as f:
# f.write(decrypted)
self._gcm.decrypt_finalize()
with open(destination_file, "wb") as f:
f.write(decrypted)
def decode_file(self, file_path):
raw_data = self.extractor.load_images()
# with open("decode-test", "wb") as f:
# f.write(raw_data)
raw_header = raw_data[:self.get_header_length()]
self.decode_header(raw_header)
self.get_tag(raw_data)
self.decrypt_and_save_data(raw_data, file_path)
def _convert(self, value):
"""Returns a Encryption object from the given string.
PasswordHash instances or None values will return unchanged.
Strings will be hashed and the resulting PasswordHash returned.
Any other input will result in a TypeError.
"""
if isinstance(value, Encryption):
return value
elif isinstance(value, basestring):
return Encryption.new(value, self.cipher_key)
elif value is not None:
raise TypeError(
'Cannot convert {} to a EncryptedValue'.format(type(value)))
class StartPageView(View):
template_name = 'start_page.html'
loginForm = LoginForm
signupForm = SignUpForm
encryption = Encryption()
def get(self, request):
if request.session.get('user_id') is not None:
return redirect('homepage_view')
login_form = self.loginForm()
signup_form = self.signupForm()
return render(request=request,
template_name=self.template_name,
context={'login_form': login_form,
'signup_form': signup_form})
def __init__(self,
password,
source_image_folder_path,
destination_image_folder_path,
mode='GCM'):
self.mode = Encoder.MODES[mode]
self.source_image_folder_path = source_image_folder_path
self.destination_image_folder_path = destination_image_folder_path
if os.path.exists(self.destination_image_folder_path):
shutil.rmtree(self.destination_image_folder_path)
os.makedirs(self.destination_image_folder_path)
self.gcm = GCM()
self.gcm.make_key(password)
self.transcriber = Transcriber(self.mode, source_image_folder_path,
destination_image_folder_path)
def build_response(self, entries=[]):
try:
from Encryption import Encryption
en = Encryption()
#print(f"{en.decrypt(entries[0])} | {en.decrypt(entries[1])} | {en.decrypt(entries[2])}")
print(f"{entries[0]} | {entries[1]} | {entries[2]}")
import subprocess
import clipboard
clipboard.copy(entries[1])
print("Password has been copied to your clipboard")
except TypeError as e:
pass
def crypt(argv):
message = bitarray()
with argv.Sourcefile as fh:
message.fromfile(fh)
key = bitarray()
with argv.Keyfile as fh:
key.fromfile(fh)
start_time = datetime.now()
encrypted = Encryption.encrypt(message, key)
time_elapsed = datetime.now() - start_time
print('Time elapsed (hh:mm:ss.ms) {}'.format(time_elapsed))
with argv.Destinationfile as fh:
encrypted.tofile(fh)
def post(self, request):
form = self.searchForm(request.POST)
if form.is_valid():
data = form.cleaned_data
with connection.cursor() as cursor:
if data['search_filter'][0] == 'C':
cursor.execute(
'''SELECT C.cat_name, S.store_name, C.cat_descr, S.store_id, C.cat_id
FROM store S, category C, store_categories SC
WHERE SC.category_id IN
(SELECT cat_id FROM category WHERE cat_name LIKE "%%{}%%")
AND S.store_id = SC.store_id
AND C.cat_id = SC.category_id'''.format(
data['search_item']))
categories_result = cursor.fetchall()
return render(request=request,
template_name=self.buyer_template_name,
context={
'categories_result': categories_result,
'search_form': form
})
elif data['search_filter'][0] == 'S':
cursor.execute(
'''SELECT S.store_name, S.create_date, U.username, S.store_id
FROM store S, user U WHERE S.store_name LIKE "%%{}%%"
AND U.user_id = S.owner_id
'''.format(data['search_item']))
store_result = cursor.fetchall()
encryption = Encryption()
store_result = [
(store[0], store[1],
encryption.decrypt(store[2][2:-1].encode()), store[3])
for store in store_result
]
return render(request=request,
template_name=self.buyer_template_name,
context={
'store_result': store_result,
'search_form': form
})
else:
cursor.execute(
'''SELECT P.product_name, P.product_specs, P.product_price,
P.number_in_stock, S.store_name, C.cat_name, P.product_id
FROM product P, store_categories SC, store S, category C
WHERE P.product_name LIKE "%%{}%%"
AND C.cat_id = P.category_id
AND SC.category_id = P.category_id
AND S.store_id = SC.store_id'''.format(
data['search_item']))
product_result = cursor.fetchall()
return render(request=request,
template_name=self.buyer_template_name,
context={
'product_result': product_result,
'search_form': form
})
* facebook : /viral4ever
* google+ : /+ViralJoshi
* twitter : /viralhj
* linkedin : /in/viralj
*
*
*/
required python version : Python 3.0+
"""
from Encryption import Encryption # Importing custom Encryption class
from Decryption import Decryption # Importing custom Decryption class
import time # Importing for time delay
a = str(input("Please enter ENCRYPTION or DECRYPTION : ")).lower() # Need user input to know next action
"""
Action for Encryption or Decryption
starts from here.
"""
if a == "encryption":
b = str(input("Please enter a string : "))
Encryption.encryption(b)
elif a == "decryption":
Decryption.decryption()
else:
print("Wrong answer! Good bye...")
time.sleep(1)
exit()
def get_header_length(self):
return GCM.get_iv_length() + GCM.get_salt_length()
# 加密调用代码
from Encryption import Encryption
enc = Encryption('Debug\H128_data.dat')
enc.encryption()
# 解密调用代码
from Decrypt import Decrypt
dec = Decrypt('Debug\H128_data.dat')
dec.decrypt()
def send_email(self):
try:
self.receiver = self.param_3.get()
self.subject = self.param_4.get()
self._send_text = self.param_5.get("0.0", "end")
except Exception as e:
print "RECEIVER INTO ERROR ->", str(e)
print self.receiver, self.subject, self._send_text
# 加入文本消息
msg = MIMEMultipart()
msg['From'] = 'WUD_EMAIL_SYSTEM <' + self.user + '>'
msg['To'] = self.receiver
msg['Subject'] = self.subject
_send_text = Encryption().Encry_text(str(self._send_text)) # AES加密后的密文
_send_text = MIMEText(_send_text, 'plain', 'utf-8')
msg.attach(_send_text)
# 加密文件
cipher_path = []
for path in self.path:
cipher_path.append(Encryption().Encry_file(path)) # 加密图片文件
self.path[:] = []
for path in cipher_path:
self.path.append(path) # 将加密后的附件路径添加至发送列表
# 添加附件 文件路径不能包含中文
if len(self.path) != 0:
try:
for file_path in self.path:
print file_path
file_part = MIMEApplication(open(file_path, 'rb').read())
file_part.add_header('Content-Disposition',
'attachment',
filename=file_path)
msg.attach(file_part)
print "ADD SUCCESS"
except Exception as e:
print "ADD FILE ERROR ->", str(e)
self.server.set_debuglevel(1)
self.server = smtplib.SMTP(self.Smtp_Server, 25) # 与邮件服务器重新建立连接
self.server.login(self.user, self.passwd) # 重新登入
self.remain_windows = Tk()
self.remain_windows.title("提示消息")
try:
self.server.sendmail(self.user, self.receiver, msg.as_string())
self.server.quit()
remain_lable = Frame(self.remain_windows)
Label(remain_lable, text="Send Success!").pack(fill="y",
expand="yes")
remain_lable.pack()
self.remain_windows.mainloop()
except Exception as e:
print "Send Error - >", str(e)
remain_lable = Frame(self.remain_windows)
Label(remain_lable, text="Send Failed!").pack(fill="y",
expand="yes")
remain_lable.pack()
self.remain_windows.mainloop()
exit_button = Frame(self.remain_windows)
Button(exit_button, text="Confirm",
command=self.destory_windows).pack()
exit_button.pack()
def process_result_value(self, value, dialect):
if value is not None:
return Encryption(value, cipher_key)
def get_tag(self, raw_data):
tag = bytes(raw_data[-GCM.get_tag_length():])
self._gcm.set_tag(tag)
def main():
# For the integration testing I will take plain txt from usr converting into binary string giving it to Encryption block to
# encrypt it so that it gives out cypher text. which is tored in image
# after extraaction of cypher txt from stegeo img it will be given to the decryption module
# Decryptor decrypt it to yield plain txt.
plain_text = input("Enter a plain text : ")
#example : This World shall Know Pain
print(f"Entered plian Txt : {plain_text}")
preprocessor = Preprocessing()
#convert to binary
plain_2_binary_string = preprocessor.string_2_binary(plain_text)
#append the length in front of 25 bit
prepended_binary_string = preprocessor.prepend_length_of_binary_string(
plain_2_binary_string)
#padding with zeroes that binary string so that it is a multiple of 128.
padded_binary_string = preprocessor.padding_of_text(
prepended_binary_string)
#ENCRYPTION
encryptor = Encryption()
print(f"Padded Binary string pt1_txt --> : {padded_binary_string}")
print('\n\n')
cipher_text = ""
pt1_txt = padded_binary_string
for i in range(0, len(padded_binary_string), 128):
string_128_bit = padded_binary_string[i:i + 128]
#Encryption starts
EI_S = preprocessor.Convert128_to_32bits(string_128_bit)
keys = "11110111110000001010010111101001101111101000101000000000111111111111000000001111111011011100010101010010101101010101000010111111"
KEYS = preprocessor.Convert128_to_32bits(keys)
C1, C2, C3, C4 = encryptor.Encrypt(EI_S, KEYS)
cipher_text += C1 + C2 + C3 + C4
print("cipher_text\n", cipher_text)
print('\n')
print("pt1_txt\n", pt1_txt)
print("\n\n")
ct_text = cipher_text
#prepended the length of cypher text in front of 25 bit i.e first 25 bit shows length of cypher text
prepended_cypher_txt = preprocessor.prepend_length_of_binary_string(
cipher_text)
#padd it now this cypher txt -->prepended_cypher_txt to padded_cypher_txt
padded_cypher_txt = preprocessor.padding_of_text(prepended_cypher_txt)
#Now the padded cypher text -->padded_cypher_txt will go inside the image and image will be called after insertion as
#steogo image
#Now we have to extract LSB of whole image (or it can be modified / optimized further )
cypher_txt_after_extraction = preprocessor.extract_real_binary_string(
padded_cypher_txt)
#DECRYPTION
padded_pt_text = ""
decryptor = Decryption()
for i in range(0, len(cypher_txt_after_extraction), 128):
cypher_128_bit = cypher_txt_after_extraction[i:i + 128]
#print("###",i , i+128 , string_128_bit)
#print('\n\n')
CT_S = preprocessor.Convert128_to_32bits(cypher_128_bit)
keys = "11110111110000001010010111101001101111101000101000000000111111111111000000001111111011011100010101010010101101010101000010111111"
KEYS = preprocessor.Convert128_to_32bits(keys)
#print("\n\nKEYS : ",KEYS)
#print('\n\n')
E1, E2, E3, E4 = decryptor.Decrypt(CT_S, KEYS)
padded_pt_text += E1 + E2 + E3 + E4
print("padded_pt_text\n", padded_pt_text)
print('\n')
print("Ab bata jara ", end="")
print(pt1_txt == padded_pt_text)
#Now extracting actual binary string from padded plain txt
real_pt_text = preprocessor.extract_real_binary_string(padded_pt_text)
#Now convert this real plain txt into Ascii text
real_plain_text = preprocessor.binary_2_string(real_pt_text)
print(
f"\n\n\n\n\n\n\n\n\n After all the actual text was :--> {real_plain_text}\n\n\n\n\n\n\n\n\n"
)
class BreakEncryption:
#Constructor for BreakEncryption class
def __init__(self, objCommon):
try:
self.common = objCommon
self.encryption = Encryption(objCommon)
self.keyGeneration = KeyGeneration(objCommon)
self.decryption = Decryption(objCommon)
except Exception as ex:
print(
"An error occurred while initializing class BreakEncryption. Error: ",
ex)
#String Representation
def __str__(self):
return "No member variables other than member objects to classes"
#4. Break encryption and get original message using Baby Step Giant Step algorithm
def BreakEncryptionGetMessage(self):
try:
print("\nIf your listening to somebody's conversation as a Man In The Middle",\
"and wish to break an encrypted message,")
print(
"you must have the knowledge of encrypted message and the header sent to the Reciever."
)
#Read Encrypted Message and Header from the file
tupleEncMsgHead = self.encryption.ReadEncryptedMessageAndHeader()
if len(tupleEncMsgHead) > 0:
print(
"\nThe public key of the Receiver is required to break an encryption."
)
print(
"The Public Keys are usually publicly available via Key Hosting Services."
)
#Read public key from file
receiversKeys = self.keyGeneration.ReadReceiversKeys(False)
if len(receiversKeys) > 0:
encryptedMessage, header = tupleEncMsgHead[
0], tupleEncMsgHead[1]
primitiveElement = receiversKeys[0]
primitiveRaisedSecretModPrime = receiversKeys[1]
randomPrime = receiversKeys[2]
print(
"\nBreaking Encyption (using Baby Step Giant Step Algorithm)..."
)
self.__PerformBabyStepGiantStep(
encryptedMessage, header, primitiveElement,
primitiveRaisedSecretModPrime, randomPrime)
except Exception as ex:
print(
"An error occurred in function BreakEncryption.BreakEncryptionGetMessage while processing. Error: ",
ex)
#To perform Baby-Step-Giant-Step algorithm using Receiver's public keys and Header to break Encryption
# and get the original message
def __PerformBabyStepGiantStep(self, encryptedMessage, header,
primitiveElement,
primitiveRaisedSecretModPrime, randomPrime):
try:
randomVar = self.__ComputePowerVariable(header, primitiveElement,
randomPrime)
#print("randomVar:", randomVar)
if randomVar == -1:
print(
"\nBaby Step Giant Step failed to break encryption for given Public Key and Header combination."
)
print(
"Please try again for a different Receiever\'s Public Key and Header combination..."
)
else:
#Encrypted Message = message * (c^b mod p) mod p
#message = Encrypted Message * Inverse of (c^b mod p) mod p
#c^b mod p
primitiveRaisedSecRaisedRandomModPrime = self.common.GetExponentiation(
primitiveRaisedSecretModPrime, randomVar, randomPrime)
#print("primitiveRaisedSecRaisedRandomModPrime:", primitiveRaisedSecRaisedRandomModPrime)
#message = Encrypted Message * Inverse of (c^b mod p) mod p
message = (encryptedMessage *
self.decryption.GetInverseModPrime(
primitiveRaisedSecRaisedRandomModPrime,
randomPrime)) % randomPrime
print("\nCracked Original Message:", message)
except Exception as ex:
print(
"An error occurred in function BreakEncryption.__PerformBabyStepGiantStep while processing. Error: ",
ex)
#In the equation a = b ^ c mod n, below function computes 'c'
# Representationally: answerVar = baseVar ^ powerVar Mod prime
def __ComputePowerVariable(self, answerVar, baseVar, prime):
try:
dictLHS, dictRHS = {}, {}
m = int(math.ceil(math.sqrt(prime - 1)))
#print("m:", m)
invBaseVar = self.decryption.GetInverseModPrime(baseVar, prime)
#print("invBaseVar:", invBaseVar)
invBaseVarRaisedm = self.common.GetExponentiation(
invBaseVar, m, prime)
#print("invBaseVarRaisedm:", invBaseVarRaisedm)
#answerVar * (invBaseVar ^ m) ^ i = baseVar ^ j
#where 0 <= i <=m
#and 0 <= j < m
#All L.H.S. values of equation answerVar * (invBaseVar ^ m) ^ i = baseVar ^ j
for i in range(m + 1):
valueLHS = (self.common.GetExponentiation(
invBaseVarRaisedm, i, prime) * answerVar) % prime
dictLHS[i] = valueLHS
#All R.H.S. values of equation answerVar * (invBaseVar ^ m) ^ powerVar = baseVar ^ otherPowerVar
for j in range(m):
valueRHS = self.common.GetExponentiation(baseVar, j, prime)
dictRHS[j] = valueRHS
listCombinationTuple = [(i, j) for i in dictLHS for j in dictRHS
if dictLHS[i] == dictRHS[j]]
#print("listCombinationTuple:", listCombinationTuple)
if len(listCombinationTuple) > 0:
powerVar = int((listCombinationTuple[0][0] * m) +
listCombinationTuple[0][1])
else:
#Baby-Step-Giant-Step algorithm failed to crack encryption
powerVar = -1
#print("powerVar:", powerVar)
return powerVar
except Exception as ex:
print(
"An error occurred in function BreakEncryption.__ComputePowerVariable while processing. Error: ",
ex)
# Date: 07 March 2016
# Written By: Phantom Raspberry Blower
# serial number (key): 0000000021adc001
# email password (crypt): JLFC3HeJQtU=
# (iv): PRB StrikesAgain
from SystemInfoNew import SystemInfo
from Encryption import Encryption
from SendEmail import SendEmail
si = SystemInfo()
serial = si.get_cpu_serial()
enc = Encryption(serial)
dec = Encryption(serial)
se = SendEmail(True)
# Fetch the configuration settings defined by the user
tree = et.parse(self.addon_data_path + 'script.force-install-all-ep/settings.xml')
root = tree.getroot()
# Iterate through the settings
for setting in root.findall('setting'):
if setting.get('id') == 'email_key':
enc_pass = enc.encrypt_msg(setting.get('value')
password = enc.decrypt_msg(enc_pass)
enc_msg = enc.encrypt_msg(si.get_system_info())
