Java Cipher.update方法代码示例

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void combination_2(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {
    Cipher c = createCipher(mode, params);
    c.updateAAD(AAD);
    int t = 0;
    int offset = 0;
    if (plainText.length > ARRAY_OFFSET) {
        t = plainText.length - ARRAY_OFFSET;
        offset = ARRAY_OFFSET;
    }
    byte[] part21 = c.update(plainText, 0, t);
    byte[] part22 = new byte[c.getOutputSize(plainText.length)];
    int len2 = c.doFinal(plainText, t, offset, part22, 0);
    int part21Length = part21 != null ? part21.length : 0;
    byte[] outputText2 = new byte[part21Length + len2];
    if (part21 != null) {
        System.arraycopy(part21, 0, outputText2, 0, part21Length);
    }
    System.arraycopy(part22, 0, outputText2, part21Length, len2);
    results.add(outputText2);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void doPairVerify2(Socket socket, byte[] pairVerify1Response, byte[] randomPrivateKey, byte[] randomPublicKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IOException, InvalidAlgorithmParameterException, SignatureException {
    byte[] atvPublicKey = Arrays.copyOfRange(pairVerify1Response, 0, 32);
    byte[] sharedSecret = new byte[32];
    Curve25519.curve(sharedSecret, randomPrivateKey, atvPublicKey);

    MessageDigest sha512Digest = MessageDigest.getInstance("SHA-512");
    sha512Digest.update("Pair-Verify-AES-Key".getBytes(StandardCharsets.UTF_8));
    sha512Digest.update(sharedSecret);
    byte[] sharedSecretSha512AesKey = Arrays.copyOfRange(sha512Digest.digest(), 0, 16);

    sha512Digest.update("Pair-Verify-AES-IV".getBytes(StandardCharsets.UTF_8));
    sha512Digest.update(sharedSecret);
    byte[] sharedSecretSha512AesIV = Arrays.copyOfRange(sha512Digest.digest(), 0, 16);

    Cipher aesCtr128Encrypt = Cipher.getInstance("AES/CTR/NoPadding");
    aesCtr128Encrypt.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(sharedSecretSha512AesKey, "AES"), new IvParameterSpec(sharedSecretSha512AesIV));

    aesCtr128Encrypt.update(Arrays.copyOfRange(pairVerify1Response, 32, pairVerify1Response.length));

    EdDSAEngine edDSAEngine = new EdDSAEngine();
    edDSAEngine.initSign(authKey);

    byte[] signature = aesCtr128Encrypt.update(edDSAEngine.signOneShot(AuthUtils.concatByteArrays(randomPublicKey, atvPublicKey)));

    AuthUtils.postData(socket, "/pair-verify", "application/octet-stream", AuthUtils.concatByteArrays(new byte[]{0, 0, 0, 0}, signature));
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
public static void encrypt(String message) throws Exception {

        byte[] iv = new byte[16];
        new SecureRandom().nextBytes(iv);

        //IV
        IvParameterSpec ivSpec = new IvParameterSpec(iv);

        //Key
        KeyGenerator generator = KeyGenerator.getInstance("AES");
        generator.init(128);
        SecretKey secretKey = generator.generateKey();

        //Encrypt
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec);
        cipher.update(message.getBytes());

        byte[] data = cipher.doFinal();
        System.out.println(HexUtil.toString(data));
    }
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void runGCMWithSameArray(int mode, byte[] array, int txtOffset,
        int length, AlgorithmParameters params) throws Exception {
    // first, generate cipher text at an allocated buffer
    Cipher cipher = createCipher(mode, params);
    cipher.updateAAD(array, 0, AADLength);
    byte[] outputText = cipher.doFinal(array, txtOffset, length);

    // new cipher for encrypt operation
    Cipher anotherCipher = createCipher(mode, params);
    anotherCipher.updateAAD(array, 0, AADLength);

    // next, generate cipher text again at the same buffer of plain text
    int off = anotherCipher.update(array, txtOffset, length,
            array, txtOffset);
    anotherCipher.doFinal(array, txtOffset + off);

    // check if two results are equal or not
    if (!isEqual(array, txtOffset, outputText, 0,
            outputText.length)) {
        throw new RuntimeException(
                "Two results are not equal, mode:" + mode);
    }
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void combination_6(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {
    Cipher c = createCipher(mode, params);
    c.updateAAD(AAD, 0, AAD.length / 2);
    c.updateAAD(AAD, AAD.length / 2, AAD.length - AAD.length / 2);
    int t = 0;
    int offset = 0;
    if (plainText.length > ARRAY_OFFSET) {
        t = plainText.length - ARRAY_OFFSET;
        offset = ARRAY_OFFSET;
    }
    byte[] part61 = c.update(plainText, 0, t);
    byte[] part62 = new byte[c.getOutputSize(plainText.length)];
    int len = c.doFinal(plainText, t, offset, part62, 0);
    int part61Length = part61 != null ? part61.length : 0;
    byte[] outputText6 = new byte[part61Length + len];
    if (part61 != null) {
        System.arraycopy(part61, 0, outputText6, 0, part61Length);
    }
    System.arraycopy(part62, 0, outputText6, part61Length, len);
    results.add(outputText6);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void runGCMWithSeparateArray(int mode, byte[] AAD, byte[] text,
        int txtOffset, int lenght, int offset, AlgorithmParameters params)
        throws Exception {
    // first, generate the cipher text at an allocated buffer
    Cipher cipher = createCipher(mode, params);
    cipher.updateAAD(AAD);
    byte[] outputText = cipher.doFinal(text, txtOffset, lenght);

    // new cipher for encrypt operation
    Cipher anotherCipher = createCipher(mode, params);
    anotherCipher.updateAAD(AAD);

    // next, generate cipher text again at the same buffer of plain text
    int myoff = offset;
    int off = anotherCipher.update(text, txtOffset, lenght, text, myoff);
    anotherCipher.doFinal(text, myoff + off);

    // check if two resutls are equal
    if (!isEqual(text, myoff, outputText, 0, outputText.length)) {
        throw new RuntimeException("Two results not equal, mode:" + mode);
    }
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
public String encrypt(String data) throws Exception {
	if (null == data)
		return null;
	Cipher cipher = Cipher.getInstance(DES);
	cipher.init(Cipher.ENCRYPT_MODE, key);
	StringBuffer sb = new StringBuffer();
	int blockSize = cipher.getBlockSize();
	int outputSize = cipher.getOutputSize(blockSize);
	byte[] src = data.getBytes();
	byte[] outBytes = new byte[outputSize];
	int i = 0;
	try {
		for (; i <= src.length - blockSize; i = i + blockSize) {
			int outLength = cipher.update(src, i, blockSize, outBytes);
			sb.append(bytesToString(outBytes, outLength));
		}
		if (i == src.length)
			outBytes = cipher.doFinal();
		else {
			outBytes = cipher.doFinal(src, i, src.length - i);
		}
		sb.append(bytesToString(outBytes));
		return sb.toString();
	} catch (Exception e) {
		e.printStackTrace();
	}
	return null;
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
public String decrypt(String data) throws Exception {
	if (null == data)
		return null;
	Cipher cipher = Cipher.getInstance(DES);
	cipher.init(Cipher.DECRYPT_MODE, key);
	StringBuffer sb = new StringBuffer();
	int blockSize = cipher.getBlockSize();
	int outputSize = cipher.getOutputSize(blockSize);
	byte[] src = stringToBytes(data);
	byte[] outBytes = new byte[outputSize];
	int i = 0;
	try {
		for (; i <= src.length - blockSize; i = i + blockSize) {
			int outLength = cipher.update(src, i, blockSize, outBytes);
			sb.append(new String(outBytes, 0, outLength));
		}
		if (i == src.length)
			outBytes = cipher.doFinal();
		else {
			outBytes = cipher.doFinal(src, i, src.length - i);
		}
		sb.append(new String(outBytes));
		return sb.toString();
	} catch (Exception e) {
		e.printStackTrace();
	}
	return null;
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
/**
 * Encrypt key (does not use salting, so the encryption result is the same for the same input)
 *
 * @param password the secret key to use
 * @param data     the data to encrypt
 * @return the encrypted data
 */
static byte[] encryptData(byte[] password, int size, byte[] data) {
    try {
        Cipher c = Cipher.getInstance(ENCRYPT_DATA_ALGORITHM);
        c.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(password, SECRET_KEY_ALGORITHM), CBC_SALT_DATA);
        c.update(new byte[]{(byte)(size >> 24), (byte)(size >> 16), (byte)(size >> 8), (byte)(size)});
        return c.doFinal(data);
    }
    catch (Exception e) {
        throw new IllegalStateException(ENCRYPT_DATA_ALGORITHM + " is not available", e);
    }
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void combination_11(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {

    // prepare ByteBuffer1 to test
    ByteBuffer buf1 = ByteBuffer.allocate(AAD.length / 2);
    buf1.put(AAD, 0, AAD.length / 2);
    buf1.position(0);
    buf1.limit(AAD.length / 2);

    // get a Cipher object and do combination
    Cipher ci = createCipher(mode, params);

    // process the first half of AAD data
    ci.updateAAD(buf1);

    // prepare ByteBuffer2 to test
    ByteBuffer buf2 = ByteBuffer.allocate(AAD.length - AAD.length / 2);
    buf2.put(AAD, AAD.length / 2, AAD.length - AAD.length / 2);
    buf2.position(0);
    buf2.limit(AAD.length - AAD.length / 2);

    // process the rest of AAD data
    ci.updateAAD(buf2);

    // encrypt plain text
    byte[] part11_1 = new byte[ci.getOutputSize(plainText.length)];
    int offset = plainText.length > ARRAY_OFFSET ? ARRAY_OFFSET : 0;
    int len_11 = ci.update(plainText, 0, plainText.length - offset,
            part11_1, 0);
    byte[] part11_2 = ci.doFinal(plainText, plainText.length - offset,
            offset);
    byte[] outputText11 = new byte[len_11 + part11_2.length];
    System.arraycopy(part11_1, 0, outputText11, 0, len_11);
    System.arraycopy(part11_2, 0, outputText11, len_11, part11_2.length);
    results.add(outputText11);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void combination_5(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {
    Cipher c = createCipher(mode, params);
    c.updateAAD(AAD, 0, AAD.length);
    byte[] part51 = c.update(plainText, 0, plainText.length);
    byte[] part52 = c.doFinal();
    int part51Length = part51 != null ? part51.length : 0;
    byte[] outputText5 = new byte[part51Length + part52.length];
    if (part51 != null) {
        System.arraycopy(part51, 0, outputText5, 0, part51Length);
    }
    System.arraycopy(part52, 0, outputText5, part51Length, part52.length);
    results.add(outputText5);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void combination_14(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {
    Cipher c = createCipher(mode, params);
    // prepare ByteBuffer to test
    ByteBuffer buf = ByteBuffer.allocateDirect(AAD.length);
    buf.put(AAD);

    // process the first half of AAD data
    buf.position(0);
    buf.limit(AAD.length / 2);
    c.updateAAD(buf);

    // process the rest of AAD data
    buf.limit(AAD.length);
    c.updateAAD(buf);

    // prepare buffers to encrypt/decrypt
    ByteBuffer in = ByteBuffer.allocate(plainText.length);
    in.put(plainText);
    in.position(0);
    in.limit(plainText.length);
    ByteBuffer out = ByteBuffer.allocate(c.getOutputSize(in.limit()));
    out.position(0);
    out.limit(c.getOutputSize(in.limit()));

    // process input text
    c.update(in, out);
    c.doFinal(in, out);
    int resultSize = out.position();
    byte[] result14 = new byte[resultSize];
    out.position(0);
    out.limit(resultSize);
    out.get(result14, 0, resultSize);
    results.add(result14);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void combination_16(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {
    Cipher c = createCipher(mode, params);

    // prepare ByteBuffer to test
    ByteBuffer buf = ByteBuffer.allocateDirect(AAD.length);
    buf.put(AAD);
    buf.position(0);
    buf.limit(AAD.length);
    c.updateAAD(buf);

    // prepare empty ByteBuffer
    ByteBuffer emptyBuf = ByteBuffer.allocateDirect(0);
    emptyBuf.put(new byte[0]);
    c.updateAAD(emptyBuf);

    // prepare buffers to encrypt/decrypt
    ByteBuffer in = ByteBuffer.allocateDirect(plainText.length);
    in.put(plainText);
    in.position(0);
    in.limit(plainText.length);
    ByteBuffer output = ByteBuffer.allocateDirect(
            c.getOutputSize(in.limit()));
    output.position(0);
    output.limit(c.getOutputSize(in.limit()));

    // process input text with an empty buffer
    c.update(in, output);
    ByteBuffer emptyBuf2 = ByteBuffer.allocate(0);
    emptyBuf2.put(new byte[0]);
    c.doFinal(emptyBuf2, output);
    int resultSize = output.position();
    byte[] result16 = new byte[resultSize];
    output.position(0);
    output.limit(resultSize);
    output.get(result16, 0, resultSize);
    results.add(result16);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void combination_8(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {
    Cipher ci = createCipher(mode, params);
    ci.updateAAD(AAD, 0, 0);
    ci.updateAAD(AAD, 0, AAD.length);
    byte[] part81 = new byte[ci.getOutputSize(plainText.length)];
    int offset = plainText.length > ARRAY_OFFSET ? ARRAY_OFFSET : 0;
    int len = ci.update(plainText, 0, plainText.length - offset, part81, 0);
    int rest = ci.doFinal(plainText, plainText.length - offset, offset,
            part81, len);
    byte[] outputText8 = new byte[len + rest];
    System.arraycopy(part81, 0, outputText8, 0, outputText8.length);
    results.add(outputText8);
}
 

import javax.crypto.Cipher; //导入方法依赖的package包/类
private void combination_10(List<byte[]> results, int mode, byte[] AAD,
        byte[] plainText, AlgorithmParameters params) throws Exception {

    // prepare ByteBuffer to test
    ByteBuffer buf = ByteBuffer.allocate(AAD.length);
    buf.put(AAD);
    buf.position(0);
    buf.limit(AAD.length / 2);

    // get a Cipher object and do the combination
    Cipher c = createCipher(mode, params);

    // process the first half of AAD data
    c.updateAAD(buf);

    // process the rest of AAD data
    buf.limit(AAD.length);
    c.updateAAD(buf);

    // prapare variables for the combination
    int t = 0;
    int offset = 0;
    if (plainText.length > ARRAY_OFFSET) {
        t = plainText.length - ARRAY_OFFSET;
        offset = ARRAY_OFFSET;
    }

    // encrypt the text
    byte[] part10_1 = c.update(plainText, 0, t);
    int part10_1_Length = part10_1 != null ? part10_1.length : 0;
    byte[] part10_2 = new byte[c.getOutputSize(plainText.length)];
    int len2 = c.doFinal(plainText, t, offset, part10_2, 0);

    // form the combination's result
    byte[] outputText10 = new byte[part10_1_Length + len2];
    if (part10_1 != null) {
        System.arraycopy(part10_1, 0, outputText10, 0, part10_1_Length);
    }
    System.arraycopy(part10_2, 0, outputText10, part10_1_Length, len2);
    results.add(outputText10);
}