← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavutil/aes.c

  • Committer: Gauvain Pocentek
  • Date: 2012-03-06 11:59:12 UTC
  • mfrom: (66.1.15 precise)
  • Revision ID: gauvain@pocentek.net-20120306115912-h9d6kt9j0l532oo5
http://bugs.debian.org/442181
http://bugs.debian.org/481807
http://bugs.debian.org/496106
http://bugs.debian.org/533546
http://bugs.debian.org/568514
http://bugs.debian.org/637077
http://bugs.debian.org/638408
http://bugs.debian.org/643621
http://bugs.debian.org/650339
http://bugs.debian.org/653887
http://bugs.debian.org/654974
* Merge from Ubuntu:
  - put back faac support
  - recommends apport-hooks-medibuntu
  - change Maintainer, Uploaders & Vcs-* fields.
* New upstream snapshot
* upload to unstable
* Build against external libmpeg2
* drop 51_FTBFS_arm.patch again
* no longer build depend on libcdparanoia-dev on the Hurd
* Fix FTBFS on the hurd.
  Thanks to Samuel Thibault <sthibault@debian.org> (Closes: #654974)
* Fix FTBFS on arm
* New upstream snapshot, Closes: #650339, #643621, #481807
* Imported Upstream version 1.0~rc4+svn34492
* Bump standards version
* Bump dependency on libav >= 4:0.8~, Closes: #653887
* Fix build-indep
* Build mplayer-gui again, Closes: #568514
* Drop debian/all-lang-config-mak.sh, no longer needed
* include .dfsg1 in version number
* remove get-orig-source target
* no longer prune compiler flags from the environment
* No longer advertise nor build 3fdx, mga and dxr3 backends,
  Closes: #496106, #442181, #533546
* beautify mplayer version identification string
* Brown paperbag upload.
* Next try to fix build failure on sparce after recent binutils change.
* Brown paperbag upload.
* Really fix build failure on sparc after recent binutils change.
* Properly set Replaces/Conflicts on mplayer2{,-dbg} to avoid
  file overwrite errors.
* Adjust versioning of mplayer listed in the mplayer-dbg's Depends field.
* Fix build failure on sparc after recent binutils change.
* Urgency medium bumped because of RC-level bugfix
  and speeding up x264 transition.
* Update to my @debian.org email.
* Upload to unstable
* Enable joystick support on Linux only, Closes: #638408
* Rebuild fixes toolchain issue on arm, Closes: #637077
* New upstream snapshot
* following the discussion started by Diego Biurrun <diego@biurrun.de>
  in debian-devel, I have prepared a new packaging of 'mplayer'
  (with code that comes from CVS)
* the upstream tar.bz cannot be distributed by Debian, since it contains
   CSS code; so I am repackaging it 
* I have tried my best to address all known issues:
  - the package contains the detailed Copyright made by Diego Biurrun 
  - the package does not contain CSS code, or  AFAIK other code on which 
     there is active patent enforcement
  - there is a script  debian/cvs-changelog.sh  that shows all changes
     done to files included in this source.
    This should comply with GPLv2 sec 2.a  (in spirit if not in letter)
    For this reason, the source code contains CVS directories.
* needs   make (>= 3.80) for 'html-chunked-$(1)' in DOCS/xml/Makefile

* some corrections, as suggested Diego Biurrun
  - binary codecs should go into /usr/lib/codecs (upstream default)
  - better template 'mplayer/install_codecs'
  - an empty 'font=' in mplayer.conf breaks mplayer: postinst corrected
* correction in 'mplayer/cfgnote'
* better mplayer.postinst and mplayer.config

* New upstream release
* better debian/copyright file
* do not ship a skin
* New upstream release
* changed DEB_BUILD_OPTIONS to DEB_BUILD_CONFIGURE ,
  DEB_BUILD_OPTIONS is used as in debian policy
* use gcc-3.4
* changed xlibs-dev to a long list of dependencies, for Debian/etch
* try to adhere to  http://www.mplayerhq.hu/DOCS/tech/binary-packaging.txt
  (see README.Debian for details)
* removed dependency on xlibmesa-dev, disabled opengl
* New upstream release
* Simon McVittie <hacks@pseudorandom.co.uk> wonderful work:
- Work around Debian bug #267442 (glibc's sys/uio.h and gcc's altivec.h have
  conflicting uses for __vector) by re-ordering #includes
- Fix potential symlink attack in ./configure
- Disable support for binary codecs on platforms for which those codecs
  aren't available; also disable the corresponding Debconf note when it's
  inappropriate
- Changed Build-Depends: so it works in pbuilder
- Explicitly build-depend on libjpeg62-dev, libfontconfig1-dev,
  libungif4-dev 
- Tweak debian/rules to avoid certain errors being ignored
- Use --language=all
* provide a target  'debian/rules get-orig-source' 
  that recreates the orig.tar.gz ; then use the above orig.tar.gz
* rewrote some parts of debian/rules
* don't clean and recompile docs if upstream ships them
* mplayer-doc was shipping too much stuff
* translated man pages where not installed properly
* compile with libdv4-dev
* correct README.Debian
* Forgot build-dep on libtheora
* Must not depend on libxvidcore
* New upstream release
* new release.
* rc1 to become 0.90
* new pre-release
* new pre-release
* gtk bug fixed.
* new release.
* version bumped
* 0.60 pre2 release
* 0.60 pre-release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavutil/aes.c
22
22
 
23
23
#include "common.h"
24
24
#include "aes.h"
 
25
#include "intreadwrite.h"
25
26
 
26
27
typedef union {
27
28
    uint64_t u64[2];
30
31
    uint8_t u8[16];
31
32
} av_aes_block;
32
33
 
33
 
typedef struct AVAES{
 
34
typedef struct AVAES {
34
35
    // Note: round_key[16] is accessed in the init code, but this only
35
 
    // overwrites state, which does not matter (see also r7471).
 
36
    // overwrites state, which does not matter (see also commit ba554c0).
36
37
    av_aes_block round_key[15];
37
38
    av_aes_block state[2];
38
39
    int rounds;
39
 
}AVAES;
 
40
} AVAES;
40
41
 
41
42
const int av_aes_size= sizeof(AVAES);
42
43
 
54
55
static uint32_t dec_multbl[4][256];
55
56
#endif
56
57
 
57
 
static inline void addkey(av_aes_block *dst, const av_aes_block *src, const av_aes_block *round_key){
 
58
#if HAVE_BIGENDIAN
 
59
#   define ROT(x, s) ((x >> s) | (x << (32-s)))
 
60
#else
 
61
#   define ROT(x, s) ((x << s) | (x >> (32-s)))
 
62
#endif
 
63
 
 
64
static inline void addkey(av_aes_block *dst, const av_aes_block *src,
 
65
                          const av_aes_block *round_key)
 
66
{
58
67
    dst->u64[0] = src->u64[0] ^ round_key->u64[0];
59
68
    dst->u64[1] = src->u64[1] ^ round_key->u64[1];
60
69
}
61
70
 
62
 
static void subshift(av_aes_block s0[2], int s, const uint8_t *box){
63
 
    av_aes_block *s1= (av_aes_block *)(s0[0].u8 - s);
64
 
    av_aes_block *s3= (av_aes_block *)(s0[0].u8 + s);
65
 
    s0[0].u8[0]=box[s0[1].u8[ 0]]; s0[0].u8[ 4]=box[s0[1].u8[ 4]]; s0[0].u8[ 8]=box[s0[1].u8[ 8]]; s0[0].u8[12]=box[s0[1].u8[12]];
66
 
    s1[0].u8[3]=box[s1[1].u8[ 7]]; s1[0].u8[ 7]=box[s1[1].u8[11]]; s1[0].u8[11]=box[s1[1].u8[15]]; s1[0].u8[15]=box[s1[1].u8[ 3]];
67
 
    s0[0].u8[2]=box[s0[1].u8[10]]; s0[0].u8[10]=box[s0[1].u8[ 2]]; s0[0].u8[ 6]=box[s0[1].u8[14]]; s0[0].u8[14]=box[s0[1].u8[ 6]];
68
 
    s3[0].u8[1]=box[s3[1].u8[13]]; s3[0].u8[13]=box[s3[1].u8[ 9]]; s3[0].u8[ 9]=box[s3[1].u8[ 5]]; s3[0].u8[ 5]=box[s3[1].u8[ 1]];
 
71
static inline void addkey_s(av_aes_block *dst, const uint8_t *src,
 
72
                            const av_aes_block *round_key)
 
73
{
 
74
    dst->u64[0] = AV_RN64(src)     ^ round_key->u64[0];
 
75
    dst->u64[1] = AV_RN64(src + 8) ^ round_key->u64[1];
 
76
}
 
77
 
 
78
static inline void addkey_d(uint8_t *dst, const av_aes_block *src,
 
79
                            const av_aes_block *round_key)
 
80
{
 
81
    AV_WN64(dst,     src->u64[0] ^ round_key->u64[0]);
 
82
    AV_WN64(dst + 8, src->u64[1] ^ round_key->u64[1]);
 
83
}
 
84
 
 
85
static void subshift(av_aes_block s0[2], int s, const uint8_t *box)
 
86
{
 
87
    av_aes_block *s1 = (av_aes_block *) (s0[0].u8 - s);
 
88
    av_aes_block *s3 = (av_aes_block *) (s0[0].u8 + s);
 
89
 
 
90
    s0[0].u8[ 0] = box[s0[1].u8[ 0]];
 
91
    s0[0].u8[ 4] = box[s0[1].u8[ 4]];
 
92
    s0[0].u8[ 8] = box[s0[1].u8[ 8]];
 
93
    s0[0].u8[12] = box[s0[1].u8[12]];
 
94
    s1[0].u8[ 3] = box[s1[1].u8[ 7]];
 
95
    s1[0].u8[ 7] = box[s1[1].u8[11]];
 
96
    s1[0].u8[11] = box[s1[1].u8[15]];
 
97
    s1[0].u8[15] = box[s1[1].u8[ 3]];
 
98
    s0[0].u8[ 2] = box[s0[1].u8[10]];
 
99
    s0[0].u8[10] = box[s0[1].u8[ 2]];
 
100
    s0[0].u8[ 6] = box[s0[1].u8[14]];
 
101
    s0[0].u8[14] = box[s0[1].u8[ 6]];
 
102
    s3[0].u8[ 1] = box[s3[1].u8[13]];
 
103
    s3[0].u8[13] = box[s3[1].u8[ 9]];
 
104
    s3[0].u8[ 9] = box[s3[1].u8[ 5]];
 
105
    s3[0].u8[ 5] = box[s3[1].u8[ 1]];
69
106
}
70
107
 
71
108
static inline int mix_core(uint32_t multbl[][256], int a, int b, int c, int d){
72
109
#if CONFIG_SMALL
73
 
#define ROT(x,s) ((x<<s)|(x>>(32-s)))
74
110
    return multbl[0][a] ^ ROT(multbl[0][b], 8) ^ ROT(multbl[0][c], 16) ^ ROT(multbl[0][d], 24);
75
111
#else
76
112
    return multbl[0][a] ^ multbl[1][b] ^ multbl[2][c] ^ multbl[3][d];
85
121
    state[0].u32[3] = mix_core(multbl, src[3][0], src[s1-1][1], src[1][2], src[s3-1][3]);
86
122
}
87
123
 
88
 
static inline void crypt(AVAES *a, int s, const uint8_t *sbox, uint32_t multbl[][256]){
 
124
static inline void crypt(AVAES *a, int s, const uint8_t *sbox,
 
125
                         uint32_t multbl[][256])
 
126
{
89
127
    int r;
90
128
 
91
 
    for(r=a->rounds-1; r>0; r--){
92
 
        mix(a->state, multbl, 3-s, 1+s);
 
129
    for (r = a->rounds - 1; r > 0; r--) {
 
130
        mix(a->state, multbl, 3 - s, 1 + s);
93
131
        addkey(&a->state[1], &a->state[0], &a->round_key[r]);
94
132
    }
 
133
 
95
134
    subshift(&a->state[0], s, sbox);
96
135
}
97
136
 
98
 
void av_aes_crypt(AVAES *a, uint8_t *dst_, const uint8_t *src_, int count, uint8_t *iv_, int decrypt){
99
 
    av_aes_block *dst = (av_aes_block *)dst_;
100
 
    const av_aes_block *src = (const av_aes_block *)src_;
101
 
    av_aes_block *iv = (av_aes_block *)iv_;
102
 
    while(count--){
103
 
        addkey(&a->state[1], src, &a->round_key[a->rounds]);
104
 
        if(decrypt) {
 
137
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src,
 
138
                  int count, uint8_t *iv, int decrypt)
 
139
{
 
140
    while (count--) {
 
141
        addkey_s(&a->state[1], src, &a->round_key[a->rounds]);
 
142
        if (decrypt) {
105
143
            crypt(a, 0, inv_sbox, dec_multbl);
106
 
            if(iv){
107
 
                addkey(&a->state[0], &a->state[0], iv);
 
144
            if (iv) {
 
145
                addkey_s(&a->state[0], iv, &a->state[0]);
108
146
                memcpy(iv, src, 16);
109
147
            }
110
 
            addkey(dst, &a->state[0], &a->round_key[0]);
111
 
        }else{
112
 
            if(iv) addkey(&a->state[1], &a->state[1], iv);
113
 
            crypt(a, 2,     sbox, enc_multbl);
114
 
            addkey(dst, &a->state[0], &a->round_key[0]);
115
 
            if(iv) memcpy(iv, dst, 16);
 
148
            addkey_d(dst, &a->state[0], &a->round_key[0]);
 
149
        } else {
 
150
            if (iv)
 
151
                addkey_s(&a->state[1], iv, &a->state[1]);
 
152
            crypt(a, 2, sbox, enc_multbl);
 
153
            addkey_d(dst, &a->state[0], &a->round_key[0]);
 
154
            if (iv)
 
155
                memcpy(iv, dst, 16);
116
156
        }
117
 
        src++;
118
 
        dst++;
 
157
        src += 16;
 
158
        dst += 16;
119
159
    }
120
160
}
121
161
 
122
 
static void init_multbl2(uint8_t tbl[1024], const int c[4], const uint8_t *log8, const uint8_t *alog8, const uint8_t *sbox){
123
 
    int i, j;
124
 
    for(i=0; i<1024; i++){
125
 
        int x= sbox[i>>2];
126
 
        if(x) tbl[i]= alog8[ log8[x] + log8[c[i&3]] ];
127
 
    }
 
162
static void init_multbl2(uint32_t tbl[][256], const int c[4],
 
163
                         const uint8_t *log8, const uint8_t *alog8,
 
164
                         const uint8_t *sbox)
 
165
{
 
166
    int i;
 
167
 
 
168
    for (i = 0; i < 256; i++) {
 
169
        int x = sbox[i];
 
170
        if (x) {
 
171
            int k, l, m, n;
 
172
            x = log8[x];
 
173
            k = alog8[x + log8[c[0]]];
 
174
            l = alog8[x + log8[c[1]]];
 
175
            m = alog8[x + log8[c[2]]];
 
176
            n = alog8[x + log8[c[3]]];
 
177
            tbl[0][i] = AV_NE(MKBETAG(k,l,m,n), MKTAG(k,l,m,n));
128
178
#if !CONFIG_SMALL
129
 
    for(j=256; j<1024; j++)
130
 
        for(i=0; i<4; i++)
131
 
            tbl[4*j+i]= tbl[4*j + ((i-1)&3) - 1024];
 
179
            tbl[1][i] = ROT(tbl[0][i], 8);
 
180
            tbl[2][i] = ROT(tbl[0][i], 16);
 
181
            tbl[3][i] = ROT(tbl[0][i], 24);
132
182
#endif
 
183
        }
 
184
    }
133
185
}
134
186
 
135
187
// this is based on the reference AES code by Paulo Barreto and Vincent Rijmen
136
 
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt) {
 
188
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
 
189
{
137
190
    int i, j, t, rconpointer = 0;
138
191
    uint8_t tk[8][4];
139
 
    int KC= key_bits>>5;
140
 
    int rounds= KC + 6;
141
 
    uint8_t  log8[256];
 
192
    int KC = key_bits >> 5;
 
193
    int rounds = KC + 6;
 
194
    uint8_t log8[256];
142
195
    uint8_t alog8[512];
143
196
 
144
 
    if(!enc_multbl[FF_ARRAY_ELEMS(enc_multbl)-1][FF_ARRAY_ELEMS(enc_multbl[0])-1]){
145
 
        j=1;
146
 
        for(i=0; i<255; i++){
147
 
            alog8[i]=
148
 
            alog8[i+255]= j;
149
 
            log8[j]= i;
150
 
            j^= j+j;
151
 
            if(j>255) j^= 0x11B;
152
 
        }
153
 
        for(i=0; i<256; i++){
154
 
            j= i ? alog8[255-log8[i]] : 0;
155
 
            j ^= (j<<1) ^ (j<<2) ^ (j<<3) ^ (j<<4);
156
 
            j = (j ^ (j>>8) ^ 99) & 255;
157
 
            inv_sbox[j]= i;
158
 
            sbox    [i]= j;
159
 
        }
160
 
        init_multbl2(dec_multbl[0], (const int[4]){0xe, 0x9, 0xd, 0xb}, log8, alog8, inv_sbox);
161
 
        init_multbl2(enc_multbl[0], (const int[4]){0x2, 0x1, 0x1, 0x3}, log8, alog8, sbox);
 
197
    if (!enc_multbl[FF_ARRAY_ELEMS(enc_multbl)-1][FF_ARRAY_ELEMS(enc_multbl[0])-1]) {
 
198
        j = 1;
 
199
        for (i = 0; i < 255; i++) {
 
200
            alog8[i] = alog8[i + 255] = j;
 
201
            log8[j] = i;
 
202
            j ^= j + j;
 
203
            if (j > 255)
 
204
                j ^= 0x11B;
 
205
        }
 
206
        for (i = 0; i < 256; i++) {
 
207
            j = i ? alog8[255 - log8[i]] : 0;
 
208
            j ^= (j << 1) ^ (j << 2) ^ (j << 3) ^ (j << 4);
 
209
            j = (j ^ (j >> 8) ^ 99) & 255;
 
210
            inv_sbox[j] = i;
 
211
            sbox[i] = j;
 
212
        }
 
213
        init_multbl2(dec_multbl, (const int[4]) { 0xe, 0x9, 0xd, 0xb },
 
214
                     log8, alog8, inv_sbox);
 
215
        init_multbl2(enc_multbl, (const int[4]) { 0x2, 0x1, 0x1, 0x3 },
 
216
                     log8, alog8, sbox);
162
217
    }
163
218
 
164
 
    if(key_bits!=128 && key_bits!=192 && key_bits!=256)
 
219
    if (key_bits != 128 && key_bits != 192 && key_bits != 256)
165
220
        return -1;
166
221
 
167
 
    a->rounds= rounds;
168
 
 
169
 
    memcpy(tk, key, KC*4);
170
 
 
171
 
    for(t= 0; t < (rounds+1)*16;) {
172
 
        memcpy(a->round_key[0].u8+t, tk, KC*4);
173
 
        t+= KC*4;
174
 
 
175
 
        for(i = 0; i < 4; i++)
176
 
            tk[0][i] ^= sbox[tk[KC-1][(i+1)&3]];
 
222
    a->rounds = rounds;
 
223
 
 
224
    memcpy(tk, key, KC * 4);
 
225
    memcpy(a->round_key[0].u8, key, KC * 4);
 
226
 
 
227
    for (t = KC * 4; t < (rounds + 1) * 16; t += KC * 4) {
 
228
        for (i = 0; i < 4; i++)
 
229
            tk[0][i] ^= sbox[tk[KC - 1][(i + 1) & 3]];
177
230
        tk[0][0] ^= rcon[rconpointer++];
178
231
 
179
 
        for(j = 1; j < KC; j++){
180
 
            if(KC != 8 || j != KC>>1)
181
 
                for(i = 0; i < 4; i++) tk[j][i] ^=      tk[j-1][i];
 
232
        for (j = 1; j < KC; j++) {
 
233
            if (KC != 8 || j != KC >> 1)
 
234
                for (i = 0; i < 4; i++)
 
235
                    tk[j][i] ^= tk[j - 1][i];
182
236
            else
183
 
                for(i = 0; i < 4; i++) tk[j][i] ^= sbox[tk[j-1][i]];
 
237
                for (i = 0; i < 4; i++)
 
238
                    tk[j][i] ^= sbox[tk[j - 1][i]];
184
239
        }
 
240
 
 
241
        memcpy(a->round_key[0].u8 + t, tk, KC * 4);
185
242
    }
186
243
 
187
 
    if(decrypt){
188
 
        for(i=1; i<rounds; i++){
 
244
    if (decrypt) {
 
245
        for (i = 1; i < rounds; i++) {
189
246
            av_aes_block tmp[3];
190
 
            memcpy(&tmp[2], &a->round_key[i], 16);
 
247
            tmp[2] = a->round_key[i];
191
248
            subshift(&tmp[1], 0, sbox);
192
249
            mix(tmp, dec_multbl, 1, 3);
193
 
            memcpy(&a->round_key[i], &tmp[0], 16);
 
250
            a->round_key[i] = tmp[0];
194
251
        }
195
 
    }else{
196
 
        for(i=0; i<(rounds+1)>>1; i++){
197
 
            for(j=0; j<16; j++)
198
 
                FFSWAP(int, a->round_key[i].u8[j], a->round_key[rounds-i].u8[j]);
 
252
    } else {
 
253
        for (i = 0; i < (rounds + 1) >> 1; i++) {
 
254
            FFSWAP(av_aes_block, a->round_key[i], a->round_key[rounds-i]);
199
255
        }
200
256
    }
201
257
 
203
259
}
204
260
 
205
261
#ifdef TEST
 
262
#include <string.h>
206
263
#include "lfg.h"
207
264
#include "log.h"
208
265
 
209
 
int main(void){
210
 
    int i,j;
211
 
    AVAES ae, ad, b;
212
 
    uint8_t rkey[2][16]= {
213
 
        {0},
214
 
        {0x10, 0xa5, 0x88, 0x69, 0xd7, 0x4b, 0xe5, 0xa3, 0x74, 0xcf, 0x86, 0x7c, 0xfb, 0x47, 0x38, 0x59}};
 
266
int main(int argc, char **argv)
 
267
{
 
268
    int i, j;
 
269
    AVAES b;
 
270
    uint8_t rkey[2][16] = {
 
271
        { 0 },
 
272
        { 0x10, 0xa5, 0x88, 0x69, 0xd7, 0x4b, 0xe5, 0xa3,
 
273
          0x74, 0xcf, 0x86, 0x7c, 0xfb, 0x47, 0x38, 0x59 }
 
274
    };
215
275
    uint8_t pt[16], rpt[2][16]= {
216
 
        {0x6a, 0x84, 0x86, 0x7c, 0xd7, 0x7e, 0x12, 0xad, 0x07, 0xea, 0x1b, 0xe8, 0x95, 0xc5, 0x3f, 0xa3},
217
 
        {0}};
 
276
        { 0x6a, 0x84, 0x86, 0x7c, 0xd7, 0x7e, 0x12, 0xad,
 
277
          0x07, 0xea, 0x1b, 0xe8, 0x95, 0xc5, 0x3f, 0xa3 },
 
278
        { 0 }
 
279
    };
218
280
    uint8_t rct[2][16]= {
219
 
        {0x73, 0x22, 0x81, 0xc0, 0xa0, 0xaa, 0xb8, 0xf7, 0xa5, 0x4a, 0x0c, 0x67, 0xa0, 0xc4, 0x5e, 0xcf},
220
 
        {0x6d, 0x25, 0x1e, 0x69, 0x44, 0xb0, 0x51, 0xe0, 0x4e, 0xaa, 0x6f, 0xb4, 0xdb, 0xf7, 0x84, 0x65}};
 
281
        { 0x73, 0x22, 0x81, 0xc0, 0xa0, 0xaa, 0xb8, 0xf7,
 
282
          0xa5, 0x4a, 0x0c, 0x67, 0xa0, 0xc4, 0x5e, 0xcf },
 
283
        { 0x6d, 0x25, 0x1e, 0x69, 0x44, 0xb0, 0x51, 0xe0,
 
284
          0x4e, 0xaa, 0x6f, 0xb4, 0xdb, 0xf7, 0x84, 0x65 }
 
285
    };
221
286
    uint8_t temp[16];
222
 
    AVLFG prng;
 
287
    int err = 0;
223
288
 
224
 
    av_aes_init(&ae, "PI=3.141592654..", 128, 0);
225
 
    av_aes_init(&ad, "PI=3.141592654..", 128, 1);
226
289
    av_log_set_level(AV_LOG_DEBUG);
227
 
    av_lfg_init(&prng, 1);
228
290
 
229
 
    for(i=0; i<2; i++){
 
291
    for (i = 0; i < 2; i++) {
230
292
        av_aes_init(&b, rkey[i], 128, 1);
231
293
        av_aes_crypt(&b, temp, rct[i], 1, NULL, 1);
232
 
        for(j=0; j<16; j++)
233
 
            if(rpt[i][j] != temp[j])
234
 
                av_log(NULL, AV_LOG_ERROR, "%d %02X %02X\n", j, rpt[i][j], temp[j]);
235
 
    }
236
 
 
237
 
    for(i=0; i<10000; i++){
238
 
        for(j=0; j<16; j++){
239
 
            pt[j] = av_lfg_get(&prng);
240
 
        }
241
 
{START_TIMER
242
 
        av_aes_crypt(&ae, temp, pt, 1, NULL, 0);
243
 
        if(!(i&(i-1)))
244
 
            av_log(NULL, AV_LOG_ERROR, "%02X %02X %02X %02X\n", temp[0], temp[5], temp[10], temp[15]);
245
 
        av_aes_crypt(&ad, temp, temp, 1, NULL, 1);
246
 
STOP_TIMER("aes")}
247
 
        for(j=0; j<16; j++){
248
 
            if(pt[j] != temp[j]){
249
 
                av_log(NULL, AV_LOG_ERROR, "%d %d %02X %02X\n", i,j, pt[j], temp[j]);
250
 
            }
251
 
        }
252
 
    }
253
 
    return 0;
 
294
        for (j = 0; j < 16; j++) {
 
295
            if (rpt[i][j] != temp[j]) {
 
296
                av_log(NULL, AV_LOG_ERROR, "%d %02X %02X\n",
 
297
                       j, rpt[i][j], temp[j]);
 
298
                err = 1;
 
299
            }
 
300
        }
 
301
    }
 
302
 
 
303
    if (argc > 1 && !strcmp(argv[1], "-t")) {
 
304
        AVAES ae, ad;
 
305
        AVLFG prng;
 
306
 
 
307
        av_aes_init(&ae, "PI=3.141592654..", 128, 0);
 
308
        av_aes_init(&ad, "PI=3.141592654..", 128, 1);
 
309
        av_lfg_init(&prng, 1);
 
310
 
 
311
        for (i = 0; i < 10000; i++) {
 
312
            for (j = 0; j < 16; j++) {
 
313
                pt[j] = av_lfg_get(&prng);
 
314
            }
 
315
            {
 
316
                START_TIMER;
 
317
                av_aes_crypt(&ae, temp, pt, 1, NULL, 0);
 
318
                if (!(i & (i - 1)))
 
319
                    av_log(NULL, AV_LOG_ERROR, "%02X %02X %02X %02X\n",
 
320
                           temp[0], temp[5], temp[10], temp[15]);
 
321
                av_aes_crypt(&ad, temp, temp, 1, NULL, 1);
 
322
                STOP_TIMER("aes");
 
323
            }
 
324
            for (j = 0; j < 16; j++) {
 
325
                if (pt[j] != temp[j]) {
 
326
                    av_log(NULL, AV_LOG_ERROR, "%d %d %02X %02X\n",
 
327
                           i, j, pt[j], temp[j]);
 
328
                }
 
329
            }
 
330
        }
 
331
    }
 
332
    return err;
254
333
}
255
334
#endif