def do_keygen(args): if args.key_name is not None: key_name = args.key_name else: key_name = getpass.getuser() if args.key_dir is not None: key_dir = args.key_dir if not os.path.exists(key_dir): raise CliException('no such directory: {}'.format(key_dir)) else: key_dir = os.path.join(os.path.expanduser('~'), '.sawtooth', 'keys') if not os.path.exists(key_dir): if not args.quiet: print('creating key directory: {}'.format(key_dir)) try: os.makedirs(key_dir) except IOError as e: raise CliException('IOError: {}'.format(str(e))) wif_filename = os.path.join(key_dir, key_name + '.wif') addr_filename = os.path.join(key_dir, key_name + '.addr') if not args.force: file_exists = False for filename in [wif_filename, addr_filename]: if os.path.exists(filename): file_exists = True print('file exists: {}'.format(filename), file=sys.stderr) if file_exists: raise CliException( 'files exist, rerun with --force to overwrite existing files') privkey = signing.generate_privkey() encoded = signing.encode_privkey(privkey) pubkey = signing.generate_pubkey(privkey) addr = signing.generate_identifier(pubkey) try: wif_exists = os.path.exists(wif_filename) with open(wif_filename, 'w') as wif_fd: if not args.quiet: if wif_exists: print('overwriting file: {}'.format(wif_filename)) else: print('writing file: {}'.format(wif_filename)) wif_fd.write(encoded) wif_fd.write('\n') addr_exists = os.path.exists(addr_filename) with open(addr_filename, 'w') as addr_fd: if not args.quiet: if addr_exists: print('overwriting file: {}'.format(addr_filename)) else: print('writing file: {}'.format(addr_filename)) addr_fd.write(addr) addr_fd.write('\n') except IOError as ioe: raise CliException('IOError: {}'.format(str(ioe)))
def _recover_verifying_address(self): assert self.Signature if not self._originator_id: self._originator_id = \ self.signature_cache[self.Signature] if not self._originator_id: self._originator_id = \ signing.generate_identifier(self.originator_public_key) self.signature_cache[self.Signature] = self._originator_id
def generate_identifier(signingkey): """Generates encoded version of the public key associated with signingkey. Args: signingkey (str): A private key. Returns: str: An encoded 'address' associated with the public key. """ return signing.generate_identifier(signing.generate_pubkey(signingkey))
def __init__(self, base_url, store_name=None, name='SawtoothClient', txntype_name=None, msgtype_name=None, keystring=None, keyfile=None, disable_client_validation=False): self._base_url = base_url self._message_type = msgtype_name self._transaction_type = txntype_name # an explicit store name takes precedence over a store name # implied by the transaction type self._store_name = None if store_name is not None: self._store_name = store_name.strip('/') elif txntype_name is not None: self._store_name = txntype_name.strip('/') self._communication = _Communication(base_url) self._last_transaction = None self._signing_key = None self._identifier = None self._update_batch = None self._disable_client_validation = disable_client_validation if keystring: LOGGER.debug("set signing key from string\n%s", keystring) self._signing_key = signing.encode_privkey( signing.decode_privkey(keystring, 'wif'), 'hex') elif keyfile: LOGGER.debug("set signing key from file %s", keyfile) try: self._signing_key = signing.encode_privkey( signing.decode_privkey( open(keyfile, "r").read().strip(), 'wif'), 'hex') except IOError as ex: raise ClientException("Failed to load key file: {}".format( str(ex))) if self._signing_key is not None: self._identifier = signing.generate_identifier( signing.generate_pubkey(self._signing_key))
def do_init(args, config): username = config.get('DEFAULT', 'username') if args.username is not None: username = args.username url = config.get('DEFAULT', 'url') if args.url is not None: url = args.url config.set('DEFAULT', 'username', username) print("set username: {}".format(username)) config.set('DEFAULT', 'url', url) print("set url: {}".format(url)) save_config(config) wif_filename = config.get('DEFAULT', 'key_file') if wif_filename.endswith(".wif"): addr_filename = wif_filename[0:-len(".wif")] + ".addr" else: addr_filename = wif_filename + ".addr" if not os.path.exists(wif_filename): try: if not os.path.exists(os.path.dirname(wif_filename)): os.makedirs(os.path.dirname(wif_filename)) privkey = signing.generate_privkey() encoded = signing.encode_privkey(privkey, 'wif') pubkey = signing.generate_pubkey(privkey) addr = signing.generate_identifier(pubkey) with open(wif_filename, "w") as wif_fd: print("writing file: {}".format(wif_filename)) wif_fd.write(encoded) wif_fd.write("\n") with open(addr_filename, "w") as addr_fd: print("writing file: {}".format(addr_filename)) addr_fd.write(addr) addr_fd.write("\n") except IOError as ioe: raise XoException("IOError: {}".format(str(ioe)))
def find_or_create_test_key(key_base_name, key_dir=None, quiet=True): ''' Interface to sawtooth cli: creates .wif key file if it does not exist, and returns a tupple containing all pertinent information. Useful for testing. Args: key_base_name: (str) key_dir: (str) Returns: (tupple) key_file: (str) private_key: (str) public_key: (str) ''' use_key_dir = key_dir is not None and not os.path.isabs(key_base_name) key_file = key_base_name if not key_file.endswith('.wif'): key_file += '.wif' if use_key_dir: key_file = os.path.join(key_dir, key_file) if not os.path.isfile(key_file): if key_base_name.endswith('.wif'): key_base_name = ''.join(key_base_name.split('.')[:-1]) cmd = 'keygen %s' % key_base_name if use_key_dir: cmd += ' --key-dir %s' % key_dir if quiet is True: cmd += ' -q' sawtooth_cli_intercept(cmd) assert os.path.exists(key_file) with open(key_file, 'r') as f: key_str = f.read() signing_key = key_str.split('\n')[0] identifier = signing.generate_identifier( signing.generate_pubkey(signing_key)) addr_file = '.'.join(key_file.split('.')[:-1]) + '.addr' if not os.path.exists(addr_file): with open(addr_file, 'w') as f: f.write('{}\n'.format(identifier)) return key_file, signing_key, identifier
def __init__(self): self.SigningKey = signing.generate_privkey() self.Address = signing.generate_identifier( signing.generate_pubkey(self.SigningKey))
addr_filename = os.path.join(key_dir, key_name + '.addr') if not args.force: file_exists = False for filename in [wif_filename, addr_filename]: if os.path.exists(filename): file_exists = True print >> sys.stderr, 'file exists: {}'.format(filename) if file_exists: raise ClientException( 'files exist, rerun with --force to overwrite existing files') privkey = signing.generate_privkey() encoded = signing.encode_privkey(privkey) pubkey = signing.generate_pubkey(privkey) addr = signing.generate_identifier(pubkey) try: wif_exists = os.path.exists(wif_filename) with open(wif_filename, 'w') as wif_fd: if not args.quiet: if wif_exists: print 'overwriting file: {}'.format(wif_filename) else: print 'writing file: {}'.format(wif_filename) wif_fd.write(encoded) wif_fd.write('\n') addr_exists = os.path.exists(addr_filename) with open(addr_filename, 'w') as addr_fd: if not args.quiet:
def get_address_from_private_key_wif(key): return signing.generate_identifier( signing.generate_pubkey(signing.decode_privkey(key, 'wif')))
def check_valid(self, store, txn): """ Verify the validity of the update Args: store: The local store for bond transactions txn: Ignored Returns: Nothing Throws InvalidTransactionError if not valid. """ LOGGER.debug('checking %s', str(self)) # A LIBOR transaction requires the following: # 1. The update must be signed by a well-known key. Currently this key # has been generated by us, but eventually it is hoped to be the # private counterpart to a public key published by the organization # that provides the LIBORs. if self.__libor_object__.Signature is None: raise InvalidTransactionError('LIBOR data has not been signed') libor_publisher_addr = \ signing.generate_identifier(self._libor_public_key) if not self.__libor_object__.verify_signature(libor_publisher_addr): raise InvalidTransactionError( 'Key used to sign LIBOR data does not match publisher') # 2. The date must be present, must be in IOS-8601 format, and may not # be a date in the future. if self.__libor_object__.date is None: raise InvalidTransactionError('Date is not set') # Try to convert the date from an ISO-8601 string ("YYYY-MM-DD") to # a date object. An exception indicates that the format is invalid. try: the_date = \ datetime.strptime( self.__libor_object__.date, "%Y-%m-%d").date() except TypeError: raise InvalidTransactionError( 'Date value <{}> must be a string value'.format( self.__libor_object__.date)) except ValueError: raise InvalidTransactionError( 'Date <{}> is invalid or not in YYYY-MM-DD format'.format( self.__libor_object__.date)) if the_date > datetime.utcnow().date(): raise InvalidTransactionError( 'Date <{0}> is in the future. Today is <{1}>.'.format( the_date.isoformat(), datetime.utcnow().date().isoformat())) # 3. The data must not already be in the store (i.e., rates have # not already been submitted for this date by some validator). if self._object_id in store: raise InvalidTransactionError( 'Rates have already been set for {}'.format( self.__libor_object__.date)) # 4. Each rate must not be NaN for maturity, rate in self.__libor_object__.rates.items(): if math.isnan(rate): raise InvalidTransactionError( '{} maturity does not contain a valid rate'.format( maturity))