MD5: Difference between revisions

 

=={{header|8th}}==

"md5" cr:hash! "Some text" cr:hash cr:hash>s

. cr bye

{{out}}

<tt>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program MD5_64.s */

.include "../includeARM64.inc"

 

<pre>

Result for => D41D8CD98F00B204E9800998ECF8427E

=={{header|Ada}}==

{{works with|GNAT}}

with GNAT.MD5;

 

begin

Put(GNAT.MD5.Digest("Foo bar baz"));

 

=={{header|ALGOL 68}}==

 

# Based on wikipedia article pseudocode #

print (("failed"))

FI

 

=={{header|APL}}==

{{works with|Dyalog APL}}

md5←{

⍝ index origin zero

(⎕D,⎕A)[,⍉(2⍴16)⊤,⍉⊖(4⍴256)⊤M loop A B C D]

}

 

=={{header|Arturo}}==

 

 

{{out}}

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI */

/* program MD5.s */

/***************************************************/

.include "../affichage.inc"

<pre>

Result for abc => 900150983CD24FB0D6963F7D28E17F72

===Regular version===

Source: [http://www.autohotkey.com/forum/post-275910.html#275910 AutoHotkey forum] by SKAN

MsgBox % MD5(data,StrLen(data)) ; 900150983cd24fb0d6963f7d28e17f72

 

Return MD5

}

 

===Native implementation===

Source: [http://www.autohotkey.com/forum/topic17853.html AutoHotkey forum] by Laszlo

r = 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

SetFormat Integer, DECIMAL

Return x

 

=={{header|BaCon}}==

PRAGMA INCLUDE <stdio.h>

PRAGMA INCLUDE <stdlib.h>

FOR i = 0 TO MD5_DIGEST_LENGTH-1

PRINT result[i] FORMAT "%02x"

 

 

=={{header|BASIC256}}==

print MD5("a")

print MD5("abc")

print MD5("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")

print MD5("12345678901234567890123456789012345678901234567890123456789012345678901234567890")

{{out}}

<pre>d41d8cd98f00b204e9800998ecf8427e

{{works with|BBC BASIC for Windows}}

See [[MD5/Implementation]] for a native version.

PRINT FN_MD5("a")

PRINT FN_MD5("abc")

MD5$ += RIGHT$("0"+STR$~(MD5_CTX.digest&(I%)),2)

NEXT

 

=={{header|C}}==

{{libheader|OpenSSL}}

#include <stdlib.h>

#include <string.h>

 

return EXIT_SUCCESS;

Implementation of md5

(Needs review - differences observed for the last 8 characters when compared with openssl implementation)

#include <stdio.h>

#include <string.h>

 

return 0;

 

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

using System.Security.Cryptography;

 

byte[] data = Encoding.ASCII.GetBytes("The quick brown fox jumped over the lazy dog's back");

byte[] hash = MD5.Create().ComputeHash(data);

 

=={{header|C++}}==

{{libheader|Poco Crypto}}

#include <iostream>

#include "Poco/MD5Engine.h"

<< " !" << std::endl ;

return 0 ;

{{out}}

<pre>The quick brown fox jumped over the lazy dog's back as a MD5 digest :

 

=={{header|Clojure}}==

(map (partial format "%02x")

(.digest (doto (java.security.MessageDigest/getInstance "MD5")

.reset

 

=={{header|COBOL}}==

IDENTIFICATION DIVISION.

PROGRAM-ID. MD5.

CLOSE Tmp-MD5.

CALL "CBL_DELETE_FILE" USING '/tmp/MD5'.

IDENTIFICATION DIVISION.

 

END FUNCTION MD5.

{{Out}}

<pre>

=={{header|Common Lisp}}==

{{libheader|Ironclad}}

(defun md5 (str)

(ironclad:byte-array-to-hex-string

(dolist (msg *tests*)

(format T "~s: ~a~%" msg (md5 msg)))

 

{{Out}}

 

<h5>Another method using openssl:</h5> {{libheader|CFFI}}

 

(cffi:defcfun ("MD5" MD5) :void (string :string) (len :int) (ptr :pointer))

(loop for i from 0 below 16 do

(format t "~a" (write-to-string (cffi:mem-ref ptr :unsigned-char i) :base 16)))

 

{{Out}}<pre>E38CA1D920C4B8B8D3946B2C72F01680</pre>

 

=={{header|Crystal}}==

 

{{Out}}<pre>e38ca1d920c4b8b8d3946b2c72f01680</pre>

 

=={{header|D}}==

import std.stdio, std.digest.md;

 

auto txt = "The quick brown fox jumped over the lazy dog's back";

writefln("%-(%02x%)", txt.md5Of);

{{out}}

<pre>e38ca1d920c4b8b8d3946b2c72f01680</pre>

Alternative version:

{{libheader|Tango}}

 

void main(char[][] args) {

Stdout.formatln("[{}]=>\n[{}]", args[i], md5.hexDigest());

}

Output:

<pre>>md5test "The quick brown fox jumped over the lazy dog's back"

=={{header|Delphi}}==

If you require a native implementation, look inside the class '''TIdHashMessageDigest5'''. This class is placed in the unit '''IdHashMessageDigest.pas'''.

 

{$APPTYPE CONSOLE}

Writeln(MD5('12345678901234567890123456789012345678901234567890123456789012345678901234567890'));

Readln;

'''Output:'''

<pre>

{{works with|E-on-Java}}

{{trans|Java}} (with modifications)

def sprintf := <import:java.lang.makeString>.format

 

print(sprintf("%02x", [b]))

}

 

=={{header|Emacs Lisp}}==

 

 

=={{header|Erlang}}==

By default, Erlang's crypto functions like md5 return a binary value rather than a hex string. We have two write our own function to translate it:

-export([md5/1]).

 

string:to_upper(

lists:flatten([io_lib:format("~2.16.0b",[N]) || <<N>> <= erlang:md5(S)])

Testing it:

{ok,tests}

2> tests:md5("The quick brown fox jumped over the lazy dog's back").

 

=={{header|F_Sharp|F#}}==

Using built-in System.Security.Cryptography.MD5 class (Link to original blog [https://znprojects.blogspot.com/2017/04/md5-in-f-functionally.html]).

 

use md5 = System.Security.Cryptography.MD5.Create()

msg

|> Seq.reduce ( + )

 

 

=={{header|Factor}}==

=={{header|Forth}}==

{{libheader|Forth Foundation Library}}

 

\ Create a MD5 variable md1 in the dictionary

\ Convert the hash value to a hex string and print it

 

=={{header|Fortran}}==

Using Windows API. See [https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta CryptAcquireContextA], [https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptcreatehash CryptCreateHash], [https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-crypthashdata CryptHashData] and [https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptgethashparam CryptGetHashParam] in Microsoft documentation.

 

use kernel32

use advapi32

deallocate(name)

end do

 

=={{header|FreeBASIC}}==

=={{header|Frink}}==

The function <CODE>messageDigest[string, hash]</CODE> returns a hex-encoded hash of any input string with a variety of hashing functions.

 

=={{header|Futhark}}==

Real languages roll their own crypto.

 

type md5 = (u32, u32, u32, u32)

 

in (d, b + rotate_left(a + f + (ks())[i] + m[g], (rs())[i]), b, c)

in (a,b,c,d)

 

=={{header|Go}}==

 

import (

fmt.Println(" got: ", sum)

}

 

=={{header|Groovy}}==

 

String.metaClass.md5Checksum = {

MessageDigest.getInstance('md5').digest(delegate.bytes).collect { String.format("%02x", it) }.join('')

Testing

 

=={{header|Haskell}}==

Use modules nano-MD5 and ByteString from [http://hackage.haskell.org/packages/hackage.html HackageDB]

import Data.ByteString (pack)

import Data.Char (ord)

let message = "The quick brown fox jumped over the lazy dog's back"

digest = (md5sum . pack . map (fromIntegral . ord)) message

 

Use in GHCi:

This version uses the [https://hackage.haskell.org/package/cryptonite Cryptonite] package:

{{libheader|Cryptonite}}

 

import Data.ByteString.Char8 (pack)

main :: IO ()

main = print . md5 . pack . unwords =<< getArgs

{{out}}

<pre>

 

=={{header|Haxe}}==

 

class Main {

Sys.println(md5);

}

 

{{out}}

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

The following program demonstrates the MD5 using a native Icon/Unicon implementation (see [[MD5/Implementation]]) and checks the results against reference values. Alternate implementations using call outs to md5sum on Linux or fciv on windows are possible but were not coded.

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

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

write("Message(length=",*s,") = ",image(s))

write("Digest = ",hexstring(h := MD5(s)),if h = rh then " matches reference hash" else (" does not match reference hash = " || hexstring(rh)),"\n")

 

Sample Output:<pre>Message(length=43) = "The quick brown fox jumps over the lazy dog"

 

=={{header|Io}}==

==> MD5_0x97663e0:

appendSeq = MD5_appendSeq()

md5String = MD5_md5String()

Io> MD5 clone appendSeq("The quick brown fox jumped over the lazy dog's back") md5String

 

=={{header|J}}==

Using the <tt>[https://github.com/jsoftware/convert_misc/blob/master/md5.ijs md5]</tt> script from the <tt>convert/misc</tt> addon package:

md5 'The quick brown fox jumped over the lazy dog''s back'

 

Implementation here, in case the link to the script goes dead again:

 

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

end.

hexlist r

 

An alternative and faster approach is to use the Qt library function available using the <tt>ide/qt</tt> addon from J8:

getmd5=: 'md5'&gethash_jqtide_

getmd5 'The quick brown fox jumped over the lazy dog''s back'

 

=={{header|Java}}==

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

}

}

 

Other options for digest algorithms (to replace "MD5" in the example above) include: MD2, SHA-1, SHA-256, SHA-384, and SHA-512.

 

=={{header|Jsish}}==

var str = 'Rosetta code';

puts(Util.hash(str, {type:'md5'}));

MD5('12345678901234567890123456789012345678901234567890123456789012345678901234567890') ==> 57edf4a22be3c955ac49da2e2107b67a

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

 

 

function Base.trunc(s::AbstractString, n::Integer)

println("* The sum should be ", h)

end

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.security.MessageDigest

for (byte in digest) print("%02x".format(byte))

println()

 

{{out}}

 

=={{header|Lasso}}==

 

===Test suite===

'a' = '0cc175b9c0f1b6a831c399e269772661',

'abc' = '900150983cd24fb0d6963f7d28e17f72',

with a in #test->keys do => {^

'testing: "'+#a+'": '+(Encrypt_MD5(#a)->asBytes == #test->find(#a)->asBytes)+'\r'

{{out}}

<pre>testing: "12345678901234567890123456789012345678901234567890123456789012345678901234567890": true

 

=={{header|Liberty BASIC}}==

'from tsh73's January 2008 code

 

a$=left$("00000000", 8-len(a$))+a$

revOrd$ = lower$(mid$(a$,7,2)+mid$(a$,5,2)+mid$(a$,3,2)+mid$(a$,1,2))

 

=={{header|Lingo}}==

*Using a binary plugin ("Xtra"):

{{libheader|Crypto Xtra}}

 

*Pure Lingo implementation

-- Calculates MD5 hash of string or bytearray

-- @param {bytearray|string} input

ba.position = 1

return ba

 

=={{header|LiveCode}}==

Livecode has built-in support for md4 and md5

local md5, mdhex

put md5Digest(hashtext) into md5

get binaryDecode("H*",md5,mdhex)

return mdhex

 

// rfc1321 MD5 test suite:

local md5

end repeat

put results

Output

<pre>ok abc

=={{header|Lua}}==

Using the [http://www.keplerproject.org/md5/ Kepler MD5 library]:

 

--printing a sum:

test("abcdefghijklmnopqrstuvwxyz","c3fcd3d76192e4007dfb496cca67e13b")

test("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789","d174ab98d277d9f5a5611c2c9f419d9f")

 

=={{header|Maple}}==

The <tt>Hash</tt> command in the <tt>StringTools</tt> package computes the MD5 hash value of a string.

> with( StringTools ):

> Hash( "" );

> Hash( "12345678901234567890123456789012345678901234567890123456789012345678901234567890" );

"57edf4a22be3c955ac49da2e2107b67a"

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Mathematica has built-in functions Hash and FileHash.

Example:

gives back:

 

=={{header|MATLAB}}==

This code also works with Octave (but Octave already provides md5sum(), see [[{{FULLPAGENAME}}#Octave|Octave example]]).

 

% digest = md5(message)

% Compute the MD5 digest of the message, as a hexadecimal digest.

digest = dec2hex(digest);

digest = reshape(transpose(digest), 1, numel(digest));

 

Sample Usage:

 

=={{header|min}}==

{{works with|min|0.19.6}}

 

=={{header|MOO}}==

 

=={{header|Neko}}==

MD5 in Neko

Tectonics:

 

/* Output in lowercase hex */

 

{{out}}

=={{header|Nemerle}}==

{{trans|C#}}

using System.Console;

using System.Text;

Write($"$(IsValidMD5(test.Key, test.Value)) ");

}

Output:

<pre>True True True True True True True True</pre>

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols binary

return digestSum

'''Output:'''

<pre>

 

=={{header|NewLISP}}==

;; (import native functions from the crypto library, provided by OpenSSL)

(module "crypto.lsp")

 

=={{header|Nim}}==

 

 

{{out}}

=={{header|Oberon-2}}==

{{works with|oo2c}}{{libheader|crypto}}

MODULE MD5;

IMPORT

Out.String("MD5: ");Utils.PrintHex(str,0,h.size);Out.Ln

END MD5.

{{out}}

<pre>

 

=={{header|Objeck}}==

class MD5 {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|Objective-C}}==

{{works with|GNUstep}} only; not Cocoa

NSData *digest = [[myString dataUsingEncoding:NSUTF8StringEncoding] md5Digest]; // or another encoding of your choosing

 

{{works with|iPhone}}

{{works with|Mac OS X}}

 

NSString *myString = @"The quick brown fox jumped over the lazy dog's back";

}

NSLog(@"%@", hex);

 

{{works with|Mac OS X}} (need to include "libcrypto.dylib" framework)

 

NSString *myString = @"The quick brown fox jumped over the lazy dog's back";

}

NSLog(@"%@", hex);

 

=={{header|OCaml}}==

 

=={{header|Octave}}==

hash = md5sum(s, true);

 

For an implementation of MD5, see [[{{FULLPAGENAME}}#MATLAB|MATLAB example]].

 

=={{header|Ol}}==

(import (otus ffi))

(define libcrypto (load-dynamic-library "libcrypto.so.1.0.0"))

(define MD5 (libcrypto type-vptr "MD5" type-string fft-unsigned-long type-string))

{{Out}}

(define (test str)

(define md5 "----------------")

(test "abcdefghijklmnopqrstuvwxyz")

(test "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")

 

<pre>

=={{header|OpenEdge/Progress}}==

The MD5-DIGEST function is readily available, the output is passed thru HEX-ENCODE to convert the raw result to a hexadecimal string, this then needs to be passed thru STRING for display purposes.

1 STRING( HEX-ENCODE( MD5-DIGEST( "" ) ) ) SKIP

2 STRING( HEX-ENCODE( MD5-DIGEST( "a" ) ) ) SKIP

6 STRING( HEX-ENCODE( MD5-DIGEST( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" ) ) ) SKIP

7 STRING( HEX-ENCODE( MD5-DIGEST( "12345678901234567890123456789012345678901234567890123456789012345678901234567890" ) ) )

 

Output:

 

Build a MD5 plugin using Linux system library and PARI's function interface. (Linux solution)

#include <openssl/md5.h>

 

 

return strtoGENstr(hash);

 

Compile with: gcc -Wall -O2 -fPIC -shared md5.c -o libmd5.so -lcrypt -lpari

 

Load plugin from your home directory into PARI:

 

 

Output:

 

Here is an explicit implementation in the PARI/GP language:

a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476,

s = [ 7, 12, 17, 22; 5, 9, 14, 20; 4, 11, 16, 23; 6, 10, 15, 21 ],

); \\ end forstep

Strprintf("%032x",fromdigits(Vecrev(digits(fromdigits([d,c,b,a],2^32),256),16),256))

Then:

<pre>

%2 = "d41d8cd98f00b204e9800998ecf8427e"

</pre>

<pre>

%3 = "4c57070257998981a0c7b7ec003b9d5c"

==Pascal==

Pascal has a built-in unit called md5. It can be used to get a digest both for a string and a file.

program GetMd5;

 

writeln(strEncrypted);

end.

 

{{out}}

=={{header|Perl}}==

{{libheader|Digest::MD5}}

 

 

The same in OO manner

 

$md5 = Digest::MD5->new;

$md5->add("The quick brown fox jumped over the lazy dog's back");

 

=={{header|Phix}}==

 

=={{header|PHP}}==

 

=={{header|PicoLisp}}==

Using the openssl library (the 'native' function is only in the 64-bit

version available):

(pack

(mapcar '((B) (pad 2 (hex B)))

Output:

<pre>-> "E38CA1D920C4B8B8D3946B2C72F01680"</pre>

 

=={{header|Pike}}==

import Crypto.MD5;

 

int main(){

write( string2hex( hash( "The quick brown fox jumped over the lazy dog's back" ) ) + "\n" );

 

=={{header|PowerShell}}==

{{trans|C#}}

$data = [Text.Encoding]::UTF8.GetBytes($string)

$hash = [Security.Cryptography.MD5]::Create().ComputeHash($data)

 

=={{header|PureBasic}}==

;Purebasic 5.x versions:

 

test$ = "The quick brown fox jumped over the lazy dog's back"

; Call StringFingerprint() function and display MD5 result in Debug window

Debug StringFingerprint(test$, #PB_Cipher_MD5)

 

=={{header|Python}}==

 

;Python 3.x, 2.5 and later 2.x versions:

>>> # RFC 1321 test suite:

>>> tests = (

>>> for text, golden in tests: assert hashlib.md5(text).hexdigest() == golden

 

 

;Python 2.5 and later:

>>> print hashlib.md5("The quick brown fox jumped over the lazy dog's back").hexdigest()

 

;Pre-2.5; removed in 3.x:

>>> print md5.md5("The quick brown fox jumped over the lazy dog's back").hexdigest()

 

=={{header|R}}==

hexdigest <- digest("The quick brown fox jumped over the lazy dog's back",

 

=={{header|Racket}}==

#lang racket

(require file/md5)

(md5 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")

(md5 "12345678901234567890123456789012345678901234567890123456789012345678901234567890")

 

Output:

(formerly Perl 6)

Library [http://github.com/cosimo/perl6-digest-md5/ Digest::MD5]

 

=={{header|REBOL}}==

 

=={{header|REXX}}==

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

msg.2 = 'a'

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

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

'''output''' &nbsp; when using the default (internal) inputs:

<pre>

 

=={{header|Ring}}==

See MD5("my string!") + nl

# output : a83a049fbe50cf7334caa86bf16a3520

 

=={{header|RLaB}}==

calculated in RLaB is the same as the hash of the same string vector written to a file.

 

The quick brown fox jumped over the lazy dog's back

 

>> hash("md5", x)

 

=={{header|RPG}}==

Modified from [http://www.mysamplecode.com/2011/05/rpgle-generate-sha-1-hash-use.html]:

Ctl-opt MAIN(Main);

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

endfor;

return;

Note that this implementation converts the input from EBCDIC to ASCII before computing the hash.

 

 

=={{header|Ruby}}==

Digest::MD5.hexdigest("The quick brown fox jumped over the lazy dog's back")

 

=={{header|Rust}}==

Cargo.toml

[dependencies]

rust-crypto = "0.2"

 

src/main.rs

extern crate crypto;

 

println!("{}", sh.result_str());

}

 

=={{header|S-lang}}==

Support for MD5 and SHA-1 are included in the standard "chksum" library:

 

 

{{out}}

 

=={{header|Scala}}==

 

def MD5(s: String): String = {

import scala.compat.Platform.currentTime

println(s"Successfully completed without errors. [total ${currentTime - executionStart} ms]")

 

=={{header|Seed7}}==

include "msgdigest.s7i";

 

begin

writeln(hex(md5("The quick brown fox jumped over the lazy dog's back")));

 

{{out}}

=={{header|Sidef}}==

{{libheader|Digest::MD5}}

 

The same in OO manner

md5.add("The quick brown fox jumped over the lazy dog's back");

 

=={{header|Slate}}==

You must load the code in 'src/lib/md5.slate'.

 

=={{header|Smalltalk}}==

 

{{works with|GNU Smalltalk}}

 

{{works with|Smalltalk/X}}

 

=={{header|SQL}}==

{{works with|MySQL}}

 

=={{header|Suneido}}==

 

=={{header|Tcl}}==

{{tcllib|md5}}

puts [md5::md5 -hex "The quick brown fox jumped over the lazy dog's back"]

 

=={{header|UNIX Shell}}==

 

[[GNU]] coreutils has ''md5sum'':

 

Several [[BSD]] systems have ''md5:''

 

{{libheader|OpenSSL}}

 

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|9.0+}}

Imports System.Text

 

 

End Module

 

{{out}}

</pre>

 

fn main() {

println('MD5 succeeded $s')

}

{{out}}

<pre>MD5 succeeded

{{libheader|Wren-fmt}}

This script uses a library implementation of MD5 (based on the implementation in the [[MD5/Implementation#Wren]] task) to process the Wikipedia examples.

 

var strings = [

var digest = Md5.digest(s)

Fmt.print("$s <== '$0s'", digest, s)

 

{{out}}

=={{header|zkl}}==

md5 is a built in utility