FAQ MD5 Hash

Verwendung des MD5 Hash für die Erzeugung des ZIV Datensatzes
Im Beispiel 1 wird der MD5 Hash jeweils für die Datensätze 1 und 2 gebildet. Parallel
wird der Gesamthash über alle Sätze 1 und 2 für die Speicherung in der Satzart 3
ohne Zwischenspeicherung in einem File gebildet.
Im Beispiel 2 wird eine alternative Form der Hashbildung über die Satzart 0 mit
angehängtem Datums- und Zeitstempel aufgezeigt. Diese Form kann z.B. auf
Hostsystemen unter Verwendung des MD5 REXX Moduls eingesetzt werden.
Beide Varianten werden als gleichwertig für die Ermittlung des Hashwertes im
Datensatz 3 akzeptiert.
Beispiel 1:
MD5_CTX context_satz12;
unsigned char hash_satz12[16];
MD5_CTX context_summe12;
unsigned char hash_summe12[16];
char Satzart_0[800+1];
char Satzart_1[800+1];
char Satzart_2[800+1];
char Satzart_3[800+1];
MD5Init(&context_summe12);
Satzart_0 erzeugen und in File speichern
while(Satzart_1 || Satzart_2) // erzeugen
{
if(Satzart_1)
{
MD5Init(&context_satz12);
MD5Update(&context_satz12, Satzart_1, 608);
MD5Final(hash_satz12, &context_satz12);
hash_satz12 in Satzart_1 Feld 27 speichern
50 Byte im Filler für eigene Nutzung ergänzen
MD5Update(&context_summe12, Satzart_1, 800);
Satzart_1 in File speichern
}
if(Satzart_2)
{
MD5Init(&context_satz12);
MD5Update(&context_satz12, Satzart_2, 474);
MD5Final(hash_satz12, &context_satz12);
hash_satz12 in Satzart_2 Feld 20 speichern
50 Byte im Filler für eigene Nutzung ergänzen
MD5Update(&context_summe12, Satzart_2, 800);
Satzart_2 in File speichern
}
};
Satzart_3 erzeugen
MD5Final(hash_summe12, &context_summe12);
hash_summe12 in Satzart_3 Feld 7 speichern
Satzart_3 in File speichern

Beispiel 2:
MD5_CTX context_satz12;
unsigned char hash_satz12[16];
MD5_CTX context_summe12;
unsigned char hash_summe12[16];
char Satzart_0[800+14+1];
char Satzart_1[800+1];
char Satzart_2[800+1];
char Satzart_3[800+1];
Satzart_0 erzeugen und mit Länge 800 Byte in File speichern
Aktuelles Datum + Uhrzeit + Sekunden JJJJMMTTHHMMSS an Satzart_0 anhängen
z.B. 20060303141516
MD5Init(&context_summe12);
MD5Update(&context_summe12, Satzart_0, 814);
MD5Final(hash_summe12, &context_summe12);
while(Satzart_1 || Satzart_2) // erzeugen
{
if(Satzart_1)
{
MD5Init(&context_satz12);
MD5Update(&context_satz12, Satzart_1, 608);
MD5Final(hash_satz12, &context_satz12);
hash_satz12 in Satzart_1 Feld 27 speichern
50 Byte im Filler für eigene Nutzung ergänzen
Satzart_1 in File speichern
}
if(Satzart_2)
{
MD5Init(&context_satz12);
MD5Update(&context_satz12, Satzart_2, 474);
MD5Final(hash_satz12, &context_satz12);
hash_satz12 in Satzart_2 Feld 20 speichern
50 Byte im Filler für eigene Nutzung ergänzen
Satzart_2 in File speichern
}
};
Satzart_3 erzeugen
hash_summe12 in Satzart_3 Feld 7 speichern
Satzart_3 in File speichern

fc1321.c
#include
#include
#include
typedef unsigned char *POINTER;
typedef unsigned short int UINT2;
typedef unsigned long int UINT4;
/* MD5 context. */
typedef struct
{
UINT4 state[4];
UINT4 count[2];
unsigned char buffer[64];
} MD5_CTX;
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
void MD5Init(MD5_CTX *);
void MD5Update(MD5_CTX *, unsigned char *, unsigned int);
void MD5Final(unsigned char [16], MD5_CTX *);
static void MD5Transform(UINT4 [4], unsigned char [64]);
static void Encode(unsigned char *, UINT4 *, unsigned int);
static void Decode(UINT4 *, unsigned char *, unsigned int);
static unsigned char PADDING[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define ROTATE_LEFT(x, n) (((x) > (32-(n))))
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
void MD5Init(MD5_CTX *context)

{
context->count[0] = context->count[1] = 0;
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}
void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputLen)
{
unsigned int i, index, partLen;
}
index = (unsigned int)((context->count[0] >> 3) & 0x3F);
if((context->count[0] += ((UINT4)inputLen count[1] += ((UINT4)inputLen >> 29);
partLen = 64 - index;
if(inputLen >= partLen)
{
memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
MD5Transform(context->state, context->buffer);
for(i = partLen; i + 63 < inputLen; i += 64)
MD5Transform(context->state, &input[i]);
index = 0;
}
else
i = 0;
memcpy((POINTER)&context->buffer[index], (POINTER)&input[i],
inputLen-i);
void MD5Final(unsigned char digest[16], MD5_CTX *context)
{
unsigned char bits[8];
unsigned int index, padLen;
Encode (bits, context->count, 8);
index = (unsigned int)((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
MD5Update(context, PADDING, padLen);
MD5Update(context, bits, 8);
Encode(digest, context->state, 16);
memset((POINTER)context, 0, sizeof (*context));
}
static void MD5Transform(UINT4 state[4], unsigned char block[64])
{
UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
Decode(x, block, 64);
/* Round 1 */
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
/* Round 2 */
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */

}
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
/* Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
memset((POINTER)x, 0, sizeof(x));
static void Encode(unsigned char *output, UINT4 *input, unsigned int len)
{
unsigned int i, j;
for(i = 0, j = 0; j < len; i++, j += 4)
{
output[j] = (unsigned char)(input[i] & 0xff);
output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
}
}
static void Decode(UINT4 *output, unsigned char *input, unsigned int len)
{
unsigned int i, j;
for(i = 0, j = 0; j < len; i++, j += 4)
{

}
}
output[i] = ((UINT4)input[j]) |
(((UINT4)input[j+1])

* Prints a message digest in hexadecimal.
*/
static void MDPrint(unsigned char digest[16])
{
unsigned int i;
}
for (i = 0; i < 16; i++)
printf ("%02x", digest[i]);

Calling REXX from COBOL on OS/390 and z/OS
Beispiele des Upros für COBOL unter:
http://www-1.ibm.com/support/docview.wss?uid=swg24003837
und zwar dort das Member SIEXCOB.JCLSAMPL (muss modifiziert werden).
Aufruf aus COBOL:
*---------------------------------------------------------------­
* 2170-PRUEFEN-SATZ-HASH
* - SATZ HASH ERMITTELN UEBER UPRO REXXMD5
*---------------------------------------------------------------­
2170-PRUEFEN-SATZ-HASH SECTION.
*
CALL 'REXXMD5' USING MD5-STRING-VORHER
MD5-STRING-LAENGE
MD5-HASH-NACHHER
MD5-RETURN-CODE
IF MD5-RETURN-CODE = ZERO
CONTINUE
ELSE
MOVE MD5-RETURN-CODE TO DISP-MD5-RETURN-CODE
STRING 'FEHLER IN MODUL ERMITTELN HASHWERT'
' MODUL NAME: ' PGM-REXXMD5
DELIMITED BY SIZE
INTO F-KOMMENTAR1
STRING 'RETURNCODE: '
DISP-MD5-RETURN-CODE
DELIMITED BY SIZE
INTO F-KOMMENTAR2
END-IF
CONTINUE.
*
2170-EXIT.
EXIT.
*
REXX-Proc Library einbauen im Run-JCL:
//SYSEXEC DD DISP=SHR,DSN=UserId.TSO.CLIST
*
* Sample JCL for calling IRXEXEC from COBOL program
* You may modify this sample for your needs by including
* a REXX of your own. The argument for the REXX procedure
* may be taylored for your needs.
*
Identification Division.
PROGRAM-ID. REXXMD5.
Environment division.
Configuration section.
Special-names.
Input-output section.
File-control.
Data division.
File section.
*
Working-storage section.
01 Working-storage-for-rexxmd5 pic x.
77 PGM-NAME pic X(8).

* Define the IRXEXEC argument blocks
*
01 EXECBLK.
03 EXECBLK-ACRYN pic X(8).
03 EXECBLK-LENGTH pic S9(8) binary.
03 EXECBLK-reserved pic S9(8) binary.
03 EXECBLK-MEMBER pic X(8).
03 EXECBLK-DDNAME pic X(8).
03 EXECBLK-SUBCOM pic X(8).
03 EXECBLK-DSNPTR POINTER.
03 EXECBLK-DSNLEN pic 9(4) comp.
01 EVALBLK.
03 EVALBLK-EVPAD1 pic S9(8) binary.
03 EVALBLK-EVSIZE pic S9(8) binary.
03 EVALBLK-EVLEN pic S9(8) binary.
03 EVALBLK-EVPAD2 pic S9(8) binary.
03 EVALBLK-EVDATA pic x(256).
77 flags pic S9(8) binary.
77 REXX-return-code pic S9(8) binary.
77 dummy-zero pic S9(8) binary.
01 ARGUMENT.
02 ARGUMENT-1 OCCURS 1 TIMES.
05 ARGSTRING-PTR POINTER.
05 ARGSTRING-LENGTH pic S9(8) binary.
02 ARGSTRING-LAST1 pic S9(8) binary.
02 ARGSTRING-LAST2 pic S9(8) binary.
77 arg1 pic x(800).
77 execblk-ptr POINTER.
77 argtable-ptr POINTER.
77 evalblk-ptr POINTER.
linkage section.
copy rexxmd5c.
*****************************************************************
*** D O M A I N L O G I C **
*****************************************************************
procedure division using md5-string-vorher
md5-string-laenge
md5-hash-nachher
md5-return-code.
000-do-main-logic.
display "PROGRAM rexxmd5 - Beginning"
*--- Pass md5-string-vor as argument to the REXX procedure 'MD5'
move md5-string-vorher to arg1
call "GET-ARG1-PTR" using arg1 ARGSTRING-PTR(1)
move md5-string-laenge to ARGSTRING-LENGTH(1)
move -1 to ARGSTRING-LAST1
move -1 to ARGSTRING-LAST2
call 'GET-ARGUMENT-PTR' using argument argtable-ptr
move 'IRXEXECB' to EXECBLK-ACRYN
move 48 to EXECBLK-LENGTH
move 0 to EXECBLK-reserved
*--- Pass the procedure name MD5 to IRXEXEC.
move "MD5" to EXECBLK-MEMBER
move space to EXECBLK-SUBCOM
move space to EXECBLK-DDNAME
set EXECBLK-DSNPTR to NULL
move 0 to EXECBLK-DSNLEN
call "GET-EXECBLK-PTR" using EXECBLK execblk-ptr
move zero to EVALBLK-EVPAD1
move 34 to EVALBLK-EVSIZE
move zero to EVALBLK-EVLEN
move zero to EVALBLK-EVPAD2
call "GET-EVALBLK-PTR" using EVALBLK evalblk-ptr
move zero to dummy-zero
*--- Set flags to HEX 20000000
* i.e. exec invoked as subroutine
move 536870912 to flags
move zero to REXX-return-code

*--- Call the REXX exec --move
'IRXEXEC ' to PGM-NAME
CALL PGM-NAME USING execblk-ptr
argtable-ptr
flags
dummy-zero
dummy-zero
evalblk-ptr
dummy-zero
dummy-zero
dummy-zero
REXX-return-code
CANCEL PGM-NAME
*--- Display the return code
move evalblk-evdata to md5-hash-nachher
move rexx-return-code to md5-return-code
display "REXX return code is: " REXX-return-code
display "REXX result is: " EVALBLK-EVDATA
display "PROGRAM rexxmd5 - Normal end"
goback.
*--- Addressing helper
Identification Division.
Program-id. GET-ARG1-PTR.
Environment division.
Data division.
Working-storage section.
Linkage section.
77 arg1 pic x(800).
77 arg-ptr POINTER.
procedure division using arg1 arg-ptr.
set arg-ptr to address of arg1
goback.
end program GET-ARG1-PTR.
*--- Addressing helper
Identification Division.
Program-id. GET-ARGUMENT-PTR.
Environment division.
Data division.
Working-storage section.
Linkage section.
01 ARGUMENT.
02 ARGUMENT-1 OCCURS 1 TIMES.
05 ARGSTRING-PTR POINTER.
05 ARGSTRING-LENGTH pic S9(8) binary.
02 ARGSTRING-LAST1 pic S9(8) binary.
02 ARGSTRING-LAST2 pic S9(8) binary.
77 argtable-ptr POINTER.
procedure division using ARGUMENT argtable-ptr.
set argtable-ptr to address of ARGUMENT
goback.
end program GET-ARGUMENT-PTR.
*--- Addressing helper
Identification Division.
Program-id. GET-EXECBLK-PTR.
Environment division.
Data division.
Working-storage section.
Linkage section.
01 EXECBLK.
03 EXECBLK-ACRYN pic X(8).
03 EXECBLK-LENGTH pic 9(4) comp.
03 EXECBLK-reserved pic 9(4) comp.
03 EXECBLK-MEMBER pic X(8).
03 EXECBLK-DDNAME pic X(8).
03 EXECBLK-SUBCOM pic X(8).
03 EXECBLK-DSNPTR POINTER.
03 EXECBLK-DSNLEN pic 9(4) comp.

77 execblk-ptr POINTER.
procedure division using EXECBLK execblk-ptr.
set execblk-ptr to address of EXECBLK
goback.
end program GET-EXECBLK-PTR.
*--- Addressing helper
Identification Division.
Program-id. GET-EVALBLK-PTR.
Environment division.
Data division.
Working-storage section.
Linkage section.
01 EVALBLK.
03 EVALBLK-EVPAD1 pic 9(4) binary.
03 EVALBLK-EVSIZE pic 9(4) binary.
03 EVALBLK-EVLEN pic 9(4) binary.
03 EVALBLK-EVPAD2 pic 9(4) binary.
03 EVALBLK-EVDATA pic x(256).
77 evalblk-ptr POINTER.
procedure division using EVALBLK evalblk-ptr.
set evalblk-ptr to address of EVALBLK
goback.
end program GET-EVALBLK-PTR.
IA9990 END PROGRAM REXXMD5.
REXXMD5C1
***************************************************************
* Europaeische Zinsverordnung (EUZI)
*
* Eingabeschnittstelle zum ermitteln der MD5 hash Werte
* Es werden die folgenden Felder an das Upro "REXXMD5"
* uebergeben
*****************************************************************
*
*
01 MD5-STRING-VORHER PIC X(800).
* Eingabe String fuer MD5
*
01 MD5-STRING-LAENGE PIC S9(08) BINARY.
* Eingabe String laenge
* muss - da sonst Ergebnis
* nicht korrekt (MD5-HASH-NACHHER)
*
01 MD5-HASH-NACHHER PIC X(32).
* Rueckgabe Hashwert
*
01 MD5-RETURN-CODE PIC S9(08) BINARY.
* Rueckgabe return Code
*

REXX- MD5-Procedure
/* REXX */
RETURN MD5(ARG(1))
/* --- */
MD5 : procedure /* for MD5 details see RfC 1321 */
numeric digits 11 /* 32 bit addition + carry digit */
parse arg MSG /* if MSG < 12,500,000,000 bytes */
LEN = 8 * length( MSG ) /* MD5 operates on bit messages: */
PAD = LEN // 512 /* pad to length 448 modulo 512 */
if PAD < 448 then PAD = 448 - PAD
else PAD = 960 - PAD
PAD = left( '80'x, PAD / 8, '00'x )
MSG = MSG !! PAD !! reverse( x2c( d2x( LEN, 16 )))
A = '67452301'x ;
C = '98BADCFE'x ;
S11 = 7 ; S12 = 12 ;
S21 = 5 ; S22 = 9 ;
S31 = 4 ; S32 = 11 ;
S41 = 6 ; S42 = 10 ;
B = 'EFCDAB89'x
D = '10325476'x
S13 = 17 ; S14 = 22
S23 = 14 ; S24 = 20
S33 = 16 ; S34 = 23
S43 = 15 ; S44 = 21
do N = 1 to ( length( MSG ) / 4 ) / 16
K = N * 64 - 63
do J = 0 to 15
M.J = c2d( reverse( substr( MSG, K + J * 4, 4 )))
end J
AA = A ; BB = B ; CC = C ; DD = D
A = MD5.1( A, B, C, D, S11, M.0 + 3614090360 ) /* 1 */
D = MD5.1( D, A, B, C, S12, M.1 + 3905402710 ) /* 2 */
C = MD5.1( C, D, A, B, S13, M.2 + 606105819 ) /* 3 */
B = MD5.1( B, C, D, A, S14, M.3 + 3250441966 ) /* 4 */
A = MD5.1( A, B, C, D, S11, M.4 + 4118548399 ) /* 5 */
D = MD5.1( D, A, B, C, S12, M.5 + 1200080426 ) /* 6 */
C = MD5.1( C, D, A, B, S13, M.6 + 2821735955 ) /* 7 */
B = MD5.1( B, C, D, A, S14, M.7 + 4249261313 ) /* 8 */
A = MD5.1( A, B, C, D, S11, M.8 + 1770035416 ) /* 9 */
D = MD5.1( D, A, B, C, S12, M.9 + 2336552879 ) /* 10 */
C = MD5.1( C, D, A, B, S13, M.10+ 4294925233 ) /* 11 */
B = MD5.1( B, C, D, A, S14, M.11+ 2304563134 ) /* 12 */
A = MD5.1( A, B, C, D, S11, M.12+ 1804603682 ) /* 13 */
D = MD5.1( D, A, B, C, S12, M.13+ 4254626195 ) /* 14 */
C = MD5.1( C, D, A, B, S13, M.14+ 2792965006 ) /* 15 */
B = MD5.1( B, C, D, A, S14, M.15+ 1236535329 ) /* 16 */
A = MD5.2( A, B, C, D, S21, M.1 + 4129170786 ) /* 17 */
D = MD5.2( D, A, B, C, S22, M.6 + 3225465664 ) /* 18 */
C = MD5.2( C, D, A, B, S23, M.11+ 643717713 ) /* 19 */
B = MD5.2( B, C, D, A, S24, M.0 + 3921069994 ) /* 20 */
A = MD5.2( A, B, C, D, S21, M.5 + 3593408605 ) /* 21 */
D = MD5.2( D, A, B, C, S22, M.10+ 38016083 ) /* 22 */
C = MD5.2( C, D, A, B, S23, M.15+ 3634488961 ) /* 23 */
B = MD5.2( B, C, D, A, S24, M.4 + 3889429448 ) /* 24 */
A = MD5.2( A, B, C, D, S21, M.9 + 568446438 ) /* 25 */
D = MD5.2( D, A, B, C, S22, M.14+ 3275163606 ) /* 26 */
C = MD5.2( C, D, A, B, S23, M.3 + 4107603335 ) /* 27 */
B = MD5.2( B, C, D, A, S24, M.8 + 1163531501 ) /* 28 */
A = MD5.2( A, B, C, D, S21, M.13+ 2850285829 ) /* 29 */
D = MD5.2( D, A, B, C, S22, M.2 + 4243563512 ) /* 30 */
C = MD5.2( C, D, A, B, S23, M.7 + 1735328473 ) /* 31 */
B = MD5.2( B, C, D, A, S24, M.12+ 2368359562 ) /* 32 */
A = MD5.3( A, B, C, D, S31, M.5 + 4294588738 ) /* 33 */
D = MD5.3( D, A, B, C, S32, M.8 + 2272392833 ) /* 34 */
C = MD5.3( C, D, A, B, S33, M.11+ 1839030562 ) /* 35 */
B = MD5.3( B, C, D, A, S34, M.14+ 4259657740 ) /* 36 */
A = MD5.3( A, B, C, D, S31, M.1 + 2763975236 ) /* 37 */
D = MD5.3( D, A, B, C, S32, M.4 + 1272893353 ) /* 38 */
C = MD5.3( C, D, A, B, S33, M.7 + 4139469664 ) /* 39 */
B = MD5.3( B, C, D, A, S34, M.10+ 3200236656 ) /* 40 */
A = MD5.3( A, B, C, D, S31, M.13+ 681279174 ) /* 41 */

D = MD5.3( D, A, B, C, S32, M.0 + 3936430074 ) /* 42 */
C = MD5.3( C, D, A, B, S33, M.3 + 3572445317 ) /* 43 */
B = MD5.3( B, C, D, A, S34, M.6 + 76029189 ) /* 44 */
A = MD5.3( A, B, C, D, S31, M.9 + 3654602809 ) /* 45 */
D = MD5.3( D, A, B, C, S32, M.12+ 3873151461 ) /* 46 */
C = MD5.3( C, D, A, B, S33, M.15+ 530742520 ) /* 47 */
B = MD5.3( B, C, D, A, S34, M.2 + 3299628645 ) /* 48 */
A = MD5.4( A, B, C, D, S41, M.0 + 4096336452 ) /* 49 */
D = MD5.4( D, A, B, C, S42, M.7 + 1126891415 ) /* 50 */
C = MD5.4( C, D, A, B, S43, M.14+ 2878612391 ) /* 51 */
B = MD5.4( B, C, D, A, S44, M.5 + 4237533241 ) /* 52 */
A = MD5.4( A, B, C, D, S41, M.12+ 1700485571 ) /* 53 */
D = MD5.4( D, A, B, C, S42, M.3 + 2399980690 ) /* 54 */
C = MD5.4( C, D, A, B, S43, M.10+ 4293915773 ) /* 55 */
B = MD5.4( B, C, D, A, S44, M.1 + 2240044497 ) /* 56 */
A = MD5.4( A, B, C, D, S41, M.8 + 1873313359 ) /* 57 */
D = MD5.4( D, A, B, C, S42, M.15+ 4264355552 ) /* 58 */
C = MD5.4( C, D, A, B, S43, M.6 + 2734768916 ) /* 59 */
B = MD5.4( B, C, D, A, S44, M.13+ 1309151649 ) /* 60 */
A = MD5.4( A, B, C, D, S41, M.4 + 4149444226 ) /* 61 */
D = MD5.4( D, A, B, C, S42, M.11+ 3174756917 ) /* 62 */
C = MD5.4( C, D, A, B, S43, M.2 + 718787259 ) /* 63 */
B = MD5.4( B, C, D, A, S44, M.9 + 3951481745 ) /* 64 */
A = x2c( d2x( c2d( AA ) + c2d( A ), 8 ))
B = x2c( d2x( c2d( BB ) + c2d( B ), 8 ))
C = x2c( d2x( c2d( CC ) + c2d( C ), 8 ))
D = x2c( d2x( c2d( DD ) + c2d( D ), 8 ))
end N
A = reverse( A ) ; B = reverse( B )
C = reverse( C ) ; D = reverse( D )
return translate( c2x( A !! B !! C !! D ), 'abcdef', 'ABCDEF' )
MD5.1 : procedure /* function used in MD5 round 1: */
parse arg A, B, C, D, S, M
C = bitor( bitand( B, C ), bitand( D, bitxor( B,, 'FF'x )))
signal MD5..
MD5.2 : procedure /* function used in MD5 round 2: */
parse arg A, B, C, D, S, M
C = bitor( bitand( B, D ), bitand( C, bitxor( D,, 'FF'x )))
signal MD5..
MD5.3 : procedure /* function used in MD5 round 3: */
parse arg A, B, C, D, S, M
C = bitxor( B, bitxor( C, D ))
signal MD5..
MD5.4 : procedure /* function used in MD5 round 4: */
parse arg A, B, C, D, S, M
C = bitxor( C, bitor( B, bitxor( D,, 'FF'x )))
MD5.. :
C = x2b( d2x( c2d( A ) + c2d( C ) + M, 8 ))
C = x2d( b2x( right( C !! left( C, S ), 32 )))
return x2c( d2x( C + c2d( B ), 8 ))