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