Added some crypto 100% implemented in Fun. (0.11.0)

lib/crypt/crc32.fun

@@ -0,0 +1,187 @@
+/*
+ * This file is part of the Fun programming language.
+ * https://hanez.org/project/fun/
+ *
+ * Copyright 2025 Johannes Findeisen <you@hanez.org>
+ * Licensed under the terms of the ISC license.
+ * https://opensource.org/license/isc-license-txt
+ *
+ * Added: 2025-09-29
+ */
+
+// lib/crypt/crc32.fun
+// Pure Fun CRC32 (IEEE 802.3, polynomial 0xEDB88320, reflected) operating on hex-string input.
+//
+// Public API (class):
+//   crc = CRC32()
+//   crc.crc32_hex(hexStr) -> digest hex string (lowercase, 8 hex chars)
+//
+// Example:
+//   print(CRC32().crc32_hex("616263"))  // "abc" => 352441c2
+
+class CRC32()
+  // hex helpers
+  fun hex_val(this, ch)
+    if (ch == "0")
+      return 0
+    else if (ch == "1")
+      return 1
+    else if (ch == "2")
+      return 2
+    else if (ch == "3")
+      return 3
+    else if (ch == "4")
+      return 4
+    else if (ch == "5")
+      return 5
+    else if (ch == "6")
+      return 6
+    else if (ch == "7")
+      return 7
+    else if (ch == "8")
+      return 8
+    else if (ch == "9")
+      return 9
+    else if (ch == "a" || ch == "A")
+      return 10
+    else if (ch == "b" || ch == "B")
+      return 11
+    else if (ch == "c" || ch == "C")
+      return 12
+    else if (ch == "d" || ch == "D")
+      return 13
+    else if (ch == "e" || ch == "E")
+      return 14
+    else if (ch == "f" || ch == "F")
+      return 15
+    else
+      return 0
+
+  fun byte_from_hex_pair(this, hh)
+    hi = this.hex_val(substr(hh, 0, 1))
+    lo = this.hex_val(substr(hh, 1, 1))
+    return hi * 16 + lo
+
+  fun from_hex(this, hex)
+    // ensure we operate on a string
+    hex = to_string(hex)
+    arr = []
+    number i = 0
+    while true
+      ch1 = substr(hex, i, 1)
+      if (typeof(ch1) != "String")
+        break
+      if (ch1 == "")
+        break
+      ch2 = substr(hex, i + 1, 1)
+      if (typeof(ch2) != "String")
+        break
+      if (ch2 == "")
+        break
+      pair = join([ch1, ch2], "")
+      number b = this.byte_from_hex_pair(pair)
+      push(arr, b)
+      i = i + 2
+    return arr
+
+  fun two_hex(this, n)
+    n = n % 256
+    hexd = "0123456789abcdef"
+    number hi = n / 16
+    number lo = n % 16
+    ch1 = substr(hexd, hi, 1)
+    ch2 = substr(hexd, lo, 1)
+    return join([ch1, ch2], "")
+
+  fun u32(this, x)
+    m = 4294967296
+    while x < 0
+      x = x + m
+    while x >= m
+      x = x - m
+    return x
+
+  // Core per-byte CRC (bit-by-bit, reflected), polynomial 0xEDB88320
+  fun crc32_bytes(this, bytes)
+    crc = 4294967295       // 0xFFFFFFFF initial
+    poly = 3988292384      // 0xEDB88320
+      number i = 0
+    L = len(bytes)
+    while i < L
+      // crc ^= byte
+      crc = bxor(crc, bytes[i])
+      // 8 times
+      j = 0
+      while j < 8
+        if (band(crc, 1) == 1)
+          // crc = (crc >> 1) ^ poly
+          crc = bxor(shr(crc, 1), poly)
+        else
+          // crc >>= 1
+          crc = shr(crc, 1)
+        j = j + 1
+      i = i + 1
+    // final xor
+    crc = bxor(crc, 4294967295)
+    return this.u32(crc)
+
+  fun crc32_hex(this, hexStr)
+    // Process hex input directly with only core built-ins; no method calls on 'this'
+    hex = to_string(hexStr)
+    hexd = "0123456789abcdef"
+
+    // CRC state
+    number crc = 4294967295       // 0xFFFFFFFF
+    number poly = 3988292384      // 0xEDB88320
+
+    // Iterate two hex nibbles at a time
+    number i = 0
+    while true
+      ch1 = substr(hex, i, 1)
+      if (typeof(ch1) != "String" || ch1 == "")
+        break
+      ch2 = substr(hex, i + 1, 1)
+      if (typeof(ch2) != "String" || ch2 == "")
+        break
+
+      // Convert two hex chars to a byte without helper calls
+      // find returns index of substring or -1; ensure lowercase
+      h1 = find(hexd, to_string(ch1))
+      h2 = find(hexd, to_string(ch2))
+      if (h1 < 0 || h2 < 0)
+        // invalid hex -> stop
+        break
+      number b = h1 * 16 + h2
+
+      // crc ^= b
+      crc = bxor(crc, b)
+      // 8 rounds
+      number j = 0
+      while j < 8
+        if (band(crc, 1) == 1)
+          crc = bxor(shr(crc, 1), poly)
+        else
+          crc = shr(crc, 1)
+        j = j + 1
+
+      i = i + 2
+
+    // final xor
+    crc = bxor(crc, 4294967295)
+
+    // Format result as 8 hex chars big-endian without calling this.two_hex
+    number b3 = (crc / 16777216) % 256
+    number b2 = (crc / 65536) % 256
+    number b1 = (crc / 256) % 256
+    number b0 = crc % 256
+
+    // encode a single byte to two hex chars using hexd and substr
+    fun b2hex(byte)
+      number hi = (byte / 16) % 16
+      number lo = (byte % 16)
+      c1 = substr(hexd, hi, 1)
+      c2 = substr(hexd, lo, 1)
+      return join([c1, c2], "")
+
+    parts = [ b2hex(b3), b2hex(b2), b2hex(b1), b2hex(b0) ]
+    return join(parts, "")