LCOV - code coverage report
Current view: top level - elfutils/lib - md5.c (source / functions) Hit Total Coverage
Test: lcov.out Lines: 142 146 97.3 %
Date: 2012-10-31 Functions: 5 5 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 16 20 80.0 %

           Branch data     Line data    Source code
       1                 :            : /* Functions to compute MD5 message digest of files or memory blocks.
       2                 :            :    according to the definition of MD5 in RFC 1321 from April 1992.
       3                 :            :    Copyright (C) 1995-2011 Red Hat, Inc.
       4                 :            :    This file is part of elfutils.
       5                 :            :    Written by Ulrich Drepper <drepper@redhat.com>, 1995.
       6                 :            : 
       7                 :            :    This file is free software; you can redistribute it and/or modify
       8                 :            :    it under the terms of either
       9                 :            : 
      10                 :            :      * the GNU Lesser General Public License as published by the Free
      11                 :            :        Software Foundation; either version 3 of the License, or (at
      12                 :            :        your option) any later version
      13                 :            : 
      14                 :            :    or
      15                 :            : 
      16                 :            :      * the GNU General Public License as published by the Free
      17                 :            :        Software Foundation; either version 2 of the License, or (at
      18                 :            :        your option) any later version
      19                 :            : 
      20                 :            :    or both in parallel, as here.
      21                 :            : 
      22                 :            :    elfutils is distributed in the hope that it will be useful, but
      23                 :            :    WITHOUT ANY WARRANTY; without even the implied warranty of
      24                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      25                 :            :    General Public License for more details.
      26                 :            : 
      27                 :            :    You should have received copies of the GNU General Public License and
      28                 :            :    the GNU Lesser General Public License along with this program.  If
      29                 :            :    not, see <http://www.gnu.org/licenses/>.  */
      30                 :            : 
      31                 :            : #ifdef HAVE_CONFIG_H
      32                 :            : # include <config.h>
      33                 :            : #endif
      34                 :            : 
      35                 :            : #include <stdlib.h>
      36                 :            : #include <string.h>
      37                 :            : #include <sys/types.h>
      38                 :            : 
      39                 :            : #include "md5.h"
      40                 :            : #include "system.h"
      41                 :            : 
      42                 :            : #define SWAP(n) LE32 (n)
      43                 :            : 
      44                 :            : /* This array contains the bytes used to pad the buffer to the next
      45                 :            :    64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
      46                 :            : static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
      47                 :            : 
      48                 :            : 
      49                 :            : /* Initialize structure containing state of computation.
      50                 :            :    (RFC 1321, 3.3: Step 3)  */
      51                 :            : void
      52                 :          4 : md5_init_ctx (ctx)
      53                 :            :      struct md5_ctx *ctx;
      54                 :            : {
      55                 :          4 :   ctx->A = 0x67452301;
      56                 :          4 :   ctx->B = 0xefcdab89;
      57                 :          4 :   ctx->C = 0x98badcfe;
      58                 :          4 :   ctx->D = 0x10325476;
      59                 :            : 
      60                 :          4 :   ctx->total[0] = ctx->total[1] = 0;
      61                 :          4 :   ctx->buflen = 0;
      62                 :          4 : }
      63                 :            : 
      64                 :            : /* Put result from CTX in first 16 bytes following RESBUF.  The result
      65                 :            :    must be in little endian byte order.
      66                 :            : 
      67                 :            :    IMPORTANT: On some systems it is required that RESBUF is correctly
      68                 :            :    aligned for a 32 bits value.  */
      69                 :            : void *
      70                 :          4 : md5_read_ctx (ctx, resbuf)
      71                 :            :      const struct md5_ctx *ctx;
      72                 :            :      void *resbuf;
      73                 :            : {
      74                 :          4 :   ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
      75                 :          4 :   ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
      76                 :          4 :   ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C);
      77                 :          4 :   ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D);
      78                 :            : 
      79                 :          4 :   return resbuf;
      80                 :            : }
      81                 :            : 
      82                 :            : static void
      83                 :            : le64_copy (char *dest, uint64_t x)
      84                 :            : {
      85         [ +  + ]:         36 :   for (size_t i = 0; i < 8; ++i)
      86                 :            :     {
      87                 :         32 :       dest[i] = (uint8_t) x;
      88                 :         32 :       x >>= 8;
      89                 :            :     }
      90                 :            : }
      91                 :            : 
      92                 :            : /* Process the remaining bytes in the internal buffer and the usual
      93                 :            :    prolog according to the standard and write the result to RESBUF.
      94                 :            : 
      95                 :            :    IMPORTANT: On some systems it is required that RESBUF is correctly
      96                 :            :    aligned for a 32 bits value.  */
      97                 :            : void *
      98                 :          4 : md5_finish_ctx (ctx, resbuf)
      99                 :            :      struct md5_ctx *ctx;
     100                 :            :      void *resbuf;
     101                 :            : {
     102                 :            :   /* Take yet unprocessed bytes into account.  */
     103                 :          4 :   md5_uint32 bytes = ctx->buflen;
     104                 :            :   size_t pad;
     105                 :            : 
     106                 :            :   /* Now count remaining bytes.  */
     107                 :          4 :   ctx->total[0] += bytes;
     108         [ -  + ]:          4 :   if (ctx->total[0] < bytes)
     109                 :          0 :     ++ctx->total[1];
     110                 :            : 
     111         [ +  + ]:          4 :   pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
     112                 :          4 :   memcpy (&ctx->buffer[bytes], fillbuf, pad);
     113                 :            : 
     114                 :            :   /* Put the 64-bit file length in *bits* at the end of the buffer.  */
     115                 :          8 :   const uint64_t bit_length = ((ctx->total[0] << 3)
     116                 :          8 :                                + ((uint64_t) ((ctx->total[1] << 3) |
     117                 :          8 :                                               (ctx->total[0] >> 29)) << 32));
     118                 :          4 :   le64_copy (&ctx->buffer[bytes + pad], bit_length);
     119                 :            : 
     120                 :            :   /* Process last bytes.  */
     121                 :          4 :   md5_process_block (ctx->buffer, bytes + pad + 8, ctx);
     122                 :            : 
     123                 :          4 :   return md5_read_ctx (ctx, resbuf);
     124                 :            : }
     125                 :            : 
     126                 :            : 
     127                 :            : #ifdef NEED_MD5_STREAM
     128                 :            : /* Compute MD5 message digest for bytes read from STREAM.  The
     129                 :            :    resulting message digest number will be written into the 16 bytes
     130                 :            :    beginning at RESBLOCK.  */
     131                 :            : int
     132                 :            : md5_stream (stream, resblock)
     133                 :            :      FILE *stream;
     134                 :            :      void *resblock;
     135                 :            : {
     136                 :            :   /* Important: BLOCKSIZE must be a multiple of 64.  */
     137                 :            : #define BLOCKSIZE 4096
     138                 :            :   struct md5_ctx ctx;
     139                 :            :   char buffer[BLOCKSIZE + 72];
     140                 :            :   size_t sum;
     141                 :            : 
     142                 :            :   /* Initialize the computation context.  */
     143                 :            :   md5_init_ctx (&ctx);
     144                 :            : 
     145                 :            :   /* Iterate over full file contents.  */
     146                 :            :   while (1)
     147                 :            :     {
     148                 :            :       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
     149                 :            :          computation function processes the whole buffer so that with the
     150                 :            :          next round of the loop another block can be read.  */
     151                 :            :       size_t n;
     152                 :            :       sum = 0;
     153                 :            : 
     154                 :            :       /* Read block.  Take care for partial reads.  */
     155                 :            :       do
     156                 :            :         {
     157                 :            :           n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
     158                 :            : 
     159                 :            :           sum += n;
     160                 :            :         }
     161                 :            :       while (sum < BLOCKSIZE && n != 0);
     162                 :            :       if (n == 0 && ferror (stream))
     163                 :            :         return 1;
     164                 :            : 
     165                 :            :       /* If end of file is reached, end the loop.  */
     166                 :            :       if (n == 0)
     167                 :            :         break;
     168                 :            : 
     169                 :            :       /* Process buffer with BLOCKSIZE bytes.  Note that
     170                 :            :                         BLOCKSIZE % 64 == 0
     171                 :            :        */
     172                 :            :       md5_process_block (buffer, BLOCKSIZE, &ctx);
     173                 :            :     }
     174                 :            : 
     175                 :            :   /* Add the last bytes if necessary.  */
     176                 :            :   if (sum > 0)
     177                 :            :     md5_process_bytes (buffer, sum, &ctx);
     178                 :            : 
     179                 :            :   /* Construct result in desired memory.  */
     180                 :            :   md5_finish_ctx (&ctx, resblock);
     181                 :            :   return 0;
     182                 :            : }
     183                 :            : #endif
     184                 :            : 
     185                 :            : 
     186                 :            : #ifdef NEED_MD5_BUFFER
     187                 :            : /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
     188                 :            :    result is always in little endian byte order, so that a byte-wise
     189                 :            :    output yields to the wanted ASCII representation of the message
     190                 :            :    digest.  */
     191                 :            : void *
     192                 :            : md5_buffer (buffer, len, resblock)
     193                 :            :      const char *buffer;
     194                 :            :      size_t len;
     195                 :            :      void *resblock;
     196                 :            : {
     197                 :            :   struct md5_ctx ctx;
     198                 :            : 
     199                 :            :   /* Initialize the computation context.  */
     200                 :            :   md5_init_ctx (&ctx);
     201                 :            : 
     202                 :            :   /* Process whole buffer but last len % 64 bytes.  */
     203                 :            :   md5_process_bytes (buffer, len, &ctx);
     204                 :            : 
     205                 :            :   /* Put result in desired memory area.  */
     206                 :            :   return md5_finish_ctx (&ctx, resblock);
     207                 :            : }
     208                 :            : #endif
     209                 :            : 
     210                 :            : 
     211                 :            : void
     212                 :       1003 : md5_process_bytes (buffer, len, ctx)
     213                 :            :      const void *buffer;
     214                 :            :      size_t len;
     215                 :            :      struct md5_ctx *ctx;
     216                 :            : {
     217                 :            :   /* When we already have some bits in our internal buffer concatenate
     218                 :            :      both inputs first.  */
     219         [ +  + ]:       1003 :   if (ctx->buflen != 0)
     220                 :            :     {
     221                 :        875 :       size_t left_over = ctx->buflen;
     222                 :        875 :       size_t add = 128 - left_over > len ? len : 128 - left_over;
     223                 :            : 
     224                 :        875 :       memcpy (&ctx->buffer[left_over], buffer, add);
     225                 :        875 :       ctx->buflen += add;
     226                 :            : 
     227         [ +  - ]:        875 :       if (ctx->buflen > 64)
     228                 :            :         {
     229                 :        875 :           md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
     230                 :            : 
     231                 :        875 :           ctx->buflen &= 63;
     232                 :            :           /* The regions in the following copy operation cannot overlap.  */
     233                 :        875 :           memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
     234                 :            :                   ctx->buflen);
     235                 :            :         }
     236                 :            : 
     237                 :        875 :       buffer = (const char *) buffer + add;
     238                 :        875 :       len -= add;
     239                 :            :     }
     240                 :            : 
     241                 :            :   /* Process available complete blocks.  */
     242         [ +  + ]:       1003 :   if (len >= 64)
     243                 :            :     {
     244                 :            : #if !_STRING_ARCH_unaligned
     245                 :            : /* To check alignment gcc has an appropriate operator.  Other
     246                 :            :    compilers don't.  */
     247                 :            : # if __GNUC__ >= 2
     248                 :            : #  define UNALIGNED_P(p) (((md5_uintptr) p) % __alignof__ (md5_uint32) != 0)
     249                 :            : # else
     250                 :            : #  define UNALIGNED_P(p) (((md5_uintptr) p) % sizeof (md5_uint32) != 0)
     251                 :            : # endif
     252                 :            :       if (UNALIGNED_P (buffer))
     253                 :            :         while (len > 64)
     254                 :            :           {
     255                 :            :             md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
     256                 :            :             buffer = (const char *) buffer + 64;
     257                 :            :             len -= 64;
     258                 :            :           }
     259                 :            :       else
     260                 :            : #endif
     261                 :            :         {
     262                 :       1000 :           md5_process_block (buffer, len & ~63, ctx);
     263                 :       1000 :           buffer = (const char *) buffer + (len & ~63);
     264                 :       1000 :           len &= 63;
     265                 :            :         }
     266                 :            :     }
     267                 :            : 
     268                 :            :   /* Move remaining bytes in internal buffer.  */
     269         [ +  + ]:       1003 :   if (len > 0)
     270                 :            :     {
     271                 :        878 :       size_t left_over = ctx->buflen;
     272                 :            : 
     273                 :        878 :       memcpy (&ctx->buffer[left_over], buffer, len);
     274                 :        878 :       left_over += len;
     275         [ -  + ]:        878 :       if (left_over >= 64)
     276                 :            :         {
     277                 :          0 :           md5_process_block (ctx->buffer, 64, ctx);
     278                 :          0 :           left_over -= 64;
     279                 :          0 :           memcpy (ctx->buffer, &ctx->buffer[64], left_over);
     280                 :            :         }
     281                 :        878 :       ctx->buflen = left_over;
     282                 :            :     }
     283                 :       1003 : }
     284                 :            : 
     285                 :            : 
     286                 :            : /* These are the four functions used in the four steps of the MD5 algorithm
     287                 :            :    and defined in the RFC 1321.  The first function is a little bit optimized
     288                 :            :    (as found in Colin Plumbs public domain implementation).  */
     289                 :            : /* #define FF(b, c, d) ((b & c) | (~b & d)) */
     290                 :            : #define FF(b, c, d) (d ^ (b & (c ^ d)))
     291                 :            : #define FG(b, c, d) FF (d, b, c)
     292                 :            : #define FH(b, c, d) (b ^ c ^ d)
     293                 :            : #define FI(b, c, d) (c ^ (b | ~d))
     294                 :            : 
     295                 :            : /* Process LEN bytes of BUFFER, accumulating context into CTX.
     296                 :            :    It is assumed that LEN % 64 == 0.  */
     297                 :            : 
     298                 :            : void
     299                 :       1879 : md5_process_block (buffer, len, ctx)
     300                 :            :      const void *buffer;
     301                 :            :      size_t len;
     302                 :            :      struct md5_ctx *ctx;
     303                 :            : {
     304                 :            :   md5_uint32 correct_words[16];
     305                 :       1879 :   const md5_uint32 *words = buffer;
     306                 :       1879 :   size_t nwords = len / sizeof (md5_uint32);
     307                 :       1879 :   const md5_uint32 *endp = words + nwords;
     308                 :       1879 :   md5_uint32 A = ctx->A;
     309                 :       1879 :   md5_uint32 B = ctx->B;
     310                 :       1879 :   md5_uint32 C = ctx->C;
     311                 :       1879 :   md5_uint32 D = ctx->D;
     312                 :            : 
     313                 :            :   /* First increment the byte count.  RFC 1321 specifies the possible
     314                 :            :      length of the file up to 2^64 bits.  Here we only compute the
     315                 :            :      number of bytes.  Do a double word increment.  */
     316                 :       1879 :   ctx->total[0] += len;
     317         [ -  + ]:       1879 :   if (ctx->total[0] < len)
     318                 :       1879 :     ++ctx->total[1];
     319                 :            : 
     320                 :            :   /* Process all bytes in the buffer with 64 bytes in each round of
     321                 :            :      the loop.  */
     322         [ +  + ]:      17509 :   while (words < endp)
     323                 :            :     {
     324                 :      15630 :       md5_uint32 *cwp = correct_words;
     325                 :      15630 :       md5_uint32 A_save = A;
     326                 :      15630 :       md5_uint32 B_save = B;
     327                 :      15630 :       md5_uint32 C_save = C;
     328                 :      15630 :       md5_uint32 D_save = D;
     329                 :            : 
     330                 :            :       /* First round: using the given function, the context and a constant
     331                 :            :          the next context is computed.  Because the algorithms processing
     332                 :            :          unit is a 32-bit word and it is determined to work on words in
     333                 :            :          little endian byte order we perhaps have to change the byte order
     334                 :            :          before the computation.  To reduce the work for the next steps
     335                 :            :          we store the swapped words in the array CORRECT_WORDS.  */
     336                 :            : 
     337                 :            : #define OP(a, b, c, d, s, T)                                            \
     338                 :            :       do                                                                \
     339                 :            :         {                                                               \
     340                 :            :           a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
     341                 :            :           ++words;                                                      \
     342                 :            :           CYCLIC (a, s);                                                \
     343                 :            :           a += b;                                                       \
     344                 :            :         }                                                               \
     345                 :            :       while (0)
     346                 :            : 
     347                 :            :       /* It is unfortunate that C does not provide an operator for
     348                 :            :          cyclic rotation.  Hope the C compiler is smart enough.  */
     349                 :            : #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
     350                 :            : 
     351                 :            :       /* Before we start, one word to the strange constants.
     352                 :            :          They are defined in RFC 1321 as
     353                 :            : 
     354                 :            :          T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
     355                 :            :        */
     356                 :            : 
     357                 :            :       /* Round 1.  */
     358                 :      15630 :       OP (A, B, C, D,  7, 0xd76aa478);
     359                 :      15630 :       OP (D, A, B, C, 12, 0xe8c7b756);
     360                 :      15630 :       OP (C, D, A, B, 17, 0x242070db);
     361                 :      15630 :       OP (B, C, D, A, 22, 0xc1bdceee);
     362                 :      15630 :       OP (A, B, C, D,  7, 0xf57c0faf);
     363                 :      15630 :       OP (D, A, B, C, 12, 0x4787c62a);
     364                 :      15630 :       OP (C, D, A, B, 17, 0xa8304613);
     365                 :      15630 :       OP (B, C, D, A, 22, 0xfd469501);
     366                 :      15630 :       OP (A, B, C, D,  7, 0x698098d8);
     367                 :      15630 :       OP (D, A, B, C, 12, 0x8b44f7af);
     368                 :      15630 :       OP (C, D, A, B, 17, 0xffff5bb1);
     369                 :      15630 :       OP (B, C, D, A, 22, 0x895cd7be);
     370                 :      15630 :       OP (A, B, C, D,  7, 0x6b901122);
     371                 :      15630 :       OP (D, A, B, C, 12, 0xfd987193);
     372                 :      15630 :       OP (C, D, A, B, 17, 0xa679438e);
     373                 :      15630 :       OP (B, C, D, A, 22, 0x49b40821);
     374                 :            : 
     375                 :            :       /* For the second to fourth round we have the possibly swapped words
     376                 :            :          in CORRECT_WORDS.  Redefine the macro to take an additional first
     377                 :            :          argument specifying the function to use.  */
     378                 :            : #undef OP
     379                 :            : #define OP(f, a, b, c, d, k, s, T)                                      \
     380                 :            :       do                                                                \
     381                 :            :         {                                                               \
     382                 :            :           a += f (b, c, d) + correct_words[k] + T;                      \
     383                 :            :           CYCLIC (a, s);                                                \
     384                 :            :           a += b;                                                       \
     385                 :            :         }                                                               \
     386                 :            :       while (0)
     387                 :            : 
     388                 :            :       /* Round 2.  */
     389                 :      15630 :       OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
     390                 :      15630 :       OP (FG, D, A, B, C,  6,  9, 0xc040b340);
     391                 :      15630 :       OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
     392                 :      15630 :       OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
     393                 :      15630 :       OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
     394                 :      15630 :       OP (FG, D, A, B, C, 10,  9, 0x02441453);
     395                 :      15630 :       OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
     396                 :      15630 :       OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
     397                 :      15630 :       OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
     398                 :      15630 :       OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
     399                 :      15630 :       OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
     400                 :      15630 :       OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
     401                 :      15630 :       OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
     402                 :      15630 :       OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
     403                 :      15630 :       OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
     404                 :      15630 :       OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
     405                 :            : 
     406                 :            :       /* Round 3.  */
     407                 :      15630 :       OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
     408                 :      15630 :       OP (FH, D, A, B, C,  8, 11, 0x8771f681);
     409                 :      15630 :       OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
     410                 :      15630 :       OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
     411                 :      15630 :       OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
     412                 :      15630 :       OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
     413                 :      15630 :       OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
     414                 :      15630 :       OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
     415                 :      15630 :       OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
     416                 :      15630 :       OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
     417                 :      15630 :       OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
     418                 :      15630 :       OP (FH, B, C, D, A,  6, 23, 0x04881d05);
     419                 :      15630 :       OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
     420                 :      15630 :       OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
     421                 :      15630 :       OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
     422                 :      15630 :       OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
     423                 :            : 
     424                 :            :       /* Round 4.  */
     425                 :      15630 :       OP (FI, A, B, C, D,  0,  6, 0xf4292244);
     426                 :      15630 :       OP (FI, D, A, B, C,  7, 10, 0x432aff97);
     427                 :      15630 :       OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
     428                 :      15630 :       OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
     429                 :      15630 :       OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
     430                 :      15630 :       OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
     431                 :      15630 :       OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
     432                 :      15630 :       OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
     433                 :      15630 :       OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
     434                 :      15630 :       OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
     435                 :      15630 :       OP (FI, C, D, A, B,  6, 15, 0xa3014314);
     436                 :      15630 :       OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
     437                 :      15630 :       OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
     438                 :      15630 :       OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
     439                 :      15630 :       OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
     440                 :      15630 :       OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
     441                 :            : 
     442                 :            :       /* Add the starting values of the context.  */
     443                 :      15630 :       A += A_save;
     444                 :      15630 :       B += B_save;
     445                 :      15630 :       C += C_save;
     446                 :      15630 :       D += D_save;
     447                 :            :     }
     448                 :            : 
     449                 :            :   /* Put checksum in context given as argument.  */
     450                 :       1879 :   ctx->A = A;
     451                 :       1879 :   ctx->B = B;
     452                 :       1879 :   ctx->C = C;
     453                 :       1879 :   ctx->D = D;
     454                 :       1879 : }

Generated by: LCOV version 1.9