cybercore-systems/cybercore-signer
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

feat: initial commit - cybercore signer desktop agent

Browse Source
This commit is contained in:
Claudecio Martins
2026-10-11 08:20:24 -03:00
commit ccfa358f97
206 changed files with 23952 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/CCSP.md
+208
View File
@@ -0,0 +1,208 @@
# CyberCore Signing Protocol (CCSP/1)
O **CyberCore Signing Protocol (CCSP)** é o protocolo padrão para comunicação local entre aplicações web rodando no navegador e o agente desktop **CyberCore Signer**.
A versão inicial descrita neste documento é a **CCSP/1**.
---
## 1. Princípios de Segurança
1. **Isolamento de Rede:** O servidor local escuta exclusivamente no endereço de loopback `127.0.0.1` (porta padrão `21325`), impedindo qualquer acesso a partir da rede local (LAN) ou externa (WAN).
2. **Controle Estrito de Origem (CORS):** O agente valida cabeçalhos `Origin` e responde apenas a pré-voos `OPTIONS` com origens autorizadas.
3. **Registro e Autorização de Aplicações:** Nenhuma aplicação desconhecida tem acesso a certificados ou assinaturas. Ao tentar conectar pela primeira vez, uma caixa de diálogo nativa solicita aprovação explícita do usuário.
4. **Confirmação Visual da Assinatura:** Toda operação de assinatura exige confirmação manual na interface gráfica, exibindo a aplicação solicitante, o hash do documento e o certificado selecionado.
5. **Proteção Contra Ataques de Replay:** Toda requisição deve conter um `nonce` UUID único com validação temporal (`expires_at` ou `timestamp`). Requisições com nonces repetidos são sumariamente rejeitadas (`REPLAY_DETECTED`).
6. **Privacidade Criptográfica:** Apenas o **digest (hash)** do documento é enviado ao agente. O documento completo nunca sai da aplicação web e a chave privada nunca sai do dispositivo/computador do usuário.
---
## 2. Endpoints do Protocolo (CCSP/1)
### 2.1 `GET /ccsp/v1/status`
Verifica se o agente está instalado, em execução e pronto para operações.
#### Resposta de Sucesso (200 OK)
```json
{
"version": "1",
"status": "ready",
"agent": "CyberCore Signer",
"agent_version": "0.1.0",
"os": "Windows 11",
"timestamp": "2026-10-08T19:40:00Z"
}
```
---
### 2.2 `GET /ccsp/v1/certificates`
Retorna a lista de certificados digitais atualmente disponíveis e aptos para assinatura.
#### Headers / Parâmetros
- `X-CyberCore-AppId`: UUID da aplicação autorizada (ou query param `?application_id=uuid`).
- `Origin`: Origem web autorizada.
#### Resposta de Sucesso (200 OK)
```json
{
"version": "1",
"status": "success",
"certificates": [
{
"id": "win-4340656a",
"alias": "CLAUDIO SILVA:12345678900",
"common_name": "CLAUDIO SILVA:12345678900",
"subject_dn": "CN=CLAUDIO SILVA:12345678900, OU=Autenticado por AR, O=ICP-Brasil, C=BR",
"issuer_dn": "CN=AC SERPRO v5, O=ICP-Brasil, C=BR",
"type": "A3",
"provider_id": "provider-win-store",
"device_name": "Token / Smart Card (Windows CAPI/CNG)",
"valid_from": "2024-05-10T12:00:00Z",
"valid_to": "2027-05-10T12:00:00Z",
"serial_number": "72910482910482019482",
"can_sign": true,
"status": "AVAILABLE"
}
]
}
```
---
### 2.3 `POST /ccsp/v1/authorize`
Handshake inicial de uma nova aplicação web para solicitar autorização ao usuário.
#### Requisição
```json
{
"version": "1",
"application_id": "550e8400-e29b-41d4-a716-446655440000",
"name": "Portal Assinaturas Jurídicas"
}
```
#### Resposta (200 OK)
```json
{
"version": "1",
"status": "authorized",
"application_id": "550e8400-e29b-41d4-a716-446655440000"
}
```
---
### 2.4 `POST /ccsp/v1/sign`
Executa a assinatura digital do digest informado (PDF, XML, documentos ou arquivos gerais).
#### Requisição
```json
{
"version": "1",
"request_id": "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d",
"application_id": "550e8400-e29b-41d4-a716-446655440000",
"operation": "sign",
"algorithm": "SHA256withRSA",
"digest": "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=",
"certificate_hint": "win-4340656a",
"document_name": "contrato_locacao.pdf",
"document_type": "PDF",
"nonce": "c4ca4238a0b923820dcc509a6f75849b",
"expires_at": "2026-10-08T19:45:00Z"
}
```
#### Resposta de Sucesso (200 OK)
```json
{
"version": "1",
"request_id": "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d",
"status": "signed",
"signature": "MEUCIQDq...base64...",
"certificate": "MIIFazC...base64...",
"certificate_chain": [
"MIIFazC...base64...",
"MIIEazC...base64..."
],
"algorithm": "SHA256withRSA",
"subject_name": "CLAUDIO SILVA",
"subject_cpf_cnpj": "12345678900",
"document_name": "contrato_locacao.pdf",
"document_type": "PDF"
}
```
---
### 2.5 `POST /ccsp/v1/authenticate`
Executa o login / autenticação digital segura de um usuário em sistemas web via desafio criptográfico (Challenge-Response ICP-Brasil).
#### Requisição
```json
{
"version": "1",
"request_id": "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d",
"application_id": "550e8400-e29b-41d4-a716-446655440000",
"operation": "authenticate",
"challenge": "server-session-challenge-nonce-2026",
"certificate_hint": "win-4340656a",
"purpose": "AUTHENTICATION",
"nonce": "c4ca4238a0b923820dcc509a6f75849b",
"expires_at": "2026-10-08T19:45:00Z"
}
```
#### Resposta de Sucesso (200 OK)
```json
{
"version": "1",
"request_id": "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d",
"status": "authenticated",
"signature": "MEUCIQDq...base64...",
"certificate": "MIIFazC...base64...",
"certificate_chain": [
"MIIFazC...base64..."
],
"algorithm": "SHA256withRSA",
"subject_name": "CLAUDIO SILVA",
"subject_cpf_cnpj": "12345678900",
"document_type": "AUTH_CHALLENGE"
}
```
#### Resposta de Erro (400/403/404)
```json
{
"version": "1",
"request_id": "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d",
"status": "error",
"error_code": "USER_CANCELLED",
"message": "Operação de assinatura cancelada pelo usuário."
}
```
---
## 3. Tabela de Códigos de Erro Estruturados
| Código | Significado |
|---|---|
| `CERTIFICATE_NOT_FOUND` | Certificado indicado no hint não foi encontrado. |
| `CERTIFICATE_EXPIRED` | O certificado selecionado está fora do período de vigência. |
| `CERTIFICATE_INVALID` | O certificado é inválido ou corrompido. |
| `PRIVATE_KEY_NOT_AVAILABLE` | Chave privada inacessível ou ausente. |
| `TOKEN_NOT_FOUND` | Nenhum dispositivo ou leitor compatível foi localizado. |
| `TOKEN_REMOVED` | Dispositivo de hardware foi removido durante a assinatura. |
| `PIN_REQUIRED` | PIN obrigatório para liberar chave privada em PKCS#11. |
| `PIN_INCORRECT` | PIN digitado está incorreto. |
| `PKCS11_ERROR` | Falha no middleware PKCS#11 do fabricante. |
| `SIGNATURE_FAILED` | Erro durante a geração da assinatura digital. |
| `APPLICATION_NOT_AUTHORIZED` | Aplicação não autorizada ou recusada pelo usuário. |
| `REQUEST_EXPIRED` | A data/hora de validade da requisição expirou. |
| `REPLAY_DETECTED` | O nonce informado já foi processado anteriormente. |
| `INVALID_ORIGIN` | O cabeçalho Origin não corresponde ao cadastro da aplicação. |
| `UNSUPPORTED_ALGORITHM` | Algoritmo não suportado (ex: diferente de SHA256withRSA). |
| `USER_CANCELLED` | O usuário clicou em Cancelar ou fechou a janela de confirmação. |
| `PROVIDER_NOT_AVAILABLE` | O provedor criptográfico necessário está inativo no SO. |
| `COMMUNICATION_ERROR` | Erro interno no agente de comunicação local. |
docs/a1-a3-certificates.md
+46
View File
@@ -0,0 +1,46 @@
# Certificados Digitais A1, A3 e PKCS#11
O **CyberCore Signer** oferece suporte abrangente aos formatos e repositórios de certificados digitais padrão ICP-Brasil utilizados no Brasil.
---
## 1. Certificados Digitais A1 (Software / PKCS#12)
Os certificados A1 são arquivos com extensão `.pfx` ou `.p12` protegidos por senha.
### Fluxo de Uso
1. O usuário seleciona o arquivo via diálogo nativo (`FileChooser`) na interface ou importa via tela de Dashboard.
2. É solicitada a senha em um diálogo seguro (`A1PasswordDialog`), mantida em `char[]` temporário e sobrescrita com zeros logo após a leitura da chave.
3. O provedor `Pkcs12CertificateProvider` instancia um `KeyStore.getInstance("PKCS12")` e extrai os metadados do certificado X.509 (`subject`, `issuer`, `validade`, `algoritmo`, `tamanho da chave`).
4. Durante a assinatura, a chave privada em memória gera a assinatura digital via `Signature.getInstance("SHA256withRSA")`.
---
## 2. Certificados Digitais A3 no Windows (Windows Certificate Store)
No Windows 10/11, a maioria dos drivers de tokens USB e Smart Cards (ex: SafeSign, SafeNet Authentication Client, Serpro, Certisign) registra seus certificados diretamente no repositório de certificados do usuário (`Windows-MY`).
### Vantagens do Provider `WindowsCertificateStoreProvider`
- Acessa certificados físicos via CryptoAPI (CAPI) e Cryptography Next Generation (CNG) através do provedor JDK `SunMSCAPI`.
- A chave privada permanece dentro do chip criptográfico do token.
- Quando o token exige autenticação por PIN, a janela nativa do próprio driver do fabricante é invocada com segurança pelo sistema operacional Windows.
---
## 3. Hardware PKCS#11 Direto (Tokens USB e Smartcards)
Para ambientes onde se deseja acesso direto ao middleware ou no Linux:
- `Pkcs11CertificateProvider` pesquisa bibliotecas DLL / SO padrão:
- `eps2003csp11.dll` (SafeNet / eToken)
- `aetpkss1.dll` (SafeSign AET)
- `acospkcs11.dll` (ACOS / G&D)
- `opensc-pkcs11.dll` / `opensc-pkcs11.so` (OpenSC)
- Utiliza o provider SunPKCS11 do JDK (`jdk.crypto.cryptoki`).
---
## 4. Monitoramento Dinâmico de Hardware (`SmartCardWatcher`)
O componente `SmartCardWatcher` monitora os leitores PC/SC em segundo plano:
- **Ao inserir um token:** Atualiza a lista de certificados automaticamente e notifica a interface gráfica.
- **Ao remover o token:** Registra evento de auditoria (`AUDITORIA [TOKEN_REMOVED]`), limpa o cache de PIN de sessão em `PinSessionManager` e força um warm reset via `SmartCardSessionManager`.
docs/architecture.md
+79
View File
@@ -0,0 +1,79 @@
# Arquitetura do CyberCore Signer
O **CyberCore Signer** é um agente desktop nativo desenvolvido em Java 21+ LTS (Java 25 LTS) com interface JavaFX e segurança criptográfica JCA/JCE pura, projetado para permitir que aplicações web autorizadas solicitem assinaturas digitais ICP-Brasil padrão **A1** e **A3** diretamente da máquina do usuário.
---
## 1. Visão Geral da Arquitetura em Módulos
O projeto adota uma arquitetura desacoplada em múltiplos módulos Maven independentes:
```
cybercore-signer/
├── modules/
│ ├── cybercore-core/ # Núcleo de criptografia, provedores, protocolo e segurança
│ ├── cybercore-ui/ # Interface gráfica JavaFX, diálogos nativos e System Tray
│ └── cybercore-app/ # Ponto de entrada (Main), bootstrap e empacotamento nativo
├── sdk/ # SDK Web em JavaScript (@cybercore/signer-sdk)
├── scripts/ # Scripts de build nativo jpackage para Windows e Linux
└── docs/ # Especificações técnicas e manuais de integração
```
### 1.1 `cybercore-core`
- **Domínio:** Modelos imutáveis como `ManagedCertificate`, `SigningContext`, `SigningResult`, `CertificateType` e `CertificateStatus`.
- **Criptografia:** `SigningService` e `DigestAlgorithm` utilizando exclusivamente os provedores padrão JCA/JCE (sem reimplementação manual de algoritmos).
- **Provedores:** Abstração `CertificateProvider` com implementações:
- `Pkcs12CertificateProvider`: leitura de arquivos `.pfx`/`.p12` em memória protegida.
- `WindowsCertificateStoreProvider`: integração nativa com o repositório de chaves do Windows (`Windows-MY` via SunMSCAPI/CNG).
- `Pkcs11CertificateProvider`: integração com drivers de middleware e tokens USB/Smartcards via `SunPKCS11`.
- **Protocolo & Rede Local:** `CcspServer` escuta estritamente em `127.0.0.1:21325`, fornecendo a API REST CCSP/1.
- **Segurança & Configurações:** `ApplicationRegistry`, `NonceManager` (proteção anti-replay), `OriginValidator`, `SmartCardSessionManager` e `AgentConfigurationService` (persistência em `~/.cybercore/config.json`).
- **Validação Criptográfica:** `SignatureValidationService` com suporte a Assinaturas Incorporadas (PAdES PDF, CMS/P7M com conteúdo embutido, XMLDSig) e Assinaturas Destacadas (Detached CMS/P7S).
- **Selos Visuais Personalizados:** `CustomSealStorage` (persistência em `~/.cybercore/seals/`), `PdfSealThemeRegistry` dinâmico e `CpfDisplayMode` (privacidade LGPD).
### 1.2 `cybercore-ui`
- Interface desenvolvida com JavaFX 25, empregando layout moderno e simétrico de grade 3x3 de operações e coluna lateral de utilitários:
- `MainAppView`: grade 3x3 otimizada:
- Linha 0: Assinar PDF, Assinar XML, Assinatura Atachada
- Linha 1: Co-Assinar Documento, Carimbo do Tempo, Gerenciar Selos
- Linha 2: Validar Assinatura, Validar Carimbo, Sair do Agente
- `SealDesignerDialog`: criador e instalador de selos digitais personalizados com pré-visualização ao vivo (Live Preview), seletores de cores, estilos de emblema, obrigatoriedade de nome completo, controle de mascaramento de CPF e estampa de data/hora.
- `SignatureValidationDialog`: diálogo de validação criptográfica real com alternância entre Assinatura Incorporada e Assinatura Destacada, extração de documento embutido e relatório de signatários.
- `PdfSignDialog`: modal de assinatura PAdES com posicionamento por clique na folha, atalho direto para criar/instalar selos e opções dinâmicas de CPF/data-hora.
- `SettingsView`: configurações gerais persistentes, política de PIN e gerenciamento de selos instalados.
### 1.3 `cybercore-app`
- Main bootstrap (`CyberCoreSignerApplication`).
- Tratamento de parâmetros de inicialização (`--dev`, `--headless`).
- Execução de diagnósticos preliminares de ambiente e engine criptográfica antes do início das threads de escuta.
- Geração de Fat JAR autocontido via `maven-shade-plugin` e preparação para distribuição `jpackage`.
---
## 2. Fluxo de Dados e Princípio de Menor Privilégio
O CyberCore Signer opera sob o **modelo de assinatura descentralizada por digest**:
1. A aplicação web calcula o hash criptográfico SHA-256 no próprio navegador utilizando a Web Crypto API nativa.
2. Apenas o hash Base64 de 32 bytes trafega localmente para o CyberCore Signer.
3. O documento completo nunca sai do navegador e a chave privada nunca sai do computador ou do hardware do usuário.
```mermaid
sequenceDiagram
autonumber
actor Usuario as Usuário
participant Web as Aplicação Web (SDK)
participant CCSP as CcspServer (127.0.0.1)
participant UI as CyberCore JavaFX
participant Crypto as SigningService & Providers
Web->>CCSP: POST /ccsp/v1/sign (digest, appId, certHint, nonce)
CCSP->>CCSP: Valida autorização, nonce anti-replay e digest
CCSP->>UI: Solicita confirmação visual (requestSignatureConfirmation)
UI->>Usuario: Exibe Diálogo (Hash, Certificado, Aplicação)
Usuario->>UI: Aprova assinatura (e insere PIN se A3)
UI-->>CCSP: Confirmação concedida
CCSP->>Crypto: sign(SigningContext) [Trava FIFO]
Crypto->>Crypto: JCA/JCE Signature.update(digest) + sign()
Crypto-->>CCSP: SigningResult (signatureBytes, certChain)
CCSP-->>Web: JSON { status: "signed", signature: "...", certificate: "..." }
```
docs/authentication-login.md
+71
View File
@@ -0,0 +1,71 @@
# Autenticação e Login Digital via CyberCore Signer
Este documento descreve o fluxo de **Login e Autenticação de Usuários com Certificado Digital ICP-Brasil (A1 e A3)** através do agente desktop **CyberCore Signer** e o protocolo **CCSP/1**.
---
## 1. Visão Geral do Modelo de Autenticação
O login por certificado digital no CyberCore Signer adota o padrão de mercado **Challenge-Response Criptográfico**:
1. O backend da sua aplicação web gera um **desafio único (challenge / nonce)** para a sessão atual.
2. A aplicação web solicita a assinatura desse desafio ao **CyberCore Signer** através do SDK JavaScript.
3. O CyberCore Signer apresenta ao usuário na tela nativa do computador uma solicitação visual com destaque de **LOGIN / AUTENTICAÇÃO**:
- Identifica a aplicação solicitante e a origem;
- Mostra o certificado selecionado e o titular;
- Solicita aprovação expressa do usuário (e a digitação do PIN caso seja token ou smart card A3).
4. O CyberCore assina o desafio com a chave privada do certificado local e devolve:
- A **assinatura digital do desafio**;
- O **certificado X.509 completo** (DER Base64) e cadeia;
- O **nome e CPF/CNPJ** do titular extraídos do certificado.
5. O frontend web envia a resposta de volta ao backend, que:
- Valida criptograficamente a assinatura com a chave pública do certificado recebido;
- Confirma a validade e cadeia do certificado junto à ICP-Brasil;
- Localiza o usuário correspondente no banco de dados pelo CPF/CNPJ;
- Cria a sessão autenticada do usuário no sistema.
---
## 2. Exemplo de Integração Frontend com o SDK
```javascript
import { CyberCoreSigner } from '@cybercore/signer-sdk';
const signer = new CyberCoreSigner({
applicationName: 'Portal Corporativo'
});
async function realizarLoginComCertificado(certificateId) {
// 1. Obter desafio único gerado pelo seu backend
const { challenge } = await fetch('/api/auth/challenge').then(r => r.json());
// 2. Solicitar autenticação ao CyberCore Signer
const authResult = await signer.authenticate({
certificateId: certificateId,
challenge: challenge
});
// 3. Enviar assinatura e certificado ao backend para validação e abertura de sessão
const sessionResponse = await fetch('/api/auth/login-certificate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
challenge: authResult.challenge,
signature: authResult.signature,
certificate: authResult.certificate
})
});
if (sessionResponse.ok) {
console.log('Usuário autenticado com sucesso:', authResult.subjectName);
window.location.href = '/dashboard';
}
}
```
---
## 3. Segurança e Prevenção de Ataques
- **Prevenção de Ataques de Replay:** Cada desafio deve possuir tempo de expiração curto (ex: 60 a 90 segundos) e ser descartado no servidor após uma única tentativa.
- **Proteção da Chave Privada:** A chave privada e o PIN do usuário permanecem exclusivamente sob custódia do hardware/computador local do usuário.
- **Consentimento Explícito:** O CyberCore Signer nunca assina desafios em segundo plano sem a exibição do diálogo e autorização do usuário na tela nativa.
docs/development-mode.md
+48
View File
@@ -0,0 +1,48 @@
# Modo de Desenvolvimento e Diagnóstico Detalhado
O **CyberCore Signer** opera exclusivamente com **certificados digitais e provedores criptográficos reais** (A1 via arquivos `.pfx`/`.p12`, repositório nativo do Windows `Windows-MY` e tokens/smart cards físicos PKCS#11). Em conformidade com a exigência de segurança de produção, **não existem mocks ou certificados sintéticos no agente**.
---
## 1. Ativação do Modo de Desenvolvimento
Para iniciar o agente em modo de desenvolvimento (com logs detalhados e diagnósticos ampliados), utilize o argumento `--dev`:
```bash
java -jar cybercore-signer.jar --dev
```
Ao iniciar, uma mensagem informativa é registrada no log:
```
=========================================================
MODO DE DESENVOLVIMENTO ATIVADO (--dev)
Logs detalhados ativos. Operação com certificados reais.
=========================================================
```
---
## 2. Testando em Ambiente de Desenvolvimento
Para desenvolvedores testarem fluxos completos de assinatura de PDF, XML, arquivos em geral e login digital:
1. **Certificados A1 de Teste/Homologação:**
- Adicione um certificado A1 `.pfx` ou `.p12` emitido por uma autoridade de teste ou autoassinado.
- Pela interface desktop, clique no botão **"Importar A1 (.pfx/.p12)"** no Dashboard e informe o arquivo e a senha.
- O certificado ficará disponível imediatamente para todas as operações CCSP/1.
2. **Repositório Nativo do Windows (Windows-MY):**
- Instale o certificado no repositório de certificados pessoais do Windows (`certmgr.msc`).
- O provedor `WindowsCertificateStoreProvider` detectará o certificado automaticamente.
3. **Tokens USB / Smart Cards (PKCS#11):**
- Conecte o dispositivo físico com middleware homologado (SafeSign, GD Burti, SafeNet, OpenSC, etc.).
- O provedor `Pkcs11CertificateProvider` detectará o token e seus slots.
---
## 3. Garantia de Operação Real
1. Toda assinatura é gerada criptograficamente através dos provedores JCA/JCE reais.
2. A resposta do protocolo CCSP/1 contém assinaturas válidas e certificados X.509 autênticos.
3. Não há certificados simulados ou flags artificiais nas respostas do agente.
docs/diagnostics.md
+34
View File
@@ -0,0 +1,34 @@
# Diagnóstico de Ambiente e Auto-Teste
O **CyberCore Signer** possui um subsistema nativo de diagnóstico integrado (`DiagnosticService`), permitindo auditoria detalhada de saúde e integridade técnica da máquina do usuário.
---
## 1. Itens Inspecionados no Diagnóstico
Ao abrir a aba **Diagnóstico** na interface ou invocar `diagnosticService.runDiagnostic()`, o agente avalia:
1. **Ambiente Java / Runtime:**
- Versão do Java (requer Java 21+ LTS, homologado em Java 25 LTS);
- Vendor do JDK (Temurin, Oracle, etc.);
- Arquitetura do processador e sistema operacional.
2. **Engine Criptográfica JCA/JCE:**
- Disponibilidade dos provedores de segurança registrados na JVM (`SUN`, `SunRsaSign`, `SunMSCAPI`, etc.);
- Suporte ao algoritmo de hash `SHA-256`;
- Suporte ao algoritmo de assinatura `SHA256withRSA`.
3. **Repositório de Chaves do Sistema Operacional:**
- Detecção do repositório `Windows-MY` (Windows CryptoAPI / CNG).
4. **Middlewares PKCS#11 e SmartCard:**
- Verificação de bibliotecas de smartcard registradas no sistema (`eps2003csp11.dll`, `aetpkss1.dll`, `opensc-pkcs11.dll`, etc.);
- Disponibilidade do subsistema PC/SC `javax.smartcardio`.
---
## 2. Auto-Teste de Assinatura Local (Self-Test)
A aba de diagnóstico disponibiliza o botão **"Executar Auto-teste de Assinatura"**:
1. Seleciona o primeiro certificado operacional disponível na máquina.
2. Gera um hash SHA-256 interno de teste: `"Documento_Teste_CyberCore_<timestamp>"`.
3. Abre o diálogo de confirmação visual para validação do usuário.
4. Executa a assinatura real JCA/JCE e afere os bytes gerados.
5. Emite relatório de sucesso com tempo decorrido e tamanho da assinatura.
docs/errors.md
+28
View File
@@ -0,0 +1,28 @@
# Catálogo Estruturado de Erros
O **CyberCore Signer** adota um sistema unificado e determinístico de códigos de erro (`CcspErrorCode`) compartilhados entre o agente Java desktop, o protocolo CCSP/1 e o SDK Web em JavaScript.
---
## 1. Tabela de Erros Estruturados
| Código de Erro | Descrição Detalhada | Ação Recomendada para a Aplicação Web |
|---|---|---|
| `CERTIFICATE_NOT_FOUND` | O certificado indicado pelo `certificate_hint` não foi localizado. | Solicite ao usuário selecionar novamente o certificado via `getCertificates()`. |
| `CERTIFICATE_EXPIRED` | O certificado selecionado expirou. | Oriente o usuário a renovar o certificado digital junto à autoridade certificadora. |
| `CERTIFICATE_INVALID` | O certificado possui estrutura corrompida ou ainda não é válido. | Verificar a data e integridade do arquivo/dispositivo. |
| `PRIVATE_KEY_NOT_AVAILABLE` | O certificado está presente mas a chave privada não está acessível. | Em tokens A3, verifique se o middleware/driver está instalado corretamente. |
| `TOKEN_NOT_FOUND` | Nenhum dispositivo ou leitor compatível foi localizado. | Solicite ao usuário conectar o token USB ou inserir o smartcard no leitor. |
| `TOKEN_REMOVED` | O token USB ou cartão foi removido fisicamente durante a assinatura. | Peça ao usuário reconectar o token e reiniciar a operação de assinatura. |
| `PIN_REQUIRED` | O token exige PIN para liberar a chave privada e nenhum PIN foi fornecido. | Exibir campo de solicitação de PIN na tela. |
| `PIN_INCORRECT` | O PIN digitado está incorreto. | Informar o usuário e alertar sobre o risco de bloqueio de PUK após 3 tentativas. |
| `PKCS11_ERROR` | Falha no driver ou biblioteca PKCS#11 do fabricante. | Verificar a instalação do SafeSign, SafeNet ou OpenSC. |
| `SIGNATURE_FAILED` | Erro durante a geração dos bytes da assinatura digital. | Tentar novamente ou reiniciar o agente desktop. |
| `APPLICATION_NOT_AUTHORIZED` | A aplicação web teve autorização recusada pelo usuário. | Informar o usuário que é necessário aceitar a notificação na tela do agente. |
| `REQUEST_EXPIRED` | O timestamp ou `expires_at` da requisição expirou. | Gerar nova requisição de assinatura com timestamp atualizado. |
| `REPLAY_DETECTED` | O nonce informado já foi processado anteriormente. | Sempre gerar um UUID único para cada chamada de assinatura. |
| `INVALID_ORIGIN` | O cabeçalho `Origin` não confere com o cadastro da aplicação. | Conectar-se com a URL e protocolo autorizados. |
| `UNSUPPORTED_ALGORITHM` | Algoritmo solicitado não é suportado pelo agente ou certificado. | Utilizar algoritmo padrão homologado (`SHA256withRSA`). |
| `USER_CANCELLED` | O usuário clicou em Cancelar ou fechou a janela do CyberCore. | Tratar como cancelamento voluntário sem mensagem de erro alarmante. |
| `PROVIDER_NOT_AVAILABLE` | O provedor criptográfico necessário não está ativo no sistema operacional. | Verificar a integridade do Windows Certificate Store ou Java Runtime. |
| `COMMUNICATION_ERROR` | Erro interno de socket ou timeout de rede local. | Verificar se a porta `21325` não está bloqueada por antivírus local. |
docs/image.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 147 KiB

docs/installation.md
+43
View File
@@ -0,0 +1,43 @@
# Instalação e Empacotamento Nativo
O **CyberCore Signer** foi projetado para distribuição sem exigir que o usuário final tenha o Java ou JRE instalado em seu computador.
---
## 1. Requisitos de Sistema
- **Sistema Operacional Homologado:** Windows 10 (64-bit) ou Windows 11 (64-bit).
- **Compatibilidade Adicional:** Linux x86_64 e macOS (arquitetura preparada).
- **Hardware:** Mínimo de 4 GB RAM, 150 MB de espaço em disco.
- **Porta de Rede Local:** A porta TCP `21325` deve estar livre em `127.0.0.1`.
---
## 2. Geração do Instalador Windows (MSI / EXE) com `jpackage`
O empacotamento utiliza a ferramenta nativa `jpackage` incluída no JDK 21/25.
### No Windows:
Execute o script em lote localizado na raiz:
```cmd
scripts\package-windows.bat
```
### O que o script realiza:
1. Compila o projeto em modo release:
```cmd
mvnw clean package -DskipTests
```
2. Invoca o `jpackage` criando o instalador Windows:
- Extrai um runtime mínimo customizado contendo apenas os módulos necessários (`java.base`, `java.desktop`, `java.smartcardio`, `jdk.crypto.cryptoki`, etc.).
- Cria atalhos na Área de Trabalho e no Menu Iniciar.
- Gera um instalador padrão MSI ou EXE em `dist/`.
---
## 3. Instalação e Inicialização com o Sistema
1. Execute o instalador `CyberCore-Signer-0.1.0.msi`.
2. Siga as instruções do assistente de instalação.
3. Ao concluir, o ícone do **CyberCore Signer** aparecerá na Área de Notificação (System Tray) ao lado do relógio do Windows.
4. O serviço local `http://127.0.0.1:21325` estará imediatamente disponível para atender as aplicações web autorizadas.
docs/limitations.md
+25
View File
@@ -0,0 +1,25 @@
# Limitações Técnicas e Dependências Declaradas
Conforme estabelecido na **Regra 23** do projeto (*"Não invente suporte a certificados, tokens, providers, algoritmos ou hardware que não tenham sido realmente implementados/testados. Quando algo depender de fabricante, middleware, Windows ou hardware físico, declare a dependência"*), as seguintes limitações são formalmente declaradas:
---
## 1. Dependências de Sistema Operacional e Hardware
1. **Windows Certificate Store (Windows-MY):**
- Disponível apenas em sistemas operacionais Microsoft Windows (Windows 10/11).
- Em Linux e macOS, o provedor `WindowsCertificateStoreProvider` declara-se automaticamente indisponível (`isAvailable() == false`), operando via arquivos A1 ou PKCS#11 direto.
2. **Tokens A3 e Middlewares Proprietários:**
- O reconhecimento de smartcards e tokens USB depende da instalação prévia dos drivers do fabricante do dispositivo físico (ex: SafeSign Identity Client, SafeNet Authentication Client, drivers de leitoras Gemalto/Omnikey).
- O CyberCore Signer não instala drivers de hardware nem substitui o middleware do fabricante.
3. **Bloqueio de Cartão por Tentativas de PIN:**
- A política de bloqueio por tentativas consecutivas de PIN incorreto (geralmente 3 tentativas) é governada estritamente pelo chip físico do dispositivo A3 e pelo driver do fabricante, estando fora do controle do software do agente.
---
## 2. Limitações de Rede e Concorrência
1. **Escuta Exclusiva em Loopback:**
- O agente não oferece nem oferece suporte para escuta em endereços de rede externa (IPs locais de LAN ou WAN). Essa restrição é um elemento fundamental do modelo de segurança.
2. **Operações Concorrentes no Mesmo Token Físico:**
- Drivers PKCS#11 e smartcards ICP-Brasil frequentemente operam em modo mono-thread ou canal serial exclusivo. Por essa razão, o CyberCore Signer serializa as assinaturas em fila FIFO (`signLock`) para impedir corrupção de sessão no chip do cartão.
docs/pades.md
+92
View File
@@ -0,0 +1,92 @@
![alt text](image.png)# Assinaturas PDF (PAdES) e Selos Visuais em SVG
Este documento descreve a arquitetura e o funcionamento da assinatura digital de arquivos PDF no padrão **PAdES (PDF Advanced Electronic Signatures)** no CyberCore Signer, incluindo o subsistema de **selos visuais temáticos baseados em SVG**.
---
## 1. Visão Geral da Arquitetura
O CyberCore Signer implementa assinatura PAdES em dois modos complementares:
1. **Modo Desacoplado via Protocolo CCSP/1 (Web):** A aplicação web prepara a estrutura `/ByteRange`, envia apenas o digest SHA-256 e o CyberCore assina localmente com o certificado A1/A3 sem expor a chave privada.
2. **Modo Desktop Completo (Desktop UI):** O usuário seleciona um arquivo PDF localmente, escolhe o certificado ICP-Brasil, customiza o selo visual e o `PdfSigningService` gera o PDF assinado completo com envelope CMS/PKCS#7 e estampa gráfica.
```mermaid
graph TD
A[Arquivo PDF Original] --> B[PdfSigningService]
C[Tema de Selo SVG] --> D[PdfSealRenderer Java2D]
E[Metadados Signatário] --> D
D -->|Estampa Visual 300 DPI| B
F[Chave Privada A1/A3] --> G[Bouncy Castle CMS Generator]
B -->|PAdES Incremental| H[PDF Assinado Digitalmente]
G --> H
```
---
## 2. Subsistema de Selos Visuais em SVG e Temas
O selo visual é uma representação gráfica da assinatura estipulada em conformidade com as recomendações do ITI e MP nº 2.200-2/2001.
### 2.1 Temas Pré-configurados e Ícones Vetoriais (`PdfSealThemeRegistry` & `PdfSealRenderer`)
Os brasões e ícones padrão do sistema ficam centralizados em:
- **Catálogo de Temas:** `modules/cybercore-core/.../pdf/seal/PdfSealThemeRegistry.java` (definição de cores, dimensões, textos padrão e tipo de ícone).
- **Desenho Vetorial Java2D:** `modules/cybercore-core/.../pdf/seal/PdfSealRenderer.drawThemeIcon()` (renderização matemática em Java2D dos brasões padrão: `shield`, `star`, `crystal`, `notary`, etc.).
| ID do Tema | Nome | Descrição | Ícone Vetorial |
| :--- | :--- | :--- | :--- |
| `icp-brasil` | **ICP-Brasil Oficial** | Padrão clássico com brasão e cadeado verde/azul | Escudo e cadeado |
| `cybercore-modern` | **CyberCore Modern** | Estilo tecnológico neon com cristal multifacetado | Cristal vetorial |
| `minimal-clean` | **Minimalista Clean** | Monocromático para relatórios executivos sóbrios | Carimbo notarial com check |
| `gov-br` | **Gov.br Oficial** | Identidade visual Verde-Oliva conforme MP 2.200-2/2001 | Brasão estelar estilizado |
### 2.2 Renderização Gráfica (`PdfSealRenderer`)
- O núcleo `cybercore-core` **não depende de JavaFX**, atendendo às regras estritas de arquitetura (`ArchitectureTest`).
- A renderização é efetuada através da API **Java2D (AWT)** nativa com anti-aliasing duplo (`RenderingHints.VALUE_ANTIALIAS_ON`, subpixel text, escala 2x / 300 DPI).
- Exporta tanto `BufferedImage` quanto `byte[]` PNG para inclusão no PDFBox ou pré-visualização dinâmica na interface com `ImageView`.
### 2.3 Criação, Instalação e Privacidade de Selos Personalizados
- **Foco Exclusivo no Titular (Sem Emissor/AC no Gráfico):** O selo foi desenhado para ser limpo e elegante. Dados técnicos do certificado e o emissor da Autoridade Certificadora não são exibidos no gráfico do selo, evitando poluição visual.
- **Obrigatoriedade do Nome Completo:** O renderizador calcula dinamicamente a métrica de fontes via `drawFittedText()` para garantir que o nome completo do signatário seja sempre exibido na íntegra, com destaque tipográfico (13.5pt a 14.5pt em negrito), sem cortes ou truncamentos.
- **Upload de Logotipo / Emblema Próprio:** Suporte a upload de imagens de logotipos (PNG, JPG, BMP) armazenadas de forma portável em Base64 dentro do tema, com renderização redimensionada e anti-aliasing de 300 DPI.
- **Campos Customizáveis (Matrícula, Cargo, OAB, etc.):** Permite definir rótulo e valor padrão no tema (ex: `Matrícula: 104829/SP` ou `Cargo: Auditor Fiscal`) ou informar pontualmente durante a assinatura via `customExtraInfo`. A informação é posicionada de forma harmônica na linha de identificação do signatário.
- **Privacidade do CPF (LGPD):** O modelo `CpfDisplayMode` suporta três modalidades:
- `FULL`: exibe o documento completo (`CPF: 123.456.789-00`).
- `MASKED`: mascara dígitos sensíveis (`CPF: ***.456.789-**`).
- `NONE`: oculta totalmente o CPF do gráfico do selo.
- **Data e Hora Opcional:** Parâmetro booleano para incluir ou suprimir data/hora no gráfico.
- **Instalação e Persistência Local:** Através de `CustomSealStorage`, novos selos criados ou importados são salvos em `~/.cybercore/seals/*.json` e registrados dinamicamente no `PdfSealThemeRegistry`.
### 2.4 Gerenciamento Centralizado de Selos (`SealManagementDialog`)
- **Lista Completa:** Exibição unificada de selos embutidos do sistema e selos personalizados instalados pelo usuário.
- **Selo Padrão Ativo:** Permite definir qual selo é o padrão ativo para todas as assinaturas do usuário, gravado em `AgentConfiguration` (`defaultSealThemeId`).
- **Pré-visualização em Tempo Real:** Renderização fiel do selo com dados de exemplo ao navegar pela lista.
- **Clonagem e Edição:** Permite duplicar qualquer selo (inclusive os embutidos) e abri-lo no `SealDesignerDialog` para customização.
- **Importação e Exportação:** Exportação de temas em arquivos `.json` e importação com um clique para compartilhamento entre máquinas e equipes.
---
## 3. Posicionamento e Pré-Visualização Interativa
A posição e a página da estampa são parametrizáveis via `PdfSignatureOptions`:
- **Posições Automáticas:** `BOTTOM_RIGHT`, `BOTTOM_LEFT`, `TOP_RIGHT`, `TOP_LEFT`.
- **Posição Interativa Personalizada (`CUSTOM`):** O usuário clica ou arrasta o selo diretamente sobre a página do PDF na interface gráfica. As coordenadas na tela são matematicamente mapeadas para as coordenadas de mídia do PDFBox:
$$X_{pdf} = \frac{X_{clique}}{Largura_{view}} \times Largura_{pdf}$$
$$Y_{pdf} = Altura_{pdf} - \left(\frac{Y_{clique}}{Altura_{view}} \times Altura_{pdf}\right) - Altura_{selo}$$
- **Páginas:** `LAST_PAGE` (recomendado), `FIRST_PAGE`, `ALL_PAGES`, ou página específica numérica (`targetPageNumber`).
- **Dimensões padrão:** 200 pt de largura por 55 pt de altura, com margens de segurança e clamping contra extravasamento.
- **Renderização da Folha:** O `PdfSigningService` fornece `renderPagePngBytes(pdfBytes, pageIndex, dpi)` via PDFBox `PDFRenderer`, permitindo que o diálogo da UI JavaFX renderize a folha de papel em background thread com paginação e sobreposição visual do selo.
---
## 4. Estrutura Criptográfica PAdES
- **Motor:** Apache PDFBox 3.0.4 + Bouncy Castle 1.80 (`bcpkix-jdk18on`).
- **Filtro:** `/Filter /Adobe.PPKLite` e `/SubFilter /adbe.pkcs7.detached`.
- **Algoritmo:** `SHA256withRSA` / PKCS#1 v1.5 com digest SHA-256.
- **Salva Incremental:** Preserva a integridade de assinaturas anteriores e do documento original sem quebrar certificações prévias.
docs/screenshots/01_dashboard.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 47 KiB

docs/screenshots/01_layout_claro.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 59 KiB

docs/screenshots/01_layout_serpro.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 52 KiB

docs/screenshots/02_diagnostico.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 54 KiB

docs/screenshots/02_layout_escuro.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 62 KiB

docs/screenshots/03_configuracoes.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 35 KiB

docs/sdk.md
+117
View File
@@ -0,0 +1,117 @@
# SDK Web JavaScript (@cybercore/signer-sdk)
O `@cybercore/signer-sdk` é a biblioteca oficial cliente em JavaScript para integrar aplicações web modernas com o agente desktop **CyberCore Signer** via protocolo **CCSP/1**.
---
## 1. Instalação e Importação
### Via Módulo ES6 (Browser ou Bundler Vite/Webpack/Next.js)
```javascript
import { CyberCoreSigner } from '@cybercore/signer-sdk';
const signer = new CyberCoreSigner({
applicationName: 'Portal Meu Negócio'
});
```
---
## 2. Métodos da API
### `isInstalled(timeoutMs = 2000): Promise<boolean>`
Testa rapidamente se o agente desktop está ativo na porta local `21325`.
### `connect(): Promise<boolean>`
Realiza o handshake inicial de autorização. Se for a primeira vez que a aplicação tenta se conectar, abre uma caixa de diálogo nativa no desktop do usuário para concessão de acesso.
### `getCertificates(): Promise<Array<Object>>`
Retorna todos os certificados A1 e A3 disponíveis e operacionais na máquina do usuário.
```javascript
const certs = await signer.getCertificates();
certs.forEach(cert => {
console.log(`[${cert.type}] ${cert.common_name} (Validade: ${cert.valid_to})`);
});
```
### `sign(options): Promise<Object>`
Solicita a assinatura digital local de um digest ou conteúdo bruto.
### `signPdf(pdfFile, options): Promise<Object>`
Assina um documento PDF (PAdES / Assinatura desacoplada). Recebe `File`, `Blob`, `ArrayBuffer` ou `Uint8Array`.
Calcula o SHA-256 no próprio navegador e transmite metadados do documento (`PDF`) ao agente para exibição clara na janela de confirmação.
```javascript
const pdfResult = await signer.signPdf(fileInput.files[0], {
certificateId: certs[0].id
});
```
### `signXml(xmlContent, options): Promise<Object>`
Assina um documento XML (XMLDSig / NF-e). Aceita string com o XML formatado ou objeto de arquivo `File`/`Blob`.
```javascript
const xmlResult = await signer.signXml(xmlString, {
certificateId: certs[0].id,
documentName: 'nfe-3524.xml'
});
```
### `signFile(file, options): Promise<Object>`
Assina qualquer arquivo (ZIP, DOCX, imagens, binários, executáveis) gerando pacote de assinatura detached / CAdES.
```javascript
const fileResult = await signer.signFile(fileInput.files[0], {
certificateId: certs[0].id
});
```
### `authenticate(options): Promise<Object>` (ou `login(options)`)
Executa login seguro com certificado digital via desafio criptográfico (Challenge-Response).
```javascript
const auth = await signer.authenticate({
certificateId: certs[0].id,
challenge: 'server-nonce-12345'
});
console.log('Bem-vindo,', auth.subjectName);
console.log('CPF/CNPJ:', auth.subjectCpfCnpj);
console.log('Assinatura do Desafio:', auth.signature);
```
### `extractSubjectInfo(certificateBase64): { name, cpfCnpj }`
Decodifica o certificado X.509 e extrai os dados do titular ICP-Brasil (Nome, CPF ou CNPJ).
### `verify(options): Promise<boolean>`
Validação sintática e criptográfica da integridade da assinatura gerada.
---
## 3. Tratamento Estruturado de Erros
O SDK expõe classes de erro dedicadas que herdam de `CyberCoreError`:
```javascript
import {
UserCancelledError,
CertificateNotFoundError,
PinIncorrectError,
TokenNotFoundError
} from '@cybercore/signer-sdk/errors';
try {
await signer.sign({ certificateId: 'cert-1', data: 'Contrato' });
} catch (err) {
if (err instanceof UserCancelledError) {
alert('Você cancelou a assinatura no CyberCore Signer.');
} else if (err instanceof PinIncorrectError) {
alert('O PIN do token informado está incorreto.');
} else if (err instanceof TokenNotFoundError) {
alert('Conecte o seu token USB na máquina para assinar.');
} else {
console.error('Erro na assinatura:', err);
}
}
```
docs/security.md
+46
View File
@@ -0,0 +1,46 @@
# Modelo de Segurança e Privacidade
O **CyberCore Signer** foi projetado seguindo as diretrizes rigorosas da ICP-Brasil e os princípios de *Security by Design* e *Least Privilege*.
---
## 1. Isolamento de Rede
1. **Loopback Estrito:** O socket do servidor HTTP local vincula-se exclusivamente ao endereço IP `127.0.0.1`. Nenhuma interface de rede externa (LAN ou WAN) escuta a porta de serviço `21325`.
2. **Prevenção contra Exposição Acidental:** Testes unitários e de arquitetura garantem que conexões fora de `127.0.0.1` sejam bloqueadas imediatamente no nível de bind do socket.
---
## 2. Autenticação e Autorização de Aplicações
Nenhuma aplicação desconhecida tem autorização para obter certificados ou assinar documentos sem consentimento expresso:
1. **Handshake de Autorização (`POST /ccsp/v1/authorize`):**
- A aplicação web identifica-se enviando seu `application_id` (UUID estável) e seu nome amigável.
- O CyberCore Signer suspende a requisição e abre uma janela modal nativa na tela principal do sistema operacional perguntando se o usuário autoriza aquele domínio web.
2. **Armazenamento Seguro das Autorizações:**
- As aplicações autorizadas são gravadas em `~/.cybercore/authorized-apps.json`.
- O usuário pode visualizar e **revogar a qualquer momento** qualquer permissão através da aba **Configurações** na interface gráfica.
---
## 3. Proteção Contra Ataques de Replay
Cada solicitação de assinatura enviada pelo SDK deve incluir:
- Um `nonce` (UUID criptograficamente aleatório);
- Um campo `expires_at` (ou `timestamp`).
O componente `NonceManager`:
- Armazena os nonces recentes em memória protegida com expiração temporal (TTL);
- Rejeita com código estruturado `REPLAY_DETECTED` caso o mesmo nonce seja submetido mais de uma vez;
- Rejeita com código `REQUEST_EXPIRED` requisições cuja data/hora de validade já tenha sido ultrapassada.
---
## 4. Confirmação Visual Obrigatória e Proteção de PIN/Chaves
1. **Confirmação Manual do Usuário:** Toda e qualquer assinatura exige intervenção física e visual do usuário. Não é possível assinar "silenciosamente" por chamadas de API em segundo plano.
2. **Inviolabilidade da Chave Privada:** A chave privada nunca é exportada nem manipulada em forma de bytes puros. Todas as operações utilizam handles JCA/JCE ou comandos de hardware nativo.
3. **Proteção de PIN e Senhas:**
- O PIN de smartcards e a senha de arquivos A1 nunca são transmitidos para a aplicação web e nunca aparecem em logs de auditoria.
- Em caso de remoção do hardware, o `SmartCardWatcher` limpa e zera os buffers de memória de PIN imediatamente.
docs/serpro-layout-and-batch.md
+82
View File
@@ -0,0 +1,82 @@
# Layout CyberCore Signer — Design Dual-Theme & Assinatura em Lote
O **CyberCore Signer** adota uma interface gráfica que une a ergonomia de hub consolidada no mercado nacional com uma identidade visual moderna, autoral e com suporte dinâmico a **Tema Claro (Light)** e **Tema Escuro (Dark)**.
---
## 1. Identidade Visual e Filosofia de Design
Em conformidade com os requisitos do projeto, a interface **não é uma cópia datada**, mas sim uma evolução:
1. **Identidade CyberCore:** Logotipo central em cristal tridimensional e escudo criptográfico vetorial (`SvgIcons`), subtítulo "Agente Criptográfico Local • ICP-Brasil" e indicador de segurança em tempo real.
2. **Badge de Status Ativo:** Exibe o status da porta local (`● Agente Ativo • 127.0.0.1:21325`) com verde esmeralda no modo claro e verde neon no modo escuro.
3. **Alternador Dinâmico de Temas:** Botão pílula localizado no cabeçalho superior que permite ao usuário alternar instantaneamente entre **Modo Claro** e **Modo Escuro**:
- Ícone do Sol ☀️ para comutar para o tema Claro.
- Ícone da Lua 🌙 para comutar para o tema Escuro.
- Classe gerenciadora centralizada: [`ThemeManager.java`](file:///var/www/cybercore/cybercore-signer/modules/cybercore-ui/src/main/java/br/com/cybercore/signer/ui/theme/ThemeManager.java), que replica a escolha de tema para todos os diálogos secundários.
---
## 2. Paleta de Cores dos Temas
| Componente | Tema Claro (Light) | Tema Escuro (Dark) |
|---|---|---|
| **Fundo da Janela** | `#f1f5f9` (Slate suave) | `#0b0f17` (Dark profundo) |
| **Header Superior** | `#ffffff`, borda `#e2e8f0` | `#121824`, borda `#1e293b` |
| **Cartões de Ação** | `#ffffff`, borda `#e2e8f0`, hover `#0284c7` | `#131c2e`, borda `#1e293b`, hover `#38bdf8` |
| **Texto dos Botões** | `#1e293b` (Cinza escuro de alto contraste) | `#f8fafc` (Branco gelo nítido) |
| **Painel Lateral** | `#ffffff`, borda `#e2e8f0` | `#121824`, borda `#1e293b` |
| **Badge de Status** | Fundo `#ecfdf5`, texto `#047857`, borda `#10b981` | Fundo `rgba(16, 185, 129, 0.15)`, texto `#34d399` |
| **Alternador de Tema** | Fundo `#ffffff`, borda `#cbd5e1`, hover `#0284c7` | Fundo `#1e293b`, borda `#334155`, hover `#38bdf8` |
---
## 3. Grade Central de Ações (Hub 4x3)
A interface principal organiza as operações em 12 cartões modernos com cantos arredondados (8px), sombras suaves e ícones vetoriais SVG nítidos:
| Posição | Operação | Descrição |
|---|---|---|
| (0, 0) | **Assinar PDF** | Assinatura digital de documentos PDF com cálculo de hash SHA-256 e gravação de assinatura. |
| (1, 0) | **Assinar XML** | Assinatura de documentos XML (estruturas fiscais, NF-e, XMLDSig). |
| (2, 0) | **Assinar Arquivo** | Assinatura genérica de qualquer arquivo ou binário do sistema. |
| (3, 0) | **Assinar em Lote** | Processamento simultâneo de múltiplos arquivos com barra de progresso em tempo real. |
| (0, 1) | **Assinatura Atachada** | Assinatura embutida/anexada ao documento original (CAdES enveloped). |
| (1, 1) | **Co-Assinar Documento** | Adição de nova assinatura a um documento previamente assinado por outro titular. |
| (2, 1) | **Carimbo do Tempo** | Integração com protocolo RFC 3161 TSP para prova de anterioridade temporal. |
| (3, 1) | **Assinatura LTV** | Perfil de Longa Duração com inclusão de cadeia de certificados e carimbos para validade permanente. |
| (0, 2) | **Validar Assinatura** | Verificação de integridade criptográfica e conformidade do certificado digital. |
| (1, 2) | **Validar Carimbo** | Verificação da autenticidade e validade temporal de tokens TSR/TSP. |
| (2, 2) | *(Reservado)* | Espaço reservado para expansões futuras do agente. |
| (3, 2) | **Sair do Agente** | Encerramento seguro da sessão do agente. |
---
## 4. Painel Lateral de Utilitários
Na coluna lateral direita, o usuário dispõe de atalhos rápidos para operações do sistema:
1. **`</> Logs`:** Visualizador de auditoria em tempo real, monitorando requisições locais CCSP/1 e eventos criptográficos.
2. **`⚙ Configurações`:** Gerenciador de origens web autorizadas, revogação de acessos e opções de PIN.
3. **`💻 Tutorial`:** Guia passo a passo interativo de uso do assinador e integração web.
4. **`🗂 Certificados`:** Lista de certificados ICP-Brasil instalados (Windows-MY, A1 e A3) e ferramenta para importação de certificados A1 (`.pfx` / `.p12`).
5. **`ℹ Sobre`:** Informações de versão, engine JCA/JCE e garantias de privacidade local.
---
## 5. Assinatura Digital em Lote (`BatchSigningDialog`)
A funcionalidade de assinatura em lote permite:
- Seleção de múltiplos arquivos simultâneos via diálogo de arquivos ou pastas.
- Visualização de tabela com nome, tamanho e status de cada item em tempo real.
- Seleção do certificado digital ICP-Brasil desejado (com exibição de titular, CPF/CNPJ, tipo A1/A3 e validade).
- Escolha da pasta de destino para os arquivos assinados (salvando arquivos `.p7s` correspondentes).
- Execução assíncrona em thread isolada para manter a interface responsiva durante todo o lote.
- Compatibilidade automática com o tema ativo (Claro ou Escuro).
---
## 6. Ícones Vetoriais SVG Nativos (`SvgIcons`)
Todos os ícones e o logotipo central em cristal foram construídos via `SVGPath` e primitivas vetoriais JavaFX nativas:
- **Resolução Infinita:** Perfeita nitidez em monitores Full HD, 2K, 4K e configurações de escala de DPI do Windows (100%, 125%, 150%, 200%).
- **Sem Dependência de Imagens Rasterizadas:** Sem risco de imagens ausentes ou corrompidas no runtime empacotado.
docs/xml-xmldsig.md
+56
View File
@@ -0,0 +1,56 @@
# Assinaturas XML (XMLDSig e ICP-Brasil)
Este documento descreve a especificação e o funcionamento da assinatura digital de arquivos XML no padrão **W3C XMLDSig (XML Digital Signatures)** e **ICP-Brasil** no CyberCore Signer.
---
## 1. Visão Geral
O CyberCore Signer fornece suporte nativo a assinaturas digitais XML utilizando a engine padronizada e segura da plataforma Java (`javax.xml.crypto.dsig`).
### 1.1 Casos de Uso Suportados
- **Documento Inteiro Envelopado (`URI=""`):** Contratos, despachos, declarações e relatórios em formato XML.
- **Assinatura de Elementos Específicos por ID:**
- **NF-e (Nota Fiscal Eletrônica):** Assinatura da tag `<infNFe Id="NFe...">`
- **CT-e (Conhecimento de Transporte Eletrônico):** Assinatura da tag `<infCte Id="CTe...">`
- **MDF-e (Manifesto Eletrônico de Documentos Fiscais):** Assinatura da tag `<infMDFe Id="MDFe...">`
- **eSocial / EFD-Reinf:** Assinatura de eventos com tags `<evt... Id="...">`
---
## 2. Padrões Criptográficos
- **Canonicalização (C14N):** `http://www.w3.org/TR/2001/REC-xml-c14n-20010315` (C14N inclusiva sem comentários).
- **Transformações:**
- `http://www.w3.org/2000/09/xmldsig#enveloped-signature` (remove a assinatura do cálculo do digest).
- C14N padrão.
- **Algoritmo de Digest:** SHA-256 (`http://www.w3.org/2001/04/xmlenc#sha256`).
- **Algoritmo de Assinatura:** RSA-SHA256 (`http://www.w3.org/2001/04/xmldsig-more#rsa-sha256`).
- **KeyInfo:** Informações do certificado X.509 embutidas em `<X509Data><X509Certificate>`.
---
## 3. Segurança e Mitigação contra XXE
O parser XML é configurado com blindagem estrita contra ataques **XML External Entity (XXE)** e expansões recursivas de entidades:
```java
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
dbf.setXIncludeAware(false);
dbf.setExpandEntityReferences(false);
```
---
## 4. Validação Pós-Assinatura
O serviço `XmlSigningService.validateXmlSignature(byte[] xmlBytes)` permite auditar a assinatura imediatamente após sua emissão, verificando:
1. A integridade criptográfica da assinatura (`SignedInfo`).
2. A integridade dos digests de todas as referências apontadas (`Reference.validate()`).
3. O certificado X.509 público extraído da chave.