Merge pull request #26 from poing/0.0.7

Better coverage

Author: poing

gems/share.py

@@ -22,14 +22,14 @@ def dithering(random_string):
 
 #print(test(2345))
 
-secrets.init(4)
+secrets.init(8)
 #secrets.init()
 #print(max(settings.logs[1:]))
 
-#settings.update_defaults(dithering=lambda string: dithering(string))
+settings.update_defaults(dithering=lambda string: dithering(string))
 
 results = secrets.share('0074007300650074002000610020007300690073006900680074', 6, 3)
 
 print(results)
 
-#print(random_list)
+print(random_list)

js2pysecrets/base.py

@@ -236,28 +236,17 @@ def splitNumStringToIntArray(string, pad_length=None):
 
 
 def horner(x, coeffs):
-    if x not in settings.logs:
-        raise ValueError(f"Value of 'x' ({x}) is not found in logs.")
 
     logx = settings.logs[x]
     fx = 0
 
     for i in range(len(coeffs) - 1, -1, -1):
         if fx != 0:
 
-            try:
-
-                fx = (
-                    settings.exps[
-                        (logx + settings.logs[fx]) % settings.maxShares
-                    ]
-                    ^ coeffs[i]
-                )
-
-            except IndexError:
-                raise IndexError(
-                    f"list index out of range: x:{x} i:{i} fx:{fx}"
-                )
+            fx = (
+                settings.exps[(logx + settings.logs[fx]) % settings.maxShares]
+                ^ coeffs[i]
+            )
 
         else:
             fx = coeffs[i]
@@ -294,6 +283,7 @@ def getShares(secret, num_shares, threshold):
 
 
 def constructPublicShareString(bits, share_id, data):
+
     share_id = int(share_id, settings.radix)
     bits = bits or settings.bits
     bits_base36 = base36encode(bits).upper()
@@ -308,14 +298,16 @@ def constructPublicShareString(bits, share_id, data):
     ):
         raise ValueError(
             f"Share id must be an integer between 1 and {id_max}, inclusive."
-        )
+        )  # pragma: no cover
 
     new_share_string = bits_base36 + id_hex + data
 
     return new_share_string
 
 
-def base36encode(number, alphabet="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"):
+def base36encode(
+    number, alphabet="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+):  # pragma: no cover
     """Converts an integer to a base36 string."""
     if not isinstance(number, int):
         raise TypeError("number must be an integer")
@@ -337,7 +329,7 @@ def base36encode(number, alphabet="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"):
     return sign + base36
 
 
-def base36decode(number):
+def base36decode(number):  # pragma: no cover
     return int(number, 36)
 
 
@@ -452,15 +444,15 @@ def share(secret, num_shares, threshold, pad_length=None):
     pad_length = pad_length or 128
 
     if not isinstance(secret, str):
-        raise ValueError("Secret must be a string.")
+        raise ValueError("Secret must be a hex string.")
 
     if not isinstance(num_shares, int) or num_shares < 2:
         raise ValueError("Number of shares must be an integer >= 2.")
 
     if num_shares > settings.maxShares:
         needed_bits = math.ceil(math.log(num_shares + 1) / math.log(2))
         raise ValueError(
-            f"Number of shares must be <= {settings.settings.maxShares}."
+            f"Number of shares must be <= {settings.maxShares}."
             f" Use at least {needed_bits} bits."
         )
 
@@ -471,7 +463,7 @@ def share(secret, num_shares, threshold, pad_length=None):
         needed_bits = math.ceil(math.log(threshold + 1) / math.log(2))
         raise ValueError(
             f"Threshold number of shares must be <= "
-            f"{settings.settings.maxShares}. Use at least {needed_bits} bits."
+            f"{settings.maxShares}. Use at least {needed_bits} bits."
         )
 
     if threshold > num_shares:
@@ -491,7 +483,6 @@ def share(secret, num_shares, threshold, pad_length=None):
 
     num_shares = int(num_shares)
     threshold = int(threshold)
-    # bits = 128  # Assuming bits as 128, you can adjust it accordingly
 
     x = [None] * num_shares
     y = [None] * num_shares

tests/test_basePrivate.py

@@ -646,6 +646,37 @@ def test_getShares(set_init_bits):
     assert True
 
 
+def test_random_dithering():
+    random_list = []
+
+    def dithering(random_string):
+        random_list.append(hex(int(random_string)))
+
+    # Check dithering disabled
+    secrets.init()
+    secrets.getShares(1234, 6, 3)
+    assert len(set(random_list)) == 0
+
+    # Enable dithering
+    settings.update_defaults(dithering=lambda string: dithering(string))
+    secrets.getShares(1234, 6, 3)
+    # print(random_list)
+    assert len(set(random_list)) > 1
+
+    # Check testRandom values are the same
+    random_list = []
+    secrets.init(8, "testRandom")
+    settings.update_defaults(dithering=lambda string: dithering(string))
+    secrets.getShares(1234, 6, 3)
+    assert len(set(random_list)) == 1
+
+    # Check dithering disabled
+    random_list = []
+    secrets.init()
+    secrets.getShares(1234, 6, 3)
+    assert len(set(random_list)) == 0
+
+
 @pytest.fixture(
     params=[
         None,
@@ -673,15 +704,145 @@ def full_range_of_bits(request):
     return request.param
 
 
+# Select a number of random shares
 def pieces(shares, number=3):
     random.shuffle(shares)  # Randomize
     return shares[-number:]
 
 
 def test_py_share(full_range_of_bits):
+    # Generate shares with python
     secrets.init(full_range_of_bits)
-    secret = secrets.random(64)
+    secret = secrets.random(128)
+
+    # A few cold runs to cover non-zero in rng
+    secrets.share(secret, 7, 6)
+    secrets.share(secret, 7, 6)
+    secrets.share(secret, 7, 6)
+
     shares = secrets.share(secret, 6, 3)
 
+    # Combine shares using the JavaScript
     result = node.combine(pieces(shares, 3))
     assert result == secret
+
+
+def test_py_share_error_string():
+    match = "Secret must be a hex string."
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secrets.share(12345, 6, 3)
+        # 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)
+
+
+def test_py_share_error_shares():
+    match = "Number of shares must be an integer"
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, 1, 1)
+        # 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)
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, "hello", 3)
+        # 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)
+
+
+def test_py_share_error_high_shares():
+    match = "Number of shares must be"
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, 800, 3)
+        # 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)
+
+
+def test_py_share_error_threshold():
+    match = "Threshold number of shares must be an integer >= 2."
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, 6, 1)
+        # 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)
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, 6, "two")
+        # 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)
+
+
+def test_py_share_error_high_threshold():
+    match = "Threshold number of shares must be"
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, 6, 800)
+        # 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)
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, 6, 7)
+        # 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)
+
+
+def test_py_share_error_padding():
+    match = "Zero-pad length must be an integer between 0 and 1024 inclusive."
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, 6, 3, "hello")
+        # 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)
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, 6, 3, -1)
+        # 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)
+    with pytest.raises(ValueError, match=match):
+        secrets.init()
+        secret = secrets.random(32)
+        secrets.share(secret, 6, 3, 1025)
+        # 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)
+
+
+def test_py_random_error():
+    match = "Number of bits must be an Integer between 1 and 65536."
+    with pytest.raises(ValueError, match=match):
+        secret = secrets.random(65538)
+        # 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)