From 6d963fe176134eef8fb5715fbb681366128b94e9 Mon Sep 17 00:00:00 2001 From: beedi Date: Sun, 29 Jun 2025 15:52:07 +0000 Subject: [PATCH 01/13] feat:added encryptionManager class for and generate && recoverKey methods && test files --- requirements.txt | 3 +- src/lighthouseweb3/__init__.py | 19 +- .../functions/encryptionManager/__init__.py | 0 .../functions/encryptionManager/config.py | 2 + .../functions/encryptionManager/generate.py | 87 +++++++++ .../functions/encryptionManager/recoverKey.py | 171 ++++++++++++++++++ tests/tests_encryptionEngine/__init__.py | 0 tests/tests_encryptionEngine/test_generate.py | 79 ++++++++ .../test_recover_key.py | 146 +++++++++++++++ 9 files changed, 505 insertions(+), 2 deletions(-) create mode 100644 src/lighthouseweb3/functions/encryptionManager/__init__.py create mode 100644 src/lighthouseweb3/functions/encryptionManager/config.py create mode 100644 src/lighthouseweb3/functions/encryptionManager/generate.py create mode 100644 src/lighthouseweb3/functions/encryptionManager/recoverKey.py create mode 100644 tests/tests_encryptionEngine/__init__.py create mode 100644 tests/tests_encryptionEngine/test_generate.py create mode 100644 tests/tests_encryptionEngine/test_recover_key.py diff --git a/requirements.txt b/requirements.txt index 13c4766..97fd17c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,4 +3,5 @@ charset-normalizer==3.1.0 idna==3.4 requests==2.31.0 urllib3==2.0.2 -eth-account==0.13.7 \ No newline at end of file +eth-account==0.13.7 +cryptography \ No newline at end of file diff --git a/src/lighthouseweb3/__init__.py b/src/lighthouseweb3/__init__.py index b1d8d7c..14bca18 100644 --- a/src/lighthouseweb3/__init__.py +++ b/src/lighthouseweb3/__init__.py @@ -2,6 +2,7 @@ import os import io +from typing import List, Dict, Any from .functions import ( upload as d, deal_status, @@ -16,7 +17,7 @@ remove_ipns_record as removeIpnsRecord, create_wallet as createWallet ) - +from .functions.encryptionManager import generate, recoverKey class Lighthouse: def __init__(self, token: str = ""): @@ -224,3 +225,19 @@ def getTagged(self, tag: str): except Exception as e: raise e +class EncryptionManager: + @staticmethod + def generate(threshold: int, keyCount: int): + try: + return generate.generate(threshold, keyCount) + except Exception as e: + raise e + + + @staticmethod + def recoverKey(keyShards: List[Dict[str, Any]]): + try: + return recoverKey.recoverKey(keyShards) + except Exception as e: + raise e + \ No newline at end of file diff --git a/src/lighthouseweb3/functions/encryptionManager/__init__.py b/src/lighthouseweb3/functions/encryptionManager/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/lighthouseweb3/functions/encryptionManager/config.py b/src/lighthouseweb3/functions/encryptionManager/config.py new file mode 100644 index 0000000..bcc79dc --- /dev/null +++ b/src/lighthouseweb3/functions/encryptionManager/config.py @@ -0,0 +1,2 @@ +#A 257-bit prime to accommodate 256-bit secrets +PRIME = 2**256 + 297 \ No newline at end of file diff --git a/src/lighthouseweb3/functions/encryptionManager/generate.py b/src/lighthouseweb3/functions/encryptionManager/generate.py new file mode 100644 index 0000000..c9e6ba4 --- /dev/null +++ b/src/lighthouseweb3/functions/encryptionManager/generate.py @@ -0,0 +1,87 @@ +import secrets +import logging +from typing import Dict, List, Any +from .config import PRIME +logger = logging.getLogger(__name__) + + +def evaluate_polynomial(coefficients: List[int], x: int, prime: int) -> int: + """ + Evaluate a polynomial with given coefficients at point x. + msk[0] is constant term (the secret), msk[1] is x coefficient, etc. + + Args: + coefficients: List of coefficients where coefficients[0] is the constant term + x: Point at which to evaluate the polynomial + prime: Prime number for the finite field + + Returns: + The result of the polynomial evaluation modulo prime + """ + result = 0 + x_power = 1 # x^0 = 1 + + for coefficient in coefficients: + result = (result + coefficient * x_power) % prime + x_power = (x_power * x) % prime + + return result + +async def generate(threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: + """ + Generate threshold cryptography key shards using Shamir's Secret Sharing + + Args: + threshold: Minimum number of shards needed to reconstruct the secret + key_count: Total number of key shards to generate + + Returns: + { + "masterKey": "", + "keyShards": [ + { + "key": "", + "index": "" + } + ] + } + """ + logger.info(f"Generating key shards with threshold={threshold}, key_count={key_count}") + + msk=[] + idVec=[] + secVec=[] + + if threshold > key_count: + raise ValueError("key_count must be greater than or equal to threshold") + if threshold < 1 or key_count < 1: + raise ValueError("threshold and key_count must be positive integers") + + + msk = [secrets.randbits(256) for _ in range(threshold)] + master_key = msk[0] + + used_ids = set() + + for i in range(key_count): + while True: + id_vec = secrets.randbits(32) + if id_vec != 0 and id_vec not in used_ids: + idVec.append(id_vec) + used_ids.add(id_vec) + break + + for i in range(key_count): + y = evaluate_polynomial(msk, idVec[i], PRIME) + secVec.append(y) + + result = { + "masterKey": hex(master_key), + "keyShards": [{"key": hex(secVec[i]), "index": hex(idVec[i])} for i in range(key_count)] + } + return result + +if __name__ == "__main__": + import asyncio + result = asyncio.run(generate(threshold=1, key_count=1)) + print(result) \ No newline at end of file diff --git a/src/lighthouseweb3/functions/encryptionManager/recoverKey.py b/src/lighthouseweb3/functions/encryptionManager/recoverKey.py new file mode 100644 index 0000000..8856723 --- /dev/null +++ b/src/lighthouseweb3/functions/encryptionManager/recoverKey.py @@ -0,0 +1,171 @@ +from typing import List, Dict, Any +import logging +from .config import PRIME + +logger = logging.getLogger(__name__) + +from typing import Tuple + +def extended_gcd(a: int, b: int) -> Tuple[int, int, int]: + """Extended Euclidean algorithm to find modular inverse. + + Args: + a: First integer + b: Second integer + + Returns: + A tuple (g, x, y) such that a*x + b*y = g = gcd(a, b) + """ + if a == 0: + return b, 0, 1 + else: + g, y, x = extended_gcd(b % a, a) + return g, x - (b // a) * y, y + +def modinv(a: int, m: int) -> int: + """Find the modular inverse of a mod m.""" + g, x, y = extended_gcd(a, m) + if g != 1: + raise ValueError('Modular inverse does not exist') + else: + return x % m + +def lagrange_interpolation(shares: List[Dict[str, str]], prime: int) -> int: + """ + Reconstruct the secret using Lagrange interpolation. + + Args: + shares: List of dictionaries with 'key' and 'index' fields + prime: The prime number used in the finite field + + Returns: + The reconstructed secret as integer + + Raises: + ValueError: If there are duplicate indices + """ + + points = [] + seen_indices = set() + + for i, share in enumerate(shares): + try: + key_str, index_str = validate_share(share, i) + x = int(index_str, 16) + + if x in seen_indices: + raise ValueError(f"Duplicate share index found: 0x{x:x}") + seen_indices.add(x) + + y = int(key_str, 16) + points.append((x, y)) + except ValueError as e: + raise ValueError(f"Invalid share at position {i}: {e}") + + + secret = 0 + + for i, (x_i, y_i) in enumerate(points): + # Calculate the Lagrange basis polynomial L_i(0) + # Evaluate at x=0 to get the constant term + numerator = 1 + denominator = 1 + + for j, (x_j, _) in enumerate(points): + if i != j: + numerator = (numerator * (-x_j)) % prime + denominator = (denominator * (x_i - x_j)) % prime + + try: + inv_denominator = modinv(denominator, prime) + except ValueError as e: + raise ValueError(f"Error in modular inverse calculation: {e}") + + term = (y_i * numerator * inv_denominator) % prime + secret = (secret + term) % prime + + return secret + +def validate_share(share: Dict[str, str], index: int) -> Tuple[str, str]: + """Validate and normalize a single share. + + Args: + share: Dictionary containing 'key' and 'index' fields + index: Position of the share in the input list (for error messages) + + Returns: + Tuple of (normalized_key, normalized_index) as strings without '0x' prefix + + Raises: + ValueError: If the share is invalid + """ + if not isinstance(share, dict): + raise ValueError(f"Share at index {index} must be a dictionary") + + if 'key' not in share or 'index' not in share: + raise ValueError(f"Share at index {index} is missing required fields 'key' or 'index'") + + key_str = str(share['key']).strip().lower() + index_str = str(share['index']).strip().lower() + + if key_str.startswith('0x'): + key_str = key_str[2:] + if index_str.startswith('0x'): + index_str = index_str[2:] + + + if not key_str: + raise ValueError(f"Empty key in share at index {index}") + if not all(c in '0123456789abcdef' for c in key_str): + raise ValueError(f"Invalid key format in share at index {index}: must be a valid hex string") + + if len(key_str) % 2 != 0: + key_str = '0' + key_str + + if not index_str: + raise ValueError(f"Empty index in share at index {index}") + if not all(c in '0123456789abcdef' for c in index_str): + raise ValueError(f"Invalid index format in share at index {index}: must be a valid hex string") + + index_int = int(index_str, 16) + if not (0 <= index_int <= 0xFFFFFFFF): + raise ValueError(f"Index out of range in share at index {index}: must be between 0 and 2^32-1") + + return key_str, index_str + + +async def recoverKey(keyShards: List[Dict[str, str]]) -> Dict[str, Any]: + """ + Recover the master key from a subset of key shares using Lagrange interpolation. + + Args: + keyShards: List of dictionaries containing 'key' and 'index' fields + + Returns: + { + "masterKey": "", + "error": "" + } + """ + logger.info(f"Attempting to recover master key from {len(keyShards)} shares") + + try: + for i, share in enumerate(keyShards): + validate_share(share, i) + secret = lagrange_interpolation(keyShards, PRIME) + return { + "masterKey": hex(secret), + "error": None + } + except ValueError as e: + logger.error(f"Validation error during key recovery: {str(e)}") + return { + "masterKey": None, + "error": f"Validation error: {str(e)}" + } + except Exception as e: + logger.error(f"Error during key recovery: {str(e)}") + return { + "masterKey": None, + "error": f"Recovery error: {str(e)}" + } diff --git a/tests/tests_encryptionEngine/__init__.py b/tests/tests_encryptionEngine/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/tests_encryptionEngine/test_generate.py b/tests/tests_encryptionEngine/test_generate.py new file mode 100644 index 0000000..3408ed3 --- /dev/null +++ b/tests/tests_encryptionEngine/test_generate.py @@ -0,0 +1,79 @@ +import unittest +import asyncio +import logging +from src.lighthouseweb3 import EncryptionManager + +logger = logging.getLogger(__name__) + +class TestGenerate(unittest.TestCase): + """Test cases for the generate module.""" + + def test_generate_basic(self): + """Test basic key generation with default parameters.""" + async def run_test(): + result = await EncryptionManager.generate(threshold=2, keyCount=3) + + self.assertIn('masterKey', result) + self.assertIn('keyShards', result) + + # Check master key format (hex string with 0x prefix) + self.assertIsInstance(result['masterKey'], str) + self.assertTrue(result['masterKey'].startswith('0x')) + self.assertTrue(all(c in '0123456789abcdef' for c in result['masterKey'][2:])) + + # Check key shards + self.assertEqual(len(result['keyShards']), 3) + for shard in result['keyShards']: + self.assertIn('key', shard) + self.assertIn('index', shard) + + # Check key format (hex string with 0x prefix) + self.assertTrue(shard['key'].startswith('0x')) + self.assertTrue(all(c in '0123456789abcdef' for c in shard['key'][2:])) + + # Check index format (hex string with 0x prefix) + self.assertTrue(shard['index'].startswith('0x')) + self.assertTrue(all(c in '0123456789abcdef' for c in shard['index'][2:])) + + return result + + return asyncio.run(run_test()) + + def test_generate_custom_parameters(self): + """Test key generation with custom parameters.""" + async def run_test(): + threshold = 3 + key_count = 5 + + result = await EncryptionManager.generate(threshold=threshold, keyCount=key_count) + + self.assertEqual(len(result['keyShards']), key_count) + + # Check all indices are present and unique + indices = [shard['index'] for shard in result['keyShards']] + self.assertEqual(len(set(indices)), key_count) # All unique + + # Verify all indices are valid hex strings with 0x prefix + for index in indices: + self.assertTrue(index.startswith('0x')) + self.assertTrue(all(c in '0123456789abcdef' for c in index[2:])) + + return result + + return asyncio.run(run_test()) + + def test_invalid_threshold(self): + """Test that invalid threshold raises an error.""" + async def run_test(): + with self.assertRaises(ValueError) as context: + await EncryptionManager.generate(threshold=0, keyCount=3) + self.assertIn("must be positive integers", str(context.exception)) + + with self.assertRaises(ValueError) as context: + await EncryptionManager.generate(threshold=4, keyCount=3) + self.assertIn("must be greater than or equal to threshold", str(context.exception)) + + return asyncio.run(run_test()) + +if __name__ == '__main__': + unittest.main(verbosity=2) diff --git a/tests/tests_encryptionEngine/test_recover_key.py b/tests/tests_encryptionEngine/test_recover_key.py new file mode 100644 index 0000000..e159687 --- /dev/null +++ b/tests/tests_encryptionEngine/test_recover_key.py @@ -0,0 +1,146 @@ +import unittest +import asyncio +import logging +from src.lighthouseweb3 import EncryptionManager + +logger = logging.getLogger(__name__) + +class TestRecoverKey(unittest.TestCase): + """Test cases for the recoverKey module.""" + + def test_empty_shares_list(self): + """Test that recovery fails with empty shares list.""" + async def run_test(): + result = await EncryptionManager.recoverKey([]) + self.assertEqual(result['masterKey'], '0x0') + self.assertIsNone(result['error']) + + return asyncio.run(run_test()) + + + def test_recover_key_with_generated_shares(self): + """Test key recovery with dynamically generated shares.""" + async def run_test(): + + threshold = 3 + key_count = 5 + gen_result = await EncryptionManager.generate(threshold=threshold, keyCount=key_count) + master_key = gen_result['masterKey'] + + shares = gen_result['keyShards'][:threshold] + result = await EncryptionManager.recoverKey(shares) + self.assertEqual(result['masterKey'], master_key) + self.assertIsNone(result['error']) + + for i in range(key_count - threshold + 1): + subset = gen_result['keyShards'][i:i+threshold] + result = await EncryptionManager.recoverKey(subset) + self.assertEqual(result['masterKey'], master_key) + self.assertIsNone(result['error']) + + return result + + return asyncio.run(run_test()) + + def test_recover_key_insufficient_shares(self): + """Test with minimum threshold shares""" + async def run_test(): + threshold = 2 + key_count = 5 + gen_result = await EncryptionManager.generate(threshold=threshold, keyCount=key_count) + master_key = gen_result['masterKey'] + shares = gen_result['keyShards'][:threshold] + result = await EncryptionManager.recoverKey(shares) + self.assertEqual(result['masterKey'], master_key) + self.assertIsNone(result['error']) + + result = await EncryptionManager.recoverKey(gen_result['keyShards']) + self.assertEqual(result['masterKey'], master_key) + self.assertIsNone(result['error']) + + return asyncio.run(run_test()) + + def test_insufficient_shares(self): + """Test with insufficient shares for recovery""" + async def run_test(): + threshold = 3 + key_count = 5 + gen_result = await EncryptionManager.generate(threshold=threshold, keyCount=key_count) + + # Test with one less than threshold (should still work as long as we have at least 2 shares) + result = await EncryptionManager.recoverKey(gen_result['keyShards'][:threshold-1]) + self.assertIsNotNone(result['masterKey']) + self.assertIsNone(result['error']) + + # Test with single share (should still work as long as we have at least 1 share) + result = await EncryptionManager.recoverKey(gen_result['keyShards'][:1]) + self.assertIsNotNone(result['masterKey']) + self.assertIsNone(result['error']) + + return asyncio.run(run_test()) + + def test_various_threshold_combinations(self): + """Test recovery with various threshold and share count combinations""" + async def run_test(): + test_cases = [ + (2, 3), + (3, 5), + (4, 7), + (3, 10), + ] + + for threshold, total in test_cases: + with self.subTest(threshold=threshold, total=total): + gen_result = await EncryptionManager.generate( + threshold=threshold, + keyCount=total + ) + master_key = gen_result['masterKey'] + + shares = gen_result['keyShards'][:threshold] + result = await EncryptionManager.recoverKey(shares) + self.assertEqual(result['masterKey'], master_key) + self.assertIsNone(result['error']) + + result = await EncryptionManager.recoverKey(gen_result['keyShards']) + self.assertEqual(result['masterKey'], master_key) + self.assertIsNone(result['error']) + + import random + subset = random.sample(gen_result['keyShards'], threshold + 1) + result = await EncryptionManager.recoverKey(subset) + self.assertEqual(result['masterKey'], master_key) + self.assertIsNone(result['error']) + + return asyncio.run(run_test()) + + + def test_invalid_share_format(self): + """Test that invalid share formats are handled correctly.""" + async def run_test(): + result = await EncryptionManager.recoverKey(["not a dict", "another invalid"]) + self.assertIsNone(result['masterKey']) + self.assertIn("must be a dictionary", result['error']) + + result = await EncryptionManager.recoverKey([{'key': '123'}, {'key': '456'}]) + self.assertIsNone(result['masterKey']) + self.assertIn("missing required fields 'key' or 'index'", result['error'].lower()) + + result = await EncryptionManager.recoverKey([ + {'key': 'invalidhex', 'index': '1'}, + {'key': 'invalidhex2', 'index': '2'} + ]) + self.assertIsNone(result['masterKey']) + self.assertIn("invalid key format", result['error'].lower()) + + result = await EncryptionManager.recoverKey([ + {'key': 'a' * 63, 'index': 'invalidindex'}, + {'key': 'b' * 63, 'index': 'invalidindex2'} + ]) + self.assertIsNone(result['masterKey']) + self.assertIn("invalid index format", result['error'].lower()) + + return asyncio.run(run_test()) + +if __name__ == '__main__': + unittest.main(verbosity=2) From f5cea273e4e42706bf0988f6acc280b7c5f984da Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Sun, 29 Jun 2025 17:17:43 +0000 Subject: [PATCH 02/13] fix:removed func call from generate.py --- src/lighthouseweb3/functions/encryptionManager/generate.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/lighthouseweb3/functions/encryptionManager/generate.py b/src/lighthouseweb3/functions/encryptionManager/generate.py index c9e6ba4..ab8c2f9 100644 --- a/src/lighthouseweb3/functions/encryptionManager/generate.py +++ b/src/lighthouseweb3/functions/encryptionManager/generate.py @@ -80,8 +80,3 @@ async def generate(threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: "keyShards": [{"key": hex(secVec[i]), "index": hex(idVec[i])} for i in range(key_count)] } return result - -if __name__ == "__main__": - import asyncio - result = asyncio.run(generate(threshold=1, key_count=1)) - print(result) \ No newline at end of file From 45c0e718b0018b47dec0785fbce3130f5b747820 Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Sun, 29 Jun 2025 18:59:22 +0000 Subject: [PATCH 03/13] fix:removed cryptography from requirements.txt --- requirements.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/requirements.txt b/requirements.txt index 97fd17c..13c4766 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,5 +3,4 @@ charset-normalizer==3.1.0 idna==3.4 requests==2.31.0 urllib3==2.0.2 -eth-account==0.13.7 -cryptography \ No newline at end of file +eth-account==0.13.7 \ No newline at end of file From 2b2382919930a68b4e4c9f1f21000158a5425327 Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Wed, 2 Jul 2025 18:43:59 +0000 Subject: [PATCH 04/13] fix: updated the variables casing --- src/lighthouseweb3/__init__.py | 7 +++++-- .../encryptionManager/{recoverKey.py => recover_key.py} | 2 +- 2 files changed, 6 insertions(+), 3 deletions(-) rename src/lighthouseweb3/functions/encryptionManager/{recoverKey.py => recover_key.py} (98%) diff --git a/src/lighthouseweb3/__init__.py b/src/lighthouseweb3/__init__.py index 14bca18..3a75113 100644 --- a/src/lighthouseweb3/__init__.py +++ b/src/lighthouseweb3/__init__.py @@ -17,7 +17,10 @@ remove_ipns_record as removeIpnsRecord, create_wallet as createWallet ) -from .functions.encryptionManager import generate, recoverKey +from .functions.encryptionManager import ( + generate, + recover_key as recoverKey +) class Lighthouse: def __init__(self, token: str = ""): @@ -237,7 +240,7 @@ def generate(threshold: int, keyCount: int): @staticmethod def recoverKey(keyShards: List[Dict[str, Any]]): try: - return recoverKey.recoverKey(keyShards) + return recoverKey.recover_key(keyShards) except Exception as e: raise e \ No newline at end of file diff --git a/src/lighthouseweb3/functions/encryptionManager/recoverKey.py b/src/lighthouseweb3/functions/encryptionManager/recover_key.py similarity index 98% rename from src/lighthouseweb3/functions/encryptionManager/recoverKey.py rename to src/lighthouseweb3/functions/encryptionManager/recover_key.py index 8856723..f03d54a 100644 --- a/src/lighthouseweb3/functions/encryptionManager/recoverKey.py +++ b/src/lighthouseweb3/functions/encryptionManager/recover_key.py @@ -134,7 +134,7 @@ def validate_share(share: Dict[str, str], index: int) -> Tuple[str, str]: return key_str, index_str -async def recoverKey(keyShards: List[Dict[str, str]]) -> Dict[str, Any]: +async def recover_key(keyShards: List[Dict[str, str]]) -> Dict[str, Any]: """ Recover the master key from a subset of key shares using Lagrange interpolation. From 0783ebe832a5a8bfbde6aaaa62494b14668b95ef Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Wed, 2 Jul 2025 19:12:58 +0000 Subject: [PATCH 05/13] feat:added shard key method --- src/lighthouseweb3/__init__.py | 10 +- .../functions/encryptionManager/generate.py | 66 +++-------- .../functions/encryptionManager/shard_key.py | 105 ++++++++++++++++++ 3 files changed, 127 insertions(+), 54 deletions(-) create mode 100644 src/lighthouseweb3/functions/encryptionManager/shard_key.py diff --git a/src/lighthouseweb3/__init__.py b/src/lighthouseweb3/__init__.py index 3a75113..4e41078 100644 --- a/src/lighthouseweb3/__init__.py +++ b/src/lighthouseweb3/__init__.py @@ -19,7 +19,8 @@ ) from .functions.encryptionManager import ( generate, - recover_key as recoverKey + recover_key as recoverKey, + shard_key as shardKey ) class Lighthouse: @@ -243,4 +244,11 @@ def recoverKey(keyShards: List[Dict[str, Any]]): return recoverKey.recover_key(keyShards) except Exception as e: raise e + + @staticmethod + def shardKey(masterKey: int, threshold: int, keyCount: int): + try: + return shardKey.shard_key(masterKey, threshold, keyCount) + except Exception as e: + raise e \ No newline at end of file diff --git a/src/lighthouseweb3/functions/encryptionManager/generate.py b/src/lighthouseweb3/functions/encryptionManager/generate.py index ab8c2f9..88d11a4 100644 --- a/src/lighthouseweb3/functions/encryptionManager/generate.py +++ b/src/lighthouseweb3/functions/encryptionManager/generate.py @@ -1,32 +1,9 @@ import secrets import logging from typing import Dict, List, Any -from .config import PRIME +from shard_key import shard_key logger = logging.getLogger(__name__) - -def evaluate_polynomial(coefficients: List[int], x: int, prime: int) -> int: - """ - Evaluate a polynomial with given coefficients at point x. - msk[0] is constant term (the secret), msk[1] is x coefficient, etc. - - Args: - coefficients: List of coefficients where coefficients[0] is the constant term - x: Point at which to evaluate the polynomial - prime: Prime number for the finite field - - Returns: - The result of the polynomial evaluation modulo prime - """ - result = 0 - x_power = 1 # x^0 = 1 - - for coefficient in coefficients: - result = (result + coefficient * x_power) % prime - x_power = (x_power * x) % prime - - return result - async def generate(threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: """ Generate threshold cryptography key shards using Shamir's Secret Sharing @@ -48,35 +25,18 @@ async def generate(threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: """ logger.info(f"Generating key shards with threshold={threshold}, key_count={key_count}") - msk=[] - idVec=[] - secVec=[] - - if threshold > key_count: - raise ValueError("key_count must be greater than or equal to threshold") - if threshold < 1 or key_count < 1: - raise ValueError("threshold and key_count must be positive integers") - + try: + master_key = secrets.randbits(256) + result = await shard_key(master_key, threshold, key_count) - msk = [secrets.randbits(256) for _ in range(threshold)] - master_key = msk[0] + if not result['isShardable']: + raise ValueError(result['error']) - used_ids = set() - - for i in range(key_count): - while True: - id_vec = secrets.randbits(32) - if id_vec != 0 and id_vec not in used_ids: - idVec.append(id_vec) - used_ids.add(id_vec) - break - - for i in range(key_count): - y = evaluate_polynomial(msk, idVec[i], PRIME) - secVec.append(y) + return { + "masterKey": hex(master_key), + "keyShards": result['keyShards'] + } - result = { - "masterKey": hex(master_key), - "keyShards": [{"key": hex(secVec[i]), "index": hex(idVec[i])} for i in range(key_count)] - } - return result + except Exception as e: + logger.error(f"Error during key generation: {str(e)}") + raise e diff --git a/src/lighthouseweb3/functions/encryptionManager/shard_key.py b/src/lighthouseweb3/functions/encryptionManager/shard_key.py new file mode 100644 index 0000000..c316273 --- /dev/null +++ b/src/lighthouseweb3/functions/encryptionManager/shard_key.py @@ -0,0 +1,105 @@ +import secrets +import logging +from typing import Dict, List, Any +from config import PRIME +logger = logging.getLogger(__name__) + + +def evaluate_polynomial(coefficients: List[int], x: int, prime: int) -> int: + """ + Evaluate a polynomial with given coefficients at point x. + msk[0] is constant term (the secret), msk[1] is x coefficient, etc. + + Args: + coefficients: List of coefficients where coefficients[0] is the constant term + x: Point at which to evaluate the polynomial + prime: Prime number for the finite field + + Returns: + { + "isShardable": true, + "keyShards": [ + { "key": "", "index": "" } + ] + } + """ + result = 0 + x_power = 1 # x^0 = 1 + + for coefficient in coefficients: + result = (result + coefficient * x_power) % prime + x_power = (x_power * x) % prime + + return result + +def validate_key(key: str) -> bool: + """ + Validate that the given key is a valid 32-byte (64 hex char) string. + """ + try: + bytes.fromhex(key) + return len(key) == 64 + except ValueError: + return False + +async def shard_key(key: str, threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: + """ + Generate threshold cryptography key shards using Shamir's Secret Sharing + + Args: + key: The key to be shared + threshold: Minimum number of shards needed to reconstruct the secret + key_count: Total number of key shards to generate + + Returns: + { + "isShardable": true, + "keyShards": [ + { + "key": "", + "index": "" + } + ] + } + """ + logger.info(f"Generating key shards with threshold={threshold}, key_count={key_count}") + + try: + msk=[] + idVec=[] + secVec=[] + + if threshold > key_count: + raise ValueError("key_count must be greater than or equal to threshold") + if threshold < 1 or key_count < 1: + raise ValueError("threshold and key_count must be positive integers") + + + msk.append(key) + + used_ids = set() + + for i in range(key_count): + while True: + id_vec = secrets.randbits(32) + if id_vec != 0 and id_vec not in used_ids: + idVec.append(id_vec) + used_ids.add(id_vec) + break + + for i in range(key_count): + y = evaluate_polynomial(msk, idVec[i], PRIME) + secVec.append(y) + + result = { + "isShardable": True, + "keyShards": [{"key": hex(secVec[i]), "index": hex(idVec[i])} for i in range(key_count)] + } + except Exception as e: + logger.error(f"Error generating key shards: {str(e)}") + result = { + "isShardable": False, + "error": str(e) + } + + return result From 94a1670eac3aa998439fca6ef565b05f45290a6f Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Wed, 2 Jul 2025 19:42:38 +0000 Subject: [PATCH 06/13] refactor: updated the hex validation func to use bytes.fromhex --- .../encryptionManager/recover_key.py | 24 ++++++++++++------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/src/lighthouseweb3/functions/encryptionManager/recover_key.py b/src/lighthouseweb3/functions/encryptionManager/recover_key.py index f03d54a..f0a6165 100644 --- a/src/lighthouseweb3/functions/encryptionManager/recover_key.py +++ b/src/lighthouseweb3/functions/encryptionManager/recover_key.py @@ -112,19 +112,26 @@ def validate_share(share: Dict[str, str], index: int) -> Tuple[str, str]: key_str = key_str[2:] if index_str.startswith('0x'): index_str = index_str[2:] - if not key_str: raise ValueError(f"Empty key in share at index {index}") - if not all(c in '0123456789abcdef' for c in key_str): - raise ValueError(f"Invalid key format in share at index {index}: must be a valid hex string") + if not index_str: + raise ValueError(f"Empty index in share at index {index}") if len(key_str) % 2 != 0: key_str = '0' + key_str - - if not index_str: - raise ValueError(f"Empty index in share at index {index}") - if not all(c in '0123456789abcdef' for c in index_str): + + if len(index_str) % 2 != 0: + index_str = '0' + index_str + + try: + bytes.fromhex(key_str) + except ValueError: + raise ValueError(f"Invalid key format in share at index {index}: must be a valid hex string") + + try: + bytes.fromhex(index_str) + except ValueError: raise ValueError(f"Invalid index format in share at index {index}: must be a valid hex string") index_int = int(index_str, 16) @@ -133,7 +140,6 @@ def validate_share(share: Dict[str, str], index: int) -> Tuple[str, str]: return key_str, index_str - async def recover_key(keyShards: List[Dict[str, str]]) -> Dict[str, Any]: """ Recover the master key from a subset of key shares using Lagrange interpolation. @@ -168,4 +174,4 @@ async def recover_key(keyShards: List[Dict[str, str]]) -> Dict[str, Any]: return { "masterKey": None, "error": f"Recovery error: {str(e)}" - } + } \ No newline at end of file From 2044cc2431fc020ad44f54eb4ab3fed71816c7ac Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Wed, 2 Jul 2025 19:45:12 +0000 Subject: [PATCH 07/13] fix:updated the validation hex code --- .../encryptionManager/recover_key.py | 21 ++++++++++++------- .../functions/encryptionManager/shard_key.py | 3 +++ 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/src/lighthouseweb3/functions/encryptionManager/recover_key.py b/src/lighthouseweb3/functions/encryptionManager/recover_key.py index f03d54a..4a082dc 100644 --- a/src/lighthouseweb3/functions/encryptionManager/recover_key.py +++ b/src/lighthouseweb3/functions/encryptionManager/recover_key.py @@ -112,19 +112,26 @@ def validate_share(share: Dict[str, str], index: int) -> Tuple[str, str]: key_str = key_str[2:] if index_str.startswith('0x'): index_str = index_str[2:] - if not key_str: raise ValueError(f"Empty key in share at index {index}") - if not all(c in '0123456789abcdef' for c in key_str): - raise ValueError(f"Invalid key format in share at index {index}: must be a valid hex string") + if not index_str: + raise ValueError(f"Empty index in share at index {index}") if len(key_str) % 2 != 0: key_str = '0' + key_str - - if not index_str: - raise ValueError(f"Empty index in share at index {index}") - if not all(c in '0123456789abcdef' for c in index_str): + + if len(index_str) % 2 != 0: + index_str = '0' + index_str + + try: + bytes.fromhex(key_str) + except ValueError: + raise ValueError(f"Invalid key format in share at index {index}: must be a valid hex string") + + try: + bytes.fromhex(index_str) + except ValueError: raise ValueError(f"Invalid index format in share at index {index}: must be a valid hex string") index_int = int(index_str, 16) diff --git a/src/lighthouseweb3/functions/encryptionManager/shard_key.py b/src/lighthouseweb3/functions/encryptionManager/shard_key.py index c316273..0459037 100644 --- a/src/lighthouseweb3/functions/encryptionManager/shard_key.py +++ b/src/lighthouseweb3/functions/encryptionManager/shard_key.py @@ -64,6 +64,9 @@ async def shard_key(key: str, threshold: int = 3, key_count: int = 5) -> Dict[st """ logger.info(f"Generating key shards with threshold={threshold}, key_count={key_count}") + if not validate_key(key): + raise ValueError("Invalid key format: must be a valid hex string") + try: msk=[] idVec=[] From a108014bafac187bc893a793851a902e6ccf4597 Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Wed, 2 Jul 2025 20:11:07 +0000 Subject: [PATCH 08/13] fix --- src/lighthouseweb3/functions/encryptionManager/generate.py | 6 +++--- src/lighthouseweb3/functions/encryptionManager/shard_key.py | 6 +++++- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/lighthouseweb3/functions/encryptionManager/generate.py b/src/lighthouseweb3/functions/encryptionManager/generate.py index 88d11a4..e115ad1 100644 --- a/src/lighthouseweb3/functions/encryptionManager/generate.py +++ b/src/lighthouseweb3/functions/encryptionManager/generate.py @@ -1,7 +1,7 @@ import secrets import logging from typing import Dict, List, Any -from shard_key import shard_key +from .shard_key import shard_key logger = logging.getLogger(__name__) async def generate(threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: @@ -26,14 +26,14 @@ async def generate(threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: logger.info(f"Generating key shards with threshold={threshold}, key_count={key_count}") try: - master_key = secrets.randbits(256) + master_key = hex(secrets.randbits(256)) result = await shard_key(master_key, threshold, key_count) if not result['isShardable']: raise ValueError(result['error']) return { - "masterKey": hex(master_key), + "masterKey": master_key, "keyShards": result['keyShards'] } diff --git a/src/lighthouseweb3/functions/encryptionManager/shard_key.py b/src/lighthouseweb3/functions/encryptionManager/shard_key.py index 0459037..a0be43e 100644 --- a/src/lighthouseweb3/functions/encryptionManager/shard_key.py +++ b/src/lighthouseweb3/functions/encryptionManager/shard_key.py @@ -1,7 +1,7 @@ import secrets import logging from typing import Dict, List, Any -from config import PRIME +from .config import PRIME logger = logging.getLogger(__name__) @@ -37,6 +37,8 @@ def validate_key(key: str) -> bool: Validate that the given key is a valid 32-byte (64 hex char) string. """ try: + if key.startswith('0x'): + key = key[2:] bytes.fromhex(key) return len(key) == 64 except ValueError: @@ -67,6 +69,8 @@ async def shard_key(key: str, threshold: int = 3, key_count: int = 5) -> Dict[st if not validate_key(key): raise ValueError("Invalid key format: must be a valid hex string") + key = int(key, 16) + try: msk=[] idVec=[] From a2f37c575dec579659126f719ed4e131d6c79e7a Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Sun, 6 Jul 2025 18:03:36 +0000 Subject: [PATCH 09/13] not working --- .../functions/encryptionManager/shard_key.py | 2 -- .../test_recover_key.py | 5 ++- .../tests_encryptionEngine/test_shard_key.py | 34 +++++++++++++++++++ 3 files changed, 36 insertions(+), 5 deletions(-) create mode 100644 tests/tests_encryptionEngine/test_shard_key.py diff --git a/src/lighthouseweb3/functions/encryptionManager/shard_key.py b/src/lighthouseweb3/functions/encryptionManager/shard_key.py index a0be43e..149dbd5 100644 --- a/src/lighthouseweb3/functions/encryptionManager/shard_key.py +++ b/src/lighthouseweb3/functions/encryptionManager/shard_key.py @@ -80,8 +80,6 @@ async def shard_key(key: str, threshold: int = 3, key_count: int = 5) -> Dict[st raise ValueError("key_count must be greater than or equal to threshold") if threshold < 1 or key_count < 1: raise ValueError("threshold and key_count must be positive integers") - - msk.append(key) used_ids = set() diff --git a/tests/tests_encryptionEngine/test_recover_key.py b/tests/tests_encryptionEngine/test_recover_key.py index e159687..b1a7202 100644 --- a/tests/tests_encryptionEngine/test_recover_key.py +++ b/tests/tests_encryptionEngine/test_recover_key.py @@ -88,7 +88,6 @@ async def run_test(): (4, 7), (3, 10), ] - for threshold, total in test_cases: with self.subTest(threshold=threshold, total=total): gen_result = await EncryptionManager.generate( @@ -113,8 +112,8 @@ async def run_test(): self.assertIsNone(result['error']) return asyncio.run(run_test()) - - + + def test_invalid_share_format(self): """Test that invalid share formats are handled correctly.""" async def run_test(): diff --git a/tests/tests_encryptionEngine/test_shard_key.py b/tests/tests_encryptionEngine/test_shard_key.py new file mode 100644 index 0000000..7d71971 --- /dev/null +++ b/tests/tests_encryptionEngine/test_shard_key.py @@ -0,0 +1,34 @@ +import unittest +import asyncio +import logging +from src.lighthouseweb3 import EncryptionManager + +logger = logging.getLogger(__name__) + +# class TestShardKey(unittest.TestCase): +# def test_valid_32_byte_key(self): +# """Test with a valid 32-byte key.""" + +# async def run_test(): +# key = "0xb51cde71e810430c9f657dd24d5ba30b17ec1f86e9f671c7f4cb3d888a4680dd" +# result = await EncryptionManager.shardKey(key, threshold=3, keyCount=5) +# self.assertTrue(result['isShardable']) +# self.assertEqual(len(result['keyShards']), 5) + +# for shard in result['keyShards']: +# self.assertIn('key', shard) +# self.assertIn('index', shard) +# self.assertIsInstance(shard['key'], str) +# self.assertIsInstance(shard['index'], str) + +# return asyncio.run(run_test()) + + # def test_invalid_key(self): + # """Test with an invalid key.""" + # async def run_test(): + # key = "e810430c9f657dd24d5ba30b17ec1f86e9f671c7f4cb3d888a4680dd" + # result = await EncryptionManager.shardKey(key, threshold=3, keyCount=5) + # self.assertFalse(result['isShardable']) + # self.assertEqual(result['error'], "Invalid key length") + + # return asyncio.run(run_test()) \ No newline at end of file From e78b5e0fe78b8240282827144a27fa6dc0a4751a Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Sun, 6 Jul 2025 18:55:35 +0000 Subject: [PATCH 10/13] feat: added shard_key method --- .../functions/encryptionManager/generate.py | 17 +- .../encryptionManager/recover_key.py | 3 +- .../test_recover_key.py | 2 +- .../tests_encryptionEngine/test_shard_key.py | 176 +++++++++++++++--- 4 files changed, 162 insertions(+), 36 deletions(-) diff --git a/src/lighthouseweb3/functions/encryptionManager/generate.py b/src/lighthouseweb3/functions/encryptionManager/generate.py index e115ad1..0071b0f 100644 --- a/src/lighthouseweb3/functions/encryptionManager/generate.py +++ b/src/lighthouseweb3/functions/encryptionManager/generate.py @@ -1,7 +1,8 @@ import secrets import logging from typing import Dict, List, Any -from .shard_key import shard_key +from .shard_key import shard_key + logger = logging.getLogger(__name__) async def generate(threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: @@ -24,19 +25,21 @@ async def generate(threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: } """ logger.info(f"Generating key shards with threshold={threshold}, key_count={key_count}") - + try: - master_key = hex(secrets.randbits(256)) + random_int = secrets.randbits(256) + master_key = f"0x{random_int:064x}" + result = await shard_key(master_key, threshold, key_count) - + if not result['isShardable']: raise ValueError(result['error']) - + return { "masterKey": master_key, "keyShards": result['keyShards'] } - + except Exception as e: logger.error(f"Error during key generation: {str(e)}") - raise e + raise e \ No newline at end of file diff --git a/src/lighthouseweb3/functions/encryptionManager/recover_key.py b/src/lighthouseweb3/functions/encryptionManager/recover_key.py index f0a6165..b2b29b0 100644 --- a/src/lighthouseweb3/functions/encryptionManager/recover_key.py +++ b/src/lighthouseweb3/functions/encryptionManager/recover_key.py @@ -159,8 +159,9 @@ async def recover_key(keyShards: List[Dict[str, str]]) -> Dict[str, Any]: for i, share in enumerate(keyShards): validate_share(share, i) secret = lagrange_interpolation(keyShards, PRIME) + master_key = f"0x{secret:064x}" return { - "masterKey": hex(secret), + "masterKey": master_key, "error": None } except ValueError as e: diff --git a/tests/tests_encryptionEngine/test_recover_key.py b/tests/tests_encryptionEngine/test_recover_key.py index b1a7202..93b53ea 100644 --- a/tests/tests_encryptionEngine/test_recover_key.py +++ b/tests/tests_encryptionEngine/test_recover_key.py @@ -12,7 +12,7 @@ def test_empty_shares_list(self): """Test that recovery fails with empty shares list.""" async def run_test(): result = await EncryptionManager.recoverKey([]) - self.assertEqual(result['masterKey'], '0x0') + self.assertEqual(result['masterKey'], '0x0000000000000000000000000000000000000000000000000000000000000000') self.assertIsNone(result['error']) return asyncio.run(run_test()) diff --git a/tests/tests_encryptionEngine/test_shard_key.py b/tests/tests_encryptionEngine/test_shard_key.py index 7d71971..d5a9eb3 100644 --- a/tests/tests_encryptionEngine/test_shard_key.py +++ b/tests/tests_encryptionEngine/test_shard_key.py @@ -5,30 +5,152 @@ logger = logging.getLogger(__name__) -# class TestShardKey(unittest.TestCase): -# def test_valid_32_byte_key(self): -# """Test with a valid 32-byte key.""" - -# async def run_test(): -# key = "0xb51cde71e810430c9f657dd24d5ba30b17ec1f86e9f671c7f4cb3d888a4680dd" -# result = await EncryptionManager.shardKey(key, threshold=3, keyCount=5) -# self.assertTrue(result['isShardable']) -# self.assertEqual(len(result['keyShards']), 5) - -# for shard in result['keyShards']: -# self.assertIn('key', shard) -# self.assertIn('index', shard) -# self.assertIsInstance(shard['key'], str) -# self.assertIsInstance(shard['index'], str) - -# return asyncio.run(run_test()) - - # def test_invalid_key(self): - # """Test with an invalid key.""" - # async def run_test(): - # key = "e810430c9f657dd24d5ba30b17ec1f86e9f671c7f4cb3d888a4680dd" - # result = await EncryptionManager.shardKey(key, threshold=3, keyCount=5) - # self.assertFalse(result['isShardable']) - # self.assertEqual(result['error'], "Invalid key length") - - # return asyncio.run(run_test()) \ No newline at end of file +class TestShardKey(unittest.TestCase): + """Test cases for the shardKey function.""" + + def test_shardKey_valid_32_byte_key(self): + """Test shardKey with valid 32-byte keys.""" + async def run_test(): + valid_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" + result = await EncryptionManager.shardKey(valid_key, threshold=2, keyCount=3) + + self.assertTrue(result['isShardable']) + self.assertIn('keyShards', result) + self.assertEqual(len(result['keyShards']), 3) + + for shard in result['keyShards']: + self.assertIn('key', shard) + self.assertIn('index', shard) + self.assertTrue(shard['key'].startswith('0x')) + self.assertTrue(shard['index'].startswith('0x')) + self.assertTrue(all(c in '0123456789abcdef' for c in shard['key'][2:])) + self.assertTrue(all(c in '0123456789abcdef' for c in shard['index'][2:])) + + valid_key_with_prefix = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" + result2 = await EncryptionManager.shardKey(valid_key_with_prefix, threshold=2, keyCount=3) + + self.assertTrue(result2['isShardable']) + self.assertEqual(len(result2['keyShards']), 3) + + return result + + return asyncio.run(run_test()) + + def test_shardKey_invalid_keys(self): + """Test shardKey with invalid keys.""" + async def run_test(): + short_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcd" + with self.assertRaises(ValueError) as context: + await EncryptionManager.shardKey(short_key, threshold=2, keyCount=3) + self.assertIn("Invalid key format", str(context.exception)) + + long_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12" + with self.assertRaises(ValueError) as context: + await EncryptionManager.shardKey(long_key, threshold=2, keyCount=3) + self.assertIn("Invalid key format", str(context.exception)) + + malformed_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefg" + with self.assertRaises(ValueError) as context: + await EncryptionManager.shardKey(malformed_key, threshold=2, keyCount=3) + self.assertIn("Invalid key format", str(context.exception)) + + with self.assertRaises(ValueError) as context: + await EncryptionManager.shardKey("", threshold=2, keyCount=3) + self.assertIn("Invalid key format", str(context.exception)) + + invalid_hex = "xyz4567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" + with self.assertRaises(ValueError) as context: + await EncryptionManager.shardKey(invalid_hex, threshold=2, keyCount=3) + self.assertIn("Invalid key format", str(context.exception)) + + return asyncio.run(run_test()) + + def test_shardKey_threshold_keyCount_combinations(self): + """Test various threshold and keyCount combinations.""" + async def run_test(): + valid_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" + + result1 = await EncryptionManager.shardKey(valid_key, threshold=1, keyCount=1) + self.assertTrue(result1['isShardable']) + self.assertEqual(len(result1['keyShards']), 1) + + result2 = await EncryptionManager.shardKey(valid_key, threshold=2, keyCount=3) + self.assertTrue(result2['isShardable']) + self.assertEqual(len(result2['keyShards']), 3) + + result3 = await EncryptionManager.shardKey(valid_key, threshold=3, keyCount=5) + self.assertTrue(result3['isShardable']) + self.assertEqual(len(result3['keyShards']), 5) + + result4 = await EncryptionManager.shardKey(valid_key, threshold=4, keyCount=4) + self.assertTrue(result4['isShardable']) + self.assertEqual(len(result4['keyShards']), 4) + + result5 = await EncryptionManager.shardKey(valid_key, threshold=5, keyCount=10) + self.assertTrue(result5['isShardable']) + self.assertEqual(len(result5['keyShards']), 10) + + indices = [shard['index'] for shard in result5['keyShards']] + self.assertEqual(len(set(indices)), 10) + + return result5 + + return asyncio.run(run_test()) + + + def test_shardKey_index_uniqueness(self): + """Test that all generated indices are unique and non-zero.""" + async def run_test(): + valid_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" + + + result = await EncryptionManager.shardKey(valid_key, threshold=3, keyCount=20) + + self.assertTrue(result['isShardable']) + self.assertEqual(len(result['keyShards']), 20) + + indices = [shard['index'] for shard in result['keyShards']] + self.assertEqual(len(set(indices)), 20) + + for index in indices: + self.assertNotEqual(index, '0x0') + + self.assertNotEqual(int(index, 16), 0) + + return result + + return asyncio.run(run_test()) + + def test_shardKey_hex_format_consistency(self): + """Test that all returned values are properly formatted hex strings.""" + async def run_test(): + valid_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" + + result = await EncryptionManager.shardKey(valid_key, threshold=2, keyCount=4) + + self.assertTrue(result['isShardable']) + + for shard in result['keyShards']: + key = shard['key'] + index = shard['index'] + + + self.assertTrue(key.startswith('0x')) + self.assertTrue(index.startswith('0x')) + + + self.assertTrue(all(c in '0123456789abcdef' for c in key[2:])) + self.assertTrue(all(c in '0123456789abcdef' for c in index[2:])) + + try: + int(key, 16) + int(index, 16) + except ValueError: + self.fail(f"Invalid hex format: key={key}, index={index}") + + return result + + return asyncio.run(run_test()) + +if __name__ == '__main__': + unittest.main(verbosity=2) \ No newline at end of file From c1080015fc1504152493ec41484463f94e30fd60 Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Sun, 6 Jul 2025 19:17:39 +0000 Subject: [PATCH 11/13] fix:fixed error --- .../functions/encryptionManager/generate.py | 2 +- .../encryptionManager/recover_key.py | 2 +- .../functions/encryptionManager/shard_key.py | 35 ++++++++++--------- 3 files changed, 20 insertions(+), 19 deletions(-) diff --git a/src/lighthouseweb3/functions/encryptionManager/generate.py b/src/lighthouseweb3/functions/encryptionManager/generate.py index 0071b0f..bc700e8 100644 --- a/src/lighthouseweb3/functions/encryptionManager/generate.py +++ b/src/lighthouseweb3/functions/encryptionManager/generate.py @@ -42,4 +42,4 @@ async def generate(threshold: int = 3, key_count: int = 5) -> Dict[str, Any]: except Exception as e: logger.error(f"Error during key generation: {str(e)}") - raise e \ No newline at end of file + raise e diff --git a/src/lighthouseweb3/functions/encryptionManager/recover_key.py b/src/lighthouseweb3/functions/encryptionManager/recover_key.py index b2b29b0..a7970b7 100644 --- a/src/lighthouseweb3/functions/encryptionManager/recover_key.py +++ b/src/lighthouseweb3/functions/encryptionManager/recover_key.py @@ -175,4 +175,4 @@ async def recover_key(keyShards: List[Dict[str, str]]) -> Dict[str, Any]: return { "masterKey": None, "error": f"Recovery error: {str(e)}" - } \ No newline at end of file + } diff --git a/src/lighthouseweb3/functions/encryptionManager/shard_key.py b/src/lighthouseweb3/functions/encryptionManager/shard_key.py index 149dbd5..4910965 100644 --- a/src/lighthouseweb3/functions/encryptionManager/shard_key.py +++ b/src/lighthouseweb3/functions/encryptionManager/shard_key.py @@ -2,13 +2,13 @@ import logging from typing import Dict, List, Any from .config import PRIME -logger = logging.getLogger(__name__) +logger = logging.getLogger(__name__) def evaluate_polynomial(coefficients: List[int], x: int, prime: int) -> int: """ Evaluate a polynomial with given coefficients at point x. - msk[0] is constant term (the secret), msk[1] is x coefficient, etc. + coefficients[0] is constant term (the secret), coefficients[1] is x coefficient, etc. Args: coefficients: List of coefficients where coefficients[0] is the constant term @@ -16,15 +16,10 @@ def evaluate_polynomial(coefficients: List[int], x: int, prime: int) -> int: prime: Prime number for the finite field Returns: - { - "isShardable": true, - "keyShards": [ - { "key": "", "index": "" } - ] - } + Value of polynomial at point x """ result = 0 - x_power = 1 # x^0 = 1 + x_power = 1 # x^0 = 1 for coefficient in coefficients: result = (result + coefficient * x_power) % prime @@ -69,29 +64,33 @@ async def shard_key(key: str, threshold: int = 3, key_count: int = 5) -> Dict[st if not validate_key(key): raise ValueError("Invalid key format: must be a valid hex string") - key = int(key, 16) + key_int = int(key, 16) try: - msk=[] - idVec=[] - secVec=[] - if threshold > key_count: raise ValueError("key_count must be greater than or equal to threshold") if threshold < 1 or key_count < 1: raise ValueError("threshold and key_count must be positive integers") - msk.append(key) - + + msk = [key_int] + + for i in range(threshold - 1): + random_coeff = secrets.randbelow(PRIME) + msk.append(random_coeff) + + idVec = [] used_ids = set() for i in range(key_count): while True: id_vec = secrets.randbits(32) - if id_vec != 0 and id_vec not in used_ids: + + if id_vec != 0 and id_vec not in used_ids and id_vec < PRIME: idVec.append(id_vec) used_ids.add(id_vec) break + secVec = [] for i in range(key_count): y = evaluate_polynomial(msk, idVec[i], PRIME) secVec.append(y) @@ -100,6 +99,7 @@ async def shard_key(key: str, threshold: int = 3, key_count: int = 5) -> Dict[st "isShardable": True, "keyShards": [{"key": hex(secVec[i]), "index": hex(idVec[i])} for i in range(key_count)] } + except Exception as e: logger.error(f"Error generating key shards: {str(e)}") result = { @@ -108,3 +108,4 @@ async def shard_key(key: str, threshold: int = 3, key_count: int = 5) -> Dict[st } return result + From 400de7ac64f948b5f0cccb3407b7e7102b12be02 Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Thu, 10 Jul 2025 16:44:50 +0000 Subject: [PATCH 12/13] refactor: changed class name --- src/lighthouseweb3/__init__.py | 4 +- .../{encryptionManager => kavach}/__init__.py | 0 .../{encryptionManager => kavach}/config.py | 0 .../{encryptionManager => kavach}/generate.py | 0 .../recover_key.py | 0 .../shard_key.py | 0 .../__init__.py | 0 .../test_generate.py | 10 ++--- .../test_recover_key.py | 38 +++++++++---------- .../test_shard_key.py | 30 +++++++-------- 10 files changed, 41 insertions(+), 41 deletions(-) rename src/lighthouseweb3/functions/{encryptionManager => kavach}/__init__.py (100%) rename src/lighthouseweb3/functions/{encryptionManager => kavach}/config.py (100%) rename src/lighthouseweb3/functions/{encryptionManager => kavach}/generate.py (100%) rename src/lighthouseweb3/functions/{encryptionManager => kavach}/recover_key.py (100%) rename src/lighthouseweb3/functions/{encryptionManager => kavach}/shard_key.py (100%) rename tests/{tests_encryptionEngine => tests_kavach}/__init__.py (100%) rename tests/{tests_encryptionEngine => tests_kavach}/test_generate.py (88%) rename tests/{tests_encryptionEngine => tests_kavach}/test_recover_key.py (76%) rename tests/{tests_encryptionEngine => tests_kavach}/test_shard_key.py (81%) diff --git a/src/lighthouseweb3/__init__.py b/src/lighthouseweb3/__init__.py index 4e41078..6078bba 100644 --- a/src/lighthouseweb3/__init__.py +++ b/src/lighthouseweb3/__init__.py @@ -17,7 +17,7 @@ remove_ipns_record as removeIpnsRecord, create_wallet as createWallet ) -from .functions.encryptionManager import ( +from .functions.kavach import ( generate, recover_key as recoverKey, shard_key as shardKey @@ -229,7 +229,7 @@ def getTagged(self, tag: str): except Exception as e: raise e -class EncryptionManager: +class Kavach: @staticmethod def generate(threshold: int, keyCount: int): try: diff --git a/src/lighthouseweb3/functions/encryptionManager/__init__.py b/src/lighthouseweb3/functions/kavach/__init__.py similarity index 100% rename from src/lighthouseweb3/functions/encryptionManager/__init__.py rename to src/lighthouseweb3/functions/kavach/__init__.py diff --git a/src/lighthouseweb3/functions/encryptionManager/config.py b/src/lighthouseweb3/functions/kavach/config.py similarity index 100% rename from src/lighthouseweb3/functions/encryptionManager/config.py rename to src/lighthouseweb3/functions/kavach/config.py diff --git a/src/lighthouseweb3/functions/encryptionManager/generate.py b/src/lighthouseweb3/functions/kavach/generate.py similarity index 100% rename from src/lighthouseweb3/functions/encryptionManager/generate.py rename to src/lighthouseweb3/functions/kavach/generate.py diff --git a/src/lighthouseweb3/functions/encryptionManager/recover_key.py b/src/lighthouseweb3/functions/kavach/recover_key.py similarity index 100% rename from src/lighthouseweb3/functions/encryptionManager/recover_key.py rename to src/lighthouseweb3/functions/kavach/recover_key.py diff --git a/src/lighthouseweb3/functions/encryptionManager/shard_key.py b/src/lighthouseweb3/functions/kavach/shard_key.py similarity index 100% rename from src/lighthouseweb3/functions/encryptionManager/shard_key.py rename to src/lighthouseweb3/functions/kavach/shard_key.py diff --git a/tests/tests_encryptionEngine/__init__.py b/tests/tests_kavach/__init__.py similarity index 100% rename from tests/tests_encryptionEngine/__init__.py rename to tests/tests_kavach/__init__.py diff --git a/tests/tests_encryptionEngine/test_generate.py b/tests/tests_kavach/test_generate.py similarity index 88% rename from tests/tests_encryptionEngine/test_generate.py rename to tests/tests_kavach/test_generate.py index 3408ed3..386fe79 100644 --- a/tests/tests_encryptionEngine/test_generate.py +++ b/tests/tests_kavach/test_generate.py @@ -1,7 +1,7 @@ import unittest import asyncio import logging -from src.lighthouseweb3 import EncryptionManager +from src.lighthouseweb3 import Kavach logger = logging.getLogger(__name__) @@ -11,7 +11,7 @@ class TestGenerate(unittest.TestCase): def test_generate_basic(self): """Test basic key generation with default parameters.""" async def run_test(): - result = await EncryptionManager.generate(threshold=2, keyCount=3) + result = await Kavach.generate(threshold=2, keyCount=3) self.assertIn('masterKey', result) self.assertIn('keyShards', result) @@ -45,7 +45,7 @@ async def run_test(): threshold = 3 key_count = 5 - result = await EncryptionManager.generate(threshold=threshold, keyCount=key_count) + result = await Kavach.generate(threshold=threshold, keyCount=key_count) self.assertEqual(len(result['keyShards']), key_count) @@ -66,11 +66,11 @@ def test_invalid_threshold(self): """Test that invalid threshold raises an error.""" async def run_test(): with self.assertRaises(ValueError) as context: - await EncryptionManager.generate(threshold=0, keyCount=3) + await Kavach.generate(threshold=0, keyCount=3) self.assertIn("must be positive integers", str(context.exception)) with self.assertRaises(ValueError) as context: - await EncryptionManager.generate(threshold=4, keyCount=3) + await Kavach.generate(threshold=4, keyCount=3) self.assertIn("must be greater than or equal to threshold", str(context.exception)) return asyncio.run(run_test()) diff --git a/tests/tests_encryptionEngine/test_recover_key.py b/tests/tests_kavach/test_recover_key.py similarity index 76% rename from tests/tests_encryptionEngine/test_recover_key.py rename to tests/tests_kavach/test_recover_key.py index 93b53ea..3ea2d30 100644 --- a/tests/tests_encryptionEngine/test_recover_key.py +++ b/tests/tests_kavach/test_recover_key.py @@ -1,7 +1,7 @@ import unittest import asyncio import logging -from src.lighthouseweb3 import EncryptionManager +from src.lighthouseweb3 import Kavach logger = logging.getLogger(__name__) @@ -11,7 +11,7 @@ class TestRecoverKey(unittest.TestCase): def test_empty_shares_list(self): """Test that recovery fails with empty shares list.""" async def run_test(): - result = await EncryptionManager.recoverKey([]) + result = await Kavach.recoverKey([]) self.assertEqual(result['masterKey'], '0x0000000000000000000000000000000000000000000000000000000000000000') self.assertIsNone(result['error']) @@ -24,17 +24,17 @@ async def run_test(): threshold = 3 key_count = 5 - gen_result = await EncryptionManager.generate(threshold=threshold, keyCount=key_count) + gen_result = await Kavach.generate(threshold=threshold, keyCount=key_count) master_key = gen_result['masterKey'] shares = gen_result['keyShards'][:threshold] - result = await EncryptionManager.recoverKey(shares) + result = await Kavach.recoverKey(shares) self.assertEqual(result['masterKey'], master_key) self.assertIsNone(result['error']) for i in range(key_count - threshold + 1): subset = gen_result['keyShards'][i:i+threshold] - result = await EncryptionManager.recoverKey(subset) + result = await Kavach.recoverKey(subset) self.assertEqual(result['masterKey'], master_key) self.assertIsNone(result['error']) @@ -47,14 +47,14 @@ def test_recover_key_insufficient_shares(self): async def run_test(): threshold = 2 key_count = 5 - gen_result = await EncryptionManager.generate(threshold=threshold, keyCount=key_count) + gen_result = await Kavach.generate(threshold=threshold, keyCount=key_count) master_key = gen_result['masterKey'] shares = gen_result['keyShards'][:threshold] - result = await EncryptionManager.recoverKey(shares) + result = await Kavach.recoverKey(shares) self.assertEqual(result['masterKey'], master_key) self.assertIsNone(result['error']) - result = await EncryptionManager.recoverKey(gen_result['keyShards']) + result = await Kavach.recoverKey(gen_result['keyShards']) self.assertEqual(result['masterKey'], master_key) self.assertIsNone(result['error']) @@ -65,15 +65,15 @@ def test_insufficient_shares(self): async def run_test(): threshold = 3 key_count = 5 - gen_result = await EncryptionManager.generate(threshold=threshold, keyCount=key_count) + gen_result = await Kavach.generate(threshold=threshold, keyCount=key_count) # Test with one less than threshold (should still work as long as we have at least 2 shares) - result = await EncryptionManager.recoverKey(gen_result['keyShards'][:threshold-1]) + result = await Kavach.recoverKey(gen_result['keyShards'][:threshold-1]) self.assertIsNotNone(result['masterKey']) self.assertIsNone(result['error']) # Test with single share (should still work as long as we have at least 1 share) - result = await EncryptionManager.recoverKey(gen_result['keyShards'][:1]) + result = await Kavach.recoverKey(gen_result['keyShards'][:1]) self.assertIsNotNone(result['masterKey']) self.assertIsNone(result['error']) @@ -90,24 +90,24 @@ async def run_test(): ] for threshold, total in test_cases: with self.subTest(threshold=threshold, total=total): - gen_result = await EncryptionManager.generate( + gen_result = await Kavach.generate( threshold=threshold, keyCount=total ) master_key = gen_result['masterKey'] shares = gen_result['keyShards'][:threshold] - result = await EncryptionManager.recoverKey(shares) + result = await Kavach.recoverKey(shares) self.assertEqual(result['masterKey'], master_key) self.assertIsNone(result['error']) - result = await EncryptionManager.recoverKey(gen_result['keyShards']) + result = await Kavach.recoverKey(gen_result['keyShards']) self.assertEqual(result['masterKey'], master_key) self.assertIsNone(result['error']) import random subset = random.sample(gen_result['keyShards'], threshold + 1) - result = await EncryptionManager.recoverKey(subset) + result = await Kavach.recoverKey(subset) self.assertEqual(result['masterKey'], master_key) self.assertIsNone(result['error']) @@ -117,22 +117,22 @@ async def run_test(): def test_invalid_share_format(self): """Test that invalid share formats are handled correctly.""" async def run_test(): - result = await EncryptionManager.recoverKey(["not a dict", "another invalid"]) + result = await Kavach.recoverKey(["not a dict", "another invalid"]) self.assertIsNone(result['masterKey']) self.assertIn("must be a dictionary", result['error']) - result = await EncryptionManager.recoverKey([{'key': '123'}, {'key': '456'}]) + result = await Kavach.recoverKey([{'key': '123'}, {'key': '456'}]) self.assertIsNone(result['masterKey']) self.assertIn("missing required fields 'key' or 'index'", result['error'].lower()) - result = await EncryptionManager.recoverKey([ + result = await Kavach.recoverKey([ {'key': 'invalidhex', 'index': '1'}, {'key': 'invalidhex2', 'index': '2'} ]) self.assertIsNone(result['masterKey']) self.assertIn("invalid key format", result['error'].lower()) - result = await EncryptionManager.recoverKey([ + result = await Kavach.recoverKey([ {'key': 'a' * 63, 'index': 'invalidindex'}, {'key': 'b' * 63, 'index': 'invalidindex2'} ]) diff --git a/tests/tests_encryptionEngine/test_shard_key.py b/tests/tests_kavach/test_shard_key.py similarity index 81% rename from tests/tests_encryptionEngine/test_shard_key.py rename to tests/tests_kavach/test_shard_key.py index d5a9eb3..c3aa209 100644 --- a/tests/tests_encryptionEngine/test_shard_key.py +++ b/tests/tests_kavach/test_shard_key.py @@ -1,7 +1,7 @@ import unittest import asyncio import logging -from src.lighthouseweb3 import EncryptionManager +from src.lighthouseweb3 import Kavach logger = logging.getLogger(__name__) @@ -12,7 +12,7 @@ def test_shardKey_valid_32_byte_key(self): """Test shardKey with valid 32-byte keys.""" async def run_test(): valid_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" - result = await EncryptionManager.shardKey(valid_key, threshold=2, keyCount=3) + result = await Kavach.shardKey(valid_key, threshold=2, keyCount=3) self.assertTrue(result['isShardable']) self.assertIn('keyShards', result) @@ -27,7 +27,7 @@ async def run_test(): self.assertTrue(all(c in '0123456789abcdef' for c in shard['index'][2:])) valid_key_with_prefix = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" - result2 = await EncryptionManager.shardKey(valid_key_with_prefix, threshold=2, keyCount=3) + result2 = await Kavach.shardKey(valid_key_with_prefix, threshold=2, keyCount=3) self.assertTrue(result2['isShardable']) self.assertEqual(len(result2['keyShards']), 3) @@ -41,26 +41,26 @@ def test_shardKey_invalid_keys(self): async def run_test(): short_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcd" with self.assertRaises(ValueError) as context: - await EncryptionManager.shardKey(short_key, threshold=2, keyCount=3) + await Kavach.shardKey(short_key, threshold=2, keyCount=3) self.assertIn("Invalid key format", str(context.exception)) long_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12" with self.assertRaises(ValueError) as context: - await EncryptionManager.shardKey(long_key, threshold=2, keyCount=3) + await Kavach.shardKey(long_key, threshold=2, keyCount=3) self.assertIn("Invalid key format", str(context.exception)) malformed_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefg" with self.assertRaises(ValueError) as context: - await EncryptionManager.shardKey(malformed_key, threshold=2, keyCount=3) + await Kavach.shardKey(malformed_key, threshold=2, keyCount=3) self.assertIn("Invalid key format", str(context.exception)) with self.assertRaises(ValueError) as context: - await EncryptionManager.shardKey("", threshold=2, keyCount=3) + await Kavach.shardKey("", threshold=2, keyCount=3) self.assertIn("Invalid key format", str(context.exception)) invalid_hex = "xyz4567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" with self.assertRaises(ValueError) as context: - await EncryptionManager.shardKey(invalid_hex, threshold=2, keyCount=3) + await Kavach.shardKey(invalid_hex, threshold=2, keyCount=3) self.assertIn("Invalid key format", str(context.exception)) return asyncio.run(run_test()) @@ -70,23 +70,23 @@ def test_shardKey_threshold_keyCount_combinations(self): async def run_test(): valid_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" - result1 = await EncryptionManager.shardKey(valid_key, threshold=1, keyCount=1) + result1 = await Kavach.shardKey(valid_key, threshold=1, keyCount=1) self.assertTrue(result1['isShardable']) self.assertEqual(len(result1['keyShards']), 1) - result2 = await EncryptionManager.shardKey(valid_key, threshold=2, keyCount=3) + result2 = await Kavach.shardKey(valid_key, threshold=2, keyCount=3) self.assertTrue(result2['isShardable']) self.assertEqual(len(result2['keyShards']), 3) - result3 = await EncryptionManager.shardKey(valid_key, threshold=3, keyCount=5) + result3 = await Kavach.shardKey(valid_key, threshold=3, keyCount=5) self.assertTrue(result3['isShardable']) self.assertEqual(len(result3['keyShards']), 5) - result4 = await EncryptionManager.shardKey(valid_key, threshold=4, keyCount=4) + result4 = await Kavach.shardKey(valid_key, threshold=4, keyCount=4) self.assertTrue(result4['isShardable']) self.assertEqual(len(result4['keyShards']), 4) - result5 = await EncryptionManager.shardKey(valid_key, threshold=5, keyCount=10) + result5 = await Kavach.shardKey(valid_key, threshold=5, keyCount=10) self.assertTrue(result5['isShardable']) self.assertEqual(len(result5['keyShards']), 10) @@ -104,7 +104,7 @@ async def run_test(): valid_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" - result = await EncryptionManager.shardKey(valid_key, threshold=3, keyCount=20) + result = await Kavach.shardKey(valid_key, threshold=3, keyCount=20) self.assertTrue(result['isShardable']) self.assertEqual(len(result['keyShards']), 20) @@ -126,7 +126,7 @@ def test_shardKey_hex_format_consistency(self): async def run_test(): valid_key = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef" - result = await EncryptionManager.shardKey(valid_key, threshold=2, keyCount=4) + result = await Kavach.shardKey(valid_key, threshold=2, keyCount=4) self.assertTrue(result['isShardable']) From b25348385ac6795893cd216cd8793799fcf85a0d Mon Sep 17 00:00:00 2001 From: AnonO6 <21ucs043@gmail.com> Date: Sun, 13 Jul 2025 17:27:28 +0000 Subject: [PATCH 13/13] feat:added doc strings --- src/lighthouseweb3/__init__.py | 36 +++++++++++++++++++++++++++++----- 1 file changed, 31 insertions(+), 5 deletions(-) diff --git a/src/lighthouseweb3/__init__.py b/src/lighthouseweb3/__init__.py index 6078bba..f0562ee 100644 --- a/src/lighthouseweb3/__init__.py +++ b/src/lighthouseweb3/__init__.py @@ -230,8 +230,21 @@ def getTagged(self, tag: str): raise e class Kavach: + """ + Kavach is a simple library for generating and managing secrets. + + It uses Shamir's Secret Sharing algorithm to split a secret into multiple shares. + """ + @staticmethod - def generate(threshold: int, keyCount: int): + def generate(threshold: int, keyCount: int) -> List[Dict[str, Any]]: + """ + Generates a set of key shards with a given threshold and key count. + + :param threshold: int, The minimum number of shards required to recover the key. + :param keyCount: int, The number of shards to generate. + :return: List[Dict[str, Any]], A list of key shards. + """ try: return generate.generate(threshold, keyCount) except Exception as e: @@ -239,16 +252,29 @@ def generate(threshold: int, keyCount: int): @staticmethod - def recoverKey(keyShards: List[Dict[str, Any]]): + def recoverKey(keyShards: List[Dict[str, Any]]) -> int: + """ + Recovers a key from a set of key shards. + + :param keyShards: List[Dict[str, Any]], A list of key shards. + :return: int, The recovered key. + """ try: return recoverKey.recover_key(keyShards) except Exception as e: raise e @staticmethod - def shardKey(masterKey: int, threshold: int, keyCount: int): + def shardKey(masterKey: int, threshold: int, keyCount: int) -> List[Dict[str, Any]]: + """ + Splits a master key into multiple shards. + + :param masterKey: int, The master key to be split. + :param threshold: int, The minimum number of shards required to recover the key. + :param keyCount: int, The number of shards to generate. + :return: List[Dict[str, Any]], A list of key shards. + """ try: return shardKey.shard_key(masterKey, threshold, keyCount) except Exception as e: - raise e - \ No newline at end of file + raise e \ No newline at end of file