wanboot/hmac/hmac.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "%Z%%M% %I% %E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <libintl.h>
#include <locale.h>
#include <string.h>
#include <errno.h>
#include <wanbootutil.h>
#include <sys/wanboot_impl.h>

/* Return codes */
#define HMAC_SUCCESS    0
#define HMAC_NOKEY  1
#define HMAC_ERROR  2

/* Private buffer length */
#define HMAC_BUF_LEN    1024

/*
 * This routine is used to compute a hash digest for the file represented
 * by the file descirptor, 'fd'. The key, 'hmac_key', and key type, 'ka',
 * will be provided by the caller. The resulting hash digest will be
 * written to stdout.
 *
 * Returns:
 *  HMAC_SUCCESS or HMAC_ERROR.
 */
static int
hash_gen(int in_fd, const wbku_key_attr_t *ka, const uint8_t *hmac_key)
{
    SHA1_CTX ctx;
    uint8_t buf[HMAC_BUF_LEN];
    ssize_t i;
    uint8_t digest[HMAC_DIGEST_LEN];

    /*
     * Initialize the computation.
     */
    HMACInit(&ctx, hmac_key, ka->ka_len);

    /*
     * Read the data to hash.
     */
    while ((i = read(in_fd, buf, HMAC_BUF_LEN)) > 0) {
        HMACUpdate(&ctx, buf, i);
    }
    if (i < 0) {
        wbku_printerr("Cannot read input_file");
        return (HMAC_ERROR);
    }

    /*
     * Finalize the digest.
     */
    HMACFinal(&ctx, hmac_key, ka->ka_len, digest);

    /*
     * Write the digest to stdout.
     */
    if (wbio_nwrite(STDOUT_FILENO, digest, sizeof (digest)) != 0) {
        wbku_printerr("Cannot output digest");
        return (HMAC_ERROR);
    }

    /*
     * Success.
     */
    return (HMAC_SUCCESS);
}

/*
 * Prints usage().
 */
static void
usage(const char *cmd)
{
    (void) fprintf(stderr,
        gettext("Usage: %s [-i input_file] -k key_file\n"), cmd);
}

/*
 * This program is used to compute a hash digest for data read in from
 * stdin or optionally, a file. The resulting hash digest will be written
 * to stdout.
 *
 * Returns:
 *  HMAC_SUCCESS, HMAC_ERROR or HMAC_NOKEY.
 */
int
main(int argc, char **argv)
{
    uint8_t hmac_key[WANBOOT_HMAC_KEY_SIZE];
    int c;
    char *infile_name = NULL;
    char *keyfile_name = NULL;
    int in_fd = -1;
    FILE *key_fp = NULL;
    wbku_key_attr_t ka;
    wbku_retcode_t wbkuret;
    int ret = HMAC_ERROR;

    /*
     * Do the necessary magic for localization support.
     */
    (void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
    (void) textdomain(TEXT_DOMAIN);

    /*
     * Initialize program name for use by wbku_printerr().
     */
    wbku_errinit(argv[0]);

    /*
     * Should be at least three arguments.
     */
    if (argc < 3) {
        usage(argv[0]);
        return (HMAC_ERROR);
    }

    /*
     * Parse the options.
     */
    while ((c = getopt(argc, argv, "i:k:")) != EOF) {
        switch (c) {
        case 'i':
            /*
             * Optional input file.
             */
            infile_name = optarg;
            break;
        case 'k':
            /*
             * Path to key file.
             */
            keyfile_name = optarg;
            break;
        default:
            usage(argv[0]);
            return (HMAC_ERROR);
        }
    }

    /*
     * A key file must be defined.
     */
    if (keyfile_name == NULL) {
        wbku_printerr("Must specify the key_file\n");
        return (HMAC_ERROR);
    }

    /*
     * If the user did not provide an input file for the data,
     * then use stdin as the source.
     */
    if (infile_name == NULL) {
        in_fd = STDIN_FILENO;
    } else {
        in_fd = open(infile_name, O_RDONLY);
        if (in_fd < 0) {
            wbku_printerr("Cannot open input_file");
            return (HMAC_ERROR);
        }
    }

    /*
     * Open the key file for reading.
     */
    if ((key_fp = fopen(keyfile_name, "r")) == NULL) {
        wbku_printerr("Cannot open %s", keyfile_name);
        goto out;
    }

    /*
     * Create a SHA1 key attribute structure. It's the only hash
     * type we support.
     */
    wbkuret = wbku_str_to_keyattr(WBKU_KW_HMAC_SHA1, &ka, WBKU_HASH_KEY);
    if (wbkuret != WBKU_SUCCESS) {
        wbku_printerr("%s\n", wbku_retmsg(wbkuret));
        goto out;
    }

    /*
     * Find the client key, if it exists.
     */
    wbkuret = wbku_find_key(key_fp, NULL, &ka, hmac_key, B_FALSE);
    if (wbkuret != WBKU_SUCCESS) {
        wbku_printerr("%s\n", wbku_retmsg(wbkuret));
        ret = (wbkuret == WBKU_NOKEY) ? HMAC_NOKEY : HMAC_ERROR;
    } else {
        ret = hash_gen(in_fd, &ka, hmac_key);
    }
out:
    /*
     * Cleanup.
     */
    if (in_fd != -1) {
        (void) close(in_fd);
    }
    if (key_fp != NULL) {
        (void) fclose(key_fp);
    }

    return (ret);
}