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 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 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
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'))))
# 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]
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)
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()
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)
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 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_)
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)
def main(f_input="input.txt"): cipher = DES() #cipher.encrypt("abcdefgh") c = cipher.encrypt(f_input) p = cipher.decrypt(c)
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()