ext/Digest/MD5/MD5.xs

   1 /*
   2  * This library is free software; you can redistribute it and/or
   3  * modify it under the same terms as Perl itself.
   4  *
   5  *  Copyright 1998-2000 Gisle Aas.
   6  *  Copyright 1995-1996 Neil Winton.
   7  *  Copyright 1991-1992 RSA Data Security, Inc.
   8  *
   9  * This code is derived from Neil Winton's MD5-1.7 Perl module, which in
  10  * turn is derived from the reference implementation in RFC 1231 which
  11  * comes with this message:
  12  *
  13  * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
  14  * rights reserved.
  15  *
  16  * License to copy and use this software is granted provided that it
  17  * is identified as the "RSA Data Security, Inc. MD5 Message-Digest
  18  * Algorithm" in all material mentioning or referencing this software
  19  * or this function.
  20  *
  21  * License is also granted to make and use derivative works provided
  22  * that such works are identified as "derived from the RSA Data
  23  * Security, Inc. MD5 Message-Digest Algorithm" in all material
  24  * mentioning or referencing the derived work.
  25  *
  26  * RSA Data Security, Inc. makes no representations concerning either
  27  * the merchantability of this software or the suitability of this
  28  * software for any particular purpose. It is provided "as is"
  29  * without express or implied warranty of any kind.
  30  *
  31  * These notices must be retained in any copies of any part of this
  32  * documentation and/or software.
  33  */
  34
  35 #ifdef __cplusplus
  36 extern "C" {
  37 #endif
  38 #include "EXTERN.h"
  39 #include "perl.h"
  40 #include "XSUB.h"
  41 #ifdef __cplusplus
  42 }
  43 #endif
  44
  45 #ifndef SvPVbyte
  46    #define SvPVbyte SvPV
  47 #endif
  48
  49 /* Perl does not guarantee that U32 is exactly 32 bits.  Some system
  50  * has no integral type with exactly 32 bits.  For instance, A Cray has
  51  * short, int and long all at 64 bits so we need to apply this macro
  52  * to reduce U32 values to 32 bits at appropriate places. If U32
  53  * really does have 32 bits then this is a no-op.
  54  */
  55 #if BYTEORDER > 0x4321 || defined(TRUNCATE_U32)
  56   #define TO32(x)    ((x) &  0xFFFFffff)
  57   #define TRUNC32(x) ((x) &= 0xFFFFffff)
  58 #else
  59   #define TO32(x)    (x)
  60   #define TRUNC32(x) /*nothing*/
  61 #endif
  62
  63 /* The MD5 algorithm is defined in terms of little endian 32-bit
  64  * values.  The following macros (and functions) allow us to convert
  65  * between native integers and such values.
  66  */
  67 #undef BYTESWAP
  68 #ifndef U32_ALIGNMENT_REQUIRED
  69  #if BYTEORDER == 0x1234      /* 32-bit little endian */
  70   #define BYTESWAP(x) (x)     /* no-op */
  71
  72  #elif BYTEORDER == 0x4321    /* 32-bit big endian */
  73   #define BYTESWAP(x)   ((((x)&0xFF)<<24)       \
  74                         |(((x)>>24)&0xFF)       \
  75                         |(((x)&0x0000FF00)<<8)  \
  76                         |(((x)&0x00FF0000)>>8)  )
  77  #endif
  78 #endif
  79
  80 #ifndef BYTESWAP
  81 static void u2s(U32 u, U8* s)
  82 {
  83     *s++ = u         & 0xFF;
  84     *s++ = (u >>  8) & 0xFF;
  85     *s++ = (u >> 16) & 0xFF;
  86     *s   = (u >> 24) & 0xFF;
  87 }
  88
  89 #define s2u(s,u) ((u) =  (U32)(*s)            |  \
  90                         ((U32)(*(s+1)) << 8)  |  \
  91                         ((U32)(*(s+2)) << 16) |  \
  92                         ((U32)(*(s+3)) << 24))
  93 #endif
  94
  95 #define MD5_CTX_SIGNATURE 200003165
  96
  97 /* This stucture keeps the current state of algorithm.
  98  */
  99 typedef struct {
 100   U32 signature;   /* safer cast in get_md5_ctx() */
 101   U32 A, B, C, D;  /* current digest */
 102   U32 bytes_low;   /* counts bytes in message */
 103   U32 bytes_high;  /* turn it into a 64-bit counter */
 104   U8 buffer[128];  /* collect complete 64 byte blocks */
 105 } MD5_CTX;
 106
 107
 108 /* Padding is added at the end of the message in order to fill a
 109  * complete 64 byte block (- 8 bytes for the message length).  The
 110  * padding is also the reason the buffer in MD5_CTX have to be
 111  * 128 bytes.
 112  */
 113 static unsigned char PADDING[64] = {
 114   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 115   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 116   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 117 };
 118
 119 /* Constants for MD5Transform routine.
 120  */
 121 #define S11 7
 122 #define S12 12
 123 #define S13 17
 124 #define S14 22
 125 #define S21 5
 126 #define S22 9
 127 #define S23 14
 128 #define S24 20
 129 #define S31 4
 130 #define S32 11
 131 #define S33 16
 132 #define S34 23
 133 #define S41 6
 134 #define S42 10
 135 #define S43 15
 136 #define S44 21
 137
 138 /* F, G, H and I are basic MD5 functions.
 139  */
 140 #define F(x, y, z) ((((x) & ((y) ^ (z))) ^ (z)))
 141 #define G(x, y, z) F(z, x, y)
 142 #define H(x, y, z) ((x) ^ (y) ^ (z))
 143 #define I(x, y, z) ((y) ^ ((x) | (~z)))
 144
 145 /* ROTATE_LEFT rotates x left n bits.
 146  */
 147 #define ROTATE_LEFT(x, n) (((x) << (n) | ((x) >> (32-(n)))))
 148
 149 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
 150  * Rotation is separate from addition to prevent recomputation.
 151  */
 152 #define FF(a, b, c, d, s, ac)                    \
 153  (a) += F ((b), (c), (d)) + (NEXTx) + (U32)(ac); \
 154  TRUNC32((a));                                   \
 155  (a) = ROTATE_LEFT ((a), (s));                   \
 156  (a) += (b);                                     \
 157  TRUNC32((a));
 158
 159 #define GG(a, b, c, d, x, s, ac)                 \
 160  (a) += G ((b), (c), (d)) + X[x] + (U32)(ac);    \
 161  TRUNC32((a));                                   \
 162  (a) = ROTATE_LEFT ((a), (s));                   \
 163  (a) += (b);                                     \
 164  TRUNC32((a));
 165
 166 #define HH(a, b, c, d, x, s, ac)                 \
 167  (a) += H ((b), (c), (d)) + X[x] + (U32)(ac);    \
 168  TRUNC32((a));                                   \
 169  (a) = ROTATE_LEFT ((a), (s));                   \
 170  (a) += (b);                                     \
 171  TRUNC32((a));
 172
 173 #define II(a, b, c, d, x, s, ac)                 \
 174  (a) += I ((b), (c), (d)) + X[x] + (U32)(ac);    \
 175  TRUNC32((a));                                   \
 176  (a) = ROTATE_LEFT ((a), (s));                   \
 177  (a) += (b);                                     \
 178  TRUNC32((a));
 179
 180
 181 static void
 182 MD5Init(MD5_CTX *ctx)
 183 {
 184   /* Start state */
 185   ctx->A = 0x67452301;
 186   ctx->B = 0xefcdab89;
 187   ctx->C = 0x98badcfe;
 188   ctx->D = 0x10325476;
 189
 190   /* message length */
 191   ctx->bytes_low = ctx->bytes_high = 0;
 192 }
 193
 194
 195 static void
 196 MD5Transform(MD5_CTX* ctx, const U8* buf, STRLEN blocks)
 197 {
 198 #ifdef MD5_DEBUG
 199     static int tcount = 0;
 200 #endif
 201
 202     U32 A = ctx->A;
 203     U32 B = ctx->B;
 204     U32 C = ctx->C;
 205     U32 D = ctx->D;
 206
 207 #ifndef U32_ALIGNMENT_REQUIRED
 208     const U32 *x = (U32*)buf;  /* really just type casting */
 209 #endif
 210
 211     do {
 212         U32 a = A;
 213         U32 b = B;
 214         U32 c = C;
 215         U32 d = D;
 216
 217 #if BYTEORDER == 0x1234 && !defined(U32_ALIGNMENT_REQUIRED)
 218         const U32 *X = x;
 219         #define NEXTx  (*x++)
 220 #else
 221         U32 X[16];      /* converted values, used in round 2-4 */
 222         U32 *uptr = X;
 223         U32 tmp;
 224  #ifdef BYTESWAP
 225         #define NEXTx  (tmp=*x++, *uptr++ = BYTESWAP(tmp))
 226  #else
 227         #define NEXTx  (s2u(buf,tmp), buf += 4, *uptr++ = tmp)
 228  #endif
 229 #endif
 230
 231 #ifdef MD5_DEBUG
 232         if (buf == ctx->buffer)
 233             fprintf(stderr,"%5d: Transform ctx->buffer", ++tcount);
 234         else
 235             fprintf(stderr,"%5d: Transform %p (%d)", ++tcount, buf, blocks);
 236
 237         {
 238             int i;
 239             fprintf(stderr,"[");
 240             for (i = 0; i < 16; i++) {
 241                 fprintf(stderr,"%x,", x[i]);
 242             }
 243             fprintf(stderr,"]\n");
 244         }
 245 #endif
 246
 247         /* Round 1 */
 248         FF (a, b, c, d, S11, 0xd76aa478); /* 1 */
 249         FF (d, a, b, c, S12, 0xe8c7b756); /* 2 */
 250         FF (c, d, a, b, S13, 0x242070db); /* 3 */
 251         FF (b, c, d, a, S14, 0xc1bdceee); /* 4 */
 252         FF (a, b, c, d, S11, 0xf57c0faf); /* 5 */
 253         FF (d, a, b, c, S12, 0x4787c62a); /* 6 */
 254         FF (c, d, a, b, S13, 0xa8304613); /* 7 */
 255         FF (b, c, d, a, S14, 0xfd469501); /* 8 */
 256         FF (a, b, c, d, S11, 0x698098d8); /* 9 */
 257         FF (d, a, b, c, S12, 0x8b44f7af); /* 10 */
 258         FF (c, d, a, b, S13, 0xffff5bb1); /* 11 */
 259         FF (b, c, d, a, S14, 0x895cd7be); /* 12 */
 260         FF (a, b, c, d, S11, 0x6b901122); /* 13 */
 261         FF (d, a, b, c, S12, 0xfd987193); /* 14 */
 262         FF (c, d, a, b, S13, 0xa679438e); /* 15 */
 263         FF (b, c, d, a, S14, 0x49b40821); /* 16 */
 264
 265         /* Round 2 */
 266         GG (a, b, c, d,  1, S21, 0xf61e2562); /* 17 */
 267         GG (d, a, b, c,  6, S22, 0xc040b340); /* 18 */
 268         GG (c, d, a, b, 11, S23, 0x265e5a51); /* 19 */
 269         GG (b, c, d, a,  0, S24, 0xe9b6c7aa); /* 20 */
 270         GG (a, b, c, d,  5, S21, 0xd62f105d); /* 21 */
 271         GG (d, a, b, c, 10, S22,  0x2441453); /* 22 */
 272         GG (c, d, a, b, 15, S23, 0xd8a1e681); /* 23 */
 273         GG (b, c, d, a,  4, S24, 0xe7d3fbc8); /* 24 */
 274         GG (a, b, c, d,  9, S21, 0x21e1cde6); /* 25 */
 275         GG (d, a, b, c, 14, S22, 0xc33707d6); /* 26 */
 276         GG (c, d, a, b,  3, S23, 0xf4d50d87); /* 27 */
 277         GG (b, c, d, a,  8, S24, 0x455a14ed); /* 28 */
 278         GG (a, b, c, d, 13, S21, 0xa9e3e905); /* 29 */
 279         GG (d, a, b, c,  2, S22, 0xfcefa3f8); /* 30 */
 280         GG (c, d, a, b,  7, S23, 0x676f02d9); /* 31 */
 281         GG (b, c, d, a, 12, S24, 0x8d2a4c8a); /* 32 */
 282
 283         /* Round 3 */
 284         HH (a, b, c, d,  5, S31, 0xfffa3942); /* 33 */
 285         HH (d, a, b, c,  8, S32, 0x8771f681); /* 34 */
 286         HH (c, d, a, b, 11, S33, 0x6d9d6122); /* 35 */
 287         HH (b, c, d, a, 14, S34, 0xfde5380c); /* 36 */
 288         HH (a, b, c, d,  1, S31, 0xa4beea44); /* 37 */
 289         HH (d, a, b, c,  4, S32, 0x4bdecfa9); /* 38 */
 290         HH (c, d, a, b,  7, S33, 0xf6bb4b60); /* 39 */
 291         HH (b, c, d, a, 10, S34, 0xbebfbc70); /* 40 */
 292         HH (a, b, c, d, 13, S31, 0x289b7ec6); /* 41 */
 293         HH (d, a, b, c,  0, S32, 0xeaa127fa); /* 42 */
 294         HH (c, d, a, b,  3, S33, 0xd4ef3085); /* 43 */
 295         HH (b, c, d, a,  6, S34,  0x4881d05); /* 44 */
 296         HH (a, b, c, d,  9, S31, 0xd9d4d039); /* 45 */
 297         HH (d, a, b, c, 12, S32, 0xe6db99e5); /* 46 */
 298         HH (c, d, a, b, 15, S33, 0x1fa27cf8); /* 47 */
 299         HH (b, c, d, a,  2, S34, 0xc4ac5665); /* 48 */
 300
 301         /* Round 4 */
 302         II (a, b, c, d,  0, S41, 0xf4292244); /* 49 */
 303         II (d, a, b, c,  7, S42, 0x432aff97); /* 50 */
 304         II (c, d, a, b, 14, S43, 0xab9423a7); /* 51 */
 305         II (b, c, d, a,  5, S44, 0xfc93a039); /* 52 */
 306         II (a, b, c, d, 12, S41, 0x655b59c3); /* 53 */
 307         II (d, a, b, c,  3, S42, 0x8f0ccc92); /* 54 */
 308         II (c, d, a, b, 10, S43, 0xffeff47d); /* 55 */
 309         II (b, c, d, a,  1, S44, 0x85845dd1); /* 56 */
 310         II (a, b, c, d,  8, S41, 0x6fa87e4f); /* 57 */
 311         II (d, a, b, c, 15, S42, 0xfe2ce6e0); /* 58 */
 312         II (c, d, a, b,  6, S43, 0xa3014314); /* 59 */
 313         II (b, c, d, a, 13, S44, 0x4e0811a1); /* 60 */
 314         II (a, b, c, d,  4, S41, 0xf7537e82); /* 61 */
 315         II (d, a, b, c, 11, S42, 0xbd3af235); /* 62 */
 316         II (c, d, a, b,  2, S43, 0x2ad7d2bb); /* 63 */
 317         II (b, c, d, a,  9, S44, 0xeb86d391); /* 64 */
 318
 319         A += a;  TRUNC32(A);
 320         B += b;  TRUNC32(B);
 321         C += c;  TRUNC32(C);
 322         D += d;  TRUNC32(D);
 323
 324     } while (--blocks);
 325     ctx->A = A;
 326     ctx->B = B;
 327     ctx->C = C;
 328     ctx->D = D;
 329 }
 330
 331
 332 #ifdef MD5_DEBUG
 333 static char*
 334 ctx_dump(MD5_CTX* ctx)
 335 {
 336     static char buf[1024];
 337     sprintf(buf, "{A=%x,B=%x,C=%x,D=%x,%d,%d(%d)}",
 338             ctx->A, ctx->B, ctx->C, ctx->D,
 339             ctx->bytes_low, ctx->bytes_high, (ctx->bytes_low&0x3F));
 340     return buf;
 341 }
 342 #endif
 343
 344
 345 static void
 346 MD5Update(MD5_CTX* ctx, const U8* buf, STRLEN len)
 347 {
 348     STRLEN blocks;
 349     STRLEN fill = ctx->bytes_low & 0x3F;
 350
 351 #ifdef MD5_DEBUG
 352     static int ucount = 0;
 353     fprintf(stderr,"%5i: Update(%s, %p, %d)\n", ++ucount, ctx_dump(ctx),
 354                                                 buf, len);
 355 #endif
 356
 357     ctx->bytes_low += len;
 358     if (ctx->bytes_low < len) /* wrap around */
 359         ctx->bytes_high++;
 360
 361     if (fill) {
 362         STRLEN missing = 64 - fill;
 363         if (len < missing) {
 364             Copy(buf, ctx->buffer + fill, len, U8);
 365             return;
 366         }
 367         Copy(buf, ctx->buffer + fill, missing, U8);
 368         MD5Transform(ctx, ctx->buffer, 1);
 369         buf += missing;
 370         len -= missing;
 371     }
 372
 373     blocks = len >> 6;
 374     if (blocks)
 375         MD5Transform(ctx, buf, blocks);
 376     if ( (len &= 0x3F)) {
 377         Copy(buf + (blocks << 6), ctx->buffer, len, U8);
 378     }
 379 }
 380
 381
 382 static void
 383 MD5Final(U8* digest, MD5_CTX *ctx)
 384 {
 385     STRLEN fill = ctx->bytes_low & 0x3F;
 386     STRLEN padlen = (fill < 56 ? 56 : 120) - fill;
 387     U32 bits_low, bits_high;
 388 #ifdef MD5_DEBUG
 389     fprintf(stderr,"       Final:  %s\n", ctx_dump(ctx));
 390 #endif
 391     Copy(PADDING, ctx->buffer + fill, padlen, U8);
 392     fill += padlen;
 393
 394     bits_low = ctx->bytes_low << 3;
 395     bits_high = (ctx->bytes_high << 3) | (ctx->bytes_low  >> 29);
 396 #ifdef BYTESWAP
 397     *(U32*)(ctx->buffer + fill) = BYTESWAP(bits_low);    fill += 4;
 398     *(U32*)(ctx->buffer + fill) = BYTESWAP(bits_high);   fill += 4;
 399 #else
 400     u2s(bits_low,  ctx->buffer + fill);   fill += 4;
 401     u2s(bits_high, ctx->buffer + fill);   fill += 4;
 402 #endif
 403
 404     MD5Transform(ctx, ctx->buffer, fill >> 6);
 405 #ifdef MD5_DEBUG
 406     fprintf(stderr,"       Result: %s\n", ctx_dump(ctx));
 407 #endif
 408
 409 #ifdef BYTESWAP
 410     *(U32*)digest = BYTESWAP(ctx->A);  digest += 4;
 411     *(U32*)digest = BYTESWAP(ctx->B);  digest += 4;
 412     *(U32*)digest = BYTESWAP(ctx->C);  digest += 4;
 413     *(U32*)digest = BYTESWAP(ctx->D);
 414 #else
 415     u2s(ctx->A, digest);
 416     u2s(ctx->B, digest+4);
 417     u2s(ctx->C, digest+8);
 418     u2s(ctx->D, digest+12);
 419 #endif
 420 }
 421
 422 #ifndef INT2PTR
 423 #define INT2PTR(any,d)  (any)(d)
 424 #endif
 425
 426 static MD5_CTX* get_md5_ctx(SV* sv)
 427 {
 428     if (SvROK(sv)) {
 429         sv = SvRV(sv);
 430         if (SvIOK(sv)) {
 431             MD5_CTX* ctx = INT2PTR(MD5_CTX*, SvIV(sv));
 432             if (ctx && ctx->signature == MD5_CTX_SIGNATURE) {
 433                 return ctx;
 434             }
 435         }
 436     }
 437     croak("Not a reference to a Digest::MD5 object");
 438     return (MD5_CTX*)0; /* some compilers insist on a return value */
 439 }
 440
 441
 442 static char* hex_16(const unsigned char* from, char* to)
 443 {
 444     static char *hexdigits = "0123456789abcdef";
 445     const unsigned char *end = from + 16;
 446     char *d = to;
 447
 448     while (from < end) {
 449         *d++ = hexdigits[(*from >> 4)];
 450         *d++ = hexdigits[(*from & 0x0F)];
 451         from++;
 452     }
 453     *d = '\0';
 454     return to;
 455 }
 456
 457 static char* base64_16(const unsigned char* from, char* to)
 458 {
 459     static char* base64 =
 460         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 461     const unsigned char *end = from + 16;
 462     unsigned char c1, c2, c3;
 463     char *d = to;
 464
 465     while (1) {
 466         c1 = *from++;
 467         *d++ = base64[c1>>2];
 468         if (from == end) {
 469             *d++ = base64[(c1 & 0x3) << 4];
 470             break;
 471         }
 472         c2 = *from++;
 473         c3 = *from++;
 474         *d++ = base64[((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4)];
 475         *d++ = base64[((c2 & 0xF) << 2) | ((c3 & 0xC0) >>6)];
 476         *d++ = base64[c3 & 0x3F];
 477     }
 478     *d = '\0';
 479     return to;
 480 }
 481
 482 /* Formats */
 483 #define F_BIN 0
 484 #define F_HEX 1
 485 #define F_B64 2
 486
 487 static SV* make_mortal_sv(const unsigned char *src, int type)
 488 {
 489     STRLEN len;
 490     char result[33];
 491     char *ret;
 492
 493     switch (type) {
 494     case F_BIN:
 495         ret = (char*)src;
 496         len = 16;
 497         break;
 498     case F_HEX:
 499         ret = hex_16(src, result);
 500         len = 32;
 501         break;
 502     case F_B64:
 503         ret = base64_16(src, result);
 504         len = 22;
 505         break;
 506     default:
 507         croak("Bad convertion type (%d)", type);
 508         break;
 509     }
 510     return sv_2mortal(newSVpv(ret,len));
 511 }
 512
 513
 514 /********************************************************************/
 515
 516 typedef PerlIO* InputStream;
 517
 518 MODULE = Digest::MD5            PACKAGE = Digest::MD5
 519
 520 PROTOTYPES: DISABLE
 521
 522 void
 523 new(xclass)
 524         SV* xclass
 525     PREINIT:
 526         MD5_CTX* context;
 527     PPCODE:
 528         if (!SvROK(xclass)) {
 529             STRLEN my_na;
 530             char *sclass = SvPV(xclass, my_na);
 531             New(55, context, 1, MD5_CTX);
 532             context->signature = MD5_CTX_SIGNATURE;
 533             ST(0) = sv_newmortal();
 534             sv_setref_pv(ST(0), sclass, (void*)context);
 535             SvREADONLY_on(SvRV(ST(0)));
 536         } else {
 537             context = get_md5_ctx(xclass);
 538         }
 539         MD5Init(context);
 540         XSRETURN(1);
 541
 542 void
 543 DESTROY(context)
 544         MD5_CTX* context
 545     CODE:
 546         Safefree(context);
 547
 548 void
 549 add(self, ...)
 550         SV* self
 551     PREINIT:
 552         MD5_CTX* context = get_md5_ctx(self);
 553         int i;
 554         unsigned char *data;
 555         STRLEN len;
 556     PPCODE:
 557         for (i = 1; i < items; i++) {
 558             data = (unsigned char *)(SvPVbyte(ST(i), len));
 559             MD5Update(context, data, len);
 560         }
 561         XSRETURN(1);  /* self */
 562
 563 void
 564 addfile(self, fh)
 565         SV* self
 566         InputStream fh
 567     PREINIT:
 568         MD5_CTX* context = get_md5_ctx(self);
 569         STRLEN fill = context->bytes_low & 0x3F;
 570         unsigned char buffer[4096];
 571         int  n;
 572     CODE:
 573         if (fh) {
 574             if (fill) {
 575                 /* The MD5Update() function is faster if it can work with
 576                  * complete blocks.  This will fill up any buffered block
 577                  * first.
 578                  */
 579                 STRLEN missing = 64 - fill;
 580                 if ( (n = PerlIO_read(fh, buffer, missing)))
 581                     MD5Update(context, buffer, n);
 582                 else
 583                     XSRETURN(1);  /* self */
 584             }
 585
 586             /* Process blocks until EOF */
 587             while ( (n = PerlIO_read(fh, buffer, sizeof(buffer)))) {
 588                 MD5Update(context, buffer, n);
 589             }
 590         }
 591         XSRETURN(1);  /* self */
 592
 593 void
 594 digest(context)
 595         MD5_CTX* context
 596     ALIAS:
 597         Digest::MD5::digest    = F_BIN
 598         Digest::MD5::hexdigest = F_HEX
 599         Digest::MD5::b64digest = F_B64
 600     PREINIT:
 601         unsigned char digeststr[16];
 602     PPCODE:
 603         MD5Final(digeststr, context);
 604         MD5Init(context);  /* In case it is reused */
 605         ST(0) = make_mortal_sv(digeststr, ix);
 606         XSRETURN(1);
 607
 608 void
 609 md5(...)
 610     ALIAS:
 611         Digest::MD5::md5        = F_BIN
 612         Digest::MD5::md5_hex    = F_HEX
 613         Digest::MD5::md5_base64 = F_B64
 614     PREINIT:
 615         MD5_CTX ctx;
 616         int i;
 617         unsigned char *data;
 618         STRLEN len;
 619         unsigned char digeststr[16];
 620     PPCODE:
 621         MD5Init(&ctx);
 622         if (PL_dowarn && items > 1) {
 623             data = (unsigned char *)SvPVbyte(ST(0), len);
 624             if (len == 11 && memEQ("Digest::MD5", data, 11)) {
 625                  char *f = (ix == F_BIN) ? "md5" :
 626                            (ix == F_HEX) ? "md5_hex" : "md5_base64";
 627                  warn("&Digest::MD5::%s function probably called as method", f);
 628             }
 629         }
 630         for (i = 0; i < items; i++) {
 631             data = (unsigned char *)(SvPVbyte(ST(i), len));
 632             MD5Update(&ctx, data, len);
 633         }
 634         MD5Final(digeststr, &ctx);
 635         ST(0) = make_mortal_sv(digeststr, ix);
 636         XSRETURN(1);