Java InvalidCipherTextException类代码示例

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
public static void main(String[] args) throws InvalidKeyException, DataLengthException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException, IllegalStateException, InvalidCipherTextException
	{

		try 
		{
			UIManager.setLookAndFeel("com.pagosoft.plaf.PgsLookAndFeel");
		}

		catch (Exception e)
		{
			;
		}
		GUI MainGUI = new GUI();
		MainGUI.ConstructGUI();
		
//		String CT = TextEncrypt.CBCDecrypt("8mjf2sqScPChi5lJQut6U5phB6IW8ze90WdqDm+ulLU1NWI2ODZlYzVmMjYxYTA5", "secret", 256, 0, "Q");
//		
//		System.out.println(CT);

	}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
public static String CBCEncrypt(int alg, int KeySize, String inFile, String pwd, String mode) throws NoSuchAlgorithmException, InvalidKeySpecException, DataLengthException, IllegalStateException, InvalidCipherTextException, IOException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException
{
	String res = "";
	
	byte[] plain = loadFile(inFile);
	
	Encryptor enc = new Encryptor();
	enc.setParameters(KeySize, alg);
	enc.setEncParameters(alg, pwd, KeySize, mode);
	byte[] bytesRes = enc.CBCEncrypt(plain, alg);
	
	save2File(inFile + ".enc", bytesRes);
	
	res = "Done! file contents encrypted and saved to a corresponding enc file!"; 
	return res;
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
public static String CBCDecrypt(int alg, int KeySize, String inFile, String pwd, String mode) throws NoSuchAlgorithmException, InvalidKeySpecException, DataLengthException, IllegalStateException, InvalidCipherTextException, IOException
{
	String res = "";
	
	if (checkFile(inFile.substring(0, inFile.lastIndexOf("."))))
	{
		res = "A file with the same name already exists! Rename or move it to avoid losing your data!";
		return res;
	}
	
	byte[] Encrypted = loadFile(inFile);
	
	
	Encryptor enc = new Encryptor();
	enc.setParameters(KeySize, alg);
	enc.setDecParameters(Encrypted, alg, pwd, KeySize, mode);
	byte[] bytesRes = enc.CBCDecrypt(Encrypted, alg);
	
	save2File(inFile.substring(0, inFile.lastIndexOf(".")), bytesRes);
	
	res = "Done! file contents decrypted and saved to the specified directory!"; 
	return res;
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
/**
 * return the number of pad bytes present in the block.
 */
public int padCount(byte[] in)
    throws InvalidCipherTextException
{
    int count = in[in.length - 1] & 0xff;

    if (count > in.length || count == 0)
    {
        throw new InvalidCipherTextException("pad block corrupted");
    }
    
    for (int i = 1; i <= count; i++)
    {
        if (in[in.length - i] != count)
        {
            throw new InvalidCipherTextException("pad block corrupted");
        }
    }

    return count;
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
public GenericKey generateUnwrappedKey(AlgorithmIdentifier encryptedKeyAlgorithm, byte[] encryptedKey)
    throws OperatorException
{
    AsymmetricBlockCipher keyCipher = createAsymmetricUnwrapper(this.getAlgorithmIdentifier().getAlgorithm());

    keyCipher.init(false, privateKey);
    try
    {
        byte[] key = keyCipher.processBlock(encryptedKey, 0, encryptedKey.length);

        if (encryptedKeyAlgorithm.getAlgorithm().equals(PKCSObjectIdentifiers.des_EDE3_CBC))
        {
            return new GenericKey(encryptedKeyAlgorithm, key);
        }
        else
        {
            return new GenericKey(encryptedKeyAlgorithm, key);
        }
    }
    catch (InvalidCipherTextException e)
    {
        throw new OperatorException("unable to recover secret key: " + e.getMessage(), e);
    }
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
public byte[] processBlock(byte[] in, int inOff, int len)
    throws InvalidCipherTextException
{
    byte[] tmp = new byte[len];

    System.arraycopy(in, inOff, tmp, 0, len);

    if (forEncryption)
    {
        return encrypt(tmp, pubKey);
    }
    else
    {
        return decrypt(tmp, privKey);
    }
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
public byte[] decryptPreMasterSecret(byte[] encryptedPreMasterSecret)
    throws IOException
{

    PKCS1Encoding encoding = new PKCS1Encoding(new RSABlindedEngine());
    encoding.init(false, new ParametersWithRandom(this.privateKey, context.getSecureRandom()));

    try
    {
        return encoding.processBlock(encryptedPreMasterSecret, 0,
            encryptedPreMasterSecret.length);
    }
    catch (InvalidCipherTextException e)
    {
        throw new TlsFatalAlert(AlertDescription.illegal_parameter);
    }
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
/**
 * return the number of pad bytes present in the block.
 */
public int padCount(byte[] in)
    throws InvalidCipherTextException
{
    int count = in.length;

    while (count > 0)
    {
        if (in[count - 1] != 0)
        {
            break;
        }

        count--;
    }

    return in.length - count;
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
/**
 * return the number of pad bytes present in the block.
 */
public int padCount(byte[] in)
    throws InvalidCipherTextException
{
    int count = in.length - 1;

    while (count > 0 && in[count] == 0)
    {
        count--;
    }

    if (in[count] != (byte)0x80)
    {
        throw new InvalidCipherTextException("pad block corrupted");
    }
    
    return in.length - count;
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
protected byte[] engineDoFinal(
    byte[]  input,
    int     inputOffset,
    int     inputLen) 
    throws IllegalBlockSizeException, BadPaddingException
{
    if (inputLen != 0)
    {
        buffer.write(input, inputOffset, inputLen);
    }

    try
    {
        byte[]  buf = buffer.toByteArray();

        buffer.reset();

        return cipher.processBlock(buf, 0, buf.length);
    }
    catch (InvalidCipherTextException e)
    {
        throw new BadPaddingException(e.getMessage());
    }
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
protected byte[] engineDoFinal(
    byte[]  input,
    int     inputOffset,
    int     inputLen) 
    throws IllegalBlockSizeException, BadPaddingException
{
    cipher.processBytes(input, inputOffset, inputLen);
    try
    {
        return cipher.doFinal();
    }
    catch (InvalidCipherTextException e)
    {
        throw new BadPaddingException(e.getMessage());
    }
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
protected KeyParameter extractSecretKey(AlgorithmIdentifier keyEncryptionAlgorithm, AlgorithmIdentifier contentEncryptionAlgorithm, byte[] derivedKey, byte[] encryptedContentEncryptionKey)
    throws CMSException
{
    Wrapper keyEncryptionCipher = EnvelopedDataHelper.createRFC3211Wrapper(keyEncryptionAlgorithm.getAlgorithm());

    keyEncryptionCipher.init(false, new ParametersWithIV(new KeyParameter(derivedKey), ASN1OctetString.getInstance(keyEncryptionAlgorithm.getParameters()).getOctets()));

    try
    {
        return new KeyParameter(keyEncryptionCipher.unwrap(encryptedContentEncryptionKey, 0, encryptedContentEncryptionKey.length));
    }
    catch (InvalidCipherTextException e)
    {
        throw new CMSException("unable to unwrap key: " + e.getMessage(), e);
    }
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
public static byte[] aesEncrypt(byte[] plaintext, byte[] myPrivateKey, byte[] theirPublicKey, byte[] nonce) {
    try {
        byte[] dhSharedSecret = new byte[32];
        Curve25519.curve(dhSharedSecret, myPrivateKey, theirPublicKey);
        for (int i = 0; i < 32; i++) {
            dhSharedSecret[i] ^= nonce[i];
        }
        byte[] key = sha256().digest(dhSharedSecret);
        byte[] iv = new byte[16];
        secureRandom.get().nextBytes(iv);
        PaddedBufferedBlockCipher aes = new PaddedBufferedBlockCipher(new CBCBlockCipher(
                new AESEngine()));
        CipherParameters ivAndKey = new ParametersWithIV(new KeyParameter(key), iv);
        aes.init(true, ivAndKey);
        byte[] output = new byte[aes.getOutputSize(plaintext.length)];
        int ciphertextLength = aes.processBytes(plaintext, 0, plaintext.length, output, 0);
        ciphertextLength += aes.doFinal(output, ciphertextLength);
        byte[] result = new byte[iv.length + ciphertextLength];
        System.arraycopy(iv, 0, result, 0, iv.length);
        System.arraycopy(output, 0, result, iv.length, ciphertextLength);
        return result;
    } catch (InvalidCipherTextException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
/**
 * Finishes and voids this cipher output stream.
 * Calling this method causes all remaining buffered bytes to get written
 * and padded if necessary.
 * Afterwards, this stream will behave as if it had been closed, although
 * the decorated stream may still be open.
 *
 * @throws IOException If {@code out} or {@code cipher} aren't properly
 *         initialized, an I/O error occurs or the cipher
 *         text is invalid because some required padding is missing.
 */
public void finish() throws IOException {
    final BufferedBlockCipher cipher = this.cipher;
    if (null == cipher)
        return;
    this.cipher = null;

    int cipherLen = cipher.getOutputSize(0);
    byte[] cipherOut = this.buffer;
    if (cipherLen > cipherOut.length)
        this.buffer = cipherOut = new byte[cipherLen];
    try {
        cipherLen = cipher.doFinal(cipherOut, 0);
    } catch (InvalidCipherTextException ex) {
        throw new IOException(ex);
    }
    out.write(cipherOut, 0, cipherLen);
}
 

import org.bouncycastle.crypto.InvalidCipherTextException; //导入依赖的package包/类
public static byte[] aesDecrypt(byte[] ivCiphertext, byte[] myPrivateKey, byte theirPublicKey[]) {
    try {
        if (ivCiphertext.length < 16 || ivCiphertext.length % 16 != 0) {
            throw new InvalidCipherTextException("invalid ciphertext");
        }
        byte[] iv = Arrays.copyOfRange(ivCiphertext, 0, 16);
        byte[] ciphertext = Arrays.copyOfRange(ivCiphertext, 16, ivCiphertext.length);
        byte[] dhSharedSecret = new byte[32];
        Curve25519.curve(dhSharedSecret, myPrivateKey, theirPublicKey);
        byte[] key = sha256().digest(dhSharedSecret);
        PaddedBufferedBlockCipher aes = new PaddedBufferedBlockCipher(new CBCBlockCipher(
                new AESEngine()));
        CipherParameters ivAndKey = new ParametersWithIV(new KeyParameter(key), iv);
        aes.init(false, ivAndKey);
        byte[] output = new byte[aes.getOutputSize(ciphertext.length)];
        int plaintextLength = aes.processBytes(ciphertext, 0, ciphertext.length, output, 0);
        plaintextLength += aes.doFinal(output, plaintextLength);
        byte[] result = new byte[plaintextLength];
        System.arraycopy(output, 0, result, 0, result.length);
        return result;
    } catch (InvalidCipherTextException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}