public static ArrayList<byte[]> createReqSmsMessage(Contact contact) throws FailedToSendSessionRequestException { final int MAX_REQUEST_LENGTH = 256; final int REQUEST_SMS_LENGTH = 128; try { byte[] request = SessionManager.generateSessionRequest(contact); if (request.length != MAX_REQUEST_LENGTH) throw new FailedToSendSessionRequestException("Request length is not standard"); byte[] firstMessage = Arrays.copyOfRange(request, 0, REQUEST_SMS_LENGTH); byte[] secondMessage = Arrays.copyOfRange(request, REQUEST_SMS_LENGTH, request.length); byte[] firstType = new byte[1]; firstType[0] = (byte) SmsMessage.Type.RequestFirstSMS.ordinal(); byte[] secondType = new byte[1]; secondType[0] = (byte) SmsMessage.Type.RequestSecondSMS.ordinal(); ArrayList<byte[]> partialRequests = new ArrayList<byte[]>(2); partialRequests.add(Arrays.concatenate(firstType, firstMessage)); partialRequests.add(Arrays.concatenate(secondType, secondMessage)); return partialRequests; } catch (FailedToGenerateSessionRequestException e) { throw new FailedToSendSessionRequestException("Failed to send the session request sms"); } }
private void ˏ( int paramInt, int[] paramArrayOfInt1, int[] paramArrayOfInt2, int[] paramArrayOfInt3) { int i = 1; String str = ""; this.beO = paramInt; if ((this.beO == paramArrayOfInt2.length) && (this.beO == paramArrayOfInt1.length)) { paramInt = i; if (this.beO == paramArrayOfInt3.length) {} } else { paramInt = 0; str = "Unexpected parameterset format"; } i = 0; while (i < this.beO) { if ((paramArrayOfInt3[i] < 2) || ((paramArrayOfInt1[i] - paramArrayOfInt3[i]) % 2 != 0)) { paramInt = 0; str = "Wrong parameter K (K >= 2 and H-K even required)!"; } if ((paramArrayOfInt1[i] < 4) || (paramArrayOfInt2[i] < 2)) { paramInt = 0; str = "Wrong parameter H or w (H > 3 and w > 1 required)!"; } i += 1; } if (paramInt != 0) { this.beC = Arrays.י(paramArrayOfInt1); this.beP = Arrays.י(paramArrayOfInt2); this.aGN = Arrays.י(paramArrayOfInt3); return; } throw new IllegalArgumentException(str); }
private void testCipherNameWithWrap(String name, String simpleName) throws Exception { KeyGenerator kg = KeyGenerator.getInstance("AES"); kg.init(new SecureRandom()); SecretKey key = kg.generateKey(); byte[] salt = { (byte) 0xc7, (byte) 0x73, (byte) 0x21, (byte) 0x8c, (byte) 0x7e, (byte) 0xc8, (byte) 0xee, (byte) 0x99 }; char[] password = {'p', 'a', 's', 's', 'w', 'o', 'r', 'd'}; PBEParameterSpec pbeParamSpec = new PBEParameterSpec(salt, 20); PBEKeySpec pbeKeySpec = new PBEKeySpec(password); SecretKeyFactory keyFac = SecretKeyFactory.getInstance(name); SecretKey pbeKey = keyFac.generateSecret(pbeKeySpec); Cipher pbeEncryptCipher = Cipher.getInstance(name, "SC"); pbeEncryptCipher.init(Cipher.WRAP_MODE, pbeKey, pbeParamSpec); byte[] symKeyBytes = pbeEncryptCipher.wrap(key); Cipher simpleCipher = Cipher.getInstance(simpleName, "SC"); simpleCipher.init(Cipher.UNWRAP_MODE, pbeKey, pbeParamSpec); SecretKey unwrappedKey = (SecretKey) simpleCipher.unwrap(symKeyBytes, "AES", Cipher.SECRET_KEY); if (!Arrays.areEqual(unwrappedKey.getEncoded(), key.getEncoded())) { fail("key mismatch on unwrapping"); } }
@Test public void deterministicUpgradeEncrypted() throws Exception { group = new KeyChainGroup(params); final ECKey key = new ECKey(); group.importKeys(key); final KeyCrypterScrypt crypter = new KeyCrypterScrypt(); final KeyParameter aesKey = crypter.deriveKey("abc"); assertTrue(group.isDeterministicUpgradeRequired()); group.encrypt(crypter, aesKey); assertTrue(group.isDeterministicUpgradeRequired()); try { group.upgradeToDeterministic(0, null); fail(); } catch (DeterministicUpgradeRequiresPassword e) { // Expected. } group.upgradeToDeterministic(0, aesKey); assertFalse(group.isDeterministicUpgradeRequired()); final DeterministicSeed deterministicSeed = group.getActiveKeyChain().getSeed(); assertNotNull(deterministicSeed); assertTrue(deterministicSeed.isEncrypted()); byte[] entropy = checkNotNull(group.getActiveKeyChain().toDecrypted(aesKey).getSeed()).getEntropyBytes(); // Check we used the right key: oldest non rotating. byte[] truncatedBytes = Arrays.copyOfRange(key.getSecretBytes(), 0, 16); assertArrayEquals(entropy, truncatedBytes); }
@Test public void deterministicUpgradeUnencrypted() throws Exception { // Check that a group that contains only random keys has its HD chain created using the private // key bytes of // the oldest random key, so upgrading the same wallet twice gives the same outcome. group = new KeyChainGroup(params); group.setLookaheadSize(LOOKAHEAD_SIZE); // Don't want slow tests. ECKey key1 = new ECKey(); Utils.rollMockClock(86400); ECKey key2 = new ECKey(); group.importKeys(key2, key1); List<Protos.Key> protobufs = group.serializeToProtobuf(); group.upgradeToDeterministic(0, null); assertFalse(group.isDeterministicUpgradeRequired()); DeterministicKey dkey1 = group.freshKey(KeyChain.KeyPurpose.RECEIVE_FUNDS); DeterministicSeed seed1 = group.getActiveKeyChain().getSeed(); assertNotNull(seed1); group = KeyChainGroup.fromProtobufUnencrypted(params, protobufs); group.upgradeToDeterministic(0, null); // Should give same result as last time. DeterministicKey dkey2 = group.freshKey(KeyChain.KeyPurpose.RECEIVE_FUNDS); DeterministicSeed seed2 = group.getActiveKeyChain().getSeed(); assertEquals(seed1, seed2); assertEquals(dkey1, dkey2); // Check we used the right (oldest) key despite backwards import order. byte[] truncatedBytes = Arrays.copyOfRange(key1.getSecretBytes(), 0, 16); assertArrayEquals(seed1.getEntropyBytes(), truncatedBytes); }
private static void compareKO( String name, Properties config, int test, byte[] calculatedOKM, byte[] testOKM) { if (!Arrays.areEqual(calculatedOKM, testOKM)) { throw new TestFailedException( new SimpleTestResult(false, name + " using " + config + " test " + test + " failed")); } }
public static byte[] createAckSmsMessage(Contact contact) throws FailedToSendSessionAcknowledgeException { try { byte[] ack = SessionManager.generateSessionAcknowledge(contact); byte[] type = new byte[1]; type[0] = (byte) SmsMessage.Type.Acknowledge.ordinal(); return Arrays.concatenate(type, ack); } catch (FailedToAcknowledgeSessionException e) { throw new FailedToSendSessionAcknowledgeException("Failed to respond to the session request"); } }
static byte[][] ˊ(byte[][] paramArrayOfByte) { if (paramArrayOfByte == null) { return null; } byte[][] arrayOfByte = new byte[paramArrayOfByte.length][]; int i = 0; while (i != paramArrayOfByte.length) { arrayOfByte[i] = Arrays.І(paramArrayOfByte[i]); i += 1; } return arrayOfByte; }
public void testSamples() throws IOException { assertTrue(Arrays.areEqual(sample1Bytes, UrlBase64.decode(sample1))); assertTrue(Arrays.areEqual(sample1Bytes, UrlBase64.decode(Strings.toByteArray(sample1)))); assertTrue(Arrays.areEqual(sample2Bytes, UrlBase64.decode(sample2))); assertTrue(Arrays.areEqual(sample2Bytes, UrlBase64.decode(Strings.toByteArray(sample2)))); assertTrue(Arrays.areEqual(sample3Bytes, UrlBase64.decode(sample3))); assertTrue(Arrays.areEqual(sample3Bytes, UrlBase64.decode(Strings.toByteArray(sample3)))); }
private AlgorithmParameters checkParameters(Cipher c, byte[] salt, int iCount) throws InvalidParameterSpecException { AlgorithmParameters param = c.getParameters(); PBEParameterSpec spec = (PBEParameterSpec) param.getParameterSpec(PBEParameterSpec.class); if (!Arrays.areEqual(salt, spec.getSalt())) { fail("" + algorithm + "failed salt test"); } if (iCount != spec.getIterationCount()) { fail("" + algorithm + "failed count test"); } return param; }
private void rawModeTest( String sigName, DERObjectIdentifier digestOID, PrivateKey privKey, PublicKey pubKey, SecureRandom random) throws Exception { byte[] sampleMessage = new byte[1000 + random.nextInt(100)]; random.nextBytes(sampleMessage); Signature normalSig = Signature.getInstance(sigName, "SC"); PSSParameterSpec spec = (PSSParameterSpec) normalSig.getParameters().getParameterSpec(PSSParameterSpec.class); // Make sure we generate the same 'random' salt for both normal and raw signers int saltLen = spec.getSaltLength(); byte[] fixedRandomBytes = new byte[saltLen]; random.nextBytes(fixedRandomBytes); normalSig.initSign(privKey, new FixedSecureRandom(fixedRandomBytes)); normalSig.update(sampleMessage); byte[] normalResult = normalSig.sign(); MessageDigest digest = MessageDigest.getInstance(digestOID.getId(), "SC"); byte[] hash = digest.digest(sampleMessage); Signature rawSig = Signature.getInstance("RAWRSASSA-PSS", "SC"); // Need to init the params explicitly to avoid having a 'raw' variety of every PSS algorithm rawSig.setParameter(spec); rawSig.initSign(privKey, new FixedSecureRandom(fixedRandomBytes)); rawSig.update(hash); byte[] rawResult = rawSig.sign(); if (!Arrays.areEqual(normalResult, rawResult)) { fail("raw mode signature differs from normal one"); } rawSig.initVerify(pubKey); rawSig.update(hash); if (!rawSig.verify(rawResult)) { fail("raw mode signature verification failed"); } }
@Test public void deterministicUpgradeRotating() throws Exception { group = new KeyChainGroup(params); group.setLookaheadSize(LOOKAHEAD_SIZE); // Don't want slow tests. long now = Utils.currentTimeSeconds(); ECKey key1 = new ECKey(); Utils.rollMockClock(86400); ECKey key2 = new ECKey(); Utils.rollMockClock(86400); ECKey key3 = new ECKey(); group.importKeys(key2, key1, key3); group.upgradeToDeterministic(now + 10, null); DeterministicSeed seed = group.getActiveKeyChain().getSeed(); assertNotNull(seed); // Check we used the right key: oldest non rotating. byte[] truncatedBytes = Arrays.copyOfRange(key2.getSecretBytes(), 0, 16); assertArrayEquals(seed.getEntropyBytes(), truncatedBytes); }
/** * return true if the internal state represents the signature described in the passed in array. */ public boolean verifySignature(byte[] signature) { if (forSigning) { throw new IllegalStateException("RSADigestSigner not initialised for verification"); } byte[] hash = new byte[digest.getDigestSize()]; digest.doFinal(hash, 0); byte[] sig; byte[] expected; try { sig = rsaEngine.processBlock(signature, 0, signature.length); expected = derEncode(hash); } catch (Exception e) { return false; } if (sig.length == expected.length) { return Arrays.constantTimeAreEqual(sig, expected); } else if (sig.length == expected.length - 2) // NULL left out { int sigOffset = sig.length - hash.length - 2; int expectedOffset = expected.length - hash.length - 2; expected[1] -= 2; // adjust lengths expected[3] -= 2; int nonEqual = 0; for (int i = 0; i < hash.length; i++) { nonEqual |= (sig[sigOffset + i] ^ expected[expectedOffset + i]); } for (int i = 0; i < sigOffset; i++) { nonEqual |= (sig[i] ^ expected[i]); // check header less NULL } return nonEqual == 0; } else { return false; } }
public void performTest() throws Exception { byte[] salt = new byte[16]; int iCount = 100; for (int i = 0; i != salt.length; i++) { salt[i] = (byte) i; } OpenSSLPBEParametersGenerator pGen = new OpenSSLPBEParametersGenerator(); pGen.init(PBEParametersGenerator.PKCS5PasswordToBytes(password), salt, iCount); ParametersWithIV params = (ParametersWithIV) pGen.generateDerivedParameters(keySize, ivSize); SecretKeySpec encKey = new SecretKeySpec(((KeyParameter) params.getParameters()).getKey(), baseAlgorithm); Cipher c; if (baseAlgorithm.equals("RC4")) { c = Cipher.getInstance(baseAlgorithm, "SC"); c.init(Cipher.ENCRYPT_MODE, encKey); } else { c = Cipher.getInstance(baseAlgorithm + "/CBC/PKCS7Padding", "SC"); c.init(Cipher.ENCRYPT_MODE, encKey, new IvParameterSpec(params.getIV())); } byte[] enc = c.doFinal(salt); c = Cipher.getInstance(algorithm, "SC"); PBEKeySpec keySpec = new PBEKeySpec(password, salt, iCount); SecretKeyFactory fact = SecretKeyFactory.getInstance(algorithm, "SC"); c.init(Cipher.DECRYPT_MODE, fact.generateSecret(keySpec)); byte[] dec = c.doFinal(enc); if (!Arrays.areEqual(salt, dec)) { fail("" + algorithm + "failed encryption/decryption test"); } }
public void testPBEonSecretKeyHmac(String hmacName, byte[] output) { SecretKey key; byte[] out; Mac mac; try { SecretKeyFactory fact = SecretKeyFactory.getInstance(hmacName, "SC"); key = fact.generateSecret(new PBEKeySpec("hello".toCharArray(), new byte[20], 100, 160)); mac = Mac.getInstance("HMAC-SHA1", "SC"); } catch (Exception e) { fail("Failed - exception " + e.toString(), e); return; } try { mac.init(key); } catch (Exception e) { fail("Failed - exception " + e.toString(), e); return; } mac.reset(); mac.update(message, 0, message.length); out = mac.doFinal(); if (!Arrays.areEqual(out, output)) { fail( "Failed - expected " + new String(Hex.encode(output)) + " got " + new String(Hex.encode(out))); } }
private void checkPBE(String baseAlg, boolean defIsUTF8, String utf8, String eightBit) throws Exception { byte[] utf8K = Hex.decode(utf8); byte[] ascK = Hex.decode(eightBit); SecretKeyFactory f = SecretKeyFactory.getInstance(baseAlg, "SC"); KeySpec ks1 = new PBEKeySpec("\u0141\u0142".toCharArray(), new byte[20], 4096, 160); if (!Arrays.areEqual((defIsUTF8) ? utf8K : ascK, f.generateSecret(ks1).getEncoded())) { fail( baseAlg + " wrong PBKDF2 k1 key generated, got : " + new String(Hex.encode(f.generateSecret(ks1).getEncoded()))); } KeySpec ks2 = new PBEKeySpec("\u0041\u0042".toCharArray(), new byte[20], 4096, 160); if (!Arrays.areEqual(ascK, f.generateSecret(ks2).getEncoded())) { fail(baseAlg + " wrong PBKDF2 k2 key generated"); } f = SecretKeyFactory.getInstance(baseAlg + "AndUTF8", "SC"); ks1 = new PBEKeySpec("\u0141\u0142".toCharArray(), new byte[20], 4096, 160); if (!Arrays.areEqual(utf8K, f.generateSecret(ks1).getEncoded())) { fail(baseAlg + " wrong PBKDF2 k1 utf8 key generated"); } ks2 = new PBEKeySpec("\u0041\u0042".toCharArray(), new byte[20], 4096, 160); if (!Arrays.areEqual(ascK, f.generateSecret(ks2).getEncoded())) { fail(baseAlg + " wrong PBKDF2 k2 utf8 key generated"); } f = SecretKeyFactory.getInstance(baseAlg + "And8BIT", "SC"); ks1 = new PBEKeySpec("\u0141\u0142".toCharArray(), new byte[20], 4096, 160); if (!Arrays.areEqual(ascK, f.generateSecret(ks1).getEncoded())) { fail(baseAlg + " wrong PBKDF2 k1 8bit key generated"); } ks2 = new PBEKeySpec("\u0041\u0042".toCharArray(), new byte[20], 4096, 160); if (!Arrays.areEqual(ascK, f.generateSecret(ks2).getEncoded())) { fail(baseAlg + " wrong PBKDF2 k2 8bit key generated"); } }
public int[] qQ() { return Arrays.י(this.aGN); }
public int[] qO() { return Arrays.י(this.beC); }
public int[] qP() { return Arrays.י(this.beP); }
/** Returns a copy of the output detached from its containing transaction, if need be. */ public TransactionOutput duplicateDetached() { return new TransactionOutput( params, null, Coin.valueOf(value), org.spongycastle.util.Arrays.clone(scriptBytes)); }
public Apdu(byte[] apdu, int length) { this(Arrays.copyOf(apdu, length)); }
public byte[] rb() { return Arrays.І(this.bfp); }
public void performTest() throws Exception { byte[] salt = new byte[digest.getDigestSize()]; int iCount = 100; digest.doFinal(salt, 0); PKCS12ParametersGenerator pGen = new PKCS12ParametersGenerator(digest); pGen.init(PBEParametersGenerator.PKCS12PasswordToBytes(password), salt, iCount); ParametersWithIV params = (ParametersWithIV) pGen.generateDerivedParameters(keySize, ivSize); SecretKeySpec encKey = new SecretKeySpec(((KeyParameter) params.getParameters()).getKey(), baseAlgorithm); Cipher c; if (baseAlgorithm.equals("RC4")) { c = Cipher.getInstance(baseAlgorithm, "SC"); c.init(Cipher.ENCRYPT_MODE, encKey); } else { c = Cipher.getInstance(baseAlgorithm + "/CBC/PKCS7Padding", "SC"); c.init(Cipher.ENCRYPT_MODE, encKey, new IvParameterSpec(params.getIV())); } byte[] enc = c.doFinal(salt); c = Cipher.getInstance(algorithm, "SC"); PBEKeySpec keySpec = new PBEKeySpec(password, salt, iCount); SecretKeyFactory fact = SecretKeyFactory.getInstance(algorithm, "SC"); c.init(Cipher.DECRYPT_MODE, fact.generateSecret(keySpec)); byte[] dec = c.doFinal(enc); if (!Arrays.areEqual(salt, dec)) { fail("" + algorithm + "failed encryption/decryption test"); } // // get the parameters // AlgorithmParameters param = checkParameters(c, salt, iCount); // // try using parameters // c = Cipher.getInstance(algorithm, "SC"); keySpec = new PBEKeySpec(password); c.init(Cipher.DECRYPT_MODE, fact.generateSecret(keySpec), param); checkParameters(c, salt, iCount); dec = c.doFinal(enc); if (!Arrays.areEqual(salt, dec)) { fail("" + algorithm + "failed encryption/decryption test"); } // // try using PBESpec // c = Cipher.getInstance(algorithm, "SC"); keySpec = new PBEKeySpec(password); c.init( Cipher.DECRYPT_MODE, fact.generateSecret(keySpec), param.getParameterSpec(PBEParameterSpec.class)); checkParameters(c, salt, iCount); dec = c.doFinal(enc); if (!Arrays.areEqual(salt, dec)) { fail("" + algorithm + "failed encryption/decryption test"); } }
public void performTest() throws Exception { byte[] input = Hex.decode("1234567890abcdefabcdef1234567890fedbca098765"); // // DES // Cipher cEnc = Cipher.getInstance("DES/CBC/PKCS7Padding", "SC"); cEnc.init( Cipher.ENCRYPT_MODE, new SecretKeySpec(Hex.decode("30e69252758e5346"), "DES"), new IvParameterSpec(Hex.decode("7c1c1ab9c454a688"))); byte[] out = cEnc.doFinal(input); char[] password = {'p', 'a', 's', 's', 'w', 'o', 'r', 'd'}; Cipher cDec = makePBECipherUsingParam( "PBEWithSHA1AndDES", Cipher.DECRYPT_MODE, password, Hex.decode("7d60435f02e9e0ae"), 2048); byte[] in = cDec.doFinal(out); if (!Arrays.areEqual(input, in)) { fail("DES failed"); } cDec = makePBECipherWithoutParam( "PBEWithSHA1AndDES", Cipher.DECRYPT_MODE, password, Hex.decode("7d60435f02e9e0ae"), 2048); in = cDec.doFinal(out); if (!Arrays.areEqual(input, in)) { fail("DES failed without param"); } // // DESede // cEnc = Cipher.getInstance("DESede/CBC/PKCS7Padding", "SC"); cEnc.init( Cipher.ENCRYPT_MODE, new SecretKeySpec(Hex.decode("732f2d33c801732b7206756cbd44f9c1c103ddd97c7cbe8e"), "DES"), new IvParameterSpec(Hex.decode("b07bf522c8d608b8"))); out = cEnc.doFinal(input); cDec = makePBECipherUsingParam( "PBEWithSHAAnd3-KeyTripleDES-CBC", Cipher.DECRYPT_MODE, password, Hex.decode("7d60435f02e9e0ae"), 2048); in = cDec.doFinal(out); if (!Arrays.areEqual(input, in)) { fail("DESede failed"); } // // 40Bit RC2 // cEnc = Cipher.getInstance("RC2/CBC/PKCS7Padding", "SC"); cEnc.init( Cipher.ENCRYPT_MODE, new SecretKeySpec(Hex.decode("732f2d33c8"), "RC2"), new IvParameterSpec(Hex.decode("b07bf522c8d608b8"))); out = cEnc.doFinal(input); cDec = makePBECipherUsingParam( "PBEWithSHAAnd40BitRC2-CBC", Cipher.DECRYPT_MODE, password, Hex.decode("7d60435f02e9e0ae"), 2048); in = cDec.doFinal(out); if (!Arrays.areEqual(input, in)) { fail("RC2 failed"); } // // 128bit RC4 // cEnc = Cipher.getInstance("RC4", "SC"); cEnc.init( Cipher.ENCRYPT_MODE, new SecretKeySpec(Hex.decode("732f2d33c801732b7206756cbd44f9c1"), "RC4")); out = cEnc.doFinal(input); cDec = makePBECipherUsingParam( "PBEWithSHAAnd128BitRC4", Cipher.DECRYPT_MODE, password, Hex.decode("7d60435f02e9e0ae"), 2048); in = cDec.doFinal(out); if (!Arrays.areEqual(input, in)) { fail("RC4 failed"); } cDec = makePBECipherWithoutParam( "PBEWithSHAAnd128BitRC4", Cipher.DECRYPT_MODE, password, Hex.decode("7d60435f02e9e0ae"), 2048); in = cDec.doFinal(out); if (!Arrays.areEqual(input, in)) { fail("RC4 failed without param"); } for (int i = 0; i != pkcs12Tests.length; i++) { pkcs12Tests[i].perform(); } for (int i = 0; i != openSSLTests.length; i++) { openSSLTests[i].perform(); } testPBEHMac("PBEWithHMacSHA1", hMac1); testPBEHMac("PBEWithHMacRIPEMD160", hMac2); testPBEonSecretKeyHmac("PBKDF2WithHmacSHA1", hMac3); testCipherNameWithWrap("PBEWITHSHA256AND128BITAES-CBC-BC", "AES/CBC/PKCS5Padding"); testCipherNameWithWrap("PBEWITHSHAAND40BITRC4", "RC4"); testCipherNameWithWrap("PBEWITHSHAAND128BITRC4", "RC4"); checkPBE( "PBKDF2WithHmacSHA1", true, "f14687fc31a66e2f7cc01d0a65f687961bd27e20", "6f6579193d6433a3e4600b243bb390674f04a615"); }
/** * Obtains the value of the {@link #PARAM_TYPE_KEY key parameter}, or <code>null</code> if not * set. */ public byte[] getKey() { return Arrays.clone((byte[]) parameters.get(Integers.valueOf(PARAM_TYPE_KEY))); }
/** * Obtains the value of the {@link #PARAM_TYPE_NONCE nonce parameter}, or <code>null</code> if not * set. */ public byte[] getNonce() { return Arrays.clone((byte[]) parameters.get(Integers.valueOf(PARAM_TYPE_NONCE))); }
/** Change the wallet password. */ @Override public void actionPerformed(ActionEvent e) { changePasswordPanel.clearMessages(); privateKeysBackupFile = null; char[] newPasswordToUse = null; char[] currentPasswordToUse = null; if (currentPassword.getPassword() == null || currentPassword.getPassword().length == 0) { // Notify must enter the current password. changePasswordPanel.setMessage1( controller.getLocaliser().getString("changePasswordPanel.enterCurrentPassword")); return; } currentPasswordToUse = currentPassword.getPassword(); // Get the new passwords on the password fields. if (newPassword.getPassword() == null || newPassword.getPassword().length == 0) { // Notify the user must enter a new password. changePasswordPanel.setMessage1( controller.getLocaliser().getString("changePasswordPanel.enterPasswords")); return; } else { if (!Arrays.areEqual(newPassword.getPassword(), repeatNewPassword.getPassword())) { // Notify user passwords are different. changePasswordPanel.setMessage1( controller .getLocaliser() .getString("showExportPrivateKeysAction.passwordsAreDifferent")); return; } else { newPasswordToUse = newPassword.getPassword(); } } Wallet wallet = super.fastcoinController.getModel().getActiveWallet(); if (wallet != null) { // Double check wallet is not busy then declare that the active // wallet is busy with the task. WalletData perWalletModelData = super.fastcoinController.getModel().getActivePerWalletModelData(); if (!perWalletModelData.isBusy()) { perWalletModelData.setBusy(true); perWalletModelData.setBusyTaskKey("changePasswordSubmitAction.text"); super.fastcoinController.fireWalletBusyChange(true); boolean decryptSuccess = false; KeyCrypter keyCrypterToUse = wallet.getKeyCrypter(); try { wallet.decrypt(keyCrypterToUse.deriveKey(CharBuffer.wrap(currentPasswordToUse))); decryptSuccess = true; } catch (KeyCrypterException kce) { // Notify the user that the decrypt failed. changePasswordPanel.setMessage1( controller .getLocaliser() .getString( "changePasswordPanel.changePasswordFailed", new String[] {kce.getMessage()})); // Declare that wallet is no longer busy with the task. perWalletModelData.setBusyTaskKey(null); perWalletModelData.setBusy(false); super.fastcoinController.fireWalletBusyChange(false); return; } if (decryptSuccess) { try { wallet.encrypt( keyCrypterToUse, keyCrypterToUse.deriveKey(CharBuffer.wrap(newPasswordToUse))); FileHandler fileHandler = new FileHandler(super.fastcoinController); fileHandler.savePerWalletModelData( super.fastcoinController.getModel().getActivePerWalletModelData(), true); // Backup the private keys. privateKeysBackupFile = fileHandler.backupPrivateKeys(CharBuffer.wrap(newPasswordToUse)); // Backup the wallet and wallet info BackupManager.INSTANCE.backupPerWalletModelData(fileHandler, perWalletModelData); } catch (KeyCrypterException kce) { // Notify the user that the encrypt failed. changePasswordPanel.setMessage1( controller .getLocaliser() .getString( "changePasswordPanel.changePasswordFailed", new String[] {kce.getMessage()})); return; } catch (IOException ede) { // Notify the user that the private key backup failed. changePasswordPanel.setMessage2( controller .getLocaliser() .getString( "changePasswordPanel.keysBackupFailed", new String[] {ede.getMessage()})); return; } finally { // Declare that wallet is no longer busy with the task. perWalletModelData.setBusyTaskKey(null); perWalletModelData.setBusy(false); super.fastcoinController.fireWalletBusyChange(false); } } else { // Declare that wallet is no longer busy with the task. perWalletModelData.setBusyTaskKey(null); perWalletModelData.setBusy(false); super.fastcoinController.fireWalletBusyChange(false); } } } // Success. SwingUtilities.invokeLater( new Runnable() { @Override public void run() { changePasswordPanel.clearMessages(); changePasswordPanel.clearPasswords(); changePasswordPanel.setMessage1( controller.getLocaliser().getString("changePasswordPanel.changePasswordSuccess")); if (privateKeysBackupFile != null) { try { changePasswordPanel.setMessage2( controller.getLocaliser().getString("changePasswordPanel.oldBackupsMessage")); changePasswordPanel.setMessage3( controller .getLocaliser() .getString( "changePasswordPanel.keysBackupSuccess", new Object[] {privateKeysBackupFile.getCanonicalPath()})); } catch (IOException e1) { log.debug(e1.getClass().getCanonicalName() + " " + e1.getMessage()); } } } }); }
/** * Obtains the value of the {@link #PARAM_TYPE_PERSONALISATION personalisation parameter}, or * <code>null</code> if not set. */ public byte[] getPersonalisation() { return Arrays.clone((byte[]) parameters.get(Integers.valueOf(PARAM_TYPE_PERSONALISATION))); }
/** * Obtains the value of the {@link #PARAM_TYPE_KEY_IDENTIFIER key identifier parameter}, or <code> * null</code> if not set. */ public byte[] getKeyIdentifier() { return Arrays.clone((byte[]) parameters.get(Integers.valueOf(PARAM_TYPE_KEY_IDENTIFIER))); }
public Object clone() { return new IntArray(Arrays.clone(m_ints)); }