import { messages } from '../core/messages/index.js';
import { CHAVE_PRIVADA_CAMINHO, CHAVE_PUBLICA_CAMINHO } from './index.js';
import { lerEstado, salvarEstado } from '../shared/persistence/index.js';
import * as openpgp from 'openpgp';
export async function gerarParDeChaves() {
    const { privateKey, publicKey } = await openpgp.generateKey({
        type: 'ecc',
        curve: 'ed25519Legacy',
        userIDs: [{ name: 'Tutanus Guardian', comment: 'Chave do sistema de integridade Guardian' }],
        format: 'armored'
    });
    return { chavePrivada: privateKey, chavePublica: publicKey };
}
export async function assinarConteudo(conteudo, chavePrivadaArmored) {
    const chavePrivada = chavePrivadaArmored || await carregarChavePrivada();
    if (!chavePrivada) {
        throw new Error(messages.GuardianMensagens.gpgChavePrivadaIndisponivel);
    }
    const chavePrivadaObj = await openpgp.readPrivateKey({ armoredKey: chavePrivada });
    const assinatura = await openpgp.sign({
        message: await openpgp.createMessage({ text: conteudo }),
        signingKeys: chavePrivadaObj,
        detached: true
    });
    if (typeof assinatura !== 'string') {
        throw new Error('Tipo de assinatura GPG invalido');
    }
    return assinatura;
}
export async function verificarAssinatura(conteudo, assinaturaArmored, chavePublicaArmored) {
    const chavePublica = chavePublicaArmored || await carregarChavePublica();
    if (!chavePublica) {
        throw new Error(messages.GuardianMensagens.gpgChavePublicaIndisponivel);
    }
    const chavePublicaObj = await openpgp.readKey({ armoredKey: chavePublica });
    const mensagem = await openpgp.createMessage({ text: conteudo });
    const assinaturaObj = await openpgp.readSignature({ armoredSignature: assinaturaArmored });
    try {
        const resultado = await openpgp.verify({
            message: mensagem,
            signature: assinaturaObj,
            verificationKeys: [chavePublicaObj]
        });
        const { verified } = resultado.signatures[0];
        await verified;
        return true;
    }
    catch {
        return false;
    }
}
export async function carregarChavePublica() {
    try {
        return await lerEstado(CHAVE_PUBLICA_CAMINHO);
    }
    catch {
        return null;
    }
}
export async function carregarChavePrivada() {
    try {
        return await lerEstado(CHAVE_PRIVADA_CAMINHO);
    }
    catch {
        return null;
    }
}
export async function salvarChavePublica(chave) {
    await salvarEstado(CHAVE_PUBLICA_CAMINHO, chave);
}
export async function salvarChavePrivada(chave) {
    await salvarEstado(CHAVE_PRIVADA_CAMINHO, chave);
}
export async function inicializarChaves() {
    const pubExistente = await carregarChavePublica();
    const privExistente = await carregarChavePrivada();
    if (pubExistente && privExistente) {
        return { chavePrivada: privExistente, chavePublica: pubExistente };
    }
    const par = await gerarParDeChaves();
    await salvarChavePublica(par.chavePublica);
    await salvarChavePrivada(par.chavePrivada);
    return par;
}
//# sourceMappingURL=gpg.js.map