source: trunk/packages/xen-3.1/xen-3.1/tools/vtpm/tpm_emulator.patch @ 34

Last change on this file since 34 was 34, checked in by hartmans, 18 years ago

Add xen and xen-common

  • Property svn:mime-type set to text/x-patch
File size: 71.8 KB
  • AUTHORS

    diff -uprN orig/tpm_emulator-0.4/AUTHORS tpm_emulator/AUTHORS
    old new  
    11Mario Strasser <mast@gmx.net>
    22Heiko Stamer <stamer@gaos.org> [DAA]
     3INTEL Corp <> [Dropped to Ring3]
  • ChangeLog

    diff -uprN orig/tpm_emulator-0.4/ChangeLog tpm_emulator/ChangeLog
    old new  
     1????-??-?? Intel Corp
     2        * Moved module out of kernel to run as a ring 3 app
     3
    142006-06-23  Mario Strasser <mast@gmx.net>
    25        * tpm_startup.c: behaviour of ST_CLEAR and storage of
    36                persistent data adapted
  • crypto/gmp_kernel_wrapper.c

    diff -uprN orig/tpm_emulator-0.4/crypto/gmp_kernel_wrapper.c tpm_emulator/crypto/gmp_kernel_wrapper.c
    old new  
    11/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
    22 * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
     3 * Copyright (C) 2005 INTEL Corp
    34 *
    45 * This module is free software; you can redistribute it and/or modify
    56 * it under the terms of the GNU General Public License as published
    int __gmp_junk; 
    2425void __attribute__ ((regparm(0))) __gmp_assert_fail(const char *filename,
    2526  int linenum, const char *expr)
    2627{
    27   panic(KERN_CRIT TPM_MODULE_NAME "%s:%d: GNU MP assertion failed: %s\n",
     28  error("%s:%d: GNU MP assertion failed: %s\n",
    2829    filename, linenum, expr);
    2930}
    3031
    31 void __attribute__ ((regparm(0))) abort(void)
    32 {
    33   panic(KERN_CRIT TPM_MODULE_NAME "GNU MP abort() was called\n");
    34 }
    35 
    3632/* overwrite GNU MP random functions (used by mpz/millerrabin.c) */
    3733
    3834void __attribute__ ((regparm(0))) gmp_randinit(gmp_randstate_t rstate,
    void __attribute__ ((regparm(0))) mpz_ur 
    7773
    7874void __attribute__ ((regparm(0))) *kernel_allocate(size_t size)
    7975{
    80   void *ret  = (void*)kmalloc(size, GFP_KERNEL);
    81   if (!ret) panic(KERN_CRIT TPM_MODULE_NAME
    82     "GMP: cannot allocate memory (size=%u)\n", size);
     76  void *ret  = (void*)malloc(size);
     77  if (!ret) error("GMP: cannot allocate memory (size=%Zu)\n", size);
    8378  return ret;
    8479}
    8580
    8681void __attribute__ ((regparm(0))) *kernel_reallocate(void *oldptr,
    8782  size_t old_size, size_t new_size)
    8883{
    89   void *ret = (void*)kmalloc(new_size, GFP_KERNEL);
    90   if (!ret) panic(KERN_CRIT TPM_MODULE_NAME "GMP: Cannot reallocate memory "
    91     "(old_size=%u new_size=%u)\n", old_size, new_size);
     84  void *ret = (void*)malloc(new_size);
     85  if (!ret) error("GMP: Cannot reallocate memory "
     86    "(old_size=%Zu new_size=%Zu)\n", old_size, new_size);
    9287  memcpy(ret, oldptr, old_size);
    93   kfree(oldptr);
     88  free(oldptr);
    9489  return ret;
    9590}
    9691
    void __attribute__ ((regparm(0))) kernel 
    9994  /* overwrite used memory */
    10095  if (blk_ptr != NULL) {
    10196    memset(blk_ptr, 0, blk_size);
    102     kfree(blk_ptr);
     97    free(blk_ptr);
    10398  }
    10499}
    105100
  • crypto/rsa.c

    diff -uprN orig/tpm_emulator-0.4/crypto/rsa.c tpm_emulator/crypto/rsa.c
    old new  
    11/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
    22 * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
     3 * Copyright (C) 2005 INTEL Corp
    34 *
    45 * This module is free software; you can redistribute it and/or modify
    56 * it under the terms of the GNU General Public License as published
    static int encode_message(int type, uint 
    381382      msg[0] = 0x00;
    382383      get_random_bytes(&msg[1], SHA1_DIGEST_LENGTH);
    383384      sha1_init(&ctx);
    384       sha1_update(&ctx, "TCPA", 4);
     385      sha1_update(&ctx, (uint8_t *) "TCPA", 4);
    385386      sha1_final(&ctx, &msg[1 + SHA1_DIGEST_LENGTH]);
    386387      memset(&msg[1 + 2 * SHA1_DIGEST_LENGTH], 0x00,
    387388        msg_len - data_len - 2 * SHA1_DIGEST_LENGTH - 2);
    static int decode_message(int type, uint 
    429430      mask_generation(&msg[1], SHA1_DIGEST_LENGTH,
    430431        &msg[1 + SHA1_DIGEST_LENGTH], msg_len - SHA1_DIGEST_LENGTH - 1);
    431432      sha1_init(&ctx);
    432       sha1_update(&ctx, "TCPA", 4);
     433      sha1_update(&ctx, (uint8_t *) "TCPA", 4);
    433434      sha1_final(&ctx, &msg[1]);
    434435      if (memcmp(&msg[1], &msg[1 + SHA1_DIGEST_LENGTH],
    435436          SHA1_DIGEST_LENGTH) != 0) return -1;
  • linux_module.c

    diff -uprN orig/tpm_emulator-0.4/linux_module.c tpm_emulator/linux_module.c
    old new  
    1 /* Software-Based Trusted Platform Module (TPM) Emulator for Linux
    2  * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
    3  *
    4  * This module is free software; you can redistribute it and/or modify
    5  * it under the terms of the GNU General Public License as published
    6  * by the Free Software Foundation; either version 2 of the License,
    7  * or (at your option) any later version. 
    8  *
    9  * This module is distributed in the hope that it will be useful,
    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    12  * GNU General Public License for more details.
    13  *
    14  * $Id: linux_module.c 91 2006-03-13 13:51:41Z mast $
    15  */
    16 
    17 #include <linux/module.h>
    18 #include <linux/kernel.h>
    19 #include <linux/init.h>
    20 #include <linux/miscdevice.h>
    21 #include <linux/poll.h>
    22 #include "linux_module.h"
    23 #include "tpm/tpm_emulator.h"
    24 
    25 MODULE_LICENSE("GPL");
    26 MODULE_AUTHOR("Mario Strasser <mast@gmx.net>");
    27 MODULE_DESCRIPTION("Trusted Platform Module (TPM) Emulator");
    28 MODULE_SUPPORTED_DEVICE(TPM_DEVICE_NAME);
    29 
    30 /* module startup parameters */
    31 char *startup = "save";
    32 module_param(startup, charp, 0444);
    33 MODULE_PARM_DESC(startup, " Sets the startup mode of the TPM. "
    34   "Possible values are 'clear', 'save' (default) and 'deactivated.");
    35 char *storage_file = "/var/tpm/tpm_emulator-1.2.0.2";
    36 module_param(storage_file, charp, 0644);
    37 MODULE_PARM_DESC(storage_file, " Sets the persistent-data storage "
    38   "file of the TPM.");
    39 
    40 /* TPM lock */
    41 static struct semaphore tpm_mutex;
    42 
    43 /* TPM command response */
    44 static struct {
    45   uint8_t *data;
    46   uint32_t size;
    47 } tpm_response;
    48 
    49 /* module state */
    50 #define STATE_IS_OPEN 0
    51 static uint32_t module_state;
    52 static struct timespec old_time;
    53 
    54 static int tpm_open(struct inode *inode, struct file *file)
    55 {
    56   debug("%s()", __FUNCTION__);
    57   if (test_and_set_bit(STATE_IS_OPEN, (void*)&module_state)) return -EBUSY;
    58   return 0;
    59 }
    60 
    61 static int tpm_release(struct inode *inode, struct file *file)
    62 {
    63   debug("%s()", __FUNCTION__);
    64   clear_bit(STATE_IS_OPEN, (void*)&module_state);
    65   down(&tpm_mutex);
    66   if (tpm_response.data != NULL) {
    67     kfree(tpm_response.data);
    68     tpm_response.data = NULL;
    69   }
    70   up(&tpm_mutex);
    71   return 0;
    72 }
    73 
    74 static ssize_t tpm_read(struct file *file, char *buf, size_t count, loff_t *ppos)
    75 {
    76   debug("%s(%d)", __FUNCTION__, count);
    77   down(&tpm_mutex);
    78   if (tpm_response.data != NULL) {
    79     count = min(count, (size_t)tpm_response.size - (size_t)*ppos);
    80     count -= copy_to_user(buf, &tpm_response.data[*ppos], count);
    81     *ppos += count;
    82     if ((size_t)tpm_response.size == (size_t)*ppos) {
    83       kfree(tpm_response.data);
    84       tpm_response.data = NULL;
    85     }
    86   } else {
    87     count = 0;
    88   }
    89   up(&tpm_mutex);
    90   return count;
    91 }
    92 
    93 static ssize_t tpm_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
    94 {
    95   debug("%s(%d)", __FUNCTION__, count);
    96   down(&tpm_mutex);
    97   *ppos = 0;
    98   if (tpm_response.data != NULL) kfree(tpm_response.data);
    99   if (tpm_handle_command(buf, count, &tpm_response.data,
    100                          &tpm_response.size) != 0) {
    101     count = -EILSEQ;
    102     tpm_response.data = NULL;
    103   }
    104   up(&tpm_mutex);
    105   return count;
    106 }
    107 
    108 #define TPMIOC_CANCEL   _IO('T', 0x00)
    109 #define TPMIOC_TRANSMIT _IO('T', 0x01)
    110 
    111 static int tpm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
    112 {
    113   debug("%s(%d, %p)", __FUNCTION__, cmd, (char*)arg);
    114   if (cmd == TPMIOC_TRANSMIT) {
    115     uint32_t count = ntohl(*(uint32_t*)(arg + 2));
    116     down(&tpm_mutex);
    117     if (tpm_response.data != NULL) kfree(tpm_response.data);
    118     if (tpm_handle_command((char*)arg, count, &tpm_response.data,
    119                            &tpm_response.size) == 0) {
    120       tpm_response.size -= copy_to_user((char*)arg, tpm_response.data,
    121                             tpm_response.size);
    122       kfree(tpm_response.data);
    123       tpm_response.data = NULL;
    124     } else {
    125       tpm_response.size = 0;
    126       tpm_response.data = NULL;
    127     }
    128     up(&tpm_mutex);
    129     return tpm_response.size;
    130   }
    131   return -1;
    132 }
    133 
    134 struct file_operations fops = {
    135   .owner   = THIS_MODULE,
    136   .open    = tpm_open,
    137   .release = tpm_release,
    138   .read    = tpm_read,
    139   .write   = tpm_write,
    140   .ioctl   = tpm_ioctl,
    141 };
    142 
    143 static struct miscdevice tpm_dev = {
    144   .minor      = TPM_DEVICE_MINOR,
    145   .name       = TPM_DEVICE_NAME,
    146   .fops       = &fops,
    147 };
    148 
    149 int __init init_tpm_module(void)
    150 {
    151   int res = misc_register(&tpm_dev);
    152   if (res != 0) {
    153     error("misc_register() failed for minor %d\n", TPM_DEVICE_MINOR);
    154     return res;
    155   }
    156   /* initialize variables */
    157   sema_init(&tpm_mutex, 1);
    158   module_state = 0;
    159   tpm_response.data = NULL;
    160   old_time = current_kernel_time();
    161   /* initialize TPM emulator */
    162   if (!strcmp(startup, "clear")) {
    163     tpm_emulator_init(1);
    164   } else if (!strcmp(startup, "save")) {
    165     tpm_emulator_init(2);
    166   } else if (!strcmp(startup, "deactivated")) {
    167     tpm_emulator_init(3);
    168   } else {
    169     error("invalid startup mode '%s'; must be 'clear', "
    170       "'save' (default) or 'deactivated", startup);
    171     misc_deregister(&tpm_dev);
    172     return -EINVAL;
    173   }
    174   return 0;
    175 }
    176 
    177 void __exit cleanup_tpm_module(void)
    178 {
    179   tpm_emulator_shutdown();
    180   misc_deregister(&tpm_dev);
    181   if (tpm_response.data != NULL) kfree(tpm_response.data);
    182 }
    183 
    184 module_init(init_tpm_module);
    185 module_exit(cleanup_tpm_module);
    186 
    187 uint64_t tpm_get_ticks(void)
    188 {
    189   struct timespec new_time = current_kernel_time();
    190   uint64_t ticks = (uint64_t)(new_time.tv_sec - old_time.tv_sec) * 1000000
    191                    + (new_time.tv_nsec - old_time.tv_nsec) / 1000;
    192   old_time = new_time;
    193   return (ticks > 0) ? ticks : 1;
    194 }
    195 
  • linux_module.h

    diff -uprN orig/tpm_emulator-0.4/linux_module.h tpm_emulator/linux_module.h
    old new  
    11/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
    22 * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
     3 * Copyright (C) 2005 INTEL Corp
    34 *
    45 * This module is free software; you can redistribute it and/or modify
    56 * it under the terms of the GNU General Public License as published
     
    1718#ifndef _LINUX_MODULE_H_
    1819#define _LINUX_MODULE_H_
    1920
    20 #include <linux/version.h>
    21 #include <linux/kernel.h>
    22 #include <linux/slab.h>
     21#include <malloc.h>
     22#include <stdint.h>
     23#include <stdio.h>
     24#include <string.h>
    2325#include <linux/types.h>
    24 #include <linux/string.h>
    25 #include <linux/random.h>
    26 #include <linux/time.h>
    27 #include <asm/byteorder.h>
    2826
    29 /* module settings */
     27#include <endian.h>
     28#define __BYTEORDER_HAS_U64__
     29#ifdef LITTLE_ENDIAN
     30 #include <linux/byteorder/little_endian.h>
     31#else
     32 #include <linux/byteorder/big_endian.h>
     33#endif
    3034
     35/* module settings */
     36#define min(A,B) ((A)<(B)?(A):(B))
     37#ifndef STR
    3138#define STR(s) __STR__(s)
    3239#define __STR__(s) #s
     40#endif
    3341#include "tpm_version.h"
    3442
    3543#define TPM_DEVICE_MINOR  224
    3644#define TPM_DEVICE_NAME   "tpm"
    3745#define TPM_MODULE_NAME   "tpm_emulator"
    3846
    39 /* debug and log output functions */
    40 
    4147#ifdef DEBUG
    42 #define debug(fmt, ...) printk(KERN_DEBUG "%s %s:%d: Debug: " fmt "\n", \
    43                         TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__)
     48#define debug(fmt, ...) printf("TPMD: %s:%d: Debug: " fmt "\n", \
     49                        __FILE__, __LINE__, ## __VA_ARGS__)
    4450#else
    4551#define debug(fmt, ...)
    4652#endif
    47 #define info(fmt, ...)  printk(KERN_INFO "%s %s:%d: Info: " fmt "\n", \
    48                         TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__)
    49 #define error(fmt, ...) printk(KERN_ERR "%s %s:%d: Error: " fmt "\n", \
    50                         TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__)
    51 #define alert(fmt, ...) printk(KERN_ALERT "%s %s:%d: Alert: " fmt "\n", \
    52                         TPM_MODULE_NAME, __FILE__, __LINE__, ## __VA_ARGS__)
     53#define info(fmt, ...)  printf("TPMD: %s:%d: Info: " fmt "\n", \
     54                        __FILE__, __LINE__, ## __VA_ARGS__)
     55#define error(fmt, ...) printf("TPMD: %s:%d: Error: " fmt "\n", \
     56                        __FILE__, __LINE__, ## __VA_ARGS__)
     57#define alert(fmt, ...) printf("TPMD: %s:%d: Alert: " fmt "\n", \
     58                        __FILE__, __LINE__, ## __VA_ARGS__)
    5359
    5460/* memory allocation */
    5561
    5662static inline void *tpm_malloc(size_t size)
    5763{
    58   return kmalloc(size, GFP_KERNEL); 
     64  return malloc(size); 
    5965}
    6066
    6167static inline void tpm_free(const void *ptr)
    6268{
    63   if (ptr != NULL) kfree(ptr);
     69  if (ptr != NULL) free( (void *) ptr);
    6470}
    6571
    6672/* random numbers */
    6773
     74//FIXME;
     75void get_random_bytes(void *buf, int nbytes);
     76
    6877static inline void tpm_get_random_bytes(void *buf, int nbytes)
    6978{
    7079  get_random_bytes(buf, nbytes);
    uint64_t tpm_get_ticks(void); 
    8493#define CPU_TO_LE16(x) __cpu_to_le16(x)
    8594
    8695#define BE64_TO_CPU(x) __be64_to_cpu(x)
    87 #define LE64_TO_CPU(x) __be64_to_cpu(x)
     96#define LE64_TO_CPU(x) __le64_to_cpu(x)
    8897#define BE32_TO_CPU(x) __be32_to_cpu(x)
    89 #define LE32_TO_CPU(x) __be32_to_cpu(x)
     98#define LE32_TO_CPU(x) __le32_to_cpu(x)
    9099#define BE16_TO_CPU(x) __be16_to_cpu(x)
    91100#define LE16_TO_CPU(x) __le16_to_cpu(x)
    92101
  • Makefile

    diff -uprN orig/tpm_emulator-0.4/Makefile tpm_emulator/Makefile
    old new  
    11# Software-Based Trusted Platform Module (TPM) Emulator for Linux
    22# Copyright (C) 2004 Mario Strasser <mast@gmx.net>
     3# Copyright (C) 2006 INTEL Corp.
    34#
    45# $Id: Makefile 115 2006-06-23 10:36:44Z mast $
    56
    6 # kernel settings
    7 KERNEL_RELEASE := $(shell uname -r)
    8 KERNEL_BUILD   := /lib/modules/$(KERNEL_RELEASE)/build
    9 MOD_SUBDIR     := misc
     7COMPILE_ARCH    ?= $(shell uname -m | sed -e s/i.86/x86_32/)
    108
    119# module settings
    12 MODULE_NAME    := tpm_emulator
     10BIN            := tpm_emulator
    1311VERSION_MAJOR  := 0
    1412VERSION_MINOR  := 4
    1513VERSION_BUILD  := $(shell date +"%s")
    1614
    17 # enable/disable DEBUG messages
    18 EXTRA_CFLAGS   += -Wall -DDEBUG -g 
     15# Installation program and options
     16INSTALL         = install
     17INSTALL_PROG    = $(INSTALL) -m0755
     18INSTALL_DIR     = $(INSTALL) -d -m0755
     19
     20# Xen tools installation directory
     21TOOLS_INSTALL_DIR = $(DESTDIR)/usr/bin
     22
     23CC      := gcc
     24CFLAGS  += -g -Wall $(INCLUDE) -DDEBUG
     25CFLAGS  += -I. -Itpm
     26
     27# Is the simulator running in it's own vm?
     28#CFLAGS += -DVTPM_MULTI_VM
     29
     30ifeq ($(COMPILE_ARCH),x86_64)
     31LIBDIR = lib64
     32else
     33LIBDIR = lib
     34endif
    1935
    2036# GNU MP configuration
    21 GMP_LIB        := /usr/lib/libgmp.a
     37GMP_LIB        := /usr/$(LIBDIR)/libgmp.a
    2238GMP_HEADER     := /usr/include/gmp.h
    2339
    2440# sources and objects
    DIRS := . crypto tpm  
    2743SRCS           := $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.c))
    2844OBJS           := $(patsubst %.c, %.o, $(SRCS))
    2945SRCS           += $(foreach dir, $(DIRS), $(wildcard $(src)/$(dir)/*.h))
    30 DISTSRC        := ./README ./AUTHORS ./ChangeLog ./Makefile $(SRCS)
    31 DISTDIR        := tpm_emulator-$(VERSION_MAJOR).$(VERSION_MINOR)
    3246
    33 obj-m               := $(MODULE_NAME).o
    34 $(MODULE_NAME)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a
     47obj-m               := $(BIN)
     48$(BIN)-objs := $(patsubst $(src)/%.o, %.o, $(OBJS)) crypto/libgmp.a
    3549
    3650EXTRA_CFLAGS   += -I$(src) -I$(src)/crypto -I$(src)/tpm
    3751
    3852# do not print "Entering directory ..."
    3953MAKEFLAGS      += --no-print-directory
    4054
    41 all:    $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version
    42         @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules
     55all: $(BIN)
    4356
    44 install:
    45         @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) modules_install
    46         test -d /var/tpm || mkdir /var/tpm
    47         test -c /dev/tpm || mknod /dev/tpm c 10 224
    48         chmod 666 /dev/tpm
    49         depmod -a
     57$(BIN): $(src)/crypto/gmp.h $(src)/crypto/libgmp.a version $(SRCS) $(OBJS)
     58        $(CC) $(CFLAGS) $(OBJS) $(src)/crypto/libgmp.a -o $(BIN)
     59
     60%.o: %.c
     61        $(CC) $(CFLAGS) -c $< -o $@
     62
     63install: $(BIN)
     64        $(INSTALL_PROG) $(BIN) $(TOOLS_INSTALL_DIR)
     65        @if [ ! -d "/var/tpm" ]; then mkdir /var/tpm; fi
    5066
    5167clean:
    52         @$(MAKE) -C $(KERNEL_BUILD) M=$(CURDIR) clean
    53         rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a
     68        rm -f $(src)/crypto/gmp.h $(src)/crypto/libgmp.a $(OBJS)
    5469
    55 dist:   $(DISTSRC)
    56         rm -rf $(DISTDIR)
    57         mkdir $(DISTDIR)
    58         cp --parents $(DISTSRC) $(DISTDIR)/
    59         rm -f $(DISTDIR)/crypto/gmp.h
    60         tar -chzf $(DISTDIR).tar.gz $(DISTDIR)
    61         rm -rf $(DISTDIR)
     70mrproper: clean
     71        rm -f $(BIN) tpm_version.h
    6272
    6373$(src)/crypto/libgmp.a:
    6474        test -f $(src)/crypto/libgmp.a || ln -s $(GMP_LIB) $(src)/crypto/libgmp.a
    version: 
    8898        @echo "#endif /* _TPM_VERSION_H_ */" >> $(src)/tpm_version.h
    8999
    90100.PHONY: all install clean dist gmp version
    91 
  • README

    diff -uprN orig/tpm_emulator-0.4/README tpm_emulator/README
    old new $Id: README 113 2006-06-18 12:38:13Z hst 
    1313Copyright
    1414--------------------------------------------------------------------------
    1515Copyright (C) 2004 Mario Strasser <mast@gmx.net> and Swiss Federal
    16 Institute of Technology (ETH) Zurich.
     16                   Institute of Technology (ETH) Zurich.
     17Copyright (C) 2005 INTEL Corp
    1718             
    1819This program is free software; you can redistribute it and/or modify
    1920it under the terms of the GNU General Public License as published by
    Example: 
    4344GMP_LIB        := /usr/lib/libgmp.a
    4445GMP_HEADER     := /usr/include/gmp.h
    4546
     47GNU MP Library on 64 bit Systems
     48--------------------------------------------------------------------------
     49Some 64-bit kernels have problems with importing the user-space gmp
     50library (/usr/lib*/libgmp.a) into kernel space.  These kernels will require
     51that the gmp library be recompiled for kernel space with -mcmodel=kernel.
     52
    4653Installation
    4754--------------------------------------------------------------------------
    4855The compilation and installation process uses the build environment for
  • tpm/tpm_credentials.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_credentials.c tpm_emulator/tpm/tpm_credentials.c
    old new int tpm_compute_pubkey_checksum(TPM_NONC 
    4747
    4848TPM_RESULT tpm_get_pubek(TPM_PUBKEY *pubEndorsementKey)
    4949{
    50   UINT32 key_length;
     50  size_t key_length;
    5151  if (!tpmData.permanent.data.endorsementKey.size) return TPM_NO_ENDORSEMENT;
    5252  /* setup TPM_PUBKEY structure */
    53   key_length = tpmData.permanent.data.endorsementKey.size;
    54   pubEndorsementKey->pubKey.keyLength = key_length >> 3;
     53  pubEndorsementKey->pubKey.keyLength = tpmData.permanent.data.endorsementKey.size >> 3;
    5554  pubEndorsementKey->pubKey.key = tpm_malloc(pubEndorsementKey->pubKey.keyLength);
    5655  if (pubEndorsementKey->pubKey.key == NULL) return TPM_FAIL;
    5756  rsa_export_modulus(&tpmData.permanent.data.endorsementKey,
    58     pubEndorsementKey->pubKey.key,
    59     &pubEndorsementKey->pubKey.keyLength);
     57                     pubEndorsementKey->pubKey.key,
     58                     &key_length);
     59  pubEndorsementKey->pubKey.keyLength = key_length;
    6060  pubEndorsementKey->algorithmParms.algorithmID = TPM_ALG_RSA;
    6161  pubEndorsementKey->algorithmParms.encScheme = TPM_ES_RSAESOAEP_SHA1_MGF1;
    6262  pubEndorsementKey->algorithmParms.sigScheme = TPM_SS_NONE;
    TPM_RESULT TPM_OwnerReadInternalPub(TPM_ 
    175175{
    176176  TPM_RESULT res;
    177177  TPM_KEY_DATA *srk = &tpmData.permanent.data.srk;
     178  size_t key_length;
    178179  info("TPM_OwnerReadInternalPub()");
    179180  /* verify authorization */
    180181  res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER);
    TPM_RESULT TPM_OwnerReadInternalPub(TPM_ 
    186187    publicPortion->pubKey.key = tpm_malloc(publicPortion->pubKey.keyLength);
    187188    if (publicPortion->pubKey.key == NULL) return TPM_FAIL;
    188189    rsa_export_modulus(&srk->key, publicPortion->pubKey.key,
    189       &publicPortion->pubKey.keyLength);
     190      &key_length);
     191    publicPortion->pubKey.keyLength = key_length;
    190192    publicPortion->algorithmParms.algorithmID = TPM_ALG_RSA;
    191193    publicPortion->algorithmParms.encScheme = srk->encScheme;
    192194    publicPortion->algorithmParms.sigScheme = srk->sigScheme;
  • tpm/tpm_crypto.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_crypto.c tpm_emulator/tpm/tpm_crypto.c
    old new TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE 
    182182  TPM_KEY_DATA *cert, *key;
    183183  sha1_ctx_t sha1_ctx;
    184184  BYTE *buf, *p;
    185   UINT32 length;
     185  UINT32 length32;
     186  size_t length;
    186187  info("TPM_CertifyKey()");
    187188  /* get keys */
    188189  cert = tpm_get_key(certHandle);
    TPM_RESULT TPM_CertifyKey(TPM_KEY_HANDLE 
    264265  /* compute the digest of the CERTIFY_INFO[2] structure and sign it */
    265266  length = sizeof_TPM_CERTIFY_INFO((*certifyInfo));
    266267  p = buf = tpm_malloc(length);
     268  length32=(UINT32) length;
    267269  if (buf == NULL
    268       || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) {
     270      || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) {
    269271    free_TPM_KEY_PARMS(certifyInfo->algorithmParms);
    270272    return TPM_FAIL;
    271273  }
    272274  length = sizeof_TPM_CERTIFY_INFO((*certifyInfo));
    273275  sha1_init(&sha1_ctx);
    274   sha1_update(&sha1_ctx, buf, length);
     276  sha1_update(&sha1_ctx, buf, (size_t) length);
    275277  sha1_final(&sha1_ctx, buf);
    276278  res = tpm_sign(cert, auth1, FALSE, buf, SHA1_DIGEST_LENGTH, outData, outDataSize);
    277279  tpm_free(buf);
    TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL 
    292294  TPM_KEY_DATA *cert, *key;
    293295  sha1_ctx_t sha1_ctx;
    294296  BYTE *buf, *p;
    295   UINT32 length;
     297  size_t length;
     298  UINT32 length32;
    296299  info("TPM_CertifyKey2()");
    297300  /* get keys */
    298301  cert = tpm_get_key(certHandle);
    TPM_RESULT TPM_CertifyKey2(TPM_KEY_HANDL 
    362365  /* compute the digest of the CERTIFY_INFO[2] structure and sign it */
    363366  length = sizeof_TPM_CERTIFY_INFO((*certifyInfo));
    364367  p = buf = tpm_malloc(length);
     368  length32 = (UINT32) length;
    365369  if (buf == NULL
    366       || tpm_marshal_TPM_CERTIFY_INFO(&p, &length, certifyInfo)) {
     370      || tpm_marshal_TPM_CERTIFY_INFO(&p, &length32, certifyInfo)) {
    367371    free_TPM_KEY_PARMS(certifyInfo->algorithmParms);
    368372    return TPM_FAIL;
    369373  }
  • tpm/tpm_daa.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_daa.c tpm_emulator/tpm/tpm_daa.c
    old new TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl 
    716716          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    717717      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    718718          sizeof(session->DAA_tpmSpecific.DAA_count));
    719       sha1_update(&sha1, "\x00", 1);
     719      sha1_update(&sha1, (BYTE *) "\x00", 1);
    720720      sha1_final(&sha1, scratch);
    721721      sha1_init(&sha1);
    722722      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey,
    723723          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    724724      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    725725          sizeof(session->DAA_tpmSpecific.DAA_count));
    726       sha1_update(&sha1, "\x01", 1);
     726      sha1_update(&sha1, (BYTE *) "\x01", 1);
    727727      sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH);
    728728      mpz_init(f), mpz_init(q);
    729729      mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch);
    TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl 
    805805          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    806806      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    807807          sizeof(session->DAA_tpmSpecific.DAA_count));
    808       sha1_update(&sha1, "\x00", 1);
     808      sha1_update(&sha1, (BYTE *) "\x00", 1);
    809809      sha1_final(&sha1, scratch);
    810810      sha1_init(&sha1);
    811811      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey,
    812812          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    813813      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    814814          sizeof(session->DAA_tpmSpecific.DAA_count));
    815       sha1_update(&sha1, "\x01", 1);
     815      sha1_update(&sha1, (BYTE *) "\x01", 1);
    816816      sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH);
    817817      mpz_init(f), mpz_init(q);
    818818      mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch);
    TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl 
    14891489          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    14901490      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    14911491          sizeof(session->DAA_tpmSpecific.DAA_count));
    1492       sha1_update(&sha1, "\x00", 1);
     1492      sha1_update(&sha1, (BYTE *) "\x00", 1);
    14931493      sha1_final(&sha1, scratch);
    14941494      sha1_init(&sha1);
    14951495      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey,
    14961496          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    14971497      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    14981498          sizeof(session->DAA_tpmSpecific.DAA_count));
    1499       sha1_update(&sha1, "\x01", 1);
     1499      sha1_update(&sha1, (BYTE *) "\x01", 1);
    15001500      sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH);
    15011501      mpz_init(f), mpz_init(q);
    15021502      mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch);
    TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl 
    17121712          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    17131713      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    17141714          sizeof(session->DAA_tpmSpecific.DAA_count));
    1715       sha1_update(&sha1, "\x00", 1);
     1715      sha1_update(&sha1, (BYTE *) "\x00", 1);
    17161716      sha1_final(&sha1, scratch);
    17171717      sha1_init(&sha1);
    17181718      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey,
    17191719          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    17201720      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    17211721          sizeof(session->DAA_tpmSpecific.DAA_count));
    1722       sha1_update(&sha1, "\x01", 1);
     1722      sha1_update(&sha1, (BYTE *) "\x01", 1);
    17231723      sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH);
    17241724      mpz_init(f), mpz_init(q);
    17251725      mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch);
    TPM_RESULT TPM_DAA_Join(TPM_HANDLE handl 
    17931793          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    17941794      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    17951795          sizeof(session->DAA_tpmSpecific.DAA_count));
    1796       sha1_update(&sha1, "\x00", 1);
     1796      sha1_update(&sha1, (BYTE *) "\x00", 1);
    17971797      sha1_final(&sha1, scratch);
    17981798      sha1_init(&sha1);
    17991799      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey,
    18001800          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    18011801      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    18021802          sizeof(session->DAA_tpmSpecific.DAA_count));
    1803       sha1_update(&sha1, "\x01", 1);
     1803      sha1_update(&sha1, (BYTE *) "\x01", 1);
    18041804      sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH);
    18051805      mpz_init(f), mpz_init(q);
    18061806      mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch);
    TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl 
    29182918          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    29192919      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    29202920          sizeof(session->DAA_tpmSpecific.DAA_count));
    2921       sha1_update(&sha1, "\x00", 1);
     2921      sha1_update(&sha1, (BYTE *) "\x00", 1);
    29222922      sha1_final(&sha1, scratch);
    29232923      sha1_init(&sha1);
    29242924      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey,
    29252925          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    29262926      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    29272927          sizeof(session->DAA_tpmSpecific.DAA_count));
    2928       sha1_update(&sha1, "\x01", 1);
     2928      sha1_update(&sha1, (BYTE *) "\x01", 1);
    29292929      sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH);
    29302930      mpz_init(f), mpz_init(q);
    29312931      mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch);
    TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl 
    31433143        sha1_init(&sha1);
    31443144        sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest,
    31453145          sizeof(session->DAA_session.DAA_digest));
    3146         sha1_update(&sha1, "\x01", 1);
     3146        sha1_update(&sha1, (BYTE *) "\x01", 1);
    31473147        sha1_update(&sha1, inputData1, inputSize1);
    31483148        sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest);
    31493149      }
    TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl 
    31723172        sha1_init(&sha1);
    31733173        sha1_update(&sha1, (BYTE*) &session->DAA_session.DAA_digest,
    31743174          sizeof(session->DAA_session.DAA_digest));
    3175         sha1_update(&sha1, "\x00", 1);
     3175        sha1_update(&sha1, (BYTE*) "\x00", 1);
    31763176        rsa_export_modulus(&aikData->key, scratch, &size);
    31773177        sha1_update(&sha1, scratch, size);
    31783178        sha1_final(&sha1, (BYTE*) &session->DAA_session.DAA_digest);
    TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl 
    32293229          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    32303230      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    32313231          sizeof(session->DAA_tpmSpecific.DAA_count));
    3232       sha1_update(&sha1, "\x00", 1);
     3232      sha1_update(&sha1, (BYTE *) "\x00", 1);
    32333233      sha1_final(&sha1, scratch);
    32343234      sha1_init(&sha1);
    32353235      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey,
    32363236          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    32373237      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    32383238          sizeof(session->DAA_tpmSpecific.DAA_count));
    3239       sha1_update(&sha1, "\x01", 1);
     3239      sha1_update(&sha1, (BYTE *) "\x01", 1);
    32403240      sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH);
    32413241      mpz_init(f), mpz_init(q);
    32423242      mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch);
    TPM_RESULT TPM_DAA_Sign(TPM_HANDLE handl 
    33093309          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    33103310      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    33113311          sizeof(session->DAA_tpmSpecific.DAA_count));
    3312       sha1_update(&sha1, "\x00", 1);
     3312      sha1_update(&sha1, (BYTE *) "\x00", 1);
    33133313      sha1_final(&sha1, scratch);
    33143314      sha1_init(&sha1);
    33153315      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_rekey,
    33163316          sizeof(session->DAA_tpmSpecific.DAA_rekey));
    33173317      sha1_update(&sha1, (BYTE*) &session->DAA_tpmSpecific.DAA_count,
    33183318          sizeof(session->DAA_tpmSpecific.DAA_count));
    3319       sha1_update(&sha1, "\x01", 1);
     3319      sha1_update(&sha1, (BYTE *) "\x01", 1);
    33203320      sha1_final(&sha1, scratch + SHA1_DIGEST_LENGTH);
    33213321      mpz_init(f), mpz_init(q);
    33223322      mpz_import(f, 2 * SHA1_DIGEST_LENGTH, 1, 1, 0, 0, scratch);
  • tpm/tpm_data.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_data.c tpm_emulator/tpm/tpm_data.c
    old new static inline void init_pcr_attr(int pcr 
    4040void tpm_init_data(void)
    4141{
    4242  /* endorsement key */
     43#ifndef TPM_GENERATE_EK
    4344  uint8_t ek_n[] =  "\xa8\xdb\xa9\x42\xa8\xf3\xb8\x06\x85\x90\x76\x93\xad\xf7"
    4445    "\x74\xec\x3f\xd3\x3d\x9d\xe8\x2e\xff\x15\xed\x0e\xce\x5f\x93"
    4546    "\x92\xeb\xd1\x96\x2b\x72\x18\x81\x79\x12\x9d\x9c\x40\xd7\x1a"
    void tpm_init_data(void) 
    7778    "\xd1\xc0\x8b\x5b\xa2\x2e\xa7\x15\xca\x50\x75\x10\x48\x9c\x2b"
    7879    "\x18\xb9\x67\x8f\x5d\x64\xc3\x28\x9f\x2f\x16\x2f\x08\xda\x47"
    7980    "\xec\x86\x43\x0c\x80\x99\x07\x34\x0f";
     81#endif
     82
    8083  int i;
    8184  /* reset all data to NULL, FALSE or 0 */
    8285  memset(&tpmData, 0, sizeof(tpmData));
    void tpm_release_data(void) 
    152155
    153156#ifdef TPM_STORE_TO_FILE
    154157
    155 #include <linux/fs.h>
    156 #include <linux/unistd.h>
    157 #include <asm/uaccess.h>
     158#include <sys/types.h>
     159#include <sys/stat.h>
     160#include <fcntl.h>
     161#include <unistd.h>
    158162
    159163#define TPM_STORAGE_FILE "/var/tpm/tpm_emulator-1.2." STR(VERSION_MAJOR) "." STR(VERSION_MINOR)
    160164
    161165static int write_to_file(uint8_t *data, size_t data_length)
    162166{
    163167  int res;
    164   struct file *fp;
    165   mm_segment_t old_fs = get_fs();
    166   fp = filp_open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR);
    167   if (IS_ERR(fp)) return -1;
    168   set_fs(get_ds());
    169   res = fp->f_op->write(fp, data, data_length, &fp->f_pos);
    170   set_fs(old_fs);
    171   filp_close(fp, NULL);
     168  int fp;
     169  fp = open(TPM_STORAGE_FILE, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR);
     170  res = write(fp, data, data_length);
     171  close(fp);
    172172  return (res == data_length) ? 0 : -1;
    173173}
    174174
    175175static int read_from_file(uint8_t **data, size_t *data_length)
    176176{
    177177  int res;
    178   struct file *fp;
    179   mm_segment_t old_fs = get_fs();
    180   fp = filp_open(TPM_STORAGE_FILE, O_RDONLY, 0);
    181   if (IS_ERR(fp)) return -1;
    182   *data_length = (size_t)fp->f_dentry->d_inode->i_size;
    183   /* *data_length = i_size_read(fp->f_dentry->d_inode); */
     178  int fp, file_status;
     179  struct stat file_info;
     180  fp = open(TPM_STORAGE_FILE, O_RDONLY, 0);
     181  file_status = fstat(fp, &file_info);
     182  if (file_status < 0) {
     183    close(fp);
     184    return -1;
     185  }
     186
     187  *data_length = file_info.st_size;
    184188  *data = tpm_malloc(*data_length);
    185189  if (*data == NULL) {
    186     filp_close(fp, NULL);
     190    close(fp);
    187191    return -1;
    188192  }
    189   set_fs(get_ds());
    190   res = fp->f_op->read(fp, *data, *data_length, &fp->f_pos);
    191   set_fs(old_fs);
    192   filp_close(fp, NULL);
     193  res = read(fp, *data, *data_length);
     194  close(fp);
    193195  if (res != *data_length) {
    194196    tpm_free(*data);
    195197    return -1;
    static int read_from_file(uint8_t **data 
    216218int tpm_store_permanent_data(void)
    217219{
    218220  uint8_t *buf, *ptr;
    219   size_t buf_length, len;
     221  UINT32 buf_length, len;
    220222
    221223  /* marshal data */
    222   buf_length = len = sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags)
    223     + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags) + 2
    224     + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data);
     224  buf_length = len = 4 + sizeof_TPM_STCLEAR_FLAGS(tpmData.stclear.flags)
     225    + sizeof_TPM_PERMANENT_FLAGS(tpmData.permanent.flags)
     226    + sizeof_TPM_STANY_FLAGS(tpmData.stany.flags) + 2
     227    + sizeof_TPM_STCLEAR_DATA(tpmData.stclear.data)
     228    + sizeof_TPM_PERMANENT_DATA(tpmData.permanent.data)
     229    + sizeof_TPM_STANY_DATA(tpmData.stany.data);
    225230  buf = ptr = tpm_malloc(buf_length);
    226231  if (buf == NULL
    227232      || tpm_marshal_TPM_VERSION(&ptr, &len, &tpmData.permanent.data.version)
    228233      || tpm_marshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags)
    229234      || tpm_marshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags)
     235      || tpm_marshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags)
    230236      || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.selfTestSucceeded)
    231237      || tpm_marshal_BOOL(&ptr, &len, tpmData.permanent.flags.owned)
    232       || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) {
     238      || tpm_marshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data)
     239      || tpm_marshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)
     240      || tpm_marshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) {
    233241    tpm_free(buf);
    234242    return -1;
    235243  }
     244
    236245  if (write_to_file(buf, buf_length - len)) {
    237246    tpm_free(buf);
    238247    return -1;
    int tpm_store_permanent_data(void) 
    244253int tpm_restore_permanent_data(void)
    245254{
    246255  uint8_t *buf, *ptr;
    247   size_t buf_length, len;
     256  size_t buf_length;
     257  UINT32 len;
    248258  TPM_VERSION ver;
    249259
    250260  /* read data */
    251261  if (read_from_file(&buf, &buf_length)) return -1;
    252262  ptr = buf;
    253   len = buf_length;
     263  len = (uint32_t) buf_length;
    254264  /* unmarshal data */
    255265  if (tpm_unmarshal_TPM_VERSION(&ptr, &len, &ver)
    256266      || memcmp(&ver, &tpmData.permanent.data.version, sizeof(TPM_VERSION))
    257267      || tpm_unmarshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags)
    258268      || tpm_unmarshal_TPM_PERMANENT_FLAGS(&ptr, &len, &tpmData.permanent.flags)
     269      || tpm_unmarshal_TPM_STANY_FLAGS(&ptr, &len, &tpmData.stany.flags)
    259270      || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.selfTestSucceeded)
    260271      || tpm_unmarshal_BOOL(&ptr, &len, &tpmData.permanent.flags.owned)
    261       || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)) {
     272      || tpm_unmarshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data)
     273      || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data)
     274      || tpm_unmarshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) {
    262275    tpm_free(buf);
    263276    return -1;
    264277  }
     278
    265279  tpm_free(buf);
    266280  return 0;
    267281}
    268282
    269283int tpm_erase_permanent_data(void)
    270284{
    271   int res = write_to_file("", 0);
     285  int res = write_to_file((uint8_t *) "", 0);
    272286  return res;
    273287}
    274288
  • tpm/tpm_deprecated.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_deprecated.c tpm_emulator/tpm/tpm_deprecated.c
    old new  
    11/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
    22 * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
    33 *                    Swiss Federal Institute of Technology (ETH) Zurich
     4 * Copyright (C) 2005 INTEL Corp
    45 *
    56 * This module is free software; you can redistribute it and/or modify
    67 * it under the terms of the GNU General Public License as published
    TPM_RESULT TPM_SaveKeyContext(TPM_KEY_HA 
    5051  BYTE *ptr;
    5152  UINT32 len;
    5253  info("TPM_SaveKeyContext()");
    53   res = TPM_SaveContext(keyHandle, TPM_RT_KEY, "SaveKeyContext..",
     54  res = TPM_SaveContext(keyHandle, TPM_RT_KEY, (BYTE*)"SaveKeyContext..",
    5455                        keyContextSize, &contextBlob);
    5556  if (res != TPM_SUCCESS) return res;
    5657  len = *keyContextSize;
    TPM_RESULT TPM_SaveAuthContext(TPM_AUTHH 
    8283  BYTE *ptr;
    8384  UINT32 len;
    8485  info("TPM_SaveAuthContext()");
    85   res = TPM_SaveContext(authHandle, TPM_RT_KEY, "SaveAuthContext.",
     86  res = TPM_SaveContext(authHandle, TPM_RT_KEY, (BYTE*)"SaveAuthContext.",
    8687                        authContextSize, &contextBlob);
    8788  if (res != TPM_SUCCESS) return res;
    8889  len = *authContextSize;
  • tpm/tpm_emulator.h

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_emulator.h tpm_emulator/tpm/tpm_emulator.h
    old new  
    11/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
    22 * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
     3 * Copyright (C) 2005 INTEL Corp
    34 *
    45 * This module is free software; you can redistribute it and/or modify
    56 * it under the terms of the GNU General Public License as published
     
    2223/* TPM configuration */
    2324#define TPM_STORE_TO_FILE       1
    2425#undef  TPM_STRONG_PERSISTENCE
    25 #undef  TPM_GENERATE_EK
     26//#undef  TPM_GENERATE_EK
     27#define  TPM_GENERATE_EK
    2628#undef  TPM_GENERATE_SEED_DAA
    2729
    2830#define TPM_MANUFACTURER 0x4554485A /* 'ETHZ' */       
  • tpm/tpm_marshalling.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.c tpm_emulator/tpm/tpm_marshalling.c
    old new int tpm_unmarshal_TPM_STANY_FLAGS(BYTE * 
    13121312
    13131313int tpm_marshal_RSA(BYTE **ptr, UINT32 *length, rsa_private_key_t *v)
    13141314{
    1315   UINT32 m_len, e_len, q_len;
     1315  size_t m_len, e_len, q_len;
    13161316  if (*length < sizeof_RSA((*v))) return -1;
    13171317  if (v->size > 0) {
    13181318    rsa_export_modulus(v, &(*ptr)[6], &m_len);
    int tpm_unmarshal_TPM_PERMANENT_DATA(BYT 
    14601460  return 0;
    14611461}
    14621462
     1463int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v)
     1464{
     1465  if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
     1466    || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceKey)
     1467    || tpm_marshal_TPM_COUNT_ID(ptr, length, v->countID) ) return -1;
     1468
     1469  return 0;
     1470}
     1471
     1472int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v)
     1473{
     1474  if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
     1475    || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceKey)
     1476    || tpm_unmarshal_TPM_COUNT_ID(ptr, length, &v->countID) ) return -1;
     1477
     1478  return 0;
     1479}
     1480
     1481int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v)
     1482{
     1483  UINT32 i;
     1484  if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
     1485    || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceSession)
     1486    || tpm_marshal_TPM_DIGEST(ptr, length, &v->auditDigest)
     1487    || tpm_marshal_BOOL(ptr, length, v->auditSession)
     1488    || tpm_marshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks)
     1489    || tpm_marshal_UINT32(ptr, length, v->contextCount)
     1490    || tpm_marshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1;
     1491  for (i = 0; i < TPM_MAX_SESSIONS; i++) {
     1492    if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1;
     1493  }
     1494  for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) {
     1495    if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1;
     1496  }
     1497  if (tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transExclusive)) return -1;
     1498
     1499  return 0;
     1500}
     1501
     1502int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v)
     1503{
     1504  UINT32 i;
     1505  if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
     1506    || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceSession)
     1507    || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->auditDigest)
     1508    || tpm_unmarshal_BOOL(ptr, length, &v->auditSession)
     1509    || tpm_unmarshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks)
     1510    || tpm_unmarshal_UINT32(ptr, length, &v->contextCount)
     1511    || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1;
     1512  for (i = 0; i < TPM_MAX_SESSIONS; i++) {
     1513    if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1;
     1514  }
     1515  for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) {
     1516    if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1;
     1517  }
     1518  if (tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transExclusive)) return -1;
     1519
     1520  return 0;
     1521}
     1522
    14631523int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v)
    14641524{
    14651525  if (tpm_marshal_BYTE(ptr, length, v->type)
  • tpm/tpm_marshalling.h

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_marshalling.h tpm_emulator/tpm/tpm_marshalling.h
    old new int tpm_unmarshal_TPM_KEY_DATA(BYTE **pt 
    432432int tpm_marshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *);
    433433int tpm_unmarshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *);
    434434
     435int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v);
     436int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v);
     437
     438int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v);
     439int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v);
     440
    435441int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v);
    436442int tpm_unmarshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v);
    437443
  • tpm/tpm_owner.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_owner.c tpm_emulator/tpm/tpm_owner.c
    old new TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO 
    108108  TPM_RESULT res;
    109109  rsa_private_key_t *ek = &tpmData.permanent.data.endorsementKey;
    110110  TPM_KEY_DATA *srk = &tpmData.permanent.data.srk;
    111   UINT32 buf_size = ek->size >> 3;
     111  size_t buf_size = ek->size >> 3, key_length;
    112112  BYTE buf[buf_size];
    113113
    114114  info("TPM_TakeOwnership()");
    TPM_RESULT TPM_TakeOwnership(TPM_PROTOCO 
    173173    return TPM_FAIL;
    174174  }
    175175  rsa_export_modulus(&srk->key, srkPub->pubKey.key,
    176     &srkPub->pubKey.keyLength);
     176                     &key_length);
     177  srkPub->pubKey.keyLength = (UINT32) key_length;
    177178  /* setup tpmProof and set state to owned */
    178179  tpm_get_random_bytes(tpmData.permanent.data.tpmProof.nonce,
    179180    sizeof(tpmData.permanent.data.tpmProof.nonce));
  • tpm/tpm_startup.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_startup.c tpm_emulator/tpm/tpm_startup.c
    old new void TPM_Init(TPM_STARTUP_TYPE startupTy 
    4141TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE startupType)
    4242{
    4343  int i;
     44  int restore_fail;
    4445  info("TPM_Startup(%d)", startupType);
    4546  if (tpmData.stany.flags.postInitialise == FALSE) return TPM_INVALID_POSTINIT;
    46   /* reset STANY_FLAGS */
    47   SET_TO_ZERO(&tpmData.stany.flags);
    48   tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS;
    49   /* reset STANY_DATA (invalidates ALL sessions) */
    50   SET_TO_ZERO(&tpmData.stany.data);
    51   tpmData.stany.data.tag = TPM_TAG_STANY_DATA;
    52   /* init session-context nonce */
    53   SET_TO_RAND(&tpmData.stany.data.contextNonceSession);
     47
     48  /* try and restore state to get EK, SRK, etc */
     49  restore_fail = tpm_restore_permanent_data();
     50
    5451  /* set data and flags according to the given startup type */
    5552  if (startupType == TPM_ST_CLEAR) {
    56     /* if available, restore permanent data */
    57     tpm_restore_permanent_data();
     53    /* reset STANY_FLAGS */
     54    SET_TO_ZERO(&tpmData.stany.flags);
     55    tpmData.stany.flags.tag = TPM_TAG_STANY_FLAGS;
     56    /* reset STANY_DATA (invalidates ALL sessions) */
     57    SET_TO_ZERO(&tpmData.stany.data);
     58    tpmData.stany.data.tag = TPM_TAG_STANY_DATA;
     59    /* init session-context nonce */
     60    SET_TO_RAND(&tpmData.stany.data.contextNonceSession);
    5861    /* reset PCR values */
    5962    for (i = 0; i < TPM_NUM_PCR; i++) {
    60       if (tpmData.permanent.data.pcrAttrib[i].pcrReset)
    61         SET_TO_ZERO(tpmData.permanent.data.pcrValue[i].digest);
     63      if (!tpmData.permanent.data.pcrAttrib[i].pcrReset)
     64        SET_TO_ZERO(&tpmData.permanent.data.pcrValue[i].digest);
    6265      else
    63         SET_TO_0xFF(tpmData.permanent.data.pcrValue[i].digest);
     66        SET_TO_0xFF(&tpmData.permanent.data.pcrValue[i].digest);
    6467    }
    6568    /* reset STCLEAR_FLAGS */
    6669    SET_TO_ZERO(&tpmData.stclear.flags);
    TPM_RESULT TPM_Startup(TPM_STARTUP_TYPE  
    7982    /* init key-context nonce */
    8083    SET_TO_RAND(&tpmData.stclear.data.contextNonceKey);
    8184  } else if (startupType == TPM_ST_STATE) {
    82     if (tpm_restore_permanent_data()) {
     85    /* restore must have been successful for TPM_ST_STATE */
     86    if (restore_fail) {
    8387      error("restoring permanent data failed");
    8488      tpmData.permanent.data.testResult = "tpm_restore_permanent_data() failed";
    8589      tpmData.permanent.flags.selfTestSucceeded = FALSE;
  • tpm/tpm_storage.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_storage.c tpm_emulator/tpm/tpm_storage.c
    old new int encrypt_sealed_data(TPM_KEY_DATA *ke 
    5858                        BYTE *enc, UINT32 *enc_size)
    5959{
    6060  UINT32 len;
     61  size_t enc_size32 = *enc_size;
    6162  BYTE *buf, *ptr;
    6263  rsa_public_key_t pub_key;
    6364  int scheme;
    int encrypt_sealed_data(TPM_KEY_DATA *ke 
    7273  if (buf == NULL
    7374      || tpm_marshal_TPM_SEALED_DATA(&ptr, &len, seal)
    7475      || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_SEALED_DATA((*seal)),
    75                      enc, enc_size)) {
     76                     enc, &enc_size32)) {
    7677    tpm_free(buf);
    7778    rsa_release_public_key(&pub_key);
    7879    return -1;
    int encrypt_sealed_data(TPM_KEY_DATA *ke 
    8586int decrypt_sealed_data(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size,
    8687                        TPM_SEALED_DATA *seal, BYTE **buf)
    8788{
    88   UINT32 len;
     89  size_t len;
     90  UINT32 len32;
    8991  BYTE *ptr;
    9092  int scheme;
    9193  switch (key->encScheme) {
    int decrypt_sealed_data(TPM_KEY_DATA *ke 
    9698  len = enc_size;
    9799  *buf = ptr = tpm_malloc(len);
    98100  if (*buf == NULL
    99       || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len)
    100       || tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len, seal)) {
     101      || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ){
     102    tpm_free(*buf);
     103    return -1;
     104  }
     105  len32 = len;
     106  if (tpm_unmarshal_TPM_SEALED_DATA(&ptr, &len32, seal)) {
    101107    tpm_free(*buf);
    102108    return -1;
    103109  }
    TPM_RESULT TPM_Unseal(TPM_KEY_HANDLE par 
    240246
    241247TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE keyHandle, UINT32 inDataSize,
    242248                      BYTE *inData, TPM_AUTH *auth1,
    243                       UINT32 *outDataSize, BYTE **outData)
     249                      UINT32 *outDataSize32, BYTE **outData)
    244250{
    245251  TPM_RESULT res;
    246252  TPM_KEY_DATA *key;
    247253  int scheme;
     254  size_t outDataSize;
    248255 
    249256  info("TPM_UnBind()");
    250257  /* get key */
    TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key 
    262269  /* the size of the input data muss be greater than zero */
    263270  if (inDataSize == 0) return TPM_BAD_PARAMETER;
    264271  /* decrypt data */
    265   *outDataSize = inDataSize;
    266   *outData = tpm_malloc(*outDataSize);
     272  outDataSize = inDataSize;
     273  *outData = tpm_malloc(outDataSize);
    267274  if (*outData == NULL) return TPM_NOSPACE;
    268275  switch (key->encScheme) {
    269276    case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break;
    TPM_RESULT TPM_UnBind(TPM_KEY_HANDLE key 
    271278    default: tpm_free(*outData); return TPM_DECRYPT_ERROR;
    272279  }
    273280  if (rsa_decrypt(&key->key, scheme, inData, inDataSize,
    274       *outData, outDataSize)) {
     281      *outData, &outDataSize)) {
    275282    tpm_free(*outData);
    276283    return TPM_DECRYPT_ERROR;
    277284  }
    278285  /* verify data if it is of type TPM_BOUND_DATA */
    279286  if (key->encScheme == TPM_ES_RSAESOAEP_SHA1_MGF1
    280287      || key->keyUsage != TPM_KEY_LEGACY) {
    281     if (*outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) {
     288    if (outDataSize < 5 || memcmp(*outData, "\x01\x01\00\x00\x02", 5) != 0) {
    282289      tpm_free(*outData);
    283290      return TPM_DECRYPT_ERROR;
    284291    }
    285     *outDataSize -= 5;
    286     memmove(*outData, &(*outData)[5], *outDataSize);
     292    outDataSize -= 5;
     293    memmove(*outData, &(*outData)[5], outDataSize);
    287294  }
     295  *outDataSize32 = (UINT32) outDataSize;
    288296  return TPM_SUCCESS;
    289297}
    290298
    int compute_pubkey_digest(TPM_PUBKEY *ke 
    334342}
    335343
    336344int encrypt_private_key(TPM_KEY_DATA *key, TPM_STORE_ASYMKEY *store,
    337                         BYTE *enc, UINT32 *enc_size)
     345                        BYTE *enc, UINT32 *enc_size32)
    338346{
    339347  UINT32 len;
    340348  BYTE *buf, *ptr;
    341349  rsa_public_key_t pub_key;
    342350  int scheme;
     351  size_t enc_size;
    343352  switch (key->encScheme) {
    344353    case TPM_ES_RSAESOAEP_SHA1_MGF1: scheme = RSA_ES_OAEP_SHA1; break;
    345354    case TPM_ES_RSAESPKCSv15: scheme = RSA_ES_PKCSV15; break;
    int encrypt_private_key(TPM_KEY_DATA *ke 
    351360  if (buf == NULL
    352361      || tpm_marshal_TPM_STORE_ASYMKEY(&ptr, &len, store)
    353362      || rsa_encrypt(&pub_key, scheme, buf, sizeof_TPM_STORE_ASYMKEY((*store)),
    354                      enc, enc_size)) {
     363                     enc, &enc_size)) {
    355364    tpm_free(buf);
    356365    rsa_release_public_key(&pub_key);
    357366    return -1;
    358367  }
     368  *enc_size32 = (UINT32) enc_size;
    359369  tpm_free(buf);
    360370  rsa_release_public_key(&pub_key);
    361371  return 0;
    int encrypt_private_key(TPM_KEY_DATA *ke 
    364374int decrypt_private_key(TPM_KEY_DATA *key, BYTE *enc, UINT32 enc_size,
    365375                        TPM_STORE_ASYMKEY *store, BYTE **buf)
    366376{
    367   UINT32 len;
     377  UINT32 len32;
     378  size_t len;
    368379  BYTE *ptr;
    369380  int scheme;
    370381  switch (key->encScheme) {
    int decrypt_private_key(TPM_KEY_DATA *ke 
    375386  len = enc_size;
    376387  *buf = ptr = tpm_malloc(len);
    377388  if (*buf == NULL
    378       || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len)
    379       || tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len, store)) {
     389      || rsa_decrypt(&key->key, scheme, enc, enc_size, *buf, &len) ) {
     390    tpm_free(*buf);
     391    return -1;
     392  }
     393  len32 = (UINT32) len;
     394  if (tpm_unmarshal_TPM_STORE_ASYMKEY(&ptr, &len32, store)) { 
    380395    tpm_free(*buf);
    381396    return -1;
    382397  }
    TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN 
    394409  TPM_SESSION_DATA *session;
    395410  TPM_STORE_ASYMKEY store;
    396411  rsa_private_key_t rsa;
    397   UINT32 key_length;
     412  size_t key_length;
    398413
    399414  info("TPM_CreateWrapKey()");
    400415  /* get parent key */
    TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN 
    450465    }
    451466  }
    452467  /* generate key and store it */
    453   key_length = keyInfo->algorithmParms.parms.rsa.keyLength;
    454   if (rsa_generate_key(&rsa, key_length)) return TPM_FAIL;
    455   wrappedKey->pubKey.keyLength = key_length >> 3;
     468  if (rsa_generate_key(&rsa, keyInfo->algorithmParms.parms.rsa.keyLength))
     469    return TPM_FAIL;
     470  wrappedKey->pubKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 3;
    456471  wrappedKey->pubKey.key = tpm_malloc(wrappedKey->pubKey.keyLength);
    457   store.privKey.keyLength = key_length >> 4;
     472  store.privKey.keyLength = keyInfo->algorithmParms.parms.rsa.keyLength >> 4;
    458473  store.privKey.key = tpm_malloc(store.privKey.keyLength);
    459474  wrappedKey->encDataSize = parent->key.size >> 3;
    460475  wrappedKey->encData = tpm_malloc(wrappedKey->encDataSize);
    TPM_RESULT TPM_CreateWrapKey(TPM_KEY_HAN 
    466481    tpm_free(wrappedKey->encData);
    467482    return TPM_NOSPACE;
    468483  }
    469   rsa_export_modulus(&rsa, wrappedKey->pubKey.key,
    470     &wrappedKey->pubKey.keyLength);
    471   rsa_export_prime1(&rsa, store.privKey.key, &store.privKey.keyLength);
     484  rsa_export_modulus(&rsa, wrappedKey->pubKey.key,
     485                     &key_length);
     486  wrappedKey->pubKey.keyLength = (UINT32) key_length;
     487  rsa_export_prime1(&rsa, store.privKey.key, &key_length);
     488  store.privKey.keyLength = (UINT32) key_length;
    472489  rsa_release_private_key(&rsa);
    473490  /* compute the digest of the wrapped key (without encData) */
    474491  if (compute_key_digest(wrappedKey, &store.pubDataDigest)) {
    TPM_RESULT TPM_LoadKey2(TPM_KEY_HANDLE p 
    602619
    603620int tpm_setup_key_parms(TPM_KEY_DATA *key, TPM_KEY_PARMS *parms)
    604621{
     622  size_t key_length;
    605623  parms->algorithmID = TPM_ALG_RSA;
    606624  parms->encScheme = key->encScheme;
    607625  parms->sigScheme = key->sigScheme;
    int tpm_setup_key_parms(TPM_KEY_DATA *ke 
    611629  parms->parms.rsa.exponent = tpm_malloc(parms->parms.rsa.exponentSize);
    612630  if (parms->parms.rsa.exponent == NULL) return -1;
    613631  rsa_export_exponent(&key->key, parms->parms.rsa.exponent,
    614     &parms->parms.rsa.exponentSize);
     632    &key_length);
     633  parms->parms.rsa.exponentSize = (UINT32) key_length;
    615634  parms->parmSize = 12 + parms->parms.rsa.exponentSize;
    616635  return 0;
    617636}
    TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE  
    622641  TPM_RESULT res;
    623642  TPM_KEY_DATA *key;
    624643  TPM_DIGEST digest;
     644  size_t key_length;
    625645  info("TPM_GetPubKey()");
    626646  /* get key */
    627647  if (keyHandle == TPM_KH_SRK
    TPM_RESULT TPM_GetPubKey(TPM_KEY_HANDLE  
    650670  pubKey->pubKey.keyLength = key->key.size >> 3;
    651671  pubKey->pubKey.key = tpm_malloc(pubKey->pubKey.keyLength);
    652672  if (pubKey->pubKey.key == NULL) return TPM_NOSPACE;
    653   rsa_export_modulus(&key->key, pubKey->pubKey.key,
    654     &pubKey->pubKey.keyLength);
     673  rsa_export_modulus(&key->key, pubKey->pubKey.key, &key_length);
     674  pubKey->pubKey.keyLength = (UINT32) key_length;
    655675  if (tpm_setup_key_parms(key, &pubKey->algorithmParms) != 0) {
    656676    error("TPM_GetPubKey(): tpm_setup_key_parms() failed.");
    657677    tpm_free(pubKey->pubKey.key);
  • tpm/tpm_structures.h

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_structures.h tpm_emulator/tpm/tpm_structures.h
    old new typedef struct tdTPM_DAA_ISSUER { 
    19581958  TPM_DIGEST DAA_digest_gamma;
    19591959  BYTE DAA_generic_q[26];
    19601960} TPM_DAA_ISSUER;
     1961#define sizeof_TPM_DAA_ISSUER(s) (2 + (20 * 6) + 26 )
    19611962
    19621963/*
    19631964 * TPM_DAA_TPM ([TPM_Part2], Section 22.4)
    typedef struct tdTPM_DAA_TPM { 
    19731974  TPM_DIGEST DAA_rekey;
    19741975  UINT32 DAA_count;
    19751976} TPM_DAA_TPM;
     1977#define sizeof_TPM_DAA_TPM(s) (2 + (4 * 20) + 4)
    19761978
    19771979/*
    19781980 * TPM_DAA_CONTEXT ([TPM_Part2], Section 22.5)
    typedef struct tdTPM_DAA_CONTEXT { 
    19871989  BYTE DAA_scratch[256];
    19881990  BYTE DAA_stage;
    19891991} TPM_DAA_CONTEXT;
     1992#define sizeof_TPM_DAA_CONTEXT(s) (2 + (3 * 20) + 256 + 1)
    19901993
    19911994/*
    19921995 * TPM_DAA_JOINDATA ([TPM_Part2], Section 22.6)
    typedef struct tdTPM_DAA_JOINDATA { 
    19982001  BYTE DAA_join_u1[138];
    19992002  TPM_DIGEST DAA_digest_n0;
    20002003} TPM_DAA_JOINDATA;
     2004#define sizeof_TPM_DAA_JOINDATA(s) (1 + 1 + 20)
    20012005
    20022006/*
    20032007 * TPM_DAA_BLOB ([TPM_Part2], Section 22.8)
    typedef struct tdTPM_STCLEAR_DATA { 
    22022206  //UINT32 ownerReference;
    22032207  //BOOL disableResetLock;
    22042208} TPM_STCLEAR_DATA;
     2209#define sizeof_TPM_STCLEAR_DATA(s) (2 + 20 + 4)
    22052210
    22062211/*
    22072212 * TPM_SESSION_DATA
    typedef struct tdTPM_DAA_SESSION_DATA { 
    22382243  TPM_DAA_JOINDATA DAA_joinSession;
    22392244  TPM_HANDLE handle;
    22402245} TPM_DAA_SESSION_DATA;
     2246#define sizeof_TPM_DAA_SESSION_DATA(s) ( 1 \
     2247  + sizeof_TPM_DAA_ISSUER(s.DAA_issuerSettings) \
     2248  + sizeof_TPM_DAA_TPM(s.DAA_tpmSpecific) \
     2249  + sizeof_TPM_DAA_CONTEXT(s.DAA_session) \
     2250  + sizeof_TPM_DAA_JOINDATA(s.DAA_joinSession) + 4)
    22412251
    22422252/*
    22432253 * TPM_STANY_DATA ([TPM_Part2], Section 7.6)
    typedef struct tdTPM_STANY_DATA { 
    22622272  TPM_DAAHANDLE currentDAA;
    22632273  TPM_TRANSHANDLE transExclusive;
    22642274} TPM_STANY_DATA;
     2275#define sizeof_TPM_STANY_DATA(s) (2 + 20 + 20 + 1 \
     2276  + sizeof_TPM_CURRENT_TICKS(s.currentTicks) \
     2277  + 4 + (4 * TPM_MAX_SESSION_LIST) \
     2278  + (sizeof_TPM_SESSION_DATA(s.sessions[0]) * TPM_MAX_SESSION_LIST) \
     2279  + (sizeof_TPM_DAA_SESSION_DATA(s.sessionsDAA[0]) * TPM_MAX_SESSIONS_DAA) + 4)
    22652280
    22662281/*
    22672282 * TPM_DATA
  • tpm/tpm_testing.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_testing.c tpm_emulator/tpm/tpm_testing.c
    old new  
    11/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
    22 * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
    33 *                    Swiss Federal Institute of Technology (ETH) Zurich
     4 * Copyright (C) 2005 INTEL Corp
    45 *
    56 * This module is free software; you can redistribute it and/or modify
    67 * it under the terms of the GNU General Public License as published
    static int tpm_test_sha1(void) 
    9596  struct {
    9697    uint8_t *data; uint32_t repetitions; uint8_t *digest;
    9798  } test_cases[] =  {{
    98     "abc", 1,
    99     "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D"
     99        (uint8_t*)"abc", 1,
     100    (uint8_t*)"\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2\x6C\x9C\xD0\xD8\x9D"
    100101  }, {
    101     "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1,
    102     "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1"
     102    (uint8_t*)"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1,
     103    (uint8_t*)"\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29\xE5\xE5\x46\x70\xF1"
    103104  }, {
    104     "a", 1000000,
    105     "\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F"
     105    (uint8_t*)"a", 1000000,
     106    (uint8_t*)"\x34\xAA\x97\x3C\xD4\xC4\xDA\xA4\xF6\x1E\xEB\x2B\xDB\xAD\x27\x31\x65\x34\x01\x6F"
    106107  }, {
    107     "0123456701234567012345670123456701234567012345670123456701234567", 10,
    108     "\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52"
     108    (uint8_t*)"0123456701234567012345670123456701234567012345670123456701234567", 10,
     109    (uint8_t*)"\xDE\xA3\x56\xA2\xCD\xDD\x90\xC7\xA7\xEC\xED\xC5\xEB\xB5\x63\x93\x4F\x46\x04\x52"
    109110  }};
    110111
    111112  debug("tpm_test_sha1()");
    112113  for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) {
    113114    sha1_init(&ctx);
    114115    for (j = 0; j < test_cases[i].repetitions; j++)
    115       sha1_update(&ctx, test_cases[i].data, strlen(test_cases[i].data));
     116      sha1_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data));
    116117    sha1_final(&ctx, digest);
    117118    if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1;
    118119  }
    static int tpm_test_hmac(void) 
    128129  struct {
    129130    uint8_t *key, key_len, *data, data_len, *digest;
    130131  } test_cases[] = {{
    131     "\x0b", 20, "Hi There", 8,
    132     "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00"
     132    (uint8_t*)"\x0b", 20, (uint8_t*)"Hi There", 8,
     133    (uint8_t*)"\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00"
    133134  }, {
    134     "Jefe", 4, "what do ya want for nothing?", 28,
    135     "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79"
     135    (uint8_t*)"Jefe", 4, (uint8_t*)"what do ya want for nothing?", 28,
     136    (uint8_t*)"\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79"
    136137  }, {
    137     "\xaa", 20, "\xdd", 50,
    138     "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3"
     138    (uint8_t*)"\xaa", 20, (uint8_t*)"\xdd", 50,
     139    (uint8_t*)"\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3"
    139140  }, {
    140     "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14"
    141     "\x15\x16\x17\x18\x19", 25, "\xcd", 50,
    142     "\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda"
     141    (uint8_t*)"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14"
     142    "\x15\x16\x17\x18\x19", 25, (uint8_t*)"\xcd", 50,
     143    (uint8_t*)"\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda"
    143144  }, {
    144     "\x0c", 20, "Test With Truncation", 20,
    145     "\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04"
     145    (uint8_t*)"\x0c", 20, (uint8_t*)"Test With Truncation", 20,
     146    (uint8_t*)"\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04"
    146147  }, {
    147     "\xaa", 80, "Test Using Larger Than Block-Size Key - Hash Key First", 54,
    148     "\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12"
     148    (uint8_t*)"\xaa", 80, (uint8_t*)"Test Using Larger Than Block-Size Key - Hash Key First", 54,
     149    (uint8_t*)"\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12"
    149150  }, {
    150     "\xaa", 80,
    151     "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73,
    152     "\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91"
     151    (uint8_t*)"\xaa", 80,
     152    (uint8_t*)"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data", 73,
     153    (uint8_t*)"\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91"
    153154  }};
    154155
    155156  debug("tpm_test_hmac()");
    156157  for (i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); i++) {
    157     if (strlen(test_cases[i].key) < test_cases[i].key_len) {
     158    if (strlen((char*)test_cases[i].key) < test_cases[i].key_len) {
    158159      uint8_t key[test_cases[i].key_len];
    159160      memset(key, test_cases[i].key[0], test_cases[i].key_len);
    160161      hmac_init(&ctx, key, test_cases[i].key_len);
    161162    } else {
    162163      hmac_init(&ctx, test_cases[i].key, test_cases[i].key_len);
    163164    }
    164     for (j = 0; j < test_cases[i].data_len; j += strlen(test_cases[i].data)) {
    165       hmac_update(&ctx, test_cases[i].data, strlen(test_cases[i].data));
     165    for (j = 0; j < test_cases[i].data_len; j += strlen((char*)test_cases[i].data)) {
     166      hmac_update(&ctx, test_cases[i].data, strlen((char*)test_cases[i].data));
    166167    }
    167168    hmac_final(&ctx, digest);
    168169    if (memcmp(digest, test_cases[i].digest, SHA1_DIGEST_LENGTH) != 0) return -1;
    static int tpm_test_hmac(void) 
    173174static int tpm_test_rsa_EK(void)
    174175{
    175176  int res = 0;
    176   char *data = "RSA PKCS #1 v1.5 Test-String";
     177  uint8_t *data = (uint8_t*)"RSA PKCS #1 v1.5 Test-String";
    177178  uint8_t buf[256];
    178   size_t buf_len, data_len = strlen(data);
     179  size_t buf_len, data_len = strlen((char*)data);
    179180  rsa_private_key_t priv_key;
    180181  rsa_public_key_t pub_key;
    181182
  • tpm/tpm_ticks.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_ticks.c tpm_emulator/tpm/tpm_ticks.c
    old new  
    11/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
    22 * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
    33 *                    Swiss Federal Institute of Technology (ETH) Zurich
     4 * Copyright (C) 2005 INTEL Corp
    45 *
    56 * This module is free software; you can redistribute it and/or modify
    67 * it under the terms of the GNU General Public License as published
    TPM_RESULT TPM_SetTickType(TPM_TICKTYPE  
    3940TPM_RESULT TPM_GetTicks(TPM_CURRENT_TICKS *currentTime)
    4041{
    4142  info("TPM_GetTicks()");
    42   memcpy(currentTime, &tpmData.stany.data.currentTicks,
    43     sizeof(TPM_CURRENT_TICKS));
    44   return TPM_SUCCESS;
     43  return TPM_DISABLED_CMD;
    4544}
    4645
    4746TPM_RESULT TPM_TickStampBlob(TPM_KEY_HANDLE keyHandle, TPM_NONCE *antiReplay,
    TPM_RESULT TPM_TickStampBlob(TPM_KEY_HAN 
    4948                             TPM_CURRENT_TICKS *currentTicks,
    5049                             UINT32 *sigSize, BYTE **sig)
    5150{
    52   TPM_RESULT res;
    53   TPM_KEY_DATA *key;
    54   BYTE *info, *p;
    55   UINT32 info_length, length;
    5651  info("TPM_TickStampBlob()");
    57   /* get key */
    58   key = tpm_get_key(keyHandle);
    59   if (key == NULL) return TPM_INVALID_KEYHANDLE;
    60   /* verify authorization */
    61   res = tpm_verify_auth(auth1, key->usageAuth, keyHandle);
    62   if (res != TPM_SUCCESS) return res;
    63   if (key->keyUsage != TPM_KEY_SIGNING && key->keyUsage != TPM_KEY_LEGACY
    64       && key->keyUsage != TPM_KEY_IDENTITY) return TPM_INVALID_KEYUSAGE;
    65   /* get current ticks */
    66   TPM_GetTicks(currentTicks);
    67   /* sign data using signature scheme PKCS1_SHA1 and TPM_SIGN_INFO container */
    68   *sigSize = key->key.size >> 3;
    69   *sig = tpm_malloc(*sigSize);
    70   if (*sig == NULL) return TPM_FAIL;
    71   /* setup TPM_SIGN_INFO structure */
    72   info_length = 30 + sizeof(TPM_DIGEST) + sizeof_TPM_CURRENT_TICKS(currentTicks);
    73   info = tpm_malloc(info_length);
    74   if (info == NULL) {
    75     tpm_free(*sig);
    76     return TPM_FAIL;
    77   }
    78   memcpy(&info[0], "\x05\x00TSTP", 6);
    79   memcpy(&info[6], antiReplay->nonce, 20);
    80   *(UINT32*)&info[26] = CPU_TO_BE32(20
    81                         + sizeof_TPM_CURRENT_TICKS(currentTicks));
    82   memcpy(&info[30], digestToStamp->digest, sizeof(TPM_DIGEST));
    83   p = &info[30 + sizeof(TPM_DIGEST)];
    84   length = sizeof_TPM_CURRENT_TICKS(currentTicks);
    85   if (tpm_marshal_TPM_CURRENT_TICKS(&p, &length, currentTicks)
    86       || rsa_sign(&key->key, RSA_SSA_PKCS1_SHA1, info, info_length, *sig)) {   
    87     tpm_free(*sig);
    88     tpm_free(info);
    89     return TPM_FAIL;
    90   }
    91   return TPM_SUCCESS;
     52  return TPM_DISABLED_CMD;
    9253}
    9354
    9455void tpm_update_ticks(void)
    9556{
    96   if (tpmData.stany.data.currentTicks.tag == 0) {
    97     tpmData.stany.data.currentTicks.tag = TPM_TAG_CURRENT_TICKS;
    98     tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks();
    99 /* removed since v1.2 rev 94
    100     tpmData.stany.data.currentTicks.tickType = tpmData.permanent.data.tickType;
    101 */
    102     tpm_get_random_bytes(tpmData.stany.data.currentTicks.tickNonce.nonce,
    103       sizeof(TPM_NONCE));
    104     tpmData.stany.data.currentTicks.tickRate = 1;
    105 /* removed since v1.2 rev 94
    106     tpmData.stany.data.currentTicks.tickSecurity = TICK_SEC_NO_CHECK;
    107 */
    108   } else {
    109     tpmData.stany.data.currentTicks.currentTicks += tpm_get_ticks();   
    110   }
    11157}
    11258
  • tpm/tpm_transport.c

    diff -uprN orig/tpm_emulator-0.4/tpm/tpm_transport.c tpm_emulator/tpm/tpm_transport.c
    old new static void decrypt_wrapped_command(BYTE 
    189189    sha1_init(&sha1);
    190190    sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce));
    191191    sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce));
    192     sha1_update(&sha1, "in", 2);
     192    sha1_update(&sha1, (BYTE*)"in", 2);
    193193    sha1_update(&sha1, secret, sizeof(TPM_SECRET));
    194194    j = CPU_TO_BE32(i);
    195195    sha1_update(&sha1, (BYTE*)&j, 4);
    static void encrypt_wrapped_command(BYTE 
    211211    sha1_init(&sha1);
    212212    sha1_update(&sha1, auth->nonceEven.nonce, sizeof(auth->nonceEven.nonce));
    213213    sha1_update(&sha1, auth->nonceOdd.nonce, sizeof(auth->nonceOdd.nonce));
    214     sha1_update(&sha1, "out", 3);
     214    sha1_update(&sha1, (BYTE*)"out", 3);
    215215    sha1_update(&sha1, secret, sizeof(TPM_SECRET));
    216216    j = CPU_TO_BE32(i);
    217217    sha1_update(&sha1, (BYTE*)&j, 4);
  • tpmd.c

    diff -uprN orig/tpm_emulator-0.4/tpmd.c tpm_emulator/tpmd.c
    old new  
     1/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
     2 * Copyright (C) 2005 INTEL Corp
     3 *
     4 * This module is free software; you can redistribute it and/or modify
     5 * it under the terms of the GNU General Public License as published
     6 * by the Free Software Foundation; either version 2 of the License,
     7 * or (at your option) any later version.
     8 *
     9 * This module is distributed in the hope that it will be useful,
     10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
     11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     12 * GNU General Public License for more details.
     13 *
     14 */
     15
     16#include <stdio.h>
     17#include <stdlib.h>
     18#include <unistd.h>
     19#include <string.h>
     20#include <sys/types.h>
     21#include <sys/stat.h>
     22#include <fcntl.h>
     23#include <sys/time.h>
     24
     25#include "tpm_emulator.h"
     26
     27#define TPM_RX_FNAME "/var/tpm/tpm_in.fifo"
     28#define TPM_TX_FNAME "/var/tpm/tpm_out.fifo"
     29
     30#define BUFFER_SIZE 2048
     31
     32static int devurandom=0;
     33         
     34void get_random_bytes(void *buf, int nbytes) {
     35 
     36  if (devurandom == 0) {
     37    devurandom = open("/dev/urandom", O_RDONLY);
     38  }
     39
     40  if (read(devurandom, buf, nbytes) != nbytes) {
     41      printf("Can't get random number.\n");
     42      exit(-1);
     43  }
     44}
     45
     46uint64_t tpm_get_ticks(void)
     47{
     48  //struct timeval tv;
     49  //int gettimeofday(&tv, struct timezone *tz);
     50  return 0;
     51}
     52
     53int main(int argc, char **argv)
     54{
     55  uint8_t in[BUFFER_SIZE], *out;
     56  uint32_t out_size;
     57  int in_size, written;
     58  int i;
     59  struct stat file_info;
     60
     61  int tpm_tx_fh=-1, tpm_rx_fh=-1;
     62  if (argc < 2) {
     63    printf("Usage: tpmd clear|save|deactivated\n" );
     64          return -1;
     65  }
     66
     67  /* initialize TPM emulator */
     68  if (!strcmp(argv[1], "clear")) {
     69    printf("Initializing tpm: %s\n", argv[1]);
     70    tpm_emulator_init(1);
     71  } else if (!strcmp(argv[1], "save")) {
     72    printf("Initializing tpm: %s\n", argv[1]);
     73    tpm_emulator_init(2);
     74  } else if (!strcmp(argv[1], "deactivated")) {
     75    printf("Initializing tpm: %s\n", argv[1]);
     76    tpm_emulator_init(3);
     77  } else {
     78    printf("invalid startup mode '%s'; must be 'clear', "
     79      "'save' (default) or 'deactivated", argv[1]);
     80    return -1;
     81  }
     82
     83  if ( stat(TPM_RX_FNAME, &file_info) == -1) {
     84    if ( mkfifo(TPM_RX_FNAME, S_IWUSR | S_IRUSR ) ) {
     85      printf("Failed to create fifo %s.\n", TPM_RX_FNAME);
     86      return -1;
     87    }
     88  }
     89
     90  if ( stat(TPM_TX_FNAME, &file_info) == -1) {
     91    if ( mkfifo(TPM_TX_FNAME, S_IWUSR | S_IRUSR ) ) {
     92      printf("Failed to create fifo %s.\n", TPM_TX_FNAME);
     93      return -1;
     94    }
     95  }
     96
     97  while (1) {
     98abort_command:
     99    if (tpm_rx_fh < 0) {
     100      tpm_rx_fh = open(TPM_RX_FNAME, O_RDONLY);
     101    }
     102   
     103    if (tpm_rx_fh < 0) {
     104      printf("ERROR: failed to open devices to listen to guest.\n");
     105      return -1;
     106    }
     107   
     108    if (tpm_tx_fh < 0) {
     109      tpm_tx_fh = open(TPM_TX_FNAME, O_WRONLY);
     110    }
     111
     112    if (tpm_tx_fh < 0) {
     113      printf("ERROR: failed to open devices to respond to guest.\n");
     114      return -1;
     115    }
     116
     117    in_size = read(tpm_rx_fh, in, BUFFER_SIZE);
     118    if (in_size < 6) { // Magic size of minium TPM command
     119      printf("Recv[%d] to small: 0x", in_size);
     120      if (in_size <= 0) {
     121          close(tpm_rx_fh);
     122          tpm_rx_fh = -1;
     123          goto abort_command;
     124      }
     125    } else {
     126      printf("Recv[%d]: 0x", in_size);
     127      for (i=0; i< in_size; i++)
     128        printf("%x ", in[i]);
     129      printf("\n");
     130    }
     131
     132   
     133    if (tpm_handle_command(in, in_size, &out, &out_size) != 0) {
     134        printf("ERROR: Handler Failed.\n");
     135    }
     136
     137    written = write(tpm_tx_fh, out, out_size);
     138
     139    if (written != out_size ) {
     140      printf("ERROR: Part of response not written %d/%d.\nAttempt: ", written, out_size);
     141    } else {
     142      printf("Sent[%Zu]: ", out_size);
     143    }
     144    for (i=0; i< out_size; i++)
     145      printf("%x ", out[i]);
     146    printf("\n");
     147    tpm_free(out);
     148
     149  } // loop
     150
     151  tpm_emulator_shutdown();
     152
     153  close(tpm_tx_fh);
     154  close(tpm_rx_fh);
     155
     156}
  • tpm_version.h

    Binary files orig/tpm_emulator-0.4/tpm_emulator and tpm_emulator/tpm_emulator differ
    diff -uprN orig/tpm_emulator-0.4/tpm_version.h tpm_emulator/tpm_version.h
    old new  
    22#define _TPM_VERSION_H_
    33#define VERSION_MAJOR 0
    44#define VERSION_MINOR 4
    5 #define VERSION_BUILD 1151058734
     5#define VERSION_BUILD 1153776940
    66#endif /* _TPM_VERSION_H_ */
Note: See TracBrowser for help on using the repository browser.