Added working combine(), conversion at 95%

Author: poing

gems/combine.py

@@ -0,0 +1,23 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# defaults.py
+
+import js2pysecrets.node as node
+
+import js2pysecrets as secrets
+from js2pysecrets.settings import Settings
+settings = Settings()
+
+secrets.init()
+secret = secrets.random(32)
+shares = secrets.share(secret, 6, 3)
+
+print("Secret: ", secret)
+print(secrets.combine(shares))
+
+
+
+
+

gems/lagrange.py

@@ -0,0 +1,21 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+# vim: set et sw=4 fenc=utf-8:
+#
+# defaults.py
+
+import js2pysecrets.node as node
+
+import js2pysecrets as secrets
+from js2pysecrets.settings import Settings
+settings = Settings()
+
+secrets.init()
+
+print(secrets.lagrange(0, [2,3,5], [113,211,22]))
+
+
+print(secrets.lagrange(0, [2,3,5], (113,211,22)))
+
+
+

js2pysecrets/base.py

@@ -5,6 +5,7 @@
 # from .wrapper import wrapper  # Import your wrapper function
 
 import math
+import re
 
 from js2pysecrets.settings import Settings
 
@@ -254,6 +255,33 @@ def horner(x, coeffs):
     return fx
 
 
+def lagrange(at, x, y):
+    result = 0
+    length = len(x)
+
+    for i in range(length):
+        if y[i]:
+            product = settings.logs[y[i]]
+
+            for j in range(length):
+                if i != j:
+                    if at == x[j]:
+                        product = -1
+                        break
+                    product = (
+                        product
+                        + settings.logs[at ^ x[j]]
+                        - settings.logs[x[i] ^ x[j]]
+                        + settings.maxShares
+                    ) % settings.maxShares
+
+            result = (
+                result ^ settings.exps[product] if product != -1 else result
+            )
+
+    return result
+
+
 def getShares(secret, num_shares, threshold):
     shares = []
     coeffs = [secret]
@@ -423,11 +451,104 @@ def hex2str(hex_string, bytes_per_char=None):
     return out
 
 
+def combine(shares, at=0):
+    result = ""
+    set_bits = None
+    x = []
+    y = []
+
+    at = at or 0
+
+    for share in shares:
+        share_components = extractShareComponents(share)
+        share_id = share_components["id"]
+        share_data = share_components["data"]
+
+        # All shares must have the same bits settings.
+        if set_bits is None:
+            set_bits = share_components["bits"]
+        elif set_bits != share_components["bits"]:
+            raise ValueError("Mismatched shares: Different bit settings.")
+
+        # Reset everything to the bit settings of the shares.
+        if settings.bits != set_bits:
+            init(set_bits)
+
+        # Gathering all the provided shares
+        if share_id not in x:
+            x.append(share_id)
+            split_share = splitNumStringToIntArray(hex2bin(share_data))
+            y.append(split_share)
+
+    # Zipping all of the shares together.
+    y = list(zip(*y))
+
+    # Extract the secret from the 'rotated' share data and return a
+    # string of Binary digits which represent the secret directly. or in the
+    # case of a newShare() return the binary string representing just that
+    # new share.
+    for yi in y:
+
+        result = padLeft(bin(lagrange(at, x, yi))[2:]) + result
+
+    return (
+        bin2hex(result) if at >= 1 else bin2hex(result[result.find("1") + 1 :])
+    )
+
+
 def getConfig():
     settings.update_defaults(hasCSPRNG=isSetRNG())
     return settings.get_config()
 
 
+def extractShareComponents(share):
+    defaults = {
+        "minBits": 1,
+        "maxBits": 32,
+    }  # Assuming defaults for minBits and maxBits
+    config = {"radix": 16}  # Assuming radix as 16 for hex numbers
+
+    bits = int(share[0], 36)
+
+    if not (
+        bits
+        and isinstance(bits, int)
+        and bits % 1 == 0
+        and defaults["minBits"] <= bits <= defaults["maxBits"]
+    ):
+        raise ValueError(
+            f"Invalid share: Number of bits must be an integer between "
+            f"{settings.min_bits} and {settings.max_bits}, inclusive."
+        )
+
+    max_shares = 2**bits - 1
+    id_len = len(hex(max_shares)[2:])
+
+    regex_str = (
+        "^([a-kA-K3-9]{1})([a-fA-F0-9]{" + str(id_len) + "})([a-fA-F0-9]+)$"
+    )
+    share_components = re.match(regex_str, share)
+
+    if share_components:
+        share_id = int(share_components.group(2), config["radix"])
+        if not (
+            isinstance(share_id, int)
+            and share_id % 1 == 0
+            and 1 <= share_id <= max_shares
+        ):
+            raise ValueError(
+                f"Invalid share: Share id must be an integer between 1 and "
+                f"{max_shares}, inclusive."
+            )
+        return {
+            "bits": bits,
+            "id": share_id,
+            "data": share_components.group(3),
+        }
+
+    raise ValueError("Invalid share data provided.")
+
+
 def random(bits):
     if not isinstance(bits, int) or bits < 2 or bits > 65536:
         raise ValueError(

tests/test_basePrivate.py

@@ -846,3 +846,84 @@ def test_py_random_error():
         assert len(caught_warnings) == 1
         assert issubclass(caught_warnings[0].category, Warning)
         assert match in str(caught_warnings[0].message)
+
+
+def test_extractShareComponents_py(full_range_of_bits):
+    # Generate shares with python
+    secrets.init(full_range_of_bits)
+    secret = secrets.random(128)
+    shares = secrets.share(secret, 6, 3)
+    shuffle = pieces(shares)
+
+    py_result = secrets.extractShareComponents(shuffle[0])
+    js_result = node.extractShareComponents(shuffle[0])
+    assert py_result["bits"] == js_result["bits"]
+    assert py_result["id"] == js_result["id"]
+    assert py_result["data"] == js_result["data"]
+
+
+def test_extractShareComponents_js(full_range_of_bits):
+    secret = secrets.random(128)
+    # Generate shares with node
+    node_data = []
+    node_data.append(node.init(full_range_of_bits, list=True))
+    node_data.append(node.share(secret, 6, 3, list=True))
+    js_results = chain(node_data)
+
+    shuffle = pieces(js_results[-1])
+
+    py_result = secrets.extractShareComponents(shuffle[0])
+    js_result = node.extractShareComponents(shuffle[0])
+    assert py_result["bits"] == js_result["bits"]
+    assert py_result["id"] == js_result["id"]
+    assert py_result["data"] == js_result["data"]
+
+
+def test_lagrange_simple():
+    secrets.init()
+    js_poly = node._lagrange(
+        0, [1, 2, 3, 4, 5, 6], [79, 123, 68, 175, 144, 164]
+    )
+    polynomial = secrets.lagrange(
+        0, [1, 2, 3, 4, 5, 6], [79, 123, 68, 175, 144, 164]
+    )
+    assert polynomial == js_poly
+    polynomial = secrets.lagrange(0, [1, 2, 3, 4, 5], [79, 123, 68, 175, 144])
+    assert polynomial == js_poly
+    polynomial = secrets.lagrange(0, [1, 2, 3, 4], [79, 123, 68, 175])
+    assert polynomial == js_poly
+    polynomial = secrets.lagrange(0, [1, 2, 3], [79, 123, 68])
+    assert polynomial == js_poly
+    polynomial = secrets.lagrange(0, [1, 2], [79, 123])
+    assert polynomial != js_poly
+    polynomial = secrets.lagrange(0, [1], [79])
+    assert polynomial != js_poly
+
+
+def test_combine_js2py(full_range_of_bits):
+    secrets.init(full_range_of_bits)
+    secret = secrets.random(128)
+    # Generate shares with node
+    node_data = []
+    node_data.append(node.init(full_range_of_bits, list=True))
+    node_data.append(node.share(secret, 6, 3, list=True))
+    js_results = chain(node_data)
+
+    shuffle = pieces(js_results[-1])
+    # print(shuffle)
+
+    py_result = secrets.combine(shuffle)
+    assert py_result == secret
+
+
+def test_combine_py2py(full_range_of_bits):
+    secrets.init(full_range_of_bits)
+    secret = secrets.random(128)
+    # Generate shares with node
+    shares = secrets.share(secret, 6, 3)
+
+    shuffle = pieces(shares)
+    # print(shuffle)
+
+    py_result = secrets.combine(shuffle)
+    assert py_result == secret