/* This file is part of TALER Copyright (C) 2014-2022 Taler Systems SA TALER is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. TALER is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with TALER; see the file COPYING. If not, see */ /** * @file exchangedb/test_exchangedb_populate_table.c * @brief test cases for DB interaction functions * @author Joseph Xu */ #include "platform.h" #include "taler_exchangedb_lib.h" #include "taler_json_lib.h" #include "taler_exchangedb_plugin.h" /**o * Global result from the testcase. */ static int result; /** * Report line of error if @a cond is true, and jump to label "drop". */ #define FAILIF(cond) \ do { \ if (! (cond)) {break;} \ GNUNET_break (0); \ goto drop; \ } while (0) /** * Initializes @a ptr with random data. */ #define RND_BLK(ptr) \ GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, ptr, sizeof (*ptr)) /** * Initializes @a ptr with zeros. */ #define ZR_BLK(ptr) \ memset (ptr, 0, sizeof (*ptr)) /** * Currency we use. Must match test-exchange-db-*.conf. */ #define CURRENCY "EUR" /** * Number of newly minted coins to use in the test. */ #define MELT_NEW_COINS 5 #define NUMBER_DEPOSIT 10 /** * How big do we make the RSA keys? */ #define RSA_KEY_SIZE 1024 /** * Database plugin under test. */ static struct TALER_EXCHANGEDB_Plugin *plugin; static struct TALER_DenomFeeSet fees; struct DenomKeyPair { struct TALER_DenominationPrivateKey priv; struct TALER_DenominationPublicKey pub; }; /** * Destroy a denomination key pair. The key is not necessarily removed from the DB. * * @param dkp the key pair to destroy */ static void destroy_denom_key_pair (struct DenomKeyPair *dkp) { TALER_denom_pub_free (&dkp->pub); TALER_denom_priv_free (&dkp->priv); GNUNET_free (dkp); } /** * Create a denomination key pair by registering the denomination in the DB. * * @param size the size of the denomination key * @param now time to use for key generation, legal expiration will be 3h later. * @param fees fees to use * @return the denominaiton key pair; NULL upon error */ static struct DenomKeyPair * create_denom_key_pair (unsigned int size, struct GNUNET_TIME_Timestamp now, const struct TALER_Amount *value, const struct TALER_DenomFeeSet *fees) { struct DenomKeyPair *dkp; struct TALER_EXCHANGEDB_DenominationKey dki; struct TALER_EXCHANGEDB_DenominationKeyInformation issue2; dkp = GNUNET_new (struct DenomKeyPair); GNUNET_assert (GNUNET_OK == TALER_denom_priv_create (&dkp->priv, &dkp->pub, TALER_DENOMINATION_RSA, size)); memset (&dki, 0, sizeof (struct TALER_EXCHANGEDB_DenominationKey)); dki.denom_pub = dkp->pub; dki.issue.start = now; dki.issue.expire_withdraw = GNUNET_TIME_absolute_to_timestamp ( GNUNET_TIME_absolute_add ( now.abs_time, GNUNET_TIME_UNIT_HOURS)); dki.issue.expire_deposit = GNUNET_TIME_absolute_to_timestamp ( GNUNET_TIME_absolute_add ( now.abs_time, GNUNET_TIME_relative_multiply ( GNUNET_TIME_UNIT_HOURS, 2))); dki.issue.expire_legal = GNUNET_TIME_absolute_to_timestamp ( GNUNET_TIME_absolute_add ( now.abs_time, GNUNET_TIME_relative_multiply ( GNUNET_TIME_UNIT_HOURS, 3))); dki.issue.value = *value; dki.issue.fees = *fees; TALER_denom_pub_hash (&dkp->pub, &dki.issue.denom_hash); if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != plugin->insert_denomination_info (plugin->cls, &dki.denom_pub, &dki.issue)) { GNUNET_break (0); destroy_denom_key_pair (dkp); return NULL; } memset (&issue2, 0, sizeof (issue2)); if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != plugin->get_denomination_info (plugin->cls, &dki.issue.denom_hash, &issue2)) { GNUNET_break (0); destroy_denom_key_pair (dkp); return NULL; } if (0 != GNUNET_memcmp (&dki.issue, &issue2)) { GNUNET_break (0); destroy_denom_key_pair (dkp); return NULL; } return dkp; } /** * Here we store the hash of the payto URI. */ static struct TALER_PaytoHashP wire_target_h_payto; /** * Counter used in auditor-related db functions. Used to count * expected rows. */ static unsigned int auditor_row_cnt; /** * Callback for #select_deposits_above_serial_id () * * @param cls closure * @param rowid unique serial ID for the deposit in our DB * @param exchange_timestamp when did the deposit happen * @param deposit deposit details * @param denom_pub denomination of the @a coin_pub * @param done flag set if the deposit was already executed (or not) * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to stop */ static enum GNUNET_GenericReturnValue audit_deposit_cb (void *cls, uint64_t rowid, struct GNUNET_TIME_Timestamp exchange_timestamp, const struct TALER_EXCHANGEDB_Deposit *deposit, const struct TALER_DenominationPublicKey *denom_pub, bool done) { (void) cls; (void) rowid; (void) exchange_timestamp; (void) deposit; (void) denom_pub; (void) done; auditor_row_cnt++; return GNUNET_OK; } /** * Function called on deposits that are past their due date * and have not yet seen a wire transfer. * * @param cls closure a `struct TALER_EXCHANGEDB_Deposit *` * @param rowid deposit table row of the coin's deposit * @param coin_pub public key of the coin * @param amount value of the deposit, including fee * @param payto_uri where should the funds be wired * @param deadline what was the requested wire transfer deadline * @param done did the exchange claim that it made a transfer? */ static void wire_missing_cb (void *cls, uint64_t rowid, const struct TALER_CoinSpendPublicKeyP *coin_pub, const struct TALER_Amount *amount, const char *payto_uri, struct GNUNET_TIME_Timestamp deadline, bool done) { const struct TALER_EXCHANGEDB_Deposit *deposit = cls; (void) payto_uri; (void) deadline; (void) rowid; if (done) { GNUNET_break (0); result = 66; } if (0 != TALER_amount_cmp (amount, &deposit->amount_with_fee)) { GNUNET_break (0); result = 66; } if (0 != GNUNET_memcmp (coin_pub, &deposit->coin.coin_pub)) { GNUNET_break (0); result = 66; } } /** * Main function that will be run by the scheduler. * * @param cls closure with config */ static void run (void *cls) { struct GNUNET_CONFIGURATION_Handle *cfg = cls; const uint32_t num_partitions = 10; struct DenomKeyPair *dkp = NULL; struct GNUNET_TIME_Timestamp ts; struct TALER_EXCHANGEDB_Deposit depos; struct GNUNET_TIME_Timestamp deadline; struct TALER_Amount value; union TALER_DenominationBlindingKeyP bks; struct TALER_CoinPubHashP c_hash; struct TALER_EXCHANGEDB_CollectableBlindcoin cbc; struct TALER_EXCHANGEDB_CollectableBlindcoin cbc2; struct TALER_ExchangeWithdrawValues alg_values = { .cipher = TALER_DENOMINATION_RSA }; struct TALER_PlanchetMasterSecretP ps; struct TALER_ReservePublicKeyP reserve_pub; struct TALER_EXCHANGEDB_Refund ref; ZR_BLK (&cbc); ZR_BLK (&cbc2); RND_BLK (&reserve_pub); memset (&depos, 0, sizeof (depos)); memset (&ref, 0, sizeof (ref)); if (NULL == (plugin = TALER_EXCHANGEDB_plugin_load (cfg))) { GNUNET_break (0); result = 77; return; } (void) plugin->drop_tables (plugin->cls); if (GNUNET_OK != plugin->create_tables (plugin->cls, true, num_partitions)) { GNUNET_break (0); result = 77; goto cleanup; } if (GNUNET_OK != plugin->preflight (plugin->cls)) { GNUNET_break (0); goto cleanup; } GNUNET_assert (GNUNET_OK == TALER_string_to_amount (CURRENCY ":1.000010", &value)); GNUNET_assert (GNUNET_OK == TALER_string_to_amount (CURRENCY ":0.000010", &fees.withdraw)); GNUNET_assert (GNUNET_OK == TALER_string_to_amount (CURRENCY ":0.000010", &fees.deposit)); GNUNET_assert (GNUNET_OK == TALER_string_to_amount (CURRENCY ":0.000010", &fees.refresh)); GNUNET_assert (GNUNET_OK == TALER_string_to_amount (CURRENCY ":0.000010", &fees.refund)); ts = GNUNET_TIME_timestamp_get (); deadline = GNUNET_TIME_timestamp_get (); dkp = create_denom_key_pair (RSA_KEY_SIZE, ts, &value, &fees); GNUNET_assert (NULL != dkp); TALER_denom_pub_hash (&dkp->pub, &cbc.denom_pub_hash); RND_BLK (&cbc.reserve_sig); RND_BLK (&ps); TALER_planchet_blinding_secret_create (&ps, &alg_values, &bks); { struct TALER_PlanchetDetail pd; struct TALER_CoinSpendPublicKeyP coin_pub; struct TALER_AgeCommitmentHash age_hash; struct TALER_AgeCommitmentHash *p_ah[2] = { NULL, &age_hash }; RND_BLK (&age_hash); for (size_t i = 0; i < sizeof(p_ah) / sizeof(p_ah[0]); i++) { fprintf(stdout, "OPEN\n"); RND_BLK (&coin_pub); GNUNET_assert (GNUNET_OK == TALER_denom_blind (&dkp->pub, &bks, p_ah[i], &coin_pub, &alg_values, &c_hash, &pd.blinded_planchet)); GNUNET_assert (GNUNET_OK == TALER_coin_ev_hash (&pd.blinded_planchet, &cbc.denom_pub_hash, &cbc.h_coin_envelope)); if (i != 0) TALER_blinded_denom_sig_free (&cbc.sig); GNUNET_assert ( GNUNET_OK == TALER_denom_sign_blinded ( &cbc.sig, &dkp->priv, false, &pd.blinded_planchet)); TALER_blinded_planchet_free (&pd.blinded_planchet); } } cbc.reserve_pub = reserve_pub; cbc.amount_with_fee = value; GNUNET_assert (GNUNET_OK == TALER_amount_set_zero (CURRENCY, &cbc.withdraw_fee)); /*wire + deposit for get_ready_deposit*/ depos.deposit_fee = fees.deposit; RND_BLK (&depos.coin.coin_pub); TALER_denom_pub_hash (&dkp->pub, &depos.coin.denom_pub_hash); TALER_denom_pub_hash (&dkp->pub, &ref.coin.denom_pub_hash); GNUNET_assert (GNUNET_OK == TALER_denom_sig_unblind (&depos.coin.denom_sig, &cbc.sig, &bks, &c_hash, &alg_values, &dkp->pub)); { uint64_t known_coin_id; struct TALER_DenominationHashP dph; struct TALER_AgeCommitmentHash agh; FAILIF (TALER_EXCHANGEDB_CKS_ADDED != plugin->ensure_coin_known (plugin->cls, &depos.coin, &known_coin_id, &dph, &agh)); } { RND_BLK (&depos.merchant_pub); RND_BLK (&depos.csig); RND_BLK (&depos.h_contract_terms); RND_BLK (&depos.wire_salt); depos.amount_with_fee = value; depos.refund_deadline = deadline; depos.wire_deadline = deadline; depos.receiver_wire_account = "payto://iban/DE67830654080004822650?receiver-name=Test"; depos.timestamp = ts; result = 8; } /*STORE INTO DEPOSIT*/ { struct GNUNET_TIME_Timestamp now; struct GNUNET_TIME_Timestamp r; struct TALER_Amount deposit_fee; struct TALER_MerchantWireHashP h_wire; now = GNUNET_TIME_timestamp_get (); FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != plugin->insert_deposit (plugin->cls, now, &depos)); TALER_merchant_wire_signature_hash (depos.receiver_wire_account, &depos.wire_salt, &h_wire); FAILIF (1 != plugin->have_deposit2 (plugin->cls, &depos.h_contract_terms, &h_wire, &depos.coin.coin_pub, &depos.merchant_pub, depos.refund_deadline, &deposit_fee, &r)); FAILIF (GNUNET_TIME_timestamp_cmp (now, !=, r)); } { struct GNUNET_TIME_Timestamp start_range; struct GNUNET_TIME_Timestamp end_range; start_range = GNUNET_TIME_absolute_to_timestamp ( GNUNET_TIME_absolute_subtract (deadline.abs_time, GNUNET_TIME_UNIT_SECONDS)); end_range = GNUNET_TIME_absolute_to_timestamp ( GNUNET_TIME_absolute_add (deadline.abs_time, GNUNET_TIME_UNIT_SECONDS)); FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != plugin->select_deposits_missing_wire (plugin->cls, start_range, end_range, &wire_missing_cb, &depos)); FAILIF (8 != result); } auditor_row_cnt = 0; FAILIF (0 >= plugin->select_deposits_above_serial_id (plugin->cls, 0, &audit_deposit_cb, NULL)); FAILIF (0 == auditor_row_cnt); result = 8; sleep (2); /*CREATE DEPOSIT*/ { struct TALER_MerchantPublicKeyP merchant_pub2; char *payto_uri2; FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != plugin->get_ready_deposit (plugin->cls, 0, INT32_MAX, &merchant_pub2, &payto_uri2)); FAILIF (0 != GNUNET_memcmp (&merchant_pub2, &depos.merchant_pub)); FAILIF (0 != strcmp (payto_uri2, depos.receiver_wire_account)); TALER_payto_hash (payto_uri2, &wire_target_h_payto); GNUNET_free (payto_uri2); } /* { RND_BLK (&ref.details.merchant_pub); RND_BLK(&ref.details.merchant_sig); ref.details.h_contract_terms = depos.h_contract_terms; ref.coin.coin_pub = depos.coin.coin_pub; ref.details.rtransaction_id = 1; ref.details.refund_amount = value; ref.details.refund_fee = fees.refund; FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != plugin->insert_refund (plugin->cls, &ref)); }*/ result = 0; drop: GNUNET_break (GNUNET_OK == plugin->drop_tables (plugin->cls)); cleanup: if (NULL != dkp) destroy_denom_key_pair (dkp); TALER_denom_sig_free (&depos.coin.denom_sig); TALER_denom_sig_free (&ref.coin.denom_sig); TALER_blinded_denom_sig_free (&cbc.sig); dkp = NULL; TALER_EXCHANGEDB_plugin_unload (plugin); plugin = NULL; } int main (int argc, char *const argv[]) { const char *plugin_name; char *config_filename; char *testname; struct GNUNET_CONFIGURATION_Handle *cfg; (void) argc; result = -1; if (NULL == (plugin_name = strrchr (argv[0], (int) '-'))) { GNUNET_break (0); return -1; } GNUNET_log_setup (argv[0], "WARNING", NULL); plugin_name++; (void) GNUNET_asprintf (&testname, "test-exchange-db-%s", plugin_name); (void) GNUNET_asprintf (&config_filename, "%s.conf", testname); fprintf (stdout, "Using config: %s\n", config_filename); cfg = GNUNET_CONFIGURATION_create (); if (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, config_filename)) { GNUNET_break (0); GNUNET_free (config_filename); GNUNET_free (testname); return 2; } GNUNET_SCHEDULER_run (&run, cfg); GNUNET_CONFIGURATION_destroy (cfg); GNUNET_free (config_filename); GNUNET_free (testname); return result; } /* end of test_exchangedb_by_j.c */