Post Syndicated from Derek Tumulak original https://aws.amazon.com/blogs/security/how-to-run-aws-cloudhsm-workloads-on-docker-containers/

January 25, 2023: We updated this post to reflect the fact that CloudHSM SDK3 does not support serverless environments and we strongly recommend deploying SDK5.

AWS CloudHSM provides hardware security modules (HSMs) in the AWS Cloud. With CloudHSM, you can generate and use your own encryption keys in the AWS Cloud, and manage your keys by using FIPS 140-2 Level 3 validated HSMs. Your HSMs are part of a CloudHSM cluster. CloudHSM automatically manages synchronization, high availability, and failover within a cluster.

CloudHSM is part of the AWS Cryptography suite of services, which also includes AWS Key Management Service (AWS KMS), AWS Secrets Manager, and AWS Private Certificate Authority (AWS Private CA). AWS KMS, Secrets Manager, and AWS Private CA are fully managed services that are convenient to use and integrate. You’ll generally use CloudHSM only if your workload requires single-tenant HSMs under your own control, or if you need cryptographic algorithms or interfaces that aren’t available in the fully managed alternatives.

CloudHSM offers several options for you to connect your application to your HSMs, including PKCS#11, Java Cryptography Extensions (JCE), OpenSSL Dynamic Engine, or Microsoft Cryptography API: Next Generation (CNG). Regardless of which library you choose, you’ll use the CloudHSM client to connect to HSMs in your cluster.

In this blog post, I’ll show you how to use Docker to develop, deploy, and run applications by using the CloudHSM SDK, and how to manage and orchestrate workloads by using tools and services like Amazon Elastic Container Service (Amazon ECS), Kubernetes, Amazon Elastic Kubernetes Service (Amazon EKS), and Jenkins.

Solution overview

This solution demonstrates how to create a Docker container that uses the CloudHSM JCE SDK to generate a key and use it to encrypt and decrypt data.

Note: In this example, you must manually enter the crypto user (CU) credentials as environment variables when you run the container. For production workloads, you’ll need to consider how to secure and automate the handling and distribution of these credentials. You should work with your security or compliance officer to ensure that you’re using an appropriate method of securing HSM login credentials. For more information on securing credentials, see AWS Secrets Manager.

Figure 1 shows the solution architecture. The Java application, running in a Docker container, integrates with JCE and communicates with CloudHSM instances in a CloudHSM cluster through HSM elastic network interfaces (ENIs). The Docker container runs in an EC2 instance, and access to the HSM ENIs is controlled with a security group.

Figure 1: Architecture diagram

Prerequisites

To implement this solution, you need to have working knowledge of the following items:

• CloudHSM
• Docker 20.10.17 – used at the time of this post
• Java 8 or Java 11 – supported at the time of this post
• Maven 3.05 – used at the time of this post

Here’s what you’ll need to follow along with my example:

1. An active CloudHSM cluster with at least one active HSM instance. You can follow the CloudHSM getting started guide to create, initialize, and activate a CloudHSM cluster.
   
   

   Note: For a production cluster, you should have at least two active HSM instances spread across Availability Zones in the Region.

2. An Amazon Linux 2 EC2 instance in the same virtual private cloud (VPC) in which you created your CloudHSM cluster. The Amazon Elastic Compute Cloud (Amazon EC2) instance must have the CloudHSM cluster security group attached—this security group is automatically created during the cluster initialization and is used to control network access to the HSMs. To learn about attaching security groups to allow EC2 instances to connect to your HSMs, see Create a cluster in the AWS CloudHSM User Guide.
3. A CloudHSM crypto user (CU) account. You can create a CU by following the steps in the topic Managing HSM users in AWS CloudHSM in the AWS CloudHSM User Guide.

Solution details

In this section, I’ll walk you through how to download, configure, compile, and run a solution in Docker.

To set up Docker and run the application that encrypts and decrypts data with a key in AWS CloudHSM

1. On your Amazon Linux EC2 instance, install Docker by running the following command.

   # sudo yum -y install docker

2. Start the docker service.

   # sudo service docker start

3. Create a new directory and move to it. In my example, I use a directory named cloudhsm_container. You’ll use the new directory to configure the Docker image.

   # mkdir cloudhsm_container
# cd cloudhsm_container

4. Copy the CloudHSM cluster’s trust anchor certificate (customerCA.crt) to the directory that you just created. You can find the trust anchor certificate on a working CloudHSM client instance under the path /opt/cloudhsm/etc/customerCA.crt. The certificate is created during initialization of the CloudHSM cluster and is required to connect to the CloudHSM cluster. This enables our application to validate that the certificate presented by the CloudHSM cluster was signed by our trust anchor certificate.
5. In your new directory (cloudhsm_container), create a new file with the name run_sample.sh that includes the following contents. The script runs the Java class that is used to generate an Advanced Encryption Standard (AES) key to encrypt and decrypt your data.

   #! /bin/bash
   
   # start application
   echo -e "\n* Entering AES GCM encrypt/decrypt sample in Docker ... \n"
   
   java -ea -jar target/assembly/aesgcm-runner.jar -method environment
   
   echo -e "\n* Exiting AES GCM encrypt/decrypt sample in Docker ... \n"

6. In the new directory, create another new file and name it Dockerfile (with no extension). This file will specify that the Docker image is built with the following components:
   • The CloudHSM client package.
   • The CloudHSM Java JCE package.
   • OpenJDK 1.8 (Java 8). This is needed to compile and run the Java classes and JAR files.
   • Maven, a build automation tool that is needed to assist with building the Java classes and JAR files.
   • The AWS CloudHSM Java JCE samples that will be downloaded and built as part of the solution.
7. Cut and paste the following contents into Dockerfile.
   
   

   Note: You will need to customize your Dockerfile, as follows:

   • Make sure to specify the SDK version to replace the one specified in the pom.xml file in the sample code. As of the writing of this post, the most current version is 5.7.0. To find the SDK version, follow the steps in the topic Check your client SDK version. For more information, see the Building section in the README file for the Cloud HSM JCE examples.
   • Make sure to update the HSM_IP line with the IP of an HSM in your CloudHSM cluster. You can get your HSM IPs from the CloudHSM console, or by running the describe-clusters AWS CLI command.

     	# Use the amazon linux image
     	FROM amazonlinux:2
     
     	# Pass HSM IP address as a build argument
     	ARG HSM_IP
     
     	# Install CloudHSM client
     	RUN yum install -y https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-jce-latest.el7.x86_64.rpm
     
     	# Install Java, Maven, wget, unzip and ncurses-compat-libs
     	RUN yum install -y java maven wget unzip ncurses-compat-libs
             
     	# Create a work dir
     	WORKDIR /app
             
     	# Download sample code
     	RUN wget https://github.com/aws-samples/aws-cloudhsm-jce-examples/archive/refs/heads/sdk5.zip
             
     	# unzip sample code
     	RUN unzip sdk5.zip
            
     	# Change to the create directory
     	WORKDIR aws-cloudhsm-jce-examples-sdk5
     
     # Build JAR files using the installed CloudHSM JCE Provider version
     RUN export CLOUDHSM_CLIENT_VERSION=`rpm -qi cloudhsm-jce | awk -F': ' '/Version/ {print $2}'` \
             && mvn validate -DcloudhsmVersion=$CLOUDHSM_CLIENT_VERSION \
             && mvn clean package -DcloudhsmVersion=$CLOUDHSM_CLIENT_VERSION
             
       # Configure cloudhsm-client
       COPY customerCA.crt /opt/cloudhsm/etc/
       RUN /opt/cloudhsm/bin/configure-jce -a $HSM_IP
            
       # Copy the run_sample.sh script
       COPY run_sample.sh .
             
       # Run the script
       CMD ["bash","run_sample.sh"]

8. Now you’re ready to build the Docker image. Run the following command, with the name jce_sample. This command will let you use the Dockerfile that you created in step 6 to create the image.

   # sudo docker build --build-arg HSM_IP=”<your HSM IP address>” -t jce_sample .

9. To run a Docker container from the Docker image that you just created, run the following command. Make sure to replace the user and password with your actual CU username and password. (If you need help setting up your CU credentials, see prerequisite 3. For more information on how to provide CU credentials to the AWS CloudHSM Java JCE Library, see Providing credentials to the JCE provider in the CloudHSM User Guide).

   # sudo docker run --env HSM_USER=<user> --env HSM_PASSWORD=<password> jce_sample

   If successful, the output should look like this:

   	* Entering AES GCM encrypt/decrypt sample in Docker ... 
   
   	737F92D1B7346267D329C16E
   	Successful decryption
   
   	* Exiting AES GCM encrypt/decrypt sample in Docker ...

Conclusion

This solution provides an example of how to run CloudHSM client workloads in Docker containers. You can use the solution as a reference to implement your cryptographic application in a way that benefits from the high availability and load balancing built in to CloudHSM without compromising the flexibility that Docker provides for developing, deploying, and running applications.

If you have comments about this post, submit them in the Comments section below.

Want more AWS Security how-to content, news, and feature announcements? Follow us on Twitter.