path: root/src/tspi/tspi_daa.c

/*
 * Licensed Materials - Property of IBM
 *
 * trousers - An open source TCG Software Stack
 *
 * (C) Copyright International Business Machines Corp. 2004
 *
 */


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>

#include "trousers/tss.h"
#include "trousers/trousers.h"
#include "trousers_types.h"
//#include "trousers_types.h"
#include "spi_utils.h"
//#include "capabilities.h"
#include "tsplog.h"
//#include "tcs_tsp.h"
//#include "tspps.h"
//#include "hosttable.h"
//#include "tcsd_wrap.h"
//#include "tcsd.h"
#include "obj.h"
#include "daa/issuer.h"
#include "daa/platform.h"
#include "daa/verifier.h"
#include "daa/anonymity_revocation.h"

#include "daa/key_correct.h"
#include "daa/issuer.h"

// static TSS_HCONTEXT _hContext;

static void *tss_alloc( size_t size, TSS_HOBJECT hContext) {
	void *ret = calloc_tspi( hContext, size);

	LogDebug("[intern_alloc (%d)] -> %d", (int)size, (int)ret);
	return ret;
}

/*
static void *normal_malloc( size_t size, TSS_HOBJECT object) {
	void *ret = malloc( size);
	return ret;
}
*/

/**
This is the first out of 3 functions to execute in order to receive a DAA Credential.
It verifies the keys of the DAA Issuer and computes the TPM DAA public key.

Parameters
	- hDAA:		Handle of the DAA object
	- hTPM:		Handle of the TPM object
	- daaCounter:	DAA counter
	- issuerPk:	Handle of the DAA Issuer public key
	- issuerAuthPKsLength:	Length of the array of issuerAuthPKs
	- issuerAuthPKs:Handle of an array of RSA public keys (key chain) of the DAA Issuer used
				to authenticate the DAA Issuer public key. The size of the modulus
				must be TPM_DAA_SIZE_issuerModulus (256)
	- issuerAuthPKSignaturesLength:Length of the array of issuerAuthPKSignatures. It is equal
				to issuerAuthPKsLength . The length of an element of the array is
				TPM_DAA_SIZE_issuerModulus (256)
	- issuerAuthPKSignatures: An array of byte arrays representing signatures on the modulus
				of the above key chain (issuerAuthPKs) in more details, the array has the
				following content (S(K[1],K[0]),S(K[2],N[1]),..S(K[ k ],K[n-1]),
				S(TPM_DAA_ISSUER,K[ k ])), where S(msg,privateKey) denotes
				the signature function with msg being signed by the privateKey.
	- capitalUprimeLength: Length of capitalUprime which is ln/8. ln is defined as the size of the RSA modulus (2048).
	- capitalUprime: U?
	- identityProof: This structure contains the endorsement, platform and conformance credential.
	- joinSession: This structure contains DAA Join session information.
*/
#if 0
TSPICALL
Tspi_TPM_DAA_JoinInit(TSS_HDAA                 hDAA,				// in
		      TSS_HTPM                 hTPM,				// in
		      UINT32                   daaCounter,			// in
		      TSS_HDAA_DATA            issuerPk,			// in
		      UINT32                   issuerAuthPKsLength,		// in
		      TSS_HKEY*                issuerAuthPKs,			// in
		      UINT32                   issuerAuthPKSignaturesLength,	// in
		      BYTE**                   issuerAuthPKSignatures,		// in
		      UINT32*                  capitalUprimeLength,		// out
		      BYTE**                   capitalUprime,			// out
		      TSS_DAA_IDENTITY_PROOF** identityProof,			// out
		      TSS_DAA_JOIN_SESSION**   joinSession)			// out
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	LogDebug("-> TSPI_TPM_DAA_joinInit hDAA=%x hTPM=%x daaCounter=%x issuerPk=%x",
		(int)hDAA, (int)hTPM, daaCounter, (int)issuerPk);
	result = Tspi_TPM_DAA_JoinInit_internal(
		hDAA,
		hTPM,
		daaCounter,
		(TSS_DAA_PK *)issuerPk,
		issuerAuthPKsLength,
		(RSA **)issuerAuthPKs,
		issuerAuthPKSignaturesLength,
		issuerAuthPKSignatures,
		capitalUprimeLength,
		capitalUprime,
		identityProof,
		joinSession);
	bi_flush_memory();

	LogDebug("TSPI_TPM_DAA_joinInit ALLOC DELTA:%d",mallinfo().uordblks-before);
	LogDebug("<- TSPI_TPM_DAA_joinInit result=%d", result);
	return result;
}
#else
TSS_RESULT
Tspi_TPM_DAA_JoinInit(TSS_HTPM                 hTPM,                          /* in */
		      TSS_HDAA_ISSUER_KEY      hIssuerKey,                    /* in */
		      UINT32                   daaCounter,                    /* in */
		      UINT32                   issuerAuthPKsLength,           /* in */
		      TSS_HKEY*                issuerAuthPKs,                 /* in */
		      UINT32                   issuerAuthPKSignaturesLength,  /* in */
		      UINT32                   issuerAuthPKSignaturesLength2, /* in */
		      BYTE**                   issuerAuthPKSignatures,        /* in */
		      UINT32*                  capitalUprimeLength,           /* out */
		      BYTE**                   capitalUprime,                 /* out */
		      TSS_DAA_IDENTITY_PROOF** identityProof,                 /* out */
		      UINT32*                  joinSessionLength,             /* out */
		      BYTE**                   joinSession)                   /* out */
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	if (!capitalUprimeLength || !capitalUprime || !identityProof || !joinSessionLength ||
	    !joinSession)
		return TSPERR(TSS_E_BAD_PARAMETER);

	result = Tspi_TPM_DAA_JoinInit_internal(hTPM, hIssuerKey, daaCounter, issuerAuthPKsLength,
						issuerAuthPKs, issuerAuthPKSignaturesLength,
						issuerAuthPKSignaturesLength2,
						issuerAuthPKSignatures, capitalUprimeLength,
						capitalUprime, identityProof, joinSessionLength,
						joinSession);

	bi_flush_memory();

	LogDebug("TSPI_TPM_DAA_joinInit ALLOC DELTA:%d",mallinfo().uordblks-before);
	LogDebug("<- TSPI_TPM_DAA_joinInit result=%d", result);

	return result;
}
#endif
/**
This function is part of the DAA Issuer component. It defines the generation of a DAA Issuer
public and secret key. Further it defines the generation of a non-interactive proof (using
the Fiat-Shamir heuristic) that the public keys were chosen correctly. The latter will guarantee
the security requirements of the platform (respectively, its user), i.e., that the privacy and
anonymity of signatures will hold.
The generation of the authentication keys of the DAA Issuer, which are used to authenticate
(main) DAA Issuer keys, is not defined by this function.
This is an optional function and does not require a TPM or a TCS.

Parameters
	- hDAA:	Handle of the DAA object
	- issuerBaseNameLength: Length of issuerBaseName
	- issuerBaseName:	Unique name of the DAA Issuer
	- numberPlatformAttributes: Number of attributes that the Platform can choose and which
						will not be visible to the Issuer.
	- numberIssuerAttributes:Number of attributes that the Issuer can choose and which will
						be visible to both the Platform and the Issuer.
	- keyPair:	Handle of the main DAA Issuer key pair (private and public portion)
	- publicKeyProof:Handle of the proof of the main DAA Issuer public key
*/
#if 0
TSPICALL
Tspi_DAA_IssueSetup(TSS_HDAA       hDAA,			// in
		    UINT32         issuerBaseNameLength,	// in
		    BYTE*          issuerBaseName,		// in
		    UINT32         numberPlatformAttributes,	// in
		    UINT32         numberIssuerAttributes,	// in
		    TSS_HDAA_DATA* keyPair,			// out (TSS_KEY_PAIR)
		    TSS_HDAA_DATA* publicKeyProof)		// out (TSS_DAA_PK_PROOF)
{
	TSS_RESULT result;
	KEY_PAIR_WITH_PROOF_internal *key_proof;
	TSS_DAA_KEY_PAIR *tss_daa_key_pair;
	TSS_HCONTEXT hContext;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	LogDebug( "TSPI_DAA_IssueSetup hDAA=%d  ",hDAA);
	// TODO: lock access to _hContext
	if ((result = obj_daa_get_tsp_context(hDAA, &hContext)))
		return result;
	result = generate_key_pair(numberIssuerAttributes,
						numberPlatformAttributes,
						issuerBaseNameLength,
						issuerBaseName,
						&key_proof);
	if (result != TSS_SUCCESS)
		return result;
	LogDebug("TSPI_DAA_IssueSetup convert internal structure to public allocated using tspi_alloc");
	LogDebug("key_proof->proof->length_challenge=%d  key_proof->proof->length_response=%d",
			key_proof->proof->length_challenge, key_proof->proof->length_response);
	// prepare out parameters
	*publicKeyProof = i_2_e_TSS_DAA_PK_PROOF( key_proof->proof, &tss_alloc, hContext);

	tss_daa_key_pair = (TSS_DAA_KEY_PAIR *)tss_alloc( sizeof(TSS_DAA_KEY_PAIR), hContext);
	if (tss_daa_key_pair == NULL) {
		LogError("malloc of %d bytes failed", sizeof(TSS_DAA_KEY_PAIR));
		result = TSPERR(TSS_E_OUTOFMEMORY);
		goto close;
	}
	tss_daa_key_pair->private_key = i_2_e_TSS_DAA_PRIVATE_KEY( key_proof->private_key,
								&tss_alloc,
								hContext);
	tss_daa_key_pair->public_key = i_2_e_TSS_DAA_PK( key_proof->pk,
							&tss_alloc,
							hContext);
	*keyPair = (TSS_HKEY)tss_daa_key_pair;
close:
	bi_flush_memory();

	LogDebug("TSPI_DAA_IssueSetup ALLOC DELTA:%d", mallinfo().uordblks-before);
	LogDebug( "TSPI_DAA_IssueSetup end return=%d ",result);
	return result;
}
#else
TSS_RESULT
Tspi_DAA_Issuer_GenerateKey(TSS_HDAA_ISSUER_KEY hIssuerKey,           // in
			    UINT32              issuerBaseNameLength, // in
			    BYTE*               issuerBaseName)       // in
{
	TSS_RESULT result;
	KEY_PAIR_WITH_PROOF_internal *key_proof;
	TSS_DAA_KEY_PAIR *tss_daa_key_pair;
	TSS_HCONTEXT tspContext;
	UINT32 numberPlatformAttributes, numberIssuerAttributes;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	if ((result = obj_daaissuerkey_get_tsp_context(hIssuerKey, &tspContext)))
		return result;

	if ((result = obj_daaissuerkey_get_attribs(hIssuerKey, &numberIssuerAttributes,
						   &numberPlatformAttributes)))
		return result;

	if ((result = generate_key_pair(numberIssuerAttributes, numberPlatformAttributes,
					issuerBaseNameLength, issuerBaseName, &key_proof)))
		return result;

	LogDebugFn("convert internal structure to public allocated using tspi_alloc");
	LogDebug("key_proof->proof->length_challenge=%d  key_proof->proof->length_response=%d",
		 key_proof->proof->length_challenge, key_proof->proof->length_response);

	// prepare out parameters
	*publicKeyProof = i_2_e_TSS_DAA_PK_PROOF( key_proof->proof, &tss_alloc, tspContext);

	tss_daa_key_pair = (TSS_DAA_KEY_PAIR *)tss_alloc( sizeof(TSS_DAA_KEY_PAIR), tspContext);
	if (tss_daa_key_pair == NULL) {
		LogError("malloc of %d bytes failed", sizeof(TSS_DAA_KEY_PAIR));
		result = TSPERR(TSS_E_OUTOFMEMORY);
		goto close;
	}
	tss_daa_key_pair->private_key = i_2_e_TSS_DAA_PRIVATE_KEY( key_proof->private_key,
								&tss_alloc,
								tspContext);
	tss_daa_key_pair->public_key = i_2_e_TSS_DAA_PK( key_proof->pk,
							&tss_alloc,
							tspContext);
	*keyPair = (TSS_HKEY)tss_daa_key_pair;
close:
	bi_flush_memory();

	LogDebug("TSPI_DAA_IssueSetup ALLOC DELTA:%d", mallinfo().uordblks-before);
	LogDebug( "TSPI_DAA_IssueSetup end return=%d ",result);
	return result;
}
#endif
/**
This function is part of the DAA Issuer component. It's the first function out of 2 in order to
issue a DAA Credential for a TCG Platform. It assumes that the endorsement key and its
associated credentials are from a genuine and valid TPM. (Verification of the credentials is
 a process defined by the TCG Infrastructure WG.)
This is an optional function and does not require a TPM or a TCS.
*/
TSPICALL
Tspi_DAA_IssueInit(TSS_HDAA                      hDAA,                          // in
		   TSS_HKEY                      issuerAuthPK,                  // in
		   TSS_HDAA_DATA                 issuerKeyPair,		    // in (TSS_DAA_KEY_PAIR)
		   TSS_DAA_IDENTITY_PROOF*       identityProof,                 // in
		   UINT32                        capitalUprimeLength,           // in
		   BYTE*                         capitalUprime,                 // in
		   UINT32                        daaCounter,                    // in
		   UINT32*                       nonceIssuerLength,             // out
		   BYTE**                        nonceIssuer,                   // out
		   UINT32*                       authenticationChallengeLength, // out
		   BYTE**                        authenticationChallenge,       // out
		   TSS_DAA_JOIN_ISSUER_SESSION** joinSession)                   // out
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	LogDebug("Tspi_DAA_IssueInit_internal hDAA=%d daaCounter=%d", (int)hDAA, (int)daaCounter);
	result = Tspi_DAA_IssueInit_internal(
		hDAA,			// in
		issuerAuthPK,		// in
		issuerKeyPair,		// in
		identityProof,		// in
		capitalUprimeLength,	// in
		capitalUprime,		// in
		daaCounter,	// in
		nonceIssuerLength,	// out
		nonceIssuer,	// out
		authenticationChallengeLength,	// out
		authenticationChallenge,	// out
		joinSession	// out
	);
	bi_flush_memory();

	LogDebug("Tspi_DAA_IssueInit_internal ALLOC DELTA:%d", mallinfo().uordblks-before);

	return result;
}

/**
This function verifies the DAA public key of a DAA Issuer with respect to its associated proof.
This is a resource consuming task. It can be done by trusted third party (certification).
This is an optional function and does not require a TPM or a TCS.
Parameters:
	- hDAA: Handle of the DAA object
	- issuerPk: DAA Issuer public key
	- issuerPkProof: Proofs the correctness of the DAA Issuer public key
	- isCorrect: Proofs the correctness of the DAA Issuer public key
*/
TSPICALL
Tspi_DAA_IssuerKeyVerification(TSS_HDAA          hDAA,		// in
			       TSS_HDAA_DATA     issuerPk,	// in (TSS_DAA_PK)
			       TSS_HDAA_DATA     issuerPkProof,	// in (TSS_DAA_PK_PROOF)
			       TSS_BOOL*         isCorrect)	// out
{
	TSS_RESULT result;
	int is_correct;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	LogDebug("TSPI_DAA_IssuerKeyVerification hDAA=%ld issuerPk=%ld issuerPkProof=%ld",
		(long)hDAA, (long)issuerPk, (long)issuerPkProof);
	TSS_DAA_PK_internal *pk_internal = e_2_i_TSS_DAA_PK( (TSS_DAA_PK *)issuerPk);
	TSS_DAA_PK_PROOF_internal *proof_internal = e_2_i_TSS_DAA_PK_PROOF( issuerPkProof);
	LogDebug( "challenge=[%s]", dump_byte_array( proof_internal->length_challenge,
							proof_internal->challenge));
	result = is_pk_correct( pk_internal, proof_internal, &is_correct );
	if( is_correct) *isCorrect = TRUE;
	else *isCorrect = FALSE;
	bi_flush_memory();
#ifdef TSS_DEBUG
	LogDebug("TSPI_DAA_IssuerKeyVerification ALLOC DELTA:%d", mallinfo().uordblks-before);
#endif
	return result;
}

/**
This function is part of the DAA Issuer component. It?s the last function out of 2 in order to
issue DAA Credential for a TCG Platform. It detects rogue TPM according to published rogue
TPM DAA keys.
This is an optional function and does not require a TPM or a TCS.
*/
TSPICALL
Tspi_DAA_IssueCredential(TSS_HDAA                      hDAA,			// in
			 UINT32                        attributesIssuerLength,	// in
			 BYTE**                        attributesIssuer,	// in
			 TSS_DAA_CREDENTIAL_REQUEST*   credentialRequest,	// in
			 TSS_DAA_JOIN_ISSUER_SESSION*  joinSession,		// in
			 TSS_DAA_CRED_ISSUER**         credIssuer)		// out
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	LogDebug("Tspi_DAA_IssueCredential hDAA=%d attributesIssuerLength=%d",
		(int)hDAA,
		(int)attributesIssuerLength);
	result = Tspi_DAA_IssueCredential_internal(
		hDAA,
		attributesIssuerLength,
		attributesIssuer,
		credentialRequest,
		joinSession,
		credIssuer
	);
	bi_flush_memory();
#ifdef TSS_DEBUG
	LogDebug("Tspi_DAA_IssueCredential ALLOC DELTA:%d", mallinfo().uordblks-before);
#endif
	return result;
}


/**
This function is part of the DAA Verifier component. It is the first function out of 2 in order
to verify a DAA credential of a TCG platform. It creates a challenge for the TCG platform.last
function out of 2 in order to issue a This is an optional function and does not require a
TPM or a TCS.
*/
TSPICALL
Tspi_DAA_VerifyInit(TSS_HDAA hDAA,			// in
		    UINT32*  nonceVerifierLength,	// out
		    BYTE**   nonceVerifier,		// out
		    UINT32*  baseNameLength,		// out
		    BYTE**   baseName)			// out
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	// TODO which interface to use ? with or without baseName ?
	LogDebug("Tspi_DAA_VerifyInit hDAA=%d", (int)hDAA);
	result = Tspi_DAA_VerifyInit_internal( hDAA,
						nonceVerifierLength,
						nonceVerifier,
						baseNameLength,
						baseName);
	bi_flush_memory();
#ifdef TSS_DEBUG
	LogDebug("Tspi_DAA_VerifyInit ALLOC DELTA:%d", mallinfo().uordblks-before);
#endif
	return result;
}


/**
This function is part of the DAA Verifier component. It is the last function out of 2 in
order to verify a DAA Credential of a TCG Platform. It verifies the DAA credential and
detects public rogue TPMs. This is an optional function and does not require a TPM
or a TCS.
*/
TSPICALL
Tspi_DAA_VerifySignature(TSS_HDAA           hDAA,		// in
			 TSS_DAA_SIGNATURE* daaSignature,	// in
			 TSS_HDAA_DATA      hPubKeyIssuer,	// in (TSS_DAA_PK)
			 TSS_DAA_SIGN_DATA* signData,		// in
			 UINT32             attributesLength,	// in
			 BYTE**             attributes,		// in
			 UINT32             nonceVerifierLength,// in
			 BYTE*              nonceVerifier,	// in
			 UINT32             baseNameLength,	// in
			 BYTE*              baseName,		// in
			 TSS_BOOL*          isCorrect)		// out
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	LogDebug("Tspi_DAA_VerifySignature hDAA=%d", (int)hDAA);
	result = Tspi_DAA_VerifySignature_internal( hDAA,
						daaSignature,
						hPubKeyIssuer,
						signData,
						attributesLength,
						attributes,
						nonceVerifierLength,
						nonceVerifier,
						baseNameLength,
						baseName,
						isCorrect);
	bi_flush_memory();
#ifdef TSS_DEBUG
	LogDebug("Tspi_DAA_VerifySignature ALLOC DELTA:%d", mallinfo().uordblks-before);
#endif
	return result;
}


/**
This function is part of the DAA Issuer component. It is the last function out of 2 in
order to issue a DAA Credential for a TCG Platform. It detects rogue TPM according
to published rogue TPM DAA keys.
This is an optional function and does not require a TPM or a TCS.

Parameters
	- hDAA: 	Handle of the DAA object
	- daaPublicKey: 	daaPublickKey
	- keyPair: Public and private key of the DAA Anonymity Revocation Authority to encrypt
			the pseudonym of a DAA Signature
*/
TSPICALL
Tspi_DAA_RevokeSetup(TSS_HDAA       hDAA,		// in
		     TSS_HDAA_DATA  daaPublicKey,	// in
		     TSS_HDAA_DATA* arPublicKey,	// out (TSS_DAA_AR_PK)
		     TSS_HDAA_DATA* arPrivateKey)	// out (TSS_DAA_AR_SK)
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	result = Tspi_DAA_RevokeSetup_internal(
		hDAA,			// in
//TODO: remove cast when the above interface is changed
		daaPublicKey,	// in
		keyPair		// out
	);
	bi_flush_memory();
#ifdef TSS_DEBUG
	LogDebug("Tspi_DAA_RevokeSetup ALLOC DELTA:%d", mallinfo().uordblks-before);
#endif
	return TSS_SUCCESS;
}


/**
This function is part of the DAA Anonymity Revocation Authority component. It defines the
Cramer-Shoup decryption algorithm to revoke the anonymity of a DAA Signature. The pseudonym,
with respect to either the DAA Verifier?s base name, the DAA Issuer?s base name or (just for
completeness) a random base name, can be revealed.
The pseudonym with respect to a DAA Signature and the used base name is V N . An encryption of
V N is the tuple (d1,d 2 ,d 3,d 4 ) and is decrypted using the secret key ( 0 5 x ,?, x ), the
decryption condition and the DAA public key.
This is an optional function and does not require a TPM or a TCS.

Parameters:
	- hDAA:					Handle of the DAA object
	- encryptedPseudonym: 			encryptedPseudonym
	- decryptCondition: 			Condition for the decryption of the pseudonym.
	- arPrivateKey:				arPrivateKey
	- daaPublicKey:				daaPublicKey
	- pseudonym:				pseudonym
*/
TSPICALL
Tspi_DAA_ARDecrypt(TSS_HDAA                     hDAA,			// in
		   TSS_DAA_PSEUDONYM_ENCRYPTED* encryptedPseudonym,	// in
		   TSS_HHASH                    decryptCondition,	// in
		   TSS_HDAA_DATA                arPrivateKey,		// in (TSS_DAA_AR_SK)
		   TSS_HDAA_DATA                daaPublicKey,		// in (TSS_DAA_PK)
		   TSS_DAA_PSEUDONYM_PLAIN**    pseudonym)		// out
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	result = Tspi_DAA_ARDecrypt_internal(
		hDAA,			// in
		encryptedPseudonym,	// in
		decryptCondition,	// in
//TODO: remove cast when the above interface is changed
		(void *)arPrivateKey,		// in
		(void *)daaPublicKey,		// in
		pseudonym		// out
	);
	bi_flush_memory();
#ifdef TSS_DEBUG
	LogDebug("Tspi_DAA_ARDecrypt ALLOC DELTA:%d", mallinfo().uordblks-before);
#endif
	return result;
}

/**
This is the second out of 3 functions to execute in order to receive a DAA Credential. It
computes the credential request for the DAA Issuer, which also includes the Platform
DAA public key and the attributes that were chosen by the Platform, and which are not
visible to the DAA Issuer. The Platform can commit to the attribute values it has chosen.
*/
TSPICALL
Tspi_TPM_DAA_JoinCreateDaaPubKey(TSS_HDAA                     hDAA,	                    // in
				 TSS_HTPM                     hTPM,	                    // in
				 UINT32                       authenticationChallengeLength,// in
				 BYTE*                        authenticationChallenge,      // in
				 UINT32                       nonceIssuerLength,            // in
				 BYTE*                        nonceIssuer,                  // in
				 UINT32                       attributesPlatformLength,     // in
				 BYTE**                       attributesPlatform,           // in
				 TSS_DAA_JOIN_SESSION*        joinSession,                // in, out
				 TSS_DAA_CREDENTIAL_REQUEST** credentialRequest)            // out
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	LogDebug("Tspi_TPM_DAA_JoinCreateDaaPubKey hDAA=%d joinSession=%d",
			(int)hDAA, (int)joinSession);
	result = Tspi_TPM_DAA_JoinCreateDaaPubKey_internal(
		hDAA,	// in
		hTPM,	// in
		authenticationChallengeLength,	// in
		authenticationChallenge,	// in
		nonceIssuerLength,	// in
		nonceIssuer,	// in
		attributesPlatformLength,	// in
		attributesPlatform,	// in
		joinSession,	// in, out
		credentialRequest	// out
	);
	bi_flush_memory();
#ifdef TSS_DEBUG
	LogDebug("Tspi_TPM_DAA_JoinCreateDaaPubKey ALLOC DELTA:%d", mallinfo().uordblks-before);
#endif
	return result;
}


/**
This is the last out of 3 functions to execute in order to receive a DAA Credential.
It verifies the issued credential from the DAA Issuer and computes the final DAA Credential.
*/
TSPICALL
Tspi_TPM_DAA_JoinStoreCredential(TSS_HDAA              hDAA,		// in
				 TSS_HTPM              hTPM,		// in
				 TSS_DAA_CRED_ISSUER*  credIssuer,	// in
				 TSS_DAA_JOIN_SESSION* joinSession,	// in
				 TSS_HDAA_DATA*        phDaaCredential)	// out (TSS_DAA_CREDENTIAL)
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	LogDebug("Tspi_TPM_DAA_JoinStoreCredential hDAA=%d credIssuer=%d joinSession=%d",
		(int)hDAA, (int)&credIssuer, (int)&joinSession);
	result = Tspi_TPM_DAA_JoinStoreCredential_internal(hDAA,
							hTPM,
							credIssuer,
							joinSession,
							phDaaCredential);
	bi_flush_memory();
#ifdef TSS_DEBUG
	LogDebug("Tspi_TPM_DAA_JoinStoreCredential ALLOC DELTA:%d", mallinfo().uordblks-before);
#endif
	return result;
}


/**
This function creates a DAA Signature that proofs ownership of the DAA Credential and
includes a signature on either a public AIK or a message.
If anonymity revocation is enabled, the value Nv is not provided in the clear anymore but
encrypted under the public key of anonymity revocation authority, a trusted third party (TTP).
Thus the DAA Verifier cannot check for revocation or link a transaction/signature to prior ones.
Depending on how z is chosen, the protocol either allows to implementing anonymity revocation
(i.e., using the DAA Issuer long-term base name bsn I as the DAA Verifier base name bsnV ), or
having the TTP doing the linking of different signatures for the same DAA Verifier (i.e.,
using the DAA Verifier base name ).
*/
TSPICALL
Tspi_TPM_DAA_Sign(TSS_HDAA                 hDAA,			// in
		  TSS_HTPM                 hTPM,			// in
		  TSS_HDAA_DATA            hDaaCredential,		// in (TSS_DAA_CREDENTIAL)
		  TSS_DAA_SELECTED_ATTRIB* revealAttributes,		// in
		  UINT32                   verifierBaseNameLength,	// in
		  BYTE*                    verifierBaseName,		// in
		  UINT32                   verifierNonceLength,		// in
		  BYTE*                    verifierNonce,		// in
		  TSS_DAA_SIGN_DATA*       signData,			// in
		  TSS_DAA_SIGNATURE**      daaSignature)		// out
{
	TSS_RESULT result;
#ifdef TSS_DEBUG
	int before = mallinfo().uordblks;
#endif

	LogDebug("-> TSPI_TPM_DAA_Sign hDAA=%ld hTPM=%ld ", (long)hDAA, (long)hTPM);

	result = Tspi_TPM_DAA_Sign_internal(hDAA,
					hTPM,
					hDaaCredential,
					revealAttributes,
					verifierBaseNameLength,
					verifierBaseName,
					verifierNonceLength,
					verifierNonce,
					signData,
					daaSignature);
	bi_flush_memory();
#ifdef TSS_DEBUG
	LogDebug("TSPI_TPM_DAA_joinInit ALLOC DELTA:%d", mallinfo().uordblks-before);
#endif
	LogDebug("<- TSPI_TPM_DAA_joinInit result=%d", result);
	return result;
}