Data update

Task/MD4/Ada/md4.adb

@@ -0,0 +1,34 @@
+with Ada.Text_IO;
+
+with CryptAda.Digests.Message_Digests.MD4;
+with CryptAda.Digests.Hashes;
+with CryptAda.Pragmatics;
+with CryptAda.Utils.Format;
+
+procedure RC_MD4 is
+   use CryptAda.Digests.Message_Digests;
+   use CryptAda.Digests;
+   use CryptAda.Pragmatics;
+
+   function To_Byte_Array (Item : String) return Byte_Array is
+      Result : Byte_Array (Item'Range);
+   begin
+      for I in Result'Range loop
+         Result (I) := Byte (Character'Pos (Item (I)));
+      end loop;
+      return Result;
+   end To_Byte_Array;
+
+   Text    : constant String                := "Rosetta Code";
+   Bytes   : constant Byte_Array            := To_Byte_Array (Text);
+   Handle  : constant Message_Digest_Handle := MD4.Get_Message_Digest_Handle;
+   Pointer : constant Message_Digest_Ptr    := Get_Message_Digest_Ptr (Handle);
+   Hash    : Hashes.Hash;
+begin
+   Digest_Start  (Pointer);
+   Digest_Update (Pointer, Bytes);
+   Digest_End    (Pointer, Hash);
+
+   Ada.Text_IO.Put_Line
+     ("""" & Text & """: " & CryptAda.Utils.Format.To_Hex_String (Hashes.Get_Bytes (Hash)));
+end RC_MD4;

Task/MD4/EasyLang/md4.easy

@@ -0,0 +1,128 @@
+func u32 x .
+   return bitand x 0xFFFFFFFF
+.
+func rol x s .
+   left = u32 bitshift x s
+   right = bitshift u32 x -(32 - s)
+   return bitor left right
+.
+func F x y z .
+   return bitor (bitand x y) (bitand bitnot x z)
+.
+func G x y z .
+   return bitor (bitor (bitand x y) (bitand x z)) (bitand y z)
+.
+func H x y z .
+   return bitxor (bitxor x y) z
+.
+func le32 b0 b1 b2 b3 .
+   return b0 + 256 * b1 + 65536 * b2 + 65536 * 256 * b3
+.
+func$ word2hex w .
+   for k = 0 to 3
+      h = w mod 256
+      for c in [ h div 16 h mod 16 ]
+         c += 48
+         if c >= 58 : c += 39
+         hex$ &= strchar c
+      .
+      w = w div 256
+   .
+   return hex$
+.
+func[] str2bytes s$ .
+   for ch$ in strchars s$ : out[] &= strcode ch$
+   return out[]
+.
+proc md4pad &data[] .
+   len8 = len data[] * 8
+   data[] &= 0x80
+   while len data[] mod 64 <> 56 : data[] &= 0x00
+   for i = 1 to 8
+      data[] &= len8 mod 256
+      len8 = len8 div 256
+   .
+.
+proc md4block &A &B &C &D blk[] .
+   for i = 0 to 15
+      b0 = blk[i * 4 + 1]
+      b1 = blk[i * 4 + 2]
+      b2 = blk[i * 4 + 3]
+      b3 = blk[i * 4 + 4]
+      x[] &= le32 b0 b1 b2 b3
+   .
+   a = A ; b = B ; c = C ; d = D
+   #
+   a = rol (a + F b c d + x[1]) 3
+   d = rol (d + F a b c + x[2]) 7
+   c = rol (c + F d a b + x[3]) 11
+   b = rol (b + F c d a + x[4]) 19
+   a = rol (a + F b c d + x[5]) 3
+   d = rol (d + F a b c + x[6]) 7
+   c = rol (c + F d a b + x[7]) 11
+   b = rol (b + F c d a + x[8]) 19
+   a = rol (a + F b c d + x[9]) 3
+   d = rol (d + F a b c + x[10]) 7
+   c = rol (c + F d a b + x[11]) 11
+   b = rol (b + F c d a + x[12]) 19
+   a = rol (a + F b c d + x[13]) 3
+   d = rol (d + F a b c + x[14]) 7
+   c = rol (c + F d a b + x[15]) 11
+   b = rol (b + F c d a + x[16]) 19
+   #
+   K2 = 0x5A827999
+   a = rol (a + G b c d + x[1] + K2) 3
+   d = rol (d + G a b c + x[5] + K2) 5
+   c = rol (c + G d a b + x[9] + K2) 9
+   b = rol (b + G c d a + x[13] + K2) 13
+   a = rol (a + G b c d + x[2] + K2) 3
+   d = rol (d + G a b c + x[6] + K2) 5
+   c = rol (c + G d a b + x[10] + K2) 9
+   b = rol (b + G c d a + x[14] + K2) 13
+   a = rol (a + G b c d + x[3] + K2) 3
+   d = rol (d + G a b c + x[7] + K2) 5
+   c = rol (c + G d a b + x[11] + K2) 9
+   b = rol (b + G c d a + x[15] + K2) 13
+   a = rol (a + G b c d + x[4] + K2) 3
+   d = rol (d + G a b c + x[8] + K2) 5
+   c = rol (c + G d a b + x[12] + K2) 9
+   b = rol (b + G c d a + x[16] + K2) 13
+   #
+   K3 = 0x6ED9EBA1
+   a = rol (a + H b c d + x[1] + K3) 3
+   d = rol (d + H a b c + x[9] + K3) 9
+   c = rol (c + H d a b + x[5] + K3) 11
+   b = rol (b + H c d a + x[13] + K3) 15
+   a = rol (a + H b c d + x[3] + K3) 3
+   d = rol (d + H a b c + x[11] + K3) 9
+   c = rol (c + H d a b + x[7] + K3) 11
+   b = rol (b + H c d a + x[15] + K3) 15
+   a = rol (a + H b c d + x[2] + K3) 3
+   d = rol (d + H a b c + x[10] + K3) 9
+   c = rol (c + H d a b + x[6] + K3) 11
+   b = rol (b + H c d a + x[14] + K3) 15
+   a = rol (a + H b c d + x[4] + K3) 3
+   d = rol (d + H a b c + x[12] + K3) 9
+   c = rol (c + H d a b + x[8] + K3) 11
+   b = rol (b + H c d a + x[16] + K3) 15
+   A = u32 (A + a)
+   B = u32 (B + b)
+   C = u32 (C + c)
+   D = u32 (D + d)
+.
+func$ md4 s$ .
+   A = 0x67452301
+   B = 0xEFCDAB89
+   C = 0x98BADCFE
+   D = 0x10325476
+   data[] = str2bytes s$
+   md4pad data[]
+   for b = 0 to len data[] / 64 - 1
+      blk[] = [ ]
+      for i = 1 to 64 : blk[] &= data[b * 64 + i]
+      md4block A B C D blk[]
+   .
+   digest$ = word2hex A & word2hex B & word2hex C & word2hex D
+   return digest$
+.
+print md4 "Rosetta Code"

Task/MD4/Emacs-Lisp/md4.el

@@ -0,0 +1,7 @@
+(require 'md4)
+(require 'hex-util)
+(let* ((s  "Rosetta Code")
+       (m  (md4 s (length s)))) ;; m = 16 binary bytes
+  (encode-hex-string m))
+=>
+"a52bcfc6a0d0d300cdc5ddbfbefe478b"

Task/MD4/Pluto/md4.pluto

@@ -0,0 +1,108 @@
+require "table2"
+
+local function to_bytes(val)
+    local bytes = {0, 0, 0, 0}
+    bytes[1] = val         & 255
+    bytes[2] = (val >> 8)  & 255
+    bytes[3] = (val >> 16) & 255
+    bytes[4] = (val >> 24) & 255
+    return bytes
+end
+
+local function to_int(bytes)
+    return bytes[1] | bytes[2] << 8 | bytes[3] << 16 | bytes[4] << 24
+end
+
+local mask32 = 0xffffffff
+
+local function md4(initmsg)
+    local f = |x, y, z| -> do
+        x, y, z = x & mask32, y & mask32, z & mask32
+        return (x & y) | (~x & z)
+    end
+    local g = |x, y, z| -> do
+        x, y, z = x & mask32, y & mask32, z & mask32
+        return (x & y) | (x & z) | (y & z)
+    end
+    local h = |x, y, z| -> do
+        x, y, z = x & mask32, y & mask32, z & mask32
+        return x ~ y ~ z
+    end
+    local r = |v, s|    -> do
+        v = v & mask32
+        return ((v << s) & mask32) | (v >> (32 - s))
+    end
+    local a = 0x67452301
+    local b = 0xefcdab89
+    local c = 0x98badcfe
+    local d = 0x10325476
+    local initbytes = {string.byte(initmsg, 1, -1)}
+    local initlen = #initbytes
+    local newlen = initlen + 1
+    while newlen % 64 != 56 do newlen += 1 end
+    local msg = table.rep(newlen + 8, 0)
+    for i = 1, initlen do msg[i] = initbytes[i] end
+    msg[initlen + 1] = 0x80  -- remaining bytes already 0
+    local lenbits = to_bytes(initlen * 8)
+    for i = newlen + 1, newlen + 4 do msg[i] = lenbits[i - newlen] end
+    local extrabits = to_bytes(initlen >> 29)
+    for i = newlen + 5, newlen + 8 do msg[i] = extrabits[i - newlen - 4] end
+    local offset = 0
+    local x = table.rep(16, 0)
+    while offset < newlen do
+        for i = 0, 15 do x[i + 1] = to_int(msg:slice(offset + i * 4 + 1, offset + i * 4 + 4)) end
+        local a2 = a
+        local b2 = b
+        local c2 = c
+        local d2 = d
+        for {0, 4, 8, 12} as i do
+            a = r(a + f(b, c, d) + x[i + 1],  3)
+            d = r(d + f(a, b, c) + x[i + 2],  7)
+            c = r(c + f(d, a, b) + x[i + 3], 11)
+            b = r(b + f(c, d, a) + x[i + 4], 19)
+        end
+        for i = 0, 3 do
+            a = r(a + g(b, c, d) + x[i + 1]  + 0x5a827999,  3)
+            d = r(d + g(a, b, c) + x[i + 5]  + 0x5a827999,  5)
+            c = r(c + g(d, a, b) + x[i + 9]  + 0x5a827999,  9)
+            b = r(b + g(c, d, a) + x[i + 13] + 0x5a827999, 13)
+        end
+        for {0, 2, 1, 3} as i do
+            a = r(a + h(b, c, d) + x[i + 1]  + 0x6ed9eba1,  3)
+            d = r(d + h(a, b, c) + x[i + 9]  + 0x6ed9eba1,  9)
+            c = r(c + h(d, a, b) + x[i + 5]  + 0x6ed9eba1, 11)
+            b = r(b + h(c, d, a) + x[i + 13] + 0x6ed9eba1, 15)
+        end
+        a += a2
+        b += b2
+        c += c2
+        d += d2
+        offset += 64
+    end
+    local digest = table.rep(16, 0)
+    local dbytes = to_bytes(a)
+    for i = 1, 4 do digest[i] = dbytes[i] end
+    dbytes = to_bytes(b)
+    for i = 1, 4 do digest[i + 4] = dbytes[i] end
+    dbytes = to_bytes(c)
+    for i = 1, 4 do digest[i + 8] = dbytes[i] end
+    dbytes = to_bytes(d)
+    for i = 1, 4 do digest[i + 12] = dbytes[i] end
+    return digest
+end
+
+local strings = {
+    "",
+    "a",
+    "abc",
+    "message digest",
+    "abcdefghijklmnopqrstuvwxyz",
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+    "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
+    "Rosetta Code"
+}
+
+for strings as s do
+    local digest = md4(s):map(|e| -> string.format("%02x", e)):concat("")
+    print($"{digest} <== '{s}'")
+end

Task/MD4/V-(Vlang)/md4.v

@@ -0,0 +1,5 @@
+import v_crypto.md4
+
+fn main(){
+    println("`Rosetta Code` hashed with MD4 is: "+md4.hexhash("Rosetta Code"))
+}