]> gitweb @ CieloNegro.org - youtube-dl.git/blob - youtube_dl/aes.py
fix multi_video part naming, add upload_date field
[youtube-dl.git] / youtube_dl / aes.py
1 from __future__ import unicode_literals
2
3 import base64
4 from math import ceil
5
6 from .utils import bytes_to_intlist, intlist_to_bytes
7
8 BLOCK_SIZE_BYTES = 16
9
10
11 def aes_ctr_decrypt(data, key, counter):
12     """
13     Decrypt with aes in counter mode
14
15     @param {int[]} data        cipher
16     @param {int[]} key         16/24/32-Byte cipher key
17     @param {instance} counter  Instance whose next_value function (@returns {int[]}  16-Byte block)
18                                returns the next counter block
19     @returns {int[]}           decrypted data
20     """
21     expanded_key = key_expansion(key)
22     block_count = int(ceil(float(len(data)) / BLOCK_SIZE_BYTES))
23
24     decrypted_data = []
25     for i in range(block_count):
26         counter_block = counter.next_value()
27         block = data[i * BLOCK_SIZE_BYTES: (i + 1) * BLOCK_SIZE_BYTES]
28         block += [0] * (BLOCK_SIZE_BYTES - len(block))
29
30         cipher_counter_block = aes_encrypt(counter_block, expanded_key)
31         decrypted_data += xor(block, cipher_counter_block)
32     decrypted_data = decrypted_data[:len(data)]
33
34     return decrypted_data
35
36
37 def aes_cbc_decrypt(data, key, iv):
38     """
39     Decrypt with aes in CBC mode
40
41     @param {int[]} data        cipher
42     @param {int[]} key         16/24/32-Byte cipher key
43     @param {int[]} iv          16-Byte IV
44     @returns {int[]}           decrypted data
45     """
46     expanded_key = key_expansion(key)
47     block_count = int(ceil(float(len(data)) / BLOCK_SIZE_BYTES))
48
49     decrypted_data = []
50     previous_cipher_block = iv
51     for i in range(block_count):
52         block = data[i * BLOCK_SIZE_BYTES: (i + 1) * BLOCK_SIZE_BYTES]
53         block += [0] * (BLOCK_SIZE_BYTES - len(block))
54
55         decrypted_block = aes_decrypt(block, expanded_key)
56         decrypted_data += xor(decrypted_block, previous_cipher_block)
57         previous_cipher_block = block
58     decrypted_data = decrypted_data[:len(data)]
59
60     return decrypted_data
61
62
63 def key_expansion(data):
64     """
65     Generate key schedule
66
67     @param {int[]} data  16/24/32-Byte cipher key
68     @returns {int[]}     176/208/240-Byte expanded key
69     """
70     data = data[:]  # copy
71     rcon_iteration = 1
72     key_size_bytes = len(data)
73     expanded_key_size_bytes = (key_size_bytes // 4 + 7) * BLOCK_SIZE_BYTES
74
75     while len(data) < expanded_key_size_bytes:
76         temp = data[-4:]
77         temp = key_schedule_core(temp, rcon_iteration)
78         rcon_iteration += 1
79         data += xor(temp, data[-key_size_bytes: 4 - key_size_bytes])
80
81         for _ in range(3):
82             temp = data[-4:]
83             data += xor(temp, data[-key_size_bytes: 4 - key_size_bytes])
84
85         if key_size_bytes == 32:
86             temp = data[-4:]
87             temp = sub_bytes(temp)
88             data += xor(temp, data[-key_size_bytes: 4 - key_size_bytes])
89
90         for _ in range(3 if key_size_bytes == 32 else 2 if key_size_bytes == 24 else 0):
91             temp = data[-4:]
92             data += xor(temp, data[-key_size_bytes: 4 - key_size_bytes])
93     data = data[:expanded_key_size_bytes]
94
95     return data
96
97
98 def aes_encrypt(data, expanded_key):
99     """
100     Encrypt one block with aes
101
102     @param {int[]} data          16-Byte state
103     @param {int[]} expanded_key  176/208/240-Byte expanded key
104     @returns {int[]}             16-Byte cipher
105     """
106     rounds = len(expanded_key) // BLOCK_SIZE_BYTES - 1
107
108     data = xor(data, expanded_key[:BLOCK_SIZE_BYTES])
109     for i in range(1, rounds + 1):
110         data = sub_bytes(data)
111         data = shift_rows(data)
112         if i != rounds:
113             data = mix_columns(data)
114         data = xor(data, expanded_key[i * BLOCK_SIZE_BYTES: (i + 1) * BLOCK_SIZE_BYTES])
115
116     return data
117
118
119 def aes_decrypt(data, expanded_key):
120     """
121     Decrypt one block with aes
122
123     @param {int[]} data          16-Byte cipher
124     @param {int[]} expanded_key  176/208/240-Byte expanded key
125     @returns {int[]}             16-Byte state
126     """
127     rounds = len(expanded_key) // BLOCK_SIZE_BYTES - 1
128
129     for i in range(rounds, 0, -1):
130         data = xor(data, expanded_key[i * BLOCK_SIZE_BYTES: (i + 1) * BLOCK_SIZE_BYTES])
131         if i != rounds:
132             data = mix_columns_inv(data)
133         data = shift_rows_inv(data)
134         data = sub_bytes_inv(data)
135     data = xor(data, expanded_key[:BLOCK_SIZE_BYTES])
136
137     return data
138
139
140 def aes_decrypt_text(data, password, key_size_bytes):
141     """
142     Decrypt text
143     - The first 8 Bytes of decoded 'data' are the 8 high Bytes of the counter
144     - The cipher key is retrieved by encrypting the first 16 Byte of 'password'
145       with the first 'key_size_bytes' Bytes from 'password' (if necessary filled with 0's)
146     - Mode of operation is 'counter'
147
148     @param {str} data                    Base64 encoded string
149     @param {str,unicode} password        Password (will be encoded with utf-8)
150     @param {int} key_size_bytes          Possible values: 16 for 128-Bit, 24 for 192-Bit or 32 for 256-Bit
151     @returns {str}                       Decrypted data
152     """
153     NONCE_LENGTH_BYTES = 8
154
155     data = bytes_to_intlist(base64.b64decode(data.encode('utf-8')))
156     password = bytes_to_intlist(password.encode('utf-8'))
157
158     key = password[:key_size_bytes] + [0] * (key_size_bytes - len(password))
159     key = aes_encrypt(key[:BLOCK_SIZE_BYTES], key_expansion(key)) * (key_size_bytes // BLOCK_SIZE_BYTES)
160
161     nonce = data[:NONCE_LENGTH_BYTES]
162     cipher = data[NONCE_LENGTH_BYTES:]
163
164     class Counter(object):
165         __value = nonce + [0] * (BLOCK_SIZE_BYTES - NONCE_LENGTH_BYTES)
166
167         def next_value(self):
168             temp = self.__value
169             self.__value = inc(self.__value)
170             return temp
171
172     decrypted_data = aes_ctr_decrypt(cipher, key, Counter())
173     plaintext = intlist_to_bytes(decrypted_data)
174
175     return plaintext
176
177 RCON = (0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36)
178 SBOX = (0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
179         0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
180         0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
181         0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
182         0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
183         0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
184         0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
185         0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
186         0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
187         0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
188         0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
189         0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
190         0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
191         0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
192         0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
193         0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16)
194 SBOX_INV = (0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
195             0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
196             0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
197             0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
198             0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
199             0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
200             0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
201             0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
202             0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
203             0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
204             0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
205             0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
206             0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
207             0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
208             0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
209             0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d)
210 MIX_COLUMN_MATRIX = ((0x2, 0x3, 0x1, 0x1),
211                      (0x1, 0x2, 0x3, 0x1),
212                      (0x1, 0x1, 0x2, 0x3),
213                      (0x3, 0x1, 0x1, 0x2))
214 MIX_COLUMN_MATRIX_INV = ((0xE, 0xB, 0xD, 0x9),
215                          (0x9, 0xE, 0xB, 0xD),
216                          (0xD, 0x9, 0xE, 0xB),
217                          (0xB, 0xD, 0x9, 0xE))
218 RIJNDAEL_EXP_TABLE = (0x01, 0x03, 0x05, 0x0F, 0x11, 0x33, 0x55, 0xFF, 0x1A, 0x2E, 0x72, 0x96, 0xA1, 0xF8, 0x13, 0x35,
219                       0x5F, 0xE1, 0x38, 0x48, 0xD8, 0x73, 0x95, 0xA4, 0xF7, 0x02, 0x06, 0x0A, 0x1E, 0x22, 0x66, 0xAA,
220                       0xE5, 0x34, 0x5C, 0xE4, 0x37, 0x59, 0xEB, 0x26, 0x6A, 0xBE, 0xD9, 0x70, 0x90, 0xAB, 0xE6, 0x31,
221                       0x53, 0xF5, 0x04, 0x0C, 0x14, 0x3C, 0x44, 0xCC, 0x4F, 0xD1, 0x68, 0xB8, 0xD3, 0x6E, 0xB2, 0xCD,
222                       0x4C, 0xD4, 0x67, 0xA9, 0xE0, 0x3B, 0x4D, 0xD7, 0x62, 0xA6, 0xF1, 0x08, 0x18, 0x28, 0x78, 0x88,
223                       0x83, 0x9E, 0xB9, 0xD0, 0x6B, 0xBD, 0xDC, 0x7F, 0x81, 0x98, 0xB3, 0xCE, 0x49, 0xDB, 0x76, 0x9A,
224                       0xB5, 0xC4, 0x57, 0xF9, 0x10, 0x30, 0x50, 0xF0, 0x0B, 0x1D, 0x27, 0x69, 0xBB, 0xD6, 0x61, 0xA3,
225                       0xFE, 0x19, 0x2B, 0x7D, 0x87, 0x92, 0xAD, 0xEC, 0x2F, 0x71, 0x93, 0xAE, 0xE9, 0x20, 0x60, 0xA0,
226                       0xFB, 0x16, 0x3A, 0x4E, 0xD2, 0x6D, 0xB7, 0xC2, 0x5D, 0xE7, 0x32, 0x56, 0xFA, 0x15, 0x3F, 0x41,
227                       0xC3, 0x5E, 0xE2, 0x3D, 0x47, 0xC9, 0x40, 0xC0, 0x5B, 0xED, 0x2C, 0x74, 0x9C, 0xBF, 0xDA, 0x75,
228                       0x9F, 0xBA, 0xD5, 0x64, 0xAC, 0xEF, 0x2A, 0x7E, 0x82, 0x9D, 0xBC, 0xDF, 0x7A, 0x8E, 0x89, 0x80,
229                       0x9B, 0xB6, 0xC1, 0x58, 0xE8, 0x23, 0x65, 0xAF, 0xEA, 0x25, 0x6F, 0xB1, 0xC8, 0x43, 0xC5, 0x54,
230                       0xFC, 0x1F, 0x21, 0x63, 0xA5, 0xF4, 0x07, 0x09, 0x1B, 0x2D, 0x77, 0x99, 0xB0, 0xCB, 0x46, 0xCA,
231                       0x45, 0xCF, 0x4A, 0xDE, 0x79, 0x8B, 0x86, 0x91, 0xA8, 0xE3, 0x3E, 0x42, 0xC6, 0x51, 0xF3, 0x0E,
232                       0x12, 0x36, 0x5A, 0xEE, 0x29, 0x7B, 0x8D, 0x8C, 0x8F, 0x8A, 0x85, 0x94, 0xA7, 0xF2, 0x0D, 0x17,
233                       0x39, 0x4B, 0xDD, 0x7C, 0x84, 0x97, 0xA2, 0xFD, 0x1C, 0x24, 0x6C, 0xB4, 0xC7, 0x52, 0xF6, 0x01)
234 RIJNDAEL_LOG_TABLE = (0x00, 0x00, 0x19, 0x01, 0x32, 0x02, 0x1a, 0xc6, 0x4b, 0xc7, 0x1b, 0x68, 0x33, 0xee, 0xdf, 0x03,
235                       0x64, 0x04, 0xe0, 0x0e, 0x34, 0x8d, 0x81, 0xef, 0x4c, 0x71, 0x08, 0xc8, 0xf8, 0x69, 0x1c, 0xc1,
236                       0x7d, 0xc2, 0x1d, 0xb5, 0xf9, 0xb9, 0x27, 0x6a, 0x4d, 0xe4, 0xa6, 0x72, 0x9a, 0xc9, 0x09, 0x78,
237                       0x65, 0x2f, 0x8a, 0x05, 0x21, 0x0f, 0xe1, 0x24, 0x12, 0xf0, 0x82, 0x45, 0x35, 0x93, 0xda, 0x8e,
238                       0x96, 0x8f, 0xdb, 0xbd, 0x36, 0xd0, 0xce, 0x94, 0x13, 0x5c, 0xd2, 0xf1, 0x40, 0x46, 0x83, 0x38,
239                       0x66, 0xdd, 0xfd, 0x30, 0xbf, 0x06, 0x8b, 0x62, 0xb3, 0x25, 0xe2, 0x98, 0x22, 0x88, 0x91, 0x10,
240                       0x7e, 0x6e, 0x48, 0xc3, 0xa3, 0xb6, 0x1e, 0x42, 0x3a, 0x6b, 0x28, 0x54, 0xfa, 0x85, 0x3d, 0xba,
241                       0x2b, 0x79, 0x0a, 0x15, 0x9b, 0x9f, 0x5e, 0xca, 0x4e, 0xd4, 0xac, 0xe5, 0xf3, 0x73, 0xa7, 0x57,
242                       0xaf, 0x58, 0xa8, 0x50, 0xf4, 0xea, 0xd6, 0x74, 0x4f, 0xae, 0xe9, 0xd5, 0xe7, 0xe6, 0xad, 0xe8,
243                       0x2c, 0xd7, 0x75, 0x7a, 0xeb, 0x16, 0x0b, 0xf5, 0x59, 0xcb, 0x5f, 0xb0, 0x9c, 0xa9, 0x51, 0xa0,
244                       0x7f, 0x0c, 0xf6, 0x6f, 0x17, 0xc4, 0x49, 0xec, 0xd8, 0x43, 0x1f, 0x2d, 0xa4, 0x76, 0x7b, 0xb7,
245                       0xcc, 0xbb, 0x3e, 0x5a, 0xfb, 0x60, 0xb1, 0x86, 0x3b, 0x52, 0xa1, 0x6c, 0xaa, 0x55, 0x29, 0x9d,
246                       0x97, 0xb2, 0x87, 0x90, 0x61, 0xbe, 0xdc, 0xfc, 0xbc, 0x95, 0xcf, 0xcd, 0x37, 0x3f, 0x5b, 0xd1,
247                       0x53, 0x39, 0x84, 0x3c, 0x41, 0xa2, 0x6d, 0x47, 0x14, 0x2a, 0x9e, 0x5d, 0x56, 0xf2, 0xd3, 0xab,
248                       0x44, 0x11, 0x92, 0xd9, 0x23, 0x20, 0x2e, 0x89, 0xb4, 0x7c, 0xb8, 0x26, 0x77, 0x99, 0xe3, 0xa5,
249                       0x67, 0x4a, 0xed, 0xde, 0xc5, 0x31, 0xfe, 0x18, 0x0d, 0x63, 0x8c, 0x80, 0xc0, 0xf7, 0x70, 0x07)
250
251
252 def sub_bytes(data):
253     return [SBOX[x] for x in data]
254
255
256 def sub_bytes_inv(data):
257     return [SBOX_INV[x] for x in data]
258
259
260 def rotate(data):
261     return data[1:] + [data[0]]
262
263
264 def key_schedule_core(data, rcon_iteration):
265     data = rotate(data)
266     data = sub_bytes(data)
267     data[0] = data[0] ^ RCON[rcon_iteration]
268
269     return data
270
271
272 def xor(data1, data2):
273     return [x ^ y for x, y in zip(data1, data2)]
274
275
276 def rijndael_mul(a, b):
277     if(a == 0 or b == 0):
278         return 0
279     return RIJNDAEL_EXP_TABLE[(RIJNDAEL_LOG_TABLE[a] + RIJNDAEL_LOG_TABLE[b]) % 0xFF]
280
281
282 def mix_column(data, matrix):
283     data_mixed = []
284     for row in range(4):
285         mixed = 0
286         for column in range(4):
287             # xor is (+) and (-)
288             mixed ^= rijndael_mul(data[column], matrix[row][column])
289         data_mixed.append(mixed)
290     return data_mixed
291
292
293 def mix_columns(data, matrix=MIX_COLUMN_MATRIX):
294     data_mixed = []
295     for i in range(4):
296         column = data[i * 4: (i + 1) * 4]
297         data_mixed += mix_column(column, matrix)
298     return data_mixed
299
300
301 def mix_columns_inv(data):
302     return mix_columns(data, MIX_COLUMN_MATRIX_INV)
303
304
305 def shift_rows(data):
306     data_shifted = []
307     for column in range(4):
308         for row in range(4):
309             data_shifted.append(data[((column + row) & 0b11) * 4 + row])
310     return data_shifted
311
312
313 def shift_rows_inv(data):
314     data_shifted = []
315     for column in range(4):
316         for row in range(4):
317             data_shifted.append(data[((column - row) & 0b11) * 4 + row])
318     return data_shifted
319
320
321 def inc(data):
322     data = data[:]  # copy
323     for i in range(len(data) - 1, -1, -1):
324         if data[i] == 255:
325             data[i] = 0
326         else:
327             data[i] = data[i] + 1
328             break
329     return data
330
331 __all__ = ['aes_encrypt', 'key_expansion', 'aes_ctr_decrypt', 'aes_cbc_decrypt', 'aes_decrypt_text']