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.

 

{{alertbox|#ffff70|'''<big>Warning</big>'''<br/>Rosetta Code is '''not''' a place you should rely on for examples of code in critical roles, including security.<br/>Also, note that MD5 has been ''broken'' and should not be used in applications requiring security. For these consider [[wp:SHA2|SHA2]] or the upcoming [[wp:SHA3|SHA3]].}}

 

=={{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/]):

/// Represent digest with ABCD

sealed public class Digest

}

 

 

Standard library-based implementation:

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

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

}

password = s.ToString();

 

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

 

=={{header|CoffeeScript}}==

# Array sum helper function.

sum = (array) ->

(String.fromCharCode x >>> 8 * y & 255 for y in [0..3]).join ''

).join ''

 

This implementation is more focused towards brevity rather than speed. Use a javascript MD5 implementation if speed is desired. Fork this code [https://gist.github.com/Higgs1/08ec61fbb250c1c92151 on github].

And tests:

 

str2hex = do ->

hex = ['0', '1', '2', '3', '4', '5', '6', '7',

"12345678901234567890123456789012345678901234567890123456789012345678901234567890"

]

 

Output:

This code requires the [https://github.com/cl-babel/babel BABEL] package for converting a string to an octet buffer.

 

(:use #:cl))

 

(md5 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")))

(assert (string= "57edf4a22be3c955ac49da2e2107b67a"

 

=={{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.

 

let gxyz x y z : uint32 = (z &&& x) ||| (~~~z &&& y)

let hxyz x y z : uint32 = x ^^^ y ^^^ z

|> (fun x -> System.BitConverter.GetBytes d |> Array.append x))

|> Array.map (sprintf "%02X")

 

=={{header|FreeBASIC}}==

' MD5 from the Wikipedia page "MD5"

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>

=={{header|Go}}==

A limitation from RFC 1321 is that the function md5 takes a string which is a number of whole bytes. Messages of arbitrary bit length are not supported.

 

import (

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

return

Output:

<pre>

57edf4a22be3c955ac49da2e2107b67a

</pre>

=={{header|Groovy}}==

class MD5 {

 

}

 

=={{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]

Note: the following code was extracted from http://www.jsoftware.com/wsvn/addons/trunk/convert/misc/md5.ijs

 

NB. RSA Data Security, Inc. MD5 Message-Digest Algorithm

NB. version: 1.0.2

)

 

 

d41d8cd98f00b204e9800998ecf8427e

md5'a'

md5'12345678901234567890123456789012345678901234567890123456789012345678901234567890'

57edf4a22be3c955ac49da2e2107b67a

 

=={{header|Java}}==

{{works with|Java|1.5+}}

Based on RFC-1321.

{

 

}

 

<b>Output:</b>

{{works with|Java|1.5+}}

Using <code>ByteBuffer</code>s

import java.nio.ByteOrder;

 

}

 

<b>Output:</b>

0x57EDF4A22BE3C955AC49DA2E2107B67A <== "12345678901234567890123456789012345678901234567890123456789012345678901234567890"

</pre>

 

=={{header|Julia}}==

 

const s = UInt32[7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,

println("MD5 of $(pair[2]) is $(md5(pair[2])), which checks with $(string(pair[1], base=16)).")

end

<pre>

MD5 of is d41d8cd98f00b204e9800998ecf8427e, which checks with d41d8cd98f00b204e9800998ecf8427e.

=={{header|Kotlin}}==

{{trans|Java}}

 

object MD5 {

println("0x${MD5.compute(s.toByteArray()).toHexString()} <== \"$s\"")

}

 

{{out}}

 

=={{header|Lingo}}==

-- Calculates MD5 hash of string or bytearray

-- @param {bytearray|string} input

ba.position = 1

return ba

 

tests.add("")

tests.add("a")

ba = md5(t)

put ba.toHexString(1, ba.length)

 

{{out}}

</pre>

 

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>

 

=={{header|Nim}}==

 

const

srcIndex = offset

 

chunk[dstIndex] = 0

chunk[dstIndex] = chunk[dstIndex] shr 8

chunk[dstIndex] = chunk[dstIndex] or (msg[srcIndex].uint32 shl 24)

var sizePadding = newSeq[uint8](8)

var size = msg.len * 8

sizePadding[ii] = uint8(size and 0xff)

size = size shr 8

var tmp = acc

 

result[dstIdx] = uint8(tmp and 0xff)

tmp = tmp shr 8

# Only needed to convert from string to uint8 sequence

iterator items * (str : string) : uint8 =

yield str[ii].uint8

 

0x0D, 0x5B, 0x09, 0x84, 0x09, 0x64, 0x44, 0x57 ])

 

 

=={{header|ooRexx}}==

{{works with|ooRexx|4.2.0 (and later)}}

 

/* Expected results:

index = 65

end

do while index=65

A = a0

 

-- A convenience class to encapsulate operations on non OORexx-like

::class int32 public

 

bstring = bstring~substr(bits+1)~left(bstring~length,'0')

return .int32~new(bstring~b2x~x2d)

 

::method bitright -- OORexx shift (>>) implementation

bstring = bstring~left(bstring~length-bits)~right(bstring~length,fill)

return .int32~new(bstring~b2x~x2d)

 

::method bitnot -- OORexx not implementation

-- Simplify function names for the necessary 'RxMath' functions

::routine sin EXTERNAL "LIBRARY rxmath RxCalcSin"

 

=={{header|Perl}}==

{{works with|Perl|5.10.1 (and later)}}

use warnings;

use integer;

}

 

($_[0] << $_[1]) | (( $_[0] >> (32 - $_[1]) ) & ((1 << $_[1]) - 1));

}

II,$d,$a,$b,$c,$_[15],10,0xbd3af235,/* 62 */

II,$c,$d,$a,$b,$_[6],15,0x2ad7d2bb,/* 63 */

 

{{out}}

</pre>

 

{{out}}

<pre>

0x57edf4a22be3c955ac49da2e2107b67a

</pre>

 

=={{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}}==

For an implementation of md5 in Racket see: github.com/racket/racket/blob/master/racket/collects/file/md5.rkt

#lang racket

(require file/md5)

(md5 #"Rosetta Code")

Output:

#"cca1bf66b09554e10f837838c3d3efb1"

 

=={{header|REXX}}==

This REXX program uses the test suite that is from the IETF RFC (1321) contained in the

@.1 = /*─────MD5 test suite [from above doc].*/

@.2 = 'a'

MD5: procedure; parse arg !; numeric digits 20 /*insure there's enough decimal digits.*/

a= '67452301'x; b= "efcdab89"x; c= '98badcfe'x; d= "10325476"x

/* [↓] a little of this, ··· */

$=! || "80"x || copies('0'x,plus%8-1)reverse(right(d2c(8*#), 4, '0'x)) || '00000000'x

/* [↑] ··· and a little of that.*/

do j=0 for length($) % 64 /*process the message (lots of steps).*/

do k=1 for 16 /*process the message in chunks. */

end /*k*/ /*────step────*/

a = .p1( a, b, c, d, 0, 7, 3614090360) /*■■■■ 1 ■■■■*/

return .a(.Lr(right(d2c(_+c2d(w) + c2d(.h(x,y,z)) + c2d(!.n)),4,'0'x),m),x)

.p4: procedure expose !.; parse arg w,x,y,z,n,m,_; n=n + 1

{{out|output|text=&nbsp; when using the default input:}}

<pre>

Based on my Java implementation. Uses free-form RPG and a CTDATA section to hold lookup tables. Converts input from EBCDIC to ASCII before hashing.

 

Ctl-opt MAIN(Main);

Ctl-opt DFTACTGRP(*NO) ACTGRP(*NEW);

1700485571 2399980690 4293915773 2240044497

1873313359 4264355552 2734768916 1309151649

 

Sample output:

DSPLY InputLen=26

DSPLY MD5: C3FCD3D76192E4007DFB496CCA67E13B</pre>

 

=={{header|Rust}}==

As with others implementations, this will not allow bit-lengths non-divisible by 8; this ability can be added in about 8 lines of code but no examples appear to be available for verification of correctness, and so it was elided.

 

#![allow(non_snake_case)] // RFC 1321 uses many capitalized variables

use std::mem;

assert!(md5_utf8("12345678901234567890123456789012345678901234567890123456789012345678901234567890") == "57edf4a22be3c955ac49da2e2107b67a");

}

 

=={{header|Scala}}==

 

 

 

}

 

 

 

=={{header|Seed7}}==

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

end for;

 

elsif index <= 32 then

f := c >< (d & (b >< c));

elsif index <= 48 then

f := b >< c >< d;

else

f := c >< (b | (bin32(16#ffffffff) >< d));

end if;

 

c0 +:= ord(c);

d0 +:= ord(d);

 

# Produce the final hash value:

end func;

 

writeln("There is an error in the md5 function");

end if;

 

Original source: [http://seed7.sourceforge.net/algorith/msgdigest.htm#md5]

 

=={{header|Sidef}}==

 

method init {

 

for i in (range(0, M.end, 16)) {

}

 

say "\tHowever, that is incorrect (expected: #{md5})"

}

{{out}}

<pre>

Original source: [//github.com/krzyzanowskim/CryptoSwift CryptoSwift]

 

import Foundation

public class MD5 {

}

}

 

From-scratch implementation based on the solutions on this page without needing any external libraries:

 

let shift : [UInt32] = [7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21]

println(toHexString(md5(Array(string.utf8))))

println()

{{out}}

<pre>

=={{header|Tcl}}==

<small>This code is extracted from the <code>md5</code> package in {{libheader|tcllib}}, and is originally due to Don Libes's transcription of the code in the MD5 specification. ''It should not be deployed in production normally; the <code>md5</code> package should be used in preference as it is usually built to be faster.</small>

# function calls for speed

variable ::md5::md5body {

format %0.2x%0.2x%0.2x%0.2x [byte0 $i] [byte1 $i] [byte2 $i] [byte3 $i]

}

Demonstration code:

0xd41d8cd98f00b204e9800998ecf8427e ==> ""

0x0cc175b9c0f1b6a831c399e269772661 ==> "a"

} {

puts "“$string” -> [md5::md5 $string] (officially: $hash)"

 

=={{header|x86 Assembly}}==

Uses DOS interrupts for display.

 

org 0x100

mov di, md5_for_display

test_input_6_len equ $ - test_input_6

test_input_7 db '12345678901234567890123456789012345678901234567890123456789012345678901234567890'

 

'''Output:'''