Java Cipher.getParameters方法代码示例

import javax.crypto.Cipher; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    Provider p = Security.getProvider("SunJCE");
    for (String alg : ALGORITHMS) {
        for (int keyStrength : KEY_STRENGTHS) {
            if (keyStrength > Cipher.getMaxAllowedKeyLength(alg)) {
                // skip this if this key length is larger than what's
                // configured in the JCE jurisdiction policy files
                continue;
            }
            for (int textLength : TEXT_LENGTHS) {
                for (int AADLength : AAD_LENGTHS) {
                    Encrypt test = new Encrypt(p, alg,
                            "GCM", "NoPadding", keyStrength, textLength,
                            AADLength);
                    Cipher cipher = test.createCipher(Cipher.ENCRYPT_MODE,
                            null);
                    AlgorithmParameters params = cipher.getParameters();
                    test.doTest(params);
                    System.out.println("Test " + alg + ":"
                            + keyStrength + ":" + textLength + ":"
                            + AADLength + " passed");
                }
            }
        }
    }
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    Provider provider = Security.getProvider("SunJCE");
    if (provider == null) {
        throw new RuntimeException("SunJCE provider not exist");
    }
    // generate no-padding cipher with secret key
    Cipher c = Cipher.getInstance("DES/CBC/NoPadding", provider);
    KeyGenerator kgen = KeyGenerator.getInstance("DES", provider);
    SecretKey skey = kgen.generateKey();
    // this is the improperly padded plaintext

    c.init(Cipher.ENCRYPT_MODE, skey);
    // encrypt plaintext
    byte[] cipher = c.doFinal(PLAIN_TEXT);
    AlgorithmParameters params = c.getParameters();
    // generate cipher that enforces PKCS5 padding
    c = Cipher.getInstance("DES/CBC/PKCS5Padding", provider);
    c.init(Cipher.DECRYPT_MODE, skey, params);
    try {
        c.doFinal(cipher);
        throw new RuntimeException(
                "ERROR: Expected BadPaddingException not thrown");
    } catch (BadPaddingException expected) {
        out.println("Expected BadPaddingException thrown");
    }

}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
/**
     * {@inheritDoc}
     */
    @Override
    public Pair<byte[], AlgorithmParameters> encrypt(String keyAlias, AlgorithmParameters params, byte[] input)
    {
        Cipher cipher = getCipher(keyAlias, params, Cipher.ENCRYPT_MODE);
        if (cipher == null)
        {
            return new Pair<byte[], AlgorithmParameters>(input, null);
        }
        try
        {
            byte[] output = cipher.doFinal(input);
            params = cipher.getParameters();
            return new Pair<byte[], AlgorithmParameters>(output, params);
        }
        catch (Throwable e)
        {
//            cipher.init(Cipher.ENCRYPT_MODE, key, params);
            throw new AlfrescoRuntimeException("Decryption failed for key alias: " + keyAlias, e);
        }
    }
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private byte[] encrypt(byte[] indata, SecretKey key, String algorithm) throws Exception {

        byte[] result = indata;

        Cipher c = Cipher.getInstance(algorithm);
        c.init(Cipher.ENCRYPT_MODE, key);
        algorithmParameters = c.getParameters();

        byte[] r1 = c.update(result);
        byte[] r2 = c.doFinal();

        result = new byte[r1.length + r2.length];
        System.arraycopy(r1, 0, result, 0, r1.length);
        System.arraycopy(r2, 0, result, r1.length, r2.length);

        return result;
    }
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
/**
 * Initiate the Cipher object using given "mode".
 * @return a cipher object.
 * @throws GeneralSecurityException all security exceptions are thrown.
 */
@Override
protected Cipher initCipher(int mode) throws GeneralSecurityException {
    Provider provider = Security.getProvider("SunJCE");
    if (provider == null) {
        throw new RuntimeException("SunJCE provider does not exist.");
    }
    // get Cipher instance
    Cipher ci = Cipher.getInstance(transformation, provider);
    if (Cipher.ENCRYPT_MODE == mode) {
        ci.init(Cipher.ENCRYPT_MODE, key);
        pbeParams = ci.getParameters();
    } else {
        ci.init(Cipher.DECRYPT_MODE, key, pbeParams);
    }
    return ci;
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private static byte[] encrypt(SecretKey key, String msg) throws GeneralSecurityException {
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE, key);
    AlgorithmParameters params = cipher.getParameters();
    byte[] iv = params.getParameterSpec(IvParameterSpec.class).getIV();
    byte[] ciphertext = cipher.doFinal(msg.getBytes());

    return concatenateByteArrays(iv, ciphertext);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
public byte[] encrypt(SecretKey key, String msg) throws Exception {
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE, key);
    AlgorithmParameters params = cipher.getParameters();
    byte[] iv = params.getParameterSpec(IvParameterSpec.class).getIV();
    byte[] ciphertext = cipher.doFinal(msg.getBytes("UTF-8"));

    return concatenateByteArrays(iv, ciphertext);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
/**
 * Encrypt plaintext.
 * @param str Plaintext to encrypt
 * @return Cipher text
 */
public String encrypt(final String str) {
    if (str == null) {
        throw new NullPointerException("Argument cannot be null");
    }

    try {
        final SecureRandom random = new SecureRandom();
        final byte[] salt = new byte[16];
        random.nextBytes(salt);

        final SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
        final KeySpec spec = new PBEKeySpec(passphrase.toCharArray(), salt, 65536, 128);
        final SecretKey tmp = factory.generateSecret(spec);
        final SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES");

        final Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, secret);

        final AlgorithmParameters params = cipher.getParameters();
        final byte[] iv = params.getParameterSpec(IvParameterSpec.class).getIV();
        final byte[] encryptedText = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));

        // concatenate salt + iv + ciphertext
        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        outputStream.write(salt);
        outputStream.write(iv);
        outputStream.write(encryptedText);

        // properly encode the complete cipher text
        return DatatypeConverter.printBase64Binary(outputStream.toByteArray());
    } catch (final Exception exception) {
        throw new RuntimeException(exception.getMessage(), exception);
    }
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
public String encrypt(String rawPassword, String salt) throws CodecOperationException {
	try {
		SecretKeySpec keySpec = createSecretKey(WAGSTAFF_PRIME, salt.getBytes());
		Cipher cipher = fetchCipher();
		cipher.init(Cipher.ENCRYPT_MODE, keySpec);
		AlgorithmParameters parameters = cipher.getParameters();
		IvParameterSpec ivParameterSpec = parameters.getParameterSpec(IvParameterSpec.class);
		byte[] cryptoText = cipher.doFinal(rawPassword.getBytes("UTF-8"));
		byte[] iv = ivParameterSpec.getIV();
		return base64Encode(iv) + SEPARATOR + base64Encode(cryptoText);
	} catch (GeneralSecurityException | UnsupportedEncodingException e) {
		throw new CodecOperationException(e);
	}
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
static void runTest(Provider p, String algo, String mode,
        String padding, int keyLength, int textLength, int AADLength,
        int offset) throws Exception {
    System.out.println("Testing " + keyLength + " key length; "
            + textLength + " text lenght; " + AADLength + " AAD length; "
            + offset + " offset");
    if (keyLength > Cipher.getMaxAllowedKeyLength(algo)) {
        // skip this if this key length is larger than what's
        // configured in the jce jurisdiction policy files
        return;
    }
    SameBuffer test = new SameBuffer(p, algo, mode,
            padding, keyLength, textLength, AADLength);

    /*
     * There are four test cases:
     *   1. AAD and text are placed in separated byte arrays
     *   2. AAD and text are placed in the same byte array
     *   3. AAD and text are placed in separated byte buffers
     *   4. AAD and text are placed in the same byte buffer
     */
    Cipher ci = test.createCipher(Cipher.ENCRYPT_MODE, null);
    AlgorithmParameters params = ci.getParameters();
    test.doTestWithSeparateArrays(offset, params);
    test.doTestWithSameArrays(offset, params);
    test.doTestWithSeparatedBuffer(offset, params);
    test.doTestWithSameBuffer(offset, params);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private static void doTest(String provider, String algo) throws Exception {
    SecretKey key;
    SecretKey keyToWrap;

    // init a secret Key
    KeyGenerator kg = KeyGenerator.getInstance(AES, PROVIDER);
    kg.init(KEY_LENGTH);
    key = kg.generateKey();
    keyToWrap = kg.generateKey();

    // initialization
    Cipher cipher = Cipher.getInstance(algo, provider);
    cipher.init(Cipher.WRAP_MODE, key);
    AlgorithmParameters params = cipher.getParameters();

    // wrap the key
    byte[] keyWrapper = cipher.wrap(keyToWrap);
    try {
        // check if we can't wrap it again with the same key/IV
        keyWrapper = cipher.wrap(keyToWrap);
        throw new RuntimeException(
                "FAILED: expected IllegalStateException hasn't "
                        + "been thrown ");
    } catch (IllegalStateException ise) {
        System.out.println(ise.getMessage());
        System.out.println("Expected exception");
    }

    // unwrap the key
    cipher.init(Cipher.UNWRAP_MODE, key, params);
    cipher.unwrap(keyWrapper, algo, Cipher.SECRET_KEY);

    // check if we can unwrap second time
    Key unwrapKey = cipher.unwrap(keyWrapper, algo, Cipher.SECRET_KEY);

    if (!Arrays.equals(keyToWrap.getEncoded(), unwrapKey.getEncoded())) {
        throw new RuntimeException(
                "FAILED: original and unwrapped keys are not equal");
    }
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
/**
 * Encrypt a string with AES algorithm.
 *
 * @param data
 *            is a string
 * @return the encrypted string
 */
public static String[] encrypt(String data, String password) throws Exception {

	String[] result = new String[2];

	Key key = getPasswordHash(password);

	Cipher cipher = Cipher.getInstance(ENC_ALGO);
	cipher.init(Cipher.ENCRYPT_MODE, key);

	AlgorithmParameters params = cipher.getParameters();
	byte[] iv = params.getParameterSpec(IvParameterSpec.class).getIV();

	byte[] encVal = cipher.doFinal(data.getBytes());

	result[0] = new String(Base64.encode(iv), Charset.forName("UTF-8"));
       result[1] = new String(Base64.encode(encVal), Charset.forName("UTF-8"));

	return result;
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
public boolean runTest(Provider p, String algo, PrintStream out)
        throws Exception {

    byte[] salt = new byte[8];
    int ITERATION_COUNT = 1000;
    AlgorithmParameters pbeParams = null;

    String baseAlgo
            = new StringTokenizer(algo, "/").nextToken().toUpperCase();
    boolean isAES = baseAlgo.contains("AES");

    boolean isUnlimited =
        (Cipher.getMaxAllowedKeyLength(algo) == Integer.MAX_VALUE);

    try {
        // Initialization
        new Random().nextBytes(salt);
        AlgorithmParameterSpec aps = new PBEParameterSpec(salt,
                ITERATION_COUNT);
        SecretKeyFactory skf = SecretKeyFactory.getInstance(baseAlgo, p);
        SecretKey key = skf.generateSecret(new PBEKeySpec(
                "Secret Key".toCharArray()));
        Cipher ci = Cipher.getInstance(algo);
        if (isAES) {
            ci.init(Cipher.WRAP_MODE, key);
            pbeParams = ci.getParameters();
        } else {
            ci.init(Cipher.WRAP_MODE, key, aps);
        }

        byte[] keyWrapper = ci.wrap(key);
        if (isAES) {
            ci.init(Cipher.UNWRAP_MODE, key, pbeParams);
        } else {
            ci.init(Cipher.UNWRAP_MODE, key, aps);
        }

        Key unwrappedKey = ci.unwrap(keyWrapper, algo, Cipher.SECRET_KEY);

        if ((baseAlgo.endsWith("TRIPLEDES")
                || baseAlgo.endsWith("AES_256")) && !isUnlimited) {
            out.print(
                    "Expected InvalidKeyException not thrown");
            return false;
        }

        return (Arrays.equals(key.getEncoded(), unwrappedKey.getEncoded()));

    } catch (InvalidKeyException ex) {

        if ((baseAlgo.endsWith("TRIPLEDES")
                || baseAlgo.endsWith("AES_256")) && !isUnlimited) {
            out.print(
                    "Expected InvalidKeyException thrown");
            return true;
        } else {
            throw ex;
        }
    }
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
public boolean runTest(Provider p, String algo, PrintStream out)
        throws Exception {

    byte[] salt = new byte[8];
    int ITERATION_COUNT = 1000;
    AlgorithmParameters pbeParams = null;

    String baseAlgo
            = new StringTokenizer(algo, "/").nextToken().toUpperCase();
    boolean isAES = baseAlgo.contains("AES");

    try {
        // Initialization
        new Random().nextBytes(salt);
        AlgorithmParameterSpec aps = new PBEParameterSpec(salt,
                ITERATION_COUNT);
        SecretKeyFactory skf = SecretKeyFactory.getInstance(baseAlgo, p);
        SecretKey key = skf.generateSecret(new PBEKeySpec(
                "Secret Key".toCharArray()));
        Cipher ci = Cipher.getInstance(algo);

        if (isAES) {
            ci.init(Cipher.WRAP_MODE, key);
            pbeParams = ci.getParameters();
        } else {
            ci.init(Cipher.WRAP_MODE, key, aps);
        }

        byte[] keyWrapper = ci.wrap(key);
        if (isAES) {
            ci.init(Cipher.UNWRAP_MODE, key, pbeParams);
        } else {
            ci.init(Cipher.UNWRAP_MODE, key, aps);
        }

        Key unwrappedKey = ci.unwrap(keyWrapper, algo, Cipher.SECRET_KEY);

        if (baseAlgo.endsWith("TRIPLEDES")
                || baseAlgo.endsWith("AES_256")) {
            out.print(
                    "InvalidKeyException not thrown when keyStrength > 128");
            return false;
        }

        return (Arrays.equals(key.getEncoded(), unwrappedKey.getEncoded()));

    } catch (InvalidKeyException ex) {

        if ((baseAlgo.endsWith("TRIPLEDES")
                || baseAlgo.endsWith("AES_256"))) {
            out.println("Expected InvalidKeyException, keyStrength > 128");
            return true;
        } else {
            throw ex;
        }
    }
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
@Override
public void main(Provider p) throws Exception {
    boolean status = true;
    Random random = new Random();
    try {
        for (int i = 0; i < TEST_LIST.length; i++) {
            CI currTest = TEST_LIST[i];
            System.out.println("===" + currTest.transformation + "===");
            try {
                KeyGenerator kg =
                    KeyGenerator.getInstance(currTest.keyAlgo, p);
                SecretKey key = kg.generateKey();
                Cipher c1 = Cipher.getInstance(currTest.transformation, p);
                Cipher c2 = Cipher.getInstance(currTest.transformation,
                                               "SunJCE");

                byte[] plainTxt = new byte[currTest.dataSize];
                random.nextBytes(plainTxt);
                System.out.println("Testing inLen = " + plainTxt.length);

                c2.init(Cipher.ENCRYPT_MODE, key);
                AlgorithmParameters params = c2.getParameters();
                byte[] answer = c2.doFinal(plainTxt);
                test(c1, Cipher.ENCRYPT_MODE, key, params,
                     plainTxt, answer);
                System.out.println("Encryption tests: DONE");
                c2.init(Cipher.DECRYPT_MODE, key, params);
                byte[] answer2 = c2.doFinal(answer);
                test(c1, Cipher.DECRYPT_MODE, key, params,
                     answer, answer2);
                System.out.println("Decryption tests: DONE");
            } catch (NoSuchAlgorithmException nsae) {
                System.out.println("Skipping unsupported algorithm: " +
                                   nsae);
            }
        }
    } catch (Exception ex) {
        // print out debug info when exception is encountered
        if (debugBuf != null) {
            System.out.println(debugBuf.toString());
        }
        throw ex;
    }
}