tokenization.c

Exemplo de tokenização com o módulo SVault utilizando geração de token e recuperação de secret.

Veja Nota sobre os exemplos.

#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"
 
int main()
{
    int nRet = 0;
    struct AUTH_PWD authPwd;
    HSESSIONCTX hSession = NULL;
 
    //Chave simétrica utilizada para proteção dos dados
#define PROTECTION_KEY_NAME "aes256"
    char szMK[] = PROTECTION_KEY_NAME;
 
    BYTE pbTokenBlob[D_SVAULT_TOKEN_BLOB_LEN] = {0};
    DWORD dwTokenBlobLen = sizeof(pbTokenBlob);
    char szToken[D_SVAULT_MAX_TL + 1] = {0};
    char szSecret[D_SVAULT_MAX_TL + 1] = {0};
    DWORD dwSecretLen = sizeof(szSecret);
    char szMask[D_SVAULT_MAX_TL + 1] = {0};
 
    //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");
 
    /*
        Gera a chave mestra.
        Esta chave é gerada apenas uma vez e deve ser persistida no HSM para 
        uso com todas os tokens gerados por ela.
    */
 
    nRet = DGenerateKey(hSession, szMK, ALG_AES_256, 0, NULL);
 
 
    /*
        Faz a tokenização de um CPF.
    */
    {
        SVAULT_GEN_TOKEN stTokenInfo = {D_SVAULT_F_MASK_SECRET,
                                        D_SVAULT_CKS_CPF,
                                        D_SVAULT_T_TKR2,
                                        D_SVAULT_BASE10,
                                        D_SVAULT_BASE10,
                                        "26122200468",
                                        PROTECTION_KEY_NAME};
 
        nRet = DSVaultGenToken(hSession,
                               0,
                               (BYTE *)&stTokenInfo,
                               pbTokenBlob,
                               &dwTokenBlobLen,
                               szToken,
                               0);
        if (nRet)
        {
            printf("Falha na funcao: DSVaultGenToken \nCodigo de erro: %d\n", nRet);
            goto clean;
        }
        printf("Token (CPF) gerado com sucesso. \"%s\".\n", szToken);
 
        /*
            Recupera o secret.
        */
 
        nRet = DSVaultGetData(hSession,
                              D_SVAULT_GET_OP_SECRET,
                              PROTECTION_KEY_NAME,
                              NULL,
                              pbTokenBlob,
                              dwTokenBlobLen,
                              szSecret,
                              &dwSecretLen,
                              0);
        if (nRet) {
            printf("Falha na funcao: DSVaultGetData (CPF) \nCodigo de erro: %d\n", nRet);
            goto clean;
        }
        printf("Secret (CPF) recuperado com sucesso. \"%s\".\n", szSecret);
 
        /*
            Recupera o secret mascarado.
        */
#define CPF_MASK "***\0\0\0***"
        memcpy(szMask, CPF_MASK, sizeof(CPF_MASK));
        dwSecretLen = sizeof(szSecret);
        nRet = DSVaultGetData(hSession,
                              D_SVAULT_GET_OP_SECRET,
                              PROTECTION_KEY_NAME,
                              szMask,
                              pbTokenBlob,
                              dwTokenBlobLen,
                              szSecret,
                              &dwSecretLen,
                              0);
 
        if (nRet)
        {
            printf("Falha na funcao: DSVaultGetData (CPF) \nCodigo de erro: %d\n", nRet);
            goto clean;
        }
        printf("Secret (CPF) recuperado com sucesso. \"%s\".\n", szSecret);
    }
 
    /*
        Faz a tokenização de uma string.
    */
 
    {
        SVAULT_GEN_TOKEN stTokenInfoString = {D_SVAULT_F_MASK_SECRET,
                                              D_SVAULT_CKS_NULL,
                                              D_SVAULT_T_TKR2,
                                              D_SVAULT_BASE62,
                                              D_SVAULT_BASE62,
                                              "Este \xc3\xA9 um teste",
                                              PROTECTION_KEY_NAME};
 
        dwTokenBlobLen = sizeof(pbTokenBlob);
        nRet = DSVaultGenToken(hSession,
                               0,
                               (BYTE *)&stTokenInfoString,
                               pbTokenBlob,
                               &dwTokenBlobLen,
                               szToken,
                               0);
        if (nRet)
        {
            printf("Falha na funcao: DSVaultGenToken (string) \nCodigo de erro: %d\n", nRet);
            goto clean;
        }
        printf("Token (string) gerado com sucesso. \"%s\".\n", szToken);
 
        /*
            Recupera o secret.
        */
        dwSecretLen = sizeof(szSecret);
        nRet = DSVaultGetData(hSession,
                              D_SVAULT_GET_OP_SECRET,
                              PROTECTION_KEY_NAME,
                              NULL,
                              pbTokenBlob,
                              dwTokenBlobLen,
                              szSecret,
                              &dwSecretLen,
                              0);
        if (nRet)
        {
            printf("Falha na funcao: DSVaultGetData (string) \nCodigo de erro: %d\n", nRet);
            goto clean;
        }
 
#ifdef _WIN32
        SetConsoleOutputCP(CP_UTF8);
#endif
        printf("Secret (string) recuperado com sucesso. \"%s\".\n", szSecret);
 
        /*
            Recupera o secret mascarado.
        */
        memset(szMask, 0, sizeof(szMask));
 
#define TEXT_MASK "*******\0\0\0"
        memcpy(szMask, TEXT_MASK, sizeof(TEXT_MASK));
        dwSecretLen = sizeof(szSecret);
        nRet = DSVaultGetData(hSession,
                              D_SVAULT_GET_OP_SECRET,
                              PROTECTION_KEY_NAME,
                              szMask,
                              pbTokenBlob,
                              dwTokenBlobLen,
                              szSecret,
                              &dwSecretLen,
                              0);
        if (nRet)
        {
            printf("Falha na funcao: DSVaultGetData (string) \nCodigo de erro: %d\n", nRet);
            goto clean;
        }
        printf("Secret (string) recuperado com sucesso. \"%s\".\n", szSecret);
    }
 
clean:
 
    if (hSession) {
        DCloseSession(&hSession, 0);
        printf("Sessao encerrada.\n");
    }
 
    DFinalize();
    printf("Bibliotecas finalizada.\n");
 
    return nRet;
}