In this article you will learn to use DES Encryption and Decryption in Java by using `javax.crypto`

framework.

- DES is a Symmetric encryption algorithm widely used for securing sensitive data.
- Developed in the 1970s by IBM and later standardized by NIST.
- Designed to provide confidentiality and privacy for digital communications and data storage.
- DES operates on a 64-bit block size and uses a 56-bit key for encryption and decryption.
- DES use a Feistel network structure, with multiple rounds of substitution, permutation, and key mixing operations to ensure robust encryption.

**Advantages of DES Encryption:**

**Widely Adopted:**DES is a well-established encryption standard, supported by various platforms and libraries.**Efficient Performance:**DES encryption and decryption operations are relatively fast and suitable for real-time applications.**Ease of Implementation:**Implementing DES in Java and other programming languages is straightforward, thanks to available libraries and APIs.

**Disadvantages of DES Encryption:**

**Short Key Length:**The 56-bit key size of DES is considered too short by modern security standards, making it vulnerable to brute-force attacks.**Security Concerns:**DES has known vulnerabilities, including the ability to decrypt data using exhaustive key search methods.**Lack of Key Management:**DES lacks robust key management features, leading to potential security risks if keys are compromised.

```
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.util.Base64;
public class DESEncryptionExample {
public static void main(String[] args) throws Exception {
// Generate a secret key for DES encryption
KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
SecretKey secretKey = keyGenerator.generateKey();
// Create a DES cipher instance
Cipher cipher = Cipher.getInstance("DES");
// Initialize the cipher for encryption using the secret key
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
// Plaintext to be encrypted
String plaintext = "Hello, DES Encryption!";
// Encrypt the plaintext
byte[] encryptedBytes = cipher.doFinal(plaintext.getBytes());
// Encode the encrypted bytes to Base64 for readability
String encryptedText = Base64.getEncoder().encodeToString(encryptedBytes);
System.out.println("Encrypted Text (DES): " + encryptedText);
// Initialize the cipher for decryption using the same secret key
cipher.init(Cipher.DECRYPT_MODE, secretKey);
// Decrypt the encrypted bytes
byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedText));
// Convert the decrypted bytes back to plaintext
String decryptedText = new String(decryptedBytes);
System.out.println("Decrypted Text (DES): " + decryptedText);
}
}
```

In this example:

- We generate a secret key for DES encryption using KeyGenerator.
- Create a DES cipher instance and initialize it for encryption using the secret key.
- Encrypt the plaintext “Hello, DES Encryption!” using cipher.doFinal().
- Encode the encrypted bytes to Base64 for better display.
- Initialize the cipher for decryption using the same secret key and decrypt the encrypted text back to plaintext.