PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/standard - md5.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 187 191 97.9 %
Date: 2014-10-30 Functions: 8 8 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Author: Alexander Peslyak (Solar Designer) <solar at openwall.com>   |
      16             :    |         Lachlan Roche                                                |
      17             :    |         Alessandro Astarita <aleast@capri.it>                        |
      18             :    +----------------------------------------------------------------------+
      19             : */
      20             : 
      21             : /* $Id$ */
      22             : 
      23             : #include "php.h"
      24             : #include "md5.h"
      25             : 
      26           7 : PHPAPI void make_digest(char *md5str, const unsigned char *digest) /* {{{ */
      27             : {
      28           7 :         make_digest_ex(md5str, digest, 16);
      29           7 : }
      30             : /* }}} */
      31             : 
      32      300583 : PHPAPI void make_digest_ex(char *md5str, const unsigned char *digest, int len) /* {{{ */
      33             : {
      34             :         static const char hexits[17] = "0123456789abcdef";
      35             :         int i;
      36             : 
      37     5110163 :         for (i = 0; i < len; i++) {
      38     4809580 :                 md5str[i * 2]       = hexits[digest[i] >> 4];
      39     4809580 :                 md5str[(i * 2) + 1] = hexits[digest[i] &  0x0F];
      40             :         }
      41      300583 :         md5str[len * 2] = '\0';
      42      300583 : }
      43             : /* }}} */
      44             : 
      45             : /* {{{ proto string md5(string str, [ bool raw_output])
      46             :    Calculate the md5 hash of a string */
      47      300494 : PHP_NAMED_FUNCTION(php_if_md5)
      48             : {
      49             :         zend_string *arg;
      50      300494 :         zend_bool raw_output = 0;
      51             :         char md5str[33];
      52             :         PHP_MD5_CTX context;
      53             :         unsigned char digest[16];
      54             :         
      55      300494 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|b", &arg, &raw_output) == FAILURE) {
      56           2 :                 return;
      57             :         }
      58             :         
      59      300492 :         md5str[0] = '\0';
      60      300492 :         PHP_MD5Init(&context);
      61      300492 :         PHP_MD5Update(&context, arg->val, arg->len);
      62      300492 :         PHP_MD5Final(digest, &context);
      63      300492 :         if (raw_output) {
      64          22 :                 RETURN_STRINGL((char *) digest, 16);
      65             :         } else {
      66      300481 :                 make_digest_ex(md5str, digest, 16);
      67      600962 :                 RETVAL_STRING(md5str);
      68             :         }
      69             : 
      70             : }
      71             : /* }}} */
      72             : 
      73             : /* {{{ proto string md5_file(string filename [, bool raw_output])
      74             :    Calculate the md5 hash of given filename */
      75          38 : PHP_NAMED_FUNCTION(php_if_md5_file)
      76             : {
      77             :         char          *arg;
      78             :         size_t           arg_len;
      79          38 :         zend_bool raw_output = 0;
      80             :         char          md5str[33];
      81             :         unsigned char buf[1024];
      82             :         unsigned char digest[16];
      83             :         PHP_MD5_CTX   context;
      84             :         size_t           n;
      85             :         php_stream    *stream;
      86             : 
      87          38 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|b", &arg, &arg_len, &raw_output) == FAILURE) {
      88           2 :                 return;
      89             :         }
      90             :         
      91          36 :         stream = php_stream_open_wrapper(arg, "rb", REPORT_ERRORS, NULL);
      92          36 :         if (!stream) {
      93           4 :                 RETURN_FALSE;
      94             :         }
      95             : 
      96          32 :         PHP_MD5Init(&context);
      97             : 
      98       84595 :         while ((n = php_stream_read(stream, (char*)buf, sizeof(buf))) > 0) {
      99       84531 :                 PHP_MD5Update(&context, buf, n);
     100             :         }
     101             : 
     102             :         /* XXX this probably can be improved with some number of retries */
     103          32 :         if (!php_stream_eof(stream)) {
     104           0 :                 php_stream_close(stream);
     105           0 :                 PHP_MD5Final(digest, &context);
     106             : 
     107           0 :                 RETURN_FALSE;
     108             :         }
     109             : 
     110          32 :         php_stream_close(stream);
     111             : 
     112          32 :         PHP_MD5Final(digest, &context);
     113             : 
     114          32 :         if (raw_output) {
     115           4 :                 RETURN_STRINGL((char *) digest, 16);
     116             :         } else {
     117          30 :                 make_digest_ex(md5str, digest, 16);
     118          60 :                 RETVAL_STRING(md5str);
     119             :         }
     120             : }
     121             : /* }}} */
     122             : 
     123             : /*
     124             :  * This is an OpenSSL-compatible implementation of the RSA Data Security,
     125             :  * Inc. MD5 Message-Digest Algorithm (RFC 1321).
     126             :  *
     127             :  * Written by Solar Designer <solar at openwall.com> in 2001, and placed
     128             :  * in the public domain.  There's absolutely no warranty.
     129             :  *
     130             :  * This differs from Colin Plumb's older public domain implementation in
     131             :  * that no 32-bit integer data type is required, there's no compile-time
     132             :  * endianness configuration, and the function prototypes match OpenSSL's.
     133             :  * The primary goals are portability and ease of use.
     134             :  *
     135             :  * This implementation is meant to be fast, but not as fast as possible.
     136             :  * Some known optimizations are not included to reduce source code size
     137             :  * and avoid compile-time configuration.
     138             :  */
     139             : 
     140             : #include <string.h>
     141             : 
     142             : /*
     143             :  * The basic MD5 functions.
     144             :  *
     145             :  * F and G are optimized compared to their RFC 1321 definitions for
     146             :  * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
     147             :  * implementation.
     148             :  */
     149             : #define F(x, y, z)                      ((z) ^ ((x) & ((y) ^ (z))))
     150             : #define G(x, y, z)                      ((y) ^ ((z) & ((x) ^ (y))))
     151             : #define H(x, y, z)                      ((x) ^ (y) ^ (z))
     152             : #define I(x, y, z)                      ((y) ^ ((x) | ~(z)))
     153             : 
     154             : /*
     155             :  * The MD5 transformation for all four rounds.
     156             :  */
     157             : #define STEP(f, a, b, c, d, x, t, s) \
     158             :         (a) += f((b), (c), (d)) + (x) + (t); \
     159             :         (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
     160             :         (a) += (b);
     161             : 
     162             : /*
     163             :  * SET reads 4 input bytes in little-endian byte order and stores them
     164             :  * in a properly aligned word in host byte order.
     165             :  *
     166             :  * The check for little-endian architectures that tolerate unaligned
     167             :  * memory accesses is just an optimization.  Nothing will break if it
     168             :  * doesn't work.
     169             :  */
     170             : #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
     171             : # define SET(n) \
     172             :         (*(php_uint32 *)&ptr[(n) * 4])
     173             : # define GET(n) \
     174             :         SET(n)
     175             : #else
     176             : # define SET(n) \
     177             :         (ctx->block[(n)] = \
     178             :         (php_uint32)ptr[(n) * 4] | \
     179             :         ((php_uint32)ptr[(n) * 4 + 1] << 8) | \
     180             :         ((php_uint32)ptr[(n) * 4 + 2] << 16) | \
     181             :         ((php_uint32)ptr[(n) * 4 + 3] << 24))
     182             : # define GET(n) \
     183             :         (ctx->block[(n)])
     184             : #endif
     185             : 
     186             : /*
     187             :  * This processes one or more 64-byte data blocks, but does NOT update
     188             :  * the bit counters.  There are no alignment requirements.
     189             :  */
     190      397503 : static const void *body(PHP_MD5_CTX *ctx, const void *data, size_t size)
     191             : {
     192             :         const unsigned char *ptr;
     193             :         php_uint32 a, b, c, d;
     194             :         php_uint32 saved_a, saved_b, saved_c, saved_d;
     195             : 
     196      397503 :         ptr = data;
     197             : 
     198      397503 :         a = ctx->a;
     199      397503 :         b = ctx->b;
     200      397503 :         c = ctx->c;
     201      397503 :         d = ctx->d;
     202             : 
     203             :         do {
     204     1687521 :                 saved_a = a;
     205     1687521 :                 saved_b = b;
     206     1687521 :                 saved_c = c;
     207     1687521 :                 saved_d = d;
     208             : 
     209             : /* Round 1 */
     210     1687521 :                 STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
     211     1687521 :                 STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
     212     1687521 :                 STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
     213     1687521 :                 STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
     214     1687521 :                 STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
     215     1687521 :                 STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
     216     1687521 :                 STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
     217     1687521 :                 STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
     218     1687521 :                 STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
     219     1687521 :                 STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
     220     1687521 :                 STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
     221     1687521 :                 STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
     222     1687521 :                 STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
     223     1687521 :                 STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
     224     1687521 :                 STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
     225     1687521 :                 STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
     226             : 
     227             : /* Round 2 */
     228     1687521 :                 STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
     229     1687521 :                 STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
     230     1687521 :                 STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
     231     1687521 :                 STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
     232     1687521 :                 STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
     233     1687521 :                 STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
     234     1687521 :                 STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
     235     1687521 :                 STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
     236     1687521 :                 STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
     237     1687521 :                 STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
     238     1687521 :                 STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
     239     1687521 :                 STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
     240     1687521 :                 STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
     241     1687521 :                 STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
     242     1687521 :                 STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
     243     1687521 :                 STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
     244             : 
     245             : /* Round 3 */
     246     1687521 :                 STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
     247     1687521 :                 STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
     248     1687521 :                 STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
     249     1687521 :                 STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
     250     1687521 :                 STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
     251     1687521 :                 STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
     252     1687521 :                 STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
     253     1687521 :                 STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
     254     1687521 :                 STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
     255     1687521 :                 STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
     256     1687521 :                 STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
     257     1687521 :                 STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
     258     1687521 :                 STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
     259     1687521 :                 STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
     260     1687521 :                 STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
     261     1687521 :                 STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)
     262             : 
     263             : /* Round 4 */
     264     1687521 :                 STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
     265     1687521 :                 STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
     266     1687521 :                 STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
     267     1687521 :                 STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
     268     1687521 :                 STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
     269     1687521 :                 STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
     270     1687521 :                 STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
     271     1687521 :                 STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
     272     1687521 :                 STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
     273     1687521 :                 STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
     274     1687521 :                 STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
     275     1687521 :                 STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
     276     1687521 :                 STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
     277     1687521 :                 STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
     278     1687521 :                 STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
     279     1687521 :                 STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
     280             : 
     281     1687521 :                 a += saved_a;
     282     1687521 :                 b += saved_b;
     283     1687521 :                 c += saved_c;
     284     1687521 :                 d += saved_d;
     285             : 
     286     1687521 :                 ptr += 64;
     287     1687521 :         } while (size -= 64);
     288             : 
     289      397503 :         ctx->a = a;
     290      397503 :         ctx->b = b;
     291      397503 :         ctx->c = c;
     292      397503 :         ctx->d = d;
     293             : 
     294      397503 :         return ptr;
     295             : }
     296             : 
     297      311288 : PHPAPI void PHP_MD5Init(PHP_MD5_CTX *ctx)
     298             : {
     299      311288 :         ctx->a = 0x67452301;
     300      311288 :         ctx->b = 0xefcdab89;
     301      311288 :         ctx->c = 0x98badcfe;
     302      311288 :         ctx->d = 0x10325476;
     303             : 
     304      311288 :         ctx->lo = 0;
     305      311288 :         ctx->hi = 0;
     306      311288 : }
     307             : 
     308      421725 : PHPAPI void PHP_MD5Update(PHP_MD5_CTX *ctx, const void *data, size_t size)
     309             : {
     310             :         php_uint32 saved_lo;
     311             :         php_uint32 used, free;
     312             : 
     313      421725 :         saved_lo = ctx->lo;
     314      421725 :         if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) {
     315           0 :                 ctx->hi++;
     316             :         }
     317      421725 :         ctx->hi += size >> 29;
     318             : 
     319      421725 :         used = saved_lo & 0x3f;
     320             : 
     321      421725 :         if (used) {
     322       25276 :                 free = 64 - used;
     323             : 
     324       25276 :                 if (size < free) {
     325       24358 :                         memcpy(&ctx->buffer[used], data, size);
     326       24358 :                         return;
     327             :                 }
     328             : 
     329         918 :                 memcpy(&ctx->buffer[used], data, free);
     330         918 :                 data = (unsigned char *)data + free;
     331         918 :                 size -= free;
     332         918 :                 body(ctx, ctx->buffer, 64);
     333             :         }
     334             : 
     335      397367 :         if (size >= 64) {
     336       84994 :                 data = body(ctx, data, size & ~(size_t)0x3f);
     337       84994 :                 size &= 0x3f;
     338             :         }
     339             : 
     340      397367 :         memcpy(ctx->buffer, data, size);
     341             : }
     342             : 
     343      311287 : PHPAPI void PHP_MD5Final(unsigned char *result, PHP_MD5_CTX *ctx)
     344             : {
     345             :         php_uint32 used, free;
     346             : 
     347      311287 :         used = ctx->lo & 0x3f;
     348             : 
     349      311287 :         ctx->buffer[used++] = 0x80;
     350             : 
     351      311287 :         free = 64 - used;
     352             : 
     353      311287 :         if (free < 8) {
     354         304 :                 memset(&ctx->buffer[used], 0, free);
     355         304 :                 body(ctx, ctx->buffer, 64);
     356         304 :                 used = 0;
     357         304 :                 free = 64;
     358             :         }
     359             : 
     360      311287 :         memset(&ctx->buffer[used], 0, free - 8);
     361             : 
     362      311287 :         ctx->lo <<= 3;
     363      311287 :         ctx->buffer[56] = ctx->lo;
     364      311287 :         ctx->buffer[57] = ctx->lo >> 8;
     365      311287 :         ctx->buffer[58] = ctx->lo >> 16;
     366      311287 :         ctx->buffer[59] = ctx->lo >> 24;
     367      311287 :         ctx->buffer[60] = ctx->hi;
     368      311287 :         ctx->buffer[61] = ctx->hi >> 8;
     369      311287 :         ctx->buffer[62] = ctx->hi >> 16;
     370      311287 :         ctx->buffer[63] = ctx->hi >> 24;
     371             : 
     372      311287 :         body(ctx, ctx->buffer, 64);
     373             : 
     374      311287 :         result[0] = ctx->a;
     375      311287 :         result[1] = ctx->a >> 8;
     376      311287 :         result[2] = ctx->a >> 16;
     377      311287 :         result[3] = ctx->a >> 24;
     378      311287 :         result[4] = ctx->b;
     379      311287 :         result[5] = ctx->b >> 8;
     380      311287 :         result[6] = ctx->b >> 16;
     381      311287 :         result[7] = ctx->b >> 24;
     382      311287 :         result[8] = ctx->c;
     383      311287 :         result[9] = ctx->c >> 8;
     384      311287 :         result[10] = ctx->c >> 16;
     385      311287 :         result[11] = ctx->c >> 24;
     386      311287 :         result[12] = ctx->d;
     387      311287 :         result[13] = ctx->d >> 8;
     388      311287 :         result[14] = ctx->d >> 16;
     389      311287 :         result[15] = ctx->d >> 24;
     390             : 
     391      311287 :         ZEND_SECURE_ZERO(ctx, sizeof(*ctx));
     392      311287 : }

Generated by: LCOV version 1.10

Generated at Thu, 30 Oct 2014 07:41:41 +0000 (30 hours ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.