From b0105598da993d4d094f3a93964d0f491967c4bf Mon Sep 17 00:00:00 2001 From: MMGen Date: Tue, 11 Jun 2019 09:13:30 +0000 Subject: [PATCH] seed splitting: 'split' -> 'share' for all identifiers, where applicable --- mmgen/obj.py | 10 +++--- mmgen/seed.py | 44 +++++++++++------------ test/objtest_py_d/ot_btc_mainnet.py | 4 +-- test/unit_tests_d/ut_seedsplit.py | 54 ++++++++++++++--------------- 4 files changed, 56 insertions(+), 56 deletions(-) diff --git a/mmgen/obj.py b/mmgen/obj.py index 1d8a16d6..1d20935b 100755 --- a/mmgen/obj.py +++ b/mmgen/obj.py @@ -339,9 +339,9 @@ class MMGenIdx(int,InitErrors): except Exception as e: return cls.init_fail(e,num) -class SeedSplitIdx(MMGenIdx): max_val = 1024 -class SeedSplitCount(SeedSplitIdx): min_val = 2 -class MasterSplitIdx(MMGenIdx): max_val = 1024 +class SeedShareIdx(MMGenIdx): max_val = 1024 +class SeedShareCount(SeedShareIdx): min_val = 2 +class MasterShareIdx(MMGenIdx): max_val = 1024 class AddrIdx(MMGenIdx): max_digits = 7 class AddrIdxList(list,InitErrors,MMGenObject): @@ -872,8 +872,8 @@ class MMGenPWIDString(MMGenLabel): desc = 'password ID string' forbidden = list(' :/\\') -class SeedSplitIDString(MMGenPWIDString): - desc = 'seed split ID string' +class SeedShareIDString(MMGenPWIDString): + desc = 'seed share ID string' class MMGenAddrType(str,Hilite,InitErrors,MMGenObject): width = 1 diff --git a/mmgen/seed.py b/mmgen/seed.py index cacd880a..9b118893 100755 --- a/mmgen/seed.py +++ b/mmgen/seed.py @@ -206,11 +206,11 @@ class Seed(SeedBase): def subseed_by_seed_id(self,sid,last_idx=None,print_msg=False): return self.subseeds.get_subseed_by_seed_id(sid,last_idx=last_idx,print_msg=print_msg) - def splitlist(self,count,id_str=None): - return SeedSplitList(self,count,id_str) + def split(self,count,id_str=None): + return SeedShareList(self,count,id_str) @staticmethod - def join_splits(seed_list): + def join_shares(seed_list): if not hasattr(seed_list,'__next__'): # seed_list can be iterator or iterable seed_list = iter(seed_list) @@ -219,7 +219,7 @@ class Seed(SeedBase): ret = 0 count = 0 - def add_split(ss): + def add_share(ss): if d.slen: assert ss.length == d.slen,'Seed length mismatch! {} != {}'.format(ss.length,d.slen) else: @@ -228,9 +228,9 @@ class Seed(SeedBase): d.count += 1 for ss in seed_list: - add_split(ss) + add_share(ss) - SeedSplitCount(d.count) + SeedShareCount(d.count) return Seed(seed_bin=d.ret.to_bytes(d.slen // 8,'big')) class SubSeed(SeedBase): @@ -257,15 +257,15 @@ class SubSeed(SeedBase): byte_len = 16 if short else seed.length // 8 return scramble_seed(seed.data,scramble_key)[:byte_len] -class SeedSplitList(SubSeedList): +class SeedShareList(SubSeedList): have_short = False split_type = 'N-of-N' - count = MMGenImmutableAttr('count',SeedSplitCount) - id_str = MMGenImmutableAttr('id_str',SeedSplitIDString) + count = MMGenImmutableAttr('count',SeedShareCount) + id_str = MMGenImmutableAttr('id_str',SeedShareIDString) def __init__(self,parent_seed,count,id_str=None): - self.member_type = SeedSplit + self.member_type = SeedShare self.parent_seed = parent_seed self.id_str = id_str or 'default' self.count = count @@ -273,8 +273,8 @@ class SeedSplitList(SubSeedList): while True: self.data = { 'long': IndexedDict(), 'short': IndexedDict() } self._generate(count-1) - self.last_split = SeedSplitLast(self) - sid = self.last_split.sid + self.last_share = SeedShareLast(self) + sid = self.last_share.sid if sid in self.data['long'] or sid == parent_seed.sid: # collision: throw out entire split list and redo with new start nonce if g.debug_subseed: @@ -289,21 +289,21 @@ class SeedSplitList(SubSeedList): B = self.join().data assert A == B,'Data mismatch!\noriginal seed: {!r}\nrejoined seed: {!r}'.format(A,B) - def get_split_by_idx(self,idx): + def get_share_by_idx(self,idx): if idx == self.count: - return self.last_split + return self.last_share else: ss_idx = SubSeedIdx(str(idx) + 'L') return self.get_subseed_by_ss_idx(ss_idx) - def get_split_by_seed_id(self,sid,last_idx=None): + def get_share_by_seed_id(self,sid,last_idx=None): if sid == self.data['long'].key(self.count-1): - return self.last_split + return self.last_share else: return self.get_subseed_by_seed_id(sid,last_idx=last_idx) def join(self): - return Seed.join_splits(self.get_split_by_idx(i+1) for i in range(len(self))) + return Seed.join_shares(self.get_share_by_idx(i+1) for i in range(len(self))) def format(self): assert self.split_type == 'N-of-N' @@ -313,7 +313,7 @@ class SeedSplitList(SubSeedList): hdr = ' {} {} ({} bits)\n'.format('Seed:',self.parent_seed.sid.hl(),self.parent_seed.length) hdr += ' {} {c}-of-{c} (XOR)\n'.format('Split Type:',c=self.count) hdr += ' {} {}\n\n'.format('ID String:',self.id_str.hl()) - hdr += fs1.format('Splits') + hdr += fs1.format('Shares') hdr += fs1.format('------') sl = self.data['long'].keys @@ -321,7 +321,7 @@ class SeedSplitList(SubSeedList): return hdr + ''.join(body) -class SeedSplit(SubSeed): +class SeedShare(SubSeed): @staticmethod def make_subseed_bin(parent_list,idx:int,nonce:int,length:str): @@ -336,9 +336,9 @@ class SeedSplit(SubSeed): byte_len = seed.length // 8 return scramble_seed(seed.data,scramble_key)[:byte_len] -class SeedSplitLast(SubSeed): +class SeedShareLast(SubSeed): - idx = MMGenImmutableAttr('idx',SeedSplitIdx) + idx = MMGenImmutableAttr('idx',SeedShareIdx) nonce = 0 def __init__(self,parent_list): @@ -347,7 +347,7 @@ class SeedSplitLast(SubSeed): @staticmethod def make_subseed_bin(parent_list): - seed_list = (parent_list.get_split_by_idx(i+1) for i in range(len(parent_list))) + seed_list = (parent_list.get_share_by_idx(i+1) for i in range(len(parent_list))) seed = parent_list.parent_seed ret = int(seed.data.hex(),16) diff --git a/test/objtest_py_d/ot_btc_mainnet.py b/test/objtest_py_d/ot_btc_mainnet.py index 2702a533..ceeff1a3 100755 --- a/test/objtest_py_d/ot_btc_mainnet.py +++ b/test/objtest_py_d/ot_btc_mainnet.py @@ -18,11 +18,11 @@ tests = OrderedDict([ 'bad': ('s',1.1,10000000,-1,0), 'good': (('7',7),(1,1),(9999999,9999999)) }), - ('SeedSplitIdx', { + ('SeedShareIdx', { 'bad': ('s',1.1,1025,-1,0), 'good': (('7',7),(1,1),(1024,1024)) }), - ('SeedSplitCount', { + ('SeedShareCount', { 'bad': ('s',2.1,1025,-1,0,1), 'good': (('7',7),(2,2),(1024,1024)) }), diff --git a/test/unit_tests_d/ut_seedsplit.py b/test/unit_tests_d/ut_seedsplit.py index fdcd466b..7a2a767d 100755 --- a/test/unit_tests_d/ut_seedsplit.py +++ b/test/unit_tests_d/ut_seedsplit.py @@ -9,7 +9,7 @@ class unit_test(object): def run_test(self,name): from mmgen.seed import Seed - from mmgen.obj import SeedSplitIdx + from mmgen.obj import SeedShareIdx def basic_ops(): test_data = { @@ -34,29 +34,29 @@ class unit_test(object): seed = Seed(seed_bin) assert seed.sid == b, seed.sid - for split_count,j,k,l in ((2,c,c,d),(5,e,f,h)): + for share_count,j,k,l in ((2,c,c,d),(5,e,f,h)): - splitlist = seed.splitlist(split_count,id_str) - A = len(splitlist) - assert A == split_count, A + shares = seed.split(share_count,id_str) + A = len(shares) + assert A == share_count, A - s = splitlist.format() + s = shares.format() vmsg_r('\n{}'.format(s)) - assert len(s.strip().split('\n')) == split_count+6, s + assert len(s.strip().split('\n')) == share_count+6, s - A = splitlist.get_split_by_idx(1).sid - B = splitlist.get_split_by_seed_id(j).sid + A = shares.get_share_by_idx(1).sid + B = shares.get_share_by_seed_id(j).sid assert A == B == j, A - A = splitlist.get_split_by_idx(split_count-1).sid - B = splitlist.get_split_by_seed_id(k).sid + A = shares.get_share_by_idx(share_count-1).sid + B = shares.get_share_by_seed_id(k).sid assert A == B == k, A - A = splitlist.get_split_by_idx(split_count).sid - B = splitlist.get_split_by_seed_id(l).sid + A = shares.get_share_by_idx(share_count).sid + B = shares.get_share_by_seed_id(l).sid assert A == B == l, A - A = splitlist.join().sid + A = shares.join().sid assert A == b, A msg('OK') @@ -67,17 +67,17 @@ class unit_test(object): seed_bin = bytes.fromhex('deadbeef' * 8) seed = Seed(seed_bin) - splitlist = seed.splitlist(SeedSplitIdx.max_val) - s = splitlist.format() + shares = seed.split(SeedShareIdx.max_val) + s = shares.format() # vmsg_r('\n{}'.format(s)) assert len(s.strip().split('\n')) == 1030, s - A = splitlist.get_split_by_idx(1024).sid - B = splitlist.get_split_by_seed_id('4BA23728').sid + A = shares.get_share_by_idx(1024).sid + B = shares.get_share_by_seed_id('4BA23728').sid assert A == '4BA23728', A assert B == '4BA23728', B - A = splitlist.join().sid + A = shares.join().sid B = seed.sid assert A == B, A @@ -86,24 +86,24 @@ class unit_test(object): def collisions(): ss_count,last_sid,collisions_chk = (65535,'B5CBCE0A',3) - msg_r('Testing Seed ID collisions ({} seed splits)...'.format(ss_count)) + msg_r('Testing Seed ID collisions ({} seed shares)...'.format(ss_count)) vmsg('') seed_bin = bytes.fromhex('1dabcdef' * 4) seed = Seed(seed_bin) - SeedSplitIdx.max_val = ss_count - splitlist = seed.splitlist(ss_count) - A = splitlist.get_split_by_idx(ss_count).sid - B = splitlist.get_split_by_seed_id(last_sid).sid + SeedShareIdx.max_val = ss_count + shares = seed.split(ss_count) + A = shares.get_share_by_idx(ss_count).sid + B = shares.get_share_by_seed_id(last_sid).sid assert A == last_sid, A assert B == last_sid, B - assert splitlist.nonce_start == 0, splitlist.nonce_start + assert shares.nonce_start == 0, shares.nonce_start collisions = 0 - for sid in splitlist.data['long']: - collisions += splitlist.data['long'][sid][1] + for sid in shares.data['long']: + collisions += shares.data['long'][sid][1] assert collisions == collisions_chk, collisions vmsg_r('\n{} collisions, last_sid {}'.format(collisions,last_sid))