Java Tutorial: Cryptography

Chapters

• Introduction
• Hashing
• Symmetric Encryption
• Asymmetric Encryption
• Digital Signature
• Message Authentication Code(MAC)
• Key Wrapping
• Storing Keys
• Salted Password

Introduction

In computer programming, Cryptography is a way of hiding data(passwords, messages, etc.) from third parties(adversaries) by securing the communication process between two entities. Cryptographic functions can be found in two java librarties: Java Cryptography Architecture(JCA) and Java Cryptography Extension(JCE).

JCA is tightly integrated with Java core API and provides basic cryptographic functions whereas JCE provides advanced cryptographic functions. Classes belonging to JCA and JCE are called engines. JCA engines are located at java.security package and JCE engines are located at javax.crypto packages. In the past, JCE is separated from JCA due to US export policies. Over time, This export control has been relaxed and in the present JCE becomes part of Java SE.

JCA and JCE provide functionalities. The actual implementations of those functions are provided by providers. Java has default providers we can use right away. Invoke getProviders() method from Security class in order to see all available providers in your java platform. The order of the providers in the array is their preference order.

The method returns Provider objects that hold information about cryptography providers. If you want to add new provider to your platform, invoke addProvider method from Security class.

For example:

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.security.Security;

public class ProviderExample{

  public static void main(String[] args){
    Security.addProvider(new BouncyCastleProvider());
  }
}

BouncyCastle is one of the popular cryptography providers that can be used in java. It was developed by an Australian charitable organization thus, US law restrictions do not apply to this provider. In the course of this tutorial, we're going to use the default providers provided by java.

Another way of using a third-party provider is to register it in the java.security file. In JDK8 and lower, the file is located in the directory where you installed java at jre\lib\security\java.security. Place the provider JAR in lib\ext

In JDK9 and above, the file is located in the directory where you installed java at conf\security\java.security. Place the provider JAR in the classpath.

Once you open java.security file, look at this section:

...
#
# List of providers and their preference orders (see above):
#
security.provider.1=SUN
security.provider.2=SunRsaSign
security.provider.3=SunEC
security.provider.4=SunJSSE
...

Then, add your third-party provider in the list:

...
#
# List of providers and their preference orders (see above):
#
security.provider.1=SUN
security.provider.2=SunRsaSign
security.provider.3=SunEC
security.provider.4=SunJSSE
security.provider.5=third-party-provider-name
...

In this tutorial, I'll be discussing Hashing, Symmetric Encryption, Asymmetric Encryption and Digital Signature. Java can also create digital certificate but I won't cover cerfiticates in this tutorial.

Hashing

Hashing or cryptographic hash function is a process of mapping data("message") with arbitrary size to an array of bits with fixed size (also called "hash value", "hash", "message digest").

Hashing is a one-way function. It means that the output is unfeasible to invert or reverse. Also, hashing must be deterministic. It means that messages that are the same have equivalent hash. On the other hand, a slight change to a message creates a different hash for the message.

This example demonstrates hashing in java.

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.*;

public class SampleClass{

  public static void main(String[] args) throws
                     NoSuchAlgorithmException,
                     UnsupportedEncodingException{
    MessageDigest digestInstance = 
    MessageDigest.getInstance("SHA-256");
    String message1 = "Secret Message!";
    String message2 = 
    "The big brown fox jumps over the lazy doge";
    
    byte[] input = message1.getBytes("UTF-8");
    byte[] hash = digestInstance.digest(input);
    
    System.out.println("Message1: " + message1);
    System.out.println("Hash Value: " + 
    new BigInteger(1, hash).toString(16));
    System.out.println("Hash Length");
    System.out.println(hash.length + " bytes");
    System.out.println((hash.length*8) + " bits");
    
    input = message2.getBytes("UTF-8");
    hash = digestInstance.digest(input);
    
    System.out.println();
    System.out.println("Message2: " + message2);
    System.out.println("Hash Value: " + 
    new BigInteger(1, hash).toString(16));
    System.out.println("Hash Length");
    System.out.println(hash.length + " bytes");
    System.out.println((hash.length*8) + " bits");
  }
}

Result
Message1: Secret Message!
Hash Value: 1bf7aa187ccdf...
Hash Length
32 bytes
256 bits

Message2: The big brown fox jumps over the lazy doge
Hash Value: ec74b616322364f...
Hash Length
32 bytes
256 bits

MessageDigest provides cryptographic hash function with cryptographic hash algorithm such as SHA-256. Take a look at this article to know the supported cryptographic hash algorithms of MessageDigest.

SHA(Secure Hash Algorithm)-256 is a cryptographic hash algorithm that produces 256-bit hash value. This algorithm produces more bits than the old SHA algorithms such as SHA-0 and SHA-1 which produce 160-bit hash value. Thus SHA-256 is more secure than its old counterparts. If you want more secure algorithms, use SHA3 algorithms.

However, SHA-2 algorithms such as SHA-256, SHA-384, SHA-512 and SHA-224 are better than SHA3 algorithms in terms of performance. MD2 and MD5 are old and less secure than SHA-2 and SHA3 algorithms. Thus, it's not recommended to be used to secure data.

Although, MD5 is still used for checking the integrity of a file. Take note that files consist of bytes. Thus, we can get those bytes and put them in MessageDigest instance. MessageDigest.getInstance method returns a MessageDigest object with the specified hash algorithm. getBytes(String charsetName) method returns the byte structure of a java object or file in array form. The bytes are formatted based on charsetName.

digest method completes the hash computation by performing final operations such as padding. The digest is reset after this call is made. Padding is an additional bit added to the hash value if the input bits are less than the bits that a hash algorithm generates. That's why, In the example above, even Message1 is less than 256 bits, the hash value is still 256 bits.

We can use hash values to ensure that the expected message that the received message of a receiver is equivalent to the sent message of the sender. Take a look at this example

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.*;
import java.util.Arrays;

public class SampleClass{

  public static void main(String[] args) throws
                     NoSuchAlgorithmException,
                     UnsupportedEncodingException{
    /*sender*/
    MessageDigest senderDigest = 
    MessageDigest.getInstance("SHA-256");
    String message = "My Message!";
    
    byte[] senderInput = message.getBytes("UTF-8");
    byte[] senderHash = 
    senderDigest.digest(senderInput);
    System.out.println("Sender Hash Value: " +
    new BigInteger(1, senderHash).toString(16));
    
    /*receiver*/
    MessageDigest receiverDigest = 
    MessageDigest.getInstance("SHA-256");
    String expectedMsg = "My Message!";
    
    byte[] receiverInput = 
    expectedMsg.getBytes("UTF-8");
    byte[] receiverHash = 
    receiverDigest.digest(receiverInput);
    
    System.out.println("Receiver Hash Value: " +
    new BigInteger(1, receiverHash).toString(16));
    System.out.println("Sender and Receiver" +
    " hash values are equal?");
    System.out.println(
    Arrays.equals(senderHash, receiverHash));
  }
}

Result
Sender Hash Value: d2f02a685b80a087de...
Receiver Hash Value: d2f02a685b80a087de...
Sender and Receiver hash values are equal?
true

The example above is analogous to password hashing. When we create an application, we take the hash value of the password instead of the password itself and store the hash value in the database. This implementation hides passwords from employees and prying eyes.

Hashing has vulnerabilities such as brute-force search and rainbow-table. Although, those vulnerabilities may take a very long time breaking hash algorithms. We're talking about years or decades.

To defend against these vulnerabilities, we need to add a salt. To put it simply, a salt is just a random data added to the input. The salt is stored along with the password hash. During verification, the stored salt is included in the hash process along with the input. Then, the generated hash will be compared with the stored hash.

If you want the hash of multiple data, we use the update method. Take a look at this example.

import java.io.UnsupportedEncodingException;
import java.security.*;
import java.math.BigInteger;

public class SampleClass{

  public static void main(String[] args) throws
                     NoSuchAlgorithmException,
                     UnsupportedEncodingException{
    MessageDigest digest = 
    MessageDigest.getInstance("SHA-512");
    String message1 = "Message1";
    String message2 = "Message2";
    
    digest.update(message1.getBytes("UTF-8"));
    digest.update(message2.getBytes("UTF-8"));
    byte[] hash = digest.digest();
    
    System.out.println("Hash value: " + 
    new BigInteger(1, hash).toString(16));
    System.out.println("Hash Length");
    System.out.println(hash.length + " bytes");
    System.out.println((hash.length*8) + " bits");
  }
}

Result
Hash value: dae036f171ffd578ff...
Hash length
64 bytes
512 bits

Symmetric Encryption

Symmetric encryption uses a single key for encrypting and decrypting data. An unencrypted data is called "cleartext" or "plaintext". The encrypted data is called "ciphertext". This example demonstrates symmetric encryption in java.

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.InvalidKeyException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.BadPaddingException;

public class SampleClass{

  public static void main(String[] args) throws
                     NoSuchAlgorithmException,
                     InvalidKeyException,
                     IllegalBlockSizeException,
                     NoSuchPaddingException,
                     BadPaddingException,
                     UnsupportedEncodingException{
    KeyGenerator keygen = 
    KeyGenerator.getInstance("AES");
    
    keygen.init(192);
    SecretKey key = keygen.generateKey();
    System.out.println("Generated Key");
    System.out.println(
    new BigInteger(1, key.getEncoded()).toString(16));
    
    byte[] input = 
    "The big brown fox jumps over a lazy dog."
    .getBytes("UTF-8");
    System.out.println("Plain text");
    System.out.println(new String(input));
    
    Cipher cipher = 
    Cipher.getInstance("AES/ECB/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE, key);
    byte[] encryptedData = cipher.doFinal(input);
    System.out.println("Ciphertext");
    System.out.println(
    new BigInteger(1, encryptedData).toString(16));
    
    cipher.init(Cipher.DECRYPT_MODE, key);
    byte[] decryptedData = 
    cipher.doFinal(encryptedData);
    System.out.println("Decrypted Data");
    System.out.println(new String(decryptedData));
  }
}

Result(may vary)
Generated Key
57197a794884a...
Plain Text
The big brown fox jumps over a lazy dog.
Ciphertext
2968b36c3699c5a12843...
Decrypted Data
The big brown fox jumps over a lazy dog.

KeyGenerator provides the functionality of a secret (symmetric) key generator. KeyGenerator objects are reusable, i.e., after a key has been generated, the same KeyGenerator object can be re-used to generate further keys. KeyGenerator.getInstance(String algorithm) method returns a KeyGenerator object with the specified algorithm for generating a key.

Available algrorithms for KeyGenerator can be found in this article. Take note that DES(Data Encryption Standard) is discouraged to be used because it's old and not secure anymore.

init(int keysize) method initializes this key generator for a certain keysize using the provider's SecureRandom. AES(Advanced Encryption Standard) supports 128/192/256 bits keysize. AES uses Substitution–permutation network.

To put it simply, AES scrambles bits in multiple rounds. Key size of AES determines the number of round that is going to be used. 128-bit key size implements 10 rounds. 192-bit implements 12 rounds. 256-bit implements 14 rounds. A key with higher key size is more secure. However, key with higher key size takes too long to encrypt/decrypt data. Thus, degrading our application's performance. For standard applications, at the time I write this tutorial, 128-bit key size should suffice.

generateKey method returns SecretKey compatible with the specified algorithm in KeyGenerator object. A key is a string of characters used within an encryption algorithm for altering data so that it appears random.

Cipher provides the functionality of a cryptographic cipher for encryption and decryption. We use Cipher class to encrypt and decrypt data. getInstance(String transformation) returns a Cipher object that implements the specified transformation.

A transformation is a string that describes the operation (or set of operations) to be performed on the given input, to produce some output. A transformation always includes the name of a cryptographic algorithm (e.g., AES), and may be followed by a feedback mode and padding scheme.

A transformation string can be one of these:

• "algorithm/mode/padding"
• "algorithm"

In the latter case, provider-specific default values for the mode and padding scheme are used. Before we discuss the mode in a transformation, we need to know two types of Ciphers: Stream Cipher and Block Cipher.

Stream Cipher encrypts the digits (typically bytes), or letters (in substitution ciphers) of a message one at a time. An example is ChaCha20. Substitution ciphers are well-known ciphers, but can be easily decrypted using a frequency table.

Block Cipher takes a number of bits and encrypt them as a single unit, padding the plaintext so that it is a multiple of the block size. The Advanced Encryption Standard (AES) algorithm, approved by NIST in December 2001, uses 128-bit blocks. To put it simply, Block cipher divides the number of bits of plaintext into blocks based on block size. Each block size of blocks is equal.

Now, mode or block cipher mode determines how blocks are encrypted. Some modes(such as CFB and OFB) can encypt and decrypt blocks that are smaller than the actual cipher's block size. There are different types of modes and I'm not gonna explain all of them in this tutorial. You can read this article if you're interested to learn more about them.

ECB(Electronic Code Book) is the simplest cipher block mode because unlike other modes, this mode directly encrypt and decrypt blocks without additional procedures. However, this mode is less secure than others. This mode is bad at hiding data patterns and susceptible to replay attacks since this mode encrypts and decrypts blocks the same way.

padding is any of a number of distinct practices which all include adding data to the beginning, middle, or end of a message prior to encryption. In classical cryptography, padding may include adding nonsense phrases to a message to obscure the fact that many messages end in predictable ways.

PKCS5Padding is commonly used padding type that is provided by default providers. In PKCS5Padding, Padding is in whole bytes. The value of each added byte is the number of bytes that are added, i.e. N bytes, each of value N are added. The number of bytes added will depend on the block boundary to which the message needs to be extended.

The padding will be one of:

01
02 02
03 03 03
04 04 04 04
05 05 05 05 05
06 06 06 06 06 06
etc.

Example: In the following example the block size is 8 bytes and padding is required for 4 bytes.

... | DD DD DD DD DD DD DD DD | DD DD DD DD 04 04 04 04 |

In java, we can use "NoPadding" in the string transformation if we're going to provide our own padding. Otherwise, we need to use one of the padding types available to our platform.

More information about padding types can be found in this article. More information about PKCS(Public Key Cryptography Standards) can be found in this article. Take note that ISO10126Padding is not encouraged to be used anymore because it's widthrawn in 2007.

init(int opmode, Key key) initializes a Cipher object with specified operation and key. The cipher is initialized for one of the following four operations: encryption, decryption, key wrapping or key unwrapping, depending on the value of opmode. This method form uses the provider's SecureRandom if the Cipher object needs random bytes.

Let's focus on encrypting and decrypting data. To initialize a Cipher object in "encrypt" mode, put Cipher.ENCRYPT_MODE in the argument list with the selected key. To initialize a Cipher object in "decrypt" mode, put Cipher.DECRYPT_MODE in the argument list with selected key.

doFinal(byte[] input) executes the operation of the Cipher object that invokes this method. If you want to encrypt multi-part data, use update(byte[] input) method per data and then invoke doFinal() method to finalize the input and execute the selected operation.

Next, I'm gonna demonstrate another cipher block mode which is the CBC(Cipher Block Chaining). This mode is more secure than ECB and is commonly used. In CBC mode, each block of plaintext is XORed with the previous ciphertext block before being encrypted. This way, each ciphertext block depends on all plaintext blocks processed up to that point. To make each message unique, an initialization vector(IV) must be used in the first block.

This example demonstrates CBC mode.

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.BadPaddingException;
import javax.crypto.spec.IvParameterSpec;

public class SampleClass{

  public static void main(String[] args) throws
                     NoSuchAlgorithmException,
                     InvalidAlgorithmParameterException,
                     InvalidKeyException,
                     IllegalBlockSizeException,
                     NoSuchPaddingException,
                     BadPaddingException,
                     UnsupportedEncodingException{
                     
    KeyGenerator keygen = 
    KeyGenerator.getInstance("AES");
    
    keygen.init(192);
    SecretKey key = keygen.generateKey();
    System.out.println("Generated Key");
    System.out.println(
    new BigInteger(1, key.getEncoded()).toString(16));
    
    SecureRandom sr = 
    SecureRandom.getInstance("SHA1PRNG");
    byte[] randBytes = new byte[16];
    sr.nextBytes(randBytes);
    IvParameterSpec iv = 
    new IvParameterSpec(randBytes);
    System.out.println("IV");
    System.out.println(
    new BigInteger(1, iv.getIV()).toString(16));
    
    byte[] input = 
    "The big brown fox jumps over a lazy dog."
    .getBytes("UTF-8");
    System.out.println("Plain text");
    System.out.println(new String(input));
    
    Cipher cipher = 
    Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE, key, iv);
    byte[] encryptedData = cipher.doFinal(input);
    System.out.println("Ciphertext");
    System.out.println(
    new BigInteger(1, encryptedData).toString(16));
    
    cipher.init(Cipher.DECRYPT_MODE, key, iv);
    byte[] decryptedData = 
    cipher.doFinal(encryptedData);
    System.out.println("Decrypted Data");
    System.out.println(new String(decryptedData));
  }
}

Result(may vary)
Generated Key
50bfcd0d400bc...
IV
afd7ece30...
Plain Text
The big brown fox jumps over a lazy dog.
Ciphertext
dcae499df38120f91...
Decrypted Data
he big brown fox jumps over a lazy dog.

SecureRandom.getInstance(String algorithm) returns a SecureRandom object that implements the specified Random Number Generator (RNG) algorithm. nextBytes(byte[] bytes) method generates random bytes and put them in the bytes array.

IvParameterSpec specifies an initialization vector (IV). Examples which use IVs are ciphers in feedback mode, e.g., DES in CBC mode and RSA ciphers with OAEP encoding operation. getIV method returns the initialization vector (IV). Take note that The IV size depends on the cryptographic primitive used; for block ciphers it is generally the cipher's block-size. In the example above, the IV size is 16 bytes or 128 bits, which is equal to AES block size.

init(int opmode, Key key, AlgorithmParameterSpec params) Initializes this cipher with a key and a set of algorithm parameters. We use this constructor if the algorithm in our Cipher object requires a parameter. Algorithm-specific parameters in java are represented by AlgorithmParameterSpec and its implementing classes and known subinterfaces.

In the example above, the Cipher object uses CBC(Cipher Block Chaining) and CBC requires an IV(initialization vector) parameter. To fulfill that requirement, we need to instantiate a IvParameterSpec object.

From the documentation:

If the cipher requires any algorithm parameters and params is null, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption or key wrapping, and raise an InvalidAlgorithmParameterException if it is being initialized for decryption or key unwrapping. The generated parameters can be retrieved using getParameters or getIV (if the parameter is an IV).

Take note that we can encrypt files using symmetric encryption. Take a look at this example.

...
byte[] input = java.nio.file.Files.
readAllBytes(
new java.io.File("fileTest.zip").
toPath());

Cipher cipher =
Cipher.getInstance("AES/CBC/PKCS5Padding");

cipher.init(Cipher.ENCRYPT_MODE, key, iv);
byte[] encryptedData = cipher.doFinal(input);
System.out.println("File Encrypted!");

cipher.init(Cipher.DECRYPT_MODE, key, iv);
byte[] decryptedData =
cipher.doFinal(encryptedData);

try(FileWriter fw =
    new FileWriter("decryptedFile.zip")){
    for(byte b : decryptedData)
      fw.write(b);
}
System.out.println("File Decrypted!");
...

Asymmetric Encryption

Asymmetric Encryption or Public-key cryptography uses a pair of keys to encrypt/decrypt data. In Asymmetric Encryption, there are two types of keys: Public Key and Private Key. Public key is used for encrypting data and private key is used for decrypting data. For example, In a sender-receiver scenario, Assuming we're the receiver, we share our public key to the sender and the sender uses our public key to encrypt the message(data) that the sender wanna send to us.

Then, once we receive the encrypted data, we decrypt it using our private key. Remember that we only share your public keys and we keep our private keys "private". To put it simply, don't share your private key with anyone except you. As you can see, Asymmetric encryption is more secure than symmetric encryption.

Even the attackers intercepted your public key, they couldn't use the public key to decrypt encrypted messages. However, asymmetric encryption is still vulnerable to some kind of attacks. The good news is that those attacks are hard to implement and don't break asymmetric encryption easily. Read this article to know more about the weaknesses of asymmetric encryption.

Another disadvantage of this encryption is that this encryption can encrypt data with limited length. Typically, asymmetric encryption is slower than symmetric encryption. There are different types of algorithms that implement asymmetric encryption. In this tutorial, I'm gonna use the RSA(Rivest–Shamir–Adleman). This article lists algorithms that supports asymmetric encryption.

This example demonstrates asymmetric cryptography using RSA algorithm.

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.KeyPairGenerator;
import java.security.KeyPair;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.PrivateKey;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;


public class SampleClass{

  public static void main(String[] args) throws
                     BadPaddingException,
                     IllegalBlockSizeException,
                     InvalidKeyException,
                     NoSuchAlgorithmException,
                     NoSuchPaddingException,
                     UnsupportedEncodingException
                     {
    KeyPairGenerator keygen = 
    KeyPairGenerator.getInstance("RSA");
    keygen.initialize(2048);
    
    KeyPair pair = keygen.generateKeyPair();
    PrivateKey privKey = pair.getPrivate();
    PublicKey pubKey = pair.getPublic();
    
    byte[] privKeyBytes = privKey.getEncoded();
    System.out.println("Private Key");
    System.out.println(
    new BigInteger(1, privKeyBytes).toString(16));
    System.out.println("Key Size");
    System.out.println(privKeyBytes.length + " bytes");
    System.out.println(
    (privKeyBytes.length*8) + " bits");
    System.out.println();
    
    byte[] pubKeyBytes = pubKey.getEncoded();
    System.out.println("Public Key");
    System.out.println(
    new BigInteger(1, pubKeyBytes).toString(16));
    System.out.println("Key Size");
    System.out.println(pubKeyBytes.length + " bytes");
    System.out.println(
    (pubKeyBytes.length*8) + " bits");
    System.out.println();
    
    String input = "I love programming!";
    System.out.println("Input");
    System.out.println(input);
    System.out.println();
    
    Cipher cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    
    byte[] inputBytes = input.getBytes("UTF-8");
    byte[] encryptedData = cipher.doFinal(inputBytes);
    System.out.println("Encrypted Data");
    System.out.println(
    new BigInteger(1, encryptedData).toString(16));
    System.out.println();
    
    cipher.init(Cipher.DECRYPT_MODE, privKey);
    byte[] decryptedData = cipher.doFinal(encryptedData);
    System.out.println("Decrypted Data");
    System.out.println(new String(decryptedData, "UTF-8"));
  }
}

Result(may vary)
Private Key
308204bc020100300d06902a...
Key Size
1216 bytes
9728 bits

Public Key
30820122300d0692a...
Key Size
294 bytes
2352 bits

Input
I love programming!

Encrypted Data
3d6c5729ec927abae5bd...

Decrypted Data
I love programming!

KeyPairGenerator is used to generate pairs of public and private keys. A Key pair generator for a particular algorithm creates a public/private key pair that can be used with this algorithm. It also associates algorithm-specific parameters with each of the generated keys.

RSA is a block cipher and it requires a padding parameter. Fortunately, java automatically provided a padding parameter for RSA when we invoke KeyPairGenerator.getInstance(String algorithm) with "RSA" as our asymmetric encryption algorithm. This article lists asymmetric algorithms that are available to java by default.

initialize(int keysize) Initializes the key pair generator for a certain keysize using a default algorithm-specific parameter set and the SecureRandom implementation of the highest-priority installed provider as the source of randomness. (If none of the installed providers supply an implementation of SecureRandom, a system-provided source of randomness is used.)

RSA supports 512, 1024, 2048 and 4096 bits key size. Key size in this context is not the actual key size of both public and private keys. Key size in this context is used to determine the length(size) of public and private keys. The higher the key size, the longer the length of public and private keys. Keys with higher length are more secure.

However, keys with higher size take time to encrypt/decrypt data. For standard applications, at the time I write this tutorial, 2048 key size is widely used because it has a good balance between security and performance. KeyPair is a simple holder for a key pair (a public key and a private key). It does not enforce any security, and should be treated like a PrivateKey when initialized because the instance of this class holds a private key.

PrivateKey is used to group (and provide type safety for) all private key interfaces. PublicKey is an interface that contains no methods or constants. It merely serves to group (and provide type safety for) all public key interfaces.

generateKeyPair() generates a pair of key(public and private) based on the selected algorithm and key size of KeyPairGenerator instance. getPrivate() retuns a PrivateKey instance with the generated private key stored in KeyPairGenerator instance. getPublic retuns a PublicKey instance with the generated public key stored in KeyPairGenerator instance.

I didn't explain some classes and methods that I've used in the example above because I already explained some of them in previous topics. I assumed you've read previous topics before reading this topic. If you're already familiar with java and its cryptography API, you don't need to read the previous topics.

In the example above, Notice that private key is longer than public key. In RSA, private key stores more information than public key and some of those information are confidential.

Take note that RSA data encryption has length limit. For example, using my java platform's default RSA provider, If I increase the byte length in input variable in the example above:

...
//repeat() means, repeat this string by the
//specified amount in the argument. In this example,
//the String is repeated 50 times.
String input = "I love programming!".repeat(50);
...

I'll get this exception:
...
Exception in thread "main" javax.crypto.IllegalBlockSizeException: Data must not be longer than 245 bytes.
...

The limitation length is based on the key size we put in initialize(int keysize). The limitation length increases/decreasees as key size gets larger/smaller. If we want to encrypt large data, symmetric encrypt is more preferrable to be used. Some of the usage of asymmetric encryption are:

• Encrypting/Decrypting symmetric keys
• Encrypting/Decrypting hashes

You may ask yourself on how to verify if a public key that you receive comes from the real sender you're expecting. This is where digital certificate comes in. Digital certificate, to put it simply, is used verify the identity of a public key. Digital certificate is not part of the scope of this tutorial.

Digital Signature

Digital signatures are used for verifying the integrity of data. Digital signature ensures that the data we receive from a sender is not tampered. Digital signature is simply just a hash of the data that is going to be sent and the hash is encrypted. This example demonstrates asymmetric digital signature.

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.KeyPairGenerator;
import java.security.KeyPair;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.PrivateKey;
import java.security.Signature;
import java.security.SignatureException;
import javax.crypto.Cipher;

public class SampleClass{

  public static void main(String[] args) throws
                     InvalidKeyException,
                     NoSuchAlgorithmException,
                     SignatureException,
                     UnsupportedEncodingException{
  
    /*Sender*/
    
    KeyPairGenerator keygen = 
    KeyPairGenerator.getInstance("RSA");
    keygen.initialize(2048);
    
    KeyPair pair = keygen.generateKeyPair();
    PrivateKey privKey = pair.getPrivate();
    PublicKey pubKey = pair.getPublic();
    
    String input = "I love programming!";
    
    Signature signatureAlg = 
    Signature.getInstance("SHA256WithRSA");
    signatureAlg.initSign(privKey);
    signatureAlg.update(input.getBytes("UTF-8"));
    byte[] signBytes = signatureAlg.sign();
    
    /*Receiver*/
    
    Signature verificationAlg =
    Signature.getInstance("SHA256WithRSA");
    verificationAlg.initVerify(pubKey);
    verificationAlg.update(input.getBytes("UTF-8"));
    System.out.println("Is data not tampered? " +
    verificationAlg.verify(signBytes));
  }
}

Result
Is data not tampered? true

In the example above, the sender gets the hash of the data and encrypts the hash using his/her private key. Then, the sender sends his/her public key, signature(encrypted hash) and the data to the receiver. Now, the receiver uses the received public key to decrypt the received hash. Then, we get the hash of the received data and compare it to the decrypted hash.

The process that I've explained can be simplified in java. We use Signature to hash and encrypt/decrypt it. Signature.getInstance(String algorithm) returns a Signature object that implements the specified signature algorithm.

"SHA256WithRSA" means SHA-256 is the hash algorithm and RSA is the encryption/decryption algorithm. More available algorithms that are supported by java can be found in this article.

initSign(PrivateKey privateKey) initializes a Signature instance for signing with PrivateKey argument. update(byte[] data) updates the data to be signed or verified, using the specified array of bytes. sign() creates a digital signature with the specified algorithm and data.

In other words, sign() gets the hash of the data, encrypts the hash and return the encrypted hash. initVerify(PublicKey publicKey) initializes a Signature instance for verification with PublicKey argument. verify(byte[] signature) verifies the specified signature.

In other words, verify(byte[] signature) decrypts the encrypted hash (signature), gets the hash of the received data and compare the decrypted hash with the hash of the received data. If both hashes match, the received data is not tampered. In the example above, I only encrypt the hash of the data that is sent to the receiver and not the data itself.

If you only want to check the integrity of your data and now worried about it to be intercepted, You don't need to encrypt the data itself. Otherwise, encrypt the data. I skipped encrypting the data itself in order to focus on digital signature.

Message Authentication Code(MAC)

Message Authentication Code is a symmetric digital signature. MAC uses a single key to create and verify a digital signature. This is also called as keyed hashing because it secures the hash of data by generating the hash with a key. One of the advantages of MAC over asymmetric digital signature is that MAC is much faster than most algorithms used for asymmetric digital signature.

However, asymmetric digital signature is commonly used than MAC because it offers more security. MAC can be cipher-based(CMAC & GMAC) or hash-based(HMAC). In this tutorial, we're going to focus on HMAC. Cipher-based MACs are tricky to implement. It's better to start with HMAC first.

This example demonstrate HMAC.

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;

public class SampleClass{

  public static void main(String[] args) throws
                       NoSuchAlgorithmException,
                       InvalidKeyException,
                       UnsupportedEncodingException{
    
    /*Sender*/
    
    KeyGenerator keygen = KeyGenerator.getInstance("HmacSHA256");
    keygen.init(256);
    SecretKey key = keygen.generateKey();
    
    Mac senderMac = Mac.getInstance("HmacSHA256");
    senderMac.init(key);
    
    String input = "A secret between you and me.";
    senderMac.update(input.getBytes("UTF-8"));
    byte[] senderComputedMac = senderMac.doFinal();
    
    /*Receiver*/
    
    Mac receiverMac = Mac.getInstance("HmacSHA256");
    receiverMac.init(key);
    receiverMac.update(input.getBytes("UTF-8"));
    byte[] receiverComputedMac = receiverMac.doFinal();
    
    String senderMacStr = 
    new BigInteger(1, senderComputedMac).toString(16);
    String receiverMacStr = 
    new BigInteger(1, receiverComputedMac).toString(16);
    
    System.out.println("Sender MAC");
    System.out.println(senderMacStr);
    System.out.println();
    
    System.out.println("Receiver MAC");
    System.out.println(receiverMacStr);
    System.out.println();
    
    System.out.println("Is data not tampered?");
    System.out.println(
    senderMacStr.equals(receiverMacStr));
  }
}

Result

Sender MAC
5df66b8ef0a885bd2...

Receiver MAC
5df66b8ef0a885bd2...

Is data not tampered?
true

In the example above, the sender generates a key, generates MAC by generating a hash from the data with the key and send the key and MAC over secure channel. The data can be sent over unsecure channel if the sender is not worried about the data getting intercepted. Otherwise, encrypt the data first before sending it to the unsecure channel. Next, once the key, MAC and data has been sent to the receiver, the receiver generates a new MAC by generating a hash from the received data with the received key.

If the received MAC and the generated MAC of the receiver are the same, it means that the data came from the sender who owns the received key and it's not tampered. Otherwise, the data may be tampered, the sender gave a wrong key or the received key is not the key that generated the received MAC.

Key size is 256 bits because at the time I write this, 256 bits keysize should suffice for standard applications. If you want more security at the expense of performance, you can increase the key size. The algorithm used is "HmacSHA256" or generated HMAC using SHA-256 algorithm. More supported Mac algorithm by java can be found in this article.

The algorithm used in the KeyGenerator and Mac instances must be the same. Take note that HmacMD5 and HmacSHA1 are discouraged to be used because they're not secure anymore. Use other algorithms like HmacSHA2 such as HmacSHA256 and HmacSHA512; HmacSHA3 algorithms.

If you want more security at the expense of performance, use hash algorithm with higher block size like HmacSHA512 or use the new SHA family which is the SHA3 family. SHA2 and SHA3 have different algorithms. SHA2 is vulnerable to length extension attack whereas SHA3 is not.

Mac class provides the functionality of a "Message Authentication Code" (MAC) algorithm.

Key Wrapping

Key wrapping is a process of encrypting a key using another key. This example demonstrates wrapping/unwrapping symmetric key using asymmetric keys.

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.*;
import javax.crypto.*;

public class SampleClass{

  public static void main(String[] args) throws
                     BadPaddingException,
                     IllegalBlockSizeException,
                     InvalidKeyException,
                     NoSuchAlgorithmException,
                     NoSuchPaddingException,
                     UnsupportedEncodingException{
    KeyPairGenerator keyPairGen = 
    KeyPairGenerator.getInstance("RSA");
    keyPairGen.initialize(2048);
    
    KeyPair pair = keyPairGen.generateKeyPair();
    PrivateKey privKey = pair.getPrivate();
    PublicKey pubKey = pair.getPublic();
    
    KeyGenerator keygen =
    KeyGenerator.getInstance("AES");
    keygen.init(192);
    
    SecretKey secretKey = keygen.generateKey();
    
    String input = "Send this message!";
    System.out.println("input: " + input);
    
    Cipher cipher = Cipher.getInstance("AES");
    cipher.init(Cipher.ENCRYPT_MODE, secretKey);
    
    byte[] encryptedData = 
    cipher.doFinal(input.getBytes("UTF-8"));
    System.out.println("Encrypted Data");
    System.out.println(
    new BigInteger(1, encryptedData).toString(16));
    
    cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.WRAP_MODE, pubKey);
    byte[] encryptedKey = 
    cipher.wrap(secretKey);
    
    cipher.init(Cipher.UNWRAP_MODE, privKey);
    SecretKey decryptedKey = 
    (SecretKey)cipher.unwrap(encryptedKey, "AES", 
    Cipher.SECRET_KEY);
    
    cipher = Cipher.getInstance("AES");
    cipher.init(Cipher.DECRYPT_MODE, decryptedKey);
    byte[] decryptedData = cipher.doFinal(encryptedData);
    
    System.out.println("Decrypted Data: " + 
    new String(decryptedData, "UTF-8"));
  }
}

Result
input: Send this message!
Encrypted Data
118729c524039308c...
Decrypted Data: Send this message!

In the example above, The sender wraps the data that he is going to send using AES which is a symmetric encryption algorithm. Then, the generated key for the encrypted data is encrypted using RSA algorithm which is an asymmetric encryption algorithm. He uses the public key of the receiver to encrypt the key of the encrypted data.

The sender sends the encrypted key and data to the receiver. Then, the receiver unwraps(decrypts) the wrapped(encrypted) key using his private key. Then, he uses the unwrapped key to decrypt the data. We can use the example above if we want to securely transfer a large encrypted data to a receiver. The asymmetric keys encrypt/decrypt the symmetric key of the large data and the symmetric key encrypts the large data.

To wrap a key, invoke init(int opmode, Key key) method of Cipher class. opmode parameter is the operation mode. We put Cipher.WRAP_MODE if we're going to wrap a key. key parameter is the key that we're going to use to wrap a key. Once init is invoked. Invoke wrap(Key key) of Cipher class to wrap the key. key parameter is the key that we're going to wrap.

Next, to unwrap the key, we invoke init again but this time the operation mode is Cipher.UNWRAP_MODE and the key is the private key of the receiver. Once init is invoked, invoke unwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, int wrappedKeyType) method.

This method unwraps a wrapped key. wrappedKey parameter is the bytes of the encrypted key. wrappedKeyAlgorithm is the associated algorithm of the encrypted key. wrappedKeyType is the key type of the encrypted key. There are three types of keys in Cipher class:

Cipher.PRIVATE_KEY
Cipher.PUBLIC_KEY

These keys are keys for asymmetric encryption.

Cipher.SECRET_KEY

This key is a key for symmetric encryption.

Storing Keys

There are two ways of storing keys. The simplest way of storing keys is to write keys to a persistent file. Make sure that you store your keys in a safe place and don't share your key with untrusted people.

Write the key hash of your key to a persistent file if you're planning to use your keys to other programming platforms. If you're planning to use your keys only in java, you can serialize the keys. SecretKey, PublicKey and PrivateKey are serializable.

This example demonstrates storing key hash in a file and recreating the key in java.

import java.io.*;
import java.math.BigInteger;
import java.security.NoSuchAlgorithmException;
import java.util.HexFormat;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class SampleClass{

  public static void main(String[] args) throws
                     IOException,
                     NoSuchAlgorithmException{
    File secretKeyFile = 
    new File("key/my-secret.key");
    
    KeyGenerator keygen =
    KeyGenerator.getInstance("AES");
    keygen.init(192);
    
    SecretKey secretKey = keygen.generateKey();
    
    //write the keys to a persistent file
    if(!secretKeyFile.exists()){
         try(BufferedWriter bw = 
             new BufferedWriter(
             new FileWriter(secretKeyFile))){
             String key =  
             new BigInteger(1, secretKey.getEncoded())
             .toString(16);
             bw.write(key, 0, key.length());
             System.out.println("Key written to file");
             System.out.println(key);
             
             //let gc remove the key as soon as possible
             //After use, don't let the key persist with
             //memory for too long.
             key = null;
         }
     }
     else{
       System.out.println("File/s already exist!");
       return;
     }
    
    //read the keys from the persistent file
    try(FileReader fr = new FileReader(secretKeyFile)){
      StringBuilder sb = new StringBuilder();
      
      int i = 0;
      while((i = fr.read()) != -1)
        sb.append((char)i);
      
      //convert the key hash to array of bytes
      //in order to recreate the secret key using
      //SecretKeySpec class
      SecretKey keyFromFile = 
      new SecretKeySpec(
      HexFormat.of().parseHex(sb.toString()),
      "AES");
      sb = null;
      
      System.out.println("key read from file");
      System.out.println(
      new BigInteger(1, 
      keyFromFile.getEncoded()).toString(16));
    }
    
  }
}

Result
Key written to file
73f6040f39f1...
Key read from file
73f6040f39f1...

HexFormat is a utility class that we can use to parse hex strings. In the example above, we're writing a plain key hash in a persistent file. If you want to obscure key hash, you can use Base64 in java.

HexFormat is introduced in java 17. If you're using java with version lower than 17, HexFormat is not available. This dicussion has a solution for parsing key hashes that works in java with version lower than 17.

If you're planning to use your keys on other platforms and you want to obscure them using Base64, make sure that the platform can decode Base64 characters. SecretKeySpec can be used to construct a SecretKey from a byte array, without having to go through a (provider-based) SecretKeyFactory.

SecretKeySpec is only useful for raw secret keys that can be represented as a byte array and have no key parameters associated with them, e.g., DES or Triple DES keys.

Another way of storing keys is to create a KeyStore. KeyStore can store keys and certificates. In this tutorial, I'm gonna demonstrates on how to store a key for symmetric encryption.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.File;
import java.math.BigInteger;
import java.security.cert.CertificateException;
import java.security.NoSuchAlgorithmException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.KeyStore.PasswordProtection;
import java.security.UnrecoverableKeyException;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

public class SampleClass{

  public static void main(String[] args) throws
                          IOException,
                          NoSuchAlgorithmException,
                          CertificateException,
                          KeyStoreException,
                          UnrecoverableKeyException{
    
    KeyGenerator keygen =
    KeyGenerator.getInstance("AES");
    keygen.init(192);
    
    SecretKey secretKey = keygen.generateKey();
    
    KeyStore keystore = KeyStore.getInstance("JCEKS");
    //This is unsecure. Don't hardcode passwords.
    //It's better to put your KeyStore password
    //in a persistent file. Before that, obscure
    //or encrypt your password first.
    char[] pass = "password".toCharArray();
    
    //initialize Keystore
    keystore.load(null, pass);
    
    File source = new File("keystore/my-keystore.jks");
    if(source.exists()){
       System.out.println("KeyStore already exists!");
       return;
    }
    
    //write KeyStore object to a file
    try(FileOutputStream fos = new 
        FileOutputStream(source)){
        keystore.store(fos, pass);
    }
    
    //Initialize KeyStore from the given
    //input stream
    try(FileInputStream fis = new 
        FileInputStream(source)){
        keystore.load(fis, pass);
    }
    
    //add entry to KeyStore
    KeyStore.SecretKeyEntry keyEntry =
    new KeyStore.SecretKeyEntry(secretKey);
    KeyStore.ProtectionParameter entryPass =
    new KeyStore.PasswordProtection(pass);
    keystore.setEntry("secret-key", keyEntry, entryPass);
    
    SecretKey ksSecretKey = 
    (SecretKey)keystore.getKey("secret-key", pass);
    
    System.out.println("Generated Key");
    System.out.println(
    new BigInteger(1, secretKey.getEncoded()).toString(16));
    System.out.println();
    
    System.out.println("Key in KeyStore");
    System.out.println(
    new BigInteger(1, ksSecretKey.getEncoded()).toString(16));
  }
}

Result
Generated Key
e71094e7294563d771...

Key in KeyStore
e71094e7294563d771...

getInstance(String type) returns KeyStore object with the specified type. JCEKS is similar to JKS(Java KeyStore). Although, JCEKS supports symmetric keys whereas JKS only supports asymmetric keys. In terms of security, JCEKS has stronger key protection.

load(InputStream stream, char[] password) Loads the KeyStore contents from the given input stream to the KeyStore intance. If stream argument is null, this method initializes KeyStore with no contents and associates the given password to it. store(OutputStream stream, char[] password) writes the KeyStore object to a persistent file via output stream and protect the file's integrity with the given password.

KeyStore.SecretKeyEntry creates an entry for a secret key.KeyStore.ProtectionParameter is used to protect the contents of a key store. KeyStore.PasswordProtection is used to wrap password that can be implemented in key store.

setEntry(String alias, KeyStore.Entry entry, KeyStore.ProtectionParameter protParam) saves a KeyStore entry to a KeyStore. alias parameter is the name associated with the entry. We can use alias if we want to select the entry associated with the alias. entry parameter is the entry that we wanna store in the KeyStore. protParam parameter is a protection of KeyStore wrapped into KeyStore.ProtectionParameter.

getKey(String alias, char[] password) retrives a key with the associated alias and the password that we put in the entry of the key. Storing symmetric key in KeyStore is simple. However, Some keys or certificates are kinda tricky to be stored in KeyStore. Another way of create a KeyStore is using the keytool command in java. keytool is not in the scope of this tutorial.

Salted Password

Salted password is a password that is mixed with cryptographic salt. Cryptographic salt or salt for short, is random data that is used as an additional input to a one-way function that hashes data. In other words, we mix salt and a data, password in our case, and then generate a key from the password with mixed salt.

In this tutorial we're gonna be using PBKDF2. bcrypt and scrypt are some of the popular alternatives to PBKDF2 but java doesn't support those algorithm by default. If you wanna use those algorithms, you need a third-party vendor that implements those algorithms.

This example demonstrates PBKDF2.

import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;

public class SampleClass{
  public static void main(String[] args)
                throws UnsupportedEncodingException,
                       NoSuchAlgorithmException,
                       InvalidKeySpecException{
    /*Encrypting*/
    String pass = "password";
    byte[] salt = new byte[16];
    SecureRandom sr =
    SecureRandom.getInstance("SHA1PRNG");
    sr.nextBytes(salt);
    int iterations = 10000;
    int keyLength = 512;
    
    SecretKeyFactory keyFactory =
    SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512");
    
    PBEKeySpec spec =
    new PBEKeySpec(pass.toCharArray(), salt,
                   iterations, keyLength);
    SecretKey key = keyFactory.generateSecret(spec);
    byte[] generatedBytes = key.getEncoded();
    String storedHash = 
    new BigInteger(1, generatedBytes).toString(16);
    System.out.println("Stored Hash");
    System.out.println(storedHash);
    System.out.println();
    
    /*Verification*/
    keyFactory = 
    SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512");
    spec = new PBEKeySpec(pass.toCharArray(), salt,
                          iterations, keyLength);
    key = keyFactory.generateSecret(spec);
    generatedBytes = key.getEncoded();
    String inputHash =
    new BigInteger(1, generatedBytes).toString(16);
    System.out.println("Input Hash");
    System.out.println(inputHash);
    System.out.println();
    
    System.out.println("Stored and input hashes equal?");
    System.out.println(storedHash.equals(inputHash));
  }
}

Result
Stored Hash
b2f36d5f92ac1f...

Input Hash
b2f36d5f92ac1f...

Stored and input hashes equal?
true

In the example above, SecureRandom is instantiated with "SHA1PRNG" algorithm. There are other algorithms that are available and they can be found here. "SHA1PRNG" is commonly used PRNG(Pseudo-Random Number Generator) algorithm due to simplicity of SHA-1 algorithm.

When generating hash or cryptographic key, SHA-1 is discouraged to be used because it's unsecure. Since we just want to generate random numbers that can be mixed with our password, "SHA1PRNG" is alright to be used. Next, we set iterations variable to 10,000 and keyLength variable to 512.

PBEKeySpec class can create a key specification with the specification of password-based encryption(PBE). PBKDF2 is a password-based encryption. Thus, The key that is created by PBEKeySpec is compatible with PBKDF2.

PBEKeySpec(char[] password, byte[] salt, int iterationCount, int keyLength) generates a key spec with the specified password mixed with salt, iteration and key length. password parameter is the password that is gonna be mixed with salt. salt parameter is the random bytes that is gonna be mixed with password. Standard salt size for PBKDF2 is at least 64 bits or 8 bytes.

In the example above, I use 16 bytes or 128 bits recommended by The US National Institute of Standards and Technology. Salt is a way to reduce the ability of attackers to break a password using pre-computed hashes such as rainbow tables.

IterationCount parameter is the number of repetitive use of pseudorandom for password along with the salt. This process makes password cracking much more difficult. This process is also known as key stretching.

Organizations have different standards when it comes to the number of iteration count. For example, Apple reportedly used 2000 for iOS 3, and 10000 for iOS 4. OWASP recommended to use 310000 iterations for PBKDF2-HMAC-SHA256 and 120000 for PBKDF2-HMAC-SHA512.

If you want more security from password cracking, you can increase the itearation count anytime. Just remember that the higher the iteration count, the slower the key generation. If computers get faster in the future, attackers can crack passwords fast. To counter that problem, we can just increase the iteration count.

keyLength is the length of the key. Long keys are harder to break. Thus, adding more security to our passwords. For stanrdard applications, length of 512 bits should suffice.

Once we generate a key spec for PBKDF2. We need to convert the key spec into a cryptographic key. To do that, we need to get an instance of SecretKeyFactory. Key factories are used to convert keys (opaque cryptographic keys of type Key) into key specifications (transparent representations of the underlying key material), and vice versa.

SecretKeyFactory.getInstance(String algorithm) returns a SecretKeyFactory object that converts secret keys of the specified algorithm. Available algorithms for SecretKeyFactory provided by java can be found here.

In the example above, I use "PBKDF2WithHmacSHA512" algorithm. This algorithm uses PBKDF2 with HMAC with SHA512. generateSecret(KeySpec keySpec) generates a SecretKey object from the provided key specification. We use SecretKey as a key type of PBKDF2 because PBKDF2 with HMAC is a symmetric encryption.

Once we successfully generated a SecretKey for our password with salt, we need to get its hash in hexadecimal form. To do that, we need to get its byte structure by invoking getEncoded() method and convert the bytes to hexadecimal using BigInteger.

We can use formatHex(byte[] bytes) in HexFormat class to convert array of bytes to hex. However, HexFormat is introduced in java 17. Java versions older than 17 can't use HexFormat.

Now, We need to store the hash of the key in hexadecimal form, salt, iteration count and length of the key because during verification, we need those values. Now, assume that the user is gonna login to our program.

To verify that the password he/she sends to our program is the same as the password he/she sent to our program, we need to create a key with the stored salt, iteration count and key length. Then, get the hash of the new key and compare the new hash to the stored hash. If they're both the same then the user can access his/her account.