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