Statistics
| Branch: | Revision:

ffmpeg / libavutil / sha.c @ 0fcbcad1

History | View | Annotate | Download (12.2 KB)

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 "common.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] = be2me_32(((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 = 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
        }
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 = be2me_64(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