Public Key Infrastructure (PKI) with OpenSSL (RSA and ECC)

Explore the basics of cryptography, including how encryption converts plain text to cipher text using a private key and how decryption reverses it.

Explain symmetric cryptosystems that use a single private key for encryption and decryption, their key-exchange drawbacks, and how Diffie-Hellman key exchange solves key distribution in networks like cryptocurrencies.

Explore asymmetric cryptosystems, using a public key for encryption and a private key for decryption to transform plaintext into cipher text and back, including RSA and elliptic curve schemes.

Install and configure OpenSSL on Windows, adjust environment variables, and access RSA, elliptic curve cryptography, and sha256 algorithms for generating keys.

Install IntelliJ community edition and configure it for Java projects to build applications and microservices, including setting the path variable and running a hello world program.

Generate rsa private and public keys with OpenSSL, save as pem files, and inspect key components such as modulus, public exponent, and private exponent.

Encrypt a file using RSA keys with public key for encryption and private key for decryption, demonstrated with OpenSSL and p key util, producing encrypted and decrypted files.

Generate elliptic curve private and public keys with OpenSSL using the prime256v1 curve, saving them in PEM and DER formats, and extract the public key from the private key.

Generate rsa key pairs in java using Bouncycastle with a 3072-bit key, print the public modulus and public exponent alongside the private exponent, and preview upcoming elliptic curve topics.

Read rsa keys from pem files and convert them into Java public and private key objects using a key factory and x509/pkcs8 specs.

Identify how root and intermediate certificates build the chain of trust in PKI. Learn how public keys, signatures, and issuer information validate SSL certificates.

Generate root certificates with OpenSSL by creating self-signed X.509 certificates using ECC and sha-256, valid 365 days, and learn about issuer, subject, public key, pem format, and key identifiers.

Explore certificate parameters in PKI with OpenSSL, including version three, serial number, issuer and subject names, and extensions such as authority key identifier, subject key identifier, and key usage.

Use OpenSSL configuration files to define certificate fields such as country, state, locality, organization, common name, and email. Set defaults and prompts in the config, enabling automated, no-prompt certificate generation.

Configure x509 extensions in an OpenSSL config file, including subject key identifier, authority key identifier, basic constraints, and path length for root and intermediate certificates.

learn how to generate a root x.509 certificate in Java using the Bouncycastle provider, creating elliptic-curve key pairs and a version 3 certificate with distinguished names and extensions.

Add extensions to a self-signed root certificate: basic constraints, subject key identifier, and authority key identifier, then sign with sha256 and ecdsa.

Generate a self-signed root certificate (version 3) with OpenSSL using elliptic curve cryptography and sha-256, include authority and subject key identifiers and basic constraint, then convert to a base64 PEM.

Explore how root and intermediate certificates form a trust chain, and how a certificate signing request enables a certificate authority to sign and issue a certificate for TLS.

Generate a certificate signing request with an OpenSSL configuration, include the distinguished name and EC public key, save as a CSR PEM, and submit to a certificate authority for signing.

Generate a root certificate and sign a certificate signing request to produce an intermediate certificate, using RSA or ECC keys with OpenSSL, ensuring serial numbers, sha256, and X.509 extensions.

Configure X509 extensions in a certificate signing request via a config file, copy extensions to the intermediate certificate, and include subject key identifier and key usage with OpenSSL.

Verify the chain of trust by using the intermediate's public key to validate the end entity certificate and the root's public key to validate the intermediate, enabling secure TLS communications.