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
Ferramentas/GitHubGitHub/dshankle/vlc_cve-2021-25804_analysis
Análise de VulnerabilidadesAnálise de CódigoExploraçãoAnálise de BináriosPapers e PesquisaAprendizado e Educação
GitHubdshankle/vlc_cve-2021-25804_analysis

VLC_CVE-2021-25804_Analysis

Análise técnica aprofundada do CVE-2021-25804, uma vulnerabilidade do analisador AVI do VLC. Inclui causa raiz, diff do patch e primitivas de exploração para pesquisadores de segurança.

Ver Repositório
34há 4 anosAinda não revisado
Compartilhar

Um arquivo AVI pode ter múltiplas faixas. Por exemplo, uma faixa de áudio e uma faixa de vídeo.

Para analisar um número arbitrário de faixas, o VLC primeiro deve determinar se uma determinada faixa está finalizada e reproduzível. Duas variáveis são configuradas com esse propósito. Ambas chamadas i_track.

A variável p_sys representa o arquivo avi para nossos propósitos. Assim, a variável i_track "oficial" que será usada para referenciar as faixas que são determinadas como finalizadas e reproduzíveis é p_sys->i_track. Ela é inicializada com uma macro aqui:

```
TAB_INIT(p_sys->i_track, p_sys->track);
//#define TAB_INIT( count, tab ) do {(count) = 0; (tab) = NULL; } while(0)
```

Enquanto isso, uma segunda variável i_track é configurada para contar TODAS as faixas, independentemente de estarem finalizadas/reproduzíveis ou não.

```
i_track = AVI_ChunkCount( p_hdrl, AVIFOURCC_strl, true );
```

A segunda i_track representa todos os chunks começando com 'strl'. Ela controla um loop 'for' que define a variável p_sys->i_track apenas se passar por uma série de verificações:

```
for( unsigned i = 0 ; i < i_track; i++ )
{
    ...

TAB_APPEND( p_sys->i_track, p_sys->track, tk );
//#define TAB_APPEND( count, tab, p ) {TAB_APPEND_CAST( , count, tab, p )}
//TAB_APPEND_CAST( ,p_sys->i_track, p_sys->track, tk)
        //if( (count) > 0 ) (tab) = cast realloc( tab, sizeof( *(tab) ) * ( (count) + 1 ) ); 
        //else  (tab) = cast malloc( sizeof( *(tab) ) );    
        //if( !(tab) ) abort();                       
        //(tab)[count] = (p);                         
        //(count)++; //p_sys->i_track incremented here
}
```

Durante um loop 'for' subsequente, a variável p_sys->i_track é utilizada como o número do chunk em uma chamada para AVI_ChunkFind, que retorna o n-ésimo chunk que corresponde a um valor de chunk FOURCC, no nosso caso 'strl':

```
for( unsigned i = 0 ; i < p_sys->i_track; i++ )
{
    avi_track_t         *tk = p_sys->track[i];

    if( tk->fmt.i_cat != AUDIO_ES ||
        tk->idx.i_size < 1 ||
        tk->i_scale != 1 ||
        tk->i_samplesize != 0 )
        continue;
        
    //CVE-2021-25804
    avi_chunk_list_t *p_strl = AVI_ChunkFind( p_hdrl, AVIFOURCC_strl, i, true );
    //subsequently changed to: avi_chunk_list_t *p_strl = AVI_ChunkFind( p_hdrl, AVIFOURCC_strl, tk->fmt.i_id, true );

    avi_chunk_strf_t *p_strf = AVI_ChunkFind( p_strl, AVIFOURCC_strf, 0, false );
    if( !p_strf || p_strf->i_cat != AUDIO_ES )
        continue;

    const WAVEFORMATEX *p_wf = p_strf->u.p_wf;
```

Embora p_sys->i_track conte o número correto de faixas concluídas, ele não mantém registro de qual número de chunk foi definido. Isso significa que, se houver um chunk strl inválido antes do chunk strl válido, o primeiro chunk será corretamente ignorado ao configurar o objeto de faixa, mas quando ChunkFind é chamado, ele ainda selecionará o primeiro chunk inválido.

Após a criação do CVE-2021-25804, o problema foi corrigido alterando a variável de número do chunk do ChunkFind de i para tk->fmt.i_id. tk->fmt.i_id é definido logo acima da chamada TAB_APPEND() que vimos anteriormente:

```
tk->fmt.i_id = i;

if( p_strn && p_strn->p_str )
    tk->fmt.psz_description = FromACP( p_strn->p_str );
//see es_format_truncated.c 
tk->p_es = es_out_Add( p_demux->out, &tk->fmt );


TAB_APPEND( p_sys->i_track, p_sys->track, tk );
```

Isso parece corrigir o problema, pois tk->fmt.i_id é definido como i e, portanto, o chunk concluído deve ser o selecionado por ChunkFind(). No entanto, testes revelam que, na verdade, o valor de tk->fmt.i_id está definido como -1 no momento da chamada problemática para ChunkFind(). Este é o valor de inicialização definido durante uma chamada a es_format_Init().

```
void es_format_Init( es_format_t *fmt,
                 int i_cat, vlc_fourcc_t i_codec )
{
    memset(fmt, 0, sizeof (*fmt));
    fmt->i_cat                  = i_cat;
    fmt->i_codec                = i_codec;
    fmt->i_profile              = -1;
    fmt->i_level                = -1;
    fmt->i_id                   = -1;
    fmt->i_priority             = ES_PRIORITY_SELECTABLE_MIN;
    fmt->psz_language           = NULL;
    fmt->psz_description        = NULL;
    fmt->p_extra_languages      = NULL;

    if (fmt->i_cat == VIDEO_ES)
        video_format_Init(&fmt->video, 0);

    fmt->b_packetized           = true;
    fmt->p_extra                = NULL;
}

```

Essa inicialização ocorre no mesmo loop 'for' em que fmt->i_id é definido como i.

```
    for( unsigned i = 0 ; i < i_track; i++ )
{
    ...
     switch( p_strh->i_type )
    {
        case( AVIFOURCC_auds ):
        {
            es_format_Init( &tk->fmt, AUDIO_ES, 0 );
            ...
        }
            ...
    }
    tk->fmt.i_id = i;

    if( p_strn && p_strn->p_str )
        tk->fmt.psz_description = FromACP( p_strn->p_str );

    tk->p_es = es_out_Add( p_demux->out, &tk->fmt );

    TAB_APPEND( p_sys->i_track, p_sys->track, tk );
}

```
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.

    614
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    476
  • 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.

    389
  • 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.

    334
  • 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.

    257
  • 6

    antifox

    antifox-ai/antifox

    Plataforma de testes de penetração autónoma com multiagentes de IA que executa reconhecimento, descoberta de superfície de ataque, validação de exploração e entrega de relatórios com evidências.

    247

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →