thoughtworks/talismanScanner de segredos baseado em hooks Git que detecta tokens, senhas e chaves privadas em conjuntos de alterações enviadas, impedindo que dados sensíveis sejam commitados ou enviados a repositórios.
Uma ferramenta para detectar e impedir que segredos sejam commitados
O Talisman é uma ferramenta que examina os conjuntos de alterações do git para garantir que segredos potenciais ou informações sensíveis não saiam da estação de trabalho do desenvolvedor.
Ele valida o conjunto de alterações de saída em busca de coisas suspeitas – como chaves SSH em potencial, tokens de autorização, chaves privadas etc.
O Talisman é compatível com MAC OSX, Linux e Windows.
O Talisman pode ser instalado e usado de uma das seguintes maneiras:
O Talisman pode ser configurado como um hook de pré-commit ou pré-push nos repositórios git.
Encontre as instruções abaixo.
Isenção de responsabilidade: Segredos que entram por meio de um push forçado em um repositório git não podem ser detectados pelo Talisman. Acredita-se que um push forçado seja notório por seus próprios problemas, e sugerimos que os administradores de repositórios git apliquem medidas apropriadas para autorizar tais atividades.
Recomendamos instalar o talisman no seu PATH para que ele fique disponível para frameworks de hook git e scripts. Escolha o binário correto para o seu sistema na nossa Página de Releases, ou execute o nosso script de instalação:```bash
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Ou defina a variável de ambiente `INSTALL_LOCATION` para especificar um local personalizado para o binário:```bash
INSTALL_LOCATION=/usr/local/bin bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Ou defina a variável de ambiente VERSION para uma tag de lançamento para instalar uma versão específica::```bash
VERSION=v1.36.0 bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/install.sh)"
Ou usando linuxbrew no Linux e homebrew no macOS executando o seguinte comando no terminal:```bash
brew install talisman
Oferecemos scripts que instalarão o Talisman como um modelo de hook git pre-commit, pois isso fará com que o Talisman esteja presente, não apenas nos seus repositórios git existentes, mas também em qualquer novo repositório que você 'init' ou 'clone'.
Como um hook pre-commit: ``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)"
OU
Como um pre-push hook: ```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/install.bash)" -- pre-push
$PATH, será perguntado um local apropriado para configurá-lo. Escolha o número da opção onde você define a origem do perfil na sua máquina.Lembre-se de executar source no arquivo de caminho ou reiniciar seu terminal.
Se você optar por configurar o $PATH mais tarde, exporte TALISMAN_HOME=$HOME/.talisman/bin para o caminho.
Instalar talisman globalmente como um gancho não substituirá nenhum gancho existente. Se o script de instalação encontrar ganchos existentes, ele apenas indicará isso no console. Para executar vários ganchos, sugerimos usar um framework de ganchos, como pre-commit ou husky. Estas instruções assumem que o executável talisman está instalado em algum lugar no caminho do seu sistema.
Use pre-commit para gerenciar ganchos existentes junto com
Talisman. Referencie nosso pre-commit-hooks no seu
.pre-commit-config.yaml:```yaml
### Husky
[husky](https://typicode.github.io/husky) é um módulo npm para gerenciar hooks.
Adicione a seguinte linha à configuração do hook pre-commit do husky no seu
`package.json`:```
talisman --githook pre-commit
Uma vez que o executável do talisman esteja instalado você pode configurar um hook pre-commit independente para um repositório git:```bash cd my-git-project echo "talisman -g pre-commit" >> .git/hooks/pre-commit chmod +x .git/hooks/pre-commit
# Upgrading
Since release v0.4.4, Talisman <b>atualiza automaticamente</b> o binário para a versão mais recente, quando o hook é invocado (no pre-commit/pre-push, conforme configurado). Então, sente-se, relaxe e continue usando o Talisman mais recente sem esforço extra.
As seguintes variáveis de ambiente podem ser definidas:
1. TALISMAN_SKIP_UPGRADE: Defina como true se quiser pular a verificação automática de atualização. O padrão é false
2. TALISMAN_UPGRADE_CONNECT_TIMEOUT: Tempo máximo de conexão antes do cancelamento da atualização (em segundos). O padrão é 10 segundos.
Se você precisar atualizar manualmente, aqui estão os passos:
<br>[Recomendado] Atualize o binário Talisman e os scripts de hook para a versão mais recente:```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
Atualize apenas o binário do Talisman executando:```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 em ação
Após a instalação bem-sucedida, o Talisman executará verificações automáticas de segredos óbvios antes de cada commit ou push (conforme escolhido durante a instalação). Caso sejam detectadas quaisquer violações de segurança, o talisman exibirá um relatório detalhado dos erros:```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 |
+-----------------+-------------------------------------------------------------------------------+
No exemplo acima, o arquivo danger.pem foi sinalizado como uma violação de segurança devido aos seguintes motivos:
Se você instalou o Talisman como um hook de pré-commit, ele escaneará apenas o diff dentro de cada commit. Isso significa que ele reportará erros apenas para partes do arquivo que foram alteradas.
Caso você tenha instalado o Talisman como um hook de pré-push, ele escaneará o arquivo completo no qual as alterações são feitas. Conforme mencionado acima, é recomendável usar o Talisman como um hook de pré-commit.
Os seguintes detectores são executados nos conjuntos de alterações para detectar segredos/informações sensíveis:
Se você tiver certeza de que deseja enviar esse arquivo, poderá configurá-lo no arquivo .talismanrc na raiz do projeto. O conteúdo necessário para ignorar seus arquivos com falha será exibido pelo Talisman no console imediatamente após o Relatório de Erro do Talisman:```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:
Adicionar isso ao arquivo `.talismanrc` garantirá que o Talisman ignore o arquivo `danger.pem` desde que o checksum corresponda ao valor mencionado no campo `checksum`.
### Modo interativo
**Disponível apenas para usuários que não são Windows**
Se é muito trabalhoso ficar copiando conteúdo para o `.talismanrc` toda vez que você encontrar um erro do Talisman, você pode ativar o modo interativo e deixar o Talisman ajudá-lo a solicitar a adição dos arquivos para ignorar.
Basta seguir os passos simples:
1. Abra seu perfil bash onde as variáveis de ambiente estão definidas (.bashrc, .bash_profile, .profile ou qualquer outro local)
2. Você verá a variável `TALISMAN_INTERACTIVE` abaixo de `# >>> talisman >>>`
3. Se ainda não estiver definida como true, adicione `export TALISMAN_INTERACTIVE=true`
4. Não se esqueça de salvar e carregar (source) o arquivo
Pronto! Toda vez que o hook do Talisman encontrar um erro durante pre-push/pre-commit, basta seguir as instruções conforme o Talisman sugere.
Cuidado para não ignorar um arquivo sem verificar o conteúdo. Você deve estar confiante de que nenhum segredo está sendo vazado.
### Ignorando detectores específicos
Abaixo está uma descrição detalhada dos vários campos que podem ser configurados no arquivo `.talismanrc`:
* `filename` : Este campo deve mencionar o nome do arquivo totalmente qualificado.
* `checksum` : Este campo deve sempre ter o valor especificado pelo Talisman na mensagem exibida acima. Se a qualquer momento uma nova alteração for feita no arquivo, resultará em um novo checksum e o Talisman examinará o arquivo novamente em busca de potenciais ameaças de segurança.
* `ignore_detectors` : Este campo desabilitará detectores específicos para um arquivo em particular.
Por exemplo, se o nome do arquivo `init-env.sh` acionar um aviso, você pode desabilitar apenas este
aviso, mas ainda será alertado se outras coisas derem errado (por exemplo, conteúdo do arquivo):```yaml
fileignoreconfig:
- filename: init-env.sh
checksum: cf97abd34cebe895417eb4d97fbd7374aa138dcb65b1fe7f6b6cc1238aaf4d48
ignore_detectors: [filename, filesize]
Nota: Aqui, tanto o detector de nome de arquivo quanto o detector de tamanho de arquivo são ignorados para init-env.sh, mas o detector de conteúdo de arquivo ainda será ativado em init-env.sh
No momento, você pode ignorar
filecontentfilenamefilesizeComo alguns dos seus arquivos podem conter palavras-chave como key ou pass que não estão necessariamente relacionadas a segredos, você pode querer ignorar essas palavras-chave para reduzir o número de falsos positivos.
Isso pode ser alcançado usando o campo allowed_patterns no nível do arquivo e/ou no nível do repositório:```yaml
fileignoreconfig:
No exemplo anterior, `key` é permitido no arquivo `test`, `keyword` e `pass` são permitidos no nível do repositório.
O campo `allowed_patterns` também suporta expressões regulares do Golang. Aqui está um exemplo de código simples onde o RegExp do Golang pode 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 padrão, o Talisman alertará para ambas as linhas. Na segunda linha, estamos extraindo a AWS Access Key ID do Hashicorp Vault, que não expõe o segredo para o código. Se esse tipo de uso for comum em seu código, talvez você queira dizer ao Talisman para não alertar quando você usar um Vault. Isso pode ser alcançado com uma configuração como:```yaml allowed_patterns:
### Ignorar múltiplos arquivos do mesmo tipo (com curingas)
Você pode optar por ignorar todos os arquivos de um determinado tipo, sabendo que eles sempre serão seguros e não gostaria que o Talisman os verificasse.
Passos:
1. Formate um padrão curinga para os arquivos que deseja ignorar. Por exemplo, `*.lock`
2. Use a [calculadora de checksum](#calculadora-de-checksum) para fornecer o padrão e obter um checksum coletivo. Por exemplo, `talisman --checksum="*.lock" `
3. Copie o bloco fileconfig, exibido no console, para o arquivo .talismanrc.
Se algum dos arquivos for modificado, o talisman verificará os arquivos novamente, a menos que você recalcule o novo checksum e o substitua no arquivo .talismanrc.
### Ignorar arquivos especificando o escopo da linguagem
Você pode optar por ignorar arquivos especificando o escopo da linguagem para o seu projeto no seu arquivo talismanrc.```yaml
scopeconfig:
- scope: go
- scope: node
- scope: images
- scope: php
- scope: python
Talisman é configurado para ignorar certos arquivos com base no escopo especificado. Por exemplo, mencionar o escopo node no scopeconfig impedirá que o talisman escaneie arquivos como yarn.lock ou package-lock.json.
Você pode especificar vários escopos.
Atualmente, o .talismanrc só suporta scopeconfig para go, node, php e images. Outros escopos serão adicionados em breve.
Você pode especificar padrões regex personalizados para procurar no repositório atual```yaml custom_patterns:
<br/><i>
**Nota**: O uso de .talismanignore foi descontinuado. O arquivo .talismanrc o substitui porque:
* .talismanrc possui um formato yaml muito mais legível
* Também traz práticas mais seguras com cada modificação de um arquivo com um valor potencialmente sensível a ser revisado
* O novo formato também traz extensibilidade para introduzir novas funcionalidades utilizáveis. Fique atento para mais informações </i>
## Configurando o limite de gravidade
Cada validação está associada a uma gravidade
1. Baixa
2. Média
3. Alta
Você pode especificar um limite no seu .talismanrc:```yaml
threshold: medium
Isso reportará todos os problemas de severidade Média e superiores (Riscos potenciais abaixo do limite serão reportados nos avisos)
Você pode personalizar os níveis de segurança dos detectores fornecidos pelo Talisman no arquivo .talismanrc:```yaml custom_severities:
Ao usar severidades personalizadas e um limiar de severidade, o Talisman pode ser configurado para alertar apenas sobre o que é importante com base no seu contexto. Isso pode ser útil para reduzir o número de falsos positivos.
## Talisman como um utilitário de CLI
Se você executar `talisman` na linha de comando, poderá ver todas as opções de parâmetros que pode passar```
-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
Quando você regularmente tem muitos arquivos que são sinalizados pelo hook do talisman, os quais você sabe que podem ser commitados sem problemas, você pode usar este recurso para deixar o talisman facilitar o processo para você. O modo interativo permitirá que o Talisman o solicite a adicionar diretamente os arquivos que você deseja ignorar ao .talismanrc a partir do prompt de comando. Para ativar este recurso, você precisa definir a variável TALISMAN_INTERACTIVE como true no seu arquivo bash.
Você pode invocar o talisman no modo interativo de uma das 2 maneiras:
Abra seu arquivo bash e adicioneexport 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: Se você usar a integração de Controle de Versão de uma IDE para operações git, este recurso não funcionará. Você ainda pode usar o nome de arquivo sugerido e o checksum para serem inseridos manualmente no arquivo .talismanrc.
Agora você pode executar o Talisman a partir da CLI e, potencialmente, adicioná-lo aos seus pipelines de CI/CD, para escanear o histórico git do seu repositório em busca de conteúdo sensível. Isso inclui a verificação dos arquivos listados no arquivo .talismanrc.
Passos:
cd <diretório para escanear>talisman --scantalisman --scan --reportdirectory=/Users/username/DesktopVocê pode usar as outras opções para escanear conforme fornecido acima.
Atualmente, o Talisman não suporta a ignorância de arquivos para escaneamento.
A Calculadora de Checksum do Talisman fornece um formato yaml que você pode copiar e colar diretamente no arquivo .talismanrc para ignorar formatos de arquivo específicos dos detectores do Talisman.
Para executar o checksum, use "cd" para a raiz do seu repositório e execute o seguinte comando.
Por exemplo:
talisman --checksum="*.pem *.txt"
Exemplo de saída:
formato .talismanrc para os nomes / padrões de arquivo fornecidos
fileignoreconfig:
- filename: '*.pem'
checksum: f731b26be086fd2647c40801630e2219ef207cb1aacc02f9bf0559a75c0855a4
ignore_detectors: []
- filename: '*.txt'
checksum: d9e9e94868d7de5b2a0706b8d38d0f79730839e0eb4de4e9a2a5a014c7c43f35
ignore_detectors: []
Nota: A calculadora de checksum considera os arquivos em staged ao calcular o checksum coletivo dos arquivos.
Desenvolvido por 
A ferramenta CLI do Talisman talisman também vem com a capacidade de fornecer um relatório HTML detalhado e compartilhável. Depois de instalar o Talisman, siga os passos mencionados em talisman-html-report, para instalar o pacote de relatórios na pasta .talisman. Para gerar o relatório html, execute:
talisman --scanWithHtmlIsso escaneará o repositório e criará uma pasta talisman_html_report dentro do repositório escaneado. Precisamos iniciar um servidor HTTP dentro deste repositório para acessar o relatório. Abaixo está uma abordagem recomendada para iniciar um servidor HTTP:
python -m SimpleHTTPServer <porta> (ex: 8000)Agora você pode acessar o relatório navegando para:
http://localhost:8000
Nota: Você não precisa iniciar um servidor se estiver executando o Talisman em CI ou qualquer outro ambiente hospedado
O processo de desinstalação depende de como você instalou o Talisman. Você pode ter optado por instalar como um modelo de hook global ou em um único repositório.
Por favor, siga os passos abaixo com base na opção que você escolheu durante a instalação.
Execute o seguinte comando no seu terminal para desinstalar o talisman globalmente da sua máquina.
Para pre-commit hook:``` bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)"
Para pre-push hook:```
bash -c "$(curl --silent https://raw.githubusercontent.com/thoughtworks/talisman/main/global_install_scripts/uninstall.bash)" -- pre-push
Isso irá
Você terá que remover manualmente TALISMAN_HOME das suas variáveis de ambiente
Quando você instalou o Talisman, ele deve ter criado um hook de pre-commit ou pre-push (conforme selecionado) no seu repositório durante a instalação.
Você pode remover o hook manualmente excluindo o hook pre-commit ou pre-push do Talisman da pasta .git/hooks no repositório.
Para contribuir com o Talisman, dê uma olhada no nosso guia de contribuição.