cmd-crypto/tpmadm/main.c

	main.c revision 47e946e784719ae402ace34695f67b0e6e76ae5c
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <strings.h>
#include <libintl.h>
#include <locale.h>

#include <tss/tspi.h>
#include "tpmadm.h"

extern cmdtable_t commands[];

static void
print_usage(char *progname, cmdtable_t cmds[])
{
    cmdtable_t *p;

    (void) fprintf(stderr,
        gettext("usage: %s command args ...\n"), progname);
    (void) fprintf(stderr,
        gettext("where 'command' is one of the following:\n"));
    for (p = &cmds[0]; p->name != NULL; p++) {
        (void) fprintf(stderr, "\t%s %s\n", p->name, p->args);
    }
}

int
main(int argc, char *argv[])
{
    char *progname;
    cmdtable_t *p;
    cmdfunc_t fptr = NULL;
    int ret;
    TSS_HCONTEXT hContext;
    TSS_HOBJECT hTPM;

    /* Set up for i18n/l10n. */
#if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D. */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it isn't. */
#endif
    (void) setlocale(LC_ALL, "");
    (void) textdomain(TEXT_DOMAIN);

    progname = argv[0];
    argc--;
    argv++;

    if (argc <= 0) {
        print_usage(progname, commands);
        return (ERR_USAGE);
    }

    for (p = &commands[0]; p->name != NULL; p++) {
        if (0 == strcmp(p->name, argv[0])) {
            fptr = p->func;
            break;
        }
    }
    if (fptr == NULL) {
        print_usage(progname, commands);
        return (ERR_USAGE);
    }

    if (tpm_preamble(&hContext, &hTPM))
        return (ERR_FAIL);
    ret = fptr(hContext, hTPM, argc, argv);
    (void) tpm_postamble(hContext);

    return (ret);
}


/*
 * Utility functions
 */

void
print_bytes(BYTE *bytes, size_t len, int formatted)
{
    int i;
    for (i = 0; i < len; i++) {
        (void) printf("%02X ", bytes[i]);
        if (formatted && i % 16 == 7)
            (void) printf("  ");
        if (formatted && i % 16 == 15)
            (void) printf("\n");
    }
    (void) printf("\n");
}


/*
 * TSS convenience functions
 */

void
print_error(TSS_RESULT ret, char *msg)
{
    char *err_string;
    extern char *Trspi_Error_String();

    err_string = Trspi_Error_String(ret);
    (void) fprintf(stderr, "%s: %s (0x%0x)\n", msg, err_string, ret);
}

int
get_tpm_capability(TSS_HCONTEXT hContext, TSS_HOBJECT hTPM, UINT32 cap,
UINT32 subcap, void *buf, size_t bufsize)
{
    TSS_RESULT ret;
    UINT32 datalen;
    BYTE *data;

    ret = Tspi_TPM_GetCapability(hTPM, cap, sizeof (subcap),
        (BYTE *)&subcap, &datalen, &data);
    if (ret) {
        print_error(ret, gettext("Get TPM capability"));
        return (ERR_FAIL);
    }

    if (datalen > bufsize) {
        (void) fprintf(stderr,
            gettext("Capability 0x%x returned %u bytes "
            "(expected %u)\n"), cap, datalen, bufsize);
        return (ERR_FAIL);
    }
    bcopy(data, buf, datalen);

    ret = Tspi_Context_FreeMemory(hContext, data);
    if (ret) {
        print_error(ret, gettext("Free capability buffer"));
        return (ERR_FAIL);
    }

    return (0);
}

int
set_object_policy(TSS_HOBJECT handle, TSS_FLAG mode, UINT32 len, BYTE *secret)
{
    TSS_HPOLICY hPolicy;
    TSS_RESULT ret;

    ret = Tspi_GetPolicyObject(handle, TSS_POLICY_USAGE, &hPolicy);
    if (ret) {
        print_error(ret, gettext("Get object policy"));
        return (ERR_FAIL);
    }

    ret = Tspi_Policy_SetSecret(hPolicy, mode, len, secret);
    if (ret) {
        print_error(ret, gettext("Set policy secret"));
        return (ERR_FAIL);
    }

    return (0);
}

int
tpm_preamble(TSS_HCONTEXT *hContext, TSS_HOBJECT *hTPM)
{
    TSS_RESULT ret;

    ret = Tspi_Context_Create(hContext);
    if (ret) {
        print_error(ret, gettext("Create context"));
        return (ERR_FAIL);
    }

    ret = Tspi_Context_Connect(*hContext, NULL);
    if (ret) {
        print_error(ret, gettext("Connect context"));
        (void) Tspi_Context_Close(*hContext);
        return (ERR_FAIL);
    }

    ret = Tspi_Context_GetTpmObject(*hContext, hTPM);
    if (ret) {
        print_error(ret, gettext("Get TPM object"));
        (void) Tspi_Context_Close(*hContext);
        return (ERR_FAIL);
    }
    return (0);
}

int
tpm_postamble(TSS_HCONTEXT hContext)
{
    TSS_RESULT ret;

    ret = Tspi_Context_Close(hContext);
    if (ret) {
        print_error(ret, gettext("Close context"));
        return (ERR_FAIL);
    }
    return (0);
}