public static void estimateKeyDerivationTime() {
   // This is run in the background after startup. If we haven't recorded it before, do a key
   // derivation to see
   // how long it takes. This helps us produce better progress feedback, as on Windows we don't
   // currently have a
   // native Scrypt impl and the Java version is ~3 times slower, plus it depends a lot on CPU
   // speed.
   checkGuiThread();
   estimatedKeyDerivationTime = Main.instance.prefs.getExpectedKeyDerivationTime();
   if (estimatedKeyDerivationTime == null) {
     new Thread(
             () -> {
               log.info("Doing background test key derivation");
               KeyCrypterScrypt scrypt = new KeyCrypterScrypt(SCRYPT_PARAMETERS);
               long start = System.currentTimeMillis();
               scrypt.deriveKey("test password");
               long msec = System.currentTimeMillis() - start;
               log.info("Background test key derivation took {}msec", msec);
               Platform.runLater(
                   () -> {
                     estimatedKeyDerivationTime = Duration.ofMillis(msec);
                     Main.instance.prefs.setExpectedKeyDerivationTime(estimatedKeyDerivationTime);
                   });
             })
         .start();
   }
 }
    protected Wallet doInBackground(Bundle... params) {
      ArrayList<String> seedWords = new ArrayList<String>();
      for (String word : seed.trim().split(" ")) {
        if (word.isEmpty()) continue;
        seedWords.add(word);
      }

      Wallet wallet = null;
      try {
        if (seedProtect) {
          wallet = new Wallet(seedWords, password);
        } else {
          wallet = new Wallet(seedWords);
        }

        KeyParameter aesKey = null;
        if (password != null && !password.isEmpty()) {
          KeyCrypterScrypt crypter = new KeyCrypterScrypt();
          aesKey = crypter.deriveKey(password);
          wallet.encrypt(crypter, aesKey);
        }

        wallet.createAccounts(coinsToCreate, true, aesKey);
        getWalletApplication().setWallet(wallet);
        getWalletApplication().saveWalletNow();
        getWalletApplication().startBlockchainService(CoinService.ServiceMode.RESET_WALLET);
      } catch (Exception e) {
        log.error("Error creating a wallet", e);
        errorMessage = e.getMessage();
      }
      return wallet;
    }
Exemplo n.º 3
0
 @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);
 }
public class WalletSetPasswordController {
  private static final Logger log = LoggerFactory.getLogger(WalletSetPasswordController.class);
  public PasswordField pass1, pass2;

  public ProgressIndicator progressMeter;
  public GridPane widgetGrid;
  public HBox buttonHBox;
  public Label explanationLabel;

  public Main.OverlayUI overlayUI;
  // These params were determined empirically on a top-range (as of 2014) MacBook Pro with native
  // scrypt support,
  // using the scryptenc command line tool from the original scrypt distribution, given a memory
  // limit of 40mb.
  public static final Protos.ScryptParameters SCRYPT_PARAMETERS =
      Protos.ScryptParameters.newBuilder()
          .setP(6)
          .setR(8)
          .setN(32768)
          .setSalt(ByteString.copyFrom(KeyCrypterScrypt.randomSalt()))
          .build();

  public void initialize() {
    progressMeter.setOpacity(0);
  }

  public static Duration estimatedKeyDerivationTime = null;

  public static void estimateKeyDerivationTime() {
    // This is run in the background after startup. If we haven't recorded it before, do a key
    // derivation to see
    // how long it takes. This helps us produce better progress feedback, as on Windows we don't
    // currently have a
    // native Scrypt impl and the Java version is ~3 times slower, plus it depends a lot on CPU
    // speed.
    checkGuiThread();
    estimatedKeyDerivationTime = Main.instance.prefs.getExpectedKeyDerivationTime();
    if (estimatedKeyDerivationTime == null) {
      new Thread(
              () -> {
                log.info("Doing background test key derivation");
                KeyCrypterScrypt scrypt = new KeyCrypterScrypt(SCRYPT_PARAMETERS);
                long start = System.currentTimeMillis();
                scrypt.deriveKey("test password");
                long msec = System.currentTimeMillis() - start;
                log.info("Background test key derivation took {}msec", msec);
                Platform.runLater(
                    () -> {
                      estimatedKeyDerivationTime = Duration.ofMillis(msec);
                      Main.instance.prefs.setExpectedKeyDerivationTime(estimatedKeyDerivationTime);
                    });
              })
          .start();
    }
  }

  @FXML
  public void setPasswordClicked(ActionEvent event) {
    if (!pass1.getText().equals(pass2.getText())) {
      informationalAlert(tr("Passwords do not match"), tr("Try re-typing your chosen passwords."));
      return;
    }
    String password = pass1.getText();
    // This is kind of arbitrary and we could do much more to help people pick strong passwords.
    if (password.length() < 4) {
      informationalAlert(
          tr("Password too short"),
          tr("You need to pick a password at least five characters or longer."));
      return;
    }

    fadeIn(progressMeter);
    fadeOut(widgetGrid);
    fadeOut(explanationLabel);
    fadeOut(buttonHBox);

    KeyCrypterScrypt scrypt = new KeyCrypterScrypt(SCRYPT_PARAMETERS);

    // Deriving the actual key runs on a background thread. 500msec is empirical on my laptop
    // (actual val is more like 333 but we give padding time).
    KeyDerivationTasks tasks =
        new KeyDerivationTasks(scrypt, password, estimatedKeyDerivationTime) {
          @Override
          protected void onFinish(KeyParameter aesKey, int timeTakenMsec) {
            // Write the target time to the wallet so we can make the progress bar work when
            // entering the password.
            WalletPasswordController.setTargetTime(Duration.ofMillis(timeTakenMsec));
            // The actual encryption part doesn't take very long as most private keys are derived on
            // demand.
            log.info("Key derived, now encrypting");
            Main.bitcoin.wallet().encrypt(scrypt, aesKey);
            log.info("Encryption done");
            informationalAlert(
                tr("Wallet encrypted"),
                tr("You can remove the password at any time from the settings screen."));
            overlayUI.done();
          }
        };
    progressMeter.progressProperty().bind(tasks.progress);
    tasks.start();
  }

  @FXML
  public void closeClicked(ActionEvent event) {
    overlayUI.done();
  }
}
  /**
   * Converts the given wallet to the object representation of the protocol buffers. This can be
   * modified, or additional data fields set, before serialization takes place.
   */
  public Protos.Wallet walletToProto(Wallet wallet) {
    Protos.Wallet.Builder walletBuilder = Protos.Wallet.newBuilder();
    walletBuilder.setNetworkIdentifier(wallet.getNetworkParameters().getId());
    if (wallet.getDescription() != null) {
      walletBuilder.setDescription(wallet.getDescription());
    }

    for (WalletTransaction wtx : wallet.getWalletTransactions()) {
      Protos.Transaction txProto = makeTxProto(wtx);
      walletBuilder.addTransaction(txProto);
    }

    walletBuilder.addAllKey(wallet.serializeKeychainToProtobuf());

    for (Script script : wallet.getWatchedScripts()) {
      Protos.Script protoScript =
          Protos.Script.newBuilder()
              .setProgram(ByteString.copyFrom(script.getProgram()))
              .setCreationTimestamp(script.getCreationTimeSeconds() * 1000)
              .build();

      walletBuilder.addWatchedScript(protoScript);
    }

    // Populate the lastSeenBlockHash field.
    Sha256Hash lastSeenBlockHash = wallet.getLastBlockSeenHash();
    if (lastSeenBlockHash != null) {
      walletBuilder.setLastSeenBlockHash(hashToByteString(lastSeenBlockHash));
      walletBuilder.setLastSeenBlockHeight(wallet.getLastBlockSeenHeight());
    }
    if (wallet.getLastBlockSeenTimeSecs() > 0)
      walletBuilder.setLastSeenBlockTimeSecs(wallet.getLastBlockSeenTimeSecs());

    // Populate the scrypt parameters.
    KeyCrypter keyCrypter = wallet.getKeyCrypter();
    if (keyCrypter == null) {
      // The wallet is unencrypted.
      walletBuilder.setEncryptionType(EncryptionType.UNENCRYPTED);
    } else {
      // The wallet is encrypted.
      walletBuilder.setEncryptionType(keyCrypter.getUnderstoodEncryptionType());
      if (keyCrypter instanceof KeyCrypterScrypt) {
        KeyCrypterScrypt keyCrypterScrypt = (KeyCrypterScrypt) keyCrypter;
        walletBuilder.setEncryptionParameters(keyCrypterScrypt.getScryptParameters());
      } else {
        // Some other form of encryption has been specified that we do not know how to persist.
        throw new RuntimeException(
            "The wallet has encryption of type '"
                + keyCrypter.getUnderstoodEncryptionType()
                + "' but this WalletProtobufSerializer does not know how to persist this.");
      }
    }

    if (wallet.getKeyRotationTime() != null) {
      long timeSecs = wallet.getKeyRotationTime().getTime() / 1000;
      walletBuilder.setKeyRotationTime(timeSecs);
    }

    populateExtensions(wallet, walletBuilder);

    for (Map.Entry<String, ByteString> entry : wallet.getTags().entrySet()) {
      Protos.Tag.Builder tag =
          Protos.Tag.newBuilder().setTag(entry.getKey()).setData(entry.getValue());
      walletBuilder.addTags(tag);
    }

    for (TransactionSigner signer : wallet.getTransactionSigners()) {
      // do not serialize LocalTransactionSigner as it's being added implicitly
      if (signer instanceof LocalTransactionSigner) continue;
      Protos.TransactionSigner.Builder protoSigner = Protos.TransactionSigner.newBuilder();
      protoSigner.setClassName(signer.getClass().getName());
      protoSigner.setData(ByteString.copyFrom(signer.serialize()));
      walletBuilder.addTransactionSigners(protoSigner);
    }

    walletBuilder.setSigsRequiredToSpend(wallet.getSigsRequiredToSpend());

    // Populate the wallet version.
    walletBuilder.setVersion(wallet.getVersion());

    return walletBuilder.build();
  }