Beispiel #1
0
p = psutil.Process(os.getpid())
proc_list = p.cpu_affinity()
p.cpu_affinity([proc_list[-1]])

# Perform several encryption / decryption operations

random_iv = bytearray(os.urandom(16))
random_key = bytearray(os.urandom(16))

data = bytearray(list(range(256)))
data1 = data[:151]
data2 = data[151:]

# Note: __PROFILE_AES__ must be defined when building the native
# module in order for the print statements below to work
aes_ctr = AES(mode='ctr', key=random_key, iv=random_iv)
result = aes_ctr.encrypt(data1)
if result:
    print('Encrypted data1 in: %5d cycles' % result)
result = aes_ctr.encrypt(data2)
if result:
    print('Encrypted data2 in: %5d cycles' % result)

data_new = data1 + data2
aes_ctr = AES(mode='ctr', key=random_key, iv=random_iv)
result = aes_ctr.decrypt(data_new)
if result:
    print('Decrypted data in:  %5d cycles' % result)

assert data == data_new, "The demo has failed."
Beispiel #2
0
def encrypt_data(plaintext, master_key):
    AESfunct = AES(master_key)
    encrypted = AES.encrypt(AESfunct, plaintext)
    return encrypted
Beispiel #3
0
def decrypt_data(ciphertext, master_key):
    AESfunct = AES(master_key)
    decrypted = AES.decrypt(AESfunct, ciphertext)
    return decrypted
Beispiel #4
0
 def __init__(self, verbose=True):
     self.VERBOSE = verbose
     self.my_aes = AES()
Beispiel #5
0
from Arytmetyka import Arytmetyka
from PrimeNumberGenerator import PrimeNumberGenerator
from aes import AES

x = 69017099569831250560832963150376437645133154616280229282066864016913299192967373975974831584150053337515088624997114590154194762430279980129131488430577361201004666775725438052779996726942967878531367335142952137219372198784721987921
y = 382901830921830718713621790372180396476213820173980217309281731648720389218321832918302100154138092183902189031289038921083921839021803921730921731478213702183902183921083021830912809312809
m = 69017099569831250560832963150376437645133154616280229282066864016913299192967373975974831584150053337515088624997114590154194762430279980129131488430577361201004666775725438052779996726942967878531367335142952143636431261619027793877014515217929147780926047591594823548628941753213191937582400215035077463393
png = PrimeNumberGenerator()

aes = AES()
aes.prepare_encrypt('CBC')
aes.encrypt_image('eiti.jpg', 'eiti_ecb.bmp', 'eiti_data', 'eiti_key_ecb',
                  'eiti_iv')

aes.prepare_decrypt('CBC', 'eiti_key_ecb', 'eiti_iv')
aes.decrypt_image('eiti_data', 'eiti_ecb_decyrpt.jpg')

aes.prepare_encrypt('CBC')
aes.encrypt_txt('message.txt', 'encrypted_message.txt', 'message_key',
                'message_iv')

aes.prepare_decrypt('CBC', 'message_key', 'message_iv')
aes.decrypt_txt('encrypted_message.txt', 'decrypted_message.txt')
Beispiel #6
0
 def setUp(self):
     master_key = 0x2b7e151628aed2a6abf7158809cf4f3c
     self.AES = AES(master_key, "AES-128")
Beispiel #7
0
def main():
    parser = argparse.ArgumentParser()
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument("-e", "--encrypt", action="store_true")
    group.add_argument("-d", "--decrypt", action="store_true")
    parser.add_argument("input_file")
    parser.add_argument("output_file")
    args = parser.parse_args()

    passwd = getpass.getpass("Enter {} password: "******"encryption" if args.encrypt else "decryption"))

    # AES block size is 128 bits (16 bytes)
    block_size = 16

    # Read input file into memory
    with open(args.input_file, "rb") as f_in:
        file_in = f_in.read()

    # Encryption
    if args.encrypt:
        # Create a random 128 bit salt (16 bytes) used in the key derivation function
        # The salt will be stored as the first block of the ciphertext
        salt = secrets.token_bytes(block_size)

        # Create a random 10-byte nonce
        nonce = secrets.token_bytes(10)

        # Create the IV from the nonce and the initial 6-byte counter value of 0
        # The IV will be stored as the second block of the ciphertext
        counter = 0

        IV = nonce + counter.to_bytes(6, "big")

        # Start AES cipher
        cipher = AES(password_str=passwd, salt=salt, key_len=256)

        # Start CTR mode
        mode = CTR(cipher, nonce)

        file_out = (
            salt + IV +
            encrypt_decrypt(mode.encrypt, file_in, block_size, counter))

        # Create authentication HMAC and store it as the last two blocks of the file
        hmac_val = hmac.digest(key=cipher.hmac_key,
                               msg=file_out,
                               digest=hashlib.sha256)

        # Append HMAC to the ciphertext
        file_out += hmac_val

    # Decryption
    else:
        # Extract the salt from the first 128 bits (16 bytes) of the ciphertext
        salt = file_in[0:block_size]

        # Extract nonce from the first 10 bytes of the second block of the ciphertext
        nonce = file_in[block_size:block_size + 10]

        # Extract the starting counter value from the next 6 bytes of the ciphertext
        counter = file_in[block_size + 10:block_size + 10 + 6]
        counter = int.from_bytes(counter, "big")

        # Extract the HMAC value from the last 2 blocks of the ciphertext
        hmac_val = file_in[-2 * block_size:]

        # Start AES cipher
        cipher = AES(password_str=passwd, salt=salt, key_len=256)

        # Compare HMAC values (remove the HMAC value from the ciphertext before comparing)
        assert hmac.compare_digest(
            hmac_val,
            hmac.digest(
                key=cipher.hmac_key,
                msg=file_in[:-2 * block_size],
                digest=hashlib.sha256,
            ),
        ), "HMAC check failed."

        # Start CTR mode
        mode = CTR(cipher, nonce)

        # Strip the salt, IV and HMAC from the ciphertext
        file_in = file_in[2 * block_size:-2 * block_size]

        file_out = encrypt_decrypt(mode.decrypt, file_in, block_size, counter)

    # Write output file
    with open(args.output_file, "wb") as f_out:
        f_out.write(file_out)

    print("\n{0} successfully completed! {1} has been stored in: {2}".format(
        "Encryption" if args.encrypt else "Decryption",
        "Ciphertext" if args.encrypt else "Plaintext",
        args.output_file,
    ))
Beispiel #8
0
    m -= 1
    m = 4
    k = int(n / m)
    # generate strings
    s = []
    for i in range(2**m):
        st = bin(i)[2:]
        s.append(str('0' * (m - len(st)) + st))
    f = []
    # get frecuency
    for i in s:
        f.append(findf(bn, i))
    sf = 0
    for i in f:
        sf += i**2
    pt = (((2**m) / k) * (sf)) - k
    return pt


k = bytes.fromhex('CFBF50935CE44C197D1459E8483A38FA')
k = bytearray.fromhex('C6CAB7B7B9D584450D0609112FD5F39A')
vi = bytes.fromhex('69F67F1AE5349D250000000000000000')
vi = bytes.fromhex('AF92750E273C5EE60000000000000000')
s = ''
aes = AES(k)
for i in range(64):
    v = bytes.fromhex(hex(int(binascii.hexlify(vi), 16) | i)[2:])
    st = str(binascii.hexlify(aes.encrypt_block(v)))
    s += st[2:len(st) - 1]
print(poker(s))