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()