Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
rusty-hog — Scanner de segredos de múltiplas fontes detectando chaves de API, senhas e PII em repositórios Git, buckets S3, sistemas de arquivos, Confluence, JIRA, Slack e Google Docs usando regex e análise de entropia. | Kitploit
Ferramentas/GitHubGitHub/newrelic/rusty-hog
Análise de CódigoSegurança na NuvemDevSecOpsDetecção de Segredos
GitHubnewrelic/rusty-hog

rusty-hog

Scanner de segredos de múltiplas fontes detectando chaves de API, senhas e PII em repositórios Git, buckets S3, sistemas de arquivos, Confluence, JIRA, Slack e Google Docs usando regex e análise de entropia.

Ver Repositório
55563há 16 diasRevisado pelo Kitploit

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Rusty Hog é um scanner de segredos construído em Rust para desempenho, e baseado no TruffleHog que é escrito em Python. O Rusty Hog fornece os seguintes binários:

  • Ankamali Hog: Escaneia segredos em um documento do Google.
  • Berkshire Hog: Escaneia segredos em um bucket S3.
  • Choctaw Hog: Escaneia segredos em um repositório Git.
  • Duroc Hog: Escaneia segredos em um diretório, arquivo e archive.
  • Essex Hog: Escaneia segredos em uma página wiki do Confluence.
  • Gottingen Hog: Escaneia segredos em um issue do JIRA.
  • Slack Hog: Escaneia segredos em um Canal do Slack.

Tabela de conteúdos

  • Uso
    • Como instalar usando binários baixados
    • Como executar usando DockerHub
    • Como construir
    • Como construir no Windows
    • Uso do Anakamali Hog (Scanner GDoc)
    • Uso do Berkshire Hog (Scanner S3 - CLI)
    • Uso do Berkshire Hog (Scanner S3 - Lambda)
    • Uso do Choctaw Hog (Scanner Git)
    • Uso do Duroc Hog (Scanner de sistema de arquivos)
    • Uso do Essex Hog (Scanner Confluence)
    • Uso do Gottingen Hog (Scanner JIRA)
    • Uso do Hante Hog (Scanner SLACK)
    • Formato do arquivo JSON de regex
    • Formato do arquivo JSON de lista de permissões
  • Informações do projeto
    • Licença de código aberto
    • Suporte
    • Comunidade
    • Issues / solicitações de melhoria
    • Contribuindo
    • Roadmap de funcionalidades
    • O que significa o nome?
  • Uso

    Este projeto fornece um conjunto de scanners que usam expressões regulares para tentar detectar a presença de informações sensíveis, como chaves de API, senhas e informações pessoais. Ele inclui um conjunto de expressões regulares padrão, mas também aceita um objeto JSON contendo suas expressões regulares personalizadas.

    Como instalar usando binários baixados

    Baixe e descompacte o último ZIP na aba de releases. Em seguida, execute cada binário com -h para ver o uso.```shell script wget https://github.com/newrelic/rusty-hog/releases/download/v1.0.11/rustyhogs-darwin-choctaw_hog-1.0.11.zip unzip rustyhogs-darwin-choctaw_hog-1.0.11.zip darwin_releases/choctaw_hog -h

    root@kitploit:~
    ## Como executar usando DockerHub
    As imagens Docker do Rusty Hog podem ser encontradas na página pessoal do autor no DockerHub [aqui](https://hub.docker.com/u/wetfeet2000)
    Uma imagem Docker é criada para cada Hog e para cada versão. Então, para usar o choctaw_hog, você executaria os seguintes comandos:```shell script
    docker pull wetfeet2000/choctaw_hog:1.0.10
    docker run -it --rm wetfeet2000/choctaw_hog:1.0.10 --help
    

    Como construir

    • Certifique-se de que você tem Rust instalado e no seu caminho.
    • Clone este repositório e execute cargo build --release. Os binários estão localizados em target/release.
    • Para construir e visualizar documentos HTML, execute cargo doc --no-deps --open.
    • Para executar testes unitários, execute cargo test.
    • Para compilar cruzadamente o Berkshire Hog para o ambiente AWS Lambda, execute os seguintes comandos e faça upload do berkshire_lambda.zip para o painel do AWS Lambda:```shell script docker run --rm -it -v "$(pwd)":/home/rust/src ekidd/rust-musl-builder cargo build --release cp target/x86_64-unknown-linux-musl/release/berkshire_hog bootstrap zip -j berkshire_lambda.zip bootstrap
    root@kitploit:~
    ## Como compilar no Windows
    Você precisará compilar os binários estáticos do OpenSSL e informar ao Rust/Cargo onde encontrá-los:```
    mkdir \Tools
    cd \Tools
    git clone https://github.com/Microsoft/vcpkg.git
    cd vcpkg
    .\bootstrap-vcpkg.bat
    .\vcpkg.exe install openssl:x64-windows-static
    
    $env:OPENSSL_DIR = 'C:\Tools\vcpkg\installed\x64-windows-static'
    $env:OPENSSL_STATIC = 'Yes'
    [System.Environment]::SetEnvironmentVariable('OPENSSL_DIR', $env:OPENSSL_DIR, [System.EnvironmentVariableTarget]::User)
    [System.Environment]::SetEnvironmentVariable('OPENSSL_STATIC', $env:OPENSSL_STATIC, [System.EnvironmentVariableTarget]::User)
    

    Agora pode seguir as instruções principais de compilação listadas acima.

    Como compilar o Berkshire Hog para Lambda

    macOS

    Use Homebrew para obter as dependências:``` brew install rpm2cpio FiloSottile/musl-cross/musl-cross

    root@kitploit:~
    Em seguida, execute `./build_lambda_macos.sh`.
    
    O script de compilação será compilado contra o OpenSSL 3.0.12. Use `export OPENSSL_BUILD_VER=3.0.12` para substituir.
    
    O script de compilação será compilado contra os cabeçalhos do kernel Amazon Linux fornecidos pelo RPM deles; `export AMAZON_KERNEL_HEADERS_RPM_URL=...` para substituir de onde o RPM é baixado. (Não há nada que impeça o uso do RPM de linux-headers de uma distribuição diferente, só precisamos dos linux-headers para compilar openssl para Linux)
    
    O script de compilação criará um diretório build-deps na raiz do seu código-fonte atual. Você pode `rm -rf` este diretório com segurança, mas ele será recriado na próxima execução do script de compilação. Ele também fará várias verificações de consistência para garantir que a compilação funcione e, se essas falharem, poderá solicitar que você `rm -rf` esse diretório de qualquer forma para tentar novamente.
    
    ### Linux
    
    Certifique-se de que `cross` está instalado (`cargo install cross`), então apenas execute `./build_lambda.sh`.
    
    # Commands
    
    ## Uso do Anakamali Hog (GDoc Scanner)```
    USAGE:
        ankamali_hog [FLAGS] [OPTIONS] <GDRIVEID>
    
    FLAGS:
            --caseinsensitive    Sets the case insensitive flag for all regexes
            --entropy            Enables entropy scanning
            --oauthsecret        Path to an OAuth secret file (JSON) ./clientsecret.json by default
            --oauthtoken         Path to an OAuth token storage file ./temp_token by default
            --prettyprint        Outputs the JSON in human readable format
        -v, --verbose            Sets the level of debugging information
        -h, --help               Prints help information
        -V, --version            Prints version information
    
    OPTIONS:
        -a, --allowlist <ALLOWLIST>                                    Sets a custom allowlist JSON file
            --default_entropy_threshold <DEFAULT_ENTROPY_THRESHOLD>    Default entropy threshold (0.6 by default)
        -o, --outputfile <OUTPUT>                                      Sets the path to write the scanner results to (stdout by default)
    
            --regex <REGEX>                                            Sets a custom regex JSON file
    
    ARGS:
        <GDRIVEID>    The ID of the Google drive file you want to scan
    

    Berkshire Hog (S3 Scanner - CLI) uso```

    USAGE: berkshire_hog [FLAGS] [OPTIONS]

    FLAGS: --caseinsensitive Sets the case insensitive flag for all regexes --entropy Enables entropy scanning --prettyprint Outputs the JSON in human readable format -r, --recursive Recursively scans files under the prefix -v, --verbose Sets the level of debugging information -h, --help Prints help information -V, --version Prints version information

    OPTIONS: -a, --allowlist Sets a custom allowlist JSON file --default_entropy_threshold <DEFAULT_ENTROPY_THRESHOLD> Default entropy threshold (0.6 by default) -o, --outputfile Sets the path to write the scanner results to (stdout by default)

    root@kitploit:~
        --profile <PROFILE>                                        When using a configuration file, enables a non-default profile
    
        --regex <REGEX>                                            Sets a custom regex JSON file
    

    ARGS: The location of a S3 bucket and optional prefix or filename to scan. This must be written in the form s3://mybucket[/prefix_or_file] Sets the region of the S3 bucket to scan

    root@kitploit:~
    ## Uso do Berkshire Hog (Scanners S3 - Lambda)
    O Berkshire Hog atualmente é projetado para ser usado como uma função Lambda. Este é o fluxo básico de dados:
    <pre>
        ┌───────────┐              ┌───────┐     ┌────────────────┐     ┌────────────┐
        │ S3 bucket │ ┌────────┐   │       │     │ Berkshire Hog  │     │ S3 bucket  │
        │  (input) ─┼─┤S3 event├──▶│  SQS  │────▶│    (Lambda)    │────▶│  (output)  │
        │           │ └────────┘   │       │     │                │     │            │
        └───────────┘              └───────┘     └────────────────┘     └────────────┘
    </pre>
    
    Para executar o Berkshire Hog desta forma, configure o seguinte:
    1) Configure o bucket de entrada para enviar um "evento" ao SQS para cada evento PUSH/PUT.
    2) Configure o tópico SQS para aceitar eventos do S3, incluindo permissões IAM.
    3) Execute o Berkshire Hog com acesso IAM ao SQS e S3.
    
    ## Uso do Choctaw Hog (Scanner Git)```
    USAGE:
        choctaw_hog [FLAGS] [OPTIONS] <GITPATH>
    
    FLAGS:
            --caseinsensitive    Sets the case insensitive flag for all regexes
            --entropy            Enables entropy scanning
            --prettyprint        Outputs the JSON in human readable format
        -v, --verbose            Sets the level of debugging information
        -h, --help               Prints help information
        -V, --version            Prints version information
    
    OPTIONS:
            --default_entropy_threshold <DEFAULT_ENTROPY_THRESHOLD>    Default entropy threshold (4.5 by default)
            --httpspass <HTTPSPASS>                                    Takes a password for HTTPS-based authentication
            --httpsuser <HTTPSUSER>                                    Takes a username for HTTPS-based authentication
        -o, --outputfile <OUTPUT>                                      Sets the path to write the scanner results to (stdout by default)
            --recent_days <RECENTDAYS>                                 Filters commits to the last number of days (branch agnostic)
        -r, --regex <REGEX>                                            Sets a custom regex JSON file
            --since_commit <SINCECOMMIT>                               Filters commits based on date committed (branch agnostic)
            --sshkeypath <SSHKEYPATH>                                  Takes a path to a private SSH key for git authentication, defaults to ssh-agent
            --sshkeyphrase <SSHKEYPHRASE>                              Takes a passphrase to a private SSH key for git authentication, defaults to none
            --until_commit <UNTILCOMMIT>                               Filters commits based on date committed (branch agnostic)
        -a, --allowlist <ALLOWLIST>                                    Sets a custom ALLOWLIST JSON file
    
    ARGS:
        <GITPATH>    Sets the path (or URL) of the Git repo to scan. SSH links must include username (git@)
    

    Duroc Hog (scanner de sistema de ficheiros) uso```

    USAGE: duroc_hog [FLAGS] [OPTIONS]

    FLAGS: --caseinsensitive Sets the case insensitive flag for all regexes --entropy Enables entropy scanning --norecursive Disable recursive scanning of all subdirectories underneath the supplied path --prettyprint Outputs the JSON in human readable format -z, --unzip Recursively scans archives (ZIP and TAR) in memory (dangerous) -v, --verbose Sets the level of debugging information -h, --help Prints help information -V, --version Prints version information

    OPTIONS: -a, --allowlist Sets a custom allowlist JSON file --default_entropy_threshold <DEFAULT_ENTROPY_THRESHOLD> Default entropy threshold (0.6 by default) -o, --outputfile Sets the path to write the scanner results to (stdout by default) -r, --regex Sets a custom regex JSON file

    ARGS: Sets the path of the directory or file to scan.

    root@kitploit:~
    ## Essex Hog (scanner do Confluence) uso```
    USAGE:
        essex_hog [FLAGS] [OPTIONS] <PAGEID> <URL>
    
    FLAGS:
            --caseinsensitive    Sets the case insensitive flag for all regexes
            --entropy            Enables entropy scanning
            --prettyprint        Outputs the JSON in human readable format
        -v, --verbose            Sets the level of debugging information
        -h, --help               Prints help information
        -V, --version            Prints version information
    
    OPTIONS:
        -a, --allowlist <ALLOWLIST>                                    Sets a custom allowlist JSON file
            --authtoken <BEARERTOKEN>                                  Confluence basic auth bearer token (instead of user & pass)
    
            --default_entropy_threshold <DEFAULT_ENTROPY_THRESHOLD>    Default entropy threshold (0.6 by default)
        -o, --outputfile <OUTPUT>                                      Sets the path to write the scanner results to (stdout by default)
            --password <PASSWORD>                                      Confluence password (crafts basic auth header)
            --regex <REGEX>                                            Sets a custom regex JSON file
            --username <USERNAME>                                      Confluence username (crafts basic auth header)
    
    ARGS:
        <PAGEID>    The ID (e.g. 1234) of the confluence page you want to scan
        <URL>       Base URL of Confluence instance (e.g. https://newrelic.atlassian.net/)
    

    Gottingen Hog (scanner JIRA) uso```

    Jira secret scanner in Rust.

    USAGE: gottingen_hog [FLAGS] [OPTIONS]

    FLAGS: --caseinsensitive Sets the case insensitive flag for all regexes --entropy Enables entropy scanning --prettyprint Outputs the JSON in human readable format -v, --verbose Sets the level of debugging information -h, --help Prints help information -V, --version Prints version information

    OPTIONS: -a, --allowlist Sets a custom allowlist JSON file --authtoken Jira basic auth bearer token (instead of user & pass) --default_entropy_threshold <DEFAULT_ENTROPY_THRESHOLD> Default entropy threshold (0.6 by default) --url Base URL of JIRA instance (e.g. https://jira.atlassian.net/) -o, --outputfile Sets the path to write the scanner results to (stdout by default) --password Jira password (crafts basic auth header) --regex Sets a custom regex JSON file --username Jira username (crafts basic auth header)

    ARGS: The ID (e.g. PROJECT-123) of the Jira issue you want to scan

    root@kitploit:~
    ## Hante Hog (SLACK scanner) uso```
    Slack secret scanner in Rust.
    
    USAGE:
        hante_hog [FLAGS] [OPTIONS] --authtoken <BEARERTOKEN> --channelid <CHANNELID> --url <SLACKURL>
    
    FLAGS:
            --caseinsensitive    Sets the case insensitive flag for all regexes
            --entropy            Enables entropy scanning
            --prettyprint        Outputs the JSON in human readable format
        -v, --verbose            Sets the level of debugging information
        -h, --help               Prints help information
        -V, --version            Prints version information
    
    OPTIONS:
        -a, --allowlist <ALLOWLIST>                                    Sets a custom allowlist JSON file
            --authtoken <BEARERTOKEN>                                  Slack basic auth bearer token
            --channelid <CHANNELID>
                The ID (e.g. C12345) of the Slack channel you want to scan
    
            --default_entropy_threshold <DEFAULT_ENTROPY_THRESHOLD>    Default entropy threshold (0.6 by default)
            --latest <LATEST>                                          End of time range of messages to include in search
            --oldest <OLDEST>                                          Start of time range of messages to include in search
        -o, --outputfile <OUTPUT>
                Sets the path to write the scanner results to (stdout by default)
    
            --regex <REGEX>                                            Sets a custom regex JSON file
            --url <SLACKURL>
                Base URL of Slack Workspace (e.g. https://[WORKSPACE NAME].slack.com)
    

    Formato do arquivo JSON de regex

    A opção de regex nos scanners permite que os utilizadores forneçam o caminho para o seu próprio arquivo JSON de expressões regulares que correspondem a material sensível. Atualmente, qualquer arquivo fornecido substituirá, e não adicionará, as expressões regulares padrão fornecidas pelo SecretScanner. O formato esperado do arquivo é um único objeto json.

    As chaves devem ser nomes para o tipo de segredo que cada entrada de regex irá detetar, pois as chaves serão utilizadas para as propriedades de motivo (reason) geradas pelo scanner.

    Cada valor deve ser uma string contendo uma [https://docs.rs/regex/1.3.9/regex/#syntax](expressão regular para Rust) que deve corresponder ao tipo de segredo descrito pela sua chave correspondente.

    A partir da versão 1.0.8, o motor Rusty Hog também suporta objetos como valores para cada segredo. O objeto pode conter todos os seguintes:

    • uma propriedade pattern com a expressão regex correspondente (obrigatório)
    • uma propriedade entropy_filter com um valor booleano para ativar a verificação de entropia para esta informação (obrigatório)
    • uma propriedade threshold para personalizar a tolerância de entropia numa escala de 0 a 1 (opcional, ajustará para o formato antigo 1-8, padrão 0.6)
    • uma propriedade keyspace para indicar quantos valores possíveis existem na chave, ex.: 16 para hex, 64 para base64, 128 para ASCII (opcional, padrão 128)
    • uma propriedade make_ascii_lowercase para indicar se o Rust deve executar .make_ascii_lowercase() na chave antes de calcular a entropia (opcional, padrão falso)

    Quanto mais alto o limite (threshold), mais entropia é necessária no segredo para considerá-lo uma correspondência.

    Um exemplo deste formato está aqui:```json { "Generic Secret": { "pattern": "(?i)secret[\s[[:punct:]]]{1,4}[0-9a-zA-Z-]{16,64}[\s[[:punct:]]]?", "entropy_filter": true, "threshold": "0.6" }, "Slack Token": { "pattern": "(xox[p|b|o|a]-[0-9]{12}-[0-9]{12}-[0-9]{12}-[a-z0-9]{32})", "entropy_filter": true, "threshold": "0.6", "keyspace": "36", "make_ascii_lowercase": true }, "Google API Key": { "pattern": "AIza[0-9A-Za-z\-]{35}", "entropy_filter": true }, "PGP private key block": "-----BEGIN PGP PRIVATE KEY BLOCK-----" }

    root@kitploit:~
    A partir da versão 1.0.11, o JSON regex padrão atual usado é o seguinte:```json
    {
    	"Slack Token": "(xox[p|b|o|a]-[0-9]{12}-[0-9]{12}-[0-9]{12}-[a-z0-9]{32})",
    	"RSA private key": "-----BEGIN RSA PRIVATE KEY-----",
    	"SSH (DSA) private key": "-----BEGIN DSA PRIVATE KEY-----",
    	"SSH (EC) private key": "-----BEGIN EC PRIVATE KEY-----",
    	"PGP private key block": "-----BEGIN PGP PRIVATE KEY BLOCK-----",
    	"Amazon AWS Access Key ID": "AKIA[0-9A-Z]{16}",
    	"Amazon MWS Auth Token": "amzn\\.mws\\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
    	"Facebook Access Token": "EAACEdEose0cBA[0-9A-Za-z]+",
    	"Facebook OAuth": "(?i)facebook[\\s[[:punct:]]]{1,4}[0-9a-f]{32}[\\s[[:punct:]]]?",
    	"GitHub": "(?i)(github|access[[:punct:]]token)[\\s[[:punct:]]]{1,4}[0-9a-zA-Z]{35,40}",
    	"Generic API Key": {
    		"pattern": "(?i)(api|access)[\\s[[:punct:]]]?key[\\s[[:punct:]]]{1,4}[0-9a-zA-Z\\-_]{16,64}[\\s[[:punct:]]]?",
    		"entropy_filter": true,
    		"threshold": "0.6",
    		"keyspace": "guess"
    	},
    	"Generic Account API Key": {
    		"pattern": "(?i)account[\\s[[:punct:]]]?api[\\s[[:punct:]]]{1,4}[0-9a-zA-Z\\-_]{16,64}[\\s[[:punct:]]]?",
    		"entropy_filter": true,
    		"threshold": "0.6",
    		"keyspace": "guess"
    	},
    	"Generic Secret": {
    		"pattern": "(?i)secret[\\s[[:punct:]]]{1,4}[0-9a-zA-Z-_]{16,64}[\\s[[:punct:]]]?",
    		"entropy_filter": true,
    		"threshold": "0.6",
    		"keyspace": "guess"
    	},
    	"Google API Key": "AIza[0-9A-Za-z\\-_]{35}",
    	"Google Cloud Platform API Key": "AIza[0-9A-Za-z\\-_]{35}",
    	"Google Cloud Platform OAuth": "(?i)[0-9]+-[0-9A-Za-z_]{32}\\.apps\\.googleusercontent\\.com",
    	"Google Drive API Key": "AIza[0-9A-Za-z\\-_]{35}",
    	"Google Drive OAuth": "(?i)[0-9]+-[0-9A-Za-z_]{32}\\.apps\\.googleusercontent\\.com",
    	"Google (GCP) Service-account": "(?i)\"type\": \"service_account\"",
    	"Google Gmail API Key": "AIza[0-9A-Za-z\\-_]{35}",
    	"Google Gmail OAuth": "(?i)[0-9]+-[0-9A-Za-z_]{32}\\.apps\\.googleusercontent\\.com",
    	"Google OAuth Access Token": "ya29\\.[0-9A-Za-z\\-_]+",
    	"Google YouTube API Key": "AIza[0-9A-Za-z\\-_]{35}",
    	"Google YouTube OAuth": "(?i)[0-9]+-[0-9A-Za-z_]{32}\\.apps\\.googleusercontent\\.com",
    	"Heroku API Key": "[h|H][e|E][r|R][o|O][k|K][u|U][\\s[[:punct:]]]{1,4}[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}",
    	"MailChimp API Key": "[0-9a-f]{32}-us[0-9]{1,2}",
    	"Mailgun API Key": "(?i)key-[0-9a-zA-Z]{32}",
    	"Credentials in absolute URL": "(?i)((https?|ftp)://)(([a-z0-9$_\\.\\+!\\*'\\(\\),;\\?&=-]|%[0-9a-f]{2})+(:([a-z0-9$_\\.\\+!\\*'\\(\\),;\\?&=-]|%[0-9a-f]{2})+)@)((([a-z0-9]\\.|[a-z0-9][a-z0-9-]*[a-z0-9]\\.)*[a-z][a-z0-9-]*[a-z0-9]|((\\d|[1-9]\\d|1\\d{2}|2[0-4][0-9]|25[0-5])\\.){3}(\\d|[1-9]\\d|1\\d{2}|2[0-4][0-9]|25[0-5]))(:\\d+)?)(((/+([a-z0-9$_\\.\\+!\\*'\\(\\),;:@&=-]|%[0-9a-f]{2})*)*(\\?([a-z0-9$_\\.\\+!\\*'\\(\\),;:@&=-]|%[0-9a-f]{2})*)?)?)?",
    	"PayPal Braintree Access Token": "(?i)access_token\\$production\\$[0-9a-z]{16}\\$[0-9a-f]{32}",
    	"Picatic API Key": "(?i)sk_live_[0-9a-z]{32}",
    	"Slack Webhook": "(?i)https://hooks.slack.com/services/T[a-zA-Z0-9_]{8}/B[a-zA-Z0-9_]{8}/[a-zA-Z0-9_]{24}",
    	"Stripe API Key": "(?i)sk_live_[0-9a-zA-Z]{24}",
    	"Stripe Restricted API Key": "(?i)rk_live_[0-9a-zA-Z]{24}",
    	"Square Access Token": "(?i)sq0atp-[0-9A-Za-z\\-_]{22}",
    	"Square OAuth Secret": "(?i)sq0csp-[0-9A-Za-z\\-_]{43}",
    	"Twilio API Key": "SK[0-9a-fA-F]{32}",
    	"Twitter Access Token": "(?i)twitter[\\s[[:punct:]]]{1,4}[1-9][0-9]+-[0-9a-zA-Z]{40}",
    	"Twitter OAuth": "(?i)twitter[\\s[[:punct:]]]{1,4}['|\"]?[0-9a-zA-Z]{35,44}['|\"]?",
    	"New Relic Partner & REST API Key": "[\\s[[:punct:]]][A-Fa-f0-9]{47}[\\s[[:punct:]][[:cntrl:]]]",
    	"New Relic Mobile Application Token": "[\\s[[:punct:]]][A-Fa-f0-9]{42}[\\s[[:punct:]][[:cntrl:]]]",
    	"New Relic Synthetics Private Location": "(?i)minion_private_location_key",
    	"New Relic Insights Key (specific)": "(?i)insights[\\s[[:punct:]]]?(key|query|insert)[\\s[[:punct:]]]{1,4}\\b[\\w-]{32,40}\\b",
    	"New Relic Insights Key (vague)": "(?i)(query|insert)[\\s[[:punct:]]]?key[\\s[[:punct:]]]{1,4}b[\\w-]{32,40}\\b",
    	"New Relic License Key": "(?i)license[\\s[[:punct:]]]?key[\\s[[:punct:]]]{1,4}\\b[\\w-]{32,40}\\b",
    	"New Relic Internal API Key": "(?i)nr-internal-api-key",
    	"New Relic HTTP Auth Headers and API Key": "(?i)(x|newrelic|nr)-?(admin|partner|account|query|insert|api|license)-?(id|key)[\\s[[:punct:]]]{1,4}\\b[\\w-]{32,47}\\b",
    	"New Relic API Key Service Key (new format)": "(?i)NRAK-[A-Z0-9]{27}",
    	"New Relic APM License Key (new format)": "(?i)[a-f0-9]{36}NRAL",
    	"New Relic APM License Key (new format, region-aware)": "(?i)[a-z]{2}[0-9]{2}xx[a-f0-9]{30}NRAL",
    	"New Relic REST API Key (new format)": "(?i)NRRA-[a-f0-9]{42}",
    	"New Relic Admin API Key (new format)": "(?i)NRAA-[a-f0-9]{27}",
    	"New Relic Insights Insert Key (new format)": "(?i)NRII-[A-Za-z0-9-_]{32}",
    	"New Relic Insights Query Key (new format)": "(?i)NRIQ-[A-Za-z0-9-_]{32}",
    	"New Relic Synthetics Private Location Key (new format)": "(?i)NRSP-[a-z]{2}[0-9]{2}[a-f0-9]{31}",
    	"Email address": "(?i)\\b(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*)@[a-z0-9][a-z0-9-]+\\.(com|de|cn|net|uk|org|info|nl|eu|ru)([\\W&&[^:/]]|\\A|\\z)",
    	"New Relic Account IDs in URL": "(newrelic\\.com/)?accounts/\\d{1,10}/",
    	"Account ID": "(?i)account[\\s[[:punct:]]]?id[\\s[[:punct:]]]{1,4}\\b[\\d]{1,10}\\b",
    	"Salary Information": "(?i)(salary|commission|compensation|pay)([\\s[[:punct:]]](amount|target))?[\\s[[:punct:]]]{1,4}\\d+"
    }
    

    Formato do arquivo JSON de lista de permissões

    Os scanners oferecem um recurso de lista de permissões. Isso permite que você especifique uma lista de expressões regulares para cada padrão que será ignorado pelo scanner. Agora você pode, opcionalmente, fornecer uma lista de expressões regulares que também são avaliadas em relação ao caminho do arquivo.

    O formato para este arquivo de lista de permissões deve ser um único objeto JSON. Cada chave na lista de permissões deve corresponder a uma chave no JSON de regex, e o valor pode ser uma de duas coisas:

    1. Um array de strings que são exceções para esse padrão regex. Por exemplo:
    2. Um objeto com pelo menos uma chave (patterns) e opcionalmente uma segunda chave (paths).

    Além disso, você pode especificar a chave <GLOBAL>, que é avaliada em relação a todos os padrões.

    O seguinte é a lista de permissões padrão incluída em todas as varreduras:```json { "Email address": { "patterns": [ "(?i)@newrelic.com", "(?i)noreply@", "(?i)test@" ], "paths": [ "(?i)authors", "(?i)contributors", "(?i)license", "(?i)maintainers", "(?i)third_party_notices" ] }, "Credentials in absolute URL": { "patterns": [ "(?i)(https?://)?user:pass(word)?@" ] }, "New Relic API Key Service Key (new format)": { "patterns": [ "NRAK-123456789ABCDEFGHIJKLMNOPQR" ] }, "Generic API Key": { "patterns": [ "(?i)sanitizeAPIKeyForLogging" ] }, "New Relic License Key": { "patterns": [ "(?i)bootstrap_newrelic_admin_license_key", "(?i)xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "(?i)YOUR_NEW_RELIC_LICENSE_KEY__LICENSE", "(?i)YOUR_NEW_RELIC_APPLICATION_TOKEN" ] }, "Generic Secret": { "patterns": [ "(?i)secret:NewRelicLicenseKeySecret" ] }, "": [ "(?i)example", "(?i)fake", "(?i)replace", "(?i)deadbeef", "(?i)ABCDEFGHIJKLMNOPQRSTUVWX", "1234567890" ] }

    root@kitploit:~
    Esteja ciente de que estas são strings, não expressões regex, e as chaves para esta lista de permissões devem ser uma chave no JSON de regex.
    As chaves diferenciam maiúsculas de minúsculas.
    
    # Project information
    ## Open source license
    
    This project is distributed under the [Apache 2 license](https://github.com/newrelic/rusty-hog/blob/HEAD/LICENSE).
    
    ## Support
    
    New Relic has open-sourced this project. This project is provided AS-IS WITHOUT WARRANTY OR SUPPORT, although you can report issues and contribute to the project here on GitHub.
    
    _Please do not report issues with this software to New Relic Global Technical Support._
    
    ## Community
    
    New Relic hosts and moderates an online forum where customers can interact with New Relic employees as well as other customers to get help and share best practices. Like all official New Relic open source projects, there's a related Community topic in the New Relic Explorer's Hub. You can find this project's topic/threads here:
    
    https://discuss.newrelic.com/t/rusty-hog-multi-platform-secret-key-scanner/90117
    
    ## Issues / enhancement requests
    
    Submit issues and enhancement requests in the [Issues tab of this repository](https://raw.githubusercontent.com/newrelic/issues). Please search for and review the existing open issues before submitting a new issue.
    
    ## Contributing
    
    Contributions are welcome (and if you submit a enhancement request, expect to be invited to contribute it yourself). Please review our [Contributors Guide](https://github.com/newrelic/rusty-hog/blob/HEAD/CONTRIBUTING.md).
    
    Keep in mind that when you submit your pull request, you'll need to sign the CLA via the click-through using CLA-Assistant. If you'd like to execute our corporate CLA, or if you have any questions, please drop us an email at [email protected].
    
    
    ## Feature Roadmap
      
    - 1.1: Enterprise features
        - [ ] Support config files (instead of command line args)
        - [ ] Support environment variables instead of CLI args
        - [ ] Multi-threading
        - [ ] Better context detection and false positive filtering (GitHound, machine learning)
        - [ ] Use Rusoto instead of s3-rust
        - [x] Add JIRA scanner
        - [x] Add file-system & archive scanner
        - [ ] Use Rust features to reduce compilation dependencies?
    
    - 1.2: Integration with larger scripts and UIs
        - [ ] Support Github API for larger org management
            - [ ] Scan all repos for a list of users
            - [x] Scan all repos in an org
        - [ ] Generate a web report or web interface. Support "save state" generation from UI.
        - [ ] Agent/manager model
        - [ ] Scheduler process (blocked by save state support)
    
    
    ## What does the name mean?
    TruffleHog is considered the de facto standard / original secret scanner. I have been
    building a suite of secret scanning tools for various platforms based on TruffleHog
    and needed a naming scheme, so I started at the top of Wikipedia's
    [list of pig breeds](https://en.wikipedia.org/wiki/List_of_pig_breeds).
    Thus each tool name is a breed of pig starting at "A" and working up.
    
    Baixar ferramenta