Example usage for org.bouncycastle.bcpg S2K S2K

Introduction

In this page you can find the example usage for org.bouncycastle.bcpg S2K S2K.

Prototype

public S2K(int algorithm, byte[] iv, int itCount) 

Source Link

Document

Constructs a specifier for a #SALTED_AND_ITERATED salted and iterated S2K generation.

Usage

From source file:genkeys.java

License:Open Source License

private static void exportSecretKey(OutputStream out, KeyPair key, int cipher, int s2kmode, int hashAlgorithm,
        boolean useSHA1, String pass, boolean armor) throws IOException, NoSuchProviderException, PGPException {
    if (armor) {/*from  www .j a  v a2s . com*/
        out = new ArmoredOutputStream(out);
    }

    SecureRandom rand = new SecureRandom();
    byte[] iv = new byte[8];
    rand.nextBytes(iv);
    S2K s2k = new S2K(hashAlgorithm, iv, 0x60);

    SecretKeyPacket packet = secretKeyPacket(key, cipher, useSHA1, s2k, pass);

    BCPGOutputStream bcOut;
    if (out instanceof BCPGOutputStream) {
        bcOut = (BCPGOutputStream) out;
    } else {
        bcOut = new BCPGOutputStream(out);
    }

    bcOut.writePacket(packet);

    if (armor) {
        out.close();
    }
}

---

From source file:org.sufficientlysecure.keychain.operations.BenchmarkOperation.java

License:Open Source License

@NonNull
@Override/*  ww  w . ja v  a 2s  .co m*/
public BenchmarkResult execute(BenchmarkInputParcel consolidateInputParcel,
        CryptoInputParcel cryptoInputParcel) {
    OperationLog log = new OperationLog();
    log.add(LogType.MSG_BENCH, 0);

    // random data
    byte[] buf = new byte[1024 * 1024 * 10];
    new Random().nextBytes(buf);

    Passphrase passphrase = new Passphrase("a");

    int numRepeats = 5;
    long totalTime = 0;

    // encrypt
    SignEncryptResult encryptResult;
    int i = 0;
    do {
        SignEncryptOperation op = new SignEncryptOperation(mContext, mProviderHelper,
                new ProgressScaler(mProgressable, i * (50 / numRepeats), (i + 1) * (50 / numRepeats), 100),
                mCancelled);
        PgpSignEncryptData data = new PgpSignEncryptData();
        data.setSymmetricPassphrase(passphrase);
        data.setSymmetricEncryptionAlgorithm(OpenKeychainSymmetricKeyAlgorithmTags.AES_128);
        SignEncryptParcel input = new SignEncryptParcel(data);
        input.setBytes(buf);
        encryptResult = op.execute(input, new CryptoInputParcel());
        log.add(encryptResult, 1);
        log.add(LogType.MSG_BENCH_ENC_TIME, 2,
                String.format("%.2f", encryptResult.getResults().get(0).mOperationTime / 1000.0));
        totalTime += encryptResult.getResults().get(0).mOperationTime;
    } while (++i < numRepeats);

    long encryptionTime = totalTime / numRepeats;
    totalTime = 0;

    // decrypt
    i = 0;
    do {
        DecryptVerifyResult decryptResult;
        PgpDecryptVerifyOperation op = new PgpDecryptVerifyOperation(mContext, mProviderHelper,
                new ProgressScaler(mProgressable, 50 + i * (50 / numRepeats), 50 + (i + 1) * (50 / numRepeats),
                        100));
        PgpDecryptVerifyInputParcel input = new PgpDecryptVerifyInputParcel(encryptResult.getResultBytes());
        input.setAllowSymmetricDecryption(true);
        decryptResult = op.execute(input, new CryptoInputParcel(passphrase));
        log.add(decryptResult, 1);
        log.add(LogType.MSG_BENCH_DEC_TIME, 2, String.format("%.2f", decryptResult.mOperationTime / 1000.0));
        totalTime += decryptResult.mOperationTime;
    } while (++i < numRepeats);

    long decryptionTime = totalTime / numRepeats;
    totalTime = 0;

    int iterationsFor100ms;
    try {
        PGPDigestCalculatorProvider digestCalcProvider = new JcaPGPDigestCalculatorProviderBuilder()
                .setProvider(Constants.BOUNCY_CASTLE_PROVIDER_NAME).build();
        PBEDataDecryptorFactory decryptorFactory = new JcePBEDataDecryptorFactoryBuilder(digestCalcProvider)
                .setProvider(Constants.BOUNCY_CASTLE_PROVIDER_NAME).build("".toCharArray());

        byte[] iv = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
        int iterations = 0;
        while (iterations < 255 && totalTime < 100) {
            iterations += 1;

            S2K s2k = new S2K(HashAlgorithmTags.SHA1, iv, iterations);
            totalTime = System.currentTimeMillis();
            decryptorFactory.makeKeyFromPassPhrase(SymmetricKeyAlgorithmTags.AES_128, s2k);
            totalTime = System.currentTimeMillis() - totalTime;

            if ((iterations % 10) == 0) {
                log.add(LogType.MSG_BENCH_S2K_FOR_IT, 1, Integer.toString(iterations),
                        Long.toString(totalTime));
            }

        }
        iterationsFor100ms = iterations;

    } catch (PGPException e) {
        Log.e(Constants.TAG, "internal error during benchmark", e);
        log.add(LogType.MSG_INTERNAL_ERROR, 0);
        return new BenchmarkResult(BenchmarkResult.RESULT_ERROR, log);
    }

    log.add(LogType.MSG_BENCH_S2K_100MS_ITS, 1, Integer.toString(iterationsFor100ms));
    log.add(LogType.MSG_BENCH_ENC_TIME_AVG, 1, String.format("%.2f", encryptionTime / 1000.0));
    log.add(LogType.MSG_BENCH_DEC_TIME_AVG, 1, String.format("%.2f", decryptionTime / 1000.0));

    log.add(LogType.MSG_BENCH_SUCCESS, 0);
    return new BenchmarkResult(BenchmarkResult.RESULT_OK, log);
}

---