Java Cryptography

Cryptography is the science of securing information by transforming it into a form that only authorized parties can read or verify.

Java applications often need to protect passwords, secrets, API tokens, data in transit, and sensitive information at rest.

Encryption converts plaintext into ciphertext so unauthorized parties cannot read it.

Decryption converts ciphertext back into plaintext using the correct key.

Plaintext is readable, unencrypted data.

Ciphertext is encrypted data that is not readable without the proper key.

A key is secret material used to encrypt, decrypt, sign, or verify data.

A symmetric key is the same key used for both encryption and decryption.

An asymmetric key pair contains a public key and a private key.

JCA is the standard API in Java for cryptographic services such as key generation, message digests, signatures, and ciphers.

JCE extends JCA with stronger cryptographic services, including ciphers and key generation for encryption.

The provider model allows Java to plug in different cryptographic implementations, such as SunJCE, BouncyCastle, or others.

A security provider implements cryptographic algorithms and services for the JCA/JCE APIs.

A message digest is a fixed-size hash computed from data, typically used for integrity checks.

Hashing is the process of transforming input into a deterministic, fixed-size digest.

SHA-256 is a common cryptographic hash function producing a 256-bit digest.

MD5 is a legacy hash function with known vulnerabilities and should not be used in new systems.

SHA-1 is deprecated for security-sensitive use because it is no longer collision-resistant.

A collision occurs when two different inputs produce the same hash value.

They can allow attackers to create alternative inputs with the same hash and bypass integrity checks.

A digital signature proves that a message was created by a private key holder and has not been altered.

Asymmetric signing uses a private key to sign data and a public key to verify it.

Public-key cryptography uses separate keys for encryption and decryption or signing and verification.

Key generation is the process of creating cryptographic keys for use in algorithms.

Key size is the length of the cryptographic key in bits, such as 128-bit or 2048-bit.

A cipher is an algorithm for encrypting and decrypting data.

A block cipher encrypts data in fixed-size blocks, such as 128 bits.

A stream cipher encrypts data one bit or byte at a time.

AES (Advanced Encryption Standard) is a widely used symmetric encryption algorithm.

AES commonly uses 128, 192, or 256-bit keys.

RSA is a widely used asymmetric algorithm for encryption and digital signatures.

A certificate binds a public key to an identity and is signed by a trusted authority.

A keystore stores keys and certificates, often in a protected file format.

A truststore contains trusted certificates used to validate peers.

A key pair consists of a private key and a matching public key.

Java KeyStore (JKS) is a password-protected repository used for keys and certificates.

PKCS#12 is a standard file format for storing keys and certificates, often used for export/import.

JCEKS is a Java Keystore type that supports stronger encryption for keystore entries than JKS.

The main JCA API entry points include classes such as KeyGenerator, KeyPairGenerator, MessageDigest, and Signature.

SecretKey is the Java interface representing a symmetric key.

PublicKey represents a public key in Java.

PrivateKey represents a private key in Java.

A certificate factory creates certificates from encoded data in Java.

javax.crypto contains classes for encryption, decryption, and secure key handling in Java.

java.security contains core security primitives, providers, permissions, and key infrastructure.

Secure random generates unpredictable values needed for IVs, salts, and secrets.

SecureRandom is Java’s class for strong randomness.

An IV (Initialization Vector) is a random value used to ensure identical plaintext blocks encrypt differently.

A salt is random data used to protect password hashes and make them less susceptible to precomputation attacks.

PBKDF2 is a password-based key derivation function designed to slow brute-force attacks.

Password hashing is the process of turning a password into a non-reversible value suitable for verification.

A MAC (Message Authentication Code) verifies the authenticity and integrity of a message.

HMAC is a keyed hash used to verify both integrity and authenticity.

An authenticated cipher provides both confidentiality and integrity.

GCM is an authenticated encryption mode commonly used with AES in modern Java applications.

CBC is an older block cipher mode that requires padding and can be vulnerable if used incorrectly.

ECB mode encrypts each block independently and is often discouraged because it leaks patterns.

Padding adds extra bytes so a block cipher operates on full blocks.

Improper or weak padding can lead to vulnerabilities and decryption failures.

OAEP is a modern padding scheme for RSA encryption that improves security over raw RSA.

PKCS#1 v1.5 is a legacy RSA padding scheme with known weaknesses compared to OAEP.

Key agreement enables two parties to derive a shared secret without explicitly transmitting it.

Diffie-Hellman is a key agreement protocol widely used in real-world secure systems.

ECDH is elliptic-curve Diffie-Hellman used for modern key agreement.

A Java provider implements cryptographic algorithms used by the JCA/JCE APIs.

Java algorithms are often requested with names such as "AES/GCM/NoPadding" or "SHA-256".

JKS is Java-specific. PKCS12 is a standard portable format.

It is standard, cross-platform, and widely supported by Java tools and libraries.

SecretKeySpec creates a key from raw bytes for a specific algorithm.

IvParameterSpec provides an IV for block cipher modes requiring one.

PBEKeySpec is used for password-based encryption and derivation.

It is a password-based encryption algorithm that combines PBKDF and AES.

A keystore password protects the keystore and its entries.

A certificate alias is a name used to reference a certificate or key in a keystore.

It manages security providers and providers configuration.

BouncyCastle is a widely used Java cryptography library that adds algorithms and formats beyond the default JCA provider.

A keystore entry is a key or certificate stored under an alias.

Importing a certificate chain means adding a certificate and intermediates to a keystore or truststore.

Java TLS uses JCA/JCE providers and JSSE for secure socket communication.

JSSE (Java Secure Socket Extension) provides SSL/TLS support for Java applications.

The key manager handles the private key and certificate during TLS client/server authentication.

The trust manager validates remote certificates during TLS handshakes.

It produces a trust manager implementation for certificate validation.

It produces a key manager for cert-based client or server authentication.

The Java runtime performs handshake negotiation, certificate validation, and secure session establishment.

Because there are multiple layers: JCA, JCE, JSSE, providers, keystore formats, and algorithms.

Poor key handling, insecure default algorithms, weak providers, or ignoring algorithm limits.

Key rotation is the periodic replacement of cryptographic keys to limit exposure.

Compromised or long-lived keys increase risk over time.

Hardcoded secrets are easy to discover in source code, logs, or dumps.

External secret management stores secrets in a secure vault or KMS service rather than in code.

A KMS (Key Management Service) manages encryption keys and access policies.

Encryption is reversible; hashing is one-way and meant for integrity or password verification.

A checksum is data used to verify integrity, but it is not necessarily cryptographic unless based on a secure hash.

It is the hierarchy used to trust a certificate presented by a peer.

A secure environment variable is a way to inject secrets without committing them to source control.

Secret leakage is when confidential keys or credentials end up in logs, stack traces, or version control.

Because logs can be read by operators, attackers, or third-party log providers.

A cryptographic exception indicates an error in key generation, algorithm use, certificate validation, or provider configuration.

A provider selection issue happens when the code asks for an unsupported algorithm or a provider doesn't implement it.

The default provider is usually the SunJCE/SunJSSE provider included with the JDK.

For example: Cipher.getInstance("AES/GCM/NoPadding") or MessageDigest.getInstance("SHA-256")

The algorithm name identifies the cryptographic function; the provider is the implementation behind it.

Different providers may implement algorithm variants differently, with different performance or security guarantees.

A Java security policy defines permissions and access rules for code.

It allows stronger cryptographic algorithms and longer keys than the default policy.

To comply with export control restrictions in older Java versions and legal requirements.

AES-GCM provides confidentiality and integrity in one algorithm and is efficient in modern hardware.

A nonce is a unique, non-repeating value used in cryptographic protocols to prevent replay and repeated encryption patterns.

Repeated IVs can leak patterns or enable attacks on encryption.

A secure random IV should be generated for every encryption operation unless a protocol explicitly says otherwise.

An encrypted key is a key encrypted with another key, often used to protect keys at rest.

Key wrap is the encryption of a symmetric key with another key for transport or storage.

It stores symmetric keys in a keystore, usually protected by a password.

Strong key generation uses a secure random source and supported key lengths.

Weak keys may be brute-forced or vulnerable to cryptanalytic attacks.

A known plaintext attack uses known plaintext-ciphertext pairs to recover keys or encryption logic.

IV reuse can make encryption patterns visible and enable chosen-ciphertext or known-plaintext analysis.

Some stream ciphers will repeat keystream if nonce reuse occurs, allowing attackers to recover plaintexts.

Authenticated encryption provides both confidentiality and integrity.

AES-GCM, ChaCha20-Poly1305 when available, and modern authenticated schemes are generally preferred.

Because repeated block patterns can reveal information about the underlying plaintext.

CBC padding oracles can leak information through decryption error timing, causing side-channel vulnerabilities.

A decryption oracle is a service that decrypts data and returns outputs or errors that reveal information.

Encryption hides the content. Signing verifies the authenticity and integrity of the content.

A digital envelope encrypts a symmetric key with an asymmetric public key, then encrypts the actual data with the symmetric key.

Hybrid encryption combines the speed of symmetric encryption with the convenience and trust of asymmetric encryption.

RSA key wrapping encrypts a symmetric key using a public key so it can be safely transferred.

Some algorithms are only available with specific providers, such as BouncyCastle.

KeyGenerator generates symmetric keys.

KeyPairGenerator generates asymmetric key pairs.

CipherOutputStream wraps output streams so encryption is applied transparently.

CipherInputStream wraps input streams so decryption is applied transparently.

The algorithm restriction is a security feature that limits which algorithms and key sizes are accepted.

X509Certificate is the Java class representing an X.509 certificate.

CertificateFactory parses certificate data into Java certificate objects.

A certificate path is the chain from the leaf certificate to a trusted root.

A trust manager determines whether a presented certificate is trusted.

A key manager provides private keys and certificate chains for the local side of a TLS connection.

Password-based key derivation derives a secret key from a password and salt, often with PBKDF2.

Because it is intentionally slow and resistant to brute-force attacks.

JCA handles cryptographic primitives. JSSE handles SSL/TLS sockets and certificates.

Usually it is obtained from the OS or a provider-backed secure random implementation.

A unique salt ensures two identical passwords do not hash to the same value.

A pepper is a secret value added to password hashing, often stored separately from the password hash.

Use PBKDF2, bcrypt, scrypt, or Argon2, not plain MD5 or SHA-1.

Password hashing is non-reversible. Encryption is reversible and intended for data protection.

A key derivation function derives a key from a password, salt, and iterations.

The iteration count in PBKDF2 determines how many times hashing is repeated to slow brute-force attempts.

Many JCA API methods work with raw bytes, so serialization and conversion are important.

Base64 converts binary data into ASCII for safe transport or storage.

Base64 is reversible but not cryptographic; it does not provide confidentiality.

A secret can be a symmetric key, API token, password, or generated credential.

Because source code is often visible to developers, system backups, and source control systems.

A vault is a system for storing and retrieving sensitive secrets securely.

It is the process of registering a provider with the Java security framework.

It occurs when the runtime cannot find a required provider or algorithm is disallowed.

It is the set of registered providers available to code via the JCA security framework.

It matters when multiple providers implement the same algorithm; the order may affect which one is selected.

Choosing robust algorithms and secure defaults is essential to real cryptographic safety.

It is the process of linking a leaf certificate to a trusted root through intermediates.

It ensures the chain is valid, signatures verify, the cert is not expired, and the purpose matches the intended use.

A peer certificate is the certificate presented by the remote endpoint in TLS or SSL.

It happens when two entries in a keystore use the same alias, causing ambiguity.

It occurs when a certificate is used for a purpose not allowed by its key usage or EKU constraints.

It validates certificates against the local truststore and trusted root certificates.

It is a Java exception indicating trust, hostname, or path validation problems.

Cryptographic agility is the ability to change algorithms, keys, or providers without major redesign.

Because cryptographic standards evolve and older algorithms are eventually deprecated.

Weak algorithms can fail security reviews, audits, and regulatory requirements.

It often checks algorithms, key sizes, provider usage, password handling, and certificate management.

A key leak is the exposure of a private key or secret material to unauthorized parties.

A certificate leak often includes private keys or chain material that should be protected.

At rest means data is stored on disk or a database. In transit means data moves over networks.

TLS secures HTTP traffic between services and prevents secrets from being exposed during network transit.

Symmetric key distribution is the challenge of safely delivering a shared key to both parties.

It allows public keys to be shared openly while only private keys remain secret.

Key exchange establishes a shared session secret used for encrypted communication.

Encryption uses keys to transform plaintext. Key agreement derives shared secrets between parties.

They can still be exposed through process dumps, CI logs, or developer tools if not protected.

A side-channel attack uses timing, power, cache behavior, or other indirect signals to extract secrets.

They reduce timing leaks that can reveal secret data or key material.

Timing attack resistance means the algorithm runs in roughly constant time regardless of secret values.

Memory zeroization clears secret data from memory to reduce the chance of recovery after use.

Java objects may remain in memory or heap dumps if secrets are not properly handled.

A heap dump can reveal sensitive passwords, tokens, or keys if they are kept in memory.

A provider attack occurs when a malicious or misconfigured provider is substituted and alters crypto behavior.

Because the provider implementation defines algorithm behavior and key handling.

The Java security manager historically controlled permissions for crypto operations, though modern Java uses more application-level controls.

It means code should abstract algorithms, avoid hardcoded providers, and allow easier future upgrades.

This is typically done with PBKDF2, bcrypt, scrypt, or Argon2, not simple SHA-256.

Argon2 is a modern password hashing function designed to resist brute-force and GPU attacks.

scrypt is a password hashing function designed to be memory-hard and resistant to ASIC/GPU attacks.

bcrypt is a password hashing algorithm designed for slow, costly brute-force attacks.

Because attackers guess passwords offline and slow hashing makes guessing more expensive.

A password cracker attempts to recover passwords by brute-force or dictionary attacks.

A brute-force attack tries many candidate passwords or keys until the correct one is found.

A dictionary attack tests likely passwords from a list rather than all possibilities.

A chosen-ciphertext attack allows the attacker to submit ciphertexts and analyze the outputs to recover secrets.

Use standard APIs, strong algorithms, secure key handling, and proper key lifecycle management; cryptography is not just about “encryption,” but about trust, identity, algorithms, and secure operational practices.