libavutil/sha1.c

   1 /*
   2  * Copyright (C) 2007 Michael Niedermayer <michaelni@gmx.at>
   3  * based on public domain SHA-1 code by Steve Reid <steve@edmweb.com>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "common.h"
  23 #include "bswap.h"
  24 #include "sha1.h"
  25
  26 /** hash context */
  27 typedef struct AVSHA1 {
  28     uint8_t  digest_len;  ///< digest length in 32-bit words
  29     uint64_t count;       ///< number of bytes in buffer
  30     uint8_t  buffer[64];  ///< 512-bit buffer of input values used in hash updating
  31     uint32_t state[8];    ///< current hash value
  32 } AVSHA1;
  33
  34 const int av_sha1_size = sizeof(AVSHA1);
  35
  36 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
  37
  38 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
  39 #define blk0(i) (block[i] = be2me_32(((const uint32_t*)buffer)[i]))
  40 #define blk(i)  (block[i] = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1))
  41
  42 #define R0(v,w,x,y,z,i) z += ((w&(x^y))^y)     + blk0(i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
  43 #define R1(v,w,x,y,z,i) z += ((w&(x^y))^y)     + blk (i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
  44 #define R2(v,w,x,y,z,i) z += ( w^x     ^y)     + blk (i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
  45 #define R3(v,w,x,y,z,i) z += (((w|x)&y)|(w&x)) + blk (i) + 0x8F1BBCDC + rol(v, 5); w = rol(w, 30);
  46 #define R4(v,w,x,y,z,i) z += ( w^x     ^y)     + blk (i) + 0xCA62C1D6 + rol(v, 5); w = rol(w, 30);
  47
  48 /* Hash a single 512-bit block. This is the core of the algorithm. */
  49
  50 static void transform(uint32_t state[5], const uint8_t buffer[64])
  51 {
  52     uint32_t block[80];
  53     unsigned int i, a, b, c, d, e;
  54
  55     a = state[0];
  56     b = state[1];
  57     c = state[2];
  58     d = state[3];
  59     e = state[4];
  60 #if CONFIG_SMALL
  61     for (i = 0; i < 80; i++) {
  62         int t;
  63         if (i < 16)
  64             t = be2me_32(((uint32_t*)buffer)[i]);
  65         else
  66             t = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1);
  67         block[i] = t;
  68         t += e + rol(a, 5);
  69         if (i < 40) {
  70             if (i < 20)
  71                 t += ((b&(c^d))^d)     + 0x5A827999;
  72             else
  73                 t += ( b^c     ^d)     + 0x6ED9EBA1;
  74         } else {
  75             if (i < 60)
  76                 t += (((b|c)&d)|(b&c)) + 0x8F1BBCDC;
  77             else
  78                 t += ( b^c     ^d)     + 0xCA62C1D6;
  79         }
  80         e = d;
  81         d = c;
  82         c = rol(b, 30);
  83         b = a;
  84         a = t;
  85     }
  86 #else
  87     for (i = 0; i < 15; i += 5) {
  88         R0(a, b, c, d, e, 0 + i);
  89         R0(e, a, b, c, d, 1 + i);
  90         R0(d, e, a, b, c, 2 + i);
  91         R0(c, d, e, a, b, 3 + i);
  92         R0(b, c, d, e, a, 4 + i);
  93     }
  94     R0(a, b, c, d, e, 15);
  95     R1(e, a, b, c, d, 16);
  96     R1(d, e, a, b, c, 17);
  97     R1(c, d, e, a, b, 18);
  98     R1(b, c, d, e, a, 19);
  99     for (i = 20; i < 40; i += 5) {
 100         R2(a, b, c, d, e, 0 + i);
 101         R2(e, a, b, c, d, 1 + i);
 102         R2(d, e, a, b, c, 2 + i);
 103         R2(c, d, e, a, b, 3 + i);
 104         R2(b, c, d, e, a, 4 + i);
 105     }
 106     for (; i < 60; i += 5) {
 107         R3(a, b, c, d, e, 0 + i);
 108         R3(e, a, b, c, d, 1 + i);
 109         R3(d, e, a, b, c, 2 + i);
 110         R3(c, d, e, a, b, 3 + i);
 111         R3(b, c, d, e, a, 4 + i);
 112     }
 113     for (; i < 80; i += 5) {
 114         R4(a, b, c, d, e, 0 + i);
 115         R4(e, a, b, c, d, 1 + i);
 116         R4(d, e, a, b, c, 2 + i);
 117         R4(c, d, e, a, b, 3 + i);
 118         R4(b, c, d, e, a, 4 + i);
 119     }
 120 #endif
 121     state[0] += a;
 122     state[1] += b;
 123     state[2] += c;
 124     state[3] += d;
 125     state[4] += e;
 126 }
 127
 128 void av_sha1_init(AVSHA1* ctx)
 129 {
 130     ctx->state[0] = 0x67452301;
 131     ctx->state[1] = 0xEFCDAB89;
 132     ctx->state[2] = 0x98BADCFE;
 133     ctx->state[3] = 0x10325476;
 134     ctx->state[4] = 0xC3D2E1F0;
 135     ctx->count    = 0;
 136 }
 137
 138 void av_sha1_update(AVSHA1* ctx, const uint8_t* data, unsigned int len)
 139 {
 140     unsigned int i, j;
 141
 142     j = ctx->count & 63;
 143     ctx->count += len;
 144 #if CONFIG_SMALL
 145     for (i = 0; i < len; i++) {
 146         ctx->buffer[j++] = data[i];
 147         if (64 == j) {
 148             transform(ctx->state, ctx->buffer);
 149             j = 0;
 150         }
 151     }
 152 #else
 153     if ((j + len) > 63) {
 154         memcpy(&ctx->buffer[j], data, (i = 64 - j));
 155         transform(ctx->state, ctx->buffer);
 156         for (; i + 63 < len; i += 64)
 157             transform(ctx->state, &data[i]);
 158         j = 0;
 159     } else
 160         i = 0;
 161     memcpy(&ctx->buffer[j], &data[i], len - i);
 162 #endif
 163 }
 164
 165 void av_sha1_final(AVSHA1* ctx, uint8_t digest[20])
 166 {
 167     int i;
 168     uint64_t finalcount = be2me_64(ctx->count << 3);
 169
 170     av_sha1_update(ctx, "\200", 1);
 171     while ((ctx->count & 63) != 56)
 172         av_sha1_update(ctx, "", 1);
 173     av_sha1_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
 174     for (i = 0; i < 5; i++)
 175         ((uint32_t*)digest)[i] = be2me_32(ctx->state[i]);
 176 }
 177
 178 #ifdef TEST
 179 #include <stdio.h>
 180 #undef printf
 181
 182 int main(void)
 183 {
 184     int i, k;
 185     AVSHA1 ctx;
 186     unsigned char digest[20];
 187
 188     for (k = 0; k < 3; k++) {
 189         av_sha1_init(&ctx);
 190         if (k == 0)
 191             av_sha1_update(&ctx, "abc", 3);
 192         else if (k == 1)
 193             av_sha1_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
 194         else
 195             for (i = 0; i < 1000 * 1000; i++)
 196                 av_sha1_update(&ctx, "a", 1);
 197         av_sha1_final(&ctx, digest);
 198         for (i = 0; i < 20; i++)
 199             printf("%02X", digest[i]);
 200         putchar('\n');
 201     }
 202     //test vectors (from FIPS PUB 180-1)
 203     printf("A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D\n"
 204            "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1\n"
 205            "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F\n");
 206
 207     return 0;
 208 }
 209 #endif