taler/exchange
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix memory leaks reported by valgrind

Browse Source
This commit is contained in:
Özgür Kesim 2023-07-10 10:23:52 +02:00
parent 9d706a01a2
commit 3024dc9fa5
Signed by: oec
GPG Key ID: 3D76A56D79EDD9D7
17 changed files with 269 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/extensions/extensions.c
View File

@ -184,7 +184,7 @@ configure_extension (
{
struct LoadConfClosure *col = cls;
const char *name;
char *lib_name;
char lib_name[1024] = {0};
struct TALER_Extension *extension;
if (GNUNET_OK != col->error)
@ -199,16 +199,15 @@ configure_extension (
/* Load the extension library */
GNUNET_asprintf (&lib_name,
GNUNET_snprintf (lib_name,
sizeof(lib_name),
"libtaler_extension_%s",
name);
/* Lower-case extension name, config is case-insensitive */
for (unsigned int i = 0; i < strlen (lib_name); i++)
{
lib_name[i] = tolower (lib_name[i]);
}
extension = GNUNET_PLUGIN_load (
lib_name,
extension = GNUNET_PLUGIN_load (lib_name,
(void *) col->cfg);
if (NULL == extension)
{

33
src/include/taler_crypto_lib.h
View File

@ -5947,33 +5947,54 @@ TALER_age_commitment_verify (
/**
* @brief helper function to free memory of a struct TALER_AgeCommitment
*
* @param p the commitment from which all memory should be freed.
* @param ac the commitment from which all memory should be freed.
*/
void
TALER_age_commitment_free (
struct TALER_AgeCommitment *p);
struct TALER_AgeCommitment *ac);
/**
* @brief helper function to free memory of a struct TALER_AgeProof
*
* @param p the proof of commitment from which all memory should be freed.
* @param ap the proof of commitment from which all memory should be freed.
*/
void
TALER_age_proof_free (
struct TALER_AgeProof *p);
struct TALER_AgeProof *ap);
/**
* @brief helper function to free memory of a struct TALER_AgeCommitmentProof
*
* @param p the commitment and its proof from which all memory should be freed.
* @param acp the commitment and its proof from which all memory should be freed.
*/
void
TALER_age_commitment_proof_free (
struct TALER_AgeCommitmentProof *p);
struct TALER_AgeCommitmentProof *acp);
/**
* @brief helper function to allocate and copy a struct TALER_AgeCommitmentProof
*
* @param[in] acp The original age commitment proof
* @return The deep copy of @e acp, allocated
*/
struct TALER_AgeCommitmentProof *
TALER_age_commitment_proof_duplicate (
const struct TALER_AgeCommitmentProof *acp);
/**
* @brief helper function to copy a struct TALER_AgeCommitmentProof
*
* @param[in] acp The original age commitment proof
* @param[out] nacp The struct to copy the data into, with freshly allocated and copied keys.
*/
void
TALER_age_commitment_proof_deep_copy (
const struct TALER_AgeCommitmentProof *acp,
struct TALER_AgeCommitmentProof *nacp);
/**
* @brief For age-withdraw, clients have to prove that the public keys for all
* age groups larger than the allowed maximum age group are derived by scalar

9
src/include/taler_exchange_service.h
View File

@ -3043,7 +3043,7 @@ struct TALER_EXCHANGE_RevealedCoinInfo
* Age commitment and its hash of the coin, might be NULL.
*/
struct TALER_AgeCommitmentProof *age_commitment_proof;
struct TALER_AgeCommitmentHash *h_age_commitment;
struct TALER_AgeCommitmentHash h_age_commitment;
/**
* Blinding keys used to blind the fresh coin.
@ -3187,10 +3187,11 @@ struct TALER_EXCHANGE_LinkedCoinInfo
struct TALER_CoinSpendPrivateKeyP coin_priv;
/**
* Age commitment and its hash, if applicable. Might be NULL.
* Age commitment and its hash, if applicable.
*/
struct TALER_AgeCommitmentProof *age_commitment_proof;
struct TALER_AgeCommitmentHash *h_age_commitment;
bool has_age_commitment;
struct TALER_AgeCommitmentProof age_commitment_proof;
struct TALER_AgeCommitmentHash h_age_commitment;
/**
* Master secret of this coin.

7
src/include/taler_util.h
View File

@ -578,11 +578,14 @@ TALER_parse_age_group_string (
/**
* @brief Encodes the age mask into a string, like "8:10:12:14:16:18:21"
*
* NOTE: This function uses a static buffer. It is not safe to call this
* function concurrently.
*
* @param mask Age mask
* @return String representation of the age mask, allocated by GNUNET_malloc.
* @return String representation of the age mask.
* Can be used as value in the TALER config.
*/
char *
const char *
TALER_age_mask_to_string (
const struct TALER_AgeMask *mask);

23
src/lib/exchange_api_link.c
View File

@ -114,6 +114,7 @@ parse_link_coin (const struct TALER_EXCHANGE_LinkHandle *lh,
struct TALER_TransferSecretP secret;
struct TALER_PlanchetDetail pd;
struct TALER_CoinPubHashP c_hash;
struct TALER_AgeCommitmentHash *pach = NULL;
/* parse reply */
if (GNUNET_OK !=
@ -137,32 +138,33 @@ parse_link_coin (const struct TALER_EXCHANGE_LinkHandle *lh,
&alg_values,
&bks);
lci->age_commitment_proof = NULL;
lci->h_age_commitment = NULL;
lci->has_age_commitment = false;
/* Derive the age commitment and calculate the hash */
if (NULL != lh->age_commitment_proof)
{
lci->age_commitment_proof = GNUNET_new (struct TALER_AgeCommitmentProof);
lci->h_age_commitment = GNUNET_new (struct TALER_AgeCommitmentHash);
GNUNET_assert (GNUNET_OK ==
TALER_age_commitment_derive (
lh->age_commitment_proof,
&secret.key,
lci->age_commitment_proof));
&lci->age_commitment_proof));
TALER_age_commitment_hash (
&(lci->age_commitment_proof->commitment),
lci->h_age_commitment);
&lci->age_commitment_proof.commitment,
&lci->h_age_commitment);
lci->has_age_commitment = true;
pach = &lci->h_age_commitment;
}
if (GNUNET_OK !=
TALER_planchet_prepare (&rpub,
TALER_planchet_prepare (
&rpub,
&alg_values,
&bks,
&lci->coin_priv,
lci->h_age_commitment,
pach,
&c_hash,
&pd))
{
@ -364,6 +366,8 @@ parse_link_ok (struct TALER_EXCHANGE_LinkHandle *lh,
{
TALER_denom_sig_free (&lcis[i].sig);
TALER_denom_pub_free (&lcis[i].pub);
if (lcis[i].has_age_commitment)
TALER_age_commitment_proof_free (&lcis[i].age_commitment_proof);
}
}
return ret;
@ -513,6 +517,7 @@ TALER_EXCHANGE_link_cancel (struct TALER_EXCHANGE_LinkHandle *lh)
GNUNET_CURL_job_cancel (lh->job);
lh->job = NULL;
}
GNUNET_free (lh->url);
GNUNET_free (lh);
}

6
src/lib/exchange_api_melt.c
View File

@ -336,7 +336,8 @@ start_melt (struct TALER_EXCHANGE_MeltHandle *mh)
}
TALER_denom_pub_hash (&mh->md.melted_coin.pub_key,
&h_denom_pub);
TALER_wallet_melt_sign (&mh->md.melted_coin.melt_amount_with_fee,
TALER_wallet_melt_sign (
&mh->md.melted_coin.melt_amount_with_fee,
&mh->md.melted_coin.fee_melt,
&mh->md.rc,
&h_denom_pub,
@ -357,7 +358,7 @@ start_melt (struct TALER_EXCHANGE_MeltHandle *mh)
GNUNET_JSON_pack_data_auto ("rc",
&mh->md.rc),
GNUNET_JSON_pack_allow_null (
mh->md.melted_coin.h_age_commitment
(NULL != mh->md.melted_coin.h_age_commitment)
? GNUNET_JSON_pack_data_auto ("age_commitment_hash",
mh->md.melted_coin.h_age_commitment)
: GNUNET_JSON_pack_string ("age_commitment_hash",
@ -504,7 +505,6 @@ csr_cb (void *cls,
}
/* FIXME: refactor this to use struct TALER_EXCHANGE_Handle */
struct TALER_EXCHANGE_MeltHandle *
TALER_EXCHANGE_melt (
struct GNUNET_CURL_Context *ctx,

23
src/lib/exchange_api_refresh_common.c
View File

@ -45,6 +45,11 @@ TALER_EXCHANGE_free_melt_data_ (struct MeltData *md)
struct FreshCoinData *fcd = &md->fcds[j];
TALER_denom_pub_free (&fcd->fresh_pk);
for (size_t i = 0; i < TALER_CNC_KAPPA; i++)
{
TALER_age_commitment_proof_free (fcd->age_commitment_proofs[i]);
GNUNET_free (fcd->age_commitment_proofs[i]);
}
}
GNUNET_free (md->fcds);
}
@ -168,7 +173,8 @@ TALER_EXCHANGE_get_melt_data_ (
union TALER_DenominationBlindingKeyP *bks = &fcd->bks[i];
struct TALER_PlanchetDetail pd;
struct TALER_CoinPubHashP c_hash;
struct TALER_AgeCommitmentHash *ach = NULL;
struct TALER_AgeCommitmentHash ach;
struct TALER_AgeCommitmentHash *pach = NULL;
TALER_transfer_secret_to_planchet_secret (&trans_sec,
j,
@ -182,22 +188,21 @@ TALER_EXCHANGE_get_melt_data_ (
&alg_values[j],
bks);
/* Handle age commitment, if present */
if (NULL != md->melted_coin.age_commitment_proof)
if (NULL != rd->melt_age_commitment_proof)
{
fcd->age_commitment_proof[i] = GNUNET_new (struct
fcd->age_commitment_proofs[i] = GNUNET_new (struct
TALER_AgeCommitmentProof);
ach = GNUNET_new (struct TALER_AgeCommitmentHash);
GNUNET_assert (GNUNET_OK ==
TALER_age_commitment_derive (
md->melted_coin.age_commitment_proof,
&trans_sec.key,
fcd->age_commitment_proof[i]));
fcd->age_commitment_proofs[i]));
TALER_age_commitment_hash (
&fcd->age_commitment_proof[i]->commitment,
ach);
&fcd->age_commitment_proofs[i]->commitment,
&ach);
pach = &ach;
}
if (TALER_DENOMINATION_CS == alg_values[j].cipher)
@ -208,7 +213,7 @@ TALER_EXCHANGE_get_melt_data_ (
&alg_values[j],
bks,
coin_priv,
ach,
pach,
&c_hash,
&pd))
{

5
src/lib/exchange_api_refresh_common.h
View File

@ -101,10 +101,9 @@ struct FreshCoinData
/**
* Arrays of age commitments and proofs to be created, one for each
* cut-and-choose dimension. The entries in each list might be NULL and
* indicate no age commitment/restriction on the particular coin.
* cut-and-choose dimension. NULL if age restriction is not applicable.
*/
struct TALER_AgeCommitmentProof *age_commitment_proof[TALER_CNC_KAPPA];
struct TALER_AgeCommitmentProof *age_commitment_proofs[TALER_CNC_KAPPA];
/**
* Blinding key secrets for the coins, depending on the

48
src/lib/exchange_api_refreshes_reveal.c
View File

@ -125,8 +125,7 @@ refresh_reveal_ok (struct TALER_EXCHANGE_RefreshesRevealHandle *rrh,
}
for (unsigned int i = 0; i<rrh->md.num_fresh_coins; i++)
{
struct TALER_EXCHANGE_RevealedCoinInfo *rci =
&rcis[i];
struct TALER_EXCHANGE_RevealedCoinInfo *rci = &rcis[i];
const struct FreshCoinData *fcd = &rrh->md.fcds[i];
const struct TALER_DenominationPublicKey *pk;
json_t *jsonai;
@ -140,25 +139,25 @@ refresh_reveal_ok (struct TALER_EXCHANGE_RefreshesRevealHandle *rrh,
};
struct TALER_FreshCoin coin;
union TALER_DenominationBlindingKeyP bks;
const struct TALER_AgeCommitmentHash *pach = NULL;
rci->ps = fcd->ps[rrh->noreveal_index];
rci->bks = fcd->bks[rrh->noreveal_index];
rci->age_commitment_proof = fcd->age_commitment_proof[rrh->noreveal_index];
rci->h_age_commitment = NULL;
rci->age_commitment_proof = NULL;
pk = &fcd->fresh_pk;
jsonai = json_array_get (jsona, i);
GNUNET_assert (NULL != jsonai);
GNUNET_assert (
(NULL != rrh->md.melted_coin.age_commitment_proof) ==
(NULL != rci->age_commitment_proof));
if (NULL != rci->age_commitment_proof)
if (NULL != rrh->md.melted_coin.age_commitment_proof)
{
rci->h_age_commitment = GNUNET_new (struct TALER_AgeCommitmentHash);
TALER_age_commitment_hash (
&rci->age_commitment_proof->commitment,
rci->h_age_commitment);
rci->age_commitment_proof =
fcd->age_commitment_proofs[rrh->noreveal_index];
TALER_age_commitment_hash (&rci->age_commitment_proof->commitment,
&rci->h_age_commitment);
pach = &rci->h_age_commitment;
}
if (GNUNET_OK !=
@ -180,15 +179,17 @@ refresh_reveal_ok (struct TALER_EXCHANGE_RefreshesRevealHandle *rrh,
hence recomputing it here... */
GNUNET_CRYPTO_eddsa_key_get_public (&rci->coin_priv.eddsa_priv,
&coin_pub.eddsa_pub);
TALER_coin_pub_hash (&coin_pub,
rci->h_age_commitment,
TALER_coin_pub_hash (
&coin_pub,
pach,
&coin_hash);
if (GNUNET_OK !=
TALER_planchet_to_coin (pk,
TALER_planchet_to_coin (
pk,
&blind_sig,
&bks,
&rci->coin_priv,
rci->h_age_commitment,
pach,
&coin_hash,
&rrh->alg_values[i],
&coin))
@ -257,7 +258,10 @@ handle_refresh_reveal_finished (void *cls,
rrh->reveal_cb = NULL;
}
for (unsigned int i = 0; i<rrh->md.num_fresh_coins; i++)
{
TALER_denom_sig_free (&rcis[i].sig);
TALER_age_commitment_proof_free (rcis[i].age_commitment_proof);
}
TALER_EXCHANGE_refreshes_reveal_cancel (rrh);
return;
}
@ -303,7 +307,6 @@ handle_refresh_reveal_finished (void *cls,
}
/* FIXME: refactor this to use struct TALER_EXCHANGE_Handle */
struct TALER_EXCHANGE_RefreshesRevealHandle *
TALER_EXCHANGE_refreshes_reveal (
struct GNUNET_CURL_Context *ctx,
@ -408,20 +411,19 @@ TALER_EXCHANGE_refreshes_reveal (
}
/* build array of old age commitment, if applicable */
GNUNET_assert ((NULL == rd->melt_age_commitment_proof) ==
(NULL == rd->melt_h_age_commitment));
if (NULL != rd->melt_age_commitment_proof)
{
GNUNET_assert (NULL != rd->melt_h_age_commitment);
GNUNET_assert (NULL != (old_age_commitment = json_array ()));
for (size_t i = 0; i < rd->melt_age_commitment_proof->commitment.num; i++)
{
GNUNET_assert (0 ==
json_array_append_new (
enum GNUNET_GenericReturnValue ret;
ret = json_array_append_new (
old_age_commitment,
GNUNET_JSON_from_data_auto (
&rd->melt_age_commitment_proof->
commitment.keys[i])));
&rd->melt_age_commitment_proof->commitment.keys[i]));
GNUNET_assert (0 == ret);
}
}

3
src/testing/test_bank_api.c
View File

@ -78,6 +78,9 @@ run (void *cls,
case TALER_TESTING_BS_IBAN:
ssoptions = "-ns";
break;
default:
ssoptions = NULL;
break;
}
memset (&wtid,
42,

1
src/testing/test_exchange_api.c
View File

@ -660,7 +660,6 @@ run (void *cls,
"refresh-reveal-age-1",
MHD_HTTP_CONFLICT,
NULL),
TALER_TESTING_cmd_end ()
};

37
src/testing/testing_api_cmd_batch_withdraw.c
View File

@ -79,10 +79,10 @@ struct CoinState
/**
* If age > 0, put here the corresponding age commitment with its proof and
* its hash, respectivelly, NULL otherwise.
* its hash, respectivelly.
*/
struct TALER_AgeCommitmentProof *age_commitment_proof;
struct TALER_AgeCommitmentHash *h_age_commitment;
struct TALER_AgeCommitmentProof age_commitment_proof;
struct TALER_AgeCommitmentHash h_age_commitment;
/**
* Reserve history entry that corresponds to this coin.
@ -316,7 +316,7 @@ batch_withdraw_run (void *cls,
wci->pk = cs->pk;
wci->ps = &cs->ps;
wci->ach = cs->h_age_commitment;
wci->ach = &cs->h_age_commitment;
}
ws->wsh = TALER_EXCHANGE_batch_withdraw (
TALER_TESTING_interpreter_get_context (is),
@ -366,13 +366,8 @@ batch_withdraw_cleanup (void *cls,
TALER_EXCHANGE_destroy_denomination_key (cs->pk);
cs->pk = NULL;
}
if (NULL != cs->age_commitment_proof)
{
TALER_age_commitment_proof_free (cs->age_commitment_proof);
cs->age_commitment_proof = NULL;
}
if (NULL != cs->h_age_commitment)
GNUNET_free (cs->h_age_commitment);
if (0 < ws->age)
TALER_age_commitment_proof_free (&cs->age_commitment_proof);
}
GNUNET_free (ws->coins);
GNUNET_free (ws->exchange_url);
@ -424,9 +419,13 @@ batch_withdraw_traits (void *cls,
TALER_TESTING_make_trait_payto_uri (ws->reserve_payto_uri),
TALER_TESTING_make_trait_exchange_url (ws->exchange_url),
TALER_TESTING_make_trait_age_commitment_proof (index,
cs->age_commitment_proof),
ws->age > 0 ?
&cs->age_commitment_proof:
NULL),
TALER_TESTING_make_trait_h_age_commitment (index,
cs->h_age_commitment),
ws->age > 0 ?
&cs->h_age_commitment :
NULL),
TALER_TESTING_trait_end ()
};
@ -473,13 +472,9 @@ TALER_TESTING_cmd_batch_withdraw (const char *label,
if (0 < age)
{
struct TALER_AgeCommitmentProof *acp;
struct TALER_AgeCommitmentHash *hac;
struct GNUNET_HashCode seed;
struct TALER_AgeMask mask;
acp = GNUNET_new (struct TALER_AgeCommitmentProof);
hac = GNUNET_new (struct TALER_AgeCommitmentHash);
mask = TALER_extensions_get_age_restriction_mask ();
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
&seed,
@ -490,7 +485,7 @@ TALER_TESTING_cmd_batch_withdraw (const char *label,
&mask,
age,
&seed,
acp))
&cs->age_commitment_proof))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to generate age commitment for age %d at %s\n",
@ -499,10 +494,8 @@ TALER_TESTING_cmd_batch_withdraw (const char *label,
GNUNET_assert (0);
}
TALER_age_commitment_hash (&acp->commitment,
hac);
cs->age_commitment_proof = acp;
cs->h_age_commitment = hac;
TALER_age_commitment_hash (&cs->age_commitment_proof.commitment,
&cs->h_age_commitment);
}
if (GNUNET_OK !=

31
src/testing/testing_api_cmd_deposit.c
View File

@ -284,8 +284,7 @@ deposit_run (void *cls,
const struct TALER_TESTING_Command *coin_cmd;
const struct TALER_CoinSpendPrivateKeyP *coin_priv;
struct TALER_CoinSpendPublicKeyP coin_pub;
const struct TALER_AgeCommitmentProof *age_commitment_proof = NULL;
struct TALER_AgeCommitmentHash h_age_commitment = {0};
const struct TALER_AgeCommitmentHash *phac;
const struct TALER_EXCHANGE_DenomPublicKey *denom_pub;
const struct TALER_DenominationSignature *denom_pub_sig;
struct TALER_CoinSpendSignatureP coin_sig;
@ -389,9 +388,9 @@ deposit_run (void *cls,
ds->coin_index,
&coin_priv)) ||
(GNUNET_OK !=
TALER_TESTING_get_trait_age_commitment_proof (coin_cmd,
TALER_TESTING_get_trait_h_age_commitment (coin_cmd,
ds->coin_index,
&age_commitment_proof)) ||
&phac)) ||
(GNUNET_OK !=
TALER_TESTING_get_trait_denom_pub (coin_cmd,
ds->coin_index,
@ -409,11 +408,6 @@ deposit_run (void *cls,
return;
}
if (NULL != age_commitment_proof)
{
TALER_age_commitment_hash (&age_commitment_proof->commitment,
&h_age_commitment);
}
ds->deposit_fee = denom_pub->fees.deposit;
GNUNET_CRYPTO_eddsa_key_get_public (&coin_priv->eddsa_priv,
&coin_pub.eddsa_pub);
@ -447,7 +441,7 @@ deposit_run (void *cls,
&denom_pub->fees.deposit,
&h_wire,
&h_contract_terms,
&h_age_commitment,
phac,
NULL, /* FIXME #7270: add hash of extensions */
&denom_pub->h_key,
ds->wallet_timestamp,
@ -460,11 +454,11 @@ deposit_run (void *cls,
{
struct TALER_EXCHANGE_CoinDepositDetail cdd = {
.amount = ds->amount,
.h_age_commitment = h_age_commitment,
.coin_pub = coin_pub,
.coin_sig = coin_sig,
.denom_sig = *denom_pub_sig,
.h_denom_pub = denom_pub->h_key
.h_denom_pub = denom_pub->h_key,
.h_age_commitment = {{{0}}},
};
struct TALER_EXCHANGE_DepositContractDetail dcd = {
.wire_deadline = ds->wire_deadline,
@ -477,6 +471,9 @@ deposit_run (void *cls,
.refund_deadline = ds->refund_deadline
};
if (NULL != phac)
cdd.h_age_commitment = *phac;
ds->dh = TALER_EXCHANGE_batch_deposit (
TALER_TESTING_interpreter_get_context (is),
exchange_url,
@ -551,6 +548,7 @@ deposit_traits (void *cls,
/* Will point to coin cmd internals. */
const struct TALER_CoinSpendPrivateKeyP *coin_spent_priv;
const struct TALER_AgeCommitmentProof *age_commitment_proof;
const struct TALER_AgeCommitmentHash *h_age_commitment;
if (GNUNET_YES != ds->command_initialized)
{
@ -575,12 +573,17 @@ deposit_traits (void *cls,
(GNUNET_OK !=
TALER_TESTING_get_trait_age_commitment_proof (coin_cmd,
ds->coin_index,
&age_commitment_proof)) )
&age_commitment_proof)) ||
(GNUNET_OK !=
TALER_TESTING_get_trait_h_age_commitment (coin_cmd,
ds->coin_index,
&h_age_commitment)) )
{
GNUNET_break (0);
TALER_TESTING_interpreter_fail (ds->is);
return GNUNET_NO;
}
{
struct TALER_TESTING_Trait traits[] = {
/* First two traits are only available if
@ -594,6 +597,8 @@ deposit_traits (void *cls,
coin_spent_priv),
TALER_TESTING_make_trait_age_commitment_proof (0,
age_commitment_proof),
TALER_TESTING_make_trait_h_age_commitment (0,
h_age_commitment),
TALER_TESTING_make_trait_wire_details (ds->wire_details),
TALER_TESTING_make_trait_contract_terms (ds->contract_terms),
TALER_TESTING_make_trait_merchant_priv (&ds->merchant_priv),

39
src/testing/testing_api_cmd_refresh.c
View File

@ -75,7 +75,7 @@ struct TALER_TESTING_FreshCoinData
* applicable.
*/
struct TALER_AgeCommitmentProof *age_commitment_proof;
struct TALER_AgeCommitmentHash *h_age_commitment;
struct TALER_AgeCommitmentHash h_age_commitment;
/**
* The blinding key (needed for recoup operations).
@ -440,8 +440,13 @@ reveal_cb (void *cls,
return;
}
fc->coin_priv = coin->coin_priv;
fc->age_commitment_proof = coin->age_commitment_proof;
if (NULL != coin->age_commitment_proof)
{
fc->age_commitment_proof =
TALER_age_commitment_proof_duplicate (coin->age_commitment_proof);
fc->h_age_commitment = coin->h_age_commitment;
}
TALER_denom_sig_deep_copy (&fc->sig,
&coin->sig);
@ -559,7 +564,11 @@ refresh_reveal_cleanup (void *cls,
}
for (unsigned int j = 0; j < rrs->num_fresh_coins; j++)
{
TALER_denom_sig_free (&rrs->fresh_coins[j].sig);
TALER_age_commitment_proof_free (rrs->fresh_coins[j].age_commitment_proof);
GNUNET_free (rrs->fresh_coins[j].age_commitment_proof);
}
GNUNET_free (rrs->fresh_coins);
GNUNET_free (rrs->psa);
@ -1024,12 +1033,12 @@ melt_run (void *cls,
{
struct TALER_Amount melt_amount;
struct TALER_Amount fresh_amount;
const struct TALER_AgeCommitmentProof *age_commitment_proof;
const struct TALER_AgeCommitmentHash *h_age_commitment;
const struct TALER_AgeCommitmentProof *age_commitment_proof = NULL;
const struct TALER_AgeCommitmentHash *h_age_commitment = NULL;
const struct TALER_DenominationSignature *melt_sig;
const struct TALER_EXCHANGE_DenomPublicKey *melt_denom_pub;
const struct TALER_TESTING_Command *coin_command;
bool age_restricted;
bool age_restricted_denom;
if (NULL == (coin_command
= TALER_TESTING_interpreter_lookup_command (
@ -1094,7 +1103,10 @@ melt_run (void *cls,
/* Melt amount starts with the melt fee of the old coin; we'll add the
values and withdraw fees of the fresh coins next */
melt_amount = melt_denom_pub->fees.refresh;
age_restricted = melt_denom_pub->key.age_mask.bits != 0;
age_restricted_denom = melt_denom_pub->key.age_mask.bits != 0;
GNUNET_assert (age_restricted_denom == (NULL != age_commitment_proof));
GNUNET_assert ((NULL == age_commitment_proof) ||
(0 < age_commitment_proof->commitment.num));
for (unsigned int i = 0; i<num_fresh_coins; i++)
{
const struct TALER_EXCHANGE_DenomPublicKey *fresh_pk;
@ -1113,7 +1125,7 @@ melt_run (void *cls,
}
fresh_pk = TALER_TESTING_find_pk (TALER_TESTING_get_keys (rms->is),
&fresh_amount,
age_restricted);
age_restricted_denom);
if (NULL == fresh_pk)
{
GNUNET_break (0);
@ -1139,13 +1151,20 @@ melt_run (void *cls,
rms->refresh_data.melt_amount = melt_amount;
rms->refresh_data.melt_sig = *melt_sig;
rms->refresh_data.melt_pk = *melt_denom_pub;
if (NULL != age_commitment_proof)
{
GNUNET_assert (NULL != h_age_commitment);
rms->refresh_data.melt_age_commitment_proof = age_commitment_proof;
rms->refresh_data.melt_h_age_commitment = h_age_commitment;
}
rms->refresh_data.fresh_pks = rms->fresh_pks;
rms->refresh_data.fresh_pks_len = num_fresh_coins;
GNUNET_assert (age_restricted ==
GNUNET_assert (age_restricted_denom ==
(NULL != age_commitment_proof));
GNUNET_assert ((NULL == age_commitment_proof) ||
(0 < age_commitment_proof->commitment.num));
rms->rmh = TALER_EXCHANGE_melt (
TALER_TESTING_interpreter_get_context (is),
@ -1198,6 +1217,7 @@ melt_cleanup (void *cls,
TALER_denom_pub_free (&rms->fresh_pks[i].key);
GNUNET_free (rms->fresh_pks);
}
GNUNET_free (rms->mbds);
GNUNET_free (rms->melt_fresh_amounts);
GNUNET_free (rms);
@ -1409,7 +1429,7 @@ refresh_reveal_traits (void *cls,
rrs->fresh_coins[index].age_commitment_proof),
TALER_TESTING_make_trait_h_age_commitment (
index,
rrs->fresh_coins[index].h_age_commitment),
&rrs->fresh_coins[index].h_age_commitment),
TALER_TESTING_make_trait_denom_pub (
index,
rrs->fresh_coins[index].pk),
@ -1427,6 +1447,7 @@ refresh_reveal_traits (void *cls,
&rrs->psa[index]),
TALER_TESTING_trait_end ()
};
return TALER_TESTING_get_trait (traits,
ret,
trait,

2
src/testing/testing_api_cmd_run_fakebank.c
View File

@ -110,6 +110,7 @@ run_fakebank_cleanup (void *cls,
}
GNUNET_free (rfs->ba.wire_gateway_url);
GNUNET_free (rfs->bank_url);
GNUNET_free (rfs->currency);
GNUNET_free (rfs);
}
@ -194,6 +195,7 @@ TALER_TESTING_cmd_run_fakebank (
(unsigned int) fakebank_port,
exchange_xtalerbank_account);
GNUNET_free (exchange_xtalerbank_account);
GNUNET_free (exchange_payto_uri);
}
rfs->ba.method = TALER_BANK_AUTH_NONE;
{

40
src/testing/testing_api_cmd_withdraw.c
View File

@ -144,10 +144,10 @@ struct WithdrawState
/**
* If age > 0, put here the corresponding age commitment with its proof and
* its hash, respectivelly, NULL otherwise.
* its hash, respectivelly.
*/
struct TALER_AgeCommitmentProof *age_commitment_proof;
struct TALER_AgeCommitmentHash *h_age_commitment;
struct TALER_AgeCommitmentProof age_commitment_proof;
struct TALER_AgeCommitmentHash h_age_commitment;
/**
* Reserve history entry that corresponds to this operation.
@ -438,7 +438,7 @@ withdraw_run (void *cls,
struct TALER_EXCHANGE_WithdrawCoinInput wci = {
.pk = ws->pk,
.ps = &ws->ps,
.ach = ws->h_age_commitment
.ach = 0 < ws->age ? &ws->h_age_commitment : NULL
};
ws->wsh = TALER_EXCHANGE_withdraw (
TALER_TESTING_interpreter_get_context (is),
@ -489,16 +489,8 @@ withdraw_cleanup (void *cls,
TALER_EXCHANGE_destroy_denomination_key (ws->pk);
ws->pk = NULL;
}
if (NULL != ws->age_commitment_proof)
{
TALER_age_commitment_proof_free (ws->age_commitment_proof);
ws->age_commitment_proof = NULL;
}
if (NULL != ws->h_age_commitment)
{
GNUNET_free (ws->h_age_commitment);
ws->h_age_commitment = NULL;
}
if (ws->age > 0)
TALER_age_commitment_proof_free (&ws->age_commitment_proof);
GNUNET_free (ws->exchange_url);
GNUNET_free (ws->reserve_payto_uri);
GNUNET_free (ws);
@ -545,9 +537,13 @@ withdraw_traits (void *cls,
TALER_TESTING_make_trait_payto_uri (ws->reserve_payto_uri),
TALER_TESTING_make_trait_exchange_url (ws->exchange_url),
TALER_TESTING_make_trait_age_commitment_proof (0,
ws->age_commitment_proof),
0 < ws->age
? &ws->age_commitment_proof
: NULL),
TALER_TESTING_make_trait_h_age_commitment (0,
ws->h_age_commitment),
0 < ws->age
? &ws->h_age_commitment
: NULL),
TALER_TESTING_trait_end ()
};
@ -573,13 +569,9 @@ TALER_TESTING_cmd_withdraw_amount (const char *label,
ws->age = age;
if (0 < age)
{
struct TALER_AgeCommitmentProof *acp;
struct TALER_AgeCommitmentHash *hac;
struct GNUNET_HashCode seed;
struct TALER_AgeMask mask;
acp = GNUNET_new (struct TALER_AgeCommitmentProof);
hac = GNUNET_new (struct TALER_AgeCommitmentHash);
mask = TALER_extensions_get_age_restriction_mask ();
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
&seed,
@ -590,7 +582,7 @@ TALER_TESTING_cmd_withdraw_amount (const char *label,
&mask,
age,
&seed,
acp))
&ws->age_commitment_proof))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to generate age commitment for age %d at %s\n",
@ -598,10 +590,8 @@ TALER_TESTING_cmd_withdraw_amount (const char *label,
label);
GNUNET_assert (0);
}
TALER_age_commitment_hash (&acp->commitment,
hac);
ws->age_commitment_proof = acp;
ws->h_age_commitment = hac;
TALER_age_commitment_hash (&ws->age_commitment_proof.commitment,
&ws->h_age_commitment);
}
ws->reserve_reference = reserve_reference;

75
src/util/age_restriction.c
View File

@ -464,6 +464,9 @@ void
TALER_age_proof_free (
struct TALER_AgeProof *proof)
{
if (NULL == proof)
return;
if (NULL != proof->keys)
{
GNUNET_CRYPTO_zero_keys (
@ -479,26 +482,71 @@ TALER_age_proof_free (
void
TALER_age_commitment_proof_free (
struct TALER_AgeCommitmentProof *cp)
struct TALER_AgeCommitmentProof *acp)
{
if (NULL != cp->proof.keys)
if (NULL == acp)
return;
if (NULL != acp->proof.keys)
{
GNUNET_CRYPTO_zero_keys (
cp->proof.keys,
sizeof(*cp->proof.keys) * cp->proof.num);
acp->proof.keys,
sizeof(*acp->proof.keys) * acp->proof.num);
GNUNET_free (cp->proof.keys);
cp->proof.keys = NULL;
GNUNET_free (acp->proof.keys);
acp->proof.keys = NULL;
}
if (NULL != cp->commitment.keys)
if (NULL != acp->commitment.keys)
{
GNUNET_free (cp->commitment.keys);
cp->commitment.keys = NULL;
GNUNET_free (acp->commitment.keys);
acp->commitment.keys = NULL;
}
}
struct TALER_AgeCommitmentProof *
TALER_age_commitment_proof_duplicate (
const struct TALER_AgeCommitmentProof *acp)
{
struct TALER_AgeCommitmentProof *nacp;
GNUNET_assert (NULL != acp);
GNUNET_assert (__builtin_popcount (acp->commitment.mask.bits) - 1 ==
(int) acp->commitment.num);
nacp = GNUNET_new (struct TALER_AgeCommitmentProof);
TALER_age_commitment_proof_deep_copy (acp,nacp);
return nacp;
}
void
TALER_age_commitment_proof_deep_copy (
const struct TALER_AgeCommitmentProof *acp,
struct TALER_AgeCommitmentProof *nacp)
{
GNUNET_assert (NULL != acp);
GNUNET_assert (__builtin_popcount (acp->commitment.mask.bits) - 1 ==
(int) acp->commitment.num);
*nacp = *acp;
nacp->commitment.keys =
GNUNET_new_array (acp->commitment.num,
struct TALER_AgeCommitmentPublicKeyP);
nacp->proof.keys =
GNUNET_new_array (acp->proof.num,
struct TALER_AgeCommitmentPrivateKeyP);
for (size_t i = 0; i < acp->commitment.num; i++)
nacp->commitment.keys[i] = acp->commitment.keys[i];
for (size_t i = 0; i < acp->proof.num; i++)
nacp->proof.keys[i] = acp->proof.keys[i];
}
enum GNUNET_GenericReturnValue
TALER_JSON_parse_age_groups (const json_t *root,
struct TALER_AgeMask *mask)
@ -571,19 +619,16 @@ TALER_parse_age_group_string (
}
char *
const char *
TALER_age_mask_to_string (
const struct TALER_AgeMask *mask)
{
static char buf[256] = {0};
uint32_t bits = mask->bits;
unsigned int n = 0;
char *buf = GNUNET_malloc (32 * 3); // max characters possible
char *pos = buf;
if (NULL == buf)
{
return buf;
}
memset (buf, 0, sizeof(buf));
while (bits != 0)
{