Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
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.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
DakshSCRA — Ferramenta de análise estática de código consciente de frameworks para revisão automatizada de código-fonte com regras específicas de plataforma, análise de fluxo de dados, estimativa de esforço e linhas de base de supressão. | Kitploit
Ferramentas/GitHubGitHub/coffeeandsecurity/dakshscra
Análise EstáticaScanners de VulnerabilidadesAnálise Estática de Código (SAST)Análise de VulnerabilidadesAnálise de CódigoSegurança WebTestes de PenetraçãoDevSecOpsSegurança Móvel
Aprendizado e Educação
GitHubcoffeeandsecurity/dakshscra

DakshSCRA

Ferramenta de análise estática de código consciente de frameworks para revisão automatizada de código-fonte com regras específicas de plataforma, análise de fluxo de dados, estimativa de esforço e linhas de base de supressão.

Ver Repositório
457150há 15 diasRevisado pelo Kitploit
Compartilhar
# Daksh SCRA (Assistente de Revisão de Código-Fonte)

```
Author:
- Debasis Mohanty ([email protected])
- Twitter / X: @coffeensecurity
- www.coffeeandsecurity.com
```

## Sobre o Daksh SCRA

O Daksh SCRA (Source Code Review Assist) foi criado para aumentar a eficiência do processo de revisão de código-fonte, proporcionando uma abordagem bem estruturada e organizada para os revisores de código.

Em vez de sinalizar indiscriminadamente tudo como um possível problema, o Daksh SCRA promove uma análise criteriosa, incentivando a investigação e a confirmação de possíveis problemas. Essa abordagem reduz a correria para marcar cada possível preocupação como um bug, diminuindo a confusão e o tempo desperdiçado com falsos positivos.

### Estreia

O Daksh SCRA foi apresentado inicialmente durante uma sessão de treinamento em revisão de código-fonte na Black Hat USA 2022 (6 a 9 de agosto), onde foi apresentado discretamente a um público específico. Sua estreia pública oficial ocorreu na Black Hat USA 2023, em Las Vegas.

## Recursos e Funcionalidades

O DakshSCRA reúne capacidades distintivas para a revisão manual de código-fonte, desde áreas de interesse em caminhos de arquivos e estimativa de esforço até reconhecimento de software, regras contextuais e análise entre arquivos.

| Recurso | Tag | Por que é importante |
|---|---|---|
| **Áreas de Interesse em Caminhos de Arquivos** | Primeiro do mundo* | Examina os próprios nomes de arquivos e diretórios, além do código, para sinalizar caminhos suspeitos, como arquivos de backup, endpoints de depuração, dumps de configuração e arquivos de credenciais que os revisores frequentemente deixam passar. |
| **Estimativa Científica de Esforço** | Primeiro do mundo* | Produz uma estimativa quantificada do esforço de revisão manual com base no tamanho da base de código e nos sinais do projeto. Premissas configuráveis tornam o planejamento do engajamento explícito e repetível. |
| **Reconhecimento de Software** | Segundo do mundo* | Detecta linguagens, frameworks e infraestrutura a partir do conteúdo dos arquivos e da estrutura do projeto antes da varredura. Conecta o inventário de tecnologias à seleção automática de regras, à análise semântica e ao planejamento da revisão. |
| **Análise Semântica Avançada e Entre Arquivos** | Mais avançada em código aberto no lançamento* | Rastreia dados controlados pelo usuário da origem ao destino através dos limites de arquivos suportados, usando uma análise especialmente desenvolvida. A Análise Avançada foi lançada junto com o RDL original em março de 2026; o RDL v2 estende a avaliação de regras semânticas entre arquivos. |

* Com base em buscas gerais na época em que cada recurso foi introduzido. Nenhum recurso semelhante foi encontrado em ferramentas de código aberto para revisão de código de segurança. Para estimativa de esforço, nenhuma abordagem semelhante foi encontrada em ferramentas comerciais também. O reconhecimento ficou em segundo lugar, atrás do Microsoft Application Inspector. A análise entre arquivos era a mais avançada entre as ferramentas de código aberto para revisão de código no momento de seu lançamento.

### Histórico de Recursos e Evidências

| Recurso / marco | Data | Versão | Evidência / escopo |
|---|---|---|---|
| Beta inicial e regras de caminhos de arquivos | 22 de outubro de 2022 | v0.1-beta | [Versão inicial; o código-fonte retido inclui o inventário dedicado de regras de caminhos de arquivos.](https://github.com/coffeeandsecurity/DakshSCRA/releases/tag/v0.1-beta) |
| Reconhecimento de software (introdução publicada) | 9 de julho de 2023 | v0.3-beta | [As notas de versão introduzem o reconhecimento; o código anterior do repositório é evidência de implementação separada.](https://github.com/coffeeandsecurity/DakshSCRA/releases/tag/v0.3-beta) |
| Estimativa de esforço de revisão manual (implementação) | 29 de julho de 2023 | Commit de implementação | [Módulo de estimativa dedicado adicionado; não é a data da versão de correção posterior.](https://github.com/coffeeandsecurity/DakshSCRA/commit/65d5c6a) |
| RDL original e Análise Avançada entre arquivos | 2 de março de 2026 | v0.31-beta | [Lógica de regras condicionais e análise independente entre arquivos lançadas juntas. A data de exibição da versão é 2 de março; o carimbo de data/hora de publicação é 1 de março de 2026 às 18:39 UTC.](https://github.com/coffeeandsecurity/DakshSCRA/commit/d90ba51) |

### Evidências comparativas

- **Predecessor do reconhecimento:** [Microsoft Application Inspector](https://www.microsoft.com/en-us/security/blog/2020/01/16/introducing-microsoft-application-inspector/) (16 de janeiro de 2020) documenta uma ferramenta anterior de características de código-fonte. O reconhecimento do Daksh SCRA é colocado em segundo lugar, atrás dela.

As datas identificam marcos do repositório ou da versão.

O DakshSCRA foi apresentado durante o treinamento da **Black Hat USA 2022** e estreou publicamente na **Black Hat USA 2023**. Essas datas descrevem a introdução do projeto, não todos os recursos atuais.

> Melhorias ativas estão em andamento. Vários novos recursos e melhorias estão planejados para as próximas versões.

Sinta-se à vontade para contribuir com a atualização ou adição de novas regras e com o desenvolvimento futuro.

Se você encontrar algum bug, reporte-o para [[email protected]](mailto:[email protected]).

Documentação detalhada: [https://dakshlabs.com/#docs](https://dakshlabs.com/#docs)

---

## Primeiros Passos

Existem duas maneiras de executar o Daksh SCRA - escolha a que melhor se adapta ao seu fluxo de trabalho:

| | Ideal para | Ir para |
|---|---|---|
| 🌐 **Web UI (Docker)** | A maneira mais fácil de começar - um comando, um painel no navegador, progresso do scan em tempo real e um navegador de relatórios/artefatos. Recomendado para a maioria dos usuários. | [Web UI (Docker)](#web-ui-docker) |
| 💻 **CLI (Python)** | Scripts, pipelines de CI ou execução de scans sem Docker. | [Configuração da CLI](#cli-setup) |

Ambos os caminhos executam exatamente o mesmo mecanismo de scan - a Web UI é uma interface de navegador sobre a mesma CLI, portanto os resultados são idênticos em ambos os casos.

---

## Web UI (Docker)

A maneira mais rápida de executar o Daksh SCRA é através de sua Web UI baseada em navegador, iniciada com o auxiliar de inicialização Docker ciente do host. Ele oferece um lançador de scans, um feed de console ao vivo e um histórico navegável de relatórios anteriores. O auxiliar de inicialização requer Python 3 (apenas biblioteca padrão); a aplicação e suas dependências são executadas no Docker.

A configuração do Docker executa a Web UI e a CLI como serviços independentes construídos a partir da mesma imagem, para que você possa usar qualquer uma (ou ambas) a partir do mesmo contêiner.

### Iniciar a Web UI

Após baixar o Daksh SCRA do GitHub, **extraia primeiro o arquivo ZIP**.
Abra um terminal (PowerShell ou Prompt de Comando no Windows) dentro da pasta
do projeto extraída que contém `docker-compose.yml` e `dakshscra.py`.
**Execute todos os comandos de inicialização e Docker Compose abaixo a partir dessa pasta.**

Se o seu terminal abrir em outro local, mude primeiro para a pasta extraída:

```text
cd "path/to/extracted/DakshSCRA-folder"
```

Substitua o caminho de exemplo pelo local real do seu download e nome da pasta.
Se você clonou o repositório, execute `cd DakshSCRA` a partir da pasta pai.

O auxiliar de inicialização reconhece Windows, WSL, Linux e macOS e, em seguida, monta a
raiz do host, as unidades Windows disponíveis e pastas comuns em modo somente leitura antes
de iniciar os contêineres. Execute-o no computador que está executando o Docker.

Linux, macOS ou WSL (primeiro plano):

```bash
python3 tools/start_webui.py
```

Windows PowerShell ou Prompt de Comando (primeiro plano):

```powershell
py tools/start_webui.py
```

Para executar no modo destacado (em segundo plano), adicione `--detach`. Os contêineres continuam em execução
após o comando de inicialização retornar, deixando seu terminal disponível.

Linux, macOS ou WSL (destacado):

```bash
python3 tools/start_webui.py --detach
```

Windows PowerShell ou Prompt de Comando (desanexado):

```powershell
py tools/start_webui.py --detach
```

Use `--dry-run` para inspecionar os caminhos detetados sem iniciar os contentores.
As substituições de caminho existentes no `.env` são respeitadas. As contas, análises e o volume
de runtime são preservados quando os contentores são recriados.

O Docker Desktop pode exigir permissão para partilhar os caminhos do host selecionados. Se
rejeitar uma montagem, permita essa localização no Docker Desktop e execute novamente o helper.
Um navegador remoto vê as pastas do **host Docker**, não as unidades do seu próprio computador.
A deteção automática requer um motor Docker local; execute o helper no host do motor
ao utilizar um contexto Docker remoto.

Para montagens configuradas manualmente, `docker compose up --build -d api web` continua
disponível. A sua configuração base monta o repositório em `/scan-targets` e
`${DAKSH_HOST_MOUNT:-/}` em `/host/root`. Utilize o helper para a descoberta de unidades Windows
e atalhos para pastas comuns; o Compose simples não consegue detetar o SO do cliente.

Depois, abra [http://localhost:3030](http://localhost:3030).

Para utilizar uma porta diferente:

```bash
DAKSH_PORT=9090 python3 tools/start_webui.py
```

Pare a stack com:

```bash
docker compose down
```

### Liberando espaço em disco após builds repetidos do Docker

Use os helpers de limpeza separados da pasta do repositório. Eles fazem uma pré-visualização por padrão:

**Isso exclui contêineres, imagens de serviço, redes e volumes do Daksh, incluindo contas salvas, histórico de varreduras e artefatos armazenados no volume de runtime. Faça backup de tudo o que deseja manter antes.**

```bash
python3 tools/clean_project_docker.py
python3 tools/purge_all_docker.py
```

Adicione `--execute` para excluir e, em seguida, digite a confirmação solicitada. O primeiro helper
remove os containers, redes, imagens de serviço e volumes deste projeto, preservando
o cache de build compartilhado. O segundo remove forçadamente containers em **todos os projetos no
engine Docker selecionado** e limpa imagens, redes, volumes nomeados/anônimos
e o cache do builder padrão. Ele pode afetar um engine remoto. Nenhum dos dois exclui
arquivos do host montados via bind nem desinstala o Docker. Usuários do Windows podem substituir `python3`
por `py`. Consulte [escopo e comandos de limpeza](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#docker-cleanup-and-full-purge)
para nomes de projeto personalizados, exclusões e detalhes de exclusão.

Verifique o uso restante de disco do Docker com:

```bash
docker system df
```

Para liberar apenas o cache de build não utilizado, mantendo os dados salvos do Daksh, execute apenas `docker builder prune --all --force`. Os arquivos em pastas do host montadas via bind, incluindo o repositório e os alvos de varredura, permanecem no disco. Inicie novamente com `python3 tools/start_webui.py --detach` quando estiver pronto.

### Fazendo login

A Web UI requer uma conta.

**Primeiro login**

1. Inicie o portal (`python3 tools/start_webui.py --detach`) e abra [http://localhost:3030](http://localhost:3030).
2. A página de login detecta a configuração inicial. Ela preenche automaticamente o nome de usuário `admin` e a senha inicial, e exibe um aviso de configuração inicial.

   | Configuração | Valor |
   |---|---|
   | Nome de usuário | `admin` (ou `DAKSH_ADMIN_USERNAME` do `.env`) |
   | Senha inicial | `Daksh@ChangeMe1` (ou `DAKSH_ADMIN_PASSWORD` do `.env`) |

3. Clique em **Sign in**. Uma etapa de **alteração de senha** em tela cheia aparece e não pode ser ignorada. Insira a senha inicial como senha atual, escolha uma nova senha (pelo menos 8 caracteres, diferente da atual) e, opcionalmente, altere o nome de usuário.
4. Após salvar, você é levado ao dashboard. A partir de então, a página de login não preenche mais nada automaticamente; faça login com suas próprias credenciais.

A senha inicial só é usada enquanto o banco de dados não tiver contas, e deixa de funcionar assim que for alterada. Até lá, qualquer pessoa que consiga acessar o portal pode entrar com ela, portanto defina `DAKSH_ADMIN_PASSWORD` no `.env` antes da primeira inicialização se o portal for acessível por outras pessoas. Uma conta de administrador pode criar outras contas por meio do endpoint de API `POST /api/v1/auth/users` (ainda não há UI dedicada para isso). Contas novas e redefinidas também precisam alterar a senha atribuída no primeiro login. Consulte `.env.example` para a lista completa de configurações relacionadas à autenticação (tempo de vida da sessão, segurança de cookies, CORS).

### O que você obtém

- Construtor de comandos responsivo para os modos scan, recon, estimate, recon+estimate, list e PDF-from-JSON
- Feed de console em tempo real e progresso ao vivo por estágio durante a execução
- Snapshots de artefatos por job para saídas HTML / PDF / JSON
- Orientação nos modos Developer Mode, Code Review Mode ou Both para resultados e relatórios; Both é o padrão
- Navegação rápida no navegador entre formulário de execução, feed ao vivo, artefatos e jobs recentes
- Navegador de diretórios integrado para selecionar caminhos de destino (ciente do SO: Windows, macOS, Linux / Docker)

Nos bastidores, a CLI continua sendo a fonte da verdade - ela realiza toda a varredura e gera cada saída HTML / PDF / JSON. A Web UI executa um job ativo por vez e faz snapshot das saídas de cada job concluído em `runtime/webui/jobs/<job-id>/artifacts/` para que relatórios anteriores permaneçam acessíveis.

### Executando a CLI no Docker

Você também não precisa de um ambiente Python local para usar a CLI - ela está disponível como um serviço Compose próprio, construído a partir da mesma imagem:

```bash
docker compose run --rm cli -h
docker compose run --rm cli -r auto -t /scan-targets/path/to/source
```

### O que há na imagem

- Backend FastAPI + frontend Web UI
- A CLI completa do Daksh SCRA, como um serviço separado
- Playwright Chromium, para geração de PDF
- Volumes persistentes `reports/` e `runtime/`
- Montagens de caminhos do host para que as varreduras possam alcançar árvores de código-fonte de dentro do contêiner

**Pontos de montagem principais:**

| Montagem | Caminho dentro do contêiner |
|---|---|
| Código-fonte do projeto | `/app` |
| Raiz de varredura padrão (repositório, ou `DAKSH_SCAN_ROOT`) | `/scan-targets` |
| Sistema de arquivos do host (unidade do sistema no Windows) | `/host/root` |
| Unidades adicionais do Windows/WSL | `/host/drives/<letter>` |
| Diretório home do usuário atual | `/host/user` |
| Pastas comuns do host | `/host/locations/<name>` |
| `DAKSH_HOST_SOURCE` opcional | `/host/source` |

Copie `.env.example` para `.env` para substituições opcionais de caminho e autenticação.
`DAKSH_BROWSE_ROOTS` é uma lista de permissões separada por vírgulas de caminhos do **contêiner**;
deixe-a sem definir para descobrir os locais montados. Listas de permissões obsoletas `/host/c`, `/host/d`
ou `/mnt` devem ser removidas ou atualizadas ao mudar para o helper.
As pastas do host são somente leitura; relatórios e dados de runtime permanecem graváveis em seus
locais existentes da aplicação. Reinicie usando o helper após anexar outra
unidade. Nenhum socket Docker ou contêiner privilegiado é necessário.

---

## Configuração da CLI

Prefere executar o Daksh SCRA diretamente com Python? Veja como configurá-lo localmente.

### Pré-requisitos

- Python 3.8+
- Todas as bibliotecas listadas em `requirements.txt`

### 1. Baixar o Daksh SCRA

```bash
git clone https://github.com/coffeeandsecurity/DakshSCRA.git
```

Ou baixe o zip mais recente em [https://github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) e descompacte-o.

### 2. Configure um Ambiente Virtual

> 💡 O ambiente virtual pode ser criado em qualquer diretório - ele não precisa estar dentro da pasta DakshSCRA.

**Opção A: Configuração em uma etapa (recomendada)**

```bash
python setup_env.py
```

Este script cria o ambiente virtual, instala todas as dependências e instala o navegador Chromium do Playwright (necessário para exportação em PDF).

**Opção B: Configuração manual**

Windows:
```bash
python -m venv daksh-env
.\daksh-env\Scripts\activate
```

macOS / Linux:
```bash
python3 -m venv daksh-env
source daksh-env/bin/activate
```

Em seguida, instale as dependências:
```bash
cd path/to/DakshSCRA
pip install -r requirements.txt
playwright install chromium
```

## Uso da CLI

Use `python` dentro de um ambiente virtual, ou `python3` fora dele.

### Opções de Linha de Comando

```
usage: dakshscra.py [-h] [-r RULES] [-f FILE_TYPES] [-v] [-t TARGET_DIR]
                    [-l {R,RF}] [--recon] [--rs] [--estimate]
                    [-rpt FORMATS] [--pdf-from-json]
                    [--json-input-dir PATH] [--pdf-output PATH]
                    [--pdf-multi-dir PATH] [--pdf-single-only]
                    [--skip-analysis] [--loc]
                    [--baseline-file PATH] [--baseline-generate] [--no-baseline]
                    [--review-config PATH]
                    [--resume-scan] [--state-file PATH] [--no-state] [--state]
```

| Opção | Descrição |
|---|---|
| `-r RULES` | Regras de plataforma (por exemplo, `php`, `java`, `php,java`) ou `auto` para deteção automática |
| `-f FILE_TYPES` | Substituir os tipos de ficheiro predefinidos para a análise |
| `-v` | Nível de verbosidade (`-v`, `-vv`, `-vvv`) |
| `-t TARGET_DIR` | Diretório do código-fonte alvo |
| `-l {R,RF}` | Listar regras de plataforma + frameworks `[R]` ou incluir tipos de ficheiro `[RF]` |
| `--recon` | Executar reconhecimento (deteção de plataforma / framework / linguagem) |
| `--rs`, `--recon-strict` | Reconhecimento estrito: apenas deteções de alta confiança (usar com `--recon`) |
| `--estimate` | Estimar o esforço de revisão de código com base no tamanho da base de código |
| `-rpt`, `--report FORMATS` | Formatos de relatório: `html`, `pdf`, `docx`, `json`, ou uma combinação separada por vírgulas (predefinição: `html`) |
| `--pdf-from-json` | Gerar relatório(s) PDF a partir de saídas JSON existentes sem reanalisar |
| `--json-input-dir PATH` | Diretório de relatórios JSON (predefinição: `./reports/data`) |
| `--pdf-output PATH` | Caminho de saída de um único PDF (predefinição: `./reports/scan/pdf/report.pdf`) |
| `--pdf-multi-dir PATH` | Diretório de saída de PDFs multi-ficheiro (predefinição: `./reports/scan/pdf/multi-file`) |
| `--pdf-single-only` | Gerar apenas o PDF combinado de ficheiro único; ignorar o conjunto multi-ficheiro por plataforma |
| `--skip-analysis` | Desativar a fase de análise para esta execução |
| `--loc` | Contar linhas de código efetivas |
| `--baseline-file PATH` | Ficheiro de linha de base de supressão (JSON) |
| `--baseline-generate` | Gerar linha de base de supressão a partir dos resultados atuais |
| `--no-baseline` | Desativar a supressão por linha de base para esta execução |
| `--review-config PATH` | Ficheiro de triagem de resultados (JSON); suprimir falsos positivos previamente revistos dos relatórios |
| `--resume-scan` | Retomar uma análise anteriormente interrompida a partir do ficheiro de estado |
| `--state-file PATH` | Caminho personalizado do ficheiro de estado / checkpoint da análise |
| `--no-state` | Desativar o checkpoint do estado da análise para esta execução |
| `--state` | Forçar a ativação do checkpoint do estado da análise para esta execução |

### Exemplo de Utilização

> `-f` (tipos de ficheiro) é opcional. Se não for especificado, o DakshSCRA utiliza os tipos de ficheiro predefinidos para a(s) plataforma(s) selecionada(s).

```bash
# Single platform scan
python dakshscra.py -r php -t /path/to/source

# Multiple platforms
python dakshscra.py -r php,java,cpp -t /path/to/source

# Auto-detect platform and apply matching rules
python dakshscra.py -r auto -t /path/to/source

# Override filetypes
python dakshscra.py -r php -f dotnet -t /path/to/source

# Reconnaissance only (no scanning)
python dakshscra.py --recon -t /path/to/source

# Reconnaissance + scanning
python dakshscra.py --recon -r php -t /path/to/source

# Strict recon (high-confidence detections only)
python dakshscra.py --recon --rs -t /path/to/source

# Effort estimation
python dakshscra.py --estimate -t /path/to/source

# Scan with HTML + PDF report output
python dakshscra.py -r auto -t /path/to/source -rpt html,pdf

# Verbosity levels
python dakshscra.py -r php -v -t /path/to/source     # default
python dakshscra.py -r php -vvv -t /path/to/source   # show all pattern checks

# Generate suppression baseline from current findings
python dakshscra.py -r auto -t /path/to/source --baseline-generate

# Apply suppression baseline (suppress known FPs)
python dakshscra.py -r auto -t /path/to/source --baseline-file config/suppressions.json

# Disable baseline for this run
python dakshscra.py -r auto -t /path/to/source --no-baseline

# Apply findings triage / review config
python dakshscra.py -r auto -t /path/to/source --review-config config/review.json

# Scan with checkpoint state enabled
python dakshscra.py -r auto -t /path/to/source --state

# Resume an interrupted scan
python dakshscra.py -r auto -t /path/to/source --resume-scan

# Resume with a custom state file
python dakshscra.py -r auto -t /path/to/source --resume-scan --state-file runtime/scan_state.json

# Generate PDF from existing JSON outputs (no re-scan)
python dakshscra.py --pdf-from-json

# Generate PDF from a custom JSON directory
python dakshscra.py --pdf-from-json --json-input-dir ./custom/reports/data

# Custom output paths for PDF
python dakshscra.py --pdf-from-json --pdf-output ./reports/scan/pdf/custom.pdf --pdf-multi-dir ./reports/scan/pdf/multi-file

# Single combined PDF only (skip per-platform set)
python dakshscra.py --pdf-from-json --pdf-single-only
```

### Regras e Frameworks de Plataformas Suportadas

```bash
python dakshscra.py -l R    # List platform rules and framework mappings
python dakshscra.py -l RF   # List platform rules, framework mappings, and filetypes
```

Plataformas e mapeamentos de frameworks atualmente suportados:

<!-- supported-platforms:start -->
| Plataforma | Frameworks |
|---|---|
| dotnet | aspnetcore, blazor, entityframework, identity |
| php | codeigniter, drupal, laravel, symfony, wordpress, yii |
| java | hibernate, mybatis, spring, springboot, struts |
| javascript | angular, electron, express, nestjs, nextjs, react, vue |
| kotlin | exposed, ktor, springkotlin |
| python | django, fastapi, flask, sqlalchemy |
| go | echo, fiber, gin, gorilla, gorm |
| c | freertos |
| cpp | boost, qt |
| android | cordova-android, flutter-android, ionic-android, jetpack, nativescript-android, reactnative-android, retrofit, room, xamarin-android |
| ios | alamofire, cordova-ios, coredata, flutter-ios, ionic-ios, nativescript-ios, reactnative-ios, swiftui, uikit, xamarin-ios |
| reactnative | expo, reactnative |
| flutter | flutter, flutter-dio, flutter-hive |
| xamarin | xamarin |
| maui | - |
| kmp | - |
| ionic | ionic |
| nativescript | nativescript |
| cordova | cordova |
| bash | - |
| powershell | - |
| dockerfile | - |
| terraform | terraform-aws, terraform-azure, terraform-gcp |
| kubernetes | - |
| ruby | rails, sinatra |
| rust | actix, axum, rocket |
| common | - |
<!-- supported-platforms:end -->

Esta tabela lista os pacotes de regras registrados. Um traço significa que nenhum pacote de framework separado está registrado. A cobertura da análise varia conforme a linguagem e a regra.

Após alterar os registros de plataformas ou frameworks, atualize esta tabela e verifique-a antes de enviar alterações:

```bash
python3 tools/supported_platforms.py
python3 tools/supported_platforms.py --check
```

Para obter as plataformas e frameworks suportados mais recentes, execute sempre:

```bash
python dakshscra.py -l R
```

## Referência de Configuração

### `config/tool.yaml`

Os padrões de execução do Daksh SCRA são controlados através de `config/tool.yaml`.

```yaml
state_management:
  enabled: false
  resume_mode: manual
  persist_after_seconds: 300
  persist_interval_seconds: 30
  default_state_file: runtime/scan_state.json
  cleanup_on_success: false

analysis:
  run_by_default: true
  include_frameworks: true
  report_theme: hacker_mode
```

**Opções de configuração do analisador:**

- `analysis.run_by_default`
  - `true`: o analisador é executado automaticamente durante a varredura
  - `false`: analisador desativado, a menos que seja reativado na configuração ou via CLI
- `analysis.include_frameworks`
  - `true`: incluir entradas do analisador em nível de framework onde existe detecção de framework
  - `false`: apenas saída do analisador em nível de plataforma
- `analysis.report_theme`
  - `hacker_mode`: tema moderno de analisador escuro de alto contraste (padrão)
  - `professional_mode`: tema moderno de analisador claro
  - `both`: gerar ambas as variantes de tema lado a lado

### Regras de Padrão e Regras Semânticas

**As Regras de Padrão identificam áreas de interesse usando padrões e condições contextuais. Um revisor investiga se elas representam problemas de segurança reais.**

**As Regras Semânticas fornecem evidências mais fortes ao analisar relações de código, propagação de entrada e proteções modeladas. Elas podem apoiar um achado ou uma supressão, mas modelagem incompleta, configurações de implantação e comportamento em tempo de execução ainda podem afetar a conclusão.**

Selecione `--rule-mode pattern|semantic|both` (padrão `both`), ou escolha os mesmos modos em New Scan. O modo somente semântico ignora as linhas de base de texto nativas, mantendo verificações refinadas de código-fonte/configuração móvel e modelos de fluxo suportados. Um achado suportado ainda requer confirmação do revisor; a supressão não estabelece segurança.

As verificações integradas são escritas como Regras de Padrão de arquivo único em [`rules/scanning/platform/`](https://github.com/coffeeandsecurity/dakshscra/blob/main/rules/scanning/platform), preservando os diretórios de plataforma e framework. Por exemplo, as verificações Java ficam em `java/java.rules/*.yaml` e as verificações Spring em `java/framework/spring.rules/*.yaml`. Cada arquivo mantém o padrão, as condições contextuais, as descrições de regra e impacto, as orientações para desenvolvedores e revisores, as recomendações e todas as configurações de contexto de código e destaque. Os `review_steps` e `recommendations` acionáveis estendem a orientação original com instruções acionáveis. Adicione um arquivo YAML a um pacote existente, valide-o com `python3 tools/rdl_lint.py rules/scanning/platform` e, em seguida, faça uma varredura em um pequeno fixture positivo/negativo. O scanner o descobre sem editar XML ou um arquivo RDL v1 separado.

As definições semânticas permanecem em [`rules/scanning/logic/rdl/v2/`](https://github.com/coffeeandsecurity/dakshscra/blob/main/rules/scanning/logic/rdl/v2). As linhas de base de texto nativas avaliadas por esse mecanismo permanecem como Regras de Padrão. As seleções legadas de `--rdl-engine` permanecem compatíveis com varreduras salvas e scripts existentes.

Consulte o [guia de autoria e migração de regras](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#pattern-rules-and-semantic-rules) para o formato YAML, condições, validação, configurações de evidência e importação de XML externo.

Os pacotes de plataforma e framework aplicáveis também incluem candidatos à revisão de operações de segurança. Os modelos semânticos distinguem valores de origem de resposta, fontes de vinculação em massa e argumentos de chave criptográfica, e podem rastrear fallbacks de configuração suportados em operações de chave. Os achados recém-gerados associam declarações de controle de método/classe suportadas à operação; a revisão de modelo C# tipado pode reter políticas de campo declaradas. O isolamento de locatários requer um invariante específico da aplicação. Essas são capacidades de revisão respaldadas por evidências com limites de modelagem explícitos, não detecção garantida de todas as falhas de autorização ou lógica de negócios. Consulte [contexto de operação e controle de segurança](https://github.com/coffeeandsecurity/dakshscra/blob/main/docs/usage-guide.md#security-operation-and-control-context).

---

## Estrutura de Saída do Relatório

As saídas da CLI são retidas por varredura em `reports/<project>/<scan>/`. As exportações da CLI e da Web UI compartilham a coleta de dados salvos e os renderizadores para HTML, PDF, Word e JSON. O HTML completo abre um resumo/índice leve com páginas de detalhes paginadas e vinculadas. Na Web UI, gere uma exportação em **Reports**; extraia o ZIP HTML e abra `index.html` primeiro.

```
reports/<project>/<scan>/
├── scan/
│   ├── html/
│   │   ├── report.html                 # Summary and report index (open first)
│   │   ├── report-files/               # Linked detail pages and saved-results.json
│   │   └── multi-file/                 # Per-platform HTML report set
│   ├── pdf/
│   │   ├── report.pdf                  # Single-file PDF scan report
│   │   └── multi-file/                 # Per-platform PDF report set
│   ├── word/
│   │   └── report.docx                 # Editable Word report when requested
│   ├── json/
│   │   └── report.json                 # Complete structured report document
│   ├── recon/
│   │   └── reconnaissance.html         # Reconnaissance HTML report
│   └── estimate/
│       └── estimation.html             # Effort estimation HTML report
├── analysis/
│   └── <platform>/
│       ├── analysis.html               # Taint analysis report (default theme)
│       ├── analysis_professional.html  # Professional theme (if theme=both)
│       ├── analysis_xref.html          # Cross-reference report
│       └── analysis.json               # Structured analysis data
└── data/
    ├── areas_of_interest.json          # AoI findings
    ├── filepaths_aoi.json              # File path AoI findings
    ├── summary.json                    # Scan summary
    ├── recon.json                      # Recon summary
    └── analysis.json                   # Analyzer output
```

Arquivos de runtime (estado de varredura, logs, inventário) são gravados em `runtime/`.

Ao executar via Web UI, as saídas de cada job são adicionalmente capturadas em snapshot em `runtime/webui/jobs/<job-id>/artifacts/` (consulte [Web UI (Docker)](#web-ui-docker)).

---

## Autor

| | |
|---|---|
| Website | [coffeeandsecurity.com](https://www.coffeeandsecurity.com) |
| Email | [email protected] |
| Twitter / X | [@coffeensecurity](https://x.com/coffeensecurity) |
| Fonte | [github.com/coffeeandsecurity/DakshSCRA](https://github.com/coffeeandsecurity/DakshSCRA) |
| Licença | GNU General Public License v3.0 (GPL-3.0) |

Se o DakshSCRA ajudou sua equipe a economizar tempo, esforço ou custo significativos, reduziu a dependência de ferramentas comerciais caras, melhorou a cobertura de revisão ou tornou a revisão de código mais estruturada e eficaz, fique à vontade para entrar em contato e compartilhar sua experiência. Estou sempre aberto a feedbacks ponderados e conversas interessantes.

Encontrou um bug ou quer contribuir? Abra uma issue ou pull request no GitHub.

---

[Read more](https://github.com/coffeeandsecurity/dakshscra)
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    786
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    506
  • 3

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    429
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    345
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    262
  • 6

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    256

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →