Merge branch '19-add-tiny-hash-function-for-small-prime-fields'

Author: steven-varga

README.md

@@ -36,22 +36,60 @@ The project includes:
 
 ```julia
 using TinyCrypto
+import TinyCrypto: is_identity
 
-# Find a suitable Weierstrass curve over small field primes and coefficient ranges
+# Find a suitable Weierstrass curve over small field primes and coefficient ranges with iterative method
+# general syntax: curve-name(prime-field-range, parameter-range₁, ..., parameter-rangeₙ, max_cofactor=8)
 curve = Weierstrass(97:103, 10:15, 2:7)  # (prime range, a range, b range)
-# Output: Weierstrass curve: y² = x³ + 10x + 3 |𝔽₉₇ with order: 101 and 𝔾(0,10)
+# Output: Weierstrass{𝔽₉₇}: y² = x³ + 10x + 3 | 𝔾(0,10), q = 101, h = 1, #E = 10
 
-# Get all curve points
-E = curve_points(curve)
+E = curve_points(curve) # Get all curve points
 # → 101-element Vector{ECPoint₁₂₈}: (0𝔽₉₇,10𝔽₉₇), (0𝔽₉₇,87𝔽₉₇), ..., (96𝔽₉₇,63𝔽₉₇), (∞,∞)
+S = subgroup_points(curve) # same as `curve_points` as #E(𝔽₉₇) ∈ primes
+
+curve = Montgomery(30:40, 8:40, 3:40)
+# Montgomery{𝔽₃₇}: 8y² = x³ + 3x² + x | 𝔾(15,2), q = 11, h = 4, #E = 44
+S = subgroup_points(curve) # when cofactor greater than one, there are multiple sub groups
+E = curve_points(curve)
+
+curve = TwistedEdwards(50:100, 1:20, 1:20)
+# TwistedEdwards{𝔽₉₇}: 3x² + y² = 1 + 10x²y² | 𝔾(48,93), q = 29, h = 4, #E = 116
+
+curve = Edwards(50:100, 1:20, max_cofactor=8)
+# Edwards{𝔽₇₉}: 1x² + y² = 1 + 6x²y² | 𝔾(7,58), q = 23, h = 4, #E = 92
+is_singular(curve) # false
+
+## Point arithmetic on curve
+𝔾 = curve.G                          # (7𝔽₇₉,58𝔽₇₉) ∈ Edwards{Fp{UInt128, 79}}
+𝔾 + 𝔾 + 𝔾 + 𝔾                        # (68𝔽₇₉,67𝔽₇₉)  point addition on a cyclic group
+2𝔾                                   # (31𝔽₇₉,51𝔽₇₉) 
+2𝔾 == 𝔾 + 𝔾                          # true
+
+𝒪 = identity(curve)                   # identity point on Edwards curve variant: (0𝔽₇₉,1𝔽₇₉)
+𝒪 + 𝔾 == 𝔾                            # true
+𝔾 + 𝒪 == 𝔾                            # true  
+
+# direct construction from paramters:
+const 𝔽₃₁ = 𝔽ₚ{UInt8, 31}                   # define field prime 𝔽ₚ for the abelian group, or use non-unicode `Fp{base_type, prime_number}`
+Weierstrass{𝔽₃₁}(6, 9, 37, 1, (0,3))        # Weierstrass{𝔽₃₁}: y² = x³ + 6x + 9 | 𝔾(0,3), q = 37, h = 1, #E = 37
+# or pass the 𝔽ₚ field prime directly as in:
+curve = Weierstrass(31, 6, 9, 37, 1, (0,3)) # Weierstrass{𝔽₃₁}: y² = x³ + 6x + 9 | 𝔾(0,3), q = 37, h = 1, #E = 37
+
+𝒪 = identity(curve)                    # (∞,∞) Weierstrass curve identity is infinity
+is_identity(𝒪)                         # true 
+∞ = infinity(curve)                    # (∞,∞) as expected
+is_infinity(∞)                         # true
+
+E = curve_points(curve)                # 
+is_point_on_curve(E[1], curve)         # true 
+is_point_on_curve(curve.G, curve)      # true, G generator point defines the cyclic group, which in this case the entire abelien group 
+
 
-# ECDSA example
-private_key = 42
-msg = 33
 
-public_key = private_key2public(private_key, curve) # ECPoint on curve
-r, s, v = ecdsa_sign(curve, private_key, msg)
-ecdsa_verify(curve, public_key, r, s, v)  # true
+## Tiny Hash (not for cryptographic use, for obvious reasons)
+H("byte size hash of a string")        # hashes string to a byte, given the abelian group is byte size
+H₁₆("16 bit hash")                     # in case you need more hash space
+H₈("is same") == H("is same")          # true, it is just a alias, smae as H8 
 ```
 
 ## Installation

src/TinyCrypto.jl

@@ -3,21 +3,24 @@ module TinyCrypto
 include("macroes.jl")
 include("utils.jl")
 include("field.jl")
+include("core/hash.jl")
 
 using .Macroes
 using .Field
 using .Utils
+using .Hash
 
 include("core/ecpoint.jl")
 include("curves/weierstrass.jl")
 include("curves/montgomery.jl")
 include("curves/edwards.jl")
     # Re-export core symbols for public API
     export @define, @attach
+    export H, H₈, H₁₆, H8, H16
     export Fp, 𝔽ₚ
     export is_prime, primes, mod_inverse
     export Point, ∞, Curve, ECPoint, Infinity
     export Weierstrass, Montgomery, Edwards, TwistedEdwards
-    export infinity, is_infinity
+    export infinity, is_infinity, identity, is_identity
     export point_add, scalar_mult, curve_points, subgroup_points, is_generator, is_point_on_curve, inverse, is_singular
 end

src/core/hash.jl

@@ -0,0 +1,70 @@
+module Hash
+    export H, H₈,H₁₆, H8, H16
+
+    const INIT8 = UInt8[0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0]
+    const K8 = UInt8[0x1f, 0x2b, 0x3c, 0x4d, 0x5e, 0x6a, 0x7d, 0x8e]
+
+    rotate(x::UInt8, n::Int) = ((x >> n) | (x << (8 - n))) % UInt8
+    rotate(x::UInt16, n::Int) = ((x >> n) | (x << (16 - n))) % UInt16
+
+    function pad8(msg::Vector{UInt8})
+        len = length(msg)
+        padded = copy(msg)
+        push!(padded, 0x80)
+        while (length(padded) % 8) != 7
+            push!(padded, 0x00)
+        end
+        push!(padded, UInt8(len % 256))
+        return padded
+    end
+
+    function compress_block8(block::Vector{UInt8}, state::Vector{UInt8})
+        W = copy(block)
+        for i in 1:8
+            W[i] ⊻= K8[i]
+            W[i] = rotate(W[i], i % 8 + 1)
+        end
+        for i in 1:8
+            state[i] = rotate(state[i] ⊻ W[i], i)
+        end
+    end
+
+    function tiny_hash8(msg::Vector{UInt8})
+        padded = pad8(msg)
+        state = copy(INIT8)
+        for i in 1:8:length(padded)
+            block = padded[i:i+7]
+            compress_block8(block, state)
+        end
+        result = state[1]
+        for i in 2:8
+            result ⊻= rotate(state[i], i)
+        end
+        return result
+    end
+    tiny_hash8(msg::String) = tiny_hash8(Vector{UInt8}(codeunits(msg)))
+
+    function tiny_hash16(msg::Vector{UInt8})
+        acc = UInt16(0xabcd)
+        for (i, byte) in enumerate(msg)
+            acc ⊻= UInt16(byte) << (i % 8)
+            acc = (acc << 5) ⊻ (acc >> 3)
+        end
+        return acc
+    end
+    tiny_hash16(msg::String) = tiny_hash16(Vector{UInt8}(codeunits(msg)))
+
+    function H8(msg::Union{String, Vector{UInt8}})
+        bytes = msg isa String ? Vector{UInt8}(codeunits(msg)) : msg
+        return tiny_hash8(bytes)
+    end
+
+    function H16(msg::Union{String, Vector{UInt8}})
+        bytes = msg isa String ? Vector{UInt8}(codeunits(msg)) : msg
+        return tiny_hash16(bytes)
+    end
+
+    H(msg::Union{String, Vector{UInt8}}) = H8(msg)
+    H₈(msg::Union{String, Vector{UInt8}}) = H8(msg)
+    H₁₆(msg::Union{String, Vector{UInt8}}) = H16(msg)
+end

test/runtests.jl

@@ -2,6 +2,7 @@ using Test
 using TinyCrypto
 
 @testset "Curve tests" begin
+    include("test_hash.jl")
     include("test_field.jl")
     include("test_montgomery.jl")
     include("test_edwards.jl")

test/test_hash.jl

@@ -0,0 +1,56 @@
+using Test
+using TinyCrypto: H, H8, H16, H₈, H₁₆
+
+@testset "Hash - TinyHash API" begin
+
+    @testset "Determinism" begin
+        @test H("msg") == H("msg")
+        @test H8("abc") == H8("abc")
+        @test H16("abc") == H16("abc")
+    end
+
+    @testset "Types & Output Range" begin
+        @test H8("") isa UInt8
+        @test H16("") isa UInt16
+        @test 0x00 <= H8("abc") <= 0xff
+        @test 0x0000 <= H16("abc") <= 0xffff
+    end
+
+    @testset "Unicode and Multibyte Strings" begin
+        @test H("𝒞rypto") isa UInt8
+        @test H16("éçüΩ") != H16("ecuo")
+    end
+
+    @testset "Empty input" begin
+        @test H8("") == H(collect(UInt8, ""))
+        @test H16("") == H16(UInt8[])
+    end
+
+    @testset "Single and Repeated Characters" begin
+        @test H8("a") == H("a")
+        @test H8("aaaaaaaa") != H8("aaaaaaaaa")  # should trigger padding into another block
+        @test H16("z"^1000) isa UInt16
+    end
+
+    @testset "Vectors of UInt8" begin
+        @test H8(UInt8[0x61, 0x62, 0x63]) == H8("abc")
+        @test H16(UInt8[0x61, 0x62, 0x63]) == H16("abc")
+    end
+
+    @testset "Aliases" begin
+        str = "hello world"
+        @test H(str) == H8(str)
+        @test H₈(str) == H8(str)
+        @test H₁₆(str) == H16(str)
+    end
+
+    @testset "Corner padding boundaries" begin
+        # Pad to block sizes: exact 7, 8, 14, 15, etc.
+        for n in (0, 1, 6, 7, 8, 13, 14, 15, 16, 100)
+            msg = "a"^n
+            @test H8(msg) isa UInt8
+            @test H16(msg) isa UInt16
+        end
+    end
+
+end