def des(self, type):
key_text = self.key_text.get()
if len(key_text) < 1:
tk.messagebox.showerror(title=None, message='請輸入密碼！！！')
return False
if type == 'encrypt':
plain_text = self.plain_text.get(0.0, 'end').split('\n')[0]
if len(plain_text) < 1:
tk.messagebox.showerror(title=None, message='請輸入明文！！！')
return False
return_text = DES().encrypt(plain_text, key_text)
self.plain_text.delete('1.0', 'end')
self.cypher_text.delete('1.0', 'end')
self.cypher_text.insert('end', return_text)
else:
cypher_text = self.cypher_text.get(0.0, 'end').split('\n')[0]
if len(cypher_text) < 1:
tk.messagebox.showerror(title=None, message='請輸入密文！！！')
return False
return_text = DES().decrypt(cypher_text, key_text)
self.cypher_text.delete('1.0', 'end')
self.plain_text.delete('1.0', 'end')
self.plain_text.insert('end', return_text)
print(return_text)
self.window.clipboard_clear()
self.window.clipboard_append(return_text)
def __init__(self, mode='des'):
if mode.lower() == 'des':
self.a = DES()
self.blocksize = 8
elif mode.lower() == 'sm4':
self.a = SM4()
self.blocksize = 16
def encrypt(self):
text = self.textEdit.toPlainText()
key = self.textEdit_2.toPlainText()
print(key)
print(text)
des = DES()
encrypt_text = des.encrypt(key, text)
print(base64.b64encode(encrypt_text))
self.textEdit_3.setText(str(base64.b64encode(encrypt_text))[2:-2])
def generate_hash(self):
self._get_keys()
c1 = DES.encrypt(self.text, self.key1, padding=False)
c2 = DES.encrypt(self.text, self.key2, padding=False)
zeros = '0' * 16
h1 = hex(bitarray2int(string2bits(c1)))[2:]
h1 = zeros[len(h1):] + h1
h2 = hex(bitarray2int(string2bits(c2)))[2:]
h2 = zeros[len(h2):] + h2
return h1 + h2
def main():
try:
file = open(sys.argv[1], "rb")
except IndexError:
print("Set file as argv[1]")
return
enc_file_name = "enc_" + sys.argv[1]
dec_file_name = "dec_" + sys.argv[1]
enc_file = open(enc_file_name, "wb")
count = 0
append_bytes = 0
d = DES([randint(0, 255) for _ in range(8)])
print("Start encrypting '{0}' ...".format(sys.argv[1]))
while True:
buf = file.read(MAX_LEN)
if (not len(buf)):
file.close()
enc_file.close()
print("Encrypting done. Results saved in file: '{0}'".format(
enc_file_name))
break
else:
count += 1
append_bytes = check_8byte(buf)
if append_bytes:
buf += b'0' * append_bytes
enc_str = d.process_string(buf)
enc_file.write(enc_str)
enc_file = open(enc_file_name, "rb")
dec_file = open(dec_file_name, "wb")
print("Start decrypting '{0}' ...".format(enc_file_name))
while True:
buf = enc_file.read(MAX_LEN)
if (not len(buf)):
enc_file.close()
dec_file.close()
print("Decrypting done. Results saved in file: '{0}'".format(
dec_file_name))
break
else:
count -= 1
dec_str = d.process_string(buf, DECRYPT)
if not count and append_bytes:
dec_str = dec_str[:-append_bytes]
dec_file.write(dec_str)
def handle_des(client_socket):
print "[*] The connection is encrypted with DES"
# waiting for key
print "[*] Waiting for key..."
try:
key_text = client_socket.recv(1024)
client_socket.send("Key received!")
except:
client_socket.close()
print "[*] Remote client is closed."
return
print "[*] Key accepted. Waiting for messages..."
while True:
try:
cipher_text = client_socket.recv(1024)
if cipher_text:
print "[*] Received: %s" % cipher_text
print "[*] Plain text is: %s" % DES.decrypt(cipher_text, key_text)
client_socket.send("ACK!")
except:
client_socket.close()
print "[*] Remote client is closed."
return
def des_method(client_socket):
# send methond message
method_message = "method:des"
try:
client_socket.send(method_message)
client_socket.recv(1024)
except:
client_socket.close()
print "\n[*] Connection is broke."
return
# send des key
print "[*] Please enter the key, and the length must longer than 8 characters."
while True:
key_text = raw_input("> ")
if len(key_text) > 8:
break
else:
print "[!] The length must longer than 8 characters.\
Please try again:)."
try:
client_socket.send(key_text)
client_socket.recv(1024)
except:
client_socket.close()
print "\n[*] Connection is broke."
return
print "[*] Please enter the message:"
# send encrypted message
while True:
try:
plain_text = raw_input('> ')
cipher_text = DES.encrypt(plain_text, key_text)
print "[*] The cipher is [%s]" % cipher_text
client_socket.send(cipher_text)
response_content = client_socket.recv(1024)
print response_content
except:
client_socket.close()
print "\n[*] Connection is broke."
return
def main():
parser = OptionParser()
parser.add_option("-e",
"--encrypt",
action="store_true",
dest="encrypt",
default=False)
parser.add_option("-d",
"--decrypt",
action="store_true",
dest="decrypt",
default=False)
parser.add_option("-k",
"--key",
action="store",
type="string",
dest="key",
default="3b3898371520f75e")
parser.add_option("--no-hex",
action="store_false",
dest="keyhex",
default=True)
options, args = parser.parse_args()
if parser.values.keyhex == True:
key = bytearray.fromhex(parser.values.key)
else:
key = str.encode(parser.values.key)
des = DES(key)
if parser.values.decrypt == True:
action = des.decrypt
else:
action = des.encrypt
# or read eg 64bytes and write 72 (encryption)
data = sys.stdin.buffer.read()
sys.stdout.buffer.write(action(data))
def symmetric_cipher(self):
"""Selects a symmetric-key chiper.
:return: an object of one of the symmetric-key encryption classes or None
"""
_cipher = None
if self.algorithm == AlgEnum.CAESAR.name:
_cipher = Caesar()
if self.algorithm == AlgEnum.VIGENERE.name:
_cipher = Vigenere()
if self.algorithm == AlgEnum.AES.name:
_cipher = AES()
if self.algorithm == AlgEnum.DES.name:
_cipher = DES()
if self.algorithm == AlgEnum.MAGMA.name:
_cipher = Magma()
if self.algorithm == AlgEnum.KUZNECHIK.name:
_cipher = Kuznechik()
if self.algorithm == AlgEnum.RSA.name:
_cipher = Kuznechik()
return _cipher
class MyEncrypter(Encrypter):
def __init__(self):
self.des = DES()
self.rabin = rabin()
def generateKey(self):
return self.des.generateKey()
def symmetricEncode(self, message, key):
self.des.input_key(key)
return self.des.encode(message)
def symmetricDecode(self, message, key):
self.des.input_key(key)
return self.des.decode(message)
def generateKeyPair(self):
return self.rabin.getrabinkey()
def asymmetricEncode(self, message, key):
return self.rabin.encode(message, long(key))
def asymmetricDecode(self, message, key):
return self.rabin.decode(message, key[0], key[1])
def decrypt(self):
key = self.textEdit_2.toPlainText()
encrypt_text = self.textEdit_3.toPlainText()
encrypt_text_ = base64.b64decode(encrypt_text.encode('utf-8'))
des = DES()
decrypt_text = des.decrypt(key, encrypt_text_)
# Author: soachishti ([email protected]) # Link: http://page.math.tu-berlin.de/~kant/teaching/hess/krypto-ws2006/des.htm from des import DES d = DES() print "\n" + "=" * 5 + "HEX Demo" + "=" * 5 + "\n" hex_message = "0123456789abcdef" key = "133457799BBCDFF1" # Must be hex encryted = d.encrypt(hex_message, key) decrypted = d.decrypt(encryted, key) print "Message: ", hex_message print "Key: ", key print "Encryted: ", encryted print "Decrypted: ", decrypted print "\n" + "=" * 5 + "ASCII Demo" + "=" * 5 + "\n" ascii_message = "OwaisAli" hex_message = d.process_message(ascii_message) encryted = d.encrypt(hex_message, key) decrypted = d.decrypt(encryted, key) print "ASCII Message: ", ascii_message print "Hex Message: ", hex_message print "Key: ", key print "Encryted: ", encryted print "Decrypted: ", decrypted.decode('hex').split('\0')[0]
m |= (((m_perm >> (ip -1)) & 1) << i)
c |= (((c_perm >> (ip -1)) & 1) << i)
#we reverse L and R
c = ((c&MASK32) << 32) | (c >> 32)
Re = m&MASK32
expanded_input = 0
for index,shift in enumerate(E):
expanded_input |= ((Re>>(shift-1))&1)<<index
coeffs = reverse_S(m,c)
reconstructed_nbrs = map(reconstruct_number, coeffs, repeat(6))
possible_keys = map(xor, reconstructed_nbrs, repeat(expanded_input))
tmp.append(set(possible_keys))
result = set.intersection(*tmp)
#we verify the result
identity=lambda x : [x]
for key_found in result:
assert(all(starmap(lambda m,c: DES(m,key_found,compute_ki=identity).C == c, correspondance_messages_encryptions)))
if len(result) == 1:
print("The key is {}".format(hex(list(result)[0])))
else:
print("Not enough (message,cypher) to determine with certitude which key it was")
print("the possible keys are:")
print(tuple(map(format, result, repeat('0x'))))
def on_click4(self):
self.crypt = DES()
helpMessage = 'use method: ' + self.crypt.name + '\nkey: \n'
helpMessage += '\n'.join([str(s.hex()) for s in self.crypt.key])
self.textbox[2].setText(helpMessage)
def handle_mix(client_socket):
# waiting for public key of the client
print "Wating for public key of the client"
try:
pub_key_string_client = client_socket.recv(2048)
pub_key_array_client = pub_key_string_client.split(',')
pub_key_client = (long(pub_key_array_client[0]), long(pub_key_array_client[1]))
except:
client_socket.close()
print "\n[*] Connection is broke."
return
print "[*] Client public key accepted."
print pub_key_client
prime_length = 512
rsaKeys = rsa.RSAKey()
pub_key_server, priv_key_server = rsaKeys.gen_keys(prime_length)
# send public key
print "[*] Keys generated. Sending public key to the client..."
pub_key_string_server = str(pub_key_server[0]) + "," + str(pub_key_server[1])
print pub_key_string_server
try:
client_socket.send(pub_key_string_server)
except:
client_socket.close()
print "\n[*] Connection is broke."
return
# waiting for des key
print "[*] Waiting for des key..."
cipher_des_key = client_socket.recv(4096)
des_key = rsaKeys.decrypt(priv_key_server, cipher_des_key.split())
client_socket.send("Key received!")
# waiting for messages...
print "[*] Key accepted. Waiting for messages..."
while True:
try:
cipher_digest = client_socket.recv(102400)
print cipher_digest
if cipher_digest:
print "[*] Received cipher digest: %s" % cipher_digest
plain_digest = rsaKeys.decrypt(pub_key_client, cipher_digest.split())
print "[*] Plain digest is: %s" % plain_digest
client_socket.send("Digest Received!")
cipher_text = client_socket.recv(2048)
client_socket.send("Message Received!")
if cipher_text:
print "[*] Received cipher text: \n%s" % cipher_text
plain_text = DES.decrypt(cipher_text, des_key)
print "[*] Plain text is: \n %s" % DES.decrypt(cipher_text, des_key)
sha1_degist = sha1.sha1(plain_text)
print "[*] Real digest: [%s]" % sha1_degist
if sha1_degist == plain_digest:
print "[*] The message is from correct client."
else:
print"[*] The message was tampered."
except:
client_socket.close()
print "\n[*] Connection is broke."
return
from des import DES
while True:
mode = input('Select DES mode (E: Encryption, D: Decryption)\nor Enter Q to quit\nSelection: ')
if mode == 'Q' or mode == 'q':
break
elif mode == 'E' or mode == 'e':
key = input('Enter the key in hex: ')
plain = input('Enter the plain text in hex: ')
des = DES(key=key, plain=plain)
print('Cipher text: ' + des.encrypt())
elif mode == 'D' or mode == 'd':
key = input('Enter the key in hex: ')
cipher = input('Enter the cipher text in hex: ')
des = DES(key=key, cipher=cipher)
print('Plain text: ' + des.decrypt())
print()
def mix_method(client_socket):
# send method
method_message = "method:mix"
client_socket.send(method_message)
client_socket.recv(1024)
prime_length = 512
rsaKeys = rsa.RSAKey()
pub_key_client, priv_key_client = rsaKeys.gen_keys(prime_length)
# send public key
print "[*] RSA Keys generated. Sending public key to the server..."
pub_key_string_client = str(pub_key_client[0]) + "," + str(pub_key_client[1])
print pub_key_string_client
try:
client_socket.send(pub_key_string_client)
except:
client_socket.close()
print "\n[*] Connection is broke."
return
print "[*] Public key sent. Waiting for the server public key..."
# waiting for public key of the client
print "Wating for public key of the server"
try:
pub_key_string_server = client_socket.recv(2048)
pub_key_array_server = pub_key_string_server.split(',')
pub_key_server = (long(pub_key_array_server[0]), long(pub_key_array_server[1]))
except:
client_socket.close()
print "\n[*] Connection is broke."
return
print "[*] Server public key accepted."
print pub_key_server
# generate des key
print "[*] Please enter des key, and the length must longer than 8 characters."
while True:
des_key = raw_input("> ")
if len(des_key) > 8:
break
else:
print "[!] The length must longer than 8 characters.\
Please try again:)."
# encryte des key with server public key
rsaKeys = rsa.RSAKey()
try:
client_socket.send(rsaKeys.encrypt(pub_key_server, des_key))
print client_socket.recv(1024)
except:
client_socket.close()
print "\n[*] Connection is broke."
return
# send encrypted digest
print "[*] Please enter the message."
while True:
try:
plain_text = raw_input('> ')
digest_text = sha1.sha1(plain_text)
print "[*] The digest is [%s]" % digest_text
client_socket.send(rsaKeys.encrypt(priv_key_client, digest_text))
response_content = client_socket.recv(1024)
print response_content
cipher_text = DES.encrypt(plain_text, des_key)
client_socket.send(cipher_text)
response_content = client_socket.recv(1024)
print response_content
except:
client_socket.close()
print "\n[*] Connection is broke."
return
def main(f_input="input.txt"):
cipher = DES()
#cipher.encrypt("abcdefgh")
c = cipher.encrypt(f_input)
p = cipher.decrypt(c)
from flask import Flask
from flask_bootstrap import Bootstrap
from flask_mail import Mail
from flask_moment import Moment
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from config import config
from des import DES
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
desclass = DES()
login_manager = LoginManager()
login_manager.login_view = 'auth.login'
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
from .main import main as main_blueprint
app.register_blueprint(main_blueprint)
from des import DES
des = DES(key=193)
number = 123456
ciphertext = des.encrypt_number(number)
decrypted = des.decrypt_number(ciphertext)
print('Number:', number)
print('Encrypted:', ciphertext)
print('Decrypyed', decrypted)
parser.add_argument('-v', '--verbose', action='store_true')
parser.add_argument('-i', '--infile',
nargs='?',
type=argparse.FileType('rb'),
default=sys.stdin,
help='input file to process, if not given stdin will be used')
parser.add_argument('-o', '--outfile',
nargs='?',
type=argparse.FileType('wb'),
default=sys.stdout,
help='output file to process, if not given stdout will be used')
args = parser.parse_args()
des = DES(verbose=args.verbose)
if args.encrypt:
action = des.encrypt
elif args.decrypt:
action = des.decrypt
if args.key:
key1 = args.key
key2 = None
if args.keys:
key1, key2 = args.keys
action(key1, args.infile, args.outfile, key2)
def hexdigest(self):
self._pad_key()
c = DES.encrypt(self.text, self.deskey, padding=False)
zeros = '0' * 16
h = hex(bitarray2int(string2bits(c)))[2:]
return zeros[len(h):] + h
def __init__(self):
self.des = DES()
self.rabin = rabin()
from des import DES
d = DES('qwertyui')
cipher = d.encrypt('hello world!')
print(cipher)
deciphered = d.decrypt(cipher, msg_in_bits=True)
print(deciphered)
import os
import random
import threading
import time
from des import DES
d = DES()
input = 'test'
c = d.encrypt(input)[0]
def des_brute_force(key: list):
d.subkeys = d._prepare_keys(key)
return d.decrypt(c).strip() == input
def random_key():
return random.choices([0, 1], k=64)
class Task(threading.Thread):
def run(self):
print('Starting {}'.format(self.name))
start = time.time()
while True:
r_k = random_key()
if des_brute_force(r_k):
end = time.time()
print('Found key: {}'.format(r_k))
print('Elapsed: {}s'.format(end - start))
class uBlockCipher():
# 初始化选择密码算法
def __init__(self, mode='des'):
if mode.lower() == 'des':
self.a = DES()
self.blocksize = 8
elif mode.lower() == 'sm4':
self.a = SM4()
self.blocksize = 16
# 读取文件
def readFile(self, filename):
f = open(filename, 'rb')
self.data = f.read()
f.close()
# 写加密后文件
def writeFile(self, filename, ed):
f = open(filename + ed, 'wb')
f.write(self.cdata)
f.close()
# 填充，支持零填充、pkcs7
def aPadding(self, s):
if s.lower() == 'zero':
t = self.blocksize - len(self.data) % self.blocksize
for _ in range(t):
self.data += b'\x00'
elif s.lower() == 'pkcs7':
t = self.blocksize - len(self.data) % self.blocksize
pad = i2b(t, 1)
for _ in range(t):
self.data += pad
else:
raise ('没有这种填充方式。')
# 反填充
def rePadding(self, s):
if s.lower() == 'zero':
las = len(self.cdata) - 1
while self.cdata[las] == 0:
las -= 1
self.cdata = self.cdata[0:las + 1]
elif s.lower() == 'pkcs7':
num = self.cdata[-1]
self.cdata = self.cdata[0:len(self.cdata) - num]
else:
raise ('没有这种填充方式。')
# ECB模式加密
def ECB_E(self, key):
self.cdata = b''
self.a.generateKey(key)
for i in range(0, len(self.data), self.blocksize):
self.cdata += self.a.aBlockEncode(self.data[i:i + self.blocksize])
# ECB模式解密
def ECB_D(self, key):
self.cdata = b''
self.a.generateKey(key)
for i in range(0, len(self.data), self.blocksize):
self.cdata += self.a.aBlockDecode(self.data[i:i + self.blocksize])
# CBC模式加密
def CBC_E(self, key, IV):
self.cdata = b''
self.a.generateKey(key)
for i in range(0, len(self.data), self.blocksize):
tmp = b''
# print(len(self.data))
for j in range(self.blocksize):
# print(j,i+j)
tmp += i2b(IV[j] ^ self.data[i + j], 1)
IV = self.a.aBlockEncode(tmp)
self.cdata += IV
# CBC模式解密
def CBC_D(self, key, IV):
self.cdata = b''
self.a.generateKey(key)
for i in range(0, len(self.data), self.blocksize):
tmp = self.a.aBlockDecode(self.data[i:i + self.blocksize])
for j in range(self.blocksize):
self.cdata += i2b(IV[j] ^ tmp[j], 1)
IV = self.data[i:i + self.blocksize]
# CFB模式加密
def CFB_E(self, key, IV, cfb_s=8):
if cfb_s % 8 != 0 or cfb_s > self.blocksize * 8:
raise ('明文分组长度出错。')
self.cdata = b''
self.a.generateKey(key)
for i in range(0, len(self.data), cfb_s // 8):
tmp = b''
eIV = self.a.aBlockEncode(IV)
for j in range(cfb_s // 8):
tmp += i2b(eIV[j] ^ self.data[i + j], 1)
IV = IV[cfb_s // 8:] + tmp
self.cdata += tmp
# CFB模式解密
def CFB_D(self, key, IV, cfb_s=8):
if cfb_s % 8 != 0 or cfb_s > self.blocksize * 8:
raise ('明文分组长度出错。')
self.cdata = b''
self.a.generateKey(key)
for i in range(0, len(self.data), cfb_s // 8):
tmp = b''
eIV = self.a.aBlockEncode(IV)
for j in range(cfb_s // 8):
tmp += i2b(eIV[j] ^ self.data[i + j], 1)
IV = IV[cfb_s // 8:] + self.data[i:i + cfb_s // 8]
self.cdata += tmp
# 文件加密
def encryptFile(self,
filename,
key,
IV,
mode='cbc',
padding='pkcs7',
coding='base64',
cfb_s=8):
self.readFile(filename)
self.aPadding(padding)
if mode.lower() == 'ecb':
print('请注意，ECB模式可能不安全！')
self.ECB_E(key)
elif mode.lower() == 'cbc':
self.CBC_E(key, IV)
elif mode.lower() == 'cfb':
self.CFB_E(key, IV, cfb_s)
else:
raise ('没有这种工作模式。')
if coding.lower() == 'base64':
self.cdata = base64.b64encode(self.cdata)
elif coding.lower() == 'hex':
self.cdata = ''.join([hex(i)[2:]
for i in self.cdata]).encode('utf-8')
else:
raise ('没有这种编码方案')
self.writeFile(filename, '.encrypt')
# 文件解密
def decryptFile(self,
filename,
key,
IV,
mode='cbc',
padding='pkcs7',
coding='base64',
cfb_s=8):
self.readFile(filename)
if coding.lower() == 'base64':
self.data = base64.b64decode(self.data)
elif coding.lower() == 'hex':
tmp = b''
for i in range(0, len(self.data), 2):
tmp += i2b(int(self.data[i:i + 2].decode('utf-8'), 16), 1)
self.data = tmp
else:
raise ('没有这种编码方案')
if mode.lower() == 'ecb':
self.ECB_D(key)
elif mode.lower() == 'cbc':
self.CBC_D(key, IV)
elif mode.lower() == 'cfb':
self.CFB_D(key, IV, cfb_s)
else:
raise ('没有这种工作模式。')
self.rePadding(padding)
self.writeFile(filename, '.decrypt')
# 测试模式
def show(self):
s = b'zzzzzzzz'
self.encryptFile('BlockCipher\\123.txt',
s,
s,
mode='cfb',
padding='pkcs7',
coding='base64')
self.decryptFile('BlockCipher\\123.txt.encrypt',
s,
s,
mode='cfb',
padding='pkcs7',
coding='base64')
from des import DES
a = DES("hllowrld", "0123456789abcdef")
print a.encrypt()
text = ''.join([char for char in text.lower() if char in 'abcdefghijklmnopqrstuvwxyz'])
def build_freq(text):
freq = {char: 0 for char in 'abcdefghijklmnopqrstuvwxyz'}
for char in text:
if char in freq:
freq[char] += 1
return freq
def plot(text, max_freq_plaintext, label, marker):
freq = build_freq(text)
rel_freq = {char: freq[char]/max_freq_plaintext for char in freq}
plt.plot(sorted(rel_freq.values(), reverse=True), label=label, marker=marker)
ccipher = CaeserCipher()
vcipher = VigenereCipher("cryptography")
pcipher = PlayfairCipher("cryptography")
dcipher = DES()
max_freq_plaintext = max(build_freq(text).values())
plot(text, max_freq_plaintext, 'Plaintext', '>')
plot(ccipher.encrypt(text), max_freq_plaintext, 'Caeser Cipher', '<')
plot(vcipher.encrypt(text), max_freq_plaintext, 'Vigenere Cipher', '+')
plot(pcipher.encrypt(text), max_freq_plaintext, 'Playfair Cipher', 'x')
plot(dcipher.encrypt("monarchy", text), max_freq_plaintext, 'DES', 'o')
plt.xlabel('Frequency ranked letters')
plt.ylabel('Relative frequency')
plt.title("Simmon's Experiment")
plt.legend()
plt.show()
