c_exportkey.c

/****************************************************************************************
*  c_exportkey.c
*
*  Note: See Tricryption Engine SDK for details on how to set the project environment.
*
*****************************************************************************************/

#include <stdio.h>
#include "teagent_c.h"

void PrintError(const char * msg)
{
    char szErr[1024];
    uint32_t nLength = 1024;
    uint32_t nCode = GetLastTEError(szErr, &nLength);
    printf("%s Code = 0x%x, Message = %s\n", msg, nCode, szErr);
}


int main()
{
    TE_HANDLE h;
    TE_RETCODE ret;
    uint32_t sid;
    uint64_t pid;   /* 8.0.1: CurrentLogonPrincipalId/TEExportKey widened Principal ID to 64-bit */

    /* Initialize the TE environment */
    TEEnvInit();

    /* Open connection to KeyServer */
    {
        char * szServerName = "localhost";     /* server name */
        long   lPort = 8888;                   /* port number */
        const char * p12_file = "/test_key.pfx";
        const char * password = "password";

        h = OpenConnectionWithPKCS12File(
                        szServerName,       /* TE server name */
                        lPort,              /* TE server port */
                        p12_file,           /* PKCS12 file name */
                        password,           /* password */
                        strlen(password)    /* password length */
                        );
        if (h == 0)
        {
            PrintError("Connection error:");
        }
        else
            printf("Connected to %s at %d as certificate user with %s.\n", szServerName, lPort, p12_file);

        ret = TEGetSystemId(h, &sid);
        if(ret) {
            PrintError("TEGetSystemId() failed:");
            goto CLEANUP;
        }
        else
            printf("sid = %d\n", sid);

        ret = CurrentLogonPrincipalId(h, &pid);
        if(ret) {
            PrintError("CurrentLogonPrincipalId() failed:");
            goto CLEANUP;
        }
        else
            printf("pid = %llu\n", (unsigned long long)pid);
    }

    /* create and export key */
    {
#define KEY_BUFFER_SIZE        256
#define HIDDENLINK_BUFFER_SIZE 60

        unsigned char hl[HIDDENLINK_BUFFER_SIZE];
        int len;
        int i;

        /* create key */
        {
            char * algorithm = NULL;      /* set to NULL or "" to use KeyServer default algorithm */
            char * acltemplate = NULL;    /* set to NULL or "" if no alc template is provided */

            ret = TECreateKey(
                h,                      /* connection handle */
                algorithm,              /* algorithm */
                acltemplate,            /* ACL template name */
                hl,                     /* hidden link buffer */
                HIDDENLINK_BUFFER_SIZE, /* hidden link buffer size */
                &len                    /* returned hidden link data length */
                );

            if(ret) {
                PrintError("Create key failed:");
                goto CLEANUP;
            }
            else {
                printf("hiddenlink (len = %d) :\n", len);
                for(i=0; i<len; i++) {
                    printf("[%2x] ", hl[i]);
                }
                printf("\n");
            }
        }

        /* export key with TEExportKey() */
        {
            TE_KEY_BUFFER tekeybuffer;

            /* Initialize key and hiddenlink buffers */
            tekeybuffer.key.buffer = (unsigned char*)malloc(KEY_BUFFER_SIZE);
            if(tekeybuffer.key.buffer == NULL) {
                printf("Error: out of memory.\n");
                goto CLEANUP;
            }
            tekeybuffer.key.size = KEY_BUFFER_SIZE;
            tekeybuffer.key.len = 0;

            tekeybuffer.hiddenlink.buffer = (unsigned char*)malloc(HIDDENLINK_BUFFER_SIZE);
            if(tekeybuffer.hiddenlink.buffer == NULL) {
                printf("Error: out of memory.\n");
                free(tekeybuffer.key.buffer); // clean up
                goto CLEANUP;
            }
            tekeybuffer.hiddenlink.size = HIDDENLINK_BUFFER_SIZE;
            tekeybuffer.hiddenlink.len = len;               /* use existing key */
            memcpy(tekeybuffer.hiddenlink.buffer, hl, len); /* set hiddenlink */

            ret = TEExportKey(
                h,              /* connection handle */
                sid,            /* system id */
                pid,            /* principal id */
                &tekeybuffer    /* key and its hidden link information */
                );

            if(ret) {
                PrintError("TEExportKey() failed:");
            }
            else {
                printf("tekeybuffer.key.buffer (len = %d) :\n", tekeybuffer.key.len);
                for(i=0; i<tekeybuffer.key.len; i++) {
                    printf("[%2x] ", tekeybuffer.key.buffer[i]);
                }
                printf("\n");
            }

            /* free key and hiddenlink buffers */
            free(tekeybuffer.key.buffer);
            free(tekeybuffer.hiddenlink.buffer);
        }
    }

CLEANUP:
    /* Close a connection */
    CloseConnection(h);

    printf("Disconnected from server\n\n");

    /* Uninitialize the TE environment */
    TEEnvClose();
    return 0;
}