git.sesse.net Git - ffmpeg/blob - libavutil/sha.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 "avutil.h"
  24 #include "bswap.h"
  25 #include "sha.h"
  26
  27 /** hash context */
  28 typedef struct AVSHA {
  29     uint8_t  digest_len;  ///< digest length in 32-bit words
  30     uint64_t count;       ///< number of bytes in buffer
  31     uint8_t  buffer[64];  ///< 512-bit buffer of input values used in hash updating
  32     uint32_t state[8];    ///< current hash value
  33     /** function used to update hash for 512-bit input block */
  34     void     (*transform)(uint32_t *state, const uint8_t buffer[64]);
  35 } AVSHA;
  36
  37 const int av_sha_size = sizeof(AVSHA);
  38
  39 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
  40
  41 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
  42 #define blk0(i) (block[i] = be2me_32(((const uint32_t*)buffer)[i]))
  43 #define blk(i)  (block[i] = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1))
  44
  45 #define R0(v,w,x,y,z,i) z += ((w&(x^y))^y)     + blk0(i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
  46 #define R1(v,w,x,y,z,i) z += ((w&(x^y))^y)     + blk (i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
  47 #define R2(v,w,x,y,z,i) z += ( w^x     ^y)     + blk (i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
  48 #define R3(v,w,x,y,z,i) z += (((w|x)&y)|(w&x)) + blk (i) + 0x8F1BBCDC + rol(v, 5); w = rol(w, 30);
  49 #define R4(v,w,x,y,z,i) z += ( w^x     ^y)     + blk (i) + 0xCA62C1D6 + rol(v, 5); w = rol(w, 30);
  50
  51 /* Hash a single 512-bit block. This is the core of the algorithm. */
  52
  53 static void sha1_transform(uint32_t state[5], const uint8_t buffer[64])
  54 {
  55     uint32_t block[80];
  56     unsigned int i, a, b, c, d, e;
  57
  58     a = state[0];
  59     b = state[1];
  60     c = state[2];
  61     d = state[3];
  62     e = state[4];
  63 #if CONFIG_SMALL
  64     for (i = 0; i < 80; i++) {
  65         int t;
  66         if (i < 16)
  67             t = be2me_32(((uint32_t*)buffer)[i]);
  68         else
  69             t = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1);
  70         block[i] = t;
  71         t += e + rol(a, 5);
  72         if (i < 40) {
  73             if (i < 20)
  74                 t += ((b&(c^d))^d)     + 0x5A827999;
  75             else
  76                 t += ( b^c     ^d)     + 0x6ED9EBA1;
  77         } else {
  78             if (i < 60)
  79                 t += (((b|c)&d)|(b&c)) + 0x8F1BBCDC;
  80             else
  81                 t += ( b^c     ^d)     + 0xCA62C1D6;
  82         }
  83         e = d;
  84         d = c;
  85         c = rol(b, 30);
  86         b = a;
  87         a = t;
  88     }
  89 #else
  90     for (i = 0; i < 15; i += 5) {
  91         R0(a, b, c, d, e, 0 + i);
  92         R0(e, a, b, c, d, 1 + i);
  93         R0(d, e, a, b, c, 2 + i);
  94         R0(c, d, e, a, b, 3 + i);
  95         R0(b, c, d, e, a, 4 + i);
  96     }
  97     R0(a, b, c, d, e, 15);
  98     R1(e, a, b, c, d, 16);
  99     R1(d, e, a, b, c, 17);
 100     R1(c, d, e, a, b, 18);
 101     R1(b, c, d, e, a, 19);
 102     for (i = 20; i < 40; i += 5) {
 103         R2(a, b, c, d, e, 0 + i);
 104         R2(e, a, b, c, d, 1 + i);
 105         R2(d, e, a, b, c, 2 + i);
 106         R2(c, d, e, a, b, 3 + i);
 107         R2(b, c, d, e, a, 4 + i);
 108     }
 109     for (; i < 60; i += 5) {
 110         R3(a, b, c, d, e, 0 + i);
 111         R3(e, a, b, c, d, 1 + i);
 112         R3(d, e, a, b, c, 2 + i);
 113         R3(c, d, e, a, b, 3 + i);
 114         R3(b, c, d, e, a, 4 + i);
 115     }
 116     for (; i < 80; i += 5) {
 117         R4(a, b, c, d, e, 0 + i);
 118         R4(e, a, b, c, d, 1 + i);
 119         R4(d, e, a, b, c, 2 + i);
 120         R4(c, d, e, a, b, 3 + i);
 121         R4(b, c, d, e, a, 4 + i);
 122     }
 123 #endif
 124     state[0] += a;
 125     state[1] += b;
 126     state[2] += c;
 127     state[3] += d;
 128     state[4] += e;
 129 }
 130
 131 int av_sha_init(AVSHA* ctx, int bits)
 132 {
 133     ctx->state[0] = 0x67452301;
 134     ctx->state[1] = 0xEFCDAB89;
 135     ctx->state[2] = 0x98BADCFE;
 136     ctx->state[3] = 0x10325476;
 137     ctx->state[4] = 0xC3D2E1F0;
 138     ctx->transform = sha1_transform;
 139     ctx->count    = 0;
 140     return 0;
 141 }
 142
 143 void av_sha_update(AVSHA* ctx, const uint8_t* data, unsigned int len)
 144 {
 145     unsigned int i, j;
 146
 147     j = ctx->count & 63;
 148     ctx->count += len;
 149 #if CONFIG_SMALL
 150     for (i = 0; i < len; i++) {
 151         ctx->buffer[j++] = data[i];
 152         if (64 == j) {
 153             ctx->transform(ctx->state, ctx->buffer);
 154             j = 0;
 155         }
 156     }
 157 #else
 158     if ((j + len) > 63) {
 159         memcpy(&ctx->buffer[j], data, (i = 64 - j));
 160         ctx->transform(ctx->state, ctx->buffer);
 161         for (; i + 63 < len; i += 64)
 162             ctx->transform(ctx->state, &data[i]);
 163         j = 0;
 164     } else
 165         i = 0;
 166     memcpy(&ctx->buffer[j], &data[i], len - i);
 167 #endif
 168 }
 169
 170 void av_sha_final(AVSHA* ctx, uint8_t *digest)
 171 {
 172     int i;
 173     uint64_t finalcount = be2me_64(ctx->count << 3);
 174
 175     av_sha_update(ctx, "\200", 1);
 176     while ((ctx->count & 63) != 56)
 177         av_sha_update(ctx, "", 1);
 178     av_sha_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
 179     for (i = 0; i < 5; i++)
 180         ((uint32_t*)digest)[i] = be2me_32(ctx->state[i]);
 181 }
 182
 183 #if LIBAVUTIL_VERSION_MAJOR < 51
 184 struct AVSHA1 {
 185     AVSHA sha;
 186 };
 187
 188 const int av_sha1_size = sizeof(struct AVSHA1);
 189
 190 void av_sha1_init(struct AVSHA1* context)
 191 {
 192     av_sha_init(&context->sha, 160);
 193 }
 194
 195 void av_sha1_update(struct AVSHA1* context, const uint8_t* data, unsigned int len)
 196 {
 197     av_sha_update(&context->sha, data, len);
 198 }
 199
 200 void av_sha1_final(struct AVSHA1* context, uint8_t digest[20])
 201 {
 202     av_sha_final(&context->sha, digest);
 203 }
 204 #endif
 205
 206 #ifdef TEST
 207 #include <stdio.h>
 208 #undef printf
 209
 210 int main(void)
 211 {
 212     int i, k;
 213     AVSHA ctx;
 214     unsigned char digest[20];
 215
 216     for (k = 0; k < 3; k++) {
 217         av_sha_init(&ctx, 160);
 218         if (k == 0)
 219             av_sha_update(&ctx, "abc", 3);
 220         else if (k == 1)
 221             av_sha_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
 222         else
 223             for (i = 0; i < 1000*1000; i++)
 224                 av_sha_update(&ctx, "a", 1);
 225         av_sha_final(&ctx, digest);
 226         for (i = 0; i < 20; i++)
 227             printf("%02X", digest[i]);
 228         putchar('\n');
 229     }
 230     //test vectors (from FIPS PUB 180-1)
 231     printf("A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D\n"
 232            "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1\n"
 233            "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F\n");
 234
 235     return 0;
 236 }
 237 #endif