Show pageOld revisionsBacklinksBack to top This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong. ====== SSL ====== ===== Display cert from pkcs12 ===== <code> openssl pkcs12 -in <p12> -nodes -nokeys -passin pass:"<password>" | openssl x509 -info </code> ===== Self signed cert ===== <code> openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout server.key -out server.crt </code> ===== Add trusted CA ===== ==== CentOS 7 ==== * Copy trusted cert into: <code> /etc/pki/ca-trust/source/anchors/ </code> * Exec command <code> sudo update-ca-trust </code> ===== CSR with multiple DNS alias ===== Fill csr_details.txt Server info: <code> FQDN : srvweb01.bm.local hostname : srvweb01 IP : 192.168.1.20 </code> We want our cert to get be valid for those 3 addresses : <code> https://srvweb01 https://srvweb01.bm.local 192.168.1.20 </code> We should precise it into openssl configuration file : <code> [req] default_bits = 2048 prompt = no default_md = sha256 req_extensions = req_ext distinguished_name = dn [ dn ] C=FR ST=Grenoble L=Grenoble O=BLOGMOTION OU=BLOGMOTION emailAddress=cert@nospam-blogmotion.fr CN = srvweb01.bm.local [ req_ext ] subjectAltName = @alt_names [ alt_names ] DNS.1 = srvweb01 DNS.2 = srvwebalias IP.1 = 192.168.1.20 EOF </code> <code> openssl req -nodes -newkey rsa:2048 -sha256 -days 3650 -keyout srvweb01.key -out srvweb01.csr -config csr_details.txt </code> ===== Certificate expiration ===== * remotely <code> DOM="FILLME" PORT="443" ## note echo added ## echo | openssl s_client -servername $DOM -connect $DOM:$PORT \ | openssl x509 -noout -dates </code> * locally <code> openssl x509 -enddate -noout -in {/path/to/my/my.pem} </code> ===== CA creation ===== ==== Create the root pair ==== === Prepare the configuration file === Choose a directory (/root/ca) to store all keys and certificates. <code> # mkdir /root/ca </code> Create the directory structure. The index.txt and serial files act as a flat file database to keep track of signed certificates. <code> # cd /root/ca # mkdir certs crl newcerts private # chmod 700 private # touch index.txt # echo 1000 > serial </code> Copy the root CA configuration file to /root/ca/openssl.cnf. <code> # OpenSSL root CA configuration file. # Copy to `/root/ca/openssl.cnf`. [ ca ] # `man ca` default_ca = CA_default [ CA_default ] # Directory and file locations. dir = /root/ca certs = $dir/certs crl_dir = $dir/crl new_certs_dir = $dir/newcerts database = $dir/index.txt serial = $dir/serial RANDFILE = $dir/private/.rand # The root key and root certificate. private_key = $dir/private/ca.key.pem certificate = $dir/certs/ca.cert.pem # For certificate revocation lists. crlnumber = $dir/crlnumber crl = $dir/crl/ca.crl.pem crl_extensions = crl_ext default_crl_days = 30 # SHA-1 is deprecated, so use SHA-2 instead. default_md = sha256 name_opt = ca_default cert_opt = ca_default default_days = 375 preserve = no policy = policy_strict [ policy_strict ] # The root CA should only sign intermediate certificates that match. # See the POLICY FORMAT section of `man ca`. countryName = match stateOrProvinceName = match organizationName = match organizationalUnitName = optional commonName = supplied emailAddress = optional [ policy_loose ] # Allow the intermediate CA to sign a more diverse range of certificates. # See the POLICY FORMAT section of the `ca` man page. countryName = optional stateOrProvinceName = optional localityName = optional organizationName = optional organizationalUnitName = optional commonName = supplied emailAddress = optional [ req ] # Options for the `req` tool (`man req`). default_bits = 2048 distinguished_name = req_distinguished_name string_mask = utf8only # SHA-1 is deprecated, so use SHA-2 instead. default_md = sha256 # Extension to add when the -x509 option is used. x509_extensions = v3_ca [ req_distinguished_name ] # See <https://en.wikipedia.org/wiki/Certificate_signing_request>. countryName = Country Name (2 letter code) stateOrProvinceName = State or Province Name localityName = Locality Name 0.organizationName = Organization Name organizationalUnitName = Organizational Unit Name commonName = Common Name emailAddress = Email Address # Optionally, specify some defaults. countryName_default = GB stateOrProvinceName_default = England localityName_default = 0.organizationName_default = Alice Ltd organizationalUnitName_default = emailAddress_default = [ v3_ca ] # Extensions for a typical CA (`man x509v3_config`). subjectKeyIdentifier = hash authorityKeyIdentifier = keyid:always,issuer basicConstraints = critical, CA:true keyUsage = critical, digitalSignature, cRLSign, keyCertSign [ v3_intermediate_ca ] # Extensions for a typical intermediate CA (`man x509v3_config`). subjectKeyIdentifier = hash authorityKeyIdentifier = keyid:always,issuer basicConstraints = critical, CA:true, pathlen:0 keyUsage = critical, digitalSignature, cRLSign, keyCertSign [ usr_cert ] # Extensions for client certificates (`man x509v3_config`). basicConstraints = CA:FALSE nsCertType = client, email nsComment = "OpenSSL Generated Client Certificate" subjectKeyIdentifier = hash authorityKeyIdentifier = keyid,issuer keyUsage = critical, nonRepudiation, digitalSignature, keyEncipherment extendedKeyUsage = clientAuth, emailProtection [ server_cert ] # Extensions for server certificates (`man x509v3_config`). basicConstraints = CA:FALSE nsCertType = server nsComment = "OpenSSL Generated Server Certificate" subjectKeyIdentifier = hash authorityKeyIdentifier = keyid,issuer:always keyUsage = critical, digitalSignature, keyEncipherment extendedKeyUsage = serverAuth [ crl_ext ] # Extension for CRLs (`man x509v3_config`). authorityKeyIdentifier=keyid:always [ ocsp ] # Extension for OCSP signing certificates (`man ocsp`). basicConstraints = CA:FALSE subjectKeyIdentifier = hash authorityKeyIdentifier = keyid,issuer keyUsage = critical, digitalSignature extendedKeyUsage = critical, OCSPSigning </code> The [ ca ] section is mandatory. Here we tell OpenSSL to use the options from the [ CA_default ] section. The [ CA_default ] section contains a range of defaults. Make sure you declare the directory you chose earlier (/root/ca). We’ll apply policy_strict for all root CA signatures, as the root CA is only being used to create intermediate CAs. We’ll apply policy_loose for all intermediate CA signatures, as the intermediate CA is signing server and client certificates that may come from a variety of third-parties. Options from the [ req ] section are applied when creating certificates or certificate signing requests. The [ req_distinguished_name ] section declares the information normally required in a certificate signing request. You can optionally specify some defaults. We’ll apply the v3_ca extension when we create the root certificate. We’ll apply the v3_ca_intermediate extension when we create the intermediate certificate. pathlen:0 ensures that there can be no further certificate authorities below the intermediate CA. We’ll apply the usr_cert extension when signing client certificates, such as those used for remote user authentication. We’ll apply the server_cert extension when signing server certificates, such as those used for web servers. The crl_ext extension is automatically applied when creating certificate revocation lists. We’ll apply the ocsp extension when signing the Online Certificate Status Protocol (OCSP) certificate. === Create the root key === Create the root key (ca.key.pem) and keep it absolutely secure. Anyone in possession of the root key can issue trusted certificates. Encrypt the root key with AES 256-bit encryption and a strong password. <code> # cd /root/ca # openssl genrsa -aes256 -out private/ca.key.pem 4096 # chmod 400 private/ca.key.pem </code> === Create the root certificate === Use the root key (ca.key.pem) to create a root certificate (ca.cert.pem). Give the root certificate a long expiry date, such as twenty years. Once the root certificate expires, all certificates signed by the CA become invalid. Warning Whenever you use the req tool, you must specify a configuration file to use with the -config option, otherwise OpenSSL will default to /etc/pki/tls/openssl.cnf. <code> # cd /root/ca # openssl req -config openssl.cnf \ -key private/ca.key.pem \ -new -x509 -days 7300 -sha256 -extensions v3_ca \ -out certs/ca.cert.pem # chmod 444 certs/ca.cert.pem </code> === Verify the root certificate === <code> # openssl x509 -noout -text -in certs/ca.cert.pem </code> ==== Create the intermediate pair ==== === Prepare the directory ==== The root CA files are kept in /root/ca. Choose a different directory (/root/ca/intermediate) to store the intermediate CA files. <code> # mkdir /root/ca/intermediate </code> Create the same directory structure used for the root CA files. It’s convenient to also create a csr directory to hold certificate signing requests. <code> # cd /root/ca/intermediate # mkdir certs crl csr newcerts private # chmod 700 private # touch index.txt # echo 1000 > serial </code> Add a crlnumber file to the intermediate CA directory tree. crlnumber is used to keep track of certificate revocation lists. <code> # echo 1000 > /root/ca/intermediate/crlnumber </code> Copy the intermediate CA configuration file to /root/ca/intermediate/openssl.cnf. <code> # OpenSSL intermediate CA configuration file. # Copy to `/root/ca/intermediate/openssl.cnf`. [ ca ] # `man ca` default_ca = CA_default [ CA_default ] # Directory and file locations. dir = /root/ca/intermediate certs = $dir/certs crl_dir = $dir/crl new_certs_dir = $dir/newcerts database = $dir/index.txt serial = $dir/serial RANDFILE = $dir/private/.rand # The root key and root certificate. private_key = $dir/private/intermediate.key.pem certificate = $dir/certs/intermediate.cert.pem # For certificate revocation lists. crlnumber = $dir/crlnumber crl = $dir/crl/intermediate.crl.pem crl_extensions = crl_ext default_crl_days = 30 # SHA-1 is deprecated, so use SHA-2 instead. default_md = sha256 name_opt = ca_default cert_opt = ca_default default_days = 375 preserve = no policy = policy_loose [ policy_strict ] # The root CA should only sign intermediate certificates that match. # See the POLICY FORMAT section of `man ca`. countryName = match stateOrProvinceName = match organizationName = match organizationalUnitName = optional commonName = supplied emailAddress = optional [ policy_loose ] # Allow the intermediate CA to sign a more diverse range of certificates. # See the POLICY FORMAT section of the `ca` man page. countryName = optional stateOrProvinceName = optional localityName = optional organizationName = optional organizationalUnitName = optional commonName = supplied emailAddress = optional [ req ] # Options for the `req` tool (`man req`). default_bits = 2048 distinguished_name = req_distinguished_name string_mask = utf8only # SHA-1 is deprecated, so use SHA-2 instead. default_md = sha256 # Extension to add when the -x509 option is used. x509_extensions = v3_ca [ req_distinguished_name ] # See <https://en.wikipedia.org/wiki/Certificate_signing_request>. countryName = Country Name (2 letter code) stateOrProvinceName = State or Province Name localityName = Locality Name 0.organizationName = Organization Name organizationalUnitName = Organizational Unit Name commonName = Common Name emailAddress = Email Address # Optionally, specify some defaults. countryName_default = GB stateOrProvinceName_default = England localityName_default = 0.organizationName_default = Alice Ltd organizationalUnitName_default = emailAddress_default = [ v3_ca ] # Extensions for a typical CA (`man x509v3_config`). subjectKeyIdentifier = hash authorityKeyIdentifier = keyid:always,issuer basicConstraints = critical, CA:true keyUsage = critical, digitalSignature, cRLSign, keyCertSign [ v3_intermediate_ca ] # Extensions for a typical intermediate CA (`man x509v3_config`). subjectKeyIdentifier = hash authorityKeyIdentifier = keyid:always,issuer basicConstraints = critical, CA:true, pathlen:0 keyUsage = critical, digitalSignature, cRLSign, keyCertSign [ usr_cert ] # Extensions for client certificates (`man x509v3_config`). basicConstraints = CA:FALSE nsCertType = client, email nsComment = "OpenSSL Generated Client Certificate" subjectKeyIdentifier = hash authorityKeyIdentifier = keyid,issuer keyUsage = critical, nonRepudiation, digitalSignature, keyEncipherment extendedKeyUsage = clientAuth, emailProtection [ server_cert ] # Extensions for server certificates (`man x509v3_config`). basicConstraints = CA:FALSE nsCertType = server nsComment = "OpenSSL Generated Server Certificate" subjectKeyIdentifier = hash authorityKeyIdentifier = keyid,issuer:always keyUsage = critical, digitalSignature, keyEncipherment extendedKeyUsage = serverAuth [ crl_ext ] # Extension for CRLs (`man x509v3_config`). authorityKeyIdentifier=keyid:always [ ocsp ] # Extension for OCSP signing certificates (`man ocsp`). basicConstraints = CA:FALSE subjectKeyIdentifier = hash authorityKeyIdentifier = keyid,issuer keyUsage = critical, digitalSignature extendedKeyUsage = critical, OCSPSigning </code> === Create the intermediate key === Create the intermediate key (intermediate.key.pem). Encrypt the intermediate key with AES 256-bit encryption and a strong password. <code> # cd /root/ca # openssl genrsa -aes256 \ -out intermediate/private/intermediate.key.pem 4096 # chmod 400 intermediate/private/intermediate.key.pem </code> === Create the intermediate certificate === Use the intermediate key to create a certificate signing request (CSR). The details should generally match the root CA. The Common Name, however, must be different. Warning Make sure you specify the intermediate CA configuration file (intermediate/openssl.cnf). <code> # cd /root/ca # openssl req -config intermediate/openssl.cnf -new -sha256 \ -key intermediate/private/intermediate.key.pem \ -out intermediate/csr/intermediate.csr.pem </code> To create an intermediate certificate, use the root CA with the v3_intermediate_ca extension to sign the intermediate CSR. The intermediate certificate should be valid for a shorter period than the root certificate. Ten years would be reasonable. Warning This time, specify the root CA configuration file (/root/ca/openssl.cnf). <code> # cd /root/ca # openssl ca -config openssl.cnf -extensions v3_intermediate_ca \ -days 3650 -notext -md sha256 \ -in intermediate/csr/intermediate.csr.pem \ -out intermediate/certs/intermediate.cert.pem # chmod 444 intermediate/certs/intermediate.cert.pem </code> The index.txt file is where the OpenSSL ca tool stores the certificate database. Do not delete or edit this file by hand. It should now contain a line that refers to the intermediate certificate. === Verify the intermediate certificate === As we did for the root certificate, check that the details of the intermediate certificate are correct. <code> # openssl x509 -noout -text \ -in intermediate/certs/intermediate.cert.pem </code> Verify the intermediate certificate against the root certificate. An OK indicates that the chain of trust is intact. <code> # openssl verify -CAfile certs/ca.cert.pem \ intermediate/certs/intermediate.cert.pem </code> === Create the certificate chain file === When an application (eg, a web browser) tries to verify a certificate signed by the intermediate CA, it must also verify the intermediate certificate against the root certificate. To complete the chain of trust, create a CA certificate chain to present to the application. To create the CA certificate chain, concatenate the intermediate and root certificates together. We will use this file later to verify certificates signed by the intermediate CA. <code> # cat intermediate/certs/intermediate.cert.pem \ certs/ca.cert.pem > intermediate/certs/ca-chain.cert.pem # chmod 444 intermediate/certs/ca-chain.cert.pem </code> Note Our certificate chain file must include the root certificate because no client application knows about it yet. A better option, particularly if you’re administrating an intranet, is to install your root certificate on every client that needs to connect. In that case, the chain file need only contain your intermediate certificate. ==== Sign server and client certificates ==== We will be signing certificates using our intermediate CA. You can use these signed certificates in a variety of situations, such as to secure connections to a web server or to authenticate clients connecting to a service. Note The steps below are from your perspective as the certificate authority. A third-party, however, can instead create their own private key and certificate signing request (CSR) without revealing their private key to you. They give you their CSR, and you give back a signed certificate. In that scenario, skip the genrsa and req commands. === Create a key === Our root and intermediate pairs are 4096 bits. Server and client certificates normally expire after one year, so we can safely use 2048 bits instead. Note Although 4096 bits is slightly more secure than 2048 bits, it slows down TLS handshakes and significantly increases processor load during handshakes. For this reason, most websites use 2048-bit pairs. If you’re creating a cryptographic pair for use with a web server (eg, Apache), you’ll need to enter this password every time you restart the web server. You may want to omit the -aes256 option to create a key without a password. <code> # cd /root/ca # openssl genrsa -aes256 \ -out intermediate/private/www.example.com.key.pem 2048 # chmod 400 intermediate/private/www.example.com.key.pem </code> === Create a certificate === Use the private key to create a certificate signing request (CSR). The CSR details don’t need to match the intermediate CA. For server certificates, the Common Name must be a fully qualified domain name (eg, www.example.com), whereas for client certificates it can be any unique identifier (eg, an e-mail address). Note that the Common Name cannot be the same as either your root or intermediate certificate. <code> # cd /root/ca # openssl req -config intermediate/openssl.cnf \ -key intermediate/private/www.example.com.key.pem \ -new -sha256 -out intermediate/csr/www.example.com.csr.pem </code> To create a certificate, use the intermediate CA to sign the CSR. If the certificate is going to be used on a server, use the server_cert extension. If the certificate is going to be used for user authentication, use the usr_cert extension. Certificates are usually given a validity of one year, though a CA will typically give a few days extra for convenience. <code> # cd /root/ca # openssl ca -config intermediate/openssl.cnf \ -extensions server_cert -days 375 -notext -md sha256 \ -in intermediate/csr/www.example.com.csr.pem \ -out intermediate/certs/www.example.com.cert.pem # chmod 444 intermediate/certs/www.example.com.cert.pem </code> The intermediate/index.txt file should contain a line referring to this new certificate. === Verify the certificate === <code> # openssl x509 -noout -text \ -in intermediate/certs/www.example.com.cert.pem </code> The Issuer is the intermediate CA. The Subject refers to the certificate itself. The output will also show the X509v3 extensions. When creating the certificate, you used either the server_cert or usr_cert extension. The options from the corresponding configuration section will be reflected in the output. Use the CA certificate chain file we created earlier (ca-chain.cert.pem) to verify that the new certificate has a valid chain of trust. <code> # openssl verify -CAfile intermediate/certs/ca-chain.cert.pem \ intermediate/certs/www.example.com.cert.pem </code> === Deploy the certificate === You can now either deploy your new certificate to a server, or distribute the certificate to a client. When deploying to a server application (eg, Apache), you need to make the following files available: ca-chain.cert.pem www.example.com.key.pem www.example.com.cert.pem If you’re signing a CSR from a third-party, you don’t have access to their private key so you only need to give them back the chain file (ca-chain.cert.pem) and the certificate (www.example.com.cert.pem). ==== Certificate revocation lists === A certificate revocation list (CRL) provides a list of certificates that have been revoked. A client application, such as a web browser, can use a CRL to check a server’s authenticity. A server application, such as Apache or OpenVPN, can use a CRL to deny access to clients that are no longer trusted. Publish the CRL at a publicly accessible location (eg, http://example.com/intermediate.crl.pem). Third-parties can fetch the CRL from this location to check whether any certificates they rely on have been revoked. Note: Some applications vendors have deprecated CRLs and are instead using the Online Certificate Status Protocol (OCSP). Prepare the configuration file When a certificate authority signs a certificate, it will normally encode the CRL location into the certificate. Add crlDistributionPoints to the appropriate sections. In our case, add it to the [ server_cert ] section. <code> [ server_cert ] # ... snipped ... crlDistributionPoints = URI:http://example.com/intermediate.crl.pem </code> === Create the CRL === <code> # cd /root/ca # openssl ca -config intermediate/openssl.cnf \ -gencrl -out intermediate/crl/intermediate.crl.pem </code> Note The CRL OPTIONS section of the ca man page contains more information on how to create CRLs. You can check the contents of the CRL with the crl tool. <code> # openssl crl -in intermediate/crl/intermediate.crl.pem -noout -text </code> No certificates have been revoked yet, so the output will state No Revoked Certificates. You should re-create the CRL at regular intervals. By default, the CRL expires after 30 days. This is controlled by the default_crl_days option in the [ CA_default ] section. === Revoke a certificate === Let’s walk through an example. Alice is running the Apache web server and has a private folder of heart-meltingly cute kitten pictures. Alice wants to grant her friend, Bob, access to this collection. Bob creates a private key and certificate signing request (CSR). <code> $ cd /home/bob $ openssl genrsa -out bob@example.com.key.pem 2048 $ openssl req -new -key bob@example.com.key.pem \ -out bob@example.com.csr.pem </code> Bob sends his CSR to Alice, who then signs it. <code> # cd /root/ca # openssl ca -config intermediate/openssl.cnf \ -extensions usr_cert -notext -md sha256 \ -in intermediate/csr/bob@example.com.csr.pem \ -out intermediate/certs/bob@example.com.cert.pem </code> Alice verifies that the certificate is valid: <code> # openssl verify -CAfile intermediate/certs/ca-chain.cert.pem \ intermediate/certs/bob@example.com.cert.pem </code> The index.txt file should contain a new entry. Alice sends Bob the signed certificate. Bob installs the certificate in his web browser and is now able to access Alice’s kitten pictures. Hurray! Sadly, it turns out that Bob is misbehaving. Bob has posted Alice’s kitten pictures to Hacker News, claiming that they’re his own and gaining huge popularity. Alice finds out and needs to revoke his access immediately. <code> # cd /root/ca # openssl ca -config intermediate/openssl.cnf \ -revoke intermediate/certs/bob@example.com.cert.pem </code> The line in index.txt that corresponds to Bob’s certificate now begins with the character R. This means the certificate has been revoked. After revoking Bob’s certificate, Alice must re-create the CRL. === Server-side use of the CRL === For client certificates, it’s typically a server-side application (eg, Apache) that is doing the verification. This application needs to have local access to the CRL. In Alice’s case, she can add the SSLCARevocationPath directive to her Apache configuration and copy the CRL to her web server. The next time that Bob connects to the web server, Apache will check his client certificate against the CRL and deny access. Similarly, OpenVPN has a crl-verify directive so that it can block clients that have had their certificates revoked. === Client-side use of the CRL === For server certificates, it’s typically a client-side application (eg, a web browser) that performs the verification. This application must have remote access to the CRL. If a certificate was signed with an extension that includes crlDistributionPoints, a client-side application can read this information and fetch the CRL from the specified location. The CRL distribution points are visible in the certificate X509v3 details. <code> # openssl x509 -in cute-kitten-pictures.example.com.cert.pem -noout -text </code> ==== Online Certificate Status Protocol ==== The Online Certificate Status Protocol (OCSP) was created as an alternative to certificate revocation lists (CRLs). Similar to CRLs, OCSP enables a requesting party (eg, a web browser) to determine the revocation state of a certificate. When a CA signs a certificate, they will typically include an OCSP server address (eg, http://ocsp.example.com) in the certificate. This is similar in function to crlDistributionPoints used for CRLs. As an example, when a web browser is presented with a server certificate, it will send a query to the OCSP server address specified in the certificate. At this address, an OCSP responder listens to queries and responds with the revocation status of the certificate. Note It’s recommended to use OCSP instead where possible, though realistically you will tend to only need OCSP for website certificates. Some web browsers have deprecated or removed support for CRLs. Prepare the configuration file To use OCSP, the CA must encode the OCSP server location into the certificates that it signs. Use the authorityInfoAccess option in the appropriate sections, which in our case means the [ server_cert ] section. <code> [ server_cert ] # ... snipped ... authorityInfoAccess = OCSP;URI:http://ocsp.example.com </code> === Create the OCSP pair === The OCSP responder requires a cryptographic pair for signing the response that it sends to the requesting party. The OCSP cryptographic pair must be signed by the same CA that signed the certificate being checked. Create a private key and encrypt it with AES-256 encryption. <code> # cd /root/ca # openssl genrsa -aes256 \ -out intermediate/private/ocsp.example.com.key.pem 4096 </code> Create a certificate signing request (CSR). The details should generally match those of the signing CA. The Common Name, however, must be a fully qualified domain name. <code> # cd /root/ca # openssl req -config intermediate/openssl.cnf -new -sha256 \ -key intermediate/private/ocsp.example.com.key.pem \ -out intermediate/csr/ocsp.example.com.csr.pem </code> Sign the CSR with the intermediate CA. <code> # openssl ca -config intermediate/openssl.cnf \ -extensions ocsp -days 375 -notext -md sha256 \ -in intermediate/csr/ocsp.example.com.csr.pem \ -out intermediate/certs/ocsp.example.com.cert.pem </code> Verify that the certificate has the correct X509v3 extensions. <code> # openssl x509 -noout -text \ -in intermediate/certs/ocsp.example.com.cert.pem </code> === Revoke a certificate === The OpenSSL ocsp tool can act as an OCSP responder, but it’s only intended for testing. Production ready OCSP responders exist, but those are beyond the scope of this guide. Create a server certificate to test. <code> # cd /root/ca # openssl genrsa -out intermediate/private/test.example.com.key.pem 2048 # openssl req -config intermediate/openssl.cnf \ -key intermediate/private/test.example.com.key.pem \ -new -sha256 -out intermediate/csr/test.example.com.csr.pem # openssl ca -config intermediate/openssl.cnf \ -extensions server_cert -days 375 -notext -md sha256 \ -in intermediate/csr/test.example.com.csr.pem \ -out intermediate/certs/test.example.com.cert.pem </code> Run the OCSP responder on localhost. Rather than storing revocation status in a separate CRL file, the OCSP responder reads index.txt directly. The response is signed with the OCSP cryptographic pair (using the -rkey and -rsigner options). <code> # openssl ocsp -port 127.0.0.1:2560 -text -sha256 \ -index intermediate/index.txt \ -CA intermediate/certs/ca-chain.cert.pem \ -rkey intermediate/private/ocsp.example.com.key.pem \ -rsigner intermediate/certs/ocsp.example.com.cert.pem \ -nrequest 1 </code> In another terminal, send a query to the OCSP responder. The -cert option specifies the certificate to query. <code> # openssl ocsp -CAfile intermediate/certs/ca-chain.cert.pem \ -url http://127.0.0.1:2560 -resp_text \ -issuer intermediate/certs/intermediate.cert.pem \ -cert intermediate/certs/test.example.com.cert.pem </code> The start of the output shows: * whether a successful response was received (OCSP Response Status) * the identity of the responder (Responder Id) * the revocation status of the certificate (Cert Status) <code> OCSP Response Data: OCSP Response Status: successful (0x0) Response Type: Basic OCSP Response Version: 1 (0x0) Responder Id: ... CN = ocsp.example.com Produced At: Apr 11 12:59:51 2015 GMT Responses: Certificate ID: Hash Algorithm: sha1 Issuer Name Hash: E35979B6D0A973EBE8AEDED75D8C27D67D2A0334 Issuer Key Hash: 69E8EC547F252360E5B6E77261F1D4B921D445E9 Serial Number: 1003 Cert Status: good This Update: Apr 11 12:59:51 2015 GMT </code> Revoke the certificate. <code> # openssl ca -config intermediate/openssl.cnf \ -revoke intermediate/certs/test.example.com.cert.pem </code> As before, run the OCSP responder and on another terminal send a query. This time, the output shows Cert Status: revoked and a Revocation Time. <code> OCSP Response Data: OCSP Response Status: successful (0x0) Response Type: Basic OCSP Response Version: 1 (0x0) Responder Id: ... CN = ocsp.example.com Produced At: Apr 11 13:03:00 2015 GMT Responses: Certificate ID: Hash Algorithm: sha1 Issuer Name Hash: E35979B6D0A973EBE8AEDED75D8C27D67D2A0334 Issuer Key Hash: 69E8EC547F252360E5B6E77261F1D4B921D445E9 Serial Number: 1003 Cert Status: revoked Revocation Time: Apr 11 13:01:09 2015 GMT This Update: Apr 11 13:03:00 2015 GMT </code> ===== Keystore creation from PEM ===== * Create PKCS12 from PEM <code> keytool -v -importkeystore -srckeystore test.p12 -srcstorepass 'AZert12@' -srcstoretype PKCS12 -srcalias '1' -destkeystore test.jks -deststoretype JKS -destalias 'cymerius-tomcat' -storepass 'Changeme123!' </code> ===== Check available algo ===== <code> for i in ssl2 ssl3 tls1 tls1_1 tls1_2; do for c in $(openssl ciphers "ALL:eNULL" | tr ':' ' '); do openssl s_client -connect <server>:<port> -cipher $c -$i < /dev/null > /dev/null 2>&1 && echo -e "$i:\t$c" done done </code> ===== Create p12 from cert and key ===== <code> openssl pkcs12 -export -out certificate.pfx -inkey privateKey.key -in certificate.crt -certfile more.crt </code> cheatsheet/ssl.txt Last modified: 2024/10/14 20:59by 127.0.0.1