* see section 4.2.8.1 of TCG TNC IF-IMC Specification 1.2
*/
TNC_Result TNC_IMC_ProvideBindFunction(TNC_IMCID imc_id,
- TNC_TNCC_BindFunctionPointer bind_function)
+ TNC_TNCC_BindFunctionPointer bind_function)
{
if (!imc_attestation)
{
/* TODO: Implement checking of components with its sub-components */
if (sub_comp_depth != 0)
{
- DBG1(DBG_IMC, "current version of Attestation IMC does not support"
- "sub component measurement deeper than zero. "
- "Measuring top level component only.");
+ DBG1(DBG_IMC, "current version of Attestation IMC does not "
+ "support sub component measurement deeper than "
+ "zero. Measuring top level component only.");
}
- comp_name_vendor_id = attr_cast->get_comp_funct_name_vendor_id(attr_cast);
+ comp_name_vendor_id = attr_cast->get_comp_funct_name_vendor_id(
+ attr_cast);
if (comp_name_vendor_id != PEN_TCG)
{
DBG1(DBG_IMC, "current version of Attestation IMC supports"
(qualifier.type & PTS_FUNC_COMP_TYPE_ALL))
{
DBG2(DBG_IMC, "wildcard was set for the qualifier of functional"
- " component. Identifying the component with name binary enumeration");
+ " component. Identifying the component with "
+ "name binary enumeration");
}
else if (!qualifier.kernel && !qualifier.sub_component &&
(qualifier.type & PTS_FUNC_COMP_TYPE_UNKNOWN))
{
DBG2(DBG_IMC, "unknown was set for the qualifier of functional"
- " component. Identifying the component with name binary enumeration");
+ " component. Identifying the component with "
+ "name binary enumeration");
}
else
{
return FALSE;
}
- if (!pts->hash_file(pts, hasher, "/etc/tnc_config", hash_output))
+ if (!pts->hash_file(pts, hasher, "/etc/tnc_config",
+ hash_output))
{
hasher->destroy(hasher);
return FALSE;
measurement_time_t = time(NULL);
if (!measurement_time_t)
{
- params.measurement_time = chunk_create("0000-00-00T00:00:00Z", 20);
+ params.measurement_time = chunk_create(
+ "0000-00-00T00:00:00Z", 20);
}
else
{
time_now = localtime(&measurement_time_t);
- if (asprintf(&utc_time, "%d-%2.2d-%2.2dT%2.2d:%2.2d:%2.2dZ",
- time_now->tm_year + 1900,
- time_now->tm_mon + 1,
- time_now->tm_mday,
- time_now->tm_hour,
- time_now->tm_min,
- time_now->tm_sec) < 0)
+ if (asprintf(&utc_time,
+ "%d-%2.2d-%2.2dT%2.2d:%2.2d:%2.2dZ",
+ time_now->tm_year + 1900,
+ time_now->tm_mon + 1,
+ time_now->tm_mday,
+ time_now->tm_hour,
+ time_now->tm_min,
+ time_now->tm_sec) < 0)
{
DBG1(DBG_IMC, "could not format local time to UTC");
hasher->destroy(hasher);
return FALSE;
}
params.measurement_time = chunk_create(utc_time, 20);
- params.measurement_time = chunk_clone(params.measurement_time);
+ params.measurement_time = chunk_clone(
+ params.measurement_time);
free(utc_time);
}
- params.measurement = chunk_create(hash_output, hasher->get_hash_size(hasher));
+ params.measurement = chunk_create(hash_output,
+ hasher->get_hash_size(hasher));
hasher->destroy(hasher);
params.policy_uri = chunk_empty;
if (!pts->read_pcr(pts, EXTEND_PCR, ¶ms.pcr_before))
{
- DBG1(DBG_IMC, "error occured while reading PCR: %d", EXTEND_PCR);
+ DBG1(DBG_IMC, "error occured while reading PCR: %d",
+ EXTEND_PCR);
return FALSE;
}
if (!pts->extend_pcr(pts, EXTEND_PCR,
params.measurement, ¶ms.pcr_after))
{
- DBG1(DBG_IMC, "error occured while extending PCR: %d", EXTEND_PCR);
+ DBG1(DBG_IMC, "error occured while extending PCR: %d",
+ EXTEND_PCR);
return FALSE;
}
}
/* Quote */
- if (!pts->quote_tpm(pts, pcrs, num_of_evidences, &pcr_composite, "e_signature))
+ if (!pts->quote_tpm(pts, pcrs, num_of_evidences,
+ &pcr_composite, "e_signature))
{
DBG1(DBG_IMC, "error occured during TPM quote operation");
DESTROY_IF(e);
case TNC_CONNECTION_STATE_DELETE:
return imv_attestation->delete_state(imv_attestation, connection_id);
case TNC_CONNECTION_STATE_HANDSHAKE:
- result = imv_attestation->change_state(imv_attestation, connection_id,
- new_state, &state);
+ result = imv_attestation->change_state(imv_attestation,
+ connection_id, new_state, &state);
if (result != TNC_RESULT_SUCCESS)
{
return result;
DBG1(DBG_IMV, "IMV \"%s\" has not been initialized", imv_name);
return TNC_RESULT_NOT_INITIALIZED;
}
- return imv_attestation->provide_recommendation(imv_attestation, connection_id);
+ return imv_attestation->provide_recommendation(imv_attestation,
+ connection_id);
}
/**
* see section 4.2.8.1 of TCG TNC IF-IMV Specification 1.2
*/
TNC_Result TNC_IMV_ProvideBindFunction(TNC_IMVID imv_id,
- TNC_TNCS_BindFunctionPointer bind_function)
+ TNC_TNCS_BindFunctionPointer bind_function)
{
if (!imv_attestation)
{
DBG1(DBG_IMV, "platform is '%s'", platform_info);
/* Send Request File Metadata attribute */
- enumerator = pts_db->create_file_meta_enumerator(pts_db, platform_info);
+ enumerator = pts_db->create_file_meta_enumerator(pts_db,
+ platform_info);
if (!enumerator)
{
break;
is_dir = (type != 0);
DBG2(DBG_IMV, "metadata request for %s '%s'",
is_dir ? "directory" : "file", pathname);
- attr = tcg_pts_attr_req_file_meta_create(is_dir, delimiter, pathname);
+ attr = tcg_pts_attr_req_file_meta_create(is_dir, delimiter,
+ pathname);
attr->set_noskip_flag(attr, TRUE);
msg->add_attribute(msg, attr);
}
name = PTS_FUNC_COMP_NAME_BIOS;
/* Send Request Functional Component Evidence attribute */
- attr = tcg_pts_attr_req_funct_comp_evid_create(flags, sub_comp_depth,
- PEN_TCG, qualifier, name);
+ attr = tcg_pts_attr_req_funct_comp_evid_create(flags,
+ sub_comp_depth, PEN_TCG, qualifier, name);
attr->set_noskip_flag(attr, TRUE);
msg->add_attribute(msg, attr);
/* Send Generate Attestation Evidence attribute */
selected_algorithm = attr_cast->get_algorithms(attr_cast);
if (!(selected_algorithm & supported_algorithms))
{
- DBG1(DBG_IMV, "PTS-IMC selected unsupported measurement algorithm");
+ DBG1(DBG_IMV, "PTS-IMC selected unsupported"
+ " measurement algorithm");
return FALSE;
}
pts->set_meas_algorithm(pts, selected_algorithm);
pcr_info_inclided = attr_cast->is_pcr_info_included(attr_cast);
flags = attr_cast->get_flags(attr_cast);
depth = attr_cast->get_sub_component_depth(attr_cast);
- /* TODO: Implement checking of components with its sub-components */
+ /* TODO: Implement check of components with its sub-components */
if (depth != 0)
{
- DBG1(DBG_IMV, "Current version of Attestation IMV does not support"
- "sub component measurement deeper than zero");
+ DBG1(DBG_IMV, "Current version of Attestation IMV does not"
+ " support sub component measurement deeper than zero");
}
- comp_vendor_id = attr_cast->get_spec_comp_funct_name_vendor_id(attr_cast);
+ comp_vendor_id = attr_cast->get_spec_comp_funct_name_vendor_id(
+ attr_cast);
if (comp_vendor_id != PEN_TCG)
{
DBG1(DBG_IMV, "Current version of Attestation IMV supports"
pcr_after = attr_cast->get_pcr_after_value(attr_cast);
measurement = attr_cast->get_comp_measurement(attr_cast);
- DBG4(DBG_IMV,"PCR: %d was extended with %B", extended_pcr, &measurement);
- DBG4(DBG_IMV,"PCR: %d before value: %B", extended_pcr, &pcr_before);
- DBG4(DBG_IMV,"PCR: %d after value: %B", extended_pcr, &pcr_after);
+ DBG4(DBG_IMV,"PCR: %d was extended with %B",
+ extended_pcr, &measurement);
+ DBG4(DBG_IMV,"PCR: %d before value: %B",
+ extended_pcr, &pcr_before);
+ DBG4(DBG_IMV,"PCR: %d after value: %B",
+ extended_pcr, &pcr_after);
entry = malloc_thing(pcr_entry_t);
entry->pcr_number = extended_pcr;
/* Check calculated PCR composite structure matches with received */
if (pcr_comp.ptr && !chunk_equals(pcr_comp, pcr_composite))
{
- DBG1(DBG_IMV, "received PCR Compsosite didn't match with constructed");
+ DBG1(DBG_IMV, "received PCR Compsosite didn't match"
+ " with constructed");
chunk_clear(&pcr_composite);
chunk_clear("e_info);
return FALSE;
chunk_clear("e_info);
if (tpm_quote_sign.ptr &&
- !pts->verify_quote_signature(pts, quote_digest, tpm_quote_sign))
+ !pts->verify_quote_signature(pts, quote_digest,
+ tpm_quote_sign))
{
chunk_clear("e_digest);
return FALSE;
}
- DBG2(DBG_IMV, "signature verification succeeded for TPM Quote Info");
+ DBG2(DBG_IMV, "signature verification succeeded for "
+ "TPM Quote Info");
chunk_clear("e_digest);
}
file_count, (file_count == 1) ? "":"s");
e = metadata->create_enumerator(metadata);
- while(e->enumerate(e, &entry))
+ while (e->enumerate(e, &entry))
{
- DBG1(DBG_IMV, "File name: %s", entry->filename);
- DBG1(DBG_IMV, " type: %d", entry->type);
- DBG1(DBG_IMV, " size: %d", entry->filesize);
- DBG1(DBG_IMV, " create time: %s", ctime(&entry->create_time));
- DBG1(DBG_IMV, " last modified: %s", ctime(&entry->last_modify_time));
- DBG1(DBG_IMV, " last accessed: %s", ctime(&entry->last_access_time));
- DBG1(DBG_IMV, " owner id: %d", entry->owner_id);
- DBG1(DBG_IMV, " group id: %d", entry->group_id);
+ DBG1(DBG_IMV, "File name: %s",
+ entry->filename);
+ DBG1(DBG_IMV, " type: %d",
+ entry->type);
+ DBG1(DBG_IMV, " size: %d",
+ entry->filesize);
+ DBG1(DBG_IMV, " create time: %s",
+ ctime(&entry->create_time));
+ DBG1(DBG_IMV, " last modified: %s",
+ ctime(&entry->last_modify_time));
+ DBG1(DBG_IMV, " last accessed: %s",
+ ctime(&entry->last_access_time));
+ DBG1(DBG_IMV, " owner id: %d",
+ entry->owner_id);
+ DBG1(DBG_IMV, " group id: %d",
+ entry->group_id);
}
e->destroy(e);
free(this);
}
-METHOD(imv_attestation_state_t, get_handshake_state, imv_attestation_handshake_state_t,
- private_imv_attestation_state_t *this)
+METHOD(imv_attestation_state_t, get_handshake_state,
+ imv_attestation_handshake_state_t, private_imv_attestation_state_t *this)
{
return this->handshake_state;
}
METHOD(imv_attestation_state_t, set_handshake_state, void,
- private_imv_attestation_state_t *this, imv_attestation_handshake_state_t new_state)
+ private_imv_attestation_state_t *this,
+ imv_attestation_handshake_state_t new_state)
{
this->handshake_state = new_state;
}
*
* @return the handshake state of IMV
*/
- imv_attestation_handshake_state_t (*get_handshake_state)(imv_attestation_state_t *this);
+ imv_attestation_handshake_state_t (*get_handshake_state)(
+ imv_attestation_state_t *this);
/**
* Set state of the handshake
hasher = lib->crypto->create_hasher(lib->crypto, hash_alg);
if (!hasher)
{
- DBG1(DBG_PTS, " hasher %N not available", hash_algorithm_names, hash_alg);
+ DBG1(DBG_PTS, "hasher %N not available", hash_algorithm_names, hash_alg);
return NULL;
}
if (stat(pathname, &st))
{
- DBG1(DBG_PTS, "Unable to obtain statistical information about %s", pathname);
+ DBG1(DBG_PTS, "Unable to obtain statistical information about %s",
+ pathname);
return FALSE;
}
result = Tspi_Context_Create(&hContext);
if (result != TSS_SUCCESS)
{
- DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x", result);
+ DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x",
+ result);
return FALSE;
}
result = Tspi_Context_Create(&hContext);
if (result != TSS_SUCCESS)
{
- DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x", result);
+ DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x",
+ result);
return FALSE;
}
result = Tspi_Context_Connect(hContext, NULL);
result = Tspi_Context_Create(&hContext);
if (result != TSS_SUCCESS)
{
- DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x", result);
+ DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x",
+ result);
return FALSE;
}
result = Tspi_Context_Connect(hContext, NULL);
goto err1;
}
- /* Retrieve SRK from TPM and set the authentication data as well known secret*/
+ /* Retrieve SRK from TPM and set the authentication to well known secret*/
result = Tspi_Context_LoadKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM,
SRK_UUID, &hSRK);
if (result != TSS_SUCCESS)
}
/* Create PCR composite object */
- result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_PCRS, 0, &hPcrComposite);
+ result = Tspi_Context_CreateObject(hContext,
+ TSS_OBJECT_TYPE_PCRS, 0, &hPcrComposite);
if (result != TSS_SUCCESS)
{
goto err2;
/**
* 1. build a TCPA_PCR_COMPOSITE structure which contains (pcrCompositeBuf)
- * TCPA_PCR_SELECTION structure (bitmask length network order + length bytes bitmask)
+ * TCPA_PCR_SELECTION structure (bitmask length + bitmask)
* UINT32 (network order) gives the number of bytes following (pcr entries * 20)
* TCPA_PCRVALUE[] with the pcr values
*
if (this->pcrs->get_count(this->pcrs) == 0)
{
- DBG1(DBG_PTS, "PCR entries unavailable, unable to construct TPM Quote Info");
+ DBG1(DBG_PTS, "PCR entries unavailable, unable to construct "
+ "TPM Quote Info");
return FALSE;
}
}
/** Implementation using strongswan -> not working */
- /*if (!aik_pub_key->verify(aik_pub_key, SIGN_RSA_EMSA_PKCS1_SHA1, data, signature))
+ /**if (!aik_pub_key->verify(aik_pub_key, SIGN_RSA_EMSA_PKCS1_SHA1,
+ data, signature))
{
DBG1(DBG_PTS, "signature verification failed for TPM Quote Info");
goto cleanup;
}
*/
- if (!aik_pub_key->get_encoding(aik_pub_key, PUBKEY_SPKI_ASN1_DER, &key_encoding))
+ if (!aik_pub_key->get_encoding(aik_pub_key,
+ PUBKEY_SPKI_ASN1_DER, &key_encoding))
{
DBG1(DBG_PTS, "failed to get encoding of AIK public key");
goto cleanup;
pkey = d2i_PUBKEY(NULL, (const unsigned char**)&p, key_encoding.len);
if (!pkey)
{
- DBG1(DBG_PTS, "failed to get EVP_PKEY object from AIK public key encoding");
+ DBG1(DBG_PTS, "failed to get EVP_PKEY object from AIK public key");
goto cleanup;
}
goto cleanup;
}
- if (RSA_verify(NID_sha1, data.ptr, data.len, signature.ptr, signature.len, rsa) != 1)
+ if (RSA_verify(NID_sha1, data.ptr, data.len,
+ signature.ptr, signature.len, rsa) != 1)
{
DBG1(DBG_PTS, "signature verification failed for TPM Quote Info");
goto cleanup;
result = Tspi_Context_Create(&hContext);
if (result != TSS_SUCCESS)
{
- DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x", result);
+ DBG1(DBG_PTS, "TPM context could not be created: tss error 0x%x",
+ result);
return FALSE;
}
result = Tspi_Context_Connect(hContext, NULL);
void (*set_peer_public_value) (pts_t *this, chunk_t value, chunk_t nonce);
/**
- * Calculates secret assessment value to be used for TPM Quote as ExternalData
+ * Calculates assessment secret to be used for TPM Quote as ExternalData
*
* @return TRUE unless both DH public values
* and nonces are set
* @param error_code Output variable for PTS error code
* @return TRUE if path is valid or file/directory
* doesn't exist or path is invalid
- * FALSE if local error occured within stat function
+ * FALSE if local error occured within stat function
*/
bool (*is_path_valid)(pts_t *this, char *path, pts_error_code_t *error_code);
* @param is_directory TRUE if directory contents are requested
* @return PTS File Metadata or NULL if FAILED
*/
- pts_file_meta_t* (*get_metadata)(pts_t *this, char *pathname, bool is_directory);
+ pts_file_meta_t* (*get_metadata)(pts_t *this, char *pathname,
+ bool is_directory);
/**
* Reads given PCR value and returns it
* @param output Chunk to save PCR value after extension
* @return FALSE in case of TSS error, TRUE otherwise
*/
- bool (*extend_pcr)(pts_t *this, u_int32_t pcr_num, chunk_t input, chunk_t *output);
+ bool (*extend_pcr)(pts_t *this, u_int32_t pcr_num, chunk_t input,
+ chunk_t *output);
/**
* Quote over PCR's
/**
* Add extended PCR with its corresponding value
*
- * @return FALSE in case of any error or non-match, TRUE otherwise
+ * @return FALSE in case of any error or non-match, TRUE otherwise
*/
void (*add_pcr_entry)(pts_t *this, pcr_entry_t *entry);
* @param quote_info Output variable to store TPM Quote Info
* @return FALSE in case of any error, TRUE otherwise
*/
- bool (*get_quote_info)(pts_t *this, chunk_t *pcr_composite, chunk_t *quote_info);
+ bool (*get_quote_info)(pts_t *this, chunk_t *pcr_composite,
+ chunk_t *quote_info);
/**
* Constructs and returns PCR Quote Digest structure expected from IMC
*
* @param data Calculated TPM Quote Digest
* @param signature TPM Quote Signature received from IMC
- * @return FALSE in case signature is not verified, TRUE otherwise
+ * @return FALSE in case signature is not verified, TRUE otherwise
*/
bool (*verify_quote_signature)(pts_t *this, chunk_t data, chunk_t signature);
* @param product software product (os, vpn client, etc.)
* @return enumerator over all matching files/directories
*/
- enumerator_t* (*create_file_enumerator)(pts_database_t *this, char *product);
+ enumerator_t* (*create_file_enumerator)(pts_database_t *this,
+ char *product);
/**
* Get files/directories to request metadata of
* @param product software product (os, vpn client, etc.)
* @return enumerator over all matching files/directories
*/
- enumerator_t* (*create_file_meta_enumerator)(pts_database_t *this, char *product);
+ enumerator_t* (*create_file_meta_enumerator)(pts_database_t *this,
+ char *product);
/**
* Get stored measurement hash for single file or directory entries
#include <bio/bio_reader.h>
#include <debug.h>
-typedef struct private_tcg_pts_attr_dh_nonce_finish_t private_tcg_pts_attr_dh_nonce_finish_t;
+typedef struct private_tcg_pts_attr_dh_nonce_finish_t
+ private_tcg_pts_attr_dh_nonce_finish_t;
/**
* PTS DH Nonce Finish
/**
* Described in header.
*/
-pa_tnc_attr_t *tcg_pts_attr_dh_nonce_finish_create(pts_meas_algorithms_t hash_algo,
- chunk_t initiator_value,
- chunk_t initiator_nonce)
+pa_tnc_attr_t *tcg_pts_attr_dh_nonce_finish_create(
+ pts_meas_algorithms_t hash_algo,
+ chunk_t initiator_value,
+ chunk_t initiator_nonce)
{
private_tcg_pts_attr_dh_nonce_finish_t *this;
* @param initiator_value DH Initiator Public Value
* @param initiator_nonce DH Initiator Nonce
*/
-pa_tnc_attr_t* tcg_pts_attr_dh_nonce_finish_create(pts_meas_algorithms_t hash_algo,
- chunk_t initiator_value,
- chunk_t initiator_nonce);
+pa_tnc_attr_t* tcg_pts_attr_dh_nonce_finish_create(
+ pts_meas_algorithms_t hash_algo,
+ chunk_t initiator_value,
+ chunk_t initiator_nonce);
/**
* Creates an tcg_pts_attr_dh_nonce_finish_t object from received data
#include <bio/bio_reader.h>
#include <debug.h>
-typedef struct private_tcg_pts_attr_dh_nonce_params_req_t private_tcg_pts_attr_dh_nonce_params_req_t;
+typedef struct private_tcg_pts_attr_dh_nonce_params_req_t
+ private_tcg_pts_attr_dh_nonce_params_req_t;
/**
* PTS DH Nonce Parameters Request
#ifndef TCG_PTS_ATTR_DH_NONCE_PARAMS_REQ_H_
#define TCG_PTS_ATTR_DH_NONCE_PARAMS_REQ_H_
-typedef struct tcg_pts_attr_dh_nonce_params_req_t tcg_pts_attr_dh_nonce_params_req_t;
+typedef struct tcg_pts_attr_dh_nonce_params_req_t
+ tcg_pts_attr_dh_nonce_params_req_t;
#include "tcg_attr.h"
#include "pa_tnc/pa_tnc_attr.h"
#include <bio/bio_reader.h>
#include <debug.h>
-typedef struct private_tcg_pts_attr_dh_nonce_params_resp_t private_tcg_pts_attr_dh_nonce_params_resp_t;
+typedef struct private_tcg_pts_attr_dh_nonce_params_resp_t
+ private_tcg_pts_attr_dh_nonce_params_resp_t;
/**
* PTS DH Nonce Parameters Response
return this->dh_group;
}
-METHOD(tcg_pts_attr_dh_nonce_params_resp_t, get_hash_algo_set, pts_meas_algorithms_t,
- private_tcg_pts_attr_dh_nonce_params_resp_t *this)
+METHOD(tcg_pts_attr_dh_nonce_params_resp_t, get_hash_algo_set,
+ pts_meas_algorithms_t, private_tcg_pts_attr_dh_nonce_params_resp_t *this)
{
return this->hash_algo_set;
}
#ifndef TCG_PTS_ATTR_DH_NONCE_PARAMS_RESP_H_
#define TCG_PTS_ATTR_DH_NONCE_PARAMS_RESP_H_
-typedef struct tcg_pts_attr_dh_nonce_params_resp_t tcg_pts_attr_dh_nonce_params_resp_t;
+typedef struct tcg_pts_attr_dh_nonce_params_resp_t
+ tcg_pts_attr_dh_nonce_params_resp_t;
#include "tcg_attr.h"
#include "pa_tnc/pa_tnc_attr.h"
*
* @return Hash algorithm set
*/
- pts_meas_algorithms_t (*get_hash_algo_set)(tcg_pts_attr_dh_nonce_params_resp_t *this);
+ pts_meas_algorithms_t (*get_hash_algo_set)(
+ tcg_pts_attr_dh_nonce_params_resp_t *this);
/**
* Get DH Responder Nonce
#include <bio/bio_reader.h>
#include <debug.h>
-typedef struct private_tcg_pts_attr_gen_attest_evid_t private_tcg_pts_attr_gen_attest_evid_t;
+typedef struct private_tcg_pts_attr_gen_attest_evid_t
+ private_tcg_pts_attr_gen_attest_evid_t;
/**
* Generate Attestation Evidence
#include <bio/bio_reader.h>
#include <debug.h>
-typedef struct private_tcg_pts_attr_get_tpm_version_info_t private_tcg_pts_attr_get_tpm_version_info_t;
+typedef struct private_tcg_pts_attr_get_tpm_version_info_t
+ private_tcg_pts_attr_get_tpm_version_info_t;
/**
* Get TPM Version Information
#ifndef TCG_PTS_ATTR_GET_TPM_VERSION_INFO_H_
#define TCG_PTS_ATTR_GET_TPM_VERSION_INFO_H_
-typedef struct tcg_pts_attr_get_tpm_version_info_t tcg_pts_attr_get_tpm_version_info_t;
+typedef struct tcg_pts_attr_get_tpm_version_info_t
+ tcg_pts_attr_get_tpm_version_info_t;
#include "tcg_attr.h"
#include "pa_tnc/pa_tnc_attr.h"
bio_reader_t *reader;
u_int8_t flags;
u_int8_t reserved;
- //u_int16_t algorithm;
+ /** u_int16_t algorithm;*/
if (this->value.len < PTS_SIMPLE_EVID_FINAL_SIZE)
{
projects / thirdparty / strongswan.git / commitdiff
