1. Basic Concepts

• Symmetric encryption:
  Symmetric encryption is an encryption method that uses a single-key cryptosystem, in which the same key is used both to encrypt and to decrypt the information. Because it is fast, it is often used to encrypt the transmission of large amounts of data.
• DES (Data Encryption Standard):
  The key length of DES is 56 bits, and the theoretical security strength of the algorithm is \( 2^{56} \). As computer processing power has increased, DES can no longer provide sufficient security.
• AES (Advanced Encryption Standard):
  In January 1997, the U.S. National Institute of Standards and Technology began soliciting proposals for an Advanced Encryption Standard, and drew responses from many scholars. After rounds of screening and performance testing, the Rijndael algorithm was finally selected. The algorithm was designed by the Belgian cryptographers Joan Daemen and Vincent Rijmen.

2. Basic Principles

Below is an animated diagram of the encryption process.

The AES encryption algorithm involves 4 operations.

• 1. SubBytes:
     The main function of byte substitution is to complete a mapping from one byte to another
• 2. ShiftRows:
     ShiftRows is a permutation between bytes within a 4x4 matrix, used to provide diffusion for the algorithm.
• 3. MixColumns:
     MixColumns is a substitution that exploits the arithmetic properties of the GF(\( 2^{8} \)) field, and is likewise used to provide diffusion for the algorithm.
• 4. AddRoundKey:
     Every byte in the matrix is XORed with the round key for that round; each subkey is produced by the key generation scheme.

Below is an illustration of the AES encryption algorithm:

3. Modes of Operation

Block ciphers perform encryption and decryption according to the block size — for example, the block size of the DES algorithm is 64 bits, while that of AES is 128 bits — but the actual length of the plaintext is generally far greater than the block size. How is such a case handled?

What a mode of operation specifies is exactly these questions: how large a block the plaintext data stream is split into, and how to handle data that does not align.

The main modes of operation:

• Electronic Code Book Mode (ECB):
  ECB mode merely splits the plaintext by block size and then normally encrypts the resulting plaintext blocks with the same key. The ideal use case for ECB is the encryption of short data (such as an encryption key). The problem with this mode is that it cannot hide the patterns of the original plaintext data, because identical plaintext blocks yield identical ciphertext when encrypted.
• Cipher Block Chaining Mode (CBC): introduces the concept of the IV (Initialization Vector). Compared with ECB, CBC mode achieves better pattern hiding, but because it brings the ciphertext into the computation, encryption and decryption operations cannot be performed in parallel. In addition, the IV it introduces must also be known to both the encrypting and the decrypting party.
• Cipher Feedback Mode (CFB): similar to CBC mode, but the difference is that CFB mode first generates a keystream dictionary and then XORs the cipher dictionary with the plaintext to finally produce the ciphertext. Generating the cipher dictionary for the next block requires the ciphertext of the previous block to take part in the computation.
• Output Feedback Mode (OFB): the difference between OFB mode and CFB mode is that the plaintext takes part in the computation when generating the dictionary, whereas CFB uses the ciphertext.
• Counter Mode (CTR): CTR mode likewise generates a stream-cipher dictionary, but at the same time it introduces a counter, to guarantee that no repeated output is produced no matter how long it runs.

4. Padding

The purpose of padding is to extend the length of plain text to the required length before encryption. ECB and CBC require padding, that is, the encrypted length may differ; CFB, OFB, and CTR do not require padding, and the ciphertext length is the same as the plaintext length. The main padding modes are PKCS7, ANSIX923, ISO10126, NoPadding, and ZeroPadding.

• PKCS7: the padding string consists of a sequence of bytes, and each byte is filled with the length of that byte sequence
• ANSIX923: the padding string contains a byte sequence padded with zeros
• ISO10126: the padding string contains random data of the length
• NoPadding: no padding is done
• ZeroPadding: the padding string consists of bytes set to zero

Example:

数据︰ FF FF FF FF FF FF FF FF FF PKCS7 填充︰ FF FF FF FF FF FF FF FF FF 07 07
07 07-07-07 07 ANSIX923填充︰ FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 07
ISO10126 填充︰ FF FF FF FF FF FF FF FF FF 7 D 2A 75 EF F8 EF 07 ZeroPadding
填充︰ FF FF FF FF FF FF FF FF FF 00 00 00 00 00 00 00

5. Frontend AES Encryption - JavaScript

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<script src="cryptojs/3.1.2/rollups/aes.js"></script>
<script src="cryptojs/3.1.2/components/pad-zeropadding-min.js"></script>
<script type="text/javascript">
  var str = "my_text";
  // 密钥key长度必须为16（AES-128）、24（AES-192）、或32（AES-256）Bytes 长度
  var key = "mDSR16qzlugnyK0wBJZOAhTHoI4sP7df";
  // 初始向量 initial vector 16 位，这里为了简便，直接截取key前16位
  var iv = key.substring(0, 16);
  // key 和 iv 可以一致

  key = CryptoJS.enc.Utf8.parse(key);
  iv = CryptoJS.enc.Utf8.parse(iv);

  //加密过程
  var encrypted = CryptoJS.AES.encrypt(str, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.ZeroPadding,
  });
  // mode 支持 CBC、CFB、CTR、ECB、OFB, 默认 CBC
  // padding 支持 Pkcs7、AnsiX923、Iso10126、NoPadding、ZeroPadding, 默认 Pkcs7

  // 转换为字符串，"7sLMd96Msn24voJuuLDllw=="
  encrypted = encrypted.toString();

  //解密过程
  var decrypted = CryptoJS.AES.decrypt(encrypted, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.ZeroPadding,
  });

  // 转换为 utf8 字符串，"my_text"
  decrypted = CryptoJS.enc.Utf8.stringify(decrypted);
</script>

6. Backend AES Encryption - Python

• Install the PyCrypto library

To use AES encryption in Python, you only need to install the PyCrypto library.

1

pip install pycrypto

• Generate a Key

The optional length of an AES key must be 16 bytes, 24 bytes, or 32 bytes.

1
2

import random, string
key = ''.join(random.sample(string.ascii_letters + string.digits, 16))

• AES encryption function prototype

1
2

from Crypto.Cipher import AES
cipher = AES.new(key, mode, iv)

• key: the initial key. According to the AES specification, it can be 16 bytes, 24 bytes, or 32 bytes long, corresponding to 128 bits, 192 bits, and 256 bits respectively
• mode: the encryption mode. You can look up the relevant documentation to learn about it. The examples that follow use CBC mode, so a brief explanation is given here: in CBC mode, the plaintext is first split into several small segments, then each small segment is XORed with the initial block or the ciphertext segment of the previous segment, and only then encrypted with the key
• iv: the initialization vector. It is needed in some encryption modes; for CBC mode, for instance, it must be chosen randomly and must be kept secret; moreover, its length is the same as the block size (the AES block length is fixed at 16 bytes)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# encoding:utf-8
import string
import base64
import random
from Crypto.Cipher import AES

class AESecrypt():
    def __init__(self, key, padding='\0'):
        # 这里密钥key 长度必须为16（AES-128）、24（AES-192）、或32（AES-256）Bytes 长度
        self.key = key
        self.iv = key[:AES.block_size]
        self.mode = AES.MODE_CBC
        self.padding = padding
        # self.is_unicode = False
    # 加密函数，如果text不是16的倍数【加密文本text必须为16的倍数！】，那就补足为16的倍数

    def encrypt(self, text):
        # if isinstance(text, unicode):
        #     text = text.encode('utf-8')
            # self.is_unicode = True
        cryptor = AES.new(self.key, self.mode, IV=self.iv)
        length = AES.block_size
        count = len(text)
        add = count % length
        if add:
            text = text + (self.padding * (length - add))
        self.ciphertext = cryptor.encrypt(text)
        # 因为AES加密时候得到的字符串不一定是ascii字符集的，输出到终端或者保存时候可能存在问题
        # 所以这里统一把加密后的字符串用base64转化
        return base64.b64encode(self.ciphertext)
    # 解密后，去掉补足的'\0'用strip() 去掉

    def decrypt(self, text):
        cryptor = AES.new(self.key, self.mode, IV=self.iv)
        plain_text = cryptor.decrypt(base64.b64decode(text)).rstrip(self.padding)
        # return plain_text.decode('utf-8') if self.is_unicode else plain_text
        return plain_text

if __name__ == '__main__':
    key = ''.join(random.sample(string.ascii_letters + string.digits, 32))
    print 'key:{key}, length:{length}'.format(key=key, length=len(key))
    tool = AESecrypt(key)

    e_text_en = tool.encrypt('my_text')
    print u'encrypt_text_en:{text}'.format(text=e_text_en)
    d_text_en = tool.decrypt(e_text_en)
    print 'de_text_en:{text}'.format(text=d_text_en)

    # e_text_cn = tool.encrypt(u'中文文本')
    # print 'encrypt_text_cn:{text}'.format(text=e_text_cn)
    # d_text_cn = tool.decrypt(e_text_cn)
    # print u'de_text_en:{text}'.format(text=d_text_cn)

Output:

1
2
3

key:8YkSbojRzx3AJfuX2QdD6s5HWFcL1iE4, length:32
encrypt_text_en:YZ5PUFJIqYeSDbD8ORq5Qg==
de_text_en:my_text

7. References

• https://github.com/matt-wu/AES