Statistics
| Branch: | Revision:

ffmpeg / libavutil / sha.c @ 84dc2d8a

History | View | Annotate | Download (12.2 KB)

1 3d44f15c Diego Biurrun
/*
2
 * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
3 aa5a99ae Kostya Shishkov
 * Copyright (C) 2009 Konstantin Shishkov
4 3d44f15c Diego Biurrun
 * based on public domain SHA-1 code by Steve Reid <steve@edmweb.com>
5 aa5a99ae Kostya Shishkov
 * and on BSD-licensed SHA-2 code by Aaron D. Gifford
6 3d44f15c Diego Biurrun
 *
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 7c60e55b Michael Niedermayer
24
#include "common.h"
25 451ae257 Kostya Shishkov
#include "avutil.h"
26 69ae9478 Attila Kinali
#include "bswap.h"
27 451ae257 Kostya Shishkov
#include "sha.h"
28 0fcbcad1 Carl Eugen Hoyos
#include "sha1.h"
29 045b60bf Kostya Shishkov
#include "intreadwrite.h"
30 7c60e55b Michael Niedermayer
31 4364fc9a Kostya Shishkov
/** hash context */
32 451ae257 Kostya Shishkov
typedef struct AVSHA {
33 01cc6288 Kostya Shishkov
    uint8_t  digest_len;  ///< digest length in 32-bit words
34 4364fc9a Kostya Shishkov
    uint64_t count;       ///< number of bytes in buffer
35 3a7c6507 Kostya Shishkov
    uint8_t  buffer[64];  ///< 512-bit buffer of input values used in hash updating
36 01cc6288 Kostya Shishkov
    uint32_t state[8];    ///< current hash value
37 2c6361e0 Kostya Shishkov
    /** function used to update hash for 512-bit input block */
38
    void     (*transform)(uint32_t *state, const uint8_t buffer[64]);
39 451ae257 Kostya Shishkov
} AVSHA;
40 7c60e55b Michael Niedermayer
41 451ae257 Kostya Shishkov
const int av_sha_size = sizeof(AVSHA);
42 537c8e7a Luca Barbato
43 7c60e55b Michael Niedermayer
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
44
45
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
46 f522310b Michael Niedermayer
#define blk0(i) (block[i] = be2me_32(((const uint32_t*)buffer)[i]))
47 0ef37cd5 Diego Biurrun
#define blk(i)  (block[i] = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1))
48 d6cf7804 Michael Niedermayer
49 0ef37cd5 Diego Biurrun
#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 7c60e55b Michael Niedermayer
55
/* Hash a single 512-bit block. This is the core of the algorithm. */
56
57 0d73abb8 Kostya Shishkov
static void sha1_transform(uint32_t state[5], const uint8_t buffer[64])
58 0ef37cd5 Diego Biurrun
{
59 aa59433a Michael Niedermayer
    uint32_t block[80];
60 5fd7f87b Michael Niedermayer
    unsigned int i, a, b, c, d, e;
61 3479b72b Michael Niedermayer
62 7c60e55b Michael Niedermayer
    a = state[0];
63
    b = state[1];
64
    c = state[2];
65
    d = state[3];
66
    e = state[4];
67 b250f9c6 Aurelien Jacobs
#if CONFIG_SMALL
68 0ef37cd5 Diego Biurrun
    for (i = 0; i < 80; i++) {
69 476f9b74 Michael Niedermayer
        int t;
70 0ef37cd5 Diego Biurrun
        if (i < 16)
71
            t = be2me_32(((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 2fa3a22d Michael Niedermayer
        }
87 0ef37cd5 Diego Biurrun
        e = d;
88
        d = c;
89
        c = rol(b, 30);
90
        b = a;
91
        a = t;
92 6573578d Michael Niedermayer
    }
93
#else
94 0ef37cd5 Diego Biurrun
    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 7c60e55b Michael Niedermayer
    }
101 0ef37cd5 Diego Biurrun
    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 7c60e55b Michael Niedermayer
    }
113 0ef37cd5 Diego Biurrun
    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 7c60e55b Michael Niedermayer
    }
120 0ef37cd5 Diego Biurrun
    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 7c60e55b Michael Niedermayer
    }
127 6573578d Michael Niedermayer
#endif
128 7c60e55b Michael Niedermayer
    state[0] += a;
129
    state[1] += b;
130
    state[2] += c;
131
    state[3] += d;
132
    state[4] += e;
133
}
134
135 aa5a99ae Kostya Shishkov
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 8b4e7c28 Diego Biurrun
    uint32_t T1, av_unused(T2);
186 aa5a99ae Kostya Shishkov
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 451ae257 Kostya Shishkov
int av_sha_init(AVSHA* ctx, int bits)
247 0ef37cd5 Diego Biurrun
{
248 aa5a99ae Kostya Shishkov
    ctx->digest_len = bits >> 5;
249
    switch (bits) {
250
    case 160: // SHA-1
251 87d718ae Kostya Shishkov
        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 aa5a99ae Kostya Shishkov
        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 451ae257 Kostya Shishkov
    return 0;
285 7c60e55b Michael Niedermayer
}
286
287 451ae257 Kostya Shishkov
void av_sha_update(AVSHA* ctx, const uint8_t* data, unsigned int len)
288 0ef37cd5 Diego Biurrun
{
289 7c60e55b Michael Niedermayer
    unsigned int i, j;
290
291 248b25f8 Michael Niedermayer
    j = ctx->count & 63;
292
    ctx->count += len;
293 b250f9c6 Aurelien Jacobs
#if CONFIG_SMALL
294 0ef37cd5 Diego Biurrun
    for (i = 0; i < len; i++) {
295
        ctx->buffer[j++] = data[i];
296
        if (64 == j) {
297 2c6361e0 Kostya Shishkov
            ctx->transform(ctx->state, ctx->buffer);
298 36c7fa7e Michael Niedermayer
            j = 0;
299
        }
300
    }
301
#else
302 7c60e55b Michael Niedermayer
    if ((j + len) > 63) {
303 0ef37cd5 Diego Biurrun
        memcpy(&ctx->buffer[j], data, (i = 64 - j));
304 2c6361e0 Kostya Shishkov
        ctx->transform(ctx->state, ctx->buffer);
305 0ef37cd5 Diego Biurrun
        for (; i + 63 < len; i += 64)
306 2c6361e0 Kostya Shishkov
            ctx->transform(ctx->state, &data[i]);
307 0ef37cd5 Diego Biurrun
        j = 0;
308
    } else
309
        i = 0;
310 248b25f8 Michael Niedermayer
    memcpy(&ctx->buffer[j], &data[i], len - i);
311 36c7fa7e Michael Niedermayer
#endif
312 7c60e55b Michael Niedermayer
}
313
314 451ae257 Kostya Shishkov
void av_sha_final(AVSHA* ctx, uint8_t *digest)
315 0ef37cd5 Diego Biurrun
{
316 7c60e55b Michael Niedermayer
    int i;
317 0ef37cd5 Diego Biurrun
    uint64_t finalcount = be2me_64(ctx->count << 3);
318 7c60e55b Michael Niedermayer
319 451ae257 Kostya Shishkov
    av_sha_update(ctx, "\200", 1);
320 0ef37cd5 Diego Biurrun
    while ((ctx->count & 63) != 56)
321 451ae257 Kostya Shishkov
        av_sha_update(ctx, "", 1);
322
    av_sha_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
323 aa5a99ae Kostya Shishkov
    for (i = 0; i < ctx->digest_len; i++)
324 a768816c Kostya Shishkov
        AV_WB32(digest + i*4, ctx->state[i]);
325 7c60e55b Michael Niedermayer
}
326
327 451ae257 Kostya Shishkov
#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 7c60e55b Michael Niedermayer
#ifdef TEST
351
#include <stdio.h>
352
#undef printf
353
354 0ef37cd5 Diego Biurrun
int main(void)
355
{
356 aa5a99ae Kostya Shishkov
    int i, j, k;
357 451ae257 Kostya Shishkov
    AVSHA ctx;
358 aa5a99ae Kostya Shishkov
    unsigned char digest[32];
359
    const int lengths[3] = { 160, 224, 256 };
360 7c60e55b Michael Niedermayer
361 aa5a99ae Kostya Shishkov
    for (j = 0; j < 3; j++) {
362
        printf("Testing SHA-%d\n", lengths[j]);
363 87d718ae Kostya Shishkov
        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 aa5a99ae Kostya Shishkov
    }
398 7c60e55b Michael Niedermayer
399
    return 0;
400
}
401
#endif