By Clay Curtis in security — Jun 20, 2014

The Hitchhiker's Guide to Using OpenSSL for Managing Certificates

Introduction

Over the years I have had to do a lot of repetitive tasks in OpenSSL, and I've always had to hunt down what command I needed to use. So, I finally made a list of the most common use cases and commands, and now it's time to share.

A Word About Certificate Formats and Encoding

There are two main types of encoding of certificates; DER and PEM.

DER is a binary encoding of a certificate. Typically these use the file extension of .crt or .cer.

PEM is a Base64 encoding of a certificate represented in ASCII therefore it is readable as a block of text. This is very useful as you can open it in a text editor work with the data more easily. The data itself is contained between a prefix of:

-----BEGIN CERTIFICATE-----

and a postfix of:

-----END CERTIFICATE-----

Similarly, RSA keys have a prefix and postfix as well. They are denoted with:

-----BEGIN PRIVATE KEY-----

and

-----END PRIVATE KEY-----

Certificate Signing Requests use:

-----BEGIN CERTIFICATE REQUEST-----

and

-----END CERTIFICATE REQUEST-----

Typically these use the file extension of .pem. RSA private and public keys use the file extension of .key. Certificate Signing Requests (CSRs) use the file extension of .csr.

In the event that you are getting errors when running any OpenSSL commands, you may need to explicitly declare the input format and/or the output format. This can be done by adding the following flags to almost any command:

-inform <pem|der> and -outform <pem|der>

Creating an RSA Private Key

Create a 2048 bit RSA private key that is unencrypted:

openssl genrsa -out name.unencrypted.priv.key 2048

Create a 2048 bit RSA private key that is encrypted with 3DES:

openssl genrsa -des3 -out name.encrypted.priv.key 2048

Encrypting/Decrypting an RSA Private Key

Encrypt an RSA private key with 3DES:

openssl rsa -des3 -in name.unencrypted.priv.key -out name.encrypted.priv.key

Decrypt an RSA private key:

openssl rsa -in name.encrypted.priv.key -out name.unencrypted.priv.key

Creating a Certificate Signing Request

Create a CSR for an existing private key:

openssl req -new -key name.<en|unen>crypted.priv.key -out name.csr

Create a CSR based on a previously issued certificate:

openssl x509 -x509toreq -in name.cer -signkey name.<en|unen>crypted.priv.key -out name.csr

Create an unencrypted private key and CSR in one command:

openssl req -new -newkey rsa:2048 -nodes -keyout name.unencrypted.priv.key -out name.csr

Create an encrypted private key and CSR in one command:

openssl req -new -newkey rsa:2048 -keyout name.encrypted.priv.key -out name.csr

Create a CSR using SHA256 signing algorithm instead of the default SHA1:

openssl req -new -newkey rsa:2048 -sha256 -nodes -keyout name.unencrypted.priv.key -out name.csr

Creating Certificate Signing Requests with Subject Alternate Names

Creating a CSR with Subject Alternate Names (SANs) requires creating a configuration file with the specifics. Then you call it with OpenSSL.

Create a file, name.req.config:

[ req ]
default_bits        = 2048
distinguished_name  = req_distinguished_name
req_extensions     = req_ext

[ req_distinguished_name ]
countryName           = Country Name (2 letter code)
countryName_default   = US
stateOrProvinceName   = State or Province Name (full name)
stateOrProvinceName_default = Florida
localityName          = Locality Name (eg, city)
localityName_default  = Tampa
organizationName          = Organization Name (eg, company)
organizationName_default  = Acme Corporation
commonName            = Common Name (eg, YOUR name)
commonName_max        = 64

[ req_ext ]
subjectAltName          = @alt_names

[alt_names]
DNS.1   = host1.domain.com
DNS.2   = host2.domain.com
DNS.3   = host3.domain.com
DNS.4   = host.differentdomain.com

Create the CSR by referencing the above configuration file:

openssl req -new -key name.encrypted.priv.key -config name.req.config -out name.csr

Showing Contents of Certificate Signing Requests

Print out the contents of the CSR in human-readable format:

openssl req -in name.csr -noout -text

Showing Contents of Certificates

Print out the contents of the certificate in human-readable format:

openssl x509 -in name.pem -noout -text

Verifying Association of Private Key to Certificate

To compare whether a private key and certificate match you need to compare the modulus of both. Considering these are very long strings of text and numbers, it's easier to perform an MD5 checksum and compare the hashes.

Output the modulus MD5 hash of the certificate:

openssl x509 -noout -modulus -in name.pem | openssl md5

Output the modulus MD5 hash of the private key:

openssl rsa -noout -modulus -in name.<en|unen>crypted.priv.key | openssl md5

Compare the outputs to make sure the MD5 hashes match.

Bash one-liner:

For unencrypted private key:

diff -q -s <(openssl x509 -noout -modulus -in name.pem | openssl md5) <(openssl rsa -noout -modulus -in name.unencrypted.priv.key | openssl md5)

For encrypted private key:

diff -q -s <(openssl x509 -noout -modulus -in name.pem | openssl md5) <(openssl rsa -noout -modulus -in name.encrypted.priv.key -passin pass:SuperSecretPassword | openssl md5)

The above command will show Files /dev/fd/63 and /dev/fd/62 are identical if the MD5 hashes match, and will show Files /dev/fd/63 and /dev/fd/62 differ if the MD5 hashes are different.

Combining Root CA and Intermediate CA Certificates into One File

In order to work with certificates that have more than one CA certificate in the issuance path, you have to combine all of the certificates into one single file. Most certificates will be issued by an intermediate authority, and then that intermediate will have been issued by a root authority.

To combine multiple PEM certificates, you just need to put the ASCII data from all of the certificates into one file. Below is an example of this.

EDIT: Reddit user zerouid mentioned that the order of the PEM certificates in the file matters for some older versions of Java. So, to be on the safe side make sure to put the key first (when applicable), then the certificate, then the intermediate, and finally the root certificate. Basically work your way up the chain to the root certificate.

Verifying Validity of Certificate Chain

Verify validity of certificate for sslserver usage:

openssl verify -verbose -purpose sslserver -CAfile CAchain.pem name.pem

Combining Private Key, Certificate, and CA Chain into a PFX

Combine into PFX:

openssl pkcs12 -export -out name.pfx -inkey name.<en|unen>crypted.priv.key -in name.pem -certfile CAchain.pem

Breaking Apart a PFX into Private Key, Certificate, and CA Chain

Extract Private Key

Extract encrypted private key:

openssl pkcs12 -in name.pfx -nocerts -out name.encrypted.priv.key

Extract unencrypted private key:

openssl pkcs12 -in name.pfx -nocerts -nodes -out name.unencrypted.priv.key

Extract Certificate

Extract only the certificate:

openssl pkcs12 -in name.pfx -nokeys -clcerts -out name.pem

Extract Certificate Authority Chain

Extract CA chain. If there are multiple certificates in the chain, they will all be in the same output file.

openssl pkcs12 -in name.pfx -nokeys -cacerts -out CAchain.pem

Converting To/From PEM & DER

Convert from PEM to DER:

openssl x509 -in name.pem -inform pem -out name.cer -outform der

Convert from DER to PEM:

openssl x509 -in name.cer -inform der -out name.pem -outform pem