Contributing back to Ansible — flexible secrets with some Sops
Tags: ansible, opensource, mozilla, secrets
Published: 2019-12-11 08:26:43

_This blog post has been published originally on Arduino blog:_ https://blog.arduino.cc/2019/12/04/contributing-back-to-ansible-flexible-secrets-with-some-sops/

_This post is from Edoardo Tenani, DevOps Engineer at Arduino._

![Post header image](https://blog.arduino.cc/wp-content/uploads/2019/12/Ansible-1024x589.png)

**In this blog, we’re going to answer: How does one store sensitive data in source code (in this case, Ansible playbooks) securely and in a way that the secrets can be easily shared with the rest of the team?**

> Ansible is an open source community project sponsored by Red Hat, it’s the simplest way to automate IT. Ansible is the only automation language that can be used across entire IT teams from systems and network administrators to developers and managers.

At Arduino, we started using Ansible around the beginning of 2018 and since then, most of our infrastructure has been provisioned via Ansible playbooks: from the frontend servers hosting our websites and applications (such as [Create Web Editor](https://create.arduino.cc/editor/)), to the MQTT broker at the heart of Arduino IoT Cloud.

As soon as we started adopting it, we faced one of the most common security problems in software: How does one store sensitive data in source code (in this case, Ansible playbooks) securely and in a way that the secrets can be easily shared with the rest of the team?

Ansible configuration system comes to the rescue here with its built-in mechanism for handling secrets called [Ansible Vault](https://docs.ansible.com/ansible/latest/user_guide/vault.html), but unfortunately it had some shortcomings for our use case.

The main disadvantage is that Vault is tied to Ansible system itself: In order to use it, you have to install the whole Ansible stack. We preferred a more self-contained solution, possibly compiled in a single binary to ease portability (i.e. inside Docker containers).

The second blocker is the “single passphrase” Ansible Vault relies on: a shared password to decrypt the entire vault. This solution is very handy and simple to use for personal projects or when the team is small, but as we are constantly growing as a company we preferred to rely on a more robust and scalable encryption strategy. Having the ability to encrypt different secrets with different keys, while being able to revoke access to specific users or machines at any time was crucial to us.

The first solution we identified has been [Hashicorp Vault](https://www.vaultproject.io/), a backend service purposely created for storing secrets and sensitive data with advanced encryption policies and access management capabilities. In our case, as the team was still growing, the operational cost of maintaining our Vault cluster was considered too high (deploying a High Available service that acts as a single point of failure for your operations is something we want to handle properly and with due care).

Around that same time, while reading industry’s best practices and looking for something that could help us managing secrets in source code, we came across mozilla/sops, a simple command line tool that allows strings and files to be encrypted using a combination of AWS KMS keys, GCP KMS keys or GPG keys.

Around that same time, while reading industry’s best practices and looking for something that could help us managing secrets in source code, we came across [**mozilla/sops**](https://github.com/mozilla/sops), a simple command line tool that allows strings and files to be encrypted using a combination of AWS KMS keys, GCP KMS keys or GPG keys.

Sops seemed to have all the requirements we were looking for to replace Ansible Vault:

- A single binary, thanks to the porting from Python to Golang that Mozilla recently did.
- Able to encrypt and decrypt both entire files and single values.
- Allow us to use identities coming from AWS KMS, identities that we already used for our web services and where our operations team had access credentials.
- A fallback to GPG keys to mitigate the AWS lock-in, allowing us to decrypt our secrets even in the case of AWS KMS disruption.
- The same low operational cost.

Sops’ adoption was a great success: The security team was happy and the implementation straightforward, with just one problem. When we tried to use Sops in Ansible configuration system, we immediately noticed what a pain it was to encrypt variables.

We tried to encrypt/decrypt single values using a helper script to properly pass them as extra variables to ansible-playbook. It almost worked, but developers and operations were not satisfied: It led to errors during development and deployments and overall felt clumsy and difficult.

Next we tried to encrypt/decrypt entire files. The helper script was still needed, but the overall complexity decreased. The main downside was that we needed to decrypt all the files prior to running ansible-playbook because Ansible system didn’t have any clue about what was going on: those were basically plain ansible var_files. It was an improvement, but still lacking the smooth developer experience we wanted.

As Ansible configuration system already supports encrypted vars and storing entire files in Ansible Vault, the obvious choice was to identify how to replicate the behaviour using Sops as the encryption/decryption engine.

Following an idea behind a feature request first opened upstream in the Ansible repository back in 2018 ([Integration with Mozilla SOPS for encrypted vars](https://github.com/ansible/ansible/issues/36982)), we developed a lookup plugin and a vars plugin that seamlessly integrate Ansible configuration system and Sops.

## No more helper scripts needed

Just ensure Sops executable is installed, correct credentials are in place (ie. AWS credentials or GPG private key) and run ansible-playbook as you normally would.

We believe contributing to a tool we use and love is fundamental in following the Arduino philosophy of spreading the love for open source. 

Our sops plugins are currently under review in the **ansible/ansible** GitHub repository: [Add sops lookup plugin](https://github.com/ansible/ansible/pull/59639) and [Add sops vars plugin](https://github.com/ansible/ansible/pull/59641). 

You can test it out right away by downloading the plugin files from the PRs and [adding them in your local Ansible controller installation](https://docs.ansible.com/ansible/latest/dev_guide/developing_locally.html). You will then be able to use both plugins from your playbooks. Documentation is available, as for all Ansible plugins, in the code itself at the beginning of the file; search for _DOCUMENTATION_ if you missed it.

If you can leave a comment or a GitHub reaction on the PR, that would be really helpful to expedite the review process.

## What to do from now on?

If you’re a developer you can have a look at Sops’ [issues list](https://github.com/mozilla/sops/issues) and contribute back to the project!

The Sops team is constantly adding new features (like a new command for publishing encrypted secrets in latest [3.4.0 release](https://github.com/mozilla/sops/releases/tag/3.4.0), or Azure Key Vault support) but surely there are interesting issues to tackle. For example, the Kubernetes Secret integration being discussed in issue [401](https://github.com/mozilla/sops/issues/401) or the –verify command discussed in issue [437](https://github.com/mozilla/sops/issues/437).

Made with <3 by the Arduino operations team!

_Ansible® is a registered trademark of Red Hat, Inc. in the United States and other countries._