user_otp.c

Ejemplo de uso de OTP para autenticar usuarios de HSM.

Véase la nota sobre ejemplos.

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <dinamo.h>
 
/* Parámetros de conexión */
#define HSM_USR_ADM "maestro"
#define HSM_USR "usuario"
#define HSM_IP "127.0.0.1"
#define HSM_PWD "12345678"
 
int NewHsmUser(HSESSIONCTX hSession, const char *szUser, const char *szPwd)
{
    int nRet = 0;
    struct USER_INFO stUserInfo = { 0 };
 
    /* Rellena la estructura de usuario */
 
    strncpy(stUserInfo. szUserId, szUser, sizeof(stUserInfo.szUserId));
    strncpy(stUserInfo. szPassword, szPwd, sizeof(stUserInfo.szPassword));
 
    /* Crea un nuevo usuario en HSM */
 
    nRet = DCreateUser(hSession, stUserInfo);
    si (nRet)
    {
        printf("DCreateUser : ¡Falló! %d.\n", nRet);
        devolver nRet;
    }
 
    Devuelve 0;
}
 
int main(void)
{
    int nRet = 0;
    struct AUTH_PWD_EX  stAuthInfoAdm   = {0};
    struct AUTH_PWD_EX  stAuthInfoUser  = { 0 };
    HSESSIONCTX hSessionAdm = NULL;
    HSESSIONCTX hSessionUser = NULL;
    OATH_SA_v1          stTokenParam    = { 0 };
 
    const char cszOTP[] = "992271";
 
    /*
    * Semilla utilizada para generar el Blob HOTP.
    *
    * Esta semilla se puede transformar de binario a Base32
    * e importado en el cliente (Google Authenticator, por ejemplo).
    *
    */
    BYTE pbOtpKey[20] =
    {
        0xD5, 0x17, 0xED, 0x40, 0x1D, 0xF3, 0x03, 0x38, 0x37, 0xE0, 0x8B, 0x62, 0x55, 0xBE, 0xDB, 0xF9,
        0x52, 0x0E, 0xF8, 0x8E,
    };
 
    /*
        Rellena la estructura del usuario administrador
    */
    strncpy(stAuthInfoAdm. szAddr, HSM_IP, sizeof(stAuthInfoAdm.szAddr));
    strncpy(stAuthInfoAdm.szUserId, HSM_USR_ADM, sizeof(stAuthInfoAdm.szUserId));
    strncpy(stAuthInfoAdm. szContraseña, HSM_PWD, sizeof(stAuthInfoAdm.szContraseña));
    stAuthInfoAdm. nPort = DEFAULT_PORT;
    stAuthInfoAdm. nStrongAuthLen = 0;
    stAuthInfoAdm. pbStrongAuth = NULL;
    stAuthInfoAdm. dwAuthType = SA_AUTH_NONE;
 
    DInitialise(0);
 
    /*
        Conectar con un usuario con permisos de administrador
        para asociar un token otp a un usuario ordinario.
    */
 
    nRet = DOpenSession(&hSessionAdm,
                        SS_USR_PWD_EX,
                        (BYTE *) &stAuthInfoAdm,
                        sizeof(struct AUTH_PWD_EX),
                        CACHE_BYPASS | LB_BYPASS | ENCRYPTED_CONN );
 
    if(nRet)
    {
        printf("DOpenSession (adm) : ¡Error! %d.\n", nRet);
        ir a limpiar;
    }
 
    /* Crea un usuario de prueba ordinario */
 
    nRet = NewHsmUser(hSessionAdm, HSM_USR, HSM_PWD);
    si (nRet)
    {
        printf("NewHsmUser : ¡Falló! %d.\n", nRet);
        ir a limpiar;
    }
 
    /* Asocia el token con el usuario común. */
 
    stTokenParam.type = OATH _SA_v1_type_SHA1;
    memcpy(stTokenParam.key, pbOtpKey, sizeof(pbOtpKey));
    stTokenParam.key_len = sizeof(pbOtpKey);
    stTokenParam.truncation_offset = OATH _SA_v1_HOTP_DYN_TRUNC_OFF;
 
    nRet = DAssignToken(hSessionAdm,
                        HSM_USR,
                        AT_OATH_TOKEN,
                        (BYTE *)&stTokenParam,
                        sizeof(stTokenParam));
    if( nRet )
    {
        printf("DAssignToken : ¡Falló! %d.\n", nRet);
        ir a limpiar;
    }
 
    /*
        Cumple la estructura del usuario ordinario.
    */
    strncpy(stAuthInfoUser.szAddr, HSM_IP, sizeof(stAuthInfoUser.szAddr));
    strncpy(stAuthInfoUser.szUserId, HSM_USR, sizeof(stAuthInfoUser.szUserId));
    strncpy(stAuthInfoUser.szContraseña, HSM_PWD, sizeof(stAuthInfoUser.szContraseña));
    stAuthInfoUser.nPort = DEFAULT_PORT;
    stAuthInfoUser.pbStrongAuth =(BYTE *)cszOTP;
    stAuthInfoUser.nStrongAuthLen = (int)sizeof(cszOTP) - 1;
    stAuthInfoUser.dwAuthType = SA_AUTH_OTP;
 
    nRet = DOpenSession(&hSessionUser,
                        SS_USR_PWD_EX,
                        (BYTE *)&stAuthInfoUser,
                        sizeof(struct AUTH_PWD_EX),
                        CACHE_BYPASS | LB_BYPASS | ENCRYPTED_CONN);
 
    si (nRet)
    {
        printf("DOpenSession (usuario) : ¡Error! %d.\n", nRet);
        ir a limpiar;
    }
 
    /*
        Resincroniza el token OTP del usuario ordinario.
        Se utiliza cuando el testigo HOTP(evento) no está sincronizado.
 
        Se pasan 2 OTP consecutivos para que el HSM ajuste la ventana de eventos
    */
    nRet = DOATHResync( hSessionAdm,
                        HSM_USR,
                        "758993",
                        "864532",
                        0);
    si (nRet)
    {
        printf("DOATHResync : ¡Falló! %d.\n", nRet);
        ir a limpiar;
    }
 
 
    /*
        Desvincula el token del usuario ordinario.
    */
    nRet = DUnassignToken( hSessionAdm,
                            AT_OATH_TOKEN,
                            HSM_USR);
    si (nRet)
    {
        printf("DUnassignToken : ¡Falló! %d.\n", nRet);
        ir a limpiar;
    }
 
    limpia:
 
    DCloseSession(&hSessionUser, 0);
 
    // Remove o usuário criado
    if (hSessionAdm != NULL)
    {
        DRemoveUser(hSessionAdm, HSM_USR);
    }
 
    DCloseSession(&hSessionAdm, 0);
 
    DFinalise();
 
    devolver nRet;
}