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))
