Java IO.pdf - Nguyen Dang Binh

public static final int ENCRYPT_MODE
public static final int DECRYPT_MODE
10.5.1.2 Key
Java I/O
The key is an instance of the java.security.Key interface that's used to either encrypt or
decrypt the data. Symmetric ciphers like DES use the same key for both encryption and
decryption. Asymmetric ciphers like RSA use different keys for encryption or decryption.
Keys are generally dependent on the cipher. For instance, an RSA key cannot be used to
encrypt a DES file or vice versa. If the key you provide doesn't match the cipher's algorithm,
an InvalidKeyException is thrown.
To create a key, you first use the bytes of the key to construct a KeySpec for the algorithm
you're using. Key specs are instances of the java.security.spec.KeySpec interface.
Algorithm-specific implementations in the java.security.spec package include
EncodedKeySpec, X509EncodedKeySpec, PKCS8EncodedKeySpec, DSAPrivateKeySpec, and
DSAPublicKeySpec. Algorithm-specific implementations in the javax.crypto.spec
package include DESKeySpec, DESedeKeySpec, DHPrivateKeySpec, DHPublicKeySpec,
PBEKeySpec, RSAPrivateKeyCrtSpec, RSAPrivateKeySpec, and RSAPublicKeySpec. For
example, if password is a string whose bytes are to form a DES key, the following creates a
DESKeySpec object that can be used to encrypt or decrypt:
byte[] desKeyData = password.getBytes();
DESKeySpec desKeySpec = new DESKeySpec(desKeyData);
Once you've constructed a key specification from the raw bytes of the key, you use a key
factory to generate the actual key. A key factory is normally an instance of an algorithmspecific
subclass of java.security.KeyFactory. It's retrieved by passing the name of the
algorithm to the factory method javax.crypto.SecretKeyFactory.getInstance(). For
example:
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey desKey = keyFactory.generateSecret(desKeySpec);
Providers should supply the necessary key factories and spec classes for any algorithms they
implement.
A few algorithms, most notably Blowfish, use raw bytes as a key without any further
manipulations. In these cases there may not be a key factory for the algorithm. Instead, you
simply use the key spec as the secret key. For example:
byte[] blowfishKeyData = password.getBytes();
SecretKeySpec blowfishKeySpec = new SecretKeySpec(blowfishKeyData,
"Blowfish");
Cipher blowfish = Cipher.getInstance("Blowfish/ECB/PKCS5Padding");
blowfish.init(Cipher.ENCRYPT_MODE, blowfishKeySpec);
Most of the examples in this book use very basic and not particularly secure passwords as
keys. Stronger encryption requires more random keys. The javax.crypto.KeyGenerator
class provides methods that generate random keys for any installed algorithm. For example:
KeyGenerator blowfishKeyGenerator = KeyGenerator.getInstance("Blowfish");
222