tokenización.c

Ejemplo de tokenización con el módulo SVault mediante generación de token y recuperación de secreto.

Véase la nota sobre ejemplos.

#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 "maestro"
#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);
    si (nRet) {
        printf("Fallo de función: DInicializar \nCódigo de error: %d\n", nRet);
        ir a limpiar;
    }
 
    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. szContraseña, USER_PWD, sizeof(authPwd.szContraseña));
 
    nRet = DOpenSession(&hSession, SS_USER_PWD,(BYTE *)&authPwd, sizeof(authPwd), ENCRYPTED_CONN);
    si (nRet) {
        printf("Fallo de función: DOpenSession \nCódigo de error: %d\n", nRet);
        ir a limpiar;
    }
    printf("Sesión con Dinamo establecida.\n");
 
    /*
        Genera la llave maestra.
        Esta clave se genera una sola vez y debe conservarse en el HSM para 
        con todas las fichas generadas por él.
    */
 
    nRet = DGenerateKey(hSession, szMK, ALG_AES_256, 0, NULL);
 
 
    /*
        Tokeniza un 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",
                                        NOMBRE_CLAVE_PROTECCION};
 
        nRet = DSVaultGenToken(hSession,
                               0,
                               (BYTE *)&stTokenInfo,
                               pbTokenBlob,
                               &dwTokenBlobLen,
                               szToken,
                               0);
        si (nRet)
        {
            printf("Fallo de función: DSVaultGenToken \nCódigo de error: %d\n", nRet);
            ir a limpiar;
        }
        printf("Token (CPF) generado correctamente. \"%s\".\n", szToken);
 
        /*
            Recupera el secreto.
        */
 
        nRet = DSVaultGetData(hSession,
                              D_SVAULT_GET_OP_SECRET,
                              NOMBRE_CLAVE_PROTECCIÓN,
                              NULO,
                              pbTokenBlob,
                              dwTokenBlobLen,
                              szSecret,
                              &dwSecretLen,
                              0);
        si (nRet) {
            printf("Function failed: DSVaultGetData (CPF) \nCódigo de error: %d\n", nRet);
            ir a limpiar;
        }
        printf("Secreto (CPF) recuperado con éxito.\"%s\".\n", szSecret);
 
        /*
            Recupera el secreto enmascarado.
        */
#define CPF_MASK "***\0\0\0***"
        memcpy(szMask, CPF_MASK, sizeof(CPF_MASK));
        dwSecretLen = sizeof(szSecret);
        nRet = DSVaultGetData(hSession,
                              D_SVAULT_GET_OP_SECRET,
                              NOMBRE_CLAVE_PROTECCIÓN,
                              szMask,
                              pbTokenBlob,
                              dwTokenBlobLen,
                              szSecret,
                              &dwSecretLen,
                              0);
 
        si (nRet)
        {
            printf("Function failed: DSVaultGetData (CPF) \nCódigo de error: %d\n", nRet);
            ir a limpiar;
        }
        printf("Secreto (CPF) recuperado con éxito.\"%s\".\n", szSecret);
    }
 
    /*
        Tokeniza una cadena.
    */
 
    {
        SVAULT_GEN_TOKEN stTokenInfoString = {D_SVAULT_F_MASK_SECRET,
                                              D_SVAULT_CKS_NULL,
                                              D_SVAULT_T_TKR2,
                                              D_SVAULT_BASE62,
                                              D_SVAULT_BASE62,
                                              "Esto es una prueba",
                                              NOMBRE_CLAVE_PROTECCION};
 
        dwTokenBlobLen = sizeof(pbTokenBlob);
        nRet = DSVaultGenToken(hSession,
                               0,
                               (BYTE *)&stTokenInfoString,
                               pbTokenBlob,
                               &dwTokenBlobLen,
                               szToken,
                               0);
        si (nRet)
        {
            printf("Function failed: DSVaultGenToken (string) \nCódigo de error: %d\n", nRet);
            ir a limpiar;
        }
        printf("Token (cadena) generado con éxito.\"%s\".\n", szToken);
 
        /*
            Recupera el secreto.
        */
        dwSecretLen = sizeof(szSecret);
        nRet = DSVaultGetData(hSession,
                              D_SVAULT_GET_OP_SECRET,
                              NOMBRE_CLAVE_PROTECCIÓN,
                              NULO,
                              pbTokenBlob,
                              dwTokenBlobLen,
                              szSecret,
                              &dwSecretLen,
                              0);
        si (nRet)
        {
            printf("Function failed: DSVaultGetData (string) \nCódigo de error: %d\n", nRet);
            ir a limpiar;
        }
 
#ifdef _WIN32
        SetConsoleOutputCP(CP_UTF8);
#endif
        printf("Secreto (cadena) recuperado con éxito.\"%s\".\n", szSecret);
 
        /*
            Recupera el secreto enmascarado.
        */
        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,
                              NOMBRE_CLAVE_PROTECCIÓN,
                              szMask,
                              pbTokenBlob,
                              dwTokenBlobLen,
                              szSecret,
                              &dwSecretLen,
                              0);
        si (nRet)
        {
            printf("Function failed: DSVaultGetData (string) \nCódigo de error: %d\n", nRet);
            ir a limpiar;
        }
        printf("Secreto (cadena) recuperado con éxito.\"%s\".\n", szSecret);
    }
 
limpia:
 
    if (hSession) {
        DCloseSession(&hSession, 0);
        printf("Sesión cerrada.\n");
    }
 
    DFinalise();
    printf("Bibliotecas finalizadas.\n");
 
    devolver nRet;
}