thoughtworks/talismanEscáner de secretos basado en hooks de Git que detecta tokens, contraseñas y claves privadas en conjuntos de cambios salientes, evitando que datos sensibles sean confirmados o enviados a repositorios.
Una herramienta para detectar y prevenir que se introduzcan secretos en el repositorio
Talisman es una herramienta que escanea los conjuntos de cambios de git para asegurar que posibles secretos o información sensible no salgan de la estación de trabajo del desarrollador.
Valida el conjunto de cambios saliente en busca de elementos que parezcan sospechosos, como posibles claves SSH, tokens de autorización, claves privadas, etc.
Talisman soporta macOS, Linux y Windows.
Talisman se puede instalar y utilizar de las siguientes maneras:
Talisman se puede configurar como un hook pre-commit o pre-push en los repositorios de git.
Encuentre las instrucciones a continuación.
Descargo de responsabilidad: Los secretos que se introduzcan mediante un forced push en un repositorio git no pueden ser detectados por Talisman. Se considera que un forced push es notoriamente problemático, y sugerimos a los administradores de repositorios git que tomen las medidas apropiadas para autorizar dichas actividades.
Recomendamos instalar talisman en su PATH para que esté disponible para frameworks de hooks de git y scripts. Elija el binario correcto para su sistema desde nuestra Página de lanzamientos, o ejecute nuestro script de instalación:```bash
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
O establece la variable de entorno `INSTALL_LOCATION` para especificar una ubicación personalizada para
el binario:```bash
INSTALL_LOCATION=/usr/local/bin bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
O establezca la variable de entorno VERSION a una etiqueta publicada para instalar una versión específica::```bash
VERSION=v1.36.0 bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
O usando linuxbrew en Linux y homebrew en macOS ejecutando el siguiente comando en la terminal:```bash
brew install talisman
Ofrecemos scripts que instalarán Talisman como una plantilla de hook pre-commit de git, ya que eso hará que Talisman esté presente, no solo en tus repositorios git existentes, sino también en cualquier nuevo repositorio que 'init' o 'clone'.
Como un hook pre-commit: ``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)"
O
Como un hook pre-push: ```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)" -- pre-push
$PATH, se te preguntará un lugar apropiado para configurarlo. Elige el número de opción donde estableces la fuente del perfil en tu máquina.Recuerda ejecutar source en el archivo de ruta o reiniciar tu terminal.
Si eliges configurar el $PATH más tarde, exporta TALISMAN_HOME=$HOME/.talisman/bin a la ruta.
Instalar globalmente talisman como un hook no sobrescribirá ningún hook existente. Si el script de instalación encuentra hooks existentes, solo lo indicará en la consola. Para ejecutar múltiples hooks, sugerimos usar un marco de hooks, como pre-commit o husky. Estas instrucciones asumen que el ejecutable de talisman está instalado en algún lugar del path de tu sistema.
Usa pre-commit para gestionar hooks existentes junto con Talisman. Referencia nuestro pre-commit-hooks en tu .pre-commit-config.yaml:```yaml
### Husky
[husky](https://typicode.github.io/husky) es un módulo npm para gestionar hooks.
Añade la siguiente línea a la configuración de pre-commit de husky en tu
`package.json`:```
talisman --githook pre-commit
Una vez que el ejecutable de talisman está instalado puedes configurar un hook pre-commit independiente para un repositorio de git:```bash cd my-git-project echo "talisman -g pre-commit" >> .git/hooks/pre-commit chmod +x .git/hooks/pre-commit
# Actualización
Desde la versión v0.4.4, Talisman <b>actualiza automáticamente</b> el binario a la última versión cuando se invoca el hook (en pre-commit/pre-push, según la configuración). Así que siéntese, relájese y siga usando la última versión de Talisman sin esfuerzo adicional.
Se pueden establecer las siguientes variables de entorno:
1. TALISMAN_SKIP_UPGRADE: Establézcase a true si desea saltar la verificación automática de actualización. El valor predeterminado es false.
2. TALISMAN_UPGRADE_CONNECT_TIMEOUT: Tiempo máximo de espera de conexión antes de cancelar la actualización (en segundos). El valor predeterminado es 10 segundos.
Si en algún caso necesita actualizar manualmente, aquí están los pasos:
<br>[Recomendado] Actualice el binario de Talisman y los scripts de hook a la última versión:```bash
curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/update_talisman.bash > /tmp/update_talisman.bash && /bin/bash /tmp/update_talisman.bash
Actualice solo el binario de Talisman ejecutando:```bash curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/update_talisman.bash > /tmp/update_talisman.bash && /bin/bash /tmp/update_talisman.bash talisman-binary
# Talisman en acción
Después de una instalación exitosa, Talisman ejecutará automáticamente comprobaciones de secretos obvios antes de cada commit o push (según lo elegido durante la instalación). En caso de que se detecten violaciones de seguridad, talisman mostrará un informe detallado de los errores:```bash
$ git push
Talisman Report:
+-----------------+-------------------------------------------------------------------------------+
| FILE | ERRORS |
+-----------------+-------------------------------------------------------------------------------+
| danger.pem | The file name "danger.pem" |
| | failed checks against the |
| | pattern ^.+\.pem$ |
+-----------------+-------------------------------------------------------------------------------+
| danger.pem | Expected file to not contain hex encoded texts such as: |
| | awsSecretKey=c64e8c79aacf5ddb02f1274db2d973f363f4f553ab1692d8d203b4cc09692f79 |
+-----------------+-------------------------------------------------------------------------------+
En el ejemplo anterior, el archivo danger.pem ha sido marcado como una violación de seguridad debido a las siguientes razones:
Si ha instalado Talisman como un hook de pre-commit, solo escaneará el diff dentro de cada commit. Esto significa que solo reportará errores para las partes del archivo que fueron modificadas.
En caso de que haya instalado Talisman como un hook de pre-push, escaneará el archivo completo en el que se realizan cambios. Como se mencionó anteriormente, se recomienda usar Talisman como un hook de pre-commit.
Los siguientes detectores se ejecutan sobre los conjuntos de cambios para detectar secretos/información sensible:
Si realmente está seguro de que desea enviar ese archivo, puede configurarlo en el archivo .talismanrc en la raíz del proyecto. El contenido necesario para ignorar sus archivos fallidos será impreso por Talisman en la consola inmediatamente después del Informe de error de Talisman:
scope:node-project,node-modules:node_modules
Ejemplo de .talismanrc:
filefilterconfig:
- filename: 'package-lock.json'
checksum: '2f0a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f2a'
- filename: 'yarn.lock'
checksum: '3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b'
Puede ignorar archivos o palabras clave usando los filtros por nombre de archivo o alcance.```bash If you are absolutely sure that you want to ignore the above files from talisman detectors, consider pasting the following format in .talismanrc file in the project root fileignoreconfig:
Al ingresar esto en el archivo `.talismanrc`, se asegurará de que Talisman ignore el archivo `danger.pem` siempre que el checksum coincida con el valor mencionado en el campo `checksum`.
### Modo interactivo
**Disponible solo para usuarios que no sean de Windows**
Si es demasiado complicado tener que copiar contenido a .talismanrc cada vez que encuentras un error de Talisman, puedes habilitar el modo interactivo y dejar que Talisman te ayude sugiriendo la adición de los archivos a ignorar.
Solo sigue estos simples pasos:
1. Abre tu perfil de bash donde se configuran tus variables de entorno (.bashrc, .bash_profile, .profile o cualquier otra ubicación)
2. Verás la variable `TALISMAN_INTERACTIVE` debajo de `# >>> talisman >>>`
3. Si aún no está configurada como true, agrega `export TALISMAN_INTERACTIVE=true`
4. No olvides guardar y aplicar los cambios al archivo (source)
¡Eso es todo! Cada vez que el hook de Talisman encuentre un error durante pre-push/pre-commit, solo sigue las instrucciones que Talisman sugiera.
Ten cuidado de no ignorar un archivo sin verificar su contenido. Debes estar seguro de que no se está filtrando ningún secreto.
### Ignorando detectores específicos
A continuación se muestra una descripción detallada de los diversos campos que se pueden configurar en el archivo `.talismanrc`:
* `filename` : Este campo debe mencionar el nombre de archivo completamente calificado.
* `checksum` : Este campo siempre debe tener el valor especificado por Talisman en el mensaje mostrado anteriormente. Si en algún momento se realiza un nuevo cambio en el archivo, resultará en un nuevo checksum y Talisman escaneará nuevamente el archivo en busca de posibles amenazas de seguridad.
* `ignore_detectors` : Este campo deshabilitará detectores específicos para un archivo en particular.
Por ejemplo, si el nombre de archivo `init-env.sh` genera una advertencia, puedes deshabilitar solo esta advertencia mientras sigues siendo alertado si otras cosas salen mal (por ejemplo, el contenido del archivo):```yaml
fileignoreconfig:
- filename: init-env.sh
checksum: cf97abd34cebe895417eb4d97fbd7374aa138dcb65b1fe7f6b6cc1238aaf4d48
ignore_detectors: [filename, filesize]
Nota: Aquí tanto los detectores de nombre de archivo como de tamaño de archivo se ignoran para init-env.sh, pero
el detector de contenido de archivo seguirá activándose en init-env.sh
Por el momento, puedes ignorar
filecontentfilenamefilesizeDebido a que algunos de tus archivos pueden contener palabras clave como key o pass que no están necesariamente relacionadas con secretos, es posible que desees ignorar estas palabras clave para reducir el número de falsos positivos.
Esto se puede lograr utilizando el campo allowed_patterns a nivel de archivo y/o a nivel de repositorio:```yaml
fileignoreconfig:
En el ejemplo anterior, se permite `key` en el archivo `test`, `keyword` y `pass` están permitidos a nivel de repositorio.
El campo `allowed_patterns` también admite expresiones regulares de Golang. Aquí hay un ejemplo de código simple donde RegExp de Golang puede ser útil:```sh
export AWS_ACCESS_KEY_ID = AKIAIO5FODNN7EXAMPLE
export AWS_ACCESS_KEY_ID=$(vault read -field=value path/to/aws-access-key-id)
Por defecto, Talisman alertará sobre ambas líneas. En la segunda línea, estamos extrayendo el ID de la Clave de Acceso AWS de Hashicorp Vault, que no expone el secreto al código. Si este tipo de uso es común en tu código, es posible que quieras indicarle a Talisman que no alerte cuando uses un Vault. Esto se puede lograr con una configuración como:```yaml allowed_patterns:
### Ignorar múltiples archivos del mismo tipo (con comodines)
Puedes optar por ignorar todos los archivos de un tipo determinado, porque sabes que siempre serán seguros y no querrías que Talisman los escanee.
Pasos:
1. Formatea un patrón de comodín para los archivos que deseas ignorar. Por ejemplo, `*.lock`
2. Usa la [calculadora de checksum](#checksum-calculator) para alimentar el patrón y obtener un checksum colectivo. Por ejemplo, `talisman --checksum="*.lock" `
3. Copia el bloque fileconfig, impreso en la consola, al archivo .talismanrc.
Si alguno de los archivos se modifica, talisman escaneará los archivos nuevamente, a menos que recalcules el nuevo checksum y lo reemplaces en el archivo .talismanrc.
### Ignorar archivos especificando el alcance del lenguaje
Puedes optar por ignorar archivos especificando el alcance del lenguaje para tu proyecto en tu talismanrc.```yaml
scopeconfig:
- scope: go
- scope: node
- scope: images
- scope: php
- scope: python
Talisman está configurado para ignorar ciertos archivos según el alcance especificado. Por ejemplo, mencionar el alcance node en el scopeconfig evitará que talisman escanee archivos como yarn.lock o package-lock.json.
Puedes especificar múltiples alcances.
Actualmente .talismanrc solo admite soporte de scopeconfig para go, node, php e images. Otros alcances se agregarán próximamente.
Puedes especificar patrones regex personalizados para buscar en el repositorio actual```yaml custom_patterns:
<br/><i>
**Nota**: El uso de .talismanignore ha sido obsoleto. El archivo .talismanrc lo reemplaza porque:
* .talismanrc tiene un formato yaml mucho más legible
* También trae prácticas más seguras con cada modificación de un archivo con un valor potencialmente sensible que debe ser revisado
* El nuevo formato también trae la extensibilidad para introducir nuevas funcionalidades utilizables. Mantente atento para más </i>
## Configurando el umbral de severidad
Cada validación está asociada a una severidad
1. Bajo
2. Medio
3. Alto
Puedes especificar un umbral en tu .talismanrc:```yaml
threshold: medium
Esto reportará todos los problemas de gravedad Media y superiores (Los riesgos potenciales que estén por debajo del umbral se reportarán en las advertencias)
Puedes personalizar los niveles de seguridad de los detectores proporcionados por Talisman en el archivo .talismanrc:```yaml custom_severities:
Al usar severidades personalizadas y un umbral de severidad, Talisman se puede configurar para alertar solo sobre lo que es importante según su contexto. Esto puede ser útil para reducir la cantidad de falsos positivos.
## Talisman como utilidad de línea de comandos
Si ejecuta `talisman` en la línea de comandos, podrá ver todas las opciones de parámetros que puede pasar```
-c, --checksum string checksum calculator calculates checksum and suggests .talismanrc format
-d, --debug enable debug mode (warning: very verbose)
-g, --githook string either pre-push or pre-commit (default "pre-push")
--ignoreHistory scanner scans all files on current head, will not scan through git commit history
-i, --interactive interactively update talismanrc (only makes sense with -g/--githook)
-p, --pattern string pattern (glob-like) of files to scan (ignores githooks)
-r, --reportdirectory string directory where the scan reports will be stored
-s, --scan scanner scans the git commit history for potential secrets
-w, --scanWithHtml generate html report (**Make sure you have installed talisman_html_report to use this, as mentioned in Readme**)
-v, --version show current version of talisman
Cuando tienes regularmente demasiados archivos que son señalados por el hook de talisman, que sabes que deberían estar bien para hacer commit, puedes usar esta función para que talisman te facilite el proceso. El modo interactivo permitirá que Talisman te solicite directamente agregar archivos que deseas ignorar a .talismanrc desde el símbolo del sistema. Para habilitar esta función, necesitas que la variable TALISMAN_INTERACTIVE esté configurada como true en tu archivo bash.
Puedes invocar talisman en modo interactivo de cualquiera de las 2 maneras:
Abre tu archivo bash y agregaexport TALISMAN_INTERACTIVE=true
Don't forget to source the bash file for the variable to take effect!
Alternatively, you can also invoke the interactive mode by using the CLI utility
(for using pre-commit hook)
talisman -i -g pre-commit
Nota: Si usas la integración de control de versiones de un IDE para operaciones de git, esta función no funcionará. Aún puedes usar el nombre de archivo sugerido y el checksum para ingresarlos manualmente en el archivo .talismanrc.
Ahora puedes ejecutar Talisman desde la CLI y potencialmente agregarlo a tus pipelines de CI/CD para escanear el historial de git de tu repositorio y encontrar cualquier contenido sensible. Esto incluye el escaneo de los archivos listados en el archivo .talismanrc también.
Pasos:
cd <directorio a escanear>talisman --scan
talisman --scan --reportdirectory=/Users/username/DesktopPuedes usar las otras opciones para escanear como se indicó anteriormente.
Talisman actualmente no soporta la omisión de archivos para el escaneo.
La calculadora de checksum de Talisman proporciona un formato yaml que puedes copiar y pegar directamente en el archivo .talismanrc para ignorar formatos de archivo particulares de los detectores de Talisman.
Para ejecutar el checksum, por favor haz "cd" a la raíz de tu repositorio y ejecuta el siguiente comando
Por ejemplo:
talisman --checksum="*.pem *.txt"
Ejemplo de salida:
.talismanrc format for given file names / patterns
fileignoreconfig:
- filename: '*.pem'
checksum: f731b26be086fd2647c40801630e2219ef207cb1aacc02f9bf0559a75c0855a4
ignore_detectors: []
- filename: '*.txt'
checksum: d9e9e94868d7de5b2a0706b8d38d0f79730839e0eb4de4e9a2a5a014c7c43f35
ignore_detectors: []
Nota: La calculadora de checksum considera los archivos staged al calcular el checksum colectivo de los archivos.
Desarrollado por 
La herramienta CLI de Talisman talisman también incluye la capacidad de proporcionar un informe HTML detallado y compartible. Una vez que hayas instalado Talisman, sigue los pasos mencionados en talisman-html-report, para instalar el paquete de informes en la carpeta .talisman. Para generar el informe HTML, ejecuta:
talisman --scanWithHtmlEsto escaneará el repositorio y creará una carpeta talisman_html_report dentro del repositorio escaneado. Necesitamos iniciar un servidor HTTP dentro de este repositorio para acceder al informe. A continuación se muestra un enfoque recomendado para iniciar un servidor HTTP:
python -m SimpleHTTPServer <port> (ej: 8000)Ahora puedes acceder al informe navegando a:
http://localhost:8000
Nota: No es necesario iniciar un servidor si estás ejecutando Talisman en CI o cualquier otro entorno alojado
El proceso de desinstalación depende de cómo hayas instalado Talisman. Podrías haber elegido instalarlo como una plantilla de hook global o en un solo repositorio.
Sigue los pasos a continuación según la opción que hayas elegido en la instalación.
Ejecuta el siguiente comando en tu terminal para desinstalar talisman globalmente de tu máquina.
Para el hook pre-commit:``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)"
Para el hook pre-push:```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)" -- pre-push
Esto
Tendrás que eliminar manualmente TALISMAN_HOME de tus variables de entorno
Cuando instalaste Talisman, debe haber creado un hook de pre-commit o pre-push (según la selección) en tu repositorio durante la instalación.
Puedes eliminar el hook manualmente borrando el hook de Talisman pre-commit o pre-push de la carpeta .git/hooks en el repositorio.
Para contribuir a Talisman, echa un vistazo a nuestra guía de contribución.