import org.bitcoinj.crypto.EncryptedData; //导入依赖的package包/类
public static Protos.Key.Builder serializeEncryptableItem(EncryptableItem item) {
    Protos.Key.Builder proto = Protos.Key.newBuilder();
    if (item.isEncrypted() && item.getEncryptedData() != null) {
        // The encrypted data can be missing for an "encrypted" key in the case of a deterministic wallet for
        // which the leaf keys chain to an encrypted parent and rederive their private keys on the fly. In that
        // case the caller in DeterministicKeyChain will take care of setting the type.
        EncryptedData data = item.getEncryptedData();
        proto.getEncryptedDataBuilder()
                .setEncryptedPrivateKey(ByteString.copyFrom(data.encryptedBytes))
                .setInitialisationVector(ByteString.copyFrom(data.initialisationVector));
        // We don't allow mixing of encryption types at the moment.
        checkState(item.getEncryptionType() == org.bitcoinj.wallet.Protos.Wallet.EncryptionType.ENCRYPTED_SCRYPT_AES, "We don't allow mixing of encryption types at the moment");
        proto.setType(Protos.Key.Type.ENCRYPTED_SCRYPT_AES);
    } else {
        final byte[] secret = item.getSecretBytes();
        // The secret might be missing in the case of a watching wallet, or a key for which the private key
        // is expected to be rederived on the fly from its parent.
        if (secret != null)
            proto.setSecretBytes(ByteString.copyFrom(secret));
        proto.setType(Protos.Key.Type.ORIGINAL);
    }
    return proto;
}
 

import org.bitcoinj.crypto.EncryptedData; //导入依赖的package包/类
@Test
public void testEncryptedCreate() throws Exception {
    ECKey unencryptedKey = new ECKey();
    byte[] originalPrivateKeyBytes = checkNotNull(unencryptedKey.getPrivKeyBytes());
    log.info("Original private key = " + Utils.HEX.encode(originalPrivateKeyBytes));
    EncryptedData encryptedPrivateKey = keyCrypter.encrypt(unencryptedKey.getPrivKeyBytes(), keyCrypter.deriveKey(PASSWORD1));
    ECKey encryptedKey = ECKey.fromEncrypted(encryptedPrivateKey, keyCrypter, unencryptedKey.getPubKey());
    assertTrue(encryptedKey.isEncrypted());
    assertNull(encryptedKey.getSecretBytes());
    ECKey rebornUnencryptedKey = encryptedKey.decrypt(keyCrypter.deriveKey(PASSWORD1));
    assertTrue(!rebornUnencryptedKey.isEncrypted());
    assertArrayEquals(originalPrivateKeyBytes, rebornUnencryptedKey.getPrivKeyBytes());
}
 

import org.bitcoinj.crypto.EncryptedData; //导入依赖的package包/类
public void load(File file, String password) throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    KeyStore keystore = mapper.readValue(new FileInputStream(file), KeyStore.class);

    Protos.ScryptParameters.Builder scryptParametersBuilder
            = Protos.ScryptParameters.newBuilder()
            .setSalt(ByteString.copyFrom(base64Url().decode(keystore.getScrypt().getSalt())))
            .setN(keystore.getScrypt().getN())
            .setR(keystore.getScrypt().getR())
            .setP(keystore.getScrypt().getP());

    KeyCrypterScrypt crypterScrypt = new KeyCrypterScrypt(scryptParametersBuilder.build());
    KeyParameter aesKey = crypterScrypt.deriveKey(password);

    for (KeyEntry entry : keystore.getKeys()) {
        byte[] key = base64Url().decode(entry.getPk());
        byte[] iv = base64Url().decode(entry.getIv());

        EncryptedData data = new EncryptedData(iv, key);
        ECKey ecKey = ECKey.fromPrivate(crypterScrypt.decrypt(data, aesKey));

        KeyContentValues kcv = new KeyContentValues();
        kcv.putNickname(entry.getAlias());
        kcv.putAddress(ecKey.toAddress(MainNetParams.get()).toString());
        kcv.putPriv(ecKey.getPrivKeyBytes());
        kcv.putPub(ecKey.getPubKey());

        KeySelection ks = new KeySelection();
        ks.nickname(entry.getAlias());

        if(kcv.update(mContext.getContentResolver(), ks) != 1) {
            kcv.insert(mContext.getContentResolver());
        };

    }
}
 

import org.bitcoinj.crypto.EncryptedData; //导入依赖的package包/类
public void store(OutputStream os, String password)
        throws Exception {
    final Cursor c = mContext.getContentResolver()
            .query(KeyColumns.CONTENT_URI, null, null, null, null);

    KeyCursor kc = new KeyCursor(c);
    kc.moveToFirst();

    KeyCrypterScrypt crypterScrypt = new KeyCrypterScrypt(512);
    KeyParameter aesKey = crypterScrypt.deriveKey(password);

    Protos.ScryptParameters params = crypterScrypt.getScryptParameters();
    ScryptHeader scryptHeader = new ScryptHeader();
    scryptHeader.setN(params.getN());
    scryptHeader.setR(params.getR());
    scryptHeader.setP(params.getP());
    scryptHeader.setSalt(BaseEncoding.base64Url().encode(params.getSalt().toByteArray()));

    KeyStore keyStore = new KeyStore();
    keyStore.setScrypt(scryptHeader);

    for (int i = 0; i < kc.getCount(); i++) {
        kc.moveToPosition(i);

        EncryptedData data = crypterScrypt.encrypt(kc.getPriv(), aesKey);
        String ecKey64 = BaseEncoding.base64Url().encode(data.encryptedBytes);

        KeyEntry entry = new KeyEntry();
        entry.setAlias(kc.getNickname());
        entry.setKty("EC");
        entry.setCrv("P-256");
        entry.setPk(ecKey64);
        entry.setIv(BaseEncoding.base64Url().encode(data.initialisationVector));
        keyStore.addKey(entry);
    }

    ObjectMapper mapper = new ObjectMapper();
    mapper.writeValue(os, keyStore);
    os.close();

}