1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <gtest/gtest.h>
18#include <string.h>
19
20#include <utils/String8.h>
21#include <utils/Vector.h>
22
23#include "AesCtrDecryptor.h"
24
25namespace clearkeydrm {
26
27using namespace android;
28
29class AesCtrDecryptorTest : public ::testing::Test {
30  protected:
31    typedef uint8_t Key[kBlockSize];
32
33    status_t attemptDecrypt(const Key& key, const Iv& iv, const uint8_t* source,
34                            uint8_t* destination, const SubSample* subSamples,
35                            size_t numSubSamples, size_t* bytesDecryptedOut) {
36        Vector<uint8_t> keyVector;
37        keyVector.appendArray(key, sizeof(key) / sizeof(uint8_t));
38
39        AesCtrDecryptor decryptor;
40        return decryptor.decrypt(keyVector, iv, source, destination, subSamples,
41                                 numSubSamples, bytesDecryptedOut);
42    }
43
44    template <size_t totalSize>
45    void attemptDecryptExpectingSuccess(const Key& key, const Iv& iv,
46                                        const uint8_t* encrypted,
47                                        const uint8_t* decrypted,
48                                        const SubSample* subSamples,
49                                        size_t numSubSamples) {
50        uint8_t outputBuffer[totalSize] = {};
51        size_t bytesDecrypted = 0;
52        ASSERT_EQ(android::OK, attemptDecrypt(key, iv, encrypted, outputBuffer,
53                                              subSamples, numSubSamples,
54                                              &bytesDecrypted));
55        EXPECT_EQ(totalSize, bytesDecrypted);
56        EXPECT_EQ(0, memcmp(outputBuffer, decrypted, totalSize));
57    }
58};
59
60TEST_F(AesCtrDecryptorTest, DecryptsWithEmptyKey) {
61    const size_t kTotalSize = 64;
62    const size_t kNumSubsamples = 1;
63
64    // Test vectors from NIST-800-38A
65    Iv iv = {
66        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
67        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
68    };
69
70    uint8_t source[kTotalSize] = { 0 };
71    uint8_t destination[kTotalSize] = { 0 };
72    SubSample subSamples[kNumSubsamples] = {
73        {0, 64}
74    };
75
76    size_t bytesDecrypted = 0;
77    Vector<uint8_t> keyVector;
78    keyVector.clear();
79
80    AesCtrDecryptor decryptor;
81    ASSERT_EQ(android::ERROR_DRM_DECRYPT, decryptor.decrypt(keyVector, iv,
82              &source[0], &destination[0],
83              &subSamples[0], kNumSubsamples, &bytesDecrypted));
84    ASSERT_EQ(0u, bytesDecrypted);
85}
86
87TEST_F(AesCtrDecryptorTest, DecryptsWithKeyTooLong) {
88    const size_t kTotalSize = 64;
89    const size_t kNumSubsamples = 1;
90
91    // Test vectors from NIST-800-38A
92    uint8_t key[kBlockSize * 2] = {
93        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
94        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c,
95        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
96        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
97    };
98
99    Iv iv = {
100        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
101        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
102    };
103
104    uint8_t source[kTotalSize] = { 0 };
105    uint8_t destination[kTotalSize] = { 0 };
106    SubSample subSamples[kNumSubsamples] = {
107        {0, 64}
108    };
109
110    size_t bytesDecrypted = 0;
111    Vector<uint8_t> keyVector;
112    keyVector.appendArray(key, sizeof(key) / sizeof(uint8_t));
113
114    AesCtrDecryptor decryptor;
115    ASSERT_EQ(android::ERROR_DRM_DECRYPT, decryptor.decrypt(keyVector, iv,
116              &source[0], &destination[0],
117              &subSamples[0], kNumSubsamples, &bytesDecrypted));
118    ASSERT_EQ(0u, bytesDecrypted);
119}
120
121TEST_F(AesCtrDecryptorTest, DecryptsContiguousEncryptedBlock) {
122    const size_t kTotalSize = 64;
123    const size_t kNumSubsamples = 1;
124
125    // Test vectors from NIST-800-38A
126    Key key = {
127        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
128        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
129    };
130
131    Iv iv = {
132        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
133        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
134    };
135
136    uint8_t encrypted[kTotalSize] = {
137        0x87, 0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26,
138        0x1b, 0xef, 0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce,
139        0x98, 0x06, 0xf6, 0x6b, 0x79, 0x70, 0xfd, 0xff,
140        0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff, 0xfd, 0xff,
141        0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5, 0xd3, 0x5e,
142        0x5b, 0x4f, 0x09, 0x02, 0x0d, 0xb0, 0x3e, 0xab,
143        0x1e, 0x03, 0x1d, 0xda, 0x2f, 0xbe, 0x03, 0xd1,
144        0x79, 0x21, 0x70, 0xa0, 0xf3, 0x00, 0x9c, 0xee
145    };
146
147    uint8_t decrypted[kTotalSize] = {
148        0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
149        0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
150        0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
151        0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
152        0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
153        0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
154        0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
155        0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
156    };
157
158    SubSample subSamples[kNumSubsamples] = {
159        {0, 64}
160    };
161
162    attemptDecryptExpectingSuccess<kTotalSize>(key, iv, encrypted, decrypted,
163                                               subSamples, kNumSubsamples);
164}
165
166TEST_F(AesCtrDecryptorTest, DecryptsAlignedBifurcatedEncryptedBlock) {
167    const size_t kTotalSize = 64;
168    const size_t kNumSubsamples = 2;
169
170    // Test vectors from NIST-800-38A
171    Key key = {
172        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
173        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
174    };
175
176    Iv iv = {
177        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
178        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
179    };
180
181    uint8_t encrypted[kTotalSize] = {
182        0x87, 0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26,
183        0x1b, 0xef, 0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce,
184        0x98, 0x06, 0xf6, 0x6b, 0x79, 0x70, 0xfd, 0xff,
185        0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff, 0xfd, 0xff,
186        0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5, 0xd3, 0x5e,
187        0x5b, 0x4f, 0x09, 0x02, 0x0d, 0xb0, 0x3e, 0xab,
188        0x1e, 0x03, 0x1d, 0xda, 0x2f, 0xbe, 0x03, 0xd1,
189        0x79, 0x21, 0x70, 0xa0, 0xf3, 0x00, 0x9c, 0xee
190    };
191
192    uint8_t decrypted[kTotalSize] = {
193        0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
194        0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
195        0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
196        0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
197        0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
198        0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
199        0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
200        0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
201    };
202
203    SubSample subSamples[kNumSubsamples] = {
204        {0, 32},
205        {0, 32}
206    };
207
208    attemptDecryptExpectingSuccess<kTotalSize>(key, iv, encrypted, decrypted,
209                                               subSamples, kNumSubsamples);
210}
211
212TEST_F(AesCtrDecryptorTest, DecryptsUnalignedBifurcatedEncryptedBlock) {
213    const size_t kTotalSize = 64;
214    const size_t kNumSubsamples = 2;
215
216    // Test vectors from NIST-800-38A
217    Key key = {
218        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
219        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
220    };
221
222    Iv iv = {
223        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
224        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
225    };
226
227    uint8_t encrypted[kTotalSize] = {
228        0x87, 0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26,
229        0x1b, 0xef, 0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce,
230        0x98, 0x06, 0xf6, 0x6b, 0x79, 0x70, 0xfd, 0xff,
231        0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff, 0xfd, 0xff,
232        0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5, 0xd3, 0x5e,
233        0x5b, 0x4f, 0x09, 0x02, 0x0d, 0xb0, 0x3e, 0xab,
234        0x1e, 0x03, 0x1d, 0xda, 0x2f, 0xbe, 0x03, 0xd1,
235        0x79, 0x21, 0x70, 0xa0, 0xf3, 0x00, 0x9c, 0xee
236    };
237
238    uint8_t decrypted[kTotalSize] = {
239        0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
240        0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
241        0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
242        0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
243        0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
244        0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
245        0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
246        0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
247    };
248
249    SubSample subSamples[kNumSubsamples] = {
250        {0, 29},
251        {0, 35}
252    };
253
254    attemptDecryptExpectingSuccess<kTotalSize>(key, iv, encrypted, decrypted,
255                                               subSamples, kNumSubsamples);
256}
257
258TEST_F(AesCtrDecryptorTest, DecryptsOneMixedSubSample) {
259    const size_t kTotalSize = 72;
260    const size_t kNumSubsamples = 1;
261
262    // Based on test vectors from NIST-800-38A
263    Key key = {
264        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
265        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
266    };
267
268    Iv iv = {
269        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
270        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
271    };
272
273    uint8_t encrypted[kTotalSize] = {
274        // 8 clear bytes
275        0xf0, 0x13, 0xca, 0xc7, 0x00, 0x64, 0x0b, 0xbb,
276        // 64 encrypted bytes
277        0x87, 0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26,
278        0x1b, 0xef, 0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce,
279        0x98, 0x06, 0xf6, 0x6b, 0x79, 0x70, 0xfd, 0xff,
280        0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff, 0xfd, 0xff,
281        0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5, 0xd3, 0x5e,
282        0x5b, 0x4f, 0x09, 0x02, 0x0d, 0xb0, 0x3e, 0xab,
283        0x1e, 0x03, 0x1d, 0xda, 0x2f, 0xbe, 0x03, 0xd1,
284        0x79, 0x21, 0x70, 0xa0, 0xf3, 0x00, 0x9c, 0xee
285    };
286
287    uint8_t decrypted[kTotalSize] = {
288        0xf0, 0x13, 0xca, 0xc7, 0x00, 0x64, 0x0b, 0xbb,
289        0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
290        0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
291        0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
292        0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
293        0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
294        0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
295        0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
296        0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
297    };
298
299    SubSample subSamples[kNumSubsamples] = {
300        {8, 64}
301    };
302
303    attemptDecryptExpectingSuccess<kTotalSize>(key, iv, encrypted, decrypted,
304                                               subSamples, kNumSubsamples);
305}
306
307TEST_F(AesCtrDecryptorTest, DecryptsAlignedMixedSubSamples) {
308    const size_t kTotalSize = 80;
309    const size_t kNumSubsamples = 2;
310
311    // Based on test vectors from NIST-800-38A
312    Key key = {
313        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
314        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
315    };
316
317    Iv iv = {
318        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
319        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
320    };
321
322    uint8_t encrypted[kTotalSize] = {
323        // 8 clear bytes
324        0xf0, 0x13, 0xca, 0xc7, 0x00, 0x64, 0x0b, 0xbb,
325        // 32 encrypted bytes
326        0x87, 0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26,
327        0x1b, 0xef, 0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce,
328        0x98, 0x06, 0xf6, 0x6b, 0x79, 0x70, 0xfd, 0xff,
329        0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff, 0xfd, 0xff,
330        // 8 clear bytes
331        0x94, 0xba, 0x88, 0x2e, 0x0e, 0x12, 0x11, 0x55,
332        // 32 encrypted bytes
333        0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5, 0xd3, 0x5e,
334        0x5b, 0x4f, 0x09, 0x02, 0x0d, 0xb0, 0x3e, 0xab,
335        0x1e, 0x03, 0x1d, 0xda, 0x2f, 0xbe, 0x03, 0xd1,
336        0x79, 0x21, 0x70, 0xa0, 0xf3, 0x00, 0x9c, 0xee
337    };
338
339    uint8_t decrypted[kTotalSize] = {
340        0xf0, 0x13, 0xca, 0xc7, 0x00, 0x64, 0x0b, 0xbb,
341        0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
342        0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
343        0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
344        0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
345        0x94, 0xba, 0x88, 0x2e, 0x0e, 0x12, 0x11, 0x55,
346        0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
347        0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
348        0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
349        0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
350    };
351
352    SubSample subSamples[kNumSubsamples] = {
353        {8, 32},
354        {8, 32}
355    };
356
357    attemptDecryptExpectingSuccess<kTotalSize>(key, iv, encrypted, decrypted,
358                                               subSamples, kNumSubsamples);
359}
360
361TEST_F(AesCtrDecryptorTest, DecryptsUnalignedMixedSubSamples) {
362    const size_t kTotalSize = 80;
363    const size_t kNumSubsamples = 2;
364
365    // Based on test vectors from NIST-800-38A
366    Key key = {
367        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
368        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
369    };
370
371    Iv iv = {
372        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
373        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
374    };
375
376    uint8_t encrypted[kTotalSize] = {
377        // 8 clear bytes
378        0xf0, 0x13, 0xca, 0xc7, 0x00, 0x64, 0x0b, 0xbb,
379        // 30 encrypted bytes
380        0x87, 0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26,
381        0x1b, 0xef, 0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce,
382        0x98, 0x06, 0xf6, 0x6b, 0x79, 0x70, 0xfd, 0xff,
383        0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff,
384        // 8 clear bytes
385        0x94, 0xba, 0x88, 0x2e, 0x0e, 0x12, 0x11, 0x55,
386        // 34 encrypted bytes
387        0xfd, 0xff, 0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5,
388        0xd3, 0x5e, 0x5b, 0x4f, 0x09, 0x02, 0x0d, 0xb0,
389        0x3e, 0xab, 0x1e, 0x03, 0x1d, 0xda, 0x2f, 0xbe,
390        0x03, 0xd1, 0x79, 0x21, 0x70, 0xa0, 0xf3, 0x00,
391        0x9c, 0xee
392    };
393
394    uint8_t decrypted[kTotalSize] = {
395        0xf0, 0x13, 0xca, 0xc7, 0x00, 0x64, 0x0b, 0xbb,
396        0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
397        0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
398        0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
399        0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x94, 0xba,
400        0x88, 0x2e, 0x0e, 0x12, 0x11, 0x55, 0x8e, 0x51,
401        0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
402        0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
403        0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
404        0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10
405    };
406
407    SubSample subSamples[kNumSubsamples] = {
408        {8, 30},
409        {8, 34}
410    };
411
412    attemptDecryptExpectingSuccess<kTotalSize>(key, iv, encrypted, decrypted,
413                                               subSamples, kNumSubsamples);
414}
415
416TEST_F(AesCtrDecryptorTest, DecryptsComplexMixedSubSamples) {
417    const size_t kTotalSize = 72;
418    const size_t kNumSubsamples = 6;
419
420    // Based on test vectors from NIST-800-38A
421    Key key = {
422        0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
423        0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
424    };
425
426    Iv iv = {
427        0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
428        0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
429    };
430
431    uint8_t encrypted[kTotalSize] = {
432        // 4 clear bytes
433        0xf0, 0x13, 0xca, 0xc7,
434        // 1 encrypted bytes
435        0x87,
436        // 9 encrypted bytes
437        0x4d, 0x61, 0x91, 0xb6, 0x20, 0xe3, 0x26, 0x1b,
438        0xef,
439        // 11 clear bytes
440        0x81, 0x4f, 0x24, 0x87, 0x0e, 0xde, 0xba, 0xad,
441        0x11, 0x9b, 0x46,
442        // 20 encrypted bytes
443        0x68, 0x64, 0x99, 0x0d, 0xb6, 0xce,
444        0x98, 0x06, 0xf6, 0x6b, 0x79, 0x70, 0xfd, 0xff,
445        0x86, 0x17, 0x18, 0x7b, 0xb9, 0xff,
446        // 8 clear bytes
447        0x94, 0xba, 0x88, 0x2e, 0x0e, 0x12, 0x11, 0x55,
448        // 3 clear bytes
449        0x10, 0xf5, 0x22,
450        // 14 encrypted bytes
451        0xfd, 0xff, 0x5a, 0xe4, 0xdf, 0x3e, 0xdb, 0xd5,
452        0xd3, 0x5e, 0x5b, 0x4f, 0x09, 0x02,
453        // 2 clear bytes
454        0x02, 0x01
455    };
456
457    uint8_t decrypted[kTotalSize] = {
458        0xf0, 0x13, 0xca, 0xc7, 0x6b, 0xc1, 0xbe, 0xe2,
459        0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x81, 0x4f,
460        0x24, 0x87, 0x0e, 0xde, 0xba, 0xad, 0x11, 0x9b,
461        0x46, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a, 0xae,
462        0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e,
463        0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x94, 0xba, 0x88,
464        0x2e, 0x0e, 0x12, 0x11, 0x55, 0x10, 0xf5, 0x22,
465        0x8e, 0x51, 0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c,
466        0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x02, 0x01
467    };
468
469    SubSample subSamples[kNumSubsamples] = {
470        {4, 1},
471        {0, 9},
472        {11, 20},
473        {8, 0},
474        {3, 14},
475        {2, 0}
476    };
477
478    attemptDecryptExpectingSuccess<kTotalSize>(key, iv, encrypted, decrypted,
479                                               subSamples, kNumSubsamples);
480}
481
482}  // namespace clearkeydrm
483