Unset variable fps for mov and mp4 muxer, they support it
[ffmpeg.git] / libavutil / sha.c
1 /*
2  * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
3  * Copyright (C) 2009 Konstantin Shishkov
4  * based on public domain SHA-1 code by Steve Reid <steve@edmweb.com>
5  * and on BSD-licensed SHA-2 code by Aaron D. Gifford
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 #include <string.h>
25 #include "avutil.h"
26 #include "bswap.h"
27 #include "sha.h"
28 #include "sha1.h"
29 #include "intreadwrite.h"
30
31 /** hash context */
32 typedef struct AVSHA {
33     uint8_t  digest_len;  ///< digest length in 32-bit words
34     uint64_t count;       ///< number of bytes in buffer
35     uint8_t  buffer[64];  ///< 512-bit buffer of input values used in hash updating
36     uint32_t state[8];    ///< current hash value
37     /** function used to update hash for 512-bit input block */
38     void     (*transform)(uint32_t *state, const uint8_t buffer[64]);
39 } AVSHA;
40
41 const int av_sha_size = sizeof(AVSHA);
42
43 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
44
45 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
46 #define blk0(i) (block[i] = av_be2ne32(((const uint32_t*)buffer)[i]))
47 #define blk(i)  (block[i] = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1))
48
49 #define R0(v,w,x,y,z,i) z += ((w&(x^y))^y)     + blk0(i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
50 #define R1(v,w,x,y,z,i) z += ((w&(x^y))^y)     + blk (i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
51 #define R2(v,w,x,y,z,i) z += ( w^x     ^y)     + blk (i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
52 #define R3(v,w,x,y,z,i) z += (((w|x)&y)|(w&x)) + blk (i) + 0x8F1BBCDC + rol(v, 5); w = rol(w, 30);
53 #define R4(v,w,x,y,z,i) z += ( w^x     ^y)     + blk (i) + 0xCA62C1D6 + rol(v, 5); w = rol(w, 30);
54
55 /* Hash a single 512-bit block. This is the core of the algorithm. */
56
57 static void sha1_transform(uint32_t state[5], const uint8_t buffer[64])
58 {
59     uint32_t block[80];
60     unsigned int i, a, b, c, d, e;
61
62     a = state[0];
63     b = state[1];
64     c = state[2];
65     d = state[3];
66     e = state[4];
67 #if CONFIG_SMALL
68     for (i = 0; i < 80; i++) {
69         int t;
70         if (i < 16)
71             t = av_be2ne32(((uint32_t*)buffer)[i]);
72         else
73             t = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1);
74         block[i] = t;
75         t += e + rol(a, 5);
76         if (i < 40) {
77             if (i < 20)
78                 t += ((b&(c^d))^d)     + 0x5A827999;
79             else
80                 t += ( b^c     ^d)     + 0x6ED9EBA1;
81         } else {
82             if (i < 60)
83                 t += (((b|c)&d)|(b&c)) + 0x8F1BBCDC;
84             else
85                 t += ( b^c     ^d)     + 0xCA62C1D6;
86         }
87         e = d;
88         d = c;
89         c = rol(b, 30);
90         b = a;
91         a = t;
92     }
93 #else
94     for (i = 0; i < 15; i += 5) {
95         R0(a, b, c, d, e, 0 + i);
96         R0(e, a, b, c, d, 1 + i);
97         R0(d, e, a, b, c, 2 + i);
98         R0(c, d, e, a, b, 3 + i);
99         R0(b, c, d, e, a, 4 + i);
100     }
101     R0(a, b, c, d, e, 15);
102     R1(e, a, b, c, d, 16);
103     R1(d, e, a, b, c, 17);
104     R1(c, d, e, a, b, 18);
105     R1(b, c, d, e, a, 19);
106     for (i = 20; i < 40; i += 5) {
107         R2(a, b, c, d, e, 0 + i);
108         R2(e, a, b, c, d, 1 + i);
109         R2(d, e, a, b, c, 2 + i);
110         R2(c, d, e, a, b, 3 + i);
111         R2(b, c, d, e, a, 4 + i);
112     }
113     for (; i < 60; i += 5) {
114         R3(a, b, c, d, e, 0 + i);
115         R3(e, a, b, c, d, 1 + i);
116         R3(d, e, a, b, c, 2 + i);
117         R3(c, d, e, a, b, 3 + i);
118         R3(b, c, d, e, a, 4 + i);
119     }
120     for (; i < 80; i += 5) {
121         R4(a, b, c, d, e, 0 + i);
122         R4(e, a, b, c, d, 1 + i);
123         R4(d, e, a, b, c, 2 + i);
124         R4(c, d, e, a, b, 3 + i);
125         R4(b, c, d, e, a, 4 + i);
126     }
127 #endif
128     state[0] += a;
129     state[1] += b;
130     state[2] += c;
131     state[3] += d;
132     state[4] += e;
133 }
134
135 static const uint32_t K256[64] = {
136     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
137     0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
138     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
139     0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
140     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
141     0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
142     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
143     0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
144     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
145     0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
146     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
147     0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
148     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
149     0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
150     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
151     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
152 };
153
154
155 #define Ch(x,y,z)   (((x) & ((y) ^ (z))) ^ (z))
156 #define Maj(x,y,z)  ((((x) | (y)) & (z)) | ((x) & (y)))
157
158 #define Sigma0_256(x)   (rol((x), 30) ^ rol((x), 19) ^ rol((x), 10))
159 #define Sigma1_256(x)   (rol((x), 26) ^ rol((x), 21) ^ rol((x),  7))
160 #define sigma0_256(x)   (rol((x), 25) ^ rol((x), 14) ^ ((x) >> 3))
161 #define sigma1_256(x)   (rol((x), 15) ^ rol((x), 13) ^ ((x) >> 10))
162
163 #undef blk
164 #define blk(i)  (block[i] = block[i - 16] + sigma0_256(block[i - 15]) + \
165                             sigma1_256(block[i - 2]) + block[i - 7])
166
167 #define ROUND256(a,b,c,d,e,f,g,h)   \
168     T1 += (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[i]; \
169     (d) += T1; \
170     (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
171     i++
172
173 #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h)   \
174     T1 = blk0(i); \
175     ROUND256(a,b,c,d,e,f,g,h)
176
177 #define ROUND256_16_TO_63(a,b,c,d,e,f,g,h)   \
178     T1 = blk(i); \
179     ROUND256(a,b,c,d,e,f,g,h)
180
181 static void sha256_transform(uint32_t *state, const uint8_t buffer[64])
182 {
183     unsigned int i, a, b, c, d, e, f, g, h;
184     uint32_t block[64];
185     uint32_t T1, av_unused(T2);
186
187     a = state[0];
188     b = state[1];
189     c = state[2];
190     d = state[3];
191     e = state[4];
192     f = state[5];
193     g = state[6];
194     h = state[7];
195 #if CONFIG_SMALL
196     for (i = 0; i < 64; i++) {
197         if (i < 16)
198             T1 = blk0(i);
199         else
200             T1 = blk(i);
201         T1 += h + Sigma1_256(e) + Ch(e, f, g) + K256[i];
202         T2 = Sigma0_256(a) + Maj(a, b, c);
203         h = g;
204         g = f;
205         f = e;
206         e = d + T1;
207         d = c;
208         c = b;
209         b = a;
210         a = T1 + T2;
211     }
212 #else
213     for (i = 0; i < 16;) {
214         ROUND256_0_TO_15(a, b, c, d, e, f, g, h);
215         ROUND256_0_TO_15(h, a, b, c, d, e, f, g);
216         ROUND256_0_TO_15(g, h, a, b, c, d, e, f);
217         ROUND256_0_TO_15(f, g, h, a, b, c, d, e);
218         ROUND256_0_TO_15(e, f, g, h, a, b, c, d);
219         ROUND256_0_TO_15(d, e, f, g, h, a, b, c);
220         ROUND256_0_TO_15(c, d, e, f, g, h, a, b);
221         ROUND256_0_TO_15(b, c, d, e, f, g, h, a);
222     }
223
224     for (; i < 64;) {
225         ROUND256_16_TO_63(a, b, c, d, e, f, g, h);
226         ROUND256_16_TO_63(h, a, b, c, d, e, f, g);
227         ROUND256_16_TO_63(g, h, a, b, c, d, e, f);
228         ROUND256_16_TO_63(f, g, h, a, b, c, d, e);
229         ROUND256_16_TO_63(e, f, g, h, a, b, c, d);
230         ROUND256_16_TO_63(d, e, f, g, h, a, b, c);
231         ROUND256_16_TO_63(c, d, e, f, g, h, a, b);
232         ROUND256_16_TO_63(b, c, d, e, f, g, h, a);
233     }
234 #endif
235     state[0] += a;
236     state[1] += b;
237     state[2] += c;
238     state[3] += d;
239     state[4] += e;
240     state[5] += f;
241     state[6] += g;
242     state[7] += h;
243 }
244
245
246 int av_sha_init(AVSHA* ctx, int bits)
247 {
248     ctx->digest_len = bits >> 5;
249     switch (bits) {
250     case 160: // SHA-1
251         ctx->state[0] = 0x67452301;
252         ctx->state[1] = 0xEFCDAB89;
253         ctx->state[2] = 0x98BADCFE;
254         ctx->state[3] = 0x10325476;
255         ctx->state[4] = 0xC3D2E1F0;
256         ctx->transform = sha1_transform;
257         break;
258     case 224: // SHA-224
259         ctx->state[0] = 0xC1059ED8;
260         ctx->state[1] = 0x367CD507;
261         ctx->state[2] = 0x3070DD17;
262         ctx->state[3] = 0xF70E5939;
263         ctx->state[4] = 0xFFC00B31;
264         ctx->state[5] = 0x68581511;
265         ctx->state[6] = 0x64F98FA7;
266         ctx->state[7] = 0xBEFA4FA4;
267         ctx->transform = sha256_transform;
268         break;
269     case 256: // SHA-256
270         ctx->state[0] = 0x6A09E667;
271         ctx->state[1] = 0xBB67AE85;
272         ctx->state[2] = 0x3C6EF372;
273         ctx->state[3] = 0xA54FF53A;
274         ctx->state[4] = 0x510E527F;
275         ctx->state[5] = 0x9B05688C;
276         ctx->state[6] = 0x1F83D9AB;
277         ctx->state[7] = 0x5BE0CD19;
278         ctx->transform = sha256_transform;
279         break;
280     default:
281         return -1;
282     }
283     ctx->count = 0;
284     return 0;
285 }
286
287 void av_sha_update(AVSHA* ctx, const uint8_t* data, unsigned int len)
288 {
289     unsigned int i, j;
290
291     j = ctx->count & 63;
292     ctx->count += len;
293 #if CONFIG_SMALL
294     for (i = 0; i < len; i++) {
295         ctx->buffer[j++] = data[i];
296         if (64 == j) {
297             ctx->transform(ctx->state, ctx->buffer);
298             j = 0;
299         }
300     }
301 #else
302     if ((j + len) > 63) {
303         memcpy(&ctx->buffer[j], data, (i = 64 - j));
304         ctx->transform(ctx->state, ctx->buffer);
305         for (; i + 63 < len; i += 64)
306             ctx->transform(ctx->state, &data[i]);
307         j = 0;
308     } else
309         i = 0;
310     memcpy(&ctx->buffer[j], &data[i], len - i);
311 #endif
312 }
313
314 void av_sha_final(AVSHA* ctx, uint8_t *digest)
315 {
316     int i;
317     uint64_t finalcount = av_be2ne64(ctx->count << 3);
318
319     av_sha_update(ctx, "\200", 1);
320     while ((ctx->count & 63) != 56)
321         av_sha_update(ctx, "", 1);
322     av_sha_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
323     for (i = 0; i < ctx->digest_len; i++)
324         AV_WB32(digest + i*4, ctx->state[i]);
325 }
326
327 #if LIBAVUTIL_VERSION_MAJOR < 51
328 struct AVSHA1 {
329     AVSHA sha;
330 };
331
332 const int av_sha1_size = sizeof(struct AVSHA1);
333
334 void av_sha1_init(struct AVSHA1* context)
335 {
336     av_sha_init(&context->sha, 160);
337 }
338
339 void av_sha1_update(struct AVSHA1* context, const uint8_t* data, unsigned int len)
340 {
341     av_sha_update(&context->sha, data, len);
342 }
343
344 void av_sha1_final(struct AVSHA1* context, uint8_t digest[20])
345 {
346     av_sha_final(&context->sha, digest);
347 }
348 #endif
349
350 #ifdef TEST
351 #include <stdio.h>
352 #undef printf
353
354 int main(void)
355 {
356     int i, j, k;
357     AVSHA ctx;
358     unsigned char digest[32];
359     const int lengths[3] = { 160, 224, 256 };
360
361     for (j = 0; j < 3; j++) {
362         printf("Testing SHA-%d\n", lengths[j]);
363         for (k = 0; k < 3; k++) {
364             av_sha_init(&ctx, lengths[j]);
365             if (k == 0)
366                 av_sha_update(&ctx, "abc", 3);
367             else if (k == 1)
368                 av_sha_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
369             else
370                 for (i = 0; i < 1000*1000; i++)
371                     av_sha_update(&ctx, "a", 1);
372             av_sha_final(&ctx, digest);
373             for (i = 0; i < lengths[j] >> 3; i++)
374                 printf("%02X", digest[i]);
375             putchar('\n');
376         }
377         switch (j) {
378         case 0:
379             //test vectors (from FIPS PUB 180-1)
380             printf("A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D\n"
381                    "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1\n"
382                    "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F\n");
383             break;
384         case 1:
385             //test vectors (from FIPS PUB 180-2 Appendix A)
386             printf("23097d22 3405d822 8642a477 bda255b3 2aadbce4 bda0b3f7 e36c9da7\n"
387                    "75388b16 512776cc 5dba5da1 fd890150 b0c6455c b4f58b19 52522525\n"
388                    "20794655 980c91d8 bbb4c1ea 97618a4b f03f4258 1948b2ee 4ee7ad67\n");
389             break;
390         case 2:
391             //test vectors (from FIPS PUB 180-2)
392             printf("ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad\n"
393                    "248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1\n"
394                    "cdc76e5c 9914fb92 81a1c7e2 84d73e67 f1809a48 a497200e 046d39cc c7112cd0\n");
395             break;
396         }
397     }
398
399     return 0;
400 }
401 #endif