1
2/*
3 * Licensed Materials - Property of IBM
4 *
5 * trousers - An open source TCG Software Stack
6 *
7 * (C) Copyright International Business Machines Corp. 2004-2006
8 *
9 */
10
11
12#include <stdlib.h>
13#include <stdio.h>
14#include <string.h>
15#include <unistd.h>
16#include <sys/types.h>
17#include <sys/mman.h>
18#include <errno.h>
19
20#include "trousers/tss.h"
21#include "trousers/trousers.h"
22#include "trousers_types.h"
23#include "trousers_types.h"
24#include "spi_utils.h"
25#include "capabilities.h"
26#include "tsplog.h"
27#include "obj.h"
28
29
30TSS_RESULT
31internal_GetCap(TSS_HCONTEXT tspContext, TSS_FLAG capArea, UINT32 subCap,
32		UINT32 * respSize, BYTE ** respData)
33{
34	UINT64 offset = 0;
35	TSS_VERSION v = INTERNAL_CAP_VERSION;
36	TSS_BOOL bValue = FALSE;
37	UINT32 u32value = 0;
38
39	switch (capArea) {
40	case TSS_TSPCAP_VERSION:
41		if ((*respData = calloc_tspi(tspContext, sizeof(TSS_VERSION))) == NULL) {
42			LogError("malloc of %zd bytes failed", sizeof(TSS_VERSION));
43			return TSPERR(TSS_E_OUTOFMEMORY);
44		}
45
46		Trspi_LoadBlob_TSS_VERSION(&offset, *respData, v);
47		*respSize = offset;
48		break;
49	case TSS_TSPCAP_ALG:
50		switch (subCap) {
51		case TSS_ALG_RSA:
52			*respSize = sizeof(TSS_BOOL);
53			bValue = INTERNAL_CAP_TSP_ALG_RSA;
54			break;
55		case TSS_ALG_AES:
56			*respSize = sizeof(TSS_BOOL);
57			bValue = INTERNAL_CAP_TSP_ALG_AES;
58			break;
59		case TSS_ALG_SHA:
60			*respSize = sizeof(TSS_BOOL);
61			bValue = INTERNAL_CAP_TSP_ALG_SHA;
62			break;
63		case TSS_ALG_HMAC:
64			*respSize = sizeof(TSS_BOOL);
65			bValue = INTERNAL_CAP_TSP_ALG_HMAC;
66			break;
67		case TSS_ALG_DES:
68			*respSize = sizeof(TSS_BOOL);
69			bValue = INTERNAL_CAP_TSP_ALG_DES;
70			break;
71		case TSS_ALG_3DES:
72			*respSize = sizeof(TSS_BOOL);
73			bValue = INTERNAL_CAP_TSP_ALG_3DES;
74			break;
75		case TSS_ALG_DEFAULT:
76			*respSize = sizeof(UINT32);
77			u32value = INTERNAL_CAP_TSP_ALG_DEFAULT;
78			break;
79		case TSS_ALG_DEFAULT_SIZE:
80			*respSize = sizeof(UINT32);
81			u32value = INTERNAL_CAP_TSP_ALG_DEFAULT_SIZE;
82			break;
83		default:
84			LogError("Unknown TSP subCap: %u", subCap);
85			return TSPERR(TSS_E_BAD_PARAMETER);
86		}
87
88		if ((*respData = calloc_tspi(tspContext, *respSize)) == NULL) {
89			LogError("malloc of %u bytes failed", *respSize);
90			return TSPERR(TSS_E_OUTOFMEMORY);
91		}
92
93		if (*respSize == sizeof(TSS_BOOL))
94			*(TSS_BOOL *)respData = bValue;
95		else
96			*(UINT32 *)respData = u32value;
97		break;
98	case TSS_TSPCAP_PERSSTORAGE:
99		if ((*respData = calloc_tspi(tspContext, sizeof(TSS_BOOL))) == NULL) {
100			LogError("malloc of %zd bytes failed", sizeof(TSS_BOOL));
101			return TSPERR(TSS_E_OUTOFMEMORY);
102		}
103
104		*respSize = sizeof(TSS_BOOL);
105		(*respData)[0] = INTERNAL_CAP_TSP_PERSSTORAGE;
106		break;
107	case TSS_TSPCAP_RETURNVALUE_INFO:
108		if (subCap != TSS_TSPCAP_PROP_RETURNVALUE_INFO)
109			return TSPERR(TSS_E_BAD_PARAMETER);
110
111		if ((*respData = calloc_tspi(tspContext, sizeof(UINT32))) == NULL) {
112			LogError("malloc of %zd bytes failed", sizeof(UINT32));
113			return TSPERR(TSS_E_OUTOFMEMORY);
114		}
115
116		*respSize = sizeof(UINT32);
117		*(UINT32 *)(*respData) = INTERNAL_CAP_TSP_RETURNVALUE_INFO;
118		break;
119	case TSS_TSPCAP_PLATFORM_INFO:
120		switch (subCap) {
121		case TSS_TSPCAP_PLATFORM_TYPE:
122			if ((*respData = calloc_tspi(tspContext, sizeof(UINT32))) == NULL) {
123				LogError("malloc of %zd bytes failed", sizeof(UINT32));
124				return TSPERR(TSS_E_OUTOFMEMORY);
125			}
126
127			*respSize = sizeof(UINT32);
128			*(UINT32 *)(*respData) = INTERNAL_CAP_TSP_PLATFORM_TYPE;
129			break;
130		case TSS_TSPCAP_PLATFORM_VERSION:
131			if ((*respData = calloc_tspi(tspContext, sizeof(UINT32))) == NULL) {
132				LogError("malloc of %zd bytes failed", sizeof(UINT32));
133				return TSPERR(TSS_E_OUTOFMEMORY);
134			}
135
136			*respSize = sizeof(UINT32);
137			*(UINT32 *)(*respData) = INTERNAL_CAP_TSP_PLATFORM_VERSION;
138			break;
139		default:
140			return TSPERR(TSS_E_BAD_PARAMETER);
141		}
142		break;
143	case TSS_TSPCAP_MANUFACTURER:
144		switch (subCap) {
145		case TSS_TSPCAP_PROP_MANUFACTURER_ID:
146			if ((*respData = calloc_tspi(tspContext, sizeof(UINT32))) == NULL) {
147				LogError("malloc of %zd bytes failed", sizeof(UINT32));
148				return TSPERR(TSS_E_OUTOFMEMORY);
149			}
150
151			*respSize = sizeof(UINT32);
152			*(UINT32 *)(*respData) = INTERNAL_CAP_MANUFACTURER_ID;
153			break;
154		case TSS_TSPCAP_PROP_MANUFACTURER_STR:
155		{
156			BYTE str[] = INTERNAL_CAP_MANUFACTURER_STR;
157
158			if ((*respData = calloc_tspi(tspContext,
159						     INTERNAL_CAP_MANUFACTURER_STR_LEN)) == NULL) {
160				LogError("malloc of %d bytes failed",
161					 INTERNAL_CAP_MANUFACTURER_STR_LEN);
162				return TSPERR(TSS_E_OUTOFMEMORY);
163			}
164
165			*respSize = INTERNAL_CAP_MANUFACTURER_STR_LEN;
166			memcpy(*respData, str, INTERNAL_CAP_MANUFACTURER_STR_LEN);
167			break;
168		}
169		default:
170			return TSPERR(TSS_E_BAD_PARAMETER);
171		}
172		break;
173	default:
174		return TSPERR(TSS_E_BAD_PARAMETER);
175	}
176
177	return TSS_SUCCESS;
178}
179