LCOV - code coverage report
Current view: top level - src/libavutil - md5.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 57 57 100.0 %
Date: 2017-01-21 09:32:20 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (C) 2006 Michael Niedermayer (michaelni@gmx.at)
       3             :  * Copyright (C) 2003-2005 by Christopher R. Hertel (crh@ubiqx.mn.org)
       4             :  *
       5             :  * References:
       6             :  *  IETF RFC 1321: The MD5 Message-Digest Algorithm
       7             :  *       Ron Rivest. IETF, April, 1992
       8             :  *
       9             :  * based on http://ubiqx.org/libcifs/source/Auth/MD5.c
      10             :  *          from Christopher R. Hertel (crh@ubiqx.mn.org)
      11             :  * Simplified, cleaned and IMO redundant comments removed by Michael.
      12             :  *
      13             :  * If you use gcc, then version 4.1 or later and -fomit-frame-pointer is
      14             :  * strongly recommended.
      15             :  *
      16             :  * This file is part of FFmpeg.
      17             :  *
      18             :  * FFmpeg is free software; you can redistribute it and/or
      19             :  * modify it under the terms of the GNU Lesser General Public
      20             :  * License as published by the Free Software Foundation; either
      21             :  * version 2.1 of the License, or (at your option) any later version.
      22             :  *
      23             :  * FFmpeg is distributed in the hope that it will be useful,
      24             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      25             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      26             :  * Lesser General Public License for more details.
      27             :  *
      28             :  * You should have received a copy of the GNU Lesser General Public
      29             :  * License along with FFmpeg; if not, write to the Free Software
      30             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      31             :  */
      32             : 
      33             : #include <stdint.h>
      34             : 
      35             : #include "bswap.h"
      36             : #include "intreadwrite.h"
      37             : #include "mem.h"
      38             : #include "md5.h"
      39             : 
      40             : typedef struct AVMD5 {
      41             :     uint64_t len;
      42             :     uint8_t  block[64];
      43             :     uint32_t ABCD[4];
      44             : } AVMD5;
      45             : 
      46             : const int av_md5_size = sizeof(AVMD5);
      47             : 
      48        2442 : struct AVMD5 *av_md5_alloc(void)
      49             : {
      50        2442 :     return av_mallocz(sizeof(struct AVMD5));
      51             : }
      52             : 
      53             : static const uint8_t S[4][4] = {
      54             :     { 7, 12, 17, 22 },  /* round 1 */
      55             :     { 5,  9, 14, 20 },  /* round 2 */
      56             :     { 4, 11, 16, 23 },  /* round 3 */
      57             :     { 6, 10, 15, 21 }   /* round 4 */
      58             : };
      59             : 
      60             : static const uint32_t T[64] = { // T[i]= fabs(sin(i+1)<<32)
      61             :     0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,   /* round 1 */
      62             :     0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
      63             :     0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
      64             :     0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
      65             : 
      66             :     0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,   /* round 2 */
      67             :     0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
      68             :     0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
      69             :     0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
      70             : 
      71             :     0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,   /* round 3 */
      72             :     0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
      73             :     0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
      74             :     0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
      75             : 
      76             :     0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,   /* round 4 */
      77             :     0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
      78             :     0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
      79             :     0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
      80             : };
      81             : 
      82             : #define CORE(i, a, b, c, d)                                             \
      83             :     do {                                                                \
      84             :         t  = S[i >> 4][i & 3];                                          \
      85             :         a += T[i];                                                      \
      86             :                                                                         \
      87             :         if (i < 32) {                                                   \
      88             :             if (i < 16)                                                 \
      89             :                 a += (d ^ (b & (c ^ d)))  + X[       i  & 15];          \
      90             :             else                                                        \
      91             :                 a += ((d & b) | (~d & c)) + X[(1 + 5*i) & 15];          \
      92             :         } else {                                                        \
      93             :             if (i < 48)                                                 \
      94             :                 a += (b ^ c ^ d)          + X[(5 + 3*i) & 15];          \
      95             :             else                                                        \
      96             :                 a += (c ^ (b | ~d))       + X[(    7*i) & 15];          \
      97             :         }                                                               \
      98             :         a = b + (a << t | a >> (32 - t));                               \
      99             :     } while (0)
     100             : 
     101      238934 : static void body(uint32_t ABCD[4], uint32_t *src, int nblocks)
     102             : {
     103             :     int i av_unused;
     104             :     int n;
     105             :     uint32_t a, b, c, d, t, *X;
     106             : 
     107    44565530 :     for (n = 0; n < nblocks; n++) {
     108    44326596 :         a = ABCD[3];
     109    44326596 :         b = ABCD[2];
     110    44326596 :         c = ABCD[1];
     111    44326596 :         d = ABCD[0];
     112             : 
     113    44326596 :         X = src + n * 16;
     114             : 
     115             : #if HAVE_BIGENDIAN
     116             :         for (i = 0; i < 16; i++)
     117             :             X[i] = av_bswap32(X[i]);
     118             : #endif
     119             : 
     120             : #if CONFIG_SMALL
     121             :         for (i = 0; i < 64; i++) {
     122             :             CORE(i, a, b, c, d);
     123             :             t = d;
     124             :             d = c;
     125             :             c = b;
     126             :             b = a;
     127             :             a = t;
     128             :         }
     129             : #else
     130             : #define CORE2(i)                                                        \
     131             :         CORE(i, a, b, c, d); CORE((i + 1), d, a, b, c);                 \
     132             :         CORE((i + 2), c, d, a, b); CORE((i + 3), b, c, d, a)
     133             : #define CORE4(i) CORE2(i); CORE2((i + 4)); CORE2((i + 8)); CORE2((i + 12))
     134    44326596 :         CORE4(0);
     135    44326596 :         CORE4(16);
     136    44326596 :         CORE4(32);
     137    44326596 :         CORE4(48);
     138             : #endif
     139             : 
     140    44326596 :         ABCD[0] += d;
     141    44326596 :         ABCD[1] += c;
     142    44326596 :         ABCD[2] += b;
     143    44326596 :         ABCD[3] += a;
     144             :     }
     145      238934 : }
     146             : 
     147       11679 : void av_md5_init(AVMD5 *ctx)
     148             : {
     149       11679 :     ctx->len     = 0;
     150             : 
     151       11679 :     ctx->ABCD[0] = 0x10325476;
     152       11679 :     ctx->ABCD[1] = 0x98badcfe;
     153       11679 :     ctx->ABCD[2] = 0xefcdab89;
     154       11679 :     ctx->ABCD[3] = 0x67452301;
     155       11679 : }
     156             : 
     157      647311 : void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len)
     158             : {
     159             :     const uint8_t *end;
     160             :     int j;
     161             : 
     162      647311 :     j         = ctx->len & 63;
     163      647311 :     ctx->len += len;
     164             : 
     165      647311 :     if (j) {
     166      577273 :         int cnt = FFMIN(len, 64 - j);
     167      577273 :         memcpy(ctx->block + j, src, cnt);
     168      577273 :         src += cnt;
     169      577273 :         len -= cnt;
     170      577273 :         if (j + cnt < 64)
     171      492825 :             return;
     172       84448 :         body(ctx->ABCD, (uint32_t *)ctx->block, 1);
     173             :     }
     174             : 
     175      154486 :     end = src + (len & ~63);
     176             :     if (HAVE_BIGENDIAN || (!HAVE_FAST_UNALIGNED && ((intptr_t)src & 3))) {
     177             :        while (src < end) {
     178             :            memcpy(ctx->block, src, 64);
     179             :            body(ctx->ABCD, (uint32_t *) ctx->block, 1);
     180             :            src += 64;
     181             :         }
     182             :     } else {
     183      154486 :         int nblocks = len / 64;
     184      154486 :         body(ctx->ABCD, (uint32_t *)src, nblocks);
     185      154486 :         src = end;
     186             :     }
     187      154486 :     len &= 63;
     188      154486 :     if (len > 0)
     189       84460 :         memcpy(ctx->block, src, len);
     190             : }
     191             : 
     192       11675 : void av_md5_final(AVMD5 *ctx, uint8_t *dst)
     193             : {
     194             :     int i;
     195       11675 :     uint64_t finalcount = av_le2ne64(ctx->len << 3);
     196             : 
     197       11675 :     av_md5_update(ctx, "\200", 1);
     198      507612 :     while ((ctx->len & 63) != 56)
     199      484262 :         av_md5_update(ctx, "", 1);
     200             : 
     201       11675 :     av_md5_update(ctx, (uint8_t *) &finalcount, 8);
     202             : 
     203       58375 :     for (i = 0; i < 4; i++)
     204       46700 :         AV_WL32(dst + 4 * i, ctx->ABCD[3 - i]);
     205       11675 : }
     206             : 
     207        5059 : void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len)
     208             : {
     209             :     AVMD5 ctx;
     210             : 
     211        5059 :     av_md5_init(&ctx);
     212        5059 :     av_md5_update(&ctx, src, len);
     213        5059 :     av_md5_final(&ctx, dst);
     214        5059 : }

Generated by: LCOV version 1.12