signature=53f29f26e97e77d293ae800260ffd103,TrouSerS

最新推荐文章于 2021-05-30 12:57:21 发布

Avatar Ye

最新推荐文章于 2021-05-30 12:57:21 发布

阅读量97

点赞数

文章标签： signature=53f29f26e97e77d293ae800260ffd103

This is an automated email from the git hooks/post-receive script. It was

generated because a ref change was pushed to the repository containing

the project "Trousers".

The branch, master has been updated

via 2a67037ecdee750dd1d1a529bd42f9b72e31aef7 (commit)

via 2883cb0dc6197ec878f2fbee5ffc8dbfec0d0e15 (commit)

via ef1ecb823c0be68cd0bb5529d9f9578db9f2165e (commit)

via 21d3ca10d52ffadf5abcf57edc52a16d22975c8d (commit)

via a09a0fd1a06714bae8d2febe2b637b6ed46cde1f (commit)

via 59351a56cac1710e89d207dff07eb23bbc644c13 (commit)

via 60f61f1f7e6e01f62e1588c0835f17085cebb705 (commit)

via aea3b103d28c9969ae5a39e0ce3d347d5fcffa98 (commit)

via 8742fe21951599487fc38af21c7e4e65afdb90b3 (commit)

from d3f81295a083efa01cdda263b83a1823021edd5a (commit)

Those revisions listed above that are new to this repository have

not appeared on any other notification email; so we list those

revisions in full, below.

- Log -----------------------------------------------------------------

http://trousers.git.sourceforge.net/git/gitweb.cgi?p=trousers/trousers;a=commitdiff;h=2a67037ecdee750dd1d1a529bd42f9b72e31aef7

commit 2a67037ecdee750dd1d1a529bd42f9b72e31aef7

Merge: d3f8129 2883cb0

Author: Hon Ching(Vicky) Lo

Date: Wed Nov 9 15:26:34 2016 -0500

Merge branch 'dev'

http://trousers.git.sourceforge.net/git/gitweb.cgi?p=trousers/trousers;a=commitdiff;h=2883cb0dc6197ec878f2fbee5ffc8dbfec0d0e15

commit 2883cb0dc6197ec878f2fbee5ffc8dbfec0d0e15

Author: Hon Ching(Vicky) Lo

Date: Tue Nov 8 21:11:37 2016 -0500

Replaced stack allocation and malloc of EVP_MD_CTX structures

This patch replaced all occurrences of stack allocation and malloc

of EVP_MD_CTX structures by EVP_MD_CTX_create() to avoid binary

incompatibility issues if the size of EVP_MD_CTX structure change.

EVP_MD_CTX_destroy() was used for freeing resources.

diff --git a/src/tcs/crypto/openssl/crypto.c b/src/tcs/crypto/openssl/crypto.c

index c02db27..ac42541 100644

--- a/src/tcs/crypto/openssl/crypto.c

+++ b/src/tcs/crypto/openssl/crypto.c

@@ -31,13 +31,15 @@

TSS_RESULT

Hash(UINT32 HashType, UINT32 BufSize, BYTE* Buf, BYTE* Digest)

{

-EVP_MD_CTX md_ctx;

+EVP_MD_CTX *md_ctx;

unsigned int result_size;

int rv;

+md_ctx = EVP_MD_CTX_create();

switch (HashType) {

case TSS_HASH_SHA1:

-rv = EVP_DigestInit(&md_ctx, EVP_sha1());

+rv = EVP_DigestInit(md_ctx, EVP_sha1());

break;

default:

rv = TCSERR(TSS_E_BAD_PARAMETER);

@@ -50,19 +52,20 @@ Hash(UINT32 HashType, UINT32 BufSize, BYTE* Buf, BYTE* Digest)

goto out;

}

-rv = EVP_DigestUpdate(&md_ctx, Buf, BufSize);

+rv = EVP_DigestUpdate(md_ctx, Buf, BufSize);

if (rv != EVP_SUCCESS) {

rv = TCSERR(TSS_E_INTERNAL_ERROR);

goto out;

}

-result_size = EVP_MD_CTX_size(&md_ctx);

-rv = EVP_DigestFinal(&md_ctx, Digest, &result_size);

+result_size = EVP_MD_CTX_size(md_ctx);

+rv = EVP_DigestFinal(md_ctx, Digest, &result_size);

if (rv != EVP_SUCCESS) {

rv = TCSERR(TSS_E_INTERNAL_ERROR);

} else

rv = TSS_SUCCESS;

out:

+EVP_MD_CTX_destroy(md_ctx);

return rv;

}

diff --git a/src/trspi/crypto/openssl/hash.c b/src/trspi/crypto/openssl/hash.c

index f6cf3dc..f2a1f0e 100644

--- a/src/trspi/crypto/openssl/hash.c

+++ b/src/trspi/crypto/openssl/hash.c

@@ -56,13 +56,15 @@ int MGF1(unsigned char *, long, const unsigned char *, long);

TSS_RESULT

Trspi_Hash(UINT32 HashType, UINT32 BufSize, BYTE* Buf, BYTE* Digest)

{

-EVP_MD_CTX md_ctx;

+EVP_MD_CTX *md_ctx;

unsigned int result_size;

int rv;

+md_ctx = EVP_MD_CTX_create();

switch (HashType) {

case TSS_HASH_SHA1:

-rv = EVP_DigestInit(&md_ctx, EVP_sha1());

+rv = EVP_DigestInit(md_ctx, EVP_sha1());

break;

default:

rv = TSPERR(TSS_E_BAD_PARAMETER);

@@ -75,14 +77,14 @@ Trspi_Hash(UINT32 HashType, UINT32 BufSize, BYTE* Buf, BYTE* Digest)

goto err;

}

-rv = EVP_DigestUpdate(&md_ctx, Buf, BufSize);

+rv = EVP_DigestUpdate(md_ctx, Buf, BufSize);

if (rv != EVP_SUCCESS) {

rv = TSPERR(TSS_E_INTERNAL_ERROR);

goto err;

}

-result_size = EVP_MD_CTX_size(&md_ctx);

-rv = EVP_DigestFinal(&md_ctx, Digest, &result_size);

+result_size = EVP_MD_CTX_size(md_ctx);

+rv = EVP_DigestFinal(md_ctx, Digest, &result_size);

if (rv != EVP_SUCCESS) {

rv = TSPERR(TSS_E_INTERNAL_ERROR);

goto err;

@@ -94,6 +96,7 @@ Trspi_Hash(UINT32 HashType, UINT32 BufSize, BYTE* Buf, BYTE* Digest)

err:

DEBUG_print_openssl_errors();

out:

+EVP_MD_CTX_destroy(md_ctx);

return rv;

}

@@ -112,7 +115,7 @@ Trspi_HashInit(Trspi_HashCtx *ctx, UINT32 HashType)

break;

}

-if ((ctx->ctx = malloc(sizeof(EVP_MD_CTX))) == NULL)

+if ((ctx->ctx = EVP_MD_CTX_create()) == NULL)

return TSPERR(TSS_E_OUTOFMEMORY);

rv = EVP_DigestInit((EVP_MD_CTX *)ctx->ctx, (const EVP_MD *)md);

diff --git a/src/tspi/daa/daa_issuer/issue_credential.c b/src/tspi/daa/daa_issuer/issue_credential.c

index 0602dcb..4d07b08 100644

--- a/src/tspi/daa/daa_issuer/issue_credential.c

+++ b/src/tspi/daa/daa_issuer/issue_credential.c

@@ -46,7 +46,7 @@ void compute_prime( bi_ptr e, int length, int interval) {

TSS_RESULT verify_authentificity(TSS_DAA_CREDENTIAL_REQUEST *credentialRequest,

TSS_DAA_JOIN_ISSUER_SESSION *joinSession) {

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

BYTE *modulus_N0_bytes;

BYTE *digest_n0;

BYTE *contextHash;

@@ -82,21 +82,22 @@ TSS_RESULT verify_authentificity(TSS_DAA_CREDENTIAL_REQUEST *credentialRequest,

TPM_DAA_SIZE_issuerModulus*8, DAA_PARAM_KEY_SIZE);

return TSS_E_INTERNAL_ERROR;

}

-EVP_DigestInit(&mdctx, DAA_PARAM_get_message_digest());

+mdctx = EVP_MD_CTX_create();

+EVP_DigestInit(mdctx, DAA_PARAM_get_message_digest());

// digestN0 = hash( modulus_N0) see Appendix B of spec. and TPM join stage 7 and 8

-EVP_DigestUpdate(&mdctx, modulus_N0_bytes, TPM_DAA_SIZE_issuerModulus);

-digest_n0Length = EVP_MD_CTX_size(&mdctx);

+EVP_DigestUpdate(mdctx, modulus_N0_bytes, TPM_DAA_SIZE_issuerModulus);

+digest_n0Length = EVP_MD_CTX_size(mdctx);

digest_n0 = (BYTE *)malloc( digest_n0Length);

if (digest_n0 == NULL) {

LogError("malloc of %d bytes failed", digest_n0Length);

result = TSPERR(TSS_E_OUTOFMEMORY);

goto close;

}

-EVP_DigestFinal(&mdctx, digest_n0, NULL);

+EVP_DigestFinal(mdctx, digest_n0, NULL);

// test if credentialRequest->authenticationProof =

//H( H( U, daaCount, H(n0), joinSession->nonceEncrypted))

-EVP_DigestInit(&mdctx, DAA_PARAM_get_message_digest());

+EVP_DigestInit(mdctx, DAA_PARAM_get_message_digest());

// enlarge capitalU to 256 (TPM_DAA_SIZE_issuerModulus)

// allocation

capitalUPrime = bi_set_as_nbin( joinSession->capitalUprimeLength, joinSession->capitalUprime);

@@ -107,36 +108,36 @@ TSS_RESULT verify_authentificity(TSS_DAA_CREDENTIAL_REQUEST *credentialRequest,

goto close;

}

bi_2_byte_array( capitalUPrime_bytes, TPM_DAA_SIZE_issuerModulus, capitalUPrime);

-EVP_DigestUpdate(&mdctx, capitalUPrime_bytes, TPM_DAA_SIZE_issuerModulus);

+EVP_DigestUpdate(mdctx, capitalUPrime_bytes, TPM_DAA_SIZE_issuerModulus);

bi_free_ptr( capitalUPrime);

daaCount = htonl( joinSession->daaCounter);

-EVP_DigestUpdate(&mdctx, &daaCount, sizeof(UINT32));

-EVP_DigestUpdate(&mdctx, digest_n0, digest_n0Length);

-contextHashLength = EVP_MD_CTX_size(&mdctx);

+EVP_DigestUpdate(mdctx, &daaCount, sizeof(UINT32));

+EVP_DigestUpdate(mdctx, digest_n0, digest_n0Length);

+contextHashLength = EVP_MD_CTX_size(mdctx);

contextHash = (BYTE *)malloc( contextHashLength);

if (contextHash == NULL) {

LogError("malloc of %d bytes failed", contextHashLength);

result = TSPERR(TSS_E_OUTOFMEMORY);

goto close;

}

-EVP_DigestFinal(&mdctx, contextHash, NULL);

-EVP_DigestInit(&mdctx, DAA_PARAM_get_message_digest());

+EVP_DigestFinal(mdctx, contextHash, NULL);

+EVP_DigestInit(mdctx, DAA_PARAM_get_message_digest());

LogDebug("PK(0).n=%s", dump_byte_array( TPM_DAA_SIZE_issuerModulus, modulus_N0_bytes));

LogDebug("digestN0h=%s", dump_byte_array( digest_n0Length, digest_n0));

LogDebug("UPrime=%s", dump_byte_array( TPM_DAA_SIZE_issuerModulus, capitalUPrime_bytes));

LogDebug("daaCount=%4x", daaCount);

LogDebug("contextHash[%d]=%s", contextHashLength, dump_byte_array( contextHashLength, contextHash));

-EVP_DigestUpdate(&mdctx, contextHash, contextHashLength);

-EVP_DigestUpdate(&mdctx, joinSession->nonceEncrypted, joinSession->nonceEncryptedLength);

-hashLength = EVP_MD_CTX_size(&mdctx);

+EVP_DigestUpdate(mdctx, contextHash, contextHashLength);

+EVP_DigestUpdate(mdctx, joinSession->nonceEncrypted, joinSession->nonceEncryptedLength);

+hashLength = EVP_MD_CTX_size(mdctx);

hash = (BYTE *)malloc( hashLength);

if (hash == NULL) {

LogError("malloc of %d bytes failed", hashLength);

result = TSPERR(TSS_E_OUTOFMEMORY);

goto close;

}

-EVP_DigestFinal(&mdctx, hash, NULL);

+EVP_DigestFinal(mdctx, hash, NULL);

if( credentialRequest->authenticationProofLength != hashLength ||

memcmp( credentialRequest->authenticationProof, hash, hashLength) != 0) {

LogError("Verification of authenticationProof failed - Step 2.b");

@@ -153,6 +154,7 @@ TSS_RESULT verify_authentificity(TSS_DAA_CREDENTIAL_REQUEST *credentialRequest,

LogDebug("verify_authenticity Done:%s",

dump_byte_array( hashLength, hash));

close:

+EVP_MD_CTX_destroy(mdctx);

free( contextHash);

free( digest_n0);

free( capitalUPrime_bytes);

@@ -169,7 +171,7 @@ compute_join_challenge_issuer( TSS_DAA_PK_internal *pk_intern,

BYTE *nonceReceiver,

UINT32 *c_primeLength,

BYTE **c_prime) { // out allocation

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

BYTE *encoded_pk;

BYTE *byte_array;

UINT32 encoded_pkLength;

@@ -179,12 +181,13 @@ compute_join_challenge_issuer( TSS_DAA_PK_internal *pk_intern,

LogError("malloc of %d bytes failed", DAA_PARAM_SIZE_RND_VALUE_CERTIFICATE / 8);

return TSPERR(TSS_E_OUTOFMEMORY);

}

-EVP_DigestInit(&mdctx, DAA_PARAM_get_message_digest());

+mdctx = EVP_MD_CTX_create();

+EVP_DigestInit(mdctx, DAA_PARAM_get_message_digest());

encoded_pk = encoded_DAA_PK_internal( &encoded_pkLength, pk_intern);

-EVP_DigestUpdate(&mdctx, encoded_pk, encoded_pkLength);

+EVP_DigestUpdate(mdctx, encoded_pk, encoded_pkLength);

LogDebug( "issuerPk: %s", dump_byte_array( encoded_pkLength, encoded_pk));

bi_2_byte_array( byte_array, DAA_PARAM_SIZE_RND_VALUE_CERTIFICATE / 8, v_prime_prime);

-EVP_DigestUpdate(&mdctx, byte_array, DAA_PARAM_SIZE_RND_VALUE_CERTIFICATE / 8);

+EVP_DigestUpdate(mdctx, byte_array, DAA_PARAM_SIZE_RND_VALUE_CERTIFICATE / 8);

LogDebug( "vPrimePrime: %s",

dump_byte_array( DAA_PARAM_SIZE_RND_VALUE_CERTIFICATE / 8, byte_array));

free( byte_array);

@@ -195,16 +198,16 @@ compute_join_challenge_issuer( TSS_DAA_PK_internal *pk_intern,

return TSPERR(TSS_E_OUTOFMEMORY);

}

bi_2_byte_array( byte_array, DAA_PARAM_SIZE_RSA_MODULUS / 8, capitalA);

-EVP_DigestUpdate(&mdctx, byte_array, DAA_PARAM_SIZE_RSA_MODULUS / 8);

+EVP_DigestUpdate(mdctx, byte_array, DAA_PARAM_SIZE_RSA_MODULUS / 8);

LogDebug( "capitalA: %s", dump_byte_array( DAA_PARAM_SIZE_RSA_MODULUS / 8, byte_array));

bi_2_byte_array( byte_array, DAA_PARAM_SIZE_RSA_MODULUS / 8, capital_Atilde);

-EVP_DigestUpdate(&mdctx, byte_array, DAA_PARAM_SIZE_RSA_MODULUS / 8);

+EVP_DigestUpdate(mdctx, byte_array, DAA_PARAM_SIZE_RSA_MODULUS / 8);

LogDebug( "capital_Atilde: %s",

dump_byte_array( DAA_PARAM_SIZE_RSA_MODULUS / 8, byte_array));

-EVP_DigestUpdate(&mdctx, nonceReceiver, nonceReceiverLength);

+EVP_DigestUpdate(mdctx, nonceReceiver, nonceReceiverLength);

LogDebug( "nonceReceiver: %s",

dump_byte_array( nonceReceiverLength, nonceReceiver));

-*c_primeLength = EVP_MD_CTX_size(&mdctx);

+*c_primeLength = EVP_MD_CTX_size(mdctx);

*c_prime = (BYTE *)malloc( *c_primeLength);

if (*c_prime == NULL) {

LogError("malloc of %d bytes failed", *c_primeLength);

@@ -212,7 +215,8 @@ compute_join_challenge_issuer( TSS_DAA_PK_internal *pk_intern,

return TSPERR(TSS_E_OUTOFMEMORY);

}

LogDebug( "c_prime: %s", dump_byte_array( *c_primeLength, *c_prime));

-EVP_DigestFinal(&mdctx, *c_prime, NULL);

+EVP_DigestFinal(mdctx, *c_prime, NULL);

+EVP_MD_CTX_destroy(mdctx);

free( byte_array);

return TSS_SUCCESS;

}

@@ -306,7 +310,7 @@ TSPICALL Tspi_DAA_IssueCredential_internal

TSS_DAA_PK_internal *pk_intern;

TSS_DAA_PRIVATE_KEY *private_key;

UINT32 i, chLength, challengeLength, length, interval;

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

BYTE *ch = NULL, *challenge = NULL;

tmp1 = bi_new_ptr();

@@ -515,17 +519,18 @@ TSPICALL Tspi_DAA_IssueCredential_internal

&ch);// out allocation

if( result != TSS_SUCCESS) goto close;

LogDebug("JoinChallengeHost: %s", dump_byte_array( chLength, ch));

-EVP_DigestInit(&mdctx, DAA_PARAM_get_message_digest());

-EVP_DigestUpdate(&mdctx, ch, chLength);

-challengeLength = EVP_MD_CTX_size( &mdctx);

+mdctx = EVP_MD_CTX_create();

+EVP_DigestInit(mdctx, DAA_PARAM_get_message_digest());

+EVP_DigestUpdate(mdctx, ch, chLength);

+challengeLength = EVP_MD_CTX_size(mdctx);

challenge = (BYTE *)malloc( challengeLength);

if( challenge == NULL) {

LogError("malloc of %d bytes failed", challengeLength);

result = TSPERR(TSS_E_OUTOFMEMORY);

goto close;

}

-EVP_DigestUpdate(&mdctx, credentialRequest.nonceTpm, credentialRequest.nonceTpmLength);

-EVP_DigestFinal(&mdctx, challenge, NULL);

+EVP_DigestUpdate(mdctx, credentialRequest.nonceTpm, credentialRequest.nonceTpmLength);

+EVP_DigestFinal(mdctx, challenge, NULL);

// checks

if( credentialRequest.challengeLength != challengeLength ||

memcmp( credentialRequest.challenge, challenge, challengeLength)!=0) {

@@ -751,6 +756,7 @@ TSPICALL Tspi_DAA_IssueCredential_internal

bi_2_nbin1( &(credIssuer->sELength), credIssuer->sE, s_e);

close:

+EVP_MD_CTX_destroy(mdctx);

//free_TSS_DAA_PK( daa_pk_extern);

if( ch != NULL) free( ch);

if( challenge != NULL) free( challenge);

diff --git a/src/tspi/daa/daa_issuer/key_correctness_proof.c b/src/tspi/daa/daa_issuer/key_correctness_proof.c

index 505e760..d82f2d1 100644

--- a/src/tspi/daa/daa_issuer/key_correctness_proof.c

+++ b/src/tspi/daa/daa_issuer/key_correctness_proof.c

@@ -87,7 +87,7 @@ generateMessageDigest(BYTE *md_value,

bi_array_ptr *commitments,

const int commitments_size

) {

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

const EVP_MD *md;

int i, j;

int length = DAA_PARAM_SIZE_RSA_MODULUS / 8;

@@ -101,52 +101,52 @@ generateMessageDigest(BYTE *md_value,

}

OpenSSL_add_all_digests();

md = EVP_get_digestbyname( DAA_PARAM_MESSAGE_DIGEST_ALGORITHM);

-EVP_MD_CTX_init(&mdctx);

-EVP_DigestInit_ex(&mdctx, md, NULL);

+EVP_MD_CTX_create(mdctx);

+EVP_DigestInit_ex(mdctx, md, NULL);

#ifdef DAA_DEBUG

fprintf(stderr, "modulus=%s\n", bi_2_hex_char( pk->modulus));

#endif

toByteArray( array, length, pk->modulus,

"!! [generateMessageDigest modulus] current_size=%d length=%d\n");

-EVP_DigestUpdate(&mdctx, array , length);

+EVP_DigestUpdate(mdctx, array , length);

toByteArray( array, length, pk->capitalS,

"!! [generateMessageDigest capitalS] current_size=%d length=%d\n");

-EVP_DigestUpdate(&mdctx, array , length);

+EVP_DigestUpdate(mdctx, array , length);

// add capitalZ, capitalR0, capitalR1, capitalY

LogDebug("capitalZ capitalR0 capitalY");

toByteArray( array, length, pk->capitalZ,

"!! [generateMessageDigest capitalZ] current_size=%d length=%d\n");

-EVP_DigestUpdate(&mdctx, array , length);

+EVP_DigestUpdate(mdctx, array , length);

toByteArray( array, length, pk->capitalR0,

"!! [generateMessageDigest capitalR0] current_size=%d length=%d\n");

-EVP_DigestUpdate(&mdctx, array , length);

+EVP_DigestUpdate(mdctx, array , length);

toByteArray( array, length, pk->capitalR1,

"!! [generateMessageDigest capitalR1] current_size=%d length=%d\n");

-EVP_DigestUpdate(&mdctx, array , length);

+EVP_DigestUpdate(mdctx, array , length);

// CAPITAL Y ( capitalRReceiver )

LogDebug("capitalRReceiver");

for( i=0; icapitalRReceiver->length; i++) {

toByteArray( array, length, pk->capitalRReceiver->array[i],

"!![generateMessageDigest capitalRReceiver] current_size=%d length=%d\n");

-EVP_DigestUpdate(&mdctx, array , length);

+EVP_DigestUpdate(mdctx, array , length);

}

LogDebug("capitalRIssuer");

// CAPITAL Y ( capitalRIssuer)

for( i=0; icapitalRIssuer->length; i++) {

toByteArray( array, length, pk->capitalRIssuer->array[i],

"!![generateMessageDigest capitalRReceiver] current_size=%d length=%d\n");

-EVP_DigestUpdate(&mdctx, array , length);

+EVP_DigestUpdate(mdctx, array , length);

}

LogDebug("commitments");

for( i=0; i

for( j=0; jlength; j++) {

toByteArray( array, length, commitments[i]->array[j],

"!! [generateMessageDigest commitments] current_size=%d length=%d\n");

-EVP_DigestUpdate(&mdctx, array , length);

+EVP_DigestUpdate(mdctx, array , length);

}

-EVP_DigestFinal_ex(&mdctx, md_value, md_len);

-EVP_MD_CTX_cleanup(&mdctx);

+EVP_DigestFinal_ex(mdctx, md_value, md_len);

+EVP_MD_CTX_destroy(mdctx);

free( array);

return TSS_SUCCESS;

}

diff --git a/src/tspi/daa/daa_platform/platform.c b/src/tspi/daa/daa_platform/platform.c

index 80180ca..f550d49 100644

--- a/src/tspi/daa/daa_platform/platform.c

+++ b/src/tspi/daa/daa_platform/platform.c

@@ -788,7 +788,7 @@ compute_join_challenge_host(TSS_HDAA hDAA,

BYTE* nonceIssuer,

UINT32 *resultLength,

BYTE **result) {

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

BYTE *encoded_pk = NULL, *buffer;

UINT32 encoded_pkLength;

int rv, length;

@@ -798,15 +798,16 @@ compute_join_challenge_host(TSS_HDAA hDAA,

LogError("malloc of %d bytes failed", 10000);

return TSPERR(TSS_E_OUTOFMEMORY);

}

-// EVP_MD_CTX_init(&mdctx);

-rv = EVP_DigestInit(&mdctx, DAA_PARAM_get_message_digest());

+mdctx = EVP_MD_CTX_create();

+rv = EVP_DigestInit(mdctx, DAA_PARAM_get_message_digest());

if (rv != EVP_SUCCESS) goto err;

// allocation

encoded_pk = encoded_DAA_PK_internal( &encoded_pkLength, pk_internal);

LogDebug("encoded issuerPk[%d]: %s",

encoded_pkLength,

dump_byte_array( encoded_pkLength, encoded_pk));

-rv = EVP_DigestUpdate(&mdctx, encoded_pk, encoded_pkLength);

+rv = EVP_DigestUpdate(mdctx, encoded_pk, encoded_pkLength);

if (rv != EVP_SUCCESS) goto err;

// capitalU

length = DAA_PARAM_SIZE_RSA_MODULUS / 8;

@@ -814,28 +815,28 @@ compute_join_challenge_host(TSS_HDAA hDAA,

LogDebug("capitalU[%ld]: %s",

bi_nbin_size(capitalU) ,

dump_byte_array( length, buffer));

-rv = EVP_DigestUpdate(&mdctx, buffer, length);

+rv = EVP_DigestUpdate(mdctx, buffer, length);

if (rv != EVP_SUCCESS) goto err;

// capital UPrime

bi_2_byte_array( buffer, length, capital_Uprime);

LogDebug("capitalUPrime[%d]: %s",

length,

dump_byte_array( length, buffer));

-rv = EVP_DigestUpdate(&mdctx, buffer, length);

+rv = EVP_DigestUpdate(mdctx, buffer, length);

if (rv != EVP_SUCCESS) goto err;

// capital Utilde

bi_2_byte_array( buffer, length, capital_utilde);

LogDebug("capitalUTilde[%d]: %s",

length,

dump_byte_array( length, buffer));

-rv = EVP_DigestUpdate(&mdctx, buffer, length);

+rv = EVP_DigestUpdate(mdctx, buffer, length);

if (rv != EVP_SUCCESS) goto err;

// capital UtildePrime

bi_2_byte_array( buffer, length, capital_utilde_prime);

LogDebug("capital_utilde_prime[%d]: %s",

length,

dump_byte_array( length, buffer));

-rv = EVP_DigestUpdate(&mdctx, buffer, length);

+rv = EVP_DigestUpdate(mdctx, buffer, length);

if (rv != EVP_SUCCESS) goto err;

//capital_ni

length = DAA_PARAM_SIZE_MODULUS_GAMMA / 8;

@@ -843,22 +844,22 @@ compute_join_challenge_host(TSS_HDAA hDAA,

LogDebug("capital_ni[%d]: %s",

length,

dump_byte_array( length, buffer));

-rv = EVP_DigestUpdate(&mdctx, buffer, length);

+rv = EVP_DigestUpdate(mdctx, buffer, length);

if (rv != EVP_SUCCESS) goto err;

//capital_ni_tilde

bi_2_byte_array( buffer, length, capital_ni_tilde);

LogDebug("capital_ni_tilde[%d]: %s",

length,

dump_byte_array( length, buffer));

-rv = EVP_DigestUpdate(&mdctx, buffer, length);

+rv = EVP_DigestUpdate(mdctx, buffer, length);

if (rv != EVP_SUCCESS) goto err;

// TODO: commitments

LogDebug("nonceIssuer[%d]: %s",

nonceIssuerLength,

dump_byte_array( nonceIssuerLength, nonceIssuer));

-rv = EVP_DigestUpdate(&mdctx, nonceIssuer, nonceIssuerLength);

+rv = EVP_DigestUpdate(mdctx, nonceIssuer, nonceIssuerLength);

if (rv != EVP_SUCCESS) goto err;

-*resultLength = EVP_MD_CTX_size(&mdctx);

+*resultLength = EVP_MD_CTX_size(mdctx);

*result = (BYTE *)malloc( *resultLength);

if (*result == NULL) {

LogError("malloc of %d bytes failed", *resultLength);

@@ -866,12 +867,14 @@ compute_join_challenge_host(TSS_HDAA hDAA,

free( encoded_pk);

return TSPERR(TSS_E_OUTOFMEMORY);

}

-rv = EVP_DigestFinal(&mdctx, *result, NULL);

+rv = EVP_DigestFinal(mdctx, *result, NULL);

if (rv != EVP_SUCCESS) goto err;

+EVP_MD_CTX_destroy(mdctx);

free( buffer);

free( encoded_pk);

return TSS_SUCCESS;

err:

+EVP_MD_CTX_destroy(mdctx);

free( buffer);

free( encoded_pk);

DEBUG_print_openssl_errors();

@@ -933,7 +936,7 @@ Tspi_TPM_DAA_JoinCreateDaaPubKey_internal(

BYTE *ch = NULL;

BYTE *c_byte, *noncePlatform, *nonce_tpm;

BYTE *internal_cbyte = NULL;

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

if( tmp1 == NULL || tmp2 == NULL || capital_utilde == NULL ||

v_tilde_prime == NULL || rv_tilde_prime == NULL ||

@@ -1271,23 +1274,24 @@ Tspi_TPM_DAA_JoinCreateDaaPubKey_internal(

}

// verify computation of c by TPM

-EVP_DigestInit(&mdctx, DAA_PARAM_get_message_digest());

-EVP_DigestUpdate(&mdctx, ch, chLength);

-EVP_DigestUpdate(&mdctx, nonce_tpm, nonce_tpmLength);

+mdctx = EVP_MD_CTX_create();

+EVP_DigestInit(mdctx, DAA_PARAM_get_message_digest());

+EVP_DigestUpdate(mdctx, ch, chLength);

+EVP_DigestUpdate(mdctx, nonce_tpm, nonce_tpmLength);

nonce_tpm = convert_alloc( tcsContext, nonce_tpmLength, nonce_tpm); // allocation

if( nonce_tpm == NULL) {

LogError("malloc of %d bytes failed", nonce_tpmLength);

result = TSPERR(TSS_E_OUTOFMEMORY);

goto close;

}

-internal_cbyteLength = EVP_MD_CTX_size(&mdctx);

+internal_cbyteLength = EVP_MD_CTX_size(mdctx);

internal_cbyte = (BYTE *)malloc( internal_cbyteLength);

if( internal_cbyte == NULL) {

LogError("malloc of %d bytes failed", internal_cbyteLength);

result = TSPERR(TSS_E_OUTOFMEMORY);

goto close;

}

-EVP_DigestFinal(&mdctx, internal_cbyte, NULL);

+EVP_DigestFinal(mdctx, internal_cbyte, NULL);

if( c_byteLength != internal_cbyteLength ||

memcmp( c_byte, internal_cbyte, c_byteLength) != 0) {

LogError( "Computation of c in TPM DAA Join command is incorrect. Affected stages: 16,20\n");

@@ -1483,6 +1487,7 @@ Tspi_TPM_DAA_JoinCreateDaaPubKey_internal(

}

credentialRequest->sALength = sa->length;

close:

+EVP_MD_CTX_destroy(mdctx);

if( capitalSprime_byte_array!=NULL) free( capitalSprime_byte_array);

if( ch!=NULL) free( ch);

if( internal_cbyte != NULL) free( internal_cbyte);

diff --git a/src/tspi/daa/daa_platform/test_join.c b/src/tspi/daa/daa_platform/test_join.c

index a244d85..18edd64 100644

--- a/src/tspi/daa/daa_platform/test_join.c

+++ b/src/tspi/daa/daa_platform/test_join.c

@@ -75,15 +75,15 @@ int sign( BYTE *buffer_2_sign,

BYTE *signature,

int *len_signature

) {

-EVP_MD_CTX ctx;

+EVP_MD_CTX *ctx;

int len_message = EVP_MD_size( EVP_sha1()), current_len_message;

BYTE *message = (BYTE *)malloc( len_message);

int ret;

-EVP_MD_CTX_init(&ctx);

-EVP_DigestInit_ex(&ctx, EVP_sha1(), NULL);

-EVP_DigestUpdate(&ctx, buffer_2_sign, len_buffer_2_sign);

-EVP_DigestFinal_ex(&ctx, message, &current_len_message);

+ctx = EVP_MD_CTX_create();

+EVP_DigestInit_ex(ctx, EVP_sha1(), NULL);

+EVP_DigestUpdate(ctx, buffer_2_sign, len_buffer_2_sign);

+EVP_DigestFinal_ex(ctx, message, &current_len_message);

LogDebug("Sign rsa-> with message (length=%d)", current_len_message);

//int RSA_sign(int type, unsigned char *m, unsigned int m_len,

// unsigned char *sigret, unsigned int *siglen, RSA *rsa);

@@ -92,7 +92,7 @@ int sign( BYTE *buffer_2_sign,

LogError("Error in RSA_sign: %s", ERR_error_string( ERR_get_error(), NULL));

}

LogDebug("Sign rsa-> signature (length=%d)", *len_signature );

-EVP_MD_CTX_cleanup(&ctx);

+EVP_MD_CTX_destroy(ctx);

free( message);

return ret;

}

@@ -108,11 +108,11 @@ static int init_key_chain(int length_key_chain, Issuer *issuer) {

unsigned long e = 65537;

RSA *rsa;

bi_ptr bi;

-EVP_MD_CTX ctx;

+EVP_MD_CTX *ctx;

int len_message = EVP_MD_size( EVP_sha1());

int current_len_message;

-EVP_MD_CTX_init(&ctx);

+EVP_MD_CTX_create(ctx);

message = (BYTE *)malloc(len_message);

if( length_key_chain < 1) {

free( message);

@@ -141,9 +141,9 @@ static int init_key_chain(int length_key_chain, Issuer *issuer) {

bi_2_byte_array( modulus, DAA_PARAM_KEY_SIZE / 8, bi);

LogDebug("bi=%s", bi_2_hex_char( bi));

bi_free_ptr( bi);

-EVP_DigestInit_ex(&ctx, EVP_sha1(), NULL);

-EVP_DigestUpdate(&ctx, modulus, DAA_PARAM_KEY_SIZE / 8);

-EVP_DigestFinal_ex(&ctx, message, &current_len_message);

+EVP_DigestInit_ex(ctx, EVP_sha1(), NULL);

+EVP_DigestUpdate(ctx, modulus, DAA_PARAM_KEY_SIZE / 8);

+EVP_DigestFinal_ex(ctx, message, &current_len_message);

ret = RSA_sign( NID_sha1, message, current_len_message,

signature, &len_sign, issuer->key_chain[i-1]);

if( ret == 0) {

@@ -165,13 +165,13 @@ static int init_key_chain(int length_key_chain, Issuer *issuer) {

}

free( message);

-EVP_MD_CTX_cleanup(&ctx);

+EVP_MD_CTX_destroy(ctx);

return 0;

}

Issuer* initIssuer(int length_key_chain, char *filename, char *exec, TSS_HCONTEXT hContext) {

FILE *file;

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

Issuer *issuer = (Issuer *)malloc(sizeof( Issuer));

TPM_DAA_ISSUER *tpm_daa_issuer;

bi_ptr modulus_N0;

@@ -231,25 +231,25 @@ Issuer* initIssuer(int length_key_chain, char *filename, char *exec, TSS_HCONTEX

return NULL;

}

-EVP_MD_CTX_init(&mdctx);

-EVP_DigestInit_ex(&mdctx, DAA_PARAM_get_message_digest(), NULL);

+EVP_MD_CTX_create(mdctx);

+EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL);

// digestN0 = hash( modulus_N0)

-EVP_DigestUpdate(&mdctx, modulus_N0_bytes, TPM_DAA_SIZE_issuerModulus);

-digest_n0 = (BYTE *)malloc( EVP_MD_CTX_size(&mdctx));

-EVP_DigestFinal_ex(&mdctx, digest_n0, NULL);

+EVP_DigestUpdate(mdctx, modulus_N0_bytes, TPM_DAA_SIZE_issuerModulus);

+digest_n0 = (BYTE *)EVP_MD_CTX_create();

+EVP_DigestFinal_ex(mdctx, digest_n0, NULL);

tpm_daa_issuer = convert2issuer_settings( issuer->pk);

issuer_settings_byte_array = issuer_2_byte_array( tpm_daa_issuer, &len_issuer_settings);

// data to sign: concatenation of digest_n0 and issuer_settings_byte_array

-sign_data = (BYTE *)malloc( EVP_MD_CTX_size(&mdctx) + len_issuer_settings);

-memcpy( sign_data, digest_n0, EVP_MD_CTX_size(&mdctx));

-memcpy( &sign_data[EVP_MD_CTX_size(&mdctx)],

+sign_data = (BYTE *)malloc( EVP_MD_CTX_size(mdctx) + len_issuer_settings);

+memcpy( sign_data, digest_n0, EVP_MD_CTX_size(mdctx));

+memcpy( &sign_data[EVP_MD_CTX_size(mdctx)],

issuer_settings_byte_array,

len_issuer_settings);

free( issuer_settings_byte_array);

// sign digest of TPM compatible Issuer key (sign_data)

private_nn = issuer->key_chain[issuer->length_key_chain - 1];

signature = (BYTE *)malloc( RSA_size(private_nn));

-if ( sign( sign_data, EVP_MD_CTX_size(&mdctx) + len_issuer_settings,

+if ( sign( sign_data, EVP_MD_CTX_size(mdctx) + len_issuer_settings,

private_nn,

signature,

&len_signature) ==0) {

@@ -262,16 +262,17 @@ Issuer* initIssuer(int length_key_chain, char *filename, char *exec, TSS_HCONTEX

dump_byte_array(EVP_MD_size( EVP_sha1()),

signature));

// TODO sign the complete public key of TPM compatible Issuer key

-/*EVP_DigestInit_ex(&mdctx, DAA_PARAM_get_message_digest(), NULL);

-EVP_DigestUpdate(&mdctx, digest_n0, EVP_MD_CTX_size(&mdctx));

+/*EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL);

+EVP_DigestUpdate(mdctx, digest_n0, EVP_MD_CTX_size(mdctx));

pk_encoded = encoded_DAA_PK_internal( &pk_encodedLength, issuer->pk);

-EVP_DigestUpdate(&mdctx, pk_encoded, pk_encodedLength);

-EVP_DigestFinal(&mdctx, , NULL);

+EVP_DigestUpdate(mdctx, pk_encoded, pk_encodedLength);

+EVP_DigestFinal(mdctx, , NULL);

signature = (BYTE *)malloc( EVP_MD_size( EVP_sha1()));

-if (sign( sign_data, EVP_MD_CTX_size(&mdctx) + len_issuer_settings,

+if (sign( sign_data, EVP_MD_CTX_size(mdctx) + len_issuer_settings,

private_nn, signature, &len_signature) !=0) goto close;

close:

+EVP_MD_CTX_destroy(mdctx);

free( digest_n0);

free( sign_data);

return issuer;

diff --git a/src/tspi/daa/daa_structs.c b/src/tspi/daa/daa_structs.c

index 787d5d0..5bab820 100644

--- a/src/tspi/daa/daa_structs.c

+++ b/src/tspi/daa/daa_structs.c

@@ -818,66 +818,66 @@ TPM_DAA_ISSUER *

convert2issuer_settings(TSS_DAA_PK_internal *pk_internal)

{

TPM_DAA_ISSUER *result = (TPM_DAA_ISSUER *)malloc(sizeof(TPM_DAA_ISSUER));

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

UINT32 length;

BYTE *array = (BYTE*)malloc((DAA_PARAM_SIZE_RSA_MODULUS+7)/8);

LogDebug("convert2issuer_settings");

-EVP_MD_CTX_init(&mdctx);

+EVP_MD_CTX_create(mdctx);

// TAG

result->tag = htons( TPM_TAG_DAA_ISSUER);

// capitalR0

-EVP_DigestInit(&mdctx, DAA_PARAM_get_message_digest());

+EVP_DigestInit(mdctx, DAA_PARAM_get_message_digest());

-EVP_DigestInit_ex(&mdctx, DAA_PARAM_get_message_digest(), NULL);

+EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL);

bi_2_byte_array( array,

length = (bi_length( pk_internal->capitalR0)+7)/8,

pk_internal->capitalR0);

LogDebug("capitalR0 length=%d", length);

-EVP_DigestUpdate(&mdctx, array, length);

-EVP_DigestFinal_ex(&mdctx, (BYTE *)&(result->DAA_digest_R0), NULL);

+EVP_DigestUpdate(mdctx, array, length);

+EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_R0), NULL);

// capitalR1

-EVP_DigestInit_ex(&mdctx, DAA_PARAM_get_message_digest(), NULL);

+EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL);

bi_2_byte_array( array,

length = (bi_length( pk_internal->capitalR1)+7)/8,

pk_internal->capitalR1);

LogDebug("capitalR1 length=%d", length);

-EVP_DigestUpdate(&mdctx, array, length);

-EVP_DigestFinal_ex(&mdctx, (BYTE *)&(result->DAA_digest_R1), NULL);

+EVP_DigestUpdate(mdctx, array, length);

+EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_R1), NULL);

// capitalS (S0)

-EVP_DigestInit_ex(&mdctx, DAA_PARAM_get_message_digest(), NULL);

+EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL);

bi_2_byte_array( array,

length = (bi_length( pk_internal->capitalS)+7)/8,

pk_internal->capitalS);

LogDebug("capitalS length=%d", length);

-EVP_DigestUpdate(&mdctx, array, length);

-EVP_DigestFinal_ex(&mdctx, (BYTE *)&(result->DAA_digest_S0), NULL);

+EVP_DigestUpdate(mdctx, array, length);

+EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_S0), NULL);

// capitalSprime (S1)

-EVP_DigestInit_ex(&mdctx, DAA_PARAM_get_message_digest(), NULL);

+EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL);

bi_2_byte_array( array,

length = (bi_length( pk_internal->capitalSprime)+7)/8,

pk_internal->capitalSprime);

LogDebug("capitalSprime length=%d", length);

-EVP_DigestUpdate(&mdctx, array, length);

-EVP_DigestFinal_ex(&mdctx, (BYTE *)&(result->DAA_digest_S1), NULL);

+EVP_DigestUpdate(mdctx, array, length);

+EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_S1), NULL);

// modulus (n)

-EVP_DigestInit_ex(&mdctx, DAA_PARAM_get_message_digest(), NULL);

+EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL);

bi_2_byte_array( array,

length = (bi_length( pk_internal->modulus)+7)/8,

pk_internal->modulus);

LogDebug("modulus length=%d", length);

-EVP_DigestUpdate(&mdctx, array, length);

-EVP_DigestFinal_ex(&mdctx, (BYTE *)&(result->DAA_digest_n), NULL);

+EVP_DigestUpdate(mdctx, array, length);

+EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_n), NULL);

// modulus (n)

-EVP_DigestInit_ex(&mdctx, DAA_PARAM_get_message_digest(), NULL);

+EVP_DigestInit_ex(mdctx, DAA_PARAM_get_message_digest(), NULL);

bi_2_byte_array( array,

length = (bi_length( pk_internal->capitalGamma)+7)/8,

pk_internal->capitalGamma);

LogDebug("capitalGamma length=%d", length);

-EVP_DigestUpdate(&mdctx, array, length);

+EVP_DigestUpdate(mdctx, array, length);

free(array);

-EVP_DigestFinal_ex(&mdctx, (BYTE *)&(result->DAA_digest_gamma), NULL);

-EVP_MD_CTX_cleanup(&mdctx);

+EVP_DigestFinal_ex(mdctx, (BYTE *)&(result->DAA_digest_gamma), NULL);

+EVP_MD_CTX_destroy(mdctx);

// rho

bi_2_byte_array( (BYTE *)&(result->DAA_generic_q), 26, pk_internal->rho);

return result;

diff --git a/src/tspi/daa/daa_verifier/verifier_transaction.c b/src/tspi/daa/daa_verifier/verifier_transaction.c

index 1eecd43..bb24f26 100644

--- a/src/tspi/daa/daa_verifier/verifier_transaction.c

+++ b/src/tspi/daa/daa_verifier/verifier_transaction.c

@@ -55,7 +55,7 @@ static int verifyNonce( BYTE *nonce_verifier, int length) {

}

BYTE *compute_bytes( int seedLength, BYTE *seed, int length, const EVP_MD *digest) {

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

int N;

BYTE *hash;

BYTE *result;

@@ -66,8 +66,8 @@ BYTE *compute_bytes( int seedLength, BYTE *seed, int length, const EVP_MD *diges

LogError("malloc of %d bytes failed", length);

return NULL;

}

-EVP_MD_CTX_init(&mdctx);

-EVP_DigestInit_ex(&mdctx, digest, NULL);

+mdctx = EVP_MD_CTX_create();

+EVP_DigestInit_ex(mdctx, digest, NULL);

len_hash = EVP_MD_size(digest);

N = length / len_hash;

hash = (BYTE *)malloc( len_hash);

@@ -76,20 +76,21 @@ BYTE *compute_bytes( int seedLength, BYTE *seed, int length, const EVP_MD *diges

return NULL;

}

for( i=0; i

-EVP_DigestUpdate(&mdctx, seed, seedLength);

+EVP_DigestUpdate(mdctx, seed, seedLength);

big_indian_i = htonl( i);

-EVP_DigestUpdate(&mdctx, &big_indian_i, sizeof( int));

-EVP_DigestFinal_ex(&mdctx, &result[ i * len_hash], NULL);

-EVP_DigestInit_ex(&mdctx, digest, NULL);

+EVP_DigestUpdate(mdctx, &big_indian_i, sizeof( int));

+EVP_DigestFinal_ex(mdctx, &result[ i * len_hash], NULL);

+EVP_DigestInit_ex(mdctx, digest, NULL);

}

// fill up the rest of the array (i=N)

-EVP_DigestUpdate(&mdctx, seed, seedLength);

+EVP_DigestUpdate(mdctx, seed, seedLength);

big_indian_i = htonl( i);

-EVP_DigestUpdate(&mdctx, &big_indian_i, sizeof( int));

-EVP_DigestFinal(&mdctx, hash, NULL);

+EVP_DigestUpdate(mdctx, &big_indian_i, sizeof( int));

+EVP_DigestFinal(mdctx, hash, NULL);

// copy the rest: base_nameLength % len_hash bytes

memcpy( &result[ i * len_hash], hash, length - N * len_hash);

free( hash);

+EVP_MD_CTX_destroy(mdctx);

return result;

}

@@ -238,7 +239,7 @@ BYTE *compute_sign_challenge_host(

CS_ENCRYPTION_RESULT *encryption_result_rand,

CS_ENCRYPTION_RESULT *encryption_result_proof

) {

-EVP_MD_CTX mdctx;

+EVP_MD_CTX *mdctx;

int i, length;

unsigned int big_indian;

BYTE *buffer;

@@ -270,26 +271,26 @@ BYTE *compute_sign_challenge_host(

LogDebug("encryption_result_rand:%d", (int)encryption_result_rand);

LogDebug("encryption_result_proof:%d", (int)encryption_result_proof);

-EVP_MD_CTX_init(&mdctx);

-EVP_DigestInit_ex(&mdctx, digest, NULL);

+mdctx = EVP_MD_CTX_create();

+EVP_DigestInit_ex(mdctx, digest, NULL);

// update with encoded PK

buffer = encoded_DAA_PK_internal( &length, issuer_pk);

if( buffer == NULL) return NULL;

LogDebug("encoded issuer_pk[%d]:%s", length, dump_byte_array( length, buffer));

-EVP_DigestUpdate(&mdctx, buffer , length);

+EVP_DigestUpdate(mdctx, buffer , length);

free( buffer);

// nonce verifier

-EVP_DigestUpdate(&mdctx, nonce_verifier , nonce_verifierLength);

+EVP_DigestUpdate(mdctx, nonce_verifier , nonce_verifierLength);

// length Commitments

big_indian = attribute_commitmentsLength;

-EVP_DigestUpdate(&mdctx, &big_indian, sizeof(int));

+EVP_DigestUpdate(mdctx, &big_indian, sizeof(int));

// Anonymity enabled

big_indian = is_anonymity_revocation_enabled;

-EVP_DigestUpdate(&mdctx, &big_indian, sizeof(int));

+EVP_DigestUpdate(mdctx, &big_indian, sizeof(int));

-update( &mdctx, "zeta", zeta, DAA_PARAM_SIZE_MODULUS_GAMMA);

-update( &mdctx, "capitalT", capital_t, DAA_PARAM_SIZE_RSA_MODULUS);

-update( &mdctx, "capitalTTilde", capital_tilde, DAA_PARAM_SIZE_RSA_MODULUS);

+update( mdctx, "zeta", zeta, DAA_PARAM_SIZE_MODULUS_GAMMA);

+update( mdctx, "capitalT", capital_t, DAA_PARAM_SIZE_RSA_MODULUS);

+update( mdctx, "capitalTTilde", capital_tilde, DAA_PARAM_SIZE_RSA_MODULUS);

length_gamma_modulus = DAA_PARAM_SIZE_MODULUS_GAMMA / 8;

buffer = (BYTE *)malloc( length_gamma_modulus);// allocation

@@ -302,18 +303,18 @@ BYTE *compute_sign_challenge_host(

buffer1 = to_bytes_TSS_DAA_SELECTED_ATTRIB_internal(

&length,

selected_attributes2commit[i]);

-EVP_DigestUpdate(&mdctx, buffer1, length);

+EVP_DigestUpdate(mdctx, buffer1, length);

free( buffer1);

bi_2_byte_array( buffer,

length_gamma_modulus,

attribute_commitments[i]->beta);

-EVP_DigestUpdate(&mdctx,

+EVP_DigestUpdate(mdctx,

buffer,

length_gamma_modulus);

bi_2_byte_array( buffer,

length_gamma_modulus,

attribute_commitment_proofs[i]->beta);

-EVP_DigestUpdate(&mdctx,

+EVP_DigestUpdate(mdctx,

buffer,

length_gamma_modulus);

}

@@ -321,34 +322,34 @@ BYTE *compute_sign_challenge_host(

if( !is_anonymity_revocation_enabled) {

// Nv, N~v

bi_2_byte_array( buffer, length_gamma_modulus, capital_nv);