- Published on

# Java Security - Part 5: Asymmetric encryption algorithms in Java (e.g., RSA, DSA)

- Authors
- Name
- Gary Huynh
- @huynhthienthach

Argh, buckle up, mateys! We're now leaving the calm waters of `Symmetric Encryption`

Bay, and venturing into the stormy seas of `Asymmetric Encryption`

. In this ocean, we'll be tackling the titans of the depth - `RSA`

and `DSA`

!

You remember our `Symmetric Encryption`

handshake, aye? Well, `Asymmetric Encryption`

be a different breed. This be more like passing secret notes in class - you write your note (or `encrypt your data`

) with a public key that everyone can see. But, only the mate with the corresponding private key can read your note (or `decrypt your data`

). Clever, ain't it?

Our sailing mates in this adventure are:

`RSA (Rivest-Shamir-Adleman)`

: The old salt of the sea,`RSA`

uses two mathematically linked keys. Each key can`decrypt`

data encrypted by the other. It's widely used, but watch out, it can be`slow`

and require a lot of computational power!`DSA (Digital Signature Algorithm)`

: This youthful sailor focuses on digital signatures. While you can't use`DSA`

for`encrypting`

and`decrypting`

, it's great for`signing`

data and`verifying`

signatures. It's a bit`faster`

than`RSA`

, but the math be a bit more complex!

Here be an example of how to use `RSA`

for `encryption`

and `decryption`

in Java:

```
import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
public class AsymmetricEncryptionSample {
public static void main(String[] args) throws Exception {
// Generate a RSA key pair
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048);
KeyPair keyPair = keyGen.generateKeyPair();
// Create a cipher
Cipher cipher = Cipher.getInstance("RSA");
// Initialize the cipher for encryption
cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
// Encrypt a message
byte[] message = "Ahoy, we be using RSA!".getBytes();
byte[] encryptedMessage = cipher.doFinal(message);
// Now let's decrypt using the private key
cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
byte[] decryptedMessage = cipher.doFinal(encryptedMessage);
// And the message is...
System.out.println(new String(decryptedMessage));
}
}
```

As you can see, we've generated a pair of RSA keys and used the public key to encrypt our message. Then we've used the private key to decrypt it again.

Note that while `DSA (Digital Signature Algorithm)`

is mostly used for creating a `digital signature`

for `authenticity`

and `integrity`

, it's not for `encryption`

/`decryption`

. It's like the sailor's mark on the treasure map ensuring it has not been tampered with. But let's see it in action.

Here is a basic example of using `DSA`

for signing and verifying a signature in Java:

```
import java.security.*;
import java.util.Arrays;
public class DSASample {
public static void main(String[] args) throws Exception {
// Message to be signed
byte[] message = "Ahoy, we be using DSA!".getBytes();
// Generate a DSA key pair
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA");
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
keyGen.initialize(1024, random);
KeyPair pair = keyGen.generateKeyPair();
PrivateKey priv = pair.getPrivate();
PublicKey pub = pair.getPublic();
// Sign the message
Signature dsa = Signature.getInstance("SHA1withDSA");
dsa.initSign(priv);
dsa.update(message);
byte[] signature = dsa.sign();
// Now let's verify the signature
dsa.initVerify(pub);
dsa.update(message);
boolean verifies = dsa.verify(signature);
System.out.println("Signature verifies: " + verifies);
}
}
```

This script signs a message using `DSA`

and verifies the signature. If everything be shipshape, the output will read `Signature verifies: true`

.

You see, matey, `DSA`

is like that trusty parrot that always verifies your tale of treasure. It's less about hiding the treasure and more about ensuring the map hasn't been tampered with!

Now you've seen both `symmetric`

and `asymmetric`

encryption in action. Remember, matey, use the right tool for the job. `Symmetric`

be `faster`

and `simpler`

, but `asymmetric`

be more `flexible`

and `secure`

.

Avast ye, we'll be setting sail for our next port of call soon - the mysterious land of `Hashing and Message Digest Algorithms`

. Batten down the hatches and prepare for more crypto fun! Yarr!