Пример #1
0
def test_key(
    filename,
    testname,
    testdata,
):
    logger.debug('running test:%r in %r' % (testname, filename))
    assert keys.check_keystore_json(testdata["json"])
    privkey = keys.decode_keystore_json(testdata["json"], testdata["password"])
    assert utils.encode_hex(privkey) == utils.to_string(testdata["priv"])
Пример #2
0
 def unlock(self, password):
     """Unlock the account with a password.
     If the account is already unlocked, nothing happens, even if the password is wrong.
     :raises: :exc:`ValueError` (originating in ethereum.keys) if the password is wrong (and the
              account is locked)
     """
     if self.locked:
         self._privkey = keys.decode_keystore_json(self.keystore, password)
         self.locked = False
         self.address  # get address such that it stays accessible after a subsequent lock
Пример #3
0
 def unlock(self, password):
     """Unlock the account with a password.
     If the account is already unlocked, nothing happens, even if the password is wrong.
     :raises: :exc:`ValueError` (originating in ethereum.keys) if the password is wrong (and the
              account is locked)
     """
     if self.locked:
         self._privkey = keys.decode_keystore_json(self.keystore, password)
         self.locked = False
         self.address  # get address such that it stays accessible after a subsequent lock
Пример #4
0
 def __init__(self, datadir):
     keyfile = path.join(datadir, 'ethkey.json')
     if path.exists(keyfile):
         data = json.load(open(keyfile, 'r'))
         self.priv = keys.decode_keystore_json(data, "FIXME: password!")
     else:
         self.priv = os.urandom(32)
         data = keys.make_keystore_json(self.priv, "FIXME: password!")
         json.dump(data, open(keyfile, 'w'))
     self.address = keys.privtoaddr(self.priv)
Пример #5
0
 def __init__(self, datadir):
     keyfile = path.join(datadir, 'ethkey.json')
     if path.exists(keyfile):
         data = json.load(open(keyfile, 'r'))
         self.priv = keys.decode_keystore_json(data, "FIXME: password!")
     else:
         self.priv = os.urandom(32)
         data = keys.make_keystore_json(self.priv, "FIXME: password!")
         json.dump(data, open(keyfile, 'w'))
     self.address = keys.privtoaddr(self.priv)
Пример #6
0
    def unlock(self, password):
        """Unlock the account with a password.

        If the account is already unlocked, nothing happens, even if the password is wrong.

        :raises: :exc:`ValueError` (originating in ethereum.keys) if the password is wrong (and the
                 account is locked)
        """
        if self.locked:
            self._privkey = keys.decode_keystore_json(self.keystore, password)
            self.locked = False
Пример #7
0
    def unlock(self, password):
        """Unlock the account with a password.

        If the account is already unlocked, nothing happens, even if the password is wrong.

        :raises: :exc:`ValueError` (originating in ethereum.keys) if the password is wrong (and the
                 account is locked)
        """
        if self.locked:
            self._privkey = keys.decode_keystore_json(self.keystore, password)
            self.locked = False
Пример #8
0
def load_wallet( wallet_filename, password ):

    assert os.path.isfile( wallet_filename )

    with open( wallet_filename ) as f:
        wallet_json = json.load(f)

        address = wallet_json['address']
        priv_key = decode_keystore_json(wallet_json, password)

        return address, priv_key
Пример #9
0
    def __init__(self, keyfile, passfile_or_password):
        with open(keyfile) as data_file:
            data = json.load(data_file)

        if os.path.isfile(passfile_or_password):
            with open(passfile_or_password) as f:
                password = f.read().strip('\n')
        else:
            password = passfile_or_password

        privkey_bin = decode_keystore_json(data, password)
        self.private_key = PrivateKey(privkey_bin)
Пример #10
0
def get_private_key(key_path, password_path=None):
    """Open a JSON-encoded private key and return it

    If a password file is provided, uses it to decrypt the key. If not, the
    password is asked interactively. Raw hex-encoded private keys are supported,
    but deprecated."""

    assert key_path, key_path
    if not os.path.exists(key_path):
        log.fatal("%s: no such file", key_path)
        return None

    if not check_permission_safety(key_path):
        log.fatal("Private key file %s must be readable only by its owner.",
                  key_path)
        return None

    if password_path and not check_permission_safety(password_path):
        log.fatal("Password file %s must be readable only by its owner.",
                  password_path)
        return None

    with open(key_path) as keyfile:
        private_key = keyfile.readline().strip()

        if is_hex(private_key) and len(decode_hex(private_key)) == 32:
            log.warning(
                "Private key in raw format. Consider switching to JSON-encoded"
            )
        else:
            keyfile.seek(0)
            try:
                json_data = json.load(keyfile)
                if password_path:
                    with open(password_path) as password_file:
                        password = password_file.readline().strip()
                else:
                    password = getpass.getpass(
                        "Enter the private key password: "******"Invalid private key format or password!")
                return None

    return private_key
Пример #11
0
def get_private_key(key_path, password_path=None):
    """Open a JSON-encoded private key and return it

    If a password file is provided, uses it to decrypt the key. If not, the
    password is asked interactively. Raw hex-encoded private keys are supported,
    but deprecated."""

    assert key_path, key_path
    if not os.path.exists(key_path):
        log.fatal("%s: no such file", key_path)
        return None

    if not check_permission_safety(key_path):
        log.fatal("Private key file %s must be readable only by its owner.", key_path)
        return None

    if password_path and not check_permission_safety(password_path):
        log.fatal("Password file %s must be readable only by its owner.", password_path)
        return None

    with open(key_path) as keyfile:
        private_key = keyfile.readline().strip()

        if is_hex(private_key) and len(decode_hex(private_key)) == 32:
            log.warning("Private key in raw format. Consider switching to JSON-encoded")
        else:
            keyfile.seek(0)
            try:
                json_data = json.load(keyfile)
                if password_path:
                    with open(password_path) as password_file:
                        password = password_file.readline().strip()
                else:
                    password = getpass.getpass("Enter the private key password: "******"Invalid private key format or password!")
                return None

    return private_key
Пример #12
0
def test_key(filename, testname, testdata,):
    logger.debug('running test:%r in %r' % (testname, filename))
    assert keys.check_keystore_json(testdata["json"])
    privkey = keys.decode_keystore_json(testdata["json"], testdata["password"])
    assert utils.encode_hex(privkey) == utils.to_string(testdata["priv"])
Пример #13
0
print('                        Gas: ' + str(tx.startgas))
print('                  Gas Price: ' + str(tx.gasprice))
print('Transaction amount (in wei): ' + str(tx.value))
print('Transaction amount (in eth): ' + str(web3.fromWei(tx.value, 'ether')))
print('                 From Nonce: ' + str(tx.nonce))
print('                 To Address: ' + web3.toHex(tx.to))
print('           Transaction Data: ' + web3.toHex(tx.data))
print('======================================================')

# Using file wallet to sign transaction
if args.keytype == 'file':
    json = json.loads(open(args.keyfile).read())
    print("Enter password of keyfile or ctrl+c to cancel")
    pw = getpass()
    print("Applying hard key derivation function. Wait a little")
    k = decode_keystore_json(json, pw)

    # Prepare a new transaction (decoded transaction seems immutable...)
    tx = Transaction(
        tx.nonce, tx.gasprice, tx.startgas, tx.to, tx.value, tx.data
    )
    tx.sign(k)

# Using Ledger HW1 in DEV mode (SIGNVERIFY_IMMEDIATE)
if args.keytype == 'dongle':
    from btchip.btchip import getDongle, btchip
    from bitcoin import decode_sig as bitcoin_decode_sig
    dongle = getDongle(True)
    app = btchip(dongle)
    print("Enter pin of dongle or ctrl+c to cancel")
    pin = getpass('Pin:')
Пример #14
0
def do_test_key(filename, testname=None, testdata=None, limit=99999999):
    logger.debug('running test:%r in %r' % (testname, filename))
    privkey = keys.decode_keystore_json(testdata["json"], testdata["password"])
    assert utils.encode_hex(privkey) == utils.to_string(testdata["priv"])
Пример #15
0
def do_test_key(filename, testname=None, testdata=None, limit=99999999):
    logger.debug('running test:%r in %r' % (testname, filename))
    privkey = keys.decode_keystore_json(testdata["json"], testdata["password"])
    assert utils.encode_hex(privkey) == utils.to_string(testdata["priv"])