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
cve-2023-41564-research — Análise detalhada e prova de conceito para CVE-2023-41564, uma vulnerabilidade de XSS armazenado no Cockpit CMS <=2.6.3, com causa raiz em nível de código e orientações de mitigação. | Kitploit
Ferramentas/GitHubGitHub/sota70/cve-2023-41564-research
Análise de VulnerabilidadesExploraçãoExploração de Aplicações WebSegurança WebTestes de PenetraçãoAprendizado e Educação
GitHubsota70/cve-2023-41564-research

cve-2023-41564-research

Análise detalhada e prova de conceito para CVE-2023-41564, uma vulnerabilidade de XSS armazenado no Cockpit CMS <=2.6.3, com causa raiz em nível de código e orientações de mitigação.

Ver Repositório
35há 1 anoAinda não revisado

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

Visão geral da vulnerabilidade CVE-2023-41564

A CVE-2023-415641 é uma vulnerabilidade de XSS armazenado presente no CMS Cockpit (<= v2.6.3).
Durante o upload de arquivos, se um arquivo HTML com extensão .shtml for enviado, o JavaScript é executado no momento em que o arquivo enviado é aberto.

1: https://nvd.nist.gov/vuln/detail/CVE-2023-41564

Fluxo do ataque

Em primeiro lugar, explicarei o método de ataque com base no PoC2 publicado por quem aparenta ser o relator da vulnerabilidade.
Primeiro, faça login no site com uma conta que tenha permissão de upload de arquivos.
login do cms assets do cms Em seguida, faça upload de um arquivo shtml como o seguinte:

root@kitploit:~

Copie a URL do arquivo enviado (Asset). link do cms Ao acessar o link copiado, o script descrito no HTML acima é executado. xss do cms
2: https://github.com/LongHair00/Mitre_opensource_report/blob/main/CockpitCMS-StoredXSS.md

Detalhes da ocorrência

A partir daqui, explicarei os resultados da minha investigação mais aprofundada.
O processamento do upload de Assets tem como ponto de partida uma requisição POST para o caminho /assets/upload.
O processamento da requisição de upload está definido na linha 513 de modules/Assets/bootstrap.php.
O código é exibido abaixo.

root@kitploit:~
// assets api
$this->module('assets')->extend([

    // 省略
    'upload' => function(string|array $param = 'files', array $meta = [], bool $isUpload = true) {

        $files = [];

        if (is_string($param) && isset($this->app->request->files[$param])) {
            $files = $this->app->request->files[$param];
        } elseif (is_array($param) && isset($param['name'], $param['error'], $param['tmp_name'])) {
            $files = $param;
        }

        $finfo      = finfo_open(FILEINFO_MIME_TYPE);
        $uploaded  = [];
        $failed    = [];
        $_files     = [];
        $assets    = [];

        $allowed   = $this->app->retrieve('assets/allowed_uploads', '*');
        $allowed   = $allowed == '*' ? true : str_replace([' ', ','], ['', '|'], preg_quote(is_array($allowed) ? implode(',', $allowed) : $allowed));
        $max_size  = $this->app->retrieve('assets/max_upload_size', 0);

        $forbiddenExtension = ['bat', 'exe', 'sh', 'php', 'phar', 'phtml', 'phps', 'htm', 'html', 'xhtml', 'htaccess'];
        $forbiddenMime = [
            'application/x-httpd-php', 'application/x-php', 'text/x-php',
            'text/html', 'application/xhtml+xml'
        ];

        if (isset($files['name']) && is_array($files['name'])) {

            $cnt = count($files['name']);

            for ($i = 0; $i < $cnt; $i++) {

                $_file  = $this->app->path('#tmp:').'/'.$files['name'][$i];
                $_mime = $finfo->file($files['tmp_name'][$i]);
                $_isAllowed = $allowed === true ? true : preg_match("/\.({$allowed})$/i", $_file);
                $_sizeAllowed = $max_size ? filesize($files['tmp_name'][$i]) < $max_size : true;

                $extension = strtolower(pathinfo(parse_url($_file, PHP_URL_PATH), PATHINFO_EXTENSION));

                if (!$extension) {
                    $_isAllowed = false;
                }

                // prevent uploading php / html files
                if ($_isAllowed && (
                    in_array($extension, $forbiddenExtension) ||
                    in_array(strtolower($_mime), $forbiddenMime)
                )) {
                    $_isAllowed = false;
                }

                if (!$files['error'][$i] && $_isAllowed && $_sizeAllowed && ($isUpload ? move_uploaded_file($files['tmp_name'][$i], $_file) : rename($files['tmp_name'][$i], $_file))) {

                    $_files[]   = $_file;
                    $uploaded[] = $files['name'][$i];

                    if (\preg_match('/\.(svg|xml)$/i', $_file)) {
                        file_put_contents($_file, \SVGSanitizer::clean(\file_get_contents($_file)));
                    }

                } else {
                    $failed[] = $files['name'][$i];
                }
            }
        }

        if (count($_files)) {

            $assets = $this->add($_files, $meta, isset($meta['_id']));

            foreach ($_files as $file) {
                unlink($file);
            }
        }

        return ['uploaded' => $uploaded, 'failed' => $failed, 'assets' => $assets];
    },
    // 省略
]);

A função upload é armazenada em registry['modules']['assets'], uma variável membro da classe App que armazena as funções do módulo Assets.
Portanto, ao chamar a função upload, ela é invocada da seguinte forma: $this->module('assets')->upload('file', $file);.
A função upload registrada aqui é chamada pela classe Assets4.

root@kitploit:~
public function upload() {
    this->helper('session')->close();
    this->hasValidCsrfToken(true);
    if (!this->isAllowed('assets/upload')) {
        return $this->stop(['error' => 'Upload not allowed'], 401);
    }
    $meta = ['folder' => $this->param('folder', '')];
    return $this->module('assets')->upload('files', $meta);
}

Dá para perceber que é a função upload registrada em registry['modules']['assets'] que está sendo chamada.
Aqui, vamos examinar a função upload definida em bootstrap.php.
Nesse ponto, as extensões proibidas são definidas na variável $forbiddenExtension.
No entanto, a extensão shtml está ausente.
Portanto, essa é a falha que torna possível o upload de arquivos shtml.

3: https://github.com/Cockpit-HQ/Cockpit/blob/2.6.3/modules/Assets/bootstrap.php#L51
4: https://github.com/Cockpit-HQ/Cockpit/blob/2.6.3/modules/Assets/Controller/Assets.php#L140

Mitigação

Como a causa é o shtml não estar na lista de extensões proibidas, é possível aplicar a correção adicionando shtml a forbiddenExtension.

root@kitploit:~
$forbiddenExtension = ['bat', 'exe', 'sh', 'php', 'phar', 'phtml', 'phps', 'htm', 'html', 'xhtml', 'htaccess', 'shtml'];
Baixar ferramenta