main.c File Reference

#include <ctype.h>
#include <errno.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include "cmdline.h"
#include "parsing.h"
#include "util.h"
#include <yubihsm.h>

Include dependency graph for main.c:

Go to the source code of this file.

Macros
#define	INPUT_BUFSIZE   4096
#define	WRAPKEY_BUFSIZE   32
#define	OBJECT_HEADER_SIZE   59

Functions
int	main (int argc, char *argv[])

Macro Definition Documentation

INPUT_BUFSIZE

#define INPUT_BUFSIZE   4096

Definition at line 41 of file main.c.

OBJECT_HEADER_SIZE

#define OBJECT_HEADER_SIZE   59

Definition at line 44 of file main.c.

WRAPKEY_BUFSIZE

#define WRAPKEY_BUFSIZE   32

Definition at line 42 of file main.c.

Function Documentation

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 197 of file main.c.

                                 {
  struct gengetopt_args_info args_info;
 
  int rc = EXIT_FAILURE;
  yh_rc yhrc;
 
  FILE *input_file = NULL;
  FILE *output_file = NULL;
  FILE *wrapkey_file = NULL;
 
#pragma pack(push, 1)
  union {
    struct {
      uint8_t header[OBJECT_HEADER_SIZE];
      uint8_t body[INPUT_BUFSIZE];
    };
    uint8_t buf[1];
  } wrap_object = {{{0}, {0}}};
#pragma pack(pop)
  size_t wrap_object_len = sizeof(wrap_object.body);
 
  if (cmdline_parser(argc, argv, &args_info) != 0) {
    goto main_exit;
  }
 
  yh_algorithm algorithm;
  yhrc = yh_string_to_algo(args_info.algorithm_arg, &algorithm);
  if (yhrc != YHR_SUCCESS) {
    fprintf(stderr, "Unable to parse algorithm: %s\n", yh_strerror(yhrc));
    goto main_exit;
  }
 
  yh_capabilities capabilities = {{0}};
  yhrc = yh_string_to_capabilities(args_info.capabilities_arg, &capabilities);
  if (yhrc != YHR_SUCCESS) {
    fprintf(stderr, "Unable to parse capabilities: %s\n", yh_strerror(yhrc));
    goto main_exit;
  }
 
  uint16_t domains;
  yhrc = yh_string_to_domains(args_info.domains_arg, &domains);
  if (yhrc != YHR_SUCCESS) {
    fprintf(stderr, "Unable to parse domains: %s\n", yh_strerror(yhrc));
    goto main_exit;
  }
 
  uint16_t id = args_info.id_arg;
 
  uint8_t label[YH_OBJ_LABEL_LEN] = {0};
  size_t label_len = strlen(args_info.label_arg);
  if (label_len > YH_OBJ_LABEL_LEN) {
    fprintf(stderr,
            "Unable to parse label: label too long, maximum length is %d\n",
            YH_OBJ_LABEL_LEN);
    goto main_exit;
  }
  memcpy(label, args_info.label_arg, label_len);
 
  yh_object_type type;
  if (algo2type(algorithm, &type) == false) {
    fprintf(stderr, "Invalid algorithm\n");
    goto main_exit;
  }
 
  yh_capabilities delegated = {{0}};
  bool has_delegated =
    ((type == YH_AUTHENTICATION_KEY || type == YH_WRAP_KEY) ? true : false);
  if (has_delegated == true) {
    if (!args_info.delegated_given) {
      fprintf(stderr, "Missing delegated capabilities argument\n");
      goto main_exit;
    }
 
    yhrc = yh_string_to_capabilities(args_info.delegated_arg, &delegated);
    if (yhrc != YHR_SUCCESS) {
      fprintf(stderr, "Unable to parse delegated capabilities: %s\n",
              yh_strerror(yhrc));
      goto main_exit;
    }
  }
 
  input_file = open_file(args_info.in_arg, true);
  if (input_file == NULL) {
    perror("Unable to open input file");
    goto main_exit;
  }
 
  switch (type) {
    case YH_AUTHENTICATION_KEY: {
      char password[256] = {0};
      size_t password_len = sizeof(password);
 
      if (input_file == stdin) {
        const char *prompt = "Derivation Password: ";
        if (EVP_read_pw_string(password, password_len, prompt, 1)) {
          fprintf(stderr, "Unable to read password prompt\n");
          goto main_exit;
        }
        password_len = strlen(password);
      } else {
        if (read_file(input_file, (uint8_t *) password, &password_len) ==
            false) {
          fprintf(stderr, "Unable to read input file\n");
          goto main_exit;
        }
        if (password[password_len - 1] == '\n') {
          password_len--;
        }
        if (password[password_len - 1] == '\r') {
          password_len--;
        }
        password[password_len] = '\0';
      }
 
      uint8_t key[YH_KEY_LEN * 2];
      int ret =
        PKCS5_PBKDF2_HMAC((const char *) password, password_len,
                          (uint8_t *) YH_DEFAULT_SALT, strlen(YH_DEFAULT_SALT),
                          YH_DEFAULT_ITERS, EVP_sha256(), sizeof(key), key);
      if (ret != 1) {
        fprintf(stderr, "Unable to derive keys\n");
        goto main_exit;
      }
 
      memcpy(wrap_object.body, delegated.capabilities, YH_CAPABILITIES_LEN);
      wrap_object_len -= YH_CAPABILITIES_LEN;
 
      memcpy(wrap_object.body + YH_CAPABILITIES_LEN, key, YH_KEY_LEN);
      memcpy(wrap_object.body + YH_CAPABILITIES_LEN + YH_KEY_LEN,
             key + YH_KEY_LEN, YH_KEY_LEN);
      wrap_object_len = YH_CAPABILITIES_LEN + YH_KEY_LEN * 2;
    } break;
 
    case YH_WRAP_KEY: {
      memcpy(wrap_object.body, delegated.capabilities, YH_CAPABILITIES_LEN);
      wrap_object_len -= YH_CAPABILITIES_LEN;
 
      if (read_file(input_file, wrap_object.body + YH_CAPABILITIES_LEN,
                    &wrap_object_len) == false) {
        fprintf(stderr, "Unable to read input file\n");
        goto main_exit;
      }
      wrap_object_len += YH_CAPABILITIES_LEN;
    } break;
 
    case YH_ASYMMETRIC_KEY: {
      yh_algorithm parsed_algorithm;
      if (read_file(input_file, wrap_object.body, &wrap_object_len) == false) {
        fprintf(stderr, "Unable to read input file\n");
        goto main_exit;
      }
 
      if (read_private_key(wrap_object.body, wrap_object_len, &parsed_algorithm,
                           wrap_object.body, &wrap_object_len, true) != true) {
        fprintf(stderr, "Unable to read asymmetric private key\n");
        goto main_exit;
      }
 
      if (parsed_algorithm != algorithm) {
        fprintf(stderr, "Mismatched algorithm\n");
        goto main_exit;
      }
    } break;
 
    case YH_HMAC_KEY: {
      if (read_file(input_file, wrap_object.body, &wrap_object_len) == false) {
        fprintf(stderr, "Unable to read input file\n");
        goto main_exit;
      }
 
      if (split_hmac_key(algorithm, wrap_object.body, wrap_object_len,
                         wrap_object.body, &wrap_object_len) != true) {
        fprintf(stderr, "Unable to format hmac key\n");
        goto main_exit;
      }
    } break;
 
    default:
      if (read_file(input_file, wrap_object.body, &wrap_object_len) == false) {
        fprintf(stderr, "Unable to read input file\n");
        goto main_exit;
      }
  }
 
  wrapkey_file = open_file(args_info.wrapkey_arg, true);
  if (wrapkey_file == NULL) {
    perror("Unable to open wrapkey file");
    goto main_exit;
  }
 
  uint8_t wrapkey_buf[WRAPKEY_BUFSIZE];
  size_t wrapkey_buf_len = sizeof(wrapkey_buf);
  if (read_file(wrapkey_file, wrapkey_buf, &wrapkey_buf_len) == false) {
    fprintf(stderr, "Unable to read wrapkey file\n");
  }
 
  yh_algorithm wrapkey_algorithm;
  switch (wrapkey_buf_len) {
    case 16:
      wrapkey_algorithm = YH_ALGO_AES128_CCM_WRAP;
      break;
    case 24:
      wrapkey_algorithm = YH_ALGO_AES192_CCM_WRAP;
      break;
    case 32:
      wrapkey_algorithm = YH_ALGO_AES256_CCM_WRAP;
      break;
    default:
      fprintf(stderr, "Unable to parse wrapkey: invalid length\n");
      goto main_exit;
  }
 
  output_file = open_file(args_info.out_arg, false);
  if (output_file == NULL) {
    perror("Unable to open output file");
    goto main_exit;
  }
 
  format_header(wrapkey_algorithm, capabilities, id, wrap_object_len, domains,
                type, algorithm, label, wrap_object.header);
 
  uint8_t wrapped[2048] = {0};
  size_t wrapped_len = sizeof(wrapped);
 
  if (wrap_data(wrapkey_buf, wrapkey_buf_len, wrap_object.buf,
                OBJECT_HEADER_SIZE + wrap_object_len, wrapped,
                &wrapped_len) == false) {
    fprintf(stderr, "Unable to wrap data\n");
    goto main_exit;
  }
 
  if (getenv("DEBUG") != NULL) {
    dump_hex(wrap_object.buf, OBJECT_HEADER_SIZE + wrap_object_len);
  }
  if (write_file(wrapped, wrapped_len, output_file, _base64) == false ||
      write_file((uint8_t *) "\n", 1, output_file, _binary) == false) {
    fprintf(stderr, "Unable to write output file\n");
    goto main_exit;
  }
 
  rc = EXIT_SUCCESS;
 
main_exit:
 
  cmdline_parser_free(&args_info);
 
  if (input_file != NULL) {
    fclose(input_file);
    input_file = NULL;
  }
 
  if (output_file != NULL) {
    fclose(output_file);
    output_file = NULL;
  }
 
  if (wrapkey_file != NULL) {
    fclose(wrapkey_file);
    wrapkey_file = NULL;
  }
 
  return rc;
}

Here is the call graph for this function: