Java SCrypt.scrypt方法代码示例

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
private ECKey decryptNoEC(String normalizedPassphrase) {
    try {
        byte[] derived = SCrypt.scrypt(normalizedPassphrase.getBytes(Charsets.UTF_8), addressHash, 16384, 8, 8, 64);
        byte[] key = Arrays.copyOfRange(derived, 32, 64);
        SecretKeySpec keyspec = new SecretKeySpec(key, "AES");

        DRMWorkaround.maybeDisableExportControls();
        Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");

        cipher.init(Cipher.DECRYPT_MODE, keyspec);
        byte[] decrypted = cipher.doFinal(content, 0, 32);
        for (int i = 0; i < 32; i++)
            decrypted[i] ^= derived[i];
        return ECKey.fromPrivate(decrypted, compressed);
    } catch (GeneralSecurityException x) {
        throw new RuntimeException(x);
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
/**
 * Generate AES key.
 *
 * This is a very slow operation compared to encrypt/ decrypt so it is normally worth caching the result.
 *
 * @param password    The password to use in key generation
 * @return            The KeyParameter containing the created AES key
 * @throws            KeyCrypterException
 */
@Override
public KeyParameter deriveKey(CharSequence password) throws KeyCrypterException {
    byte[] passwordBytes = null;
    try {
        passwordBytes = convertToByteArray(password);
        byte[] salt = new byte[0];
        if ( scryptParameters.getSalt() != null) {
            salt = scryptParameters.getSalt().toByteArray();
        } else {
            // Warn the user that they are not using a salt.
            // (Some early MultiBit wallets had a blank salt).
            log.warn("You are using a ScryptParameters with no salt. Your encryption may be vulnerable to a dictionary attack.");
        }

        byte[] keyBytes = SCrypt.scrypt(passwordBytes, salt, (int) scryptParameters.getN(), scryptParameters.getR(), scryptParameters.getP(), KEY_LENGTH);
        return new KeyParameter(keyBytes);
    } catch (Exception e) {
        throw new KeyCrypterException("Could not generate key from password and salt.", e);
    } finally {
        // Zero the password bytes.
        if (passwordBytes != null) {
            java.util.Arrays.fill(passwordBytes, (byte) 0);
        }
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
private ECKey decryptBip38NoEC(String normalizedPassphrase) {
    try {
        byte[] derived = SCrypt.scrypt(normalizedPassphrase.getBytes(Charsets.UTF_8), addressHash, 16384, 8, 8, 64);
        byte[] key = Arrays.copyOfRange(derived, 32, 64);
        SecretKeySpec keyspec = new SecretKeySpec(key, "AES");

        DRMWorkaround.maybeDisableExportControls();
        Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");

        cipher.init(Cipher.DECRYPT_MODE, keyspec);
        byte[] decrypted = cipher.doFinal(content, 0, 32);
        for (int i = 0; i < 32; i++)
            decrypted[i] ^= derived[i];
        return ECKey.fromPrivate(decrypted, compressed);
    } catch (GeneralSecurityException x) {
        throw new RuntimeException(x);
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
@Override
public KeyParameter deriveKey(CharSequence password) throws KeyCrypterException {
    byte[] passwordBytes = null;
    try {
        passwordBytes = convertToByteArray(password);
        byte[] salt = new byte[0];
        if (mSalt != null) {
            salt = mSalt;
        } else {
            // Warn the user that they are not using a salt.
            // (Some early MultiBit wallets had a blank salt).
            Log.w(TAG, "You are using a ScryptParameters with no salt. Your encryption may be vulnerable to a dictionary attack.");
        }

        byte[] keyBytes = SCrypt.scrypt(passwordBytes, salt, BITCOINJ_SCRYPT_N, BITCOINJ_SCRYPT_R, BITCOINJ_SCRYPT_P, KEY_LENGTH);
        return new KeyParameter(keyBytes);
    } catch (Exception e) {
        throw new KeyCrypterException("Could not generate key from password and salt.", e);
    } finally {
        // Zero the password bytes.
        if (passwordBytes != null) {
            java.util.Arrays.fill(passwordBytes, (byte) 0);
        }
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
/**
 * Generate AES key.
 * <p/>
 * This is a very slow operation compared to encrypt/ decrypt so it is normally worth caching the result.
 *
 * @param password The password to use in key generation
 * @return The KeyParameter containing the created AES key
 * @throws KeyCrypterException
 */
@Override
public KeyParameter deriveKey(CharSequence password) throws KeyCrypterException {
    byte[] passwordBytes = null;
    try {
        passwordBytes = convertToByteArray(password);
        byte[] salt = new byte[0];
        if (scryptParameters.getSalt() != null) {
            salt = scryptParameters.getSalt().toByteArray();
        } else {
            // Warn the user that they are not using a salt.
            // (Some early MultiBit wallets had a blank salt).
            log.warn("You are using a ScryptParameters with no salt. Your encryption may be vulnerable to a dictionary attack.");
        }

        byte[] keyBytes = SCrypt.scrypt(passwordBytes, salt, (int) scryptParameters.getN(), scryptParameters.getR(), scryptParameters.getP(), KEY_LENGTH);
        return new KeyParameter(keyBytes);
    } catch (Exception e) {
        throw new KeyCrypterException("Could not generate key from password and salt.", e);
    } finally {
        // Zero the password bytes.
        if (passwordBytes != null) {
            java.util.Arrays.fill(passwordBytes, (byte) 0);
        }
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
/**
 * Generate AES key.
 *
 * This is a very slow operation compared to encrypt/ decrypt so it is normally worth caching the result.
 *
 * @param password    The password to use in key generation
 * @return            The KeyParameter containing the created AES key
 * @throws            KeyCrypterException
 */
@Override
public KeyParameter deriveKey(CharSequence password) throws KeyCrypterException {
    byte[] passwordBytes = null;
    try {
        passwordBytes = convertToByteArray(password);
        byte[] salt = new byte[0];
        if ( scryptParameters.getSalt() != null) {
            salt = scryptParameters.getSalt().toByteArray();
        } else {
            // Warn the user that they are not using a salt.
            // (Some early MultiBit wallets had a blank salt).
            log.warn("You are using a ScryptParameters with no salt. Your encryption may be vulnerable to a dictionary attack.");
        }

        final Stopwatch watch = Stopwatch.createStarted();
        byte[] keyBytes = SCrypt.scrypt(passwordBytes, salt, (int) scryptParameters.getN(), scryptParameters.getR(), scryptParameters.getP(), KEY_LENGTH);
        watch.stop();
        log.info("Deriving key took {} for {} scrypt iterations.", watch, scryptParameters.getN());
        return new KeyParameter(keyBytes);
    } catch (Exception e) {
        throw new KeyCrypterException("Could not generate key from password and salt.", e);
    } finally {
        // Zero the password bytes.
        if (passwordBytes != null) {
            java.util.Arrays.fill(passwordBytes, (byte) 0);
        }
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
public ECKey generateKey() throws GeneralSecurityException, UnsupportedEncodingException {
    final String composedKey = username + ":" + password + ":tatualado";
    byte[] hash = SCrypt.scrypt(composedKey.getBytes("UTF-8"),
    new String("Uzy7pjlwDkwIWuq").getBytes("UTF-8"),
            32768, 4, 1, 32);

    ECKey generatedKey = ECKey.fromPrivate(hash, false);
    return generatedKey;
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
public byte[] getSeed(String salt, String password) {
    try {
        byte[] seed = SCrypt.scrypt(
                CryptoUtils.decodeAscii(password),
                CryptoUtils.decodeAscii(salt),
                SCRYPT_PARAMS_N, SCRYPT_PARAMS_r,
                SCRYPT_PARAMS_p, SEED_BYTES);
        return seed;
    } catch (GeneralSecurityException e) {
        e.printStackTrace();
        throw new UCoinTechnicalException(
                "Unable to salt password, using Scrypt library", e);
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
/**
 * Derives a cryptographic hash using {@code SCrypt}.
 * This function can be compute intensive.
 *
 * @param domain        The domain for which the password is used.
 * @param password      The master password from which to derive other passwords.
 * @param configuration Configuration for SCrypt.
 * @return a cryptographically secure hash, in integer form.
 */
private static BigInteger hash(byte[] domain, byte[] password, Configuration configuration) {
    try {
        byte[] salt = configuration.code.getBytes();
        // Concatenating the password and salt.
        byte[] passwordCode = new byte[password.length + salt.length];
        System.arraycopy(password, 0, passwordCode, 0, password.length);
        System.arraycopy(salt, 0, passwordCode, password.length, salt.length);

        // Using SCrypt to get a byte array hash.
        byte[] encrypted = SCrypt.scrypt(
                passwordCode,
                domain,
                (1 << configuration.logN),
                configuration.r,
                configuration.p,
                LENGTH);

        // Converting the byte array to a large integer.
        BigInteger result = BigInteger.ZERO;
        BigInteger factor = BigInteger.ONE;
        BigInteger range = BigInteger.valueOf(256);
        for (int i : encrypted) {
            BigInteger current = BigInteger.valueOf(i & 0xFF).multiply(factor);
            result = result.add(current);
            factor = factor.multiply(range);
        }
        return result;
    } catch (Exception e) {
        throw new IllegalArgumentException("Invalid parameters for SCrypt.", e);
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
public static byte[] scryptDigest(byte[] input) {
    try {
        return SCrypt.scrypt(input, input, 1024, 1, 1, 32);
    } catch (Exception e) {
        return null;
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
/**
 * Calculates the Scrypt hash of the given bytes. This is
 * standard procedure in Mintcoin for hashing blocks.
 * The resulting hash is in big endian form.
 */
public static byte[] scryptDigest(byte[] input) {
try {
    return SCrypt.scrypt(input, input, 1024, 1, 1, 32);
    } catch (Exception e) {
        return null;
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
public static byte[] scryptDigest(byte[] input) {
try {
    return SCrypt.scrypt(input, input, 1024, 1, 1, 32);
    } catch (Exception e) {
        return null;
    }
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
protected byte[] doSCryptHash (byte[] password, byte[] salt, int N, int r, int p, int keyLength){
	try {
		return SCrypt.scrypt(password, salt, N, r, p, keyLength);
	} catch (GeneralSecurityException e) {
		e.printStackTrace();
		throw new RuntimeException (e);
	}
}
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
        SCryptMetrics m = new SCryptMetrics(new SecureRandom());
        long time = System.currentTimeMillis();
        SCrypt.scrypt(m.password,m.salt,1<<17,2,645,32);
        System.out.println(System.currentTimeMillis() - time);
        m.benchmarkSCrypt(32*1024*1024);
//        int[] params = m.paramsForLowP(60,32*1024*1024);
        int[] params = m.paramsForTimeGivenMemory(60,32*1024*1024);
        System.out.println("try " + params[0] + " " + params[1] + " " + params[2]);
    }
 

import com.lambdaworks.crypto.SCrypt; //导入方法依赖的package包/类
private ECKey decryptEC(String normalizedPassphrase) {
    try {
        byte[] ownerEntropy = Arrays.copyOfRange(content, 0, 8);
        byte[] ownerSalt = hasLotAndSequence ? Arrays.copyOfRange(ownerEntropy, 0, 4) : ownerEntropy;

        byte[] passFactorBytes = SCrypt.scrypt(normalizedPassphrase.getBytes(Charsets.UTF_8), ownerSalt, 16384, 8, 8, 32);
        if (hasLotAndSequence) {
            byte[] hashBytes = Bytes.concat(passFactorBytes, ownerEntropy);
            checkState(hashBytes.length == 40);
            passFactorBytes = Sha256Hash.hashTwice(hashBytes);
        }
        BigInteger passFactor = new BigInteger(1, passFactorBytes);
        ECKey k = ECKey.fromPrivate(passFactor, true);

        byte[] salt = Bytes.concat(addressHash, ownerEntropy);
        checkState(salt.length == 12);
        byte[] derived = SCrypt.scrypt(k.getPubKey(), salt, 1024, 1, 1, 64);
        byte[] aeskey = Arrays.copyOfRange(derived, 32, 64);

        SecretKeySpec keyspec = new SecretKeySpec(aeskey, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
        cipher.init(Cipher.DECRYPT_MODE, keyspec);

        byte[] encrypted2 = Arrays.copyOfRange(content, 16, 32);
        byte[] decrypted2 = cipher.doFinal(encrypted2);
        checkState(decrypted2.length == 16);
        for (int i = 0; i < 16; i++)
            decrypted2[i] ^= derived[i + 16];

        byte[] encrypted1 = Bytes.concat(Arrays.copyOfRange(content, 8, 16), Arrays.copyOfRange(decrypted2, 0, 8));
        byte[] decrypted1 = cipher.doFinal(encrypted1);
        checkState(decrypted1.length == 16);
        for (int i = 0; i < 16; i++)
            decrypted1[i] ^= derived[i];

        byte[] seed = Bytes.concat(decrypted1, Arrays.copyOfRange(decrypted2, 8, 16));
        checkState(seed.length == 24);
        BigInteger seedFactor = new BigInteger(1, Sha256Hash.hashTwice(seed));
        checkState(passFactor.signum() >= 0);
        checkState(seedFactor.signum() >= 0);
        BigInteger priv = passFactor.multiply(seedFactor).mod(ECKey.CURVE.getN());

        return ECKey.fromPrivate(priv, compressed);
    } catch (GeneralSecurityException x) {
        throw new RuntimeException(x);
    }
}