Cyber Services / All lessons / CEH — Ethical Hacking / Applied Cryptography on Kali Linux

Applied Cryptography on Kali Linux

Module 113 of 130 · 11 min read · Free to read

MODULES ↓ Command blocks have a COPY button

Cryptography is the cornerstone of modern security, providing confidentiality, integrity, authentication, and non-repudiation. This guide explores fundamental cryptographic operations using common Kali Linux tools like OpenSSL and GnuPG (GPG), essential knowledge for any Certified Ethical Hacker.

Ethical Use: Cryptographic tools can be used defensively (protecting data) or offensively (analyzing/breaking weak implementations). Use these techniques legally and ethically within authorized security assessments or for protecting your own data.

I. Cryptographic Hashing: Verifying Integrity

What is Hashing?

A hash function takes an input (message) of any size and produces a fixed-size output string (the hash or digest). Key properties:

  • One-way: Easy to compute the hash from the input, but computationally infeasible to derive the input from the hash.
  • Deterministic: The same input always produces the same hash.
  • Collision Resistant: Extremely difficult to find two different inputs that produce the same hash (though weaknesses exist in older algorithms).
  • Avalanche Effect: A tiny change in the input drastically changes the output hash.

Use Cases: Verifying file integrity (comparing hashes), password storage (storing hashes, not plain text), digital signatures (hashing then encrypting with private key), blockchain technology, and digital forensics.

A. Hashing with OpenSSL (openssl dgst)

OpenSSL's `dgst` command can compute various digests. The -n flag in `echo` prevents adding a trailing newline, which would change the hash.

Common Secure Hashes:

SHA-256 (Recommended Standard):

echo -n "your_text_here" | openssl dgst -sha256

SHA-512 (More Secure, Larger Output):

echo -n "your_text_here" | openssl dgst -sha512

SHA-3 Family (e.g., SHA3-256 - Newer Standard):

echo -n "your_text_here" | openssl dgst -sha3-256

Hashing Files:

openssl dgst -sha256 filename.ext
openssl dgst -sha256 important_document.pdf
Example Output:
SHA256(important_document.pdf)= a1b2c3d4e5f67890abcdef1234567890abcdef1234567890abcdef1234567890
Insecure / Weak Hashes (Avoid for Security):

MD5 and SHA-1 are cryptographically broken (collisions found) and should NOT be used for security purposes like password hashing or digital signatures. They might still be seen for non-security checksums.

MD5:

echo -n "your_text_here" | openssl dgst -md5

SHA-1:

echo -n "your_text_here" | openssl dgst -sha1

(Other less common/older hashes like MD4, RIPEMD-160, TIGER available via `openssl dgst` are generally not recommended for new security applications).

Real-World Attack: Hash Collision

In 2017, Google researchers demonstrated a practical SHA-1 collision attack (SHAttered), creating two different PDF files with the same SHA-1 hash. This completely breaks the security promise of SHA-1, showing why it should never be used for security-sensitive applications.

B. Hashing with Core Linux Utilities (*sum commands)

Linux provides dedicated, often faster, utilities for common hashes, primarily used for file integrity checks.

SHA-256 Checksum:

sha256sum filename.ext

SHA-512 Checksum:

sha512sum filename.ext

MD5 Checksum (Legacy):

md5sum filename.ext
# Verify downloaded ISO integrity
sha256sum kali-linux-2024.1-installer-amd64.iso
# Compare the output hash to the one provided on the official download page.
Pro Tip: Verifying Multiple Files

You can create a checksum file and verify multiple files at once:

# Create checksums for all files in a directory
sha256sum * > checksums.sha256

# Verify all checksums
sha256sum -c checksums.sha256

II. HMAC: Verifying Integrity & Authenticity

What is HMAC?

HMAC (Hash-based Message Authentication Code) combines a cryptographic hash function with a secret key. It provides both data integrity (like a hash) and data origin authentication (proving the message came from someone who knows the secret key).

Use Cases: Verifying message authenticity in APIs, securing cookies/tokens, ensuring data hasn't been tampered with *and* originates from a trusted source, message authentication in network protocols like IPsec and TLS.

HMAC with OpenSSL (openssl dgst -hmac)

HMAC using SHA-256:

echo -n "your_message_here" | openssl dgst -sha256 -hmac "your_secret_key"
echo -n "PaymentData:User123:Amount50" | openssl dgst -sha256 -hmac "MySuperSecretAPIKey"

Both sender and receiver need the *exact same* secret key to generate and verify the HMAC.

Example Output:
(stdin)= 7a3b8c... (64-character hexadecimal string)
Advanced: Using -mac and -macopt for More Control

For more control over the HMAC generation, you can use the -mac and -macopt options:

echo -n "message" | openssl dgst -sha256 -mac HMAC -macopt hexkey:$(echo -n "secret" | xxd -p)

This allows you to specify the key in hexadecimal format, which can be useful for certain applications.

III. Symmetric Encryption: Confidentiality with Shared Keys

What is Symmetric Encryption?

Uses the same secret key for both encryption and decryption. It's generally very fast.

  • Algorithms: AES (Advanced Encryption Standard - recommended), DES/3DES (legacy/insecure), Blowfish, Twofish, ChaCha20.
  • Modes of Operation: CBC, GCM, CTR, etc., define how blocks of data are processed. GCM is often preferred as it provides Authenticated Encryption (AEAD - Confidentiality + Integrity/Authenticity).

Use Cases: Encrypting files at rest, securing data in transit (often within protocols like TLS), database encryption, full disk encryption.

Challenge: Securely sharing the single key between parties.

Symmetric Encryption/Decryption with OpenSSL (openssl enc)

Using AES-256 in CBC mode (Cipher Block Chaining) with a password-derived key and salt.

Encrypt a File:

openssl enc -aes-256-cbc -salt -in plaintext_file.txt -out encrypted_file.enc -pbkdf2 -iter 100000
-aes-256-cbc: Specifies the cipher and mode.
-salt: Adds a random salt (highly recommended!) making identical passwords produce different outputs.
-in ... -out ...: Input and output files.
-pbkdf2: Use PBKDF2 standard for deriving the key from the password (more secure than older methods).
-iter 100000: Specify number of iterations for key derivation (higher is slower but more secure against brute-force).
You will be prompted for an encryption password.
openssl enc -aes-256-cbc -salt -in secrets.txt -out secrets.enc -pbkdf2 -iter 100000

Decrypt a File:

openssl enc -d -aes-256-cbc -in encrypted_file.enc -out decrypted_file.txt -pbkdf2
-d: Decrypt mode. You will be prompted for the *same* password used during encryption. openssl enc -d -aes-256-cbc -in secrets.enc -out secrets_decrypted.txt -pbkdf2
Alternative: Using Authenticated Encryption (GCM mode)

For better security that includes authentication, use AES-GCM mode:

# Encryption with AES-GCM
openssl enc -aes-256-gcm -salt -in plaintext.txt -out encrypted.enc -pbkdf2 -iter 100000

# Decryption with AES-GCM
openssl enc -d -aes-256-gcm -in encrypted.enc -out decrypted.txt -pbkdf2

Note: GCM mode automatically provides authentication in addition to confidentiality.

Key Management is Crucial: The security of symmetric encryption relies entirely on keeping the shared key secret. Securely transmitting or storing this key is vital. Password strength is also critical when deriving keys from passwords.
Security Consideration: Side-Channel Attacks

When using cryptographic tools, be aware of potential side-channel attacks. For example, the time taken for encryption/decryption operations might leak information about the key or data. In high-security environments, use constant-time implementations.

IV. Asymmetric Encryption (Public-Key Cryptography)

What is Asymmetric Encryption?

Uses a pair of keys: a public key (shared freely) and a private key (kept secret). Data encrypted with the public key can ONLY be decrypted with the corresponding private key. Data signed (effectively encrypted) with the private key can be verified using the public key.

  • Algorithms: RSA, ECC (Elliptic Curve Cryptography - often more efficient), DSA (Digital Signature Algorithm).

Use Cases: Secure key exchange (like in TLS/SSL), digital signatures (authentication, non-repudiation), encrypting messages for specific recipients without pre-sharing a secret, cryptocurrency transactions.

Challenge: Slower than symmetric encryption; often used to encrypt a symmetric key which is then used for bulk encryption (hybrid approach).

Asymmetric Operations with GnuPG (gpg)

GPG is the standard tool on Linux for implementing the OpenPGP standard, providing robust key management, encryption, and signing capabilities.

1. Generate a Key Pair (if you don't have one):

gpg --full-gen-key
Follow the prompts (choose key type like RSA, key size like 4096, expiry, user ID, and set a strong passphrase for your private key!). For more control, use --expert option.
Advanced Key Generation

For more control over key generation, especially for Elliptic Curve Cryptography:

gpg --expert --full-gen-key

This allows you to select from more algorithm options, including ECC.

2. List Your Keys:

gpg --list-keys          # List public keys in your keyring
gpg --list-secret-keys   # List private keys in your keyring

3. Export a Public Key (to share with others):

gpg --export --armor -o recipient_pubkey.asc recipient_email_or_keyid
gpg --export --armor -o alice_pub.asc alice@example.com --armor creates ASCII-armored output (text) instead of binary.

4. Import Someone Else's Public Key:

gpg --import sender_pubkey.asc

4b. Verify and Sign Imported Keys:

gpg --list-keys
gpg --edit-key key_id
# In the interactive prompt: fpr (to see fingerprint), trust, sign, save
Always verify the fingerprint of imported keys through a secure channel before signing them.

5. Encrypt a File for a Recipient:

gpg --encrypt --recipient recipient_email_or_keyid --output encrypted_file.gpg plaintext_file.txt
gpg --encrypt --recipient alice@example.com --output confidential_report.gpg report.txt Only Alice can decrypt `confidential_report.gpg` using her private key and passphrase.

6. Decrypt a File:

gpg --decrypt --output decrypted_file.txt encrypted_file.gpg
gpg --decrypt --output report_decrypted.txt confidential_report.gpg You will be prompted for the passphrase protecting *your* private key.
Example Output (if successful):
gpg: encrypted with 2048-bit RSA key, ID A1B2C3D4E5, created 2023-01-01
gpg: Signature made Mon 01 Jan 2023 12:00:00 PM UTC
gpg: using RSA key A1B2C3D4E5F67890ABCDEF1234567890ABCDEF12
gpg: Good signature from "Alice <alice@example.com>" [ultimate]

7. Signing and Verification:

Create a Detached Signature:

gpg --detach-sign --armor -o signature.asc file_to_sign

Verify a Detached Signature:

gpg --verify signature.asc signed_file

Create a Clear-Signed Message (text only):

gpg --clearsign message.txt
Key Backup and Recovery

Always backup your GPG keys securely:

# Export private key
gpg --export-secret-keys --armor -o private.key

# Export public key
gpg --export --armor -o public.key

# Export revocation certificate (important!)
gpg --gen-revoke --armor -o revoke.asc

Store these backups in secure, offline locations.

V. Encoding vs. Encryption: A Crucial Distinction

Encoding is NOT Encryption!

Encoding (like Base64) is used for representing data in different formats, often to ensure compatibility with transmission mediums (e.g., sending binary data over email). It is easily reversible without any secret key and provides NO confidentiality.

Encryption transforms data into an unreadable format using a key, requiring the correct key for decryption, thus providing confidentiality.

Base64 Encoding/Decoding

Using `base64` utility:

# Encode text
echo -n "some data" | base64

# Decode text
echo "c29tZSBkYXRh" | base64 --decode

# Encode a file
base64 input_file > encoded_file.b64

# Decode a file
base64 --decode encoded_file.b64 > output_file

Using `openssl base64`:

# Encode file
openssl base64 -in input_file -out encoded_file.b64

# Decode file
openssl base64 -d -in encoded_file.b64 -out output_file
Security Warning: Base64 Misuse

Many security vulnerabilities occur when developers mistakenly use Base64 encoding instead of proper encryption. Always remember that Base64 provides no security - it's merely a data representation format.

VI. Password Hashing (Special Consideration)

Password Hashing vs. Cryptographic Hashing

While similar, password hashing has special requirements:

  • Must be deliberately slow to resist brute-force attacks
  • Must use a unique salt for each password to prevent rainbow table attacks
  • Should use memory-hard functions to resist GPU/ASIC attacks

Using dedicated password hashing tools

Using mkpasswd (whois package):

# Install whois package if needed
sudo apt install whois

# Generate password hash
mkpasswd -m sha-512 "yourpassword"

Using Python's passlib (if available):

python3 -c "from passlib.hash import sha512_crypt; print(sha512_crypt.hash('yourpassword'))"
Best Practices for Password Hashing
  • Use dedicated password hashing algorithms like bcrypt, Argon2, or PBKDF2
  • Use high work factors (iteration counts) that are appropriate for your hardware
  • Always use a unique, random salt for each password
  • Consider using dedicated libraries rather than command-line tools for application development

VII. Cryptographic Best Practices

  • Use Strong Algorithms: Prefer SHA-256/SHA-512/SHA3 for hashing, AES (128/256) for symmetric encryption, RSA (>=2048 bit) or ECC for asymmetric encryption.
  • Avoid Weak/Broken Algorithms: Do not use MD5, SHA-1, DES, RC4 for security purposes.
  • Use Salts: Always use salts when hashing passwords to prevent rainbow table attacks. Use PBKDF2, bcrypt, scrypt, or Argon2 for password hashing.
  • Key Management: Protect private keys and symmetric keys rigorously. Use strong passphrases for GPG keys. Establish secure methods for key exchange. Consider using hardware security modules (HSMs) for critical keys.
  • Authenticated Encryption: Whenever possible, use modes like AES-GCM that provide both confidentiality and integrity/authenticity. If not, use Encrypt-then-MAC.
  • Understand the Tool: Know the defaults and options of the tools you use (e.g., `openssl enc` defaults might not be optimal without flags like `-pbkdf2`).
  • Keep Software Updated: Cryptographic implementations improve over time, and vulnerabilities are regularly discovered and patched.
  • Use Established Libraries: Avoid implementing cryptographic algorithms yourself; use well-vetted libraries instead.
Quantum Computing Threat

Be aware that quantum computing poses a future threat to current asymmetric cryptography (RSA, ECC). Post-quantum cryptography is an active area of research, and migration to quantum-resistant algorithms may be necessary in the future.

Conclusion

Kali Linux provides powerful command-line tools like OpenSSL and GnuPG for performing essential cryptographic operations. Understanding hashing for integrity, HMAC for authentication, and both symmetric and asymmetric encryption for confidentiality is vital for any ethical hacker. Mastering these tools allows you to analyze, secure, and protect sensitive data effectively, establish secure communication channels, and verify the authenticity of information. With practical knowledge of these cryptographic techniques, ethical hackers and security professionals can better safeguard systems against cyber threats and ensure robust information security.

Modules (130) ← CEH — Ethical Hacking