sign_verify_pqc_slh_dsa.c

Example of PQC signature and verification with SLH-DSA.

See Note on examples.

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
 
#include <dinamo.h> /* header do Dinamo */
 
#define HOST_ADDR       "127.0.0.1"
#define USER_ID         "master"
#define USER_PWD        "12345678"
 
#define KEY_ID          "test_key"
#define PUB_KEY_ID      "test_pub_key"
 
int SetPqcKeyParams(HKEYCTX hKey, BYTE bPh, BYTE *pbCtx, DWORD cbCtx)
{
    int nRet = 0;
 
    nRet = DSetKeyParam(hKey, DKP_PQC_SIG_PH, &bPh, sizeof(bPh), 0);
    if (nRet) {
        printf("Falha na funcao: DSetKeyParam (DKP_PQC_SIG_PH) \nCodigo de erro: %d\n", nRet);
        return nRet;
    }
 
    printf("Parametro DKP_PQC_SIG_PH definido com sucesso.\n");
 
    if (pbCtx && cbCtx > 0) {
        nRet = DSetKeyParam(hKey, DKP_PQC_CTX, pbCtx, cbCtx, 0);
        if (nRet) {
            printf("Falha na funcao: DSetKeyParam (DKP_PQC_SIG_CTX) \nCodigo de erro: %d\n", nRet);
            return nRet;
        }
 
        printf("Parametro DKP_PQC_SIG_CTX definido com sucesso.\n");
    } else {
        printf("Contexto de assinatura PQC nao fornecido.\n");
    }
 
    return nRet;
}
 
int main()
{
    int nRet = 0;
    struct AUTH_PWD authPwd;
    HSESSIONCTX hSession = NULL;
    HHASHCTX hHash = NULL;
    HKEYCTX hKey = NULL;
    BYTE pbData[256]; /*  */
    DWORD cbData;
    BYTE pbSignature[DN_SLH_DSA_128S_SIG_LEN] = {0}; /* Buffer para a assinatura */
    DWORD cbSignature = sizeof(pbSignature);
 
    DWORD cbPubKey = 0;
    BYTE *pbPubKey = NULL;
    HKEYCTX hPubKey = NULL;
 
    BYTE bPh = 0; /* Parâmetro para assinatura pre-hash */
    BYTE pbCtx[10] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A};
    DWORD cbCtx = sizeof(pbCtx); /* Tamanho do contexto de assinatura */
 
    /* Inicializa as bibliotecas do Dinamo */
 
    nRet = DInitialize(0);
    if (nRet){
        printf("Falha na funcao: DInitialize \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    printf("Bibliotecas inicializadas.\n");
 
    /* Inicializa a estrutura para conexão com o HSM  */
    
    strncpy(authPwd.szAddr, HOST_ADDR, sizeof(authPwd.szAddr));
    authPwd.nPort = DEFAULT_PORT;
    strncpy(authPwd.szUserId, USER_ID, sizeof(authPwd.szUserId));
    strncpy(authPwd.szPassword, USER_PWD, sizeof(authPwd.szPassword));
 
    nRet = DOpenSession(&hSession, SS_USER_PWD, (BYTE *)&authPwd, sizeof(authPwd), ENCRYPTED_CONN);
    if (nRet){
        printf("Falha na funcao: DOpenSession \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    printf("Sessao com o Dinamo estabelecida.\n");
 
    /* 
        Cria um contexto de hash que receberá a mensagem a ser assinada
        O algoritmo de hash utilizado é o ALG_IDENTITY_FUNC, que não realiza 
        nenhuma operação de hash, ou seja, a assinatura será feita diretamente 
        sobre os dados fornecidos.
    */
 
    nRet = DCreateHash(hSession, ALG_IDENTITY_FUNC, 0, 0, &hHash);
    if (nRet){
        printf("Falha na funcao: DCreateHash \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    printf("Contexto de hash criado.\n");
 
    /* Preenche o buffer com dados de teste e adiciona ao contexto de hash. */
    
    cbData = sizeof(pbData);
    memset(pbData, 'A', cbData);
 
    nRet = DHashData(hHash, pbData, cbData, 0);
    if (nRet){
        printf("Falha na funcao: DHashData \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    printf("Dados adicionados ao hash.\n");
 
    nRet = DGenerateKey(hSession, KEY_ID, ALG_SLH_DSA_SHA2_128S, 0, &hKey);
    if (nRet){
        printf("Falha na funcao: DGenerateKey \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    printf("Chave criada com sucesso.\n");
 
    /*
        Define os parâmetros PQC na chave privada.
        SLH-DSA é sempre deterministico.
        O parâmetro DKP_PQC_SIG_PH indica se a assinatura é de tipo pre-hash PH (1) ou não (0). 
        Se não definido o padrão é sem uso de pre-hash.
        O parâmetro DKP_PQC_CTX é um contexto adicional que pode ser utilizado para
        fornecer informações adicionais sobre a assinatura. Opcional.
    */
 
    nRet = SetPqcKeyParams(hKey, bPh, pbCtx, cbCtx);
    if (nRet){
        printf("Falha ao definir parametros PQC na chave privada.\nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    /*
        Assina a mensagem.
    */
 
    nRet = DSignHash(hHash, hKey, 0, pbSignature, &cbSignature);
    if (nRet){
        printf("Falha na funcao: DSignHash \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    printf("Buffer assinado.\n");
 
    /*
        Exporta a chave pública à partir da chave privada e importa a chave
        pública no HSM. A primeira chamada recupera o tamanho estimado da chave
        pública, e a segunda chamada exporta a chave pública para o buffer.
    */
 
    nRet = DExportKey(hKey, NULL, PUBLICKEY_BLOB, 0, NULL, &cbPubKey);
    if (nRet){
        printf("Falha na funcao: DExportKey \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    pbPubKey = (BYTE *)malloc(cbPubKey);
    if (pbPubKey == NULL){
        printf("Falha ao alocar memoria para a chave publica.\n");
        nRet = -1;
        goto clean;
    }
 
    nRet = DExportKey(hKey, NULL, PUBLICKEY_BLOB, 0, pbPubKey, &cbPubKey);
    if (nRet){
        printf("Falha na funcao: DExportKey \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    printf("Chave publica exportada com sucesso.\n");
 
    /* 
        Importa a chave publica exportada para o HSM.
    */
 
    nRet = DImportKey(hSession, PUB_KEY_ID, NULL, PUBLICKEY_BLOB_HSM, 
                      ALG_OBJ_PUBKEY_BLOB, EXPORTABLE_KEY, pbPubKey, 
                      cbPubKey, &hPubKey);
    if (nRet){
        printf("Falha na funcao: DImportKey \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    printf("Chave publica importada com sucesso.\n");
 
    /*
        Os mesmos parâmetros PQC utilizados na chave privada devem ser
        definidos na chave pública para que a verificação da assinatura funcione
        corretamente.
    */
 
    nRet = SetPqcKeyParams(hPubKey, bPh, pbCtx, cbCtx);
    if (nRet)
    {
        printf("Falha ao definir parametros PQC na chave pública.\nCodigo de erro: %d\n", nRet);
        goto clean;
    }
 
    /*
        Verifica a assinatura utilizando a chave pública importada.
        A assinatura é verificada contra a mesma mensagem utilizada na 
        assinatura.
    */
 
    nRet = DVerifySignature(hHash, pbSignature, cbSignature, hPubKey, 0);
    if (nRet){
        printf("Falha na funcao: DVerifySignature \nCodigo de erro: %d\n",nRet);
        goto clean;
    }
 
    printf("Assinatura verificada com sucesso.\n");
 
    clean:
 
    if (pbPubKey)
        free(pbPubKey);
 
    /*
        Destroi o contexto das chaves no HSM e remove as chaves.
        A flag REMOVE_FROM_HSM indica que a chave deve ser removida do HSM.
        Caso não queira que a chave seja removida do HSM, passar 0 no lugar de
        REMOVE_FROM_HSM.
     */
 
    if (hKey){
        DDestroyKey(&hKey, REMOVE_FROM_HSM);
        printf("Contexto da chave privada liberado.\n");
    }
 
    if (hPubKey){
        DDestroyKey(&hPubKey, REMOVE_FROM_HSM);
        printf("Contexto da chave publica liberado.\n");
    }
 
    if (hHash){
        DDestroyHash(&hHash);
        printf("Contexto de hash liberado.\n");
    }
 
    if (hSession){
        DCloseSession(&hSession, 0);
        printf("Sessao encerrada.\n");
    }
 
    DFinalize();
    printf("Bibliotecas finalizada.\n");
 
    return nRet;
}