atributo_clave.c

Ejemplo de visualización de los atributos de una clave.

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"
 
#define KEY_ID "Nombre_clave"
 
BOOL IsRSAKey(DWORD dwType)
{
    switch(dwTipo)
    {
       caso ALG_RSA_512:
       caso ALG_RSA_1024:
       caso ALG_RSA_2048:
       caso ALG_RSA_4096:
       caso ALG_RSA_512_PUB:
       caso ALG_RSA_1024_PUB:
       caso ALG_RSA_2048_PUB:
       caso ALG_RSA_4096_PUB:
          devolver TRUE;
    }
 
    devuelva  FALSE;
}
 
int main()
{
    int nRet;
    struct AUTH_PWD authPwd;
    HSESSIONCTX hSession = NULL;
    HKEYCTX hKey = NULL;
    DWORD dwDataLen,
          dwKeyType,
          dwPadding,
          dwReadLocked,
          dwKeyLen,
          dwMode;
    BYTE *pbData;
    int i;
 
    //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");
 
    //Gera uma chave simétrica
    nRet = DGenerateKey(hSession, KEY_ID, ALG_AES_256, 0, &hKey);
    si (nRet)
    {
        printf("Function failed: DGenerateKey \nCódigo de error: %d\n", nRet);
        ir a limpiar;
    }
 
    printf("Clave generada con éxito.\n");
 
    //Libera o contexto da chave
    DDestroyKey(&hKey, 0);
 
    /*
        En este ejemplo generamos la clave y liberamos el contexto de la clave en el archivo
        secuencia.
        Para demostrar el uso de la API, se recupera de nuevo el contexto de la clave
        utilizando la función DGetUserKey.
    */
 
    //Recupera o handle de uma chave armazenada no HSM
    nRet = DGetUserKey(hSession, KEY_ID, 0, &hKey);
 
    si (nRet){
        printf("Function failed: DGetUserKey \nCódigo de error: %d\n",nRet);
        ir a limpiar;
    }
 
    /* Algoritmo */
 
    dwDataLen = sizeof(DWORD);
    nRet = DGetKeyParam(hKey, DKP_ALGID,(BYTE *)&dwKeyType, &dwDataLen, 0);
 
    si (nRet){
        printf("Function failed: DGetKeyParam \nCódigo de error: %d\n",nRet);
        ir a limpiar;
    }
 
    printf("Tipo de clave "DWORD_PRINT"\n", dwTipoClave);
 
    /* Tamaño */
 
    dwDataLen = sizeof(DWORD);
    nRet = DGetKeyParam(hKey, DKP_KEYLEN,(BYTE *)&dwKeyLen, &dwDataLen, 0);
 
    si (nRet){
        printf("Function failed: DGetKeyParam \nCódigo de error: %d\n",nRet);
        ir a limpiar;
    }
 
    printf("Tamaño clave "DWORD_PRINT" bits\n", dwKeyLen * 8);
 
    dwDataLen = sizeof(dwReadLocked);
    nRet = DGetKeyParam(hKey, DKP_READ_LOCK,(BYTE *)&dwReadLocked, &dwDataLen, 0);
 
    si (nRet){
        printf("Function failed: DGetKeyParam \nCódigo de error: %d\n",nRet);
        ir a limpiar;
    }
 
    printf("¿Clave exportable? %s\n", dwReadLocked == 1 ? "No": "Sí " );
 
    si (IsRSAKey(dwKeyType)){
        printf("Fin de los atributos de la clave asimétrica.\n");
        ir a limpiar;
    }
 
    /* IV */
 
    //Recupera o tamanho do IV (memória necessária)
    dwDataLen = 0;
    nRet = DGetKeyParam(hKey, DKP_IV, NULL, &dwDataLen, 0);
 
    si (nRet){
        printf("Function failed: DGetKeyParam \nCódigo de error: %d\n",nRet);
        ir a limpiar;
    }
 
    pbData =(BYTE *)malloc(dwDataLen);
 
    nRet = DGetKeyParam(hKey, DKP_IV, pbData, &dwDataLen, 0);
 
    si (nRet){
        printf("Function failed: DGetKeyParam \nCódigo de error: %d\n",nRet);
        ir a limpiar;
    }
 
    printf("IV: ");
    for (i = 0; i < (int)dwDataLen; i++)
        printf("%02x ", pbData[i]);
 
    printf("\n");
 
    free(pbData);
 
    /* Relleno */
 
    dwDataLen = sizeof(DWORD);
    nRet = DGetKeyParam(hKey, DKP_PADDING,(BYTE *)&dwPadding, &dwDataLen, 0);
 
    si (nRet){
        printf("Function failed: DGetKeyParam \nCódigo de error: %d\n",nRet);
        ir a limpiar;
    }
 
    printf("Tipo de relleno "DWORD_PRINT"\n", dwPadding);
 
    /* Modo de funcionamiento del cifrado simétrico */
 
    dwDataLen = sizeof(dwMode);
    nRet = DGetKeyParam(hKey, DKP_MODE,(BYTE *)&dwMode, &dwDataLen, 0);
 
    si (nRet){
        printf("Function failed: DGetKeyParam \nCódigo de error: %d\n",nRet);
        ir a limpiar;
    }
 
    printf("Modo de operación "DWORD_PRINT"\n", dwMode);
 
    limpia:
 
    // Apenas o contexto da chave é liberado, a chave não é removida do HSM
    if (hKey){
        DDestroyKey(&hKey, 0);
        printf("Clave contexto liberada.\n");
    }
 
    si (hSesión){
        DCloseSession(&hSession, 0);
        printf("Sesión cerrada.\n");
    }
 
    DFinalise();
    printf("Bibliotecas finalizadas.\n");
 
    devolver nRet;
}