MD4: Difference between revisions

=={{header|Ada}}==

{{libheader|CryptAda}}

 

with CryptAda.Digests.Message_Digests.MD4;

Ada.Text_IO.Put_Line

("""" & Text & """: " & CryptAda.Utils.Format.To_Hex_String (Hashes.Get_Bytes (Hash)));

{{out}}

<pre>"Rosetta Code": A52BCFC6A0D0D300CDC5DDBFBEFE478B</pre>

=={{header|AutoHotkey}}==

Source: [https://github.com/jNizM/AutoHotkey_Scripts/tree/master/Functions/Checksums MD4 @github] by jNizM

MsgBox, % "String:`n" (str) "`n`nMD4:`n" MD4(str)

 

StrPut(string, &data, floor(length / chrlength), encoding)

return CalcAddrHash(&data, length, algid, hash, hashlength)

{{out}}

<pre>String: Rosetta Code

MD4: A52BCFC6A0D0D300CDC5DDBFBEFE478B</pre>

 

=={{header|C}}==

/*

*

setMD4Registers(0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476);

}

{{Out}}

<pre>a52bcfc6a0d0d300cdc5ddbfbefe478b</pre>

 

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

using System.Collections.Generic;

using System.Linq;

}

static void Main() { Console.WriteLine("Rosetta Code".Md4Hash()); }

{{out}}

<pre>a52bcfc6a0d0d300cdc5ddbfbefe478b</pre>

 

=={{header|Clojure}}==

{{libheader|pandect}}

 

{{Out}}

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

{{libheader|Ironclad}}

(defun md4 (str)

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

(ironclad:ascii-string-to-byte-array str))))

 

 

{{Out}}

A short but not efficient implementation.

{{trans|Ruby}}

 

ubyte[16] md4(const(ubyte)[] inData) pure nothrow {

void main() {

writefln("%(%02x%)", "Rosetta Code".representation.md4);

{{out}}

<pre>a52bcfc6a0d0d300cdc5ddbfbefe478b</pre>

{{libheader| DCPmd4}}

Thanks for David Barton for DCPcrypt v2.0 library, and StephenGenusa for store and share in github [https://github.com/StephenGenusa/DCPCrypt].

program CalcMD4;

 

Writeln(MD4('Rosetta Code'));

readln;

{{out}}

<pre>A52BCFC6A0D0D300CDC5DDBFBEFE478B</pre>

<code>md4.el</code> by Taro Kawagishi, originally from [http://git.chise.org/elisp/flim/ FLIM] and included in recent Emacs, is an Elisp implementation of the MD4 algorithm. Its <code>md4</code> function returns the checksum as 16 binary bytes. <code>encode-hex-string</code> from <code>hex-util.el</code> can convert that to a hex string if desired.

 

(let* ((s "Rosetta Code")

(m (md4 s (length s)))) ;; m = 16 binary bytes

(encode-hex-string m))

=>

 

=={{header|Erlang}}==

-module(md4).

-export([md4/0]).

<<MD4:128>> = crypto:md4("Rosetta Code"),

io:fwrite("Rosetta Code => ~.16B~n",[MD4]).

<pre>

Rosetta Code => A52BCFC6A0D0D300CDC5DDBFBEFE478B

</pre>

 

=={{header|Go}}==

{{libheader|Go sub-repositories}}

 

import (

h.Write([]byte("Rosetta Code"))

fmt.Printf("%x\n", h.Sum(nil))

{{out}}

<pre>

=={{header|Haskell}}==

{{libheader|Cryptonite}}

 

import Data.ByteString.Char8 (pack)

main :: IO ()

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

{{out}}

<pre>

 

=={{header|J}}==

gethash_jqtide_ 'MD4';'Rosetta Code'

 

=={{header|Java}}==

{{libheader|BouncyCastle}}

import org.bouncycastle.util.encoders.Hex;

 

System.out.println();

}

{{out}}

<pre>

a52bcfc6a0d0d300cdc5ddbfbefe478b

 

=={{header|JavaScript}}==

 

const hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */

 

const md4 = md4func();

{{out}}

<pre>a52bcfc6a0d0d300cdc5ddbfbefe478b</pre>

=={{header|Julia}}==

[https://github.com/staticfloat/Nettle.jl Nettle.jl] provides a variety of cryptographic functions including the <tt>MD4</tt> hash.

using Nettle

 

 

println("\"", msg, "\" => ", h)

 

{{out}}

=={{header|Kotlin}}==

This is a translation of the Java code [http://www.java2s.com/Code/Java/Security/ImplementstheMD4messagedigestalgorithminJava.htm here]. In the interests of conciseness, I have removed the comments from the Kotlin version:

 

import java.security.MessageDigest

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

println()

 

{{out}}

 

=={{header|Lasso}}==

{{out}}

<pre> A52BCFC6A0D0D300CDC5DDBFBEFE478B </pre>

{{libheader|LuaCrypto}} ([http://mkottman.github.io/luacrypto/ luarocks install LuaCrypto])

 

 

require "crypto"

 

 

{{out}}

 

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

<pre>a52bcfc6a0d0d300cdc5ddbfbefe478b</pre>

 

=={{header|Nim}}==

{{libheader|OpenSSL}}

 

const MD4Len = 16

result.add s[i].BiggestInt.toHex(2).toLower

 

 

{{out}}

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

 

#include <openssl/md4.h>

 

 

return strtoGENstr(hash);

 

Compile with: gcc -Wall -O2 -fPIC -shared md4.c -o libmd4.so -lcrypt -lpari

 

Load plugin from your home directory into PARI:

 

 

Output: "a52bcfc6a0d0d300cdc5ddbfbefe478b"

=={{header|Perl}}==

In-lining code from module [https://metacpan.org/pod/Digest::Perl::MD4 Digest::Perl::MD4], lightly edited for clarity.

my @input = grep { defined && length > 0 } split /(.{64})/s, join '', @_;

push @input, '' if !@input || length($input[$#input]) >= 56;

}

 

unpack 'H*', &md4;

}

 

{{out}}

<pre>Rosetta Code => a52bcfc6a0d0d300cdc5ddbfbefe478b</pre>

{{trans|D}}

{{trans|Ruby}}

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\md4.exw

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

 

=={{header|PHP}}==

echo hash('md4', "Rosetta Code"), "\n";

{{out}}

<pre>a52bcfc6a0d0d300cdc5ddbfbefe478b</pre>

=={{header|PicoLisp}}==

Library and implementation.

(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

1 5 9 13 2 6 10 14 3 7 11 15 4 8 12 16

'(NIL (16)) ) ) ) ) )

 

 

=={{header|Python}}==

Use 'hashlib' from python's standard library.

{{libheader|hashlib}}

 

=={{header|Racket}}==

#lang racket

(require (planet soegaard/digest:1:2/digest))

(md4 #"Rosetta Code")

{{out}}

<pre>

=={{header|Raku}}==

(formerly Perl 6)

 

 

}

}

{{out}}

 

=={{header|Ruby}}==

Use 'openssl' from Ruby's standard library.

{{libheader|OpenSSL}}

 

Implement MD4 in Ruby.

 

 

# Calculates MD4 message digest of _string_. Returns binary digest.

str = 'Rosetta Code'

printf "%s:\n %s\n", str, *md4(str).unpack('H*')

{{out}}

<pre>Rosetta Code:

 

=={{header|Rust}}==

//

// https://www.ietf.org/rfc/rfc1186.txt

let val = "Rosetta Code";

println!("md4(\"{}\") = {}", val, digest_to_str(&md4(val)));

 

{{out}}

=={{header|Scala}}==

{{libheader|Scala}}

 

object RosettaRIPEMD160 extends App {

import scala.compat.Platform.currentTime

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

 

=={{header|Seed7}}==

include "msgdigest.s7i";

 

begin

writeln(hex(md4("Rosetta Code")));

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

{{out}}

<pre>

=={{header|Tcl}}==

{{tcllib|md4}}

 

# Use -hex option for hexadecimal output instead of binary

{{out}}

<pre>A52BCFC6A0D0D300CDC5DDBFBEFE478B</pre>

{{trans|D}}

{{libheader|Wren-fmt}}

 

var toBytes = Fn.new { |val|

var digest = md4.call(s)

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

 

{{out}}