Cómo manejar secretos en Python

Vivimos en un mundo donde las aplicaciones se usan para hacer todo, ya sea negociar acciones o reservar un salón, pero la comunicación detrás de escena se realiza usando secretos. Misterios contraseñas de bases de datos, claves API, tokens, etc. debe gestionarse en consecuencia para evitar cualquier infracción.

necesidad de manejo de secretos importante para cualquier organización. Los secretos se pueden filtrar de muchas maneras, incluidos los sistemas de control de versiones (¡nunca codifique ningún secreto en su código!), mensajes privados, correo electrónico y otros canales de comunicación. Si se filtran secretos, puede provocar la pérdida de confianza, credibilidad e incluso negocios (puede averiguar por qué) aquí). En algunos casos, los secretos filtrados también pueden dar lugar a acciones legales. Por eso es tan importante tener un plan para gestionar los secretos.

En este artículo, discutiremos 4 formas diferentes de administrar de manera eficiente los secretos en Python.

requisitos previos

Antes de comenzar, hay algunas cosas que debe tener en cuenta para evitar problemas más adelante.

• Python y pip están instalados en su máquina
• Comprensión de Python y CLI
• Un IDE de Python como PyCharm o VS Code
• Una comprensión básica de la nube

4 formas de administrar secretos en Python

En esta sección, discutiremos 4 formas diferentes de administrar sus secretos en Python.

1. Desde el archivo

Usando el archivo .env

Él .env file es un archivo utilizado para almacenar variables de entorno en Python. Las variables de entorno son variables que se definen fuera del código de Python y se utilizan para configurar el código de Python. El archivo .env generalmente se usa para almacenar claves privadas y contraseñas.

usaremos python-dotenv paquete para acceder a su contenido .env expediente. Para comenzar, primero instale el paquete usando el siguiente comando.

$ pip install python-dotenv

Crear .env para fines de prueba, abra el archivo y pegue los siguientes secretos:

API_KEY=test-key
API_SECRET=test-secret

¡Por supuesto, este archivo no debe estar comprometido con su repositorio de git! De lo contrario, se versionará y se podrá leer incluso después de eliminarlo.

Agrega esto a tu línea .gitignore expediente:

.env

Ya entregó el expediente.? No te preocupes, sigue las instrucciones aquí:

Git Clean, Uncommit Git File – Cheatsheet – GitGuardian Blog

Exponer secretos en un repositorio de Git es malo, pero ocurren errores. Esta es una guía completa y una hoja de trucos para sobrescribir y eliminar archivos del historial de git

Una vez hecho esto, cree el archivo main.py y péguelo debajo del fragmento de código mencionado. En este código usamos load_dotenv() función para descargar contenido .env expediente.

from dotenv import load_dotenv
import os

load_dotenv()

api_key = os.getenv("API_KEY")
api_secret = os.getenv("API_SECRET")

print("API_KEY: ", api_key)
print("API_SECRET: ", api_secret)

También podemos usarlo dotenv_values() una función que convierte un secreto en un diccionario. Se puede acceder a los secretos utilizando el siguiente fragmento de código:

from dotenv import dotenv_values

secrets = dotenv_values(".env")

def main():
   print(secrets["API_KEY"])
   print(secrets["API_SECRET"])

if __name__ == "__main__":
   main()

Cuando trabaje en un proyecto grande, es posible que necesite más de una .env archivos Por ejemplo, usted puede tener .env archivo para su entorno de desarrollo local y un .env.dev para su entorno de producción de desarrollo en la nube. Si tiene muchos archivos env, el siguiente fragmento de código puede ser útil.

from dotenv import dotenv_values

secrets = dotenv_values(".env")
local_secrets = dotenv_values(".env.dev")

def main():
   print(secrets["API_KEY"])
   print(local_secrets["API_SECRET"])

if __name__ == "__main__":
   main()

Usando un archivo JSON

También puede usar un archivo JSON para mantener los secretos más organizados. vamos a crear un secrets.json archivo y pegue los siguientes secretos en él.

{
   "db": {
       "host": "localhost",
       "port": 27017,
       "name": "test"
   },
   "server": {
       "host": "localhost",
       "port": 3000
   }
}

Ahora que tenemos nuestro archivo JSON listo, escribamos una función para acceder a los secretos del archivo:

# main.py
import json

def get_value_from_json(json_file, key, sub_key):
   try:
       with open(json_file) as f:
           data = json.load(f)
           return data[key][sub_key]
   except Exception as e:
       print("Error: ", e)
       
print(get_value_from_json("secrets.json", "db", "host")) # prints localhost

2. Uso de variables de entorno

Las variables de entorno son variables que establece el sistema operativo o un usuario específico y que los programas utilizan para definir varias configuraciones. Podemos usar estas variables para almacenar nuestros secretos y luego acceder a ellos en nuestro programa. Puede usar la siguiente sintaxis para crear una variable de entorno en una máquina MacOS o Linux.

$ export variable_name=value
$ export API_KEY_TEST=dummykey

En una máquina con Windows, usa la GUI para agregar variables de entorno, o usa el siguiente comando para agregar una variable.

$ setx [variable_name] “[value]”

Puede usar el paquete os para acceder a la variable de entorno os. A continuación se muestra el código de muestra:

import os

# Get the secret key from the environment
secret_key = os.environ.get('api_key_test')
print(secret_key) // prints dummykey

¡Los secretos en la línea de comando también deben manejarse con especial cuidado! Echa un vistazo a las mejores prácticas al respecto:

Secretos en la línea de comando [cheat sheet included]

Los desarrolladores deben evitar que las credenciales queden expuestas cuando trabajan en la línea de comandos. Aprenda cómo podría estar en riesgo y qué herramientas y técnicas pueden ayudarlo a trabajar de manera más segura.

3. Usa el administrador de secretos en la nube

La mayoría de los proveedores de servicios en la nube ofrecen un administrador de secretos integrado que se puede usar para crear y usar secretos en toda la infraestructura de la nube. Siguientes administradores secretos ofrecidos por los proveedores de la nube:

AWS Secrets Manager se utiliza ampliamente en todo el sector. Escribamos una función para generar y acceder al secreto usando AWS Boto3.

import boto3

def fetch_secret_from_aws(secret_name):
   try:
       session = boto3.session.Session()
       client = session.client(service_name='secretsmanager', region_name='us-east-1')
       get_secret_value_response = client.get_secret_value(SecretId=secret_name)
       return get_secret_value_response['SecretString']
   except Exception as e:
       print(e)
       return None
       
def create_secret_in_aws(secret_name, secret_value):
   try:
       session = boto3.session.Session()
       client = session.client(service_name='secretsmanager', region_name='us-east-1')
       client.create_secret(Name=secret_name, SecretString=secret_value)
       return True
   except Exception as e:
       print(e)
       return False

4. Uso de KMS

Un KMS es un sistema de gestión de claves que se utiliza para gestionar claves criptográficas. Se usa comúnmente en organizaciones para administrar y proteger claves de manera centralizada. KMS se puede utilizar para generar, almacenar y distribuir claves. También se puede usar para revocar claves y monitorear el uso de claves.

KMS es una forma conveniente de administrar de forma centralizada las claves utilizadas por sus aplicaciones y servicios, lo que ayuda a garantizar que solo los usuarios autorizados tengan acceso a ellas.

Hashicorp Vault es uno de los mejores KMS de código abierto disponibles en el mercado y ofrece una serie de características y beneficios, incluida la capacidad de administrar secretos y claves en múltiples entornos, sólidos controles de seguridad y buena escalabilidad.

Escribamos una función para leer y escribir secretos en una ruta específica en Vault.

import hvac

def read_secret_from_vault(secret_path, token, secret_name):
   try:
       client = hvac.Client(
           url='http://localhost:8200',
           token=token,
       )
       read_response = client.secrets.kv.read_secret_version(path=secret_path)
       return read_response['data']['data'][secret_name]
   except Exception as e:
       print(e)
       return None

def write_secret_to_vault(secret_path, token, secret_name, secret_value):
   try:
       client = hvac.Client(
           url='http://localhost:8200',
           token=token,
       )
       create_response = client.secrets.kv.v2.create_or_update_secret(
           path=secret_path,
           secret={secret_name: secret_value},
       )
       return create_response
   except Exception as e:
       print(e)
       return None

no lo envuelvas

La gestión de secretos es una parte importante del desarrollo de software. Cuando los desarrolladores codifican secretos de texto sin formato en sus aplicaciones, se crea una posible brecha de seguridad. Si se descubren esos secretos, un atacante puede utilizar esos secretos para obtener acceso a información confidencial.

Otra alternativa a los métodos sugeridos aquí es verificar los secretos en el código fuente y compartirlos con su equipo. encriptado. Si aprende a usar una herramienta como Mozilla, esta puede ser una solución muy flexible SOP. Lea esta guía para obtener más información sobre SOPS y comenzar a usarlo:

Una guía completa de SOPS: administre sus secretos como un visionario, no como un funcional

¿Has oído hablar de SOPS? Si alguna vez ha estado en una situación en la que necesitaba compartir información confidencial con sus compañeros de equipo, esto es para usted.

¿Sabía usted que? GitGuardian descubre más de 16,000 secretos codificados en GitHub todos los días? Cuando se descubre un secreto, GitGuardian notifica al propietario del repositorio para que pueda tomar medidas para proteger sus datos.

Si desea ver mejor cuántos secretos se pueden ocultar en sus bóvedas, inscribirse (gratis) o pedir una demostración ¡Acceda a la plataforma GitGuardian para escanear cada compromiso y tomar medidas preventivas ahora!

*** Este es un blog sindicado de Security Bloggers Network Blog de GitGuardian – Detección de secretos automatizada es el autor Experto invitado. Lea la publicación original aquí: https://blog.gitguardian.com/how-to-handle-secrets-in-python/