def pad_and_checksum(s, compact, checksum): """Apply length padding and checksum to a string""" assert isinstance(s, bytes) if checksum: k = Keccak() k.absorb(s) checksum_length = max(1, (len(s)-1).bit_length()) checksum = k.squeeze(checksum_length) length = chr(checksum_length) if compact else encode_varint(len(s), endian='little') return s + checksum + length else: length = '\x01' if compact else encode_varint(len(s), endian='little') return s + length
def pad_and_checksum(s, compact, checksum): """Apply length padding and checksum to a string""" assert isinstance(s, bytes) if checksum: k = Keccak() k.absorb(s) checksum_length = max(1, (len(s) - 1).bit_length()) checksum = k.squeeze(checksum_length) length = chr(checksum_length) if compact else encode_varint( len(s), endian='little') return s + checksum + length else: length = '\x01' if compact else encode_varint(len(s), endian='little') return s + length
def encode(s, compact=False): """From a byte string, produce a list of words that durably encodes the string. s: the byte string to be encoded compact: instead of using the length encoding scheme, pad by prepending a 1 bit The words in the encoding dictionary were chosen to be common and unambiguous. The encoding also includes a checksum. The encoding is constructed so that common errors are extremely unlikely to produce a valid encoding. """ if not isinstance(s, bytes): raise TypeError("mnemonic.encode can only encode byte strings") k = Keccak() k.absorb(s) checksum_length = max(1, (len(s)-1).bit_length()) checksum = k.squeeze(checksum_length) length = chr(checksum_length) if compact else encode_varint(len(s), endian='little') s += checksum s += length word_index = 0 i = bytes2int(s) retval = [None] * int(floor(log(i, len(words)) + 1)) for j in xrange(len(retval)): assert i > 0 word_index += i % len(words) word_index %= len(words) retval[j] = words[word_index] i //= len(words) assert i == 0 return tuple(retval)
def encode(s, compact=False): """From a byte string, produce a list of words that durably encodes the string. s: the byte string to be encoded compact: instead of using the length encoding scheme, pad by prepending a 1 bit The words in the encoding dictionary were chosen to be common and unambiguous. The encoding also includes a checksum. The encoding is constructed so that common errors are extremely unlikely to produce a valid encoding. """ if not isinstance(s, bytes): raise TypeError("mnemonic.encode can only encode byte strings") k = Keccak() k.absorb(s) checksum_length = max(1, (len(s) - 1).bit_length()) checksum = k.squeeze(checksum_length) length = chr(checksum_length) if compact else encode_varint( len(s), endian='little') s += checksum s += length word_index = 0 i = bytes2int(s) retval = [None] * int(floor(log(i, len(words)) + 1)) for j in xrange(len(retval)): assert i > 0 word_index += i % len(words) word_index %= len(words) retval[j] = words[word_index] i //= len(words) assert i == 0 return tuple(retval)
def from_seed_index(cls, seed, depth, index): if not isinstance(seed, bytes): raise TypeError('seed must be a bytes') if not isinstance(depth, Integral): raise TypeError('depth must be an Integral') if not isinstance(index, Integral): raise TypeError('index must be an Integral') k = keccak.Keccak(**_keccak_args) seed = k.pad10star1(seed, k.r) k.update(seed) depth = encode_varint(depth,endian='big') depth = k.pad10star1(depth, k.r) k.update(depth) index = encode_varint(index,endian='big') # k will automatically pad index upon squeezing k.update(index) raw_key_material = k.squeeze(key_size * num_subkey_pairs * 2) subkey_type = globals()[cls.subkey_type] temp = ( subkey_type(''.join(subkey)) for subkey in _grouper(raw_key_material, key_size) ) temp = tuple(temp) return cls(temp)
def string_to_element(s): if not isinstance(s, bytes): s = int2bytes(s, endian='little') if len(s) > 30: raise ValueError("Argument too large to fit into an element") encoded_length = encode_varint(len(s), endian='little') null_padding = '\x00' * (31 - len(encoded_length) - len(s)) s += null_padding s += encoded_length s = bytes2int(s, endian='little') if s >= p: raise ValueError("Argument too large to fit into an element") s = Element(s) return s
def serialize(self): retval = ''.join(imap(methodcaller('serialize'), self)) return self.tag_byte+encode_varint(len(self),endian='big')+retval
def serialize(self): return self.tag_byte+encode_varint(len(self),endian='big')+self