MD5/Implementation: Difference between revisions

** A translation of a correct implementation from another language

** A library routine in the same language; however, the source must be included here.

 

The solutions shown here will provide practical illustrations of bit manipulation, unsigned integers, working with little-endian data. Additionally, the task requires an attention to details such as boundary conditions since being out by even 1 bit will produce dramatically different results. Subtle implementation bugs can result in some hashes being correct while others are wrong. Not only is it critical to get the individual sub functions working correctly, even small errors in padding, endianness, or data layout will result in failure.

The MD5 Message-Digest Algorithm was developed by [[wp:RSA_SecurityRSA|RSA Data Security, Inc.]] in 1991.

 

 

=={{header|Ada}}==

 

md5.ads:

 

type Int32 is mod 2 ** 32;

function To_String (Item : MD5_Hash) return MD5_String;

 

 

md5.adb:

 

package body MD5 is

end To_String;

 

 

tester.adb:

with Ada.Text_IO;

with MD5;

Ada.Text_IO.Put_Line (To_String (Digests (I)) & " (correct value)");

end loop;

 

output:

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PRINT FN_MD5("a")

PRINT FN_MD5("abc")

REM Break chunk into sixteen 32-bit little-endian words:

FOR i% = 0 TO 15

NEXT i%

WHILE n# > &7FFFFFFF : n# -= 2^32 : ENDWHILE

WHILE n# < &80000000 : n# += 2^32 : ENDWHILE

 

=={{header|C}}==

=={{header|C sharp}}==

Handwritten implementation ([http://farazmahmood.wordpress.com/projects/md5-implementation-in-c/]):

public class MD5

{

}

 

 

Standard library-based implementation:

System.Security.Cryptography.MD5CryptoServiceProvider x = new System.Security.Cryptography.MD5CryptoServiceProvider();

byte[] bs = System.Text.Encoding.UTF8.GetBytes(password);

System.Text.StringBuilder s = new System.Text.StringBuilder();

foreach (byte b in bs)

}

password = s.ToString();

 

{{omit from|Clojure|Unavailable bit operations}}

 

=={{header|D}}==

 

This code generates x86 assembly code by compile time functions, then mix-in the assembly code. It only works on x86 machine.

std.string;

 

writefln("zmd5 : %8.2f M/sec ( %8.2f secs)",

megaBytes / time2, time2);

{{out|Output (dmd compiler)}}

<pre>md5 digest("") = D41D8CD98F00B204E9800998ECF8427E

 

As you see this asm is much faster than the D code compiled by dmd, but the D code compiled by ldc2 is a little faster still.

 

=={{header|Go}}==

 

import (

func main() {

for _, tc := range testCases {

}

}

}

 

padded.WriteByte(0x80)

for padded.Len() % 64 != 56 {

binary.Write(bytes.NewBuffer(r[:0]), binary.LittleEndian, []uint32{a, b, c, d})

return

Output:

<pre>

57edf4a22be3c955ac49da2e2107b67a

</pre>

 

=={{header|Haskell}}==

 

import qualified Data.ByteString.Lazy as BL

w = datA ! (idxA ! i)

a' = b + (a + f b c d + w + sinA ! i) `rotateL` rotA ! i

 

=={{header|Icon}} and {{header|Unicon}}==

The following program is based on part on the Wikipedia pseudo-code and in part on the reference implementation in RFC 1321. The implementation uses large integers. The solution works in both Icon and Unicon. One limitation of this implementation is that will not handle arbitrary (bit) length messages - all are byte aligned. Another small challenge was that Icon/Unicon bit manipulation functions work on signed integers (and large integers), as a result there are no native rotation and negation functions.

testMD5("The quick brown fox jumps over the lazy dog", 16r9e107d9d372bb6826bd81d3542a419d6)

testMD5("The quick brown fox jumps over the lazy dog.", 16re4d909c290d0fb1ca068ffaddf22cbd0)

end

 

 

The {{libheader|Icon Programming Library}} provides [http://www.cs.arizona.edu/icon/library/src/procs/unsigned.icn unsigned] and [http://www.cs.arizona.edu/icon/library/src/procs/hexcvt.icn hexcvt]

=={{header|J}}==

 

 

NB. version: 1.0.2

NB.

NB. 09/04/2003 Oleg Kobchenko

NB. 03/31/2007 Oleg Kobchenko j601, JAL

 

require 'convert'

 

NB. lt= (*. -.)~ gt= *. -. ge= +. -. xor= ~:

'`lt gt ge xor'=: (20 b.)`(18 b.)`(27 b.)`(22 b.)

add=: (+&(_16&sh) (16&sh@(+ _16&sh) or and&65535@]) +&(and&65535))"0

hexlist=: tolower@:,@:hfd@:,@:(|."1)@(256 256 256 256&#:)

 

cmn=: 4 : 0

)

 

 

I=: ".;._2(0 : 0)

)

S=: 4 4$7 12 17 22 5 9 14 20 4 11 16 23 6 10 15 21

 

T=: |:".;._2(0 : 0)

)

 

norm=: 3 : 0

)

 

NB. diagest=. md5 message

md5=: 3 : 0

end.

end.

 

d41d8cd98f00b204e9800998ecf8427e

md5'a'

md5'12345678901234567890123456789012345678901234567890123456789012345678901234567890'

57edf4a22be3c955ac49da2e2107b67a

 

=={{header|Java}}==

{{works with|Java|1.5+}}

Based on RFC-1321.

{

 

}

 

<b>Output:</b>

0xD174AB98D277D9F5A5611C2C9F419D9F <== "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"

0x57EDF4A22BE3C955AC49DA2E2107B67A <== "12345678901234567890123456789012345678901234567890123456789012345678901234567890"

</pre>

 

''See the implementation at [[MD5#Liberty BASIC]].''

 

Module[{r = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17,

22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4,

FromDigits[

Flatten[Reverse@IntegerDigits[#, 256, 4] & /@ {h0, h1, h2, h3}],

Example:

Output:

 

=={{header|MATLAB}} / {{header|Octave}}==

=={{header|Modula-3}}==

 

 

IMPORT Word;

PROCEDURE ToText(hash: Digest): TEXT;

 

 

IMPORT Word, Text, Fmt;

 

BEGIN

Example usage:

 

IMPORT MD5, IO;

MD5.Update(md5ctx, "The quick brown fox jumped over the lazy dog's back");

IO.Put(MD5.ToText(MD5.Final(md5ctx)) & "\n");

Output:

<pre>

</pre>

 

 

 

 

 

 

 

 

 

}

 

}

}

 

}

 

 

{{out}}

 

=={{header|PicoLisp}}==

care had to be taken with modulo 32-bit arithmetics, as PicoLisp supports only

numbers of unspecified size.

(load "@lib/math.l") # For 'sin'

 

(do 4 # Convert to little endian hex string

(link (pad 2 (hex (& N 255))))

Output:

<pre>: (md5 "")

Note that the following code focuses on brevity and elegance instead of performance, since Python isn't very good at number crunching anyway. If performance is important, the best solution is to use the built-in '''md5''' module, written in C.

 

 

rotate_amounts = [7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,

for message in demo:

print(md5_to_hex(md5(message)),' <= "',message.decode('ascii'),'"', sep='')

 

Implementation notes:

 

=={{header|Racket}}==

#lang racket

(require file/md5)

(md5 #"Rosetta Code")

Output:

#"cca1bf66b09554e10f837838c3d3efb1"

 

 

 

 

 

<pre>

in =

in = 12345678901234567890123456789012345678901234567890123456789012345678901234567890

out = 57EDF4A22BE3C955AC49DA2E2107B67A

</pre>

 

The example below contains the implementation of the function [http://seed7.sourceforge.net/libraries/msgdigest.htm#md5%28in_var_string%29 md5] from the library [http://seed7.sourceforge.net/libraries/msgdigest.htm msgdigest.s7i].

 

include "bytedata.s7i";

include "bin32.s7i";

const array integer: k is createMd5Table;

var integer: length is 0;

var integer: index is 0;

var array bin32: m is 16 times bin32.value;

message &:= "\0;" mult 63 - (length + 8) mod 64;

# Append length of message (before pre-processing), in bits, as 64-bit little-endian integer.

 

# Process the message in successive 512-bit chunks:

# Break chunk into sixteen 32-bit little-endian words.

for index range 1 to 16 do