"Fossies" - the Fresh Open Source Software Archive

Member "littleutils-1.0.43/littleutils/orig/md5.c" (11 Sep 2019, 15807 Bytes) of package /linux/privat/littleutils-1.0.43.tar.lz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "md5.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 1.0.40_vs_1.0.41.

    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-1997, 1999-2001, 2005-2006, 2008-2019 Free Software
    4    Foundation, Inc.
    5    This file is part of the GNU C Library.
    6 
    7    This program is free software; you can redistribute it and/or modify it
    8    under the terms of the GNU General Public License as published by the
    9    Free Software Foundation; either version 3, or (at your option) any
   10    later version.
   11 
   12    This program 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
   15    GNU General Public License for more details.
   16 
   17    You should have received a copy of the GNU General Public License
   18    along with this program; if not, see <https://www.gnu.org/licenses/>.  */
   19 
   20 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
   21 
   22 #include <config.h>
   23 
   24 #if HAVE_OPENSSL_MD5
   25 # define GL_OPENSSL_INLINE _GL_EXTERN_INLINE
   26 #endif
   27 #include "md5.h"
   28 
   29 #include <stdalign.h>
   30 #include <stdint.h>
   31 #include <stdlib.h>
   32 #include <string.h>
   33 #include <sys/types.h>
   34 
   35 #if USE_UNLOCKED_IO
   36 # include "unlocked-io.h"
   37 #endif
   38 
   39 #ifdef _LIBC
   40 # include <endian.h>
   41 # if __BYTE_ORDER == __BIG_ENDIAN
   42 #  define WORDS_BIGENDIAN 1
   43 # endif
   44 /* We need to keep the namespace clean so define the MD5 function
   45    protected using leading __ .  */
   46 # define md5_init_ctx __md5_init_ctx
   47 # define md5_process_block __md5_process_block
   48 # define md5_process_bytes __md5_process_bytes
   49 # define md5_finish_ctx __md5_finish_ctx
   50 # define md5_read_ctx __md5_read_ctx
   51 # define md5_stream __md5_stream
   52 # define md5_buffer __md5_buffer
   53 #endif
   54 
   55 #include <byteswap.h>
   56 #ifdef WORDS_BIGENDIAN
   57 # define SWAP(n) bswap_32 (n)
   58 #else
   59 # define SWAP(n) (n)
   60 #endif
   61 
   62 #define BLOCKSIZE 32768
   63 #if BLOCKSIZE % 64 != 0
   64 # error "invalid BLOCKSIZE"
   65 #endif
   66 
   67 #if ! HAVE_OPENSSL_MD5
   68 /* This array contains the bytes used to pad the buffer to the next
   69    64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
   70 static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
   71 
   72 
   73 /* Initialize structure containing state of computation.
   74    (RFC 1321, 3.3: Step 3)  */
   75 void
   76 md5_init_ctx (struct md5_ctx *ctx)
   77 {
   78   ctx->A = 0x67452301;
   79   ctx->B = 0xefcdab89;
   80   ctx->C = 0x98badcfe;
   81   ctx->D = 0x10325476;
   82 
   83   ctx->total[0] = ctx->total[1] = 0;
   84   ctx->buflen = 0;
   85 }
   86 
   87 /* Copy the 4 byte value from v into the memory location pointed to by *cp,
   88    If your architecture allows unaligned access this is equivalent to
   89    * (uint32_t *) cp = v  */
   90 static void
   91 set_uint32 (char *cp, uint32_t v)
   92 {
   93   memcpy (cp, &v, sizeof v);
   94 }
   95 
   96 /* Put result from CTX in first 16 bytes following RESBUF.  The result
   97    must be in little endian byte order.  */
   98 void *
   99 md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
  100 {
  101   char *r = resbuf;
  102   set_uint32 (r + 0 * sizeof ctx->A, SWAP (ctx->A));
  103   set_uint32 (r + 1 * sizeof ctx->B, SWAP (ctx->B));
  104   set_uint32 (r + 2 * sizeof ctx->C, SWAP (ctx->C));
  105   set_uint32 (r + 3 * sizeof ctx->D, SWAP (ctx->D));
  106 
  107   return resbuf;
  108 }
  109 
  110 /* Process the remaining bytes in the internal buffer and the usual
  111    prolog according to the standard and write the result to RESBUF.  */
  112 void *
  113 md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
  114 {
  115   /* Take yet unprocessed bytes into account.  */
  116   uint32_t bytes = ctx->buflen;
  117   size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
  118 
  119   /* Now count remaining bytes.  */
  120   ctx->total[0] += bytes;
  121   if (ctx->total[0] < bytes)
  122     ++ctx->total[1];
  123 
  124   /* Put the 64-bit file length in *bits* at the end of the buffer.  */
  125   ctx->buffer[size - 2] = SWAP (ctx->total[0] << 3);
  126   ctx->buffer[size - 1] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
  127 
  128   memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
  129 
  130   /* Process last bytes.  */
  131   md5_process_block (ctx->buffer, size * 4, ctx);
  132 
  133   return md5_read_ctx (ctx, resbuf);
  134 }
  135 #endif
  136 
  137 #if defined _LIBC || defined GL_COMPILE_CRYPTO_STREAM
  138 
  139 #include "af_alg.h"
  140 
  141 /* Compute MD5 message digest for bytes read from STREAM.  The
  142    resulting message digest number will be written into the 16 bytes
  143    beginning at RESBLOCK.  */
  144 int
  145 md5_stream (FILE *stream, void *resblock)
  146 {
  147   switch (afalg_stream (stream, "md5", resblock, MD5_DIGEST_SIZE))
  148     {
  149     case 0: return 0;
  150     case -EIO: return 1;
  151     }
  152 
  153   char *buffer = malloc (BLOCKSIZE + 72);
  154   if (!buffer)
  155     return 1;
  156 
  157   struct md5_ctx ctx;
  158   md5_init_ctx (&ctx);
  159   size_t sum;
  160 
  161   /* Iterate over full file contents.  */
  162   while (1)
  163     {
  164       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
  165          computation function processes the whole buffer so that with the
  166          next round of the loop another block can be read.  */
  167       size_t n;
  168       sum = 0;
  169 
  170       /* Read block.  Take care for partial reads.  */
  171       while (1)
  172         {
  173           /* Either process a partial fread() from this loop,
  174              or the fread() in afalg_stream may have gotten EOF.
  175              We need to avoid a subsequent fread() as EOF may
  176              not be sticky.  For details of such systems, see:
  177              https://sourceware.org/bugzilla/show_bug.cgi?id=1190  */
  178           if (feof (stream))
  179             goto process_partial_block;
  180 
  181           n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
  182 
  183           sum += n;
  184 
  185           if (sum == BLOCKSIZE)
  186             break;
  187 
  188           if (n == 0)
  189             {
  190               /* Check for the error flag IFF N == 0, so that we don't
  191                  exit the loop after a partial read due to e.g., EAGAIN
  192                  or EWOULDBLOCK.  */
  193               if (ferror (stream))
  194                 {
  195                   free (buffer);
  196                   return 1;
  197                 }
  198               goto process_partial_block;
  199             }
  200         }
  201 
  202       /* Process buffer with BLOCKSIZE bytes.  Note that
  203          BLOCKSIZE % 64 == 0
  204        */
  205       md5_process_block (buffer, BLOCKSIZE, &ctx);
  206     }
  207 
  208 process_partial_block:
  209 
  210   /* Process any remaining bytes.  */
  211   if (sum > 0)
  212     md5_process_bytes (buffer, sum, &ctx);
  213 
  214   /* Construct result in desired memory.  */
  215   md5_finish_ctx (&ctx, resblock);
  216   free (buffer);
  217   return 0;
  218 }
  219 #endif
  220 
  221 #if ! HAVE_OPENSSL_MD5
  222 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
  223    result is always in little endian byte order, so that a byte-wise
  224    output yields to the wanted ASCII representation of the message
  225    digest.  */
  226 void *
  227 md5_buffer (const char *buffer, size_t len, void *resblock)
  228 {
  229   struct md5_ctx ctx;
  230 
  231   /* Initialize the computation context.  */
  232   md5_init_ctx (&ctx);
  233 
  234   /* Process whole buffer but last len % 64 bytes.  */
  235   md5_process_bytes (buffer, len, &ctx);
  236 
  237   /* Put result in desired memory area.  */
  238   return md5_finish_ctx (&ctx, resblock);
  239 }
  240 
  241 
  242 void
  243 md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
  244 {
  245   /* When we already have some bits in our internal buffer concatenate
  246      both inputs first.  */
  247   if (ctx->buflen != 0)
  248     {
  249       size_t left_over = ctx->buflen;
  250       size_t add = 128 - left_over > len ? len : 128 - left_over;
  251 
  252       memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
  253       ctx->buflen += add;
  254 
  255       if (ctx->buflen > 64)
  256         {
  257           md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
  258 
  259           ctx->buflen &= 63;
  260           /* The regions in the following copy operation cannot overlap,
  261              because ctx->buflen < 64 ≤ (left_over + add) & ~63.  */
  262           memcpy (ctx->buffer,
  263                   &((char *) ctx->buffer)[(left_over + add) & ~63],
  264                   ctx->buflen);
  265         }
  266 
  267       buffer = (const char *) buffer + add;
  268       len -= add;
  269     }
  270 
  271   /* Process available complete blocks.  */
  272   if (len >= 64)
  273     {
  274 #if !(_STRING_ARCH_unaligned || _STRING_INLINE_unaligned)
  275 # define UNALIGNED_P(p) ((uintptr_t) (p) % alignof (uint32_t) != 0)
  276       if (UNALIGNED_P (buffer))
  277         while (len > 64)
  278           {
  279             md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
  280             buffer = (const char *) buffer + 64;
  281             len -= 64;
  282           }
  283       else
  284 #endif
  285         {
  286           md5_process_block (buffer, len & ~63, ctx);
  287           buffer = (const char *) buffer + (len & ~63);
  288           len &= 63;
  289         }
  290     }
  291 
  292   /* Move remaining bytes in internal buffer.  */
  293   if (len > 0)
  294     {
  295       size_t left_over = ctx->buflen;
  296 
  297       memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
  298       left_over += len;
  299       if (left_over >= 64)
  300         {
  301           md5_process_block (ctx->buffer, 64, ctx);
  302           left_over -= 64;
  303           /* The regions in the following copy operation cannot overlap,
  304              because left_over ≤ 64.  */
  305           memcpy (ctx->buffer, &ctx->buffer[16], left_over);
  306         }
  307       ctx->buflen = left_over;
  308     }
  309 }
  310 
  311 
  312 /* These are the four functions used in the four steps of the MD5 algorithm
  313    and defined in the RFC 1321.  The first function is a little bit optimized
  314    (as found in Colin Plumbs public domain implementation).  */
  315 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
  316 #define FF(b, c, d) (d ^ (b & (c ^ d)))
  317 #define FG(b, c, d) FF (d, b, c)
  318 #define FH(b, c, d) (b ^ c ^ d)
  319 #define FI(b, c, d) (c ^ (b | ~d))
  320 
  321 /* Process LEN bytes of BUFFER, accumulating context into CTX.
  322    It is assumed that LEN % 64 == 0.  */
  323 
  324 void
  325 md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
  326 {
  327   uint32_t correct_words[16];
  328   const uint32_t *words = buffer;
  329   size_t nwords = len / sizeof (uint32_t);
  330   const uint32_t *endp = words + nwords;
  331   uint32_t A = ctx->A;
  332   uint32_t B = ctx->B;
  333   uint32_t C = ctx->C;
  334   uint32_t D = ctx->D;
  335   uint32_t lolen = len;
  336 
  337   /* First increment the byte count.  RFC 1321 specifies the possible
  338      length of the file up to 2^64 bits.  Here we only compute the
  339      number of bytes.  Do a double word increment.  */
  340   ctx->total[0] += lolen;
  341   ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen);
  342 
  343   /* Process all bytes in the buffer with 64 bytes in each round of
  344      the loop.  */
  345   while (words < endp)
  346     {
  347       uint32_t *cwp = correct_words;
  348       uint32_t A_save = A;
  349       uint32_t B_save = B;
  350       uint32_t C_save = C;
  351       uint32_t D_save = D;
  352 
  353       /* First round: using the given function, the context and a constant
  354          the next context is computed.  Because the algorithms processing
  355          unit is a 32-bit word and it is determined to work on words in
  356          little endian byte order we perhaps have to change the byte order
  357          before the computation.  To reduce the work for the next steps
  358          we store the swapped words in the array CORRECT_WORDS.  */
  359 
  360 #define OP(a, b, c, d, s, T)                                            \
  361       do                                                                \
  362         {                                                               \
  363           a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
  364           ++words;                                                      \
  365           CYCLIC (a, s);                                                \
  366           a += b;                                                       \
  367         }                                                               \
  368       while (0)
  369 
  370       /* It is unfortunate that C does not provide an operator for
  371          cyclic rotation.  Hope the C compiler is smart enough.  */
  372 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
  373 
  374       /* Before we start, one word to the strange constants.
  375          They are defined in RFC 1321 as
  376 
  377          T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
  378 
  379          Here is an equivalent invocation using Perl:
  380 
  381          perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'
  382        */
  383 
  384       /* Round 1.  */
  385       OP (A, B, C, D, 7, 0xd76aa478);
  386       OP (D, A, B, C, 12, 0xe8c7b756);
  387       OP (C, D, A, B, 17, 0x242070db);
  388       OP (B, C, D, A, 22, 0xc1bdceee);
  389       OP (A, B, C, D, 7, 0xf57c0faf);
  390       OP (D, A, B, C, 12, 0x4787c62a);
  391       OP (C, D, A, B, 17, 0xa8304613);
  392       OP (B, C, D, A, 22, 0xfd469501);
  393       OP (A, B, C, D, 7, 0x698098d8);
  394       OP (D, A, B, C, 12, 0x8b44f7af);
  395       OP (C, D, A, B, 17, 0xffff5bb1);
  396       OP (B, C, D, A, 22, 0x895cd7be);
  397       OP (A, B, C, D, 7, 0x6b901122);
  398       OP (D, A, B, C, 12, 0xfd987193);
  399       OP (C, D, A, B, 17, 0xa679438e);
  400       OP (B, C, D, A, 22, 0x49b40821);
  401 
  402       /* For the second to fourth round we have the possibly swapped words
  403          in CORRECT_WORDS.  Redefine the macro to take an additional first
  404          argument specifying the function to use.  */
  405 #undef OP
  406 #define OP(f, a, b, c, d, k, s, T)                                      \
  407       do                                                                \
  408         {                                                               \
  409           a += f (b, c, d) + correct_words[k] + T;                      \
  410           CYCLIC (a, s);                                                \
  411           a += b;                                                       \
  412         }                                                               \
  413       while (0)
  414 
  415       /* Round 2.  */
  416       OP (FG, A, B, C, D, 1, 5, 0xf61e2562);
  417       OP (FG, D, A, B, C, 6, 9, 0xc040b340);
  418       OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
  419       OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
  420       OP (FG, A, B, C, D, 5, 5, 0xd62f105d);
  421       OP (FG, D, A, B, C, 10, 9, 0x02441453);
  422       OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
  423       OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
  424       OP (FG, A, B, C, D, 9, 5, 0x21e1cde6);
  425       OP (FG, D, A, B, C, 14, 9, 0xc33707d6);
  426       OP (FG, C, D, A, B, 3, 14, 0xf4d50d87);
  427       OP (FG, B, C, D, A, 8, 20, 0x455a14ed);
  428       OP (FG, A, B, C, D, 13, 5, 0xa9e3e905);
  429       OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8);
  430       OP (FG, C, D, A, B, 7, 14, 0x676f02d9);
  431       OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
  432 
  433       /* Round 3.  */
  434       OP (FH, A, B, C, D, 5, 4, 0xfffa3942);
  435       OP (FH, D, A, B, C, 8, 11, 0x8771f681);
  436       OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
  437       OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
  438       OP (FH, A, B, C, D, 1, 4, 0xa4beea44);
  439       OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9);
  440       OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60);
  441       OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
  442       OP (FH, A, B, C, D, 13, 4, 0x289b7ec6);
  443       OP (FH, D, A, B, C, 0, 11, 0xeaa127fa);
  444       OP (FH, C, D, A, B, 3, 16, 0xd4ef3085);
  445       OP (FH, B, C, D, A, 6, 23, 0x04881d05);
  446       OP (FH, A, B, C, D, 9, 4, 0xd9d4d039);
  447       OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
  448       OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
  449       OP (FH, B, C, D, A, 2, 23, 0xc4ac5665);
  450 
  451       /* Round 4.  */
  452       OP (FI, A, B, C, D, 0, 6, 0xf4292244);
  453       OP (FI, D, A, B, C, 7, 10, 0x432aff97);
  454       OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
  455       OP (FI, B, C, D, A, 5, 21, 0xfc93a039);
  456       OP (FI, A, B, C, D, 12, 6, 0x655b59c3);
  457       OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92);
  458       OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
  459       OP (FI, B, C, D, A, 1, 21, 0x85845dd1);
  460       OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f);
  461       OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
  462       OP (FI, C, D, A, B, 6, 15, 0xa3014314);
  463       OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
  464       OP (FI, A, B, C, D, 4, 6, 0xf7537e82);
  465       OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
  466       OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
  467       OP (FI, B, C, D, A, 9, 21, 0xeb86d391);
  468 
  469       /* Add the starting values of the context.  */
  470       A += A_save;
  471       B += B_save;
  472       C += C_save;
  473       D += D_save;
  474     }
  475 
  476   /* Put checksum in context given as argument.  */
  477   ctx->A = A;
  478   ctx->B = B;
  479   ctx->C = C;
  480   ctx->D = D;
  481 }
  482 #endif
  483 
  484 /*
  485  * Hey Emacs!
  486  * Local Variables:
  487  * coding: utf-8
  488  * End:
  489  */