Java IvParameterSpec.getIV方法代碼示例

import javax.crypto.spec.IvParameterSpec; //導入方法依賴的package包/類
protected Token(final byte version, final Instant timestamp, final IvParameterSpec initializationVector,
        final byte[] cipherText, final byte[] hmac) {
    if (version != supportedVersion) {
        throw new IllegalTokenException("Unsupported version: " + version);
    }
    if (timestamp == null) {
        throw new IllegalTokenException("timestamp cannot be null");
    }
    if (initializationVector == null || initializationVector.getIV().length != initializationVectorBytes) {
        throw new IllegalTokenException("Initialization Vector must be 128 bits");
    }
    if (cipherText == null || cipherText.length % cipherTextBlockSize != 0) {
        throw new IllegalTokenException("Ciphertext must be a multiple of 128 bits");
    }
    if (hmac == null || hmac.length != signatureBytes) {
        throw new IllegalTokenException("hmac must be 256 bits");
    }
    this.version = version;
    this.timestamp = timestamp;
    this.initializationVector = initializationVector;
    this.cipherText = cipherText;
    this.hmac = hmac;
}
 

import javax.crypto.spec.IvParameterSpec; //導入方法依賴的package包/類
private void init(int opmode, Key key, IvParameterSpec params) {
	if ( mIsInited ) {
		// Do not allow multiple inits
		assert(true);
		throw new RuntimeException("Don't allow multiple inits");
	} else {
		NativeLib.init();
		mIsInited = true;
	}
	
	mIV = params.getIV();
	mEncrypting = opmode == Cipher.ENCRYPT_MODE;
	mCtxPtr = nInit(mEncrypting, key.getEncoded(), mIV);
	addToCleanupQueue(this, mCtxPtr);
}
 

import javax.crypto.spec.IvParameterSpec; //導入方法依賴的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.spec.IvParameterSpec; //導入方法依賴的package包/類
private void wolfCryptSetIV(AlgorithmParameterSpec spec,
        SecureRandom random) throws InvalidAlgorithmParameterException {

    /* store AlgorithmParameterSpec for class reset */
    this.storedSpec = spec;

    /* RSA doesn't need an IV */
    if (this.cipherType == CipherType.WC_RSA)
        return;

    /* store IV, or generate random IV if not available */
    if (spec == null) {
        this.iv = new byte[this.blockSize];

        if (random != null) {
            random.nextBytes(this.iv);
        } else {
            SecureRandom rand = new SecureRandom();
            rand.nextBytes(this.iv);
        }

    } else {
        if (!(spec instanceof IvParameterSpec)) {
            throw new InvalidAlgorithmParameterException(
                "AlgorithmParameterSpec must be of type IvParameterSpec");
        }

        IvParameterSpec ivSpec = (IvParameterSpec)spec;

        /* IV should be of block size length */
        if (ivSpec.getIV().length != this.blockSize) {
            throw new InvalidAlgorithmParameterException(
                    "Bad IV length (" + ivSpec.getIV().length +
                    "), must be " + blockSize + " bytes long");
        }

        this.iv = ivSpec.getIV();
    }
}
 

import javax.crypto.spec.IvParameterSpec; //導入方法依賴的package包/類
/**
 * Applies the algorithm AES-CBC-128 according to NIST Special Publication 800-38A.
 * The initialization vector IV shall be randomly generated before encryption and shall have a 
 * length of 128 bit and never be reused.
 * The IV shall be transmitted in the 16 most significant bytes of the 
 * ContractSignatureEncryptedPrivateKey field.
 * 
 * @param sessionKey The symmetric session key with which the private key will be encrypted
 * @param contractCertPrivateKey The private key which is to be encrypted
 * @return The encrypted private key of the contract certificate given as a byte array
 */
private static byte[] encryptPrivateKey(SecretKey sessionKey, ECPrivateKey contractCertPrivateKey) {
	try {
		/*
		 * Padding of the plain text (private key) is not required as its length (256 bit) is a 
		 * multiple of the block size (128 bit) of the used encryption algorithm (AES)
		 */
		Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
		IvParameterSpec ivParamSpec = new IvParameterSpec(generateRandomNumber(16));
		cipher.init(Cipher.ENCRYPT_MODE, sessionKey, ivParamSpec);
		
		/*
		 * Not the complete ECPrivateKey container, but the private value s represents the 256 bit 
		 * private key which must be encoded. 
		 * The private key is stored as an ASN.1 integer which may need to have zero padding 
		 * in the most significant bits removed (if 33 bytes)
		 */
		byte[] encryptedKey;
		if (contractCertPrivateKey.getS().toByteArray().length == 33) {
			byte[] temp = new byte[32];
			System.arraycopy(contractCertPrivateKey.getS().toByteArray(), 1, temp, 0, contractCertPrivateKey.getS().toByteArray().length-1);
			encryptedKey = cipher.doFinal(temp);
		} else {
			encryptedKey = cipher.doFinal(contractCertPrivateKey.getS().toByteArray());
		}
		
		/*
		 * The IV must be transmitted in the 16 most significant bytes of the
		 * ContractSignatureEncryptedPrivateKey
		 */
		byte[] encryptedKeyWithIV = new byte[ivParamSpec.getIV().length + encryptedKey.length];
		System.arraycopy(ivParamSpec.getIV(), 0, encryptedKeyWithIV, 0, ivParamSpec.getIV().length);
		System.arraycopy(encryptedKey, 0, encryptedKeyWithIV, ivParamSpec.getIV().length, encryptedKey.length);
		getLogger().debug("Encrypted private key: " + ByteUtils.toHexString(encryptedKeyWithIV));
		
		return encryptedKeyWithIV;
	} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | 
			 InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
		getLogger().error(e.getClass().getSimpleName() + " occurred while trying to encrypt private key." +
						  "\nSession key (" + sessionKey.getEncoded().length + " bytes): " +
						  ByteUtils.toHexString(sessionKey.getEncoded()) +
						  "\nContract certificate private key (" + contractCertPrivateKey.getS().toByteArray().length + " bytes): " +
						  ByteUtils.toHexString(contractCertPrivateKey.getS().toByteArray()), e);
	} 
	
	return null;
}