import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
@Override
public void onSignResult(@Nullable Exception error, ExchangeEntry exchangeEntry) {
    if (error != null) {
        getSupportFragmentManager().popBackStack();
        // Ignore wallet decryption errors
        if (!(error instanceof KeyCrypterException)) {
            DialogBuilder builder = DialogBuilder.warn(this, com.fillerino.wallet.R.string.trade_error);
            builder.setMessage(getString(com.fillerino.wallet.R.string.trade_error_sign_tx_message, error.getMessage()));
            builder.setPositiveButton(com.fillerino.wallet.R.string.button_ok, null)
                    .create().show();
        }
    } else if (exchangeEntry != null) {
        getSupportFragmentManager().popBackStack();
        replaceFragment(TradeStatusFragment.newInstance(exchangeEntry, true), containerRes);
    }
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
@Override
public void onAddCoinTaskFinished(Exception error, WalletAccount newAccount) {
    if (Dialogs.dismissAllowingStateLoss(getFragmentManager(), ADD_COIN_TASK_BUSY_DIALOG_TAG)) return;

    if (error != null) {
        if (error instanceof KeyCrypterException) {
            showPasswordRetryDialog();
        } else {
            ACRA.getErrorReporter().handleSilentException(error);
            Toast.makeText(getActivity(), com.fillerino.wallet.R.string.error_generic, Toast.LENGTH_LONG).show();
        }
    } else {
        destinationAccount = newAccount;
        destinationType = newAccount.getCoinType();
        onHandleNext();
    }
    addCoinAndProceedTask = null;
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
/**
 * Queue a request to decrypt this wallet. This returns immediately, as the
 * actual work is done on the network thread in order to ensure the thread
 * context is correct. Unhandled errors are reported back to Network.
 *
 * @param password password to decrypt the wallet with
 * @param onSuccess callback on success
 * @param onWalletNotEncrypted callback if the wallet is not encrypted
 * @param onCrypterError callback in case of an error in the key crypter
 * @param timeout timeout on queueing the work request
 * @param timeUnit time unit for the timeout
 */
public void decrypt(String password, Consumer<Object> onSuccess,
        Consumer<Object> onWalletNotEncrypted,
        Consumer<KeyCrypterException> onCrypterError,
        final long timeout, final TimeUnit timeUnit) {
    this.networkExecutor.execute((Runnable) () -> {
        final Wallet wallet = wallet();
        if (!wallet.isEncrypted()) {
            onCrypterError.accept(null);
        } else {
            final KeyCrypter keyCrypter = wallet().getKeyCrypter();

            if (keyCrypter == null) {
                throw new IllegalStateException("Wallet is encrypted but has no key crypter.");
            } else {
                try {
                    wallet().decrypt(keyCrypter.deriveKey(password));
                    encrypted.set(false);
                    onSuccess.accept(null);
                } catch (KeyCrypterException ex) {
                    onCrypterError.accept(ex);
                }
            }
        }
    });
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
public static MasternodeSignature signMessage(String strMessage, StringBuilder errorMessage, ECKey key)
{
    //ECKey ecKey = ECKey.fromPublicOnly(key.getBytes());
    try {
        byte dataToHash [] = (Utils.BITCOIN_SIGNED_MESSAGE_HEADER_BYTES+strMessage).getBytes(Charsets.UTF_8);


        ECKey.ECDSASignature signature = key.sign(Sha256Hash.twiceOf(dataToHash));

        return new MasternodeSignature(signature.encodeToDER());
    }
    catch (KeyCrypterException x)
    {

    }
    errorMessage.append("Sign failed");
    return null;
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
private static void forwardCoins(Transaction tx) {
    try {
        Coin value = tx.getValueSentToMe(kit.wallet());
        System.out.println("Forwarding " + value.toFriendlyString());
        // Now send the coins back! Send with a small fee attached to ensure rapid confirmation.
        final Coin amountToSend = value.subtract(Transaction.REFERENCE_DEFAULT_MIN_TX_FEE);
        final Wallet.SendResult sendResult = kit.wallet().sendCoins(kit.peerGroup(), forwardingAddress, amountToSend);
        checkNotNull(sendResult);  // We should never try to send more coins than we have!
        System.out.println("Sending ...");
        // Register a callback that is invoked when the transaction has propagated across the network.
        // This shows a second style of registering ListenableFuture callbacks, it works when you don't
        // need access to the object the future returns.
        sendResult.broadcastComplete.addListener(new Runnable() {
            @Override
            public void run() {
                // The wallet has changed now, it'll get auto saved shortly or when the app shuts down.
                System.out.println("Sent coins onwards! Transaction hash is " + sendResult.tx.getHashAsString());
            }
        }, MoreExecutors.directExecutor());
    } catch (KeyCrypterException | InsufficientMoneyException e) {
        // We don't use encrypted wallets in this example - can never happen.
        throw new RuntimeException(e);
    }
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
private void doRaiseFee(final KeyParameter encryptionKey) {
    // construct child-pays-for-parent
    final TransactionOutput outputToSpend = checkNotNull(findSpendableOutput(wallet, transaction, feeRaise));
    final Transaction transactionToSend = new Transaction(Constants.NETWORK_PARAMETERS);
    transactionToSend.addInput(outputToSpend);
    transactionToSend.addOutput(outputToSpend.getValue().subtract(feeRaise),
            wallet.freshAddress(KeyPurpose.CHANGE));
    transactionToSend.setPurpose(Transaction.Purpose.RAISE_FEE);

    final SendRequest sendRequest = SendRequest.forTx(transactionToSend);
    sendRequest.aesKey = encryptionKey;

    try {
        wallet.signTransaction(sendRequest);

        log.info("raise fee: cpfp {}", transactionToSend);

        wallet.commitTx(transactionToSend);
        application.broadcastTransaction(transactionToSend);

        state = State.DONE;
        updateView();

        dismiss();
    } catch (final KeyCrypterException x) {
        badPasswordView.setVisibility(View.VISIBLE);

        state = State.INPUT;
        updateView();

        passwordView.requestFocus();

        log.info("raise fee: bad spending password");
    }
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
@Test(expected = KeyCrypterException.class)
public void cannotImportEncryptedKey() {
    final ECKey key1 = new ECKey();
    chain.importKeys(ImmutableList.of(key1));
    chain = chain.toEncrypted("foobar");
    ECKey encryptedKey = chain.getKey(KeyChain.KeyPurpose.RECEIVE_FUNDS);
    assertTrue(encryptedKey.isEncrypted());

    BasicKeyChain chain2 = new BasicKeyChain();
    chain2.importKeys(ImmutableList.of(encryptedKey));
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
@Test(expected = KeyCrypterException.class)
public void cannotMixParams() throws Exception {
    chain = chain.toEncrypted("foobar");
    KeyCrypterScrypt scrypter = new KeyCrypterScrypt(2);    // Some bogus params.
    ECKey key1 = new ECKey().encrypt(scrypter, scrypter.deriveKey("other stuff"));
    chain.importKeys(key1);
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
@Override
public void onAddCoinTaskFinished(Exception error, WalletAccount newAccount) {
    if (Dialogs.dismissAllowingStateLoss(getSupportFragmentManager(), ADD_COIN_TASK_BUSY_DIALOG_TAG)) return;
    addCoinTask = null;
    final Intent result = new Intent();
    if (error != null) {
        if (error instanceof KeyCrypterException) {
            new AlertDialog.Builder(this)
                    .setTitle(getString(com.fillerino.wallet.R.string.unlocking_wallet_error_title))
                    .setMessage(com.fillerino.wallet.R.string.unlocking_wallet_error_detail)
                    .setPositiveButton(com.fillerino.wallet.R.string.button_retry, new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            showAddCoinDialog();
                        }
                    })
                    .setNegativeButton(com.fillerino.wallet.R.string.button_cancel, null)
                    .create().show();
        } else {
            String message = getResources().getString(com.fillerino.wallet.R.string.add_coin_error,
                    selectedCoin.getName(), error.getMessage());
            Toast.makeText(AddCoinsActivity.this, message, Toast.LENGTH_LONG).show();
            setResult(RESULT_CANCELED, result);
            finish();
        }
    } else {
        result.putExtra(Constants.ARG_ACCOUNT_ID, newAccount.getId());
        setResult(RESULT_OK, result);
        finish();
    }

}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
@Override
public boolean checkAESKey(KeyParameter aesKey) {
    checkNotNull(aesKey, "Cannot check null KeyParameter");
    checkState(getKeyCrypter() != null, "Key chain not encrypted");
    try {
        return rootKey.decrypt(aesKey).getPubKeyPoint().equals(rootKey.getPubKeyPoint());
    } catch (KeyCrypterException e) {
        return false;
    }
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
@Override
public boolean checkAESKey(KeyParameter aesKey) {
    checkNotNull(aesKey, "Cannot check null KeyParameter");
    checkNotNull(getKeyCrypter(), "Key not encrypted");
    try {
        return Arrays.equals(publicKey,
                Crypto.getPublicKey(entropy.decrypt(aesKey).getPrivKeyBytes()));
    } catch (KeyCrypterException e) {
        return false;
    }
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
private void doRaiseFee(final KeyParameter encryptionKey)
{
    // construct child-pays-for-parent
    final TransactionOutput outputToSpend = checkNotNull(findSpendableOutput(wallet, transaction));
    final Transaction transactionToSend = new Transaction(Constants.NETWORK_PARAMETERS);
    transactionToSend.addInput(outputToSpend);
    transactionToSend.addOutput(outputToSpend.getValue().subtract(FEE_RAISE), wallet.freshAddress(KeyPurpose.CHANGE));
    transactionToSend.setPurpose(Transaction.Purpose.RAISE_FEE);

    final SendRequest sendRequest = SendRequest.forTx(transactionToSend);
    sendRequest.aesKey = encryptionKey;

    try
    {
        wallet.signTransaction(sendRequest);

        log.info("raise fee: cpfp {}", transactionToSend);

        wallet.commitTx(transactionToSend);
        application.broadcastTransaction(transactionToSend);

        state = State.DONE;
        updateView();

        dismiss();
    }
    catch (final KeyCrypterException x)
    {
        badPasswordView.setVisibility(View.VISIBLE);

        state = State.INPUT;
        updateView();

        passwordView.requestFocus();

        log.info("raise fee: bad spending password");
    }
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
private static void decrypt() {
    if (password == null) {
        System.err.println("You must provide a --password");
        return;
    }
    if (!wallet.isEncrypted()) {
        System.err.println("This wallet is not encrypted.");
        return;
    }
    try {
        wallet.decrypt(password);
    } catch (KeyCrypterException e) {
        System.err.println("Password incorrect.");
    }
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
public void decryptWallet(BAPassword password) throws NoWalletPasswordException{
	if(isWalletEncrypted())
	if(password.hasPassword()){
		try {
			mWalletWrapper.decryptWallet(password.toString());
		}
		catch(KeyCrypterException returnException) { 
			throw new NoWalletPasswordException("Illegal Password");
		}
		LOG.info("Decrypted wallet with password: " + password.toString());
	}
	else
		throw new NoWalletPasswordException("Illegal Password");
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
/**
    * Will check if the given password can decrypt the wallet.<br>
    * If wallet is encrypted, at the end of the check will keep the wallet encrypted.<br>
    * If wallet is not encrypted or the password does decrypt the wallet, this will return true;
    * 
    * @param password
    * @return
    * @throws NoWalletPasswordException 
    */
private boolean checkIfPasswordDecryptsWallet(BAPassword password){
	if(Authenticator.getWalletOperation().isWalletEncrypted()){
   		try{
   			Authenticator.getWalletOperation().decryptWallet(password);
   			Authenticator.getWalletOperation().encryptWallet(password);
   		}
   		catch(KeyCrypterException | NoWalletPasswordException  e){
   			return false;
   		} 	
   	}
	
	return true;
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
private static void forwardCoins(Transaction tx) {
    try {
        Coin value = tx.getValueSentToMe(kit.wallet());
        System.out.println("Forwarding " + value.toFriendlyString());
        // Now send the coins back! Send with a small fee attached to ensure rapid confirmation.
        final Coin amountToSend = value.subtract(Transaction.REFERENCE_DEFAULT_MIN_TX_FEE);
        final Wallet.SendResult sendResult = kit.wallet().sendCoins(kit.peerGroup(), forwardingAddress, amountToSend);
        checkNotNull(sendResult);  // We should never try to send more coins than we have!
        System.out.println("Sending ...");
        // Register a callback that is invoked when the transaction has propagated across the network.
        // This shows a second style of registering ListenableFuture callbacks, it works when you don't
        // need access to the object the future returns.
        sendResult.broadcastComplete.addListener(new Runnable() {
            @Override
            public void run() {
                // The wallet has changed now, it'll get auto saved shortly or when the app shuts down.
                System.out.println("Sent coins onwards! Transaction hash is " + sendResult.tx.getHashAsString());
            }
        }, MoreExecutors.sameThreadExecutor());

        //MasternodeDB.dumpMasternodes();
        FlatDB<MasternodeManager> mndb = new FlatDB<MasternodeManager>(kit.directory().getAbsolutePath(),"mncache.dat", "magicMasternodeCache");
        mndb.dump(Context.get().masternodeManager);
    } catch (KeyCrypterException | InsufficientMoneyException e) {
        // We don't use encrypted wallets in this example - can never happen.
        throw new RuntimeException(e);
    }
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
public final void deriveKey(final Wallet wallet, final String password) {
    checkState(wallet.isEncrypted());
    final KeyCrypter keyCrypter = checkNotNull(wallet.getKeyCrypter());

    backgroundHandler.post(new Runnable() {
        @Override
        public void run() {
            org.bitcoinj.core.Context.propagate(Constants.CONTEXT);

            // Key derivation takes time.
            KeyParameter key = keyCrypter.deriveKey(password);
            boolean wasChanged = false;

            // If the key isn't derived using the desired parameters, derive a new key.
            if (keyCrypter instanceof KeyCrypterScrypt) {
                final long scryptIterations = ((KeyCrypterScrypt) keyCrypter).getScryptParameters().getN();

                if (scryptIterations != scryptIterationsTarget) {
                    log.info("upgrading scrypt iterations from {} to {}; re-encrypting wallet", scryptIterations,
                            scryptIterationsTarget);

                    final KeyCrypterScrypt newKeyCrypter = new KeyCrypterScrypt(scryptIterationsTarget);
                    final KeyParameter newKey = newKeyCrypter.deriveKey(password);

                    // Re-encrypt wallet with new key.
                    try {
                        wallet.changeEncryptionKey(newKeyCrypter, key, newKey);
                        key = newKey;
                        wasChanged = true;
                        log.info("scrypt upgrade succeeded");
                    } catch (final KeyCrypterException x) {
                        log.info("scrypt upgrade failed: {}", x.getMessage());
                    }
                }
            }

            // Hand back the (possibly changed) encryption key.
            final KeyParameter keyToReturn = key;
            final boolean keyToReturnWasChanged = wasChanged;
            callbackHandler.post(new Runnable() {
                @Override
                public void run() {
                    onSuccess(keyToReturn, keyToReturnWasChanged);
                }
            });
        }
    });
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
private void handleGo() {
    final String oldPassword = Strings.emptyToNull(oldPasswordView.getText().toString().trim());
    final String newPassword = Strings.emptyToNull(newPasswordView.getText().toString().trim());

    if (oldPassword != null && newPassword != null)
        log.info("changing spending password");
    else if (newPassword != null)
        log.info("setting spending password");
    else if (oldPassword != null)
        log.info("removing spending password");
    else
        throw new IllegalStateException();

    state = State.CRYPTING;
    updateView();

    backgroundHandler.post(new Runnable() {
        @Override
        public void run() {
            // For the old key, we use the key crypter that was used to derive the password in the first
            // place.
            final KeyParameter oldKey = oldPassword != null ? wallet.getKeyCrypter().deriveKey(oldPassword) : null;

            // For the new key, we create a new key crypter according to the desired parameters.
            final KeyCrypterScrypt keyCrypter = new KeyCrypterScrypt(application.scryptIterationsTarget());
            final KeyParameter newKey = newPassword != null ? keyCrypter.deriveKey(newPassword) : null;

            handler.post(new Runnable() {
                @Override
                public void run() {
                    if (wallet.isEncrypted()) {
                        if (oldKey == null) {
                            log.info("wallet is encrypted, but did not provide spending password");
                            state = State.INPUT;
                            oldPasswordView.requestFocus();
                        } else {
                            try {
                                wallet.decrypt(oldKey);

                                state = State.DONE;
                                log.info("wallet successfully decrypted");
                            } catch (final KeyCrypterException x) {
                                log.info("wallet decryption failed: " + x.getMessage());
                                badPasswordView.setVisibility(View.VISIBLE);
                                state = State.INPUT;
                                oldPasswordView.requestFocus();
                            }
                        }
                    }

                    if (newKey != null && !wallet.isEncrypted()) {
                        wallet.encrypt(keyCrypter, newKey);

                        log.info(
                                "wallet successfully encrypted, using key derived by new spending password ({} scrypt iterations)",
                                keyCrypter.getScryptParameters().getN());
                        state = State.DONE;
                    }

                    updateView();

                    if (state == State.DONE) {
                        application.backupWallet();
                        delayedDismiss();
                    }
                }

                private void delayedDismiss() {
                    handler.postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            dismiss();
                        }
                    }, 2000);
                }
            });
        }
    });
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
private void handleGo()
{
    final boolean isEncrypted = wallet.isEncrypted();
    final String oldPassword = oldPasswordView.getText().toString().trim();
    final String password = newPasswordView.getText().toString().trim();

    state = State.CRYPTING;
    updateView();

    backgroundHandler.post(new Runnable()
    {
        @Override
        public void run()
        {
            final byte[] salt = new byte[KeyCrypterScrypt.SALT_LENGTH];
            new SecureRandom().nextBytes(salt);
            final KeyCrypter keyCrypter = new KeyCrypterScrypt(Protos.ScryptParameters.newBuilder().setSalt(ByteString.copyFrom(salt))
                    .setN(SCRYPT_ITERATIONS).build());

            final KeyParameter oldKey = isEncrypted ? wallet.getKeyCrypter().deriveKey(oldPassword) : null;

            final KeyParameter newKey = password.isEmpty() ? null : keyCrypter.deriveKey(password);

            handler.post(new Runnable()
            {
                @Override
                public void run()
                {
                    try
                    {
                        if (oldKey != null)
                            wallet.decrypt(oldKey);

                        if (newKey != null)
                            wallet.encrypt(keyCrypter, newKey);

                        application.backupWallet();

                        state = State.DONE;
                        updateView();

                        log.info("spending password set or changed");

                        delayedDismiss();
                    }
                    catch (final KeyCrypterException x)
                    {
                        badPasswordView.setVisibility(View.VISIBLE);

                        state = State.INPUT;
                        updateView();

                        oldPasswordView.requestFocus();

                        log.info("remove or change of spending password failed");
                    }
                }

                private void delayedDismiss()
                {
                    handler.postDelayed(new Runnable()
                    {
                        @Override
                        public void run()
                        {
                            dismiss();
                        }
                    }, 2000);
                }
            });
        }
    });
}
 

import org.bitcoinj.crypto.KeyCrypterException; //导入依赖的package包/类
private static void importKey() {
    ECKey key;
    long creationTimeSeconds = getCreationTimeSeconds();
    if (options.has("privkey")) {
        String data = (String) options.valueOf("privkey");
        if (data.startsWith("5J") || data.startsWith("5H") || data.startsWith("5K")) {
            DumpedPrivateKey dpk;
            try {
                dpk = new DumpedPrivateKey(params, data);
            } catch (AddressFormatException e) {
                System.err.println("Could not parse dumped private key " + data);
                return;
            }
            key = dpk.getKey();
        } else {
            byte[] decode = Utils.parseAsHexOrBase58(data);
            if (decode == null) {
                System.err.println("Could not understand --privkey as either hex or base58: " + data);
                return;
            }
            key = ECKey.fromPrivate(new BigInteger(1, decode));
        }
        if (options.has("pubkey")) {
            // Give the user a hint.
            System.out.println("You don't have to specify --pubkey when a private key is supplied.");
        }
        key.setCreationTimeSeconds(creationTimeSeconds);
    } else if (options.has("pubkey")) {
        byte[] pubkey = Utils.parseAsHexOrBase58((String) options.valueOf("pubkey"));
        key = ECKey.fromPublicOnly(pubkey);
        key.setCreationTimeSeconds(creationTimeSeconds);
    } else {
        throw new IllegalStateException();
    }
    if (wallet.findKeyFromPubKey(key.getPubKey()) != null) {
        System.err.println("That key already exists in this wallet.");
        return;
    }
    try {
        if (wallet.isEncrypted()) {
            KeyParameter aesKey = passwordToKey(true);
            if (aesKey == null)
                return;   // Error message already printed.
            key = key.encrypt(checkNotNull(wallet.getKeyCrypter()), aesKey);
        }
        wallet.importKey(key);
        System.out.println(key.toAddress(params) + " " + key);
    } catch (KeyCrypterException kce) {
        System.err.println("There was an encryption related error when adding the key. The error was '" + kce.getMessage() + "'.");
    }
}