My hexidigit is changing on day by day basis. How can I change it back to static
Code
from Crypto.Cipher import AES
import pandas as pd
import mysql.connector
myconn = mysql.connector.connect(host="######", user="##", password="######", database="#######")
query = """SELECT * from table """
df = pd.read_sql(query, myconn) #getting hexidigit back from the SQL server after dumping the ecrypted data into the database
def resize_length(string):
#resizes the String to a size divisible by 16 (needed for this Cipher)
return string.rjust((len(string) // 16 + 1) * 16)
def encrypt(url, cipher):
# Converts the string to bytes and encodes them with your Cipher
cipherstring = cipher.encrypt(resize_length(url).encode())
cipherstring = "".join("{:02x}".format(c) for c in cipherstring)
return cipherstring
def decrypt(text, cipher):
# Converts the string to bytes and decodes them with your Cipher
text = bytes.fromhex(text)
original_url = cipher.decrypt(text).decode().lstrip()
return original_url
# It is important to use 2 ciphers with the same information, else the system breaks
# Define the Cipher with your data (Encryption Key and IV)
cipher1 = AES.new('This is a key123', AES.MODE_CBC, 'This is an IV456')
cipher2 = AES.new('This is a key123', AES.MODE_CBC, 'This is an IV456')
message = df['values'][4]
eypt = encrypt(message, cipher1)
print(decrypt(eypt, cipher2))
I'm able to decrypt the string after calling from database but on the next day the encrypted string changes which fails my code. How can I freeze this? Keeping a constant string everyday?
I got the solution by encrypting the key using bytes()
Use the byte method to store the key in secured config file or database and encrypt the byte string to get the key. After that use any cipher method with suitable algorithm to encrypt the data and mask it.
Related
so i want to encrypt text to audio mp3. but when i run the code, there's error message Exception Type: AssertionError. and it's say there's error at
assert len(key) == key_bytes
can someone please check what's error with the function? i want encrypt using AES 128 and 256, please help me.
from Crypto.Cipher import AES
from Crypto.Util import Counter
from Crypto import Random
import binascii
key_bytes = 16
# Takes as input a 32-byte key and an arbitrary-length plaintext and returns a
# pair (iv, ciphtertext). "iv" stands for initialization vector.
def encrypt(key, testaudio):
assert len(key) == key_bytes
print(testaudio)
print(key)
# Choose a random, 16-byte IV.
iv = Random.new().read(AES.block_size)
# Convert the IV to a Python integer.
iv_int = int(binascii.hexlify(iv), 16)
# Create a new Counter object with IV = iv_int.
ctr = Counter.new(AES.block_size * 8, initial_value=iv_int)
# Create AES-CTR cipher.
aes = AES.new(key, AES.MODE_CTR, counter=ctr)
# Encrypt and return IV and ciphertext.
ciphertext = aes.encrypt(testaudio)
print(iv)
print(ciphertext)
return (iv, ciphertext)
at my view, i call the function like this. where testaudio have file audio mp3.
enkripsi = encrypt("testing", testaudio)
print(enkripsi)
You have defined the value of key_bytes as 16 but in your encrypt function you are using assert to check whether the length of key which is 7 when you are calling the function(length of word "testing"), either you change the value of key_bytes or change the value of key which you are passing when calling your function.
Edited:
import random, string
len_16_string = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
print(len_16_string)
enkripsi = encrypt(len_16_string, testaudio)
print(enkripsi)
I'm trying to figure out the best way to encrypt and decrypt some JSON data that I'm passing from my client (Python) to server (Java). I keep running into a few errors. Originally I had a set IV that I had hardcoded into both client and server and it was working great, it would encrypt and decrypt as I needed. However, that's obviously a bad idea, I set a random IV that I would then slice with my server and that sorta worked. It would decrpyt most of the data, except for the first 50 bytes or so. They would just be random chars (�6OC� Ղ�{�9��aJ, "number": 1243.2,...etc) and I couldn't parse the JSON.
Then when I try to slice OFF the IV (16 chars) from the decoded bytes I get an error saying that the data needs to be in multiples of 16, but I'm not sure why that isn't working.
Any ideas on how to get this working? Thanks!
Python Client
jsonString = json.dumps(data.__dict__, default=str)
key = 'sixteenssixteens'
text = jsonString
plaintext = self.pad(text)
iv = os.urandom(16)
cipher = AES.new(key, AES.MODE_CBC, iv)
encrpyt_btye = cipher.encrypt(plaintext)
encrpyt_text = base64.urlsafe_b64encode(encrpyt_btye).decode("UTF-8")
requests.post('server', data=encrpy_text)
def pad(self, text):
numberBytestoPad = block_size - len(text) % block_size
ascii_string = chr(numberBytestoPad)
padding_str = numberBytestoPad * ascii_string
padded_text = text + padding_str
return padded_text
Java Server
requestBody = exchange.getRequestBody();
String requestData = readString(requestBody);
System.out.println(requestData);
String key = "sixteenssixteens";
String initVector = requestData.substring(0, 16);
IvParameterSpec iv = new IvParameterSpec(initVector.getBytes("UTF-8"));
SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");
try {
//Tried to remove the IV from the start of the string
// String removeIV = requestData.substring(16);
Cipher cipherd = Cipher.getInstance("AES/CBC/PKCS5PADDING");
cipherd.init(Cipher.DECRYPT_MODE, skeySpec, iv);
byte[] original = cipherd.doFinal(Base64.getUrlDecoder().decode(requestData));
String decryptedResult = new String(original);
System.out.println("Decrypted string: " + decryptedResult);
try {
data = gson.fromJson(decryptedResult, Data.class);
} catch (Exception ex){
ex.printStackTrace();
return;
}
I have a ciphertext that was encrypted using PHP which I need to decrypt using Python.
I have the below PHP code that decrypts the ciphertext perfectly.
$cryptText = "ciphertext";
$iv = "some iv"
$cipher = new Crypt_Rijndael(CRYPT_RIJNDAEL_MODE_CFB);
$password = "some password";
$salt = "some salt";
$cipher->setPassword($password, 'pbkdf2', 'sha512', $salt, 1000, 256 / 8);
$cipher->setIV($iv);
$plaintext = $cipher->decrypt(base64_decode($cryptText));
Now to decrypt it using Python I used 2 approaches
Using pyaes
from base64 import b64encode, b64decode
import hashlib
import pyaes
import os
ciphertext = 'ciphertext'
ciphertext = b64decode(ciphertext)
password = b'some password'
salt = b'some salt'
iv=b'some iv'
key = hashlib.pbkdf2_hmac('sha512', password, salt, 1000, 32)
aes = pyaes.AESModeOfOperationCFB(key, iv = iv)
decryptedData = aes.decrypt(ciphertext)
PyCryptodome (Crypto.Cipher.AES)
import base64
import hashlib
from Crypto import Random
from Crypto.Cipher import AES
import hashlib
ciphertext = 'ciphertext'
ciphertext = b64decode(ciphertext)
password = b'some password'
salt = b'some salt'
iv=b'some iv'
key = hashlib.pbkdf2_hmac('sha512', password, salt, 1000, 32)
cipher = AES.new(key, AES.MODE_CFB, iv)
decryptedData = cipher.decrypt(ciphertext)
The result from 1 and 2 is same but not matching the one from PHP
The PHP code uses a different segment size1) than the two Python codes: The phpseclib v1 specifies with CRYPT_RIJNDAEL_MODE_CFB the CFB mode with a segment size of 128 bits (full-block CFB), while PyCryptodome and pyaes use a segment size of 8 bits by default.
Therefore, a ciphertext that can be decrypted with the PHP code cannot be decrypted with either Python code. For this to be possible, the segment size must be explicitly set to 128 bits in the Python codes,
for PyCryptodome:
cipher = AES.new(key, AES.MODE_CFB, iv=iv, segment_size=128)
for pyaes:
cipher = pyaes.AESModeOfOperationCFB(key, iv=iv, segment_size=16)
Note that for pyaes the segment size is specified in bytes and not in bits. Furthermore, pyaes requires that the plaintext must be an integer multiple of the segment size, i.e. for full-block CFB an integer multiple of 16 bytes.
1) The segment size of the CFB mode corresponds to the bits encrypted per encryption step, see CFB.
from docx import Document
from Crypto.Cipher import AES
document = Document('test.docx')
allText = ""
for docpara in document.paragraphs:
allText+=(docpara.text)
key="1234567891011121"
cipher=AES.new(key,AES.MODE_ECB)
msg=cipher.encrypt(allText)
I want to encrypt a Docx file in python.But when i run this code:
raise TypeError("Object type %s cannot be passed to C code" % type(data))
TypeError: Object type cannot be passed to C code
How can i solve this problem?
From the documentation:
>>> from Crypto.Cipher import AES
>>> from Crypto import Random
>>>
>>> key = b'Sixteen byte key'
>>> iv = Random.new().read(AES.block_size)
>>> cipher = AES.new(key, AES.MODE_CFB, iv)
>>> msg = iv + cipher.encrypt(b'Attack at dawn')
I think your key needs to be converted to bytes first, and the object to be encrypted too. Notice the b' before both.
You also need to add an initialization vector (iv) to use for the encryption.
I am trying to decrypt an AES encrypted data.
I am having the key and iv with me but I think key is also encoded.
Here is the code I have used:
import binascii
from Crypto.Cipher import AES
enckey = '5f35604280b44dd1073f7ee83e346d81'
key = binascii.unhexlify(enckey)
key32 = "{: <32}".format(key).encode("utf-8")
data='692fa1deafad8ad80b98cd6f077899e9be457ac5364c3822aae9457d4912e4829d71cb
8702bd10e1d54f7a0461edba193517b353835480bd174804f586776e623473022548ff098a95
45b608282bf498a36968dd6b858ad631f6eaa79ea1a87c984f4a8da5a9d1cee1b11b32d46c0d
2a670d4e634ecc47c7105387a0a38853c91e10747170de69ebf6f0e1a99f0134ddb0af0cec2c
fc70f53c9eab7227460cf1153ef686a5dc5014bd286fb0efdec571327f5a4874bec5fd5c65f0
9f0ed10e906e4199dd8c3cb8340aca1904f486a70b02554581f0e723d22854188e933ed9fce6
0172099bc675b89eba39651bbc0658ae264213217f14ff4f0824494585d8856dfd44e4ce9505
e43762a9f1ea48f9c736603e83c3e10c5740cdf279dc3a914e19eee089160ffa91180d1b4299
38ab1b6a4272d1779f7702f760cbac3f35fc35c16fcf21c7e00183f306e7a18f71ffb3b62b91
250dca7dd627876a6cedbfe83f0f18abbbb7c7650566a7f761844243fe1271cef22b1026a3f1
d37b8e7bd7c068331897680ec101e269ce66c3f129de33d3277c2cc120feb88f77f1bb851d41
b83468128366b7ed92ae07f37675cee07355ebcdfcba90a690e3d4817cd18123a0c9de175ea6
c5049c51170ee73facd5148f6525024116991b0601598a3501e770493dab0653e146981e91d2
ea9c50fbd1e6b8bb38407655c518f30852ce43ed62d1c578e642c4fa92f00bbf102c3418ed52
ed23138c86d327bbc4718ec44440f289e3af6c096c7ad69af5d941768b0f4b2e3decfad5dcfe
6dc491ce4f2f9d86d226b87f19dfb56dc44f6d66820773e6fcfa4fcd7958da2d639037627057
99a414baf93081242c2b594981c93b892f4f28883203875a4010ace9a5eafea51ee406'
cipher_text = binascii.unhexlify(data)
# Decryption
decryption_suite = AES.new('key32', AES.MODE_CBC, 'heF9BATUfWuISyO8')
plain_text = decryption_suite.decrypt(cipher_text)
print plain_text
And this is the error I am receiving :
UnicodeDecodeError: 'ascii' codec can't decode byte 0x80 in position 4:
ordinal not in range(128)
I am unable to figure out the problem with my key and data...
And please let me know if I have to make any changes to my code.
The following code works:
from Crypto.Cipher import AES
keyAscii = '5f35604280b44dd1073f7ee83e346d81'
keyBinary = bytes(keyAscii, 'ascii')
ciphertextHex='692fa1deafad8ad80b98cd6f077899e9be457ac5364c3822aae9457d4912e4829d71cb8702bd10e1d54f7a0461edba193517b353835480bd174804f586776e623473022548ff098a9545b608282bf498a36968dd6b858ad631f6eaa79ea1a87c984f4a8da5a9d1cee1b11b32d46c0d2a670d4e634ecc47c7105387a0a38853c91e10747170de69ebf6f0e1a99f0134ddb0af0cec2cfc70f53c9eab7227460cf1153ef686a5dc5014bd286fb0efdec571327f5a4874bec5fd5c65f09f0ed10e906e4199dd8c3cb8340aca1904f486a70b02554581f0e723d22854188e933ed9fce60172099bc675b89eba39651bbc0658ae264213217f14ff4f0824494585d8856dfd44e4ce9505e43762a9f1ea48f9c736603e83c3e10c5740cdf279dc3a914e19eee089160ffa91180d1b429938ab1b6a4272d1779f7702f760cbac3f35fc35c16fcf21c7e00183f306e7a18f71ffb3b62b91250dca7dd627876a6cedbfe83f0f18abbbb7c7650566a7f761844243fe1271cef22b1026a3f1d37b8e7bd7c068331897680ec101e269ce66c3f129de33d3277c2cc120feb88f77f1bb851d41b83468128366b7ed92ae07f37675cee07355ebcdfcba90a690e3d4817cd18123a0c9de175ea6c5049c51170ee73facd5148f6525024116991b0601598a3501e770493dab0653e146981e91d2ea9c50fbd1e6b8bb38407655c518f30852ce43ed62d1c578e642c4fa92f00bbf102c3418ed52ed23138c86d327bbc4718ec44440f289e3af6c096c7ad69af5d941768b0f4b2e3decfad5dcfe6dc491ce4f2f9d86d226b87f19dfb56dc44f6d66820773e6fcfa4fcd7958da2d63903762705799a414baf93081242c2b594981c93b892f4f28883203875a4010ace9a5eafea51ee406'
ciphertextBinary = bytes.fromhex(ciphertextHex)
ivAscii = 'heF9BATUfWuISyO8'
ivBinary = bytes(ivAscii, 'ascii')
# Decryption
decrypter = AES.new(keyBinary, AES.MODE_CBC, ivBinary)
plaintextBinary = decrypter.decrypt(ciphertextBinary)
plaintext = plaintextBinary.decode('utf-8')
print(plaintext)
and outputs
connection_type=wifi&android_id=863e87fea9a09533&app_name=AstroNest&app_version=53&app_version_name=2.7.1&device_brand=motorola&device_cpu_type=armv7l&device_model=XT1562&google_aid=ab95a01a-242b-4ac2-ad12-b6189e983a56&google_ad_tracking_disabled=0&insdate=1494826343&installer=com.android.vending&language=en&mac_address=02%3A00%3A00%3A00%3A00%3A00&mat_id=45c0a743-a948-434b-a20d-fe66e870d285&os_version=6.0.1&screen_density=3.0&screen_layout_size=1920x1080&sdk_version=3.11.4&conversion_user_agent=Dalvik%2F2.1.0+%28Linux%3B+U%3B+Android+6.0.1%3B+XT1562+Build%2FMPDS24.107-70-1-5%29¤cy_code=USD&revenue=0.0&system_date=1494826532
But it's cryptographically wrong in many ways:
The key looks like 32 character hex string (which would encode a 128-bit key), but you actually need to treat it as ASCII encoding a 32-byte key. That's wrong, since keys are supposed to be uniformly distributed binary string
Similarly an IV is supposed to be a uniform binary, but it's actually ASCII
The IV is fixed, but the whole point of an IV is to be different (unpredictably random for CBC mode) for each message.
CBC mode is vulnerable to padding oracle attacks, which allow an active attacker to recover the plaintext if they can execute a chosen ciphertext attack where they learn which ciphertext decrypt successfully.
You should use authenticated encryption with unique IVs instead.
this one may help you
import binascii
from Crypto.Cipher import AES
import re
enckey = '5f35604280b44dd1073f7ee83e346d81'
key32 = "{: <32}".format(enckey).encode("utf-8")
cipher = AES.new(key32, AES.MODE_ECB)
data='692fa1deafad8ad80b98cd6f077899e9be457ac5364c3822aae9457d4912e4829d71cb8702bd10e1d54f7a0461edba193517b353835480bd174804f586776e623473022548ff098a9545b608282bf498a36968dd6b858ad631f6eaa79ea1a87c984f4a8da5a9d1cee1b11b32d46c0d2a670d4e634ecc47c7105387a0a38853c91e10747170de69ebf6f0e1a99f0134ddb0af0cec2cfc70f53c9eab7227460cf1153ef686a5dc5014bd286fb0efdec571327f5a4874bec5fd5c65f09f0ed10e906e4199dd8c3cb8340aca1904f486a70b02554581f0e723d22854188e933ed9fce60172099bc675b89eba39651bbc0658ae264213217f14ff4f0824494585d8856dfd44e4ce9505e43762a9f1ea48f9c736603e83c3e10c5740cdf279dc3a914e19eee089160ffa91180d1b429938ab1b6a4272d1779f7702f760cbac3f35fc35c16fcf21c7e00183f306e7a18f71ffb3b62b91250dca7dd627876a6cedbfe83f0f18abbbb7c7650566a7f761844243fe1271cef22b1026a3f1d37b8e7bd7c068331897680ec101e269ce66c3f129de33d3277c2cc120feb88f77f1bb851d41b83468128366b7ed92ae07f37675cee07355ebcdfcba90a690e3d4817cd18123a0c9de175ea6c5049c51170ee73facd5148f6525024116991b0601598a3501e770493dab0653e146981e91d2ea9c50fbd1e6b8bb38407655c518f30852ce43ed62d1c578e642c4fa92f00bbf102c3418ed52ed23138c86d327bbc4718ec44440f289e3af6c096c7ad69af5d941768b0f4b2e3decfad5dcfe6dc491ce4f2f9d86d226b87f19dfb56dc44f6d66820773e6fcfa4fcd7958da2d63903762705799a414baf93081242c2b594981c93b892f4f28883203875a4010ace9a5eafea51ee406'
cipher_text = binascii.unhexlify(data)
# Decryption
plain_text = re.sub('\0*$','', cipher.decrypt( data[16:]))
print plain_text
or try this
import binascii
from Crypto.Cipher import AES
enckey = '5f35604280b44dd1073f7ee83e346d81'
key32 = "{: <32}".format(enckey).encode("utf-8")
cipher = AES.new(key32, AES.MODE_ECB)
data='692fa1deafad8ad80b98cd6f077899e9be457ac5364c3822aae9457d4912e4829d71cb8702bd10e1d54f7a0461edba193517b353835480bd174804f586776e623473022548ff098a9545b608282bf498a36968dd6b858ad631f6eaa79ea1a87c984f4a8da5a9d1cee1b11b32d46c0d2a670d4e634ecc47c7105387a0a38853c91e10747170de69ebf6f0e1a99f0134ddb0af0cec2cfc70f53c9eab7227460cf1153ef686a5dc5014bd286fb0efdec571327f5a4874bec5fd5c65f09f0ed10e906e4199dd8c3cb8340aca1904f486a70b02554581f0e723d22854188e933ed9fce60172099bc675b89eba39651bbc0658ae264213217f14ff4f0824494585d8856dfd44e4ce9505e43762a9f1ea48f9c736603e83c3e10c5740cdf279dc3a914e19eee089160ffa91180d1b429938ab1b6a4272d1779f7702f760cbac3f35fc35c16fcf21c7e00183f306e7a18f71ffb3b62b91250dca7dd627876a6cedbfe83f0f18abbbb7c7650566a7f761844243fe1271cef22b1026a3f1d37b8e7bd7c068331897680ec101e269ce66c3f129de33d3277c2cc120feb88f77f1bb851d41b83468128366b7ed92ae07f37675cee07355ebcdfcba90a690e3d4817cd18123a0c9de175ea6c5049c51170ee73facd5148f6525024116991b0601598a3501e770493dab0653e146981e91d2ea9c50fbd1e6b8bb38407655c518f30852ce43ed62d1c578e642c4fa92f00bbf102c3418ed52ed23138c86d327bbc4718ec44440f289e3af6c096c7ad69af5d941768b0f4b2e3decfad5dcfe6dc491ce4f2f9d86d226b87f19dfb56dc44f6d66820773e6fcfa4fcd7958da2d63903762705799a414baf93081242c2b594981c93b892f4f28883203875a4010ace9a5eafea51ee406'
cipher_text = binascii.unhexlify(data)
# Decryption
plain_text = cipher.decrypt(cipher_text)
print plain_text