Fixed exp and log tables, added horner()

Author: poing

gems/defaults3.py

@@ -5,14 +5,18 @@
 # defaults.py
 
 import json
-import js2pysecrets as secrets
 import js2pysecrets.node as node
 
-from js2pysecrets.settings import Settings
 import random
 
 # This does not work
+
+import js2pysecrets as secrets
+from js2pysecrets.settings import Settings
 settings = Settings()
+
+
+
 #config = settings.get_config()
 #print(secrets.isSetRNG())
 

gems/splitNumStringToIntArray.py

@@ -0,0 +1,71 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# splitNumStringToIntArray.py.py
+
+import js2pysecrets as secrets
+
+secrets.init()
+string = secrets.hex2bin(secrets.str2hex('hello world'))
+#print(string)
+string = '1' + string
+#print(string)
+
+split_string = secrets.splitNumStringToIntArray(string, 8)
+
+print(split_string)
+
+
+"""
+
+00000000
+01100100
+00000000
+01101100
+00000000
+01110010
+00000000
+01101111
+00000000
+01110111
+00000000
+00100000
+00000000
+01101111
+00000000
+01101100
+00000000
+01101100
+00000000
+01100101
+00000000
+01101000
+
+"""
+
+"""
+
+1100100
+00000000
+01101100
+00000000
+01110010
+00000000
+01101111
+00000000
+01110111
+00000000
+00100000
+00000000
+01101111
+00000000
+01101100
+00000000
+01101100
+00000000
+01100101
+00000000
+01101000
+
+"""

js2pysecrets/base.py

@@ -45,12 +45,46 @@ def padLeft(string, multipleOfBits=None):
 
 def bin2hex(binary_string: str) -> str:
     hex_string = hex(int(binary_string, 2))[2:]
+
+    # Need to respect any leading zeros in the binary string when converting
+    #  to hex.  Because 0b0011 = 0x3, while 0x03 is desired
     hex_string = hex_string.zfill((len(padLeft(binary_string, 4)) // 4))
+
     return hex_string
 
 
-def hex2bin(hex_string: str) -> str:
-    return bin(int(hex_string, 16))[2:]
+def hex2bin(hex_str):
+    bin_str = ""
+
+    # Can NOT use `bin(int(hex_str, 16))[2:]` for this conversion.  Need to
+    #  use this unconventional method to match the JavaScript, specifically
+    #  to achieve the correct zero padding in the binary string output.
+    for char in reversed(hex_str):
+        try:
+            num = int(char, 16)
+        except ValueError:
+            raise ValueError(f"Invalid hex character: {char}")
+
+        bin_str = bin(num)[2:].zfill(4) + bin_str
+
+    return bin_str
+
+
+# def hex2bin(hex_string: str) -> str:
+#     binary_string = bin(int(hex_string, 16))[2:]
+#
+#     # Need to respect any leading zeros in the binary string when converting
+#     #  to hex.  Because 0b0011 = 0x3, while 0x03 is desired
+#     binary_string = binary_string.zfill((len(binary_string) // 8))
+#
+#     #binary_string = bin(int(hex_string, 16))[2:]
+#
+#     # Need to respect any leading zeros in the binary string when converting
+#     #  to hex.  Because 0b0011 = 0x3, while 0x03 is desired
+#     #binary_string = binary_string.zfill(int(hex_string, 2))
+#
+#     # return bin(int(hex_string, 16))[2:]
+#     return binary_string
 
 
 """
@@ -59,8 +93,8 @@ def hex2bin(hex_string: str) -> str:
 
 
 def init(bits=None, rngType=None):
-    logs = []
     exps = []
+    logs = [None]
     x = 1
     primitive = None
 
@@ -88,14 +122,21 @@ def init(bits=None, rngType=None):
     # Construct the exp and log tables for multiplication.
     primitive = settings.primitive_polynomials[settings.bits]
 
+    temp_logs = {}  # Temporary Dict to hold logs
     for i in range(settings.size):
-        exps.append(x)
-        logs.append(i)
+        # this works with loop below
+        exps.insert(i, x)
+        temp_logs[x] = i
+
         x = x << 1  # Left shift assignment
         if x >= settings.size:
             x = x ^ primitive  # Bitwise XOR assignment
             x = x & settings.maxShares  # Bitwise AND assignment
 
+    # Fill the logs List in the proper order
+    for i in range(1, settings.size):
+        logs.append(temp_logs[i])
+
     settings.update_defaults(logs=logs)
     settings.update_defaults(exps=exps)
 
@@ -178,6 +219,38 @@ def getRNG():
     return settings.rng
 
 
+def splitNumStringToIntArray(string, pad_length=None):
+    parts = []
+
+    if pad_length:
+        string = padLeft(string, pad_length)
+
+    # Reverse the string to facilitate right-to-left splitting
+    string = string[::-1]
+
+    for i in range(0, len(string), settings.bits):
+        print(string[i : i + settings.bits][::-1])
+        parts.append(int(string[i : i + settings.bits][::-1], 2))
+
+    return parts
+
+
+def horner(x, coeffs):
+    logx = settings.logs[x]
+    fx = 0
+
+    for i in range(len(coeffs) - 1, -1, -1):
+        if fx != 0:
+            fx = (
+                settings.exps[(logx + settings.logs[fx]) % settings.maxShares]
+                ^ coeffs[i]
+            )
+        else:
+            fx = coeffs[i]
+
+    return fx
+
+
 # lambda bits: bin(1+random.getrandbits(bits))[2:].zfill(bits)
 # lambda bits: bin(1+secrets.randbits(bits))[2:].zfill(bits)
 # lambda bits: (bin(123456789)[2:].zfill(32) * -(-bits // 32))[-bits:]

js2pysecrets/settings.py

@@ -7,6 +7,7 @@
 @dataclass
 class Defaults:
     rng = lambda self, bits: bin(1 + random.getrandbits(bits))[2:].zfill(bits)
+    dithering = None
     bits: int = 8  # default number of bits
     radix: int = 16  # work with HEX by default
     min_bits: int = 3

tests/test_basePrivate.py

@@ -6,6 +6,7 @@
 import pytest
 import random
 import warnings
+from js2pysecrets.wrapper import wrapper, chain
 
 
 settings = Settings()
@@ -535,3 +536,99 @@ def test_py_js_random(input_range):
     py_string = secrets.random(bits)
     js_string = node.random(bits, test=True)
     assert py_string == js_string
+
+
+@pytest.mark.parametrize("input_range", range(300))
+def test_py_js_hex2bin(input_range):
+    # bits = random_range(input_range)
+    bits = int(input_range * 188) + 2
+    secrets.init()
+    secrets.setRNG()
+    hex_string = secrets.random(bits)
+    py_string = secrets.hex2bin(hex_string)
+    js_string = node._hex2bin(hex_string)
+    assert py_string == js_string
+
+
+def test_hex2bin_Fail():
+    match = "Invalid hex character:"
+    with pytest.raises(ValueError, match=match):
+        secrets.hex2bin("0123efgh")
+        # Check if any warnings were raised
+        assert len(caught_warnings) == 1
+        assert issubclass(caught_warnings[0].category, Warning)
+        assert match in str(caught_warnings[0].message)
+
+
+@pytest.fixture(params=[None, 128, 256, 384, 512, 640, 768, 896, 1024])
+def multiple_of_bits(request):
+    return request.param
+
+
+# Define your test function
+def test_array_split(random_string, multiple_of_bits):
+    hex_string = secrets.str2hex(random_string)
+    bin_string = "1" + secrets.hex2bin(hex_string)
+
+    py_array = secrets.splitNumStringToIntArray(bin_string, multiple_of_bits)
+    js_array = node._splitNumStringToIntArray(bin_string, multiple_of_bits)
+
+    # Iterate over the elements of one array
+    for i in range(len(py_array)):
+        assert py_array[i] == js_array[i]
+
+
+@pytest.fixture(
+    params=[None, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+)
+def set_init_bits(request):
+    return request.param
+
+
+# Define test cases
+@pytest.mark.parametrize(
+    "x, coeffs",
+    [
+        (1, [21, 47, 205]),
+        (2, [21, 47, 205]),
+        (3, [21, 47, 205]),
+        (4, [21, 47, 205]),
+        (5, [21, 47, 205]),
+        (6, [21, 47, 205]),
+        (1, [0, 215, 162, 173, 194, 32, 53]),
+        (2, [0, 215, 162, 173, 194, 32, 53]),
+        (3, [0, 215, 162, 173, 194, 32, 53]),
+        (4, [0, 215, 162, 173, 194, 32, 53]),
+        (5, [0, 215, 162, 173, 194, 32, 53]),
+        (6, [0, 215, 162, 173, 194, 32, 53]),
+        (7, [0, 215, 162, 173, 194, 32, 53]),
+        (8, [0, 215, 162, 173, 194, 32, 53]),
+        (9, [0, 215, 162, 173, 194, 32, 53]),
+        (10, [0, 215, 162, 173, 194, 32, 53]),
+        (11, [0, 215, 162, 173, 194, 32, 53]),
+        (12, [0, 215, 162, 173, 194, 32, 53]),
+        (13, [0, 215, 162, 173, 194, 32, 53]),
+        (14, [0, 215, 162, 173, 194, 32, 53]),
+        (15, [0, 215, 162, 173, 194, 32, 53]),
+        (16, [0, 215, 162, 173, 194, 32, 53]),
+        (17, [0, 215, 162, 173, 194, 32, 53]),
+        (18, [0, 215, 162, 173, 194, 32, 53]),
+        (19, [0, 215, 162, 173, 194, 32, 53]),
+        (20, [0, 215, 162, 173, 194, 32, 53]),
+        (21, [0, 215, 162, 173, 194, 32, 53]),
+        # Add more test cases as needed
+    ],
+)
+
+
+# Define the test function
+def test_horner(x, coeffs, set_init_bits):
+    secrets.init(set_init_bits)
+    # assert secrets.horner(x, coeffs) == node._horner(x, coeffs)
+
+    node_data = []
+    node_data.append(node.init(set_init_bits, list=True))
+    node_data.append(node._horner(x, coeffs, list=True))
+    js_results = chain(node_data)
+
+    assert secrets.horner(x, coeffs) == js_results[-1]