LCOV - code coverage report
Current view: top level - exchangedb - test_refresh.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 98.8 % 252 249
Test Date: 2026-11-18 17:34:04 Functions: 100.0 % 15 15

            Line data    Source code
       1              : /*
       2              :   This file is part of TALER
       3              :   Copyright (C) 2026 Taler Systems SA
       4              : 
       5              :   TALER is free software; you can redistribute it and/or modify it under the
       6              :   terms of the GNU General Public License as published by the Free Software
       7              :   Foundation; either version 3, or (at your option) any later version.
       8              : 
       9              :   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
      10              :   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
      11              :   A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
      12              : 
      13              :   You should have received a copy of the GNU General Public License along with
      14              :   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
      15              : */
      16              : /**
      17              :  * @file exchangedb/test_refresh.c
      18              :  * @brief tests for the exchangedb functions whose primary table is
      19              :  *        `refresh`
      20              :  * @author Christian Grothoff
      21              :  *
      22              :  * Covers #TALER_EXCHANGEDB_do_refresh(), #TALER_EXCHANGEDB_get_refresh(),
      23              :  * #TALER_EXCHANGEDB_update_to_refresh_revealed(),
      24              :  * #TALER_EXCHANGEDB_iterate_refreshes_above_serial_id().
      25              :  *
      26              :  * `refresh` references `known_coins`, which TDB_coin() creates.  The
      27              :  * do_refresh() answers checked here are: unknown coin, insufficient coin
      28              :  * balance, the zombie requirement, blinding-seed reuse and an idempotent
      29              :  * replay.
      30              :  */
      31              : #include "test_common.h"
      32              : #include "exchange-database/do_refresh.h"
      33              : #include "exchange-database/get_known_coin.h"
      34              : #include "exchange-database/get_refresh.h"
      35              : #include "exchange-database/iterate_refreshes_above_serial_id.h"
      36              : #include "exchange-database/insert_records_by_table.h"
      37              : #include "exchange-database/iterate_records_by_table.h"
      38              : #include "exchange-database/update_to_refresh_revealed.h"
      39              : 
      40              : 
      41              : /**
      42              :  * Denomination the checks melt.
      43              :  */
      44              : static struct TDB_Denom denom;
      45              : 
      46              : 
      47              : /**
      48              :  * Fill in a refresh (melt) request for one fresh coin.
      49              :  *
      50              :  * @param seed seed for the commitment, signatures and seeds
      51              :  * @param amount amount to melt, e.g. "1"
      52              :  * @param coin coin being melted
      53              :  * @param with_seed true to pass a blinding seed and a CS R value
      54              :  * @param[out] rf set to the request; release with free_refresh()
      55              :  */
      56              : static void
      57            9 : make_refresh (uint32_t seed,
      58              :               const char *amount,
      59              :               const struct TALER_CoinPublicInfo *coin,
      60              :               bool with_seed,
      61              :               struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS *rf)
      62              : {
      63            9 :   memset (rf,
      64              :           0,
      65              :           sizeof (*rf));
      66            9 :   rf->coin.coin_pub = coin->coin_pub;
      67            9 :   rf->coin.denom_pub_hash = coin->denom_pub_hash;
      68            9 :   rf->coin.no_age_commitment = coin->no_age_commitment;
      69            9 :   TDB_fill (&rf->coin_sig,
      70              :             sizeof (rf->coin_sig),
      71              :             seed);
      72            9 :   TDB_fill (&rf->rc,
      73              :             sizeof (rf->rc),
      74              :             seed);
      75            9 :   TDB_fill (&rf->refresh_seed,
      76              :             sizeof (rf->refresh_seed),
      77              :             seed);
      78            9 :   TDB_fill (&rf->planchets_h,
      79              :             sizeof (rf->planchets_h),
      80              :             seed);
      81            9 :   TDB_fill (&rf->selected_h,
      82              :             sizeof (rf->selected_h),
      83              :             seed + 1);
      84            9 :   rf->amount_with_fee = TDB_amount (amount);
      85            9 :   rf->num_coins = 1;
      86            9 :   rf->denom_serials = GNUNET_new (uint64_t);
      87            9 :   rf->denom_serials[0] = denom.serial;
      88            9 :   rf->denom_sigs = GNUNET_new (struct TALER_BlindedDenominationSignature);
      89            9 :   TDB_blinded_denom_sig (seed,
      90              :                          &rf->denom_sigs[0]);
      91            9 :   rf->noreveal_index = 1;
      92              :   /* v27 refresh: the client provides no transfer public keys */
      93            9 :   rf->rc_version = TALER_REFRESH_COMMITMENT_VERSION_LEGACY_V27;
      94            9 :   rf->no_blinding_seed = ! with_seed;
      95            9 :   if (with_seed)
      96              :   {
      97            2 :     TDB_fill (&rf->blinding_seed,
      98              :               sizeof (rf->blinding_seed),
      99              :               seed);
     100            2 :     rf->num_cs_r_values = 1;
     101            2 :     rf->cs_r_values = GNUNET_new (struct GNUNET_CRYPTO_CSPublicRPairP);
     102            2 :     TDB_fill (rf->cs_r_values,
     103              :               sizeof (*rf->cs_r_values),
     104              :               seed);
     105            2 :     rf->cs_r_choices = 0;
     106              :   }
     107            9 : }
     108              : 
     109              : 
     110              : /**
     111              :  * Release what make_refresh() allocated.
     112              :  *
     113              :  * @param[in,out] rf request to clean up
     114              :  */
     115              : static void
     116           13 : free_refresh (struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS *rf)
     117              : {
     118           26 :   for (size_t i = 0; i<rf->num_coins; i++)
     119           13 :     TALER_blinded_denom_sig_free (&rf->denom_sigs[i]);
     120           13 :   GNUNET_free (rf->denom_sigs);
     121           13 :   GNUNET_free (rf->denom_serials);
     122           13 :   GNUNET_free (rf->cs_r_values);
     123           13 :   GNUNET_free (rf->transfer_pubs);
     124           13 :   GNUNET_free (rf->denom_pub_hashes);
     125           13 : }
     126              : 
     127              : 
     128              : /**
     129              :  * Outcome flags of a refresh request.
     130              :  */
     131              : struct RefreshStatus
     132              : {
     133              :   /**
     134              :    * Was there already a row for this commitment?
     135              :    */
     136              :   bool found;
     137              : 
     138              :   /**
     139              :    * Did the melt have to be of a zombie coin?
     140              :    */
     141              :   bool zombie_required;
     142              : 
     143              :   /**
     144              :    * Was the blinding seed used before?
     145              :    */
     146              :   bool nonce_reuse;
     147              : 
     148              :   /**
     149              :    * Was the coin balance sufficient?
     150              :    */
     151              :   bool balance_ok;
     152              : 
     153              :   /**
     154              :    * Balance the coin had.
     155              :    */
     156              :   struct TALER_Amount coin_balance;
     157              : 
     158              :   /**
     159              :    * Index the exchange chose not to reveal.
     160              :    */
     161              :   uint32_t noreveal_index;
     162              : };
     163              : 
     164              : 
     165              : /**
     166              :  * Perform a refresh request.
     167              :  *
     168              :  * @param pg the database context
     169              :  * @param rf the request
     170              :  * @param zombie_required whether the coin must be a zombie
     171              :  * @param[out] st set to the outcome
     172              :  * @return transaction status
     173              :  */
     174              : static enum GNUNET_DB_QueryStatus
     175           10 : run_refresh (struct TALER_EXCHANGEDB_PostgresContext *pg,
     176              :              struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS *rf,
     177              :              bool zombie_required,
     178              :              struct RefreshStatus *st)
     179              : {
     180           10 :   struct GNUNET_TIME_Timestamp now = GNUNET_TIME_timestamp_get ();
     181              : 
     182           10 :   memset (st,
     183              :           0,
     184              :           sizeof (*st));
     185           10 :   st->zombie_required = zombie_required;
     186           10 :   return TALER_EXCHANGEDB_do_refresh (pg,
     187              :                                       rf,
     188              :                                       &now,
     189              :                                       &st->found,
     190              :                                       &st->noreveal_index,
     191              :                                       &st->zombie_required,
     192              :                                       &st->nonce_reuse,
     193              :                                       &st->balance_ok,
     194              :                                       &st->coin_balance);
     195              : }
     196              : 
     197              : 
     198              : /**
     199              :  * Melting a coin that is not known does nothing.
     200              :  *
     201              :  * @param pg the database context
     202              :  * @return 0 on success
     203              :  */
     204              : static int
     205            1 : check_unknown_coin (struct TALER_EXCHANGEDB_PostgresContext *pg)
     206              : {
     207              :   struct TALER_CoinPublicInfo coin;
     208              :   struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS rf;
     209              :   struct RefreshStatus st;
     210              : 
     211            1 :   TDB_denom (pg,
     212              :              10,
     213              :              "5",
     214              :              "0.1",
     215              :              &denom);
     216            1 :   memset (&coin,
     217              :           0,
     218              :           sizeof (coin));
     219            1 :   TDB_FILL (coin.coin_pub,
     220              :             1);
     221            1 :   coin.denom_pub_hash = denom.h_denom_pub;
     222            1 :   coin.no_age_commitment = true;
     223            1 :   make_refresh (1,
     224              :                 "1",
     225              :                 &coin,
     226              :                 false,
     227              :                 &rf);
     228            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
     229              :             run_refresh (pg,
     230              :                          &rf,
     231              :                          false,
     232              :                          &st),
     233              :             free_refresh (&rf));
     234            1 :   free_refresh (&rf);
     235            1 :   FAILIF (0 != TDB_count (pg,
     236              :                           "FROM refresh"));
     237            1 :   return 0;
     238              : }
     239              : 
     240              : 
     241              : /**
     242              :  * Melting more than the coin is worth does nothing.
     243              :  *
     244              :  * @param pg the database context
     245              :  * @return 0 on success
     246              :  */
     247              : static int
     248            1 : check_insufficient_balance (struct TALER_EXCHANGEDB_PostgresContext *pg)
     249              : {
     250              :   struct TALER_CoinPublicInfo coin;
     251              :   struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS rf;
     252              :   struct RefreshStatus st;
     253            1 :   struct TALER_Amount expect = TDB_amount ("5");
     254              : 
     255            1 :   TDB_coin (pg,
     256              :             &denom,
     257              :             20,
     258              :             &coin,
     259              :             NULL);
     260            1 :   make_refresh (2,
     261              :                 "6",
     262              :                 &coin,
     263              :                 false,
     264              :                 &rf);
     265            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     266              :             run_refresh (pg,
     267              :                          &rf,
     268              :                          false,
     269              :                          &st),
     270              :             free_refresh (&rf); TDB_coin_free (&coin));
     271            1 :   free_refresh (&rf);
     272            1 :   FAILIF_C (st.balance_ok,
     273              :             TDB_coin_free (&coin));
     274            1 :   FAILIF_C (0 != TALER_amount_cmp (&st.coin_balance,
     275              :                                    &expect),
     276              :             TDB_coin_free (&coin));
     277              :   /* the row was written before the balance was checked, so the caller has
     278              :      to roll back -- here the check simply notes that it is there */
     279            1 :   FAILIF_C (1 != TDB_count (pg,
     280              :                             "FROM refresh"),
     281              :             TDB_coin_free (&coin));
     282            1 :   FAILIF_C (GNUNET_OK !=
     283              :             TDB_exec (pg,
     284              :                       "DELETE FROM refresh;"),
     285              :             TDB_coin_free (&coin));
     286            1 :   TDB_coin_free (&coin);
     287            1 :   return 0;
     288              : }
     289              : 
     290              : 
     291              : /**
     292              :  * A melt within the coin's balance is recorded and debits the coin.
     293              :  *
     294              :  * @param pg the database context
     295              :  * @return 0 on success
     296              :  */
     297              : static int
     298            1 : check_refresh (struct TALER_EXCHANGEDB_PostgresContext *pg)
     299              : {
     300              :   struct TALER_CoinPublicInfo coin;
     301              :   struct TALER_CoinPublicInfo got_coin;
     302              :   struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS rf;
     303              :   struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS got;
     304              :   struct RefreshStatus st;
     305            1 :   struct TALER_Amount expect_amount = TDB_amount ("1");
     306              : 
     307            1 :   TDB_coin (pg,
     308              :             &denom,
     309              :             20,
     310              :             &coin,
     311              :             NULL);
     312            1 :   make_refresh (3,
     313              :                 "1",
     314              :                 &coin,
     315              :                 true,
     316              :                 &rf);
     317            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     318              :             run_refresh (pg,
     319              :                          &rf,
     320              :                          false,
     321              :                          &st),
     322              :             free_refresh (&rf); TDB_coin_free (&coin));
     323            1 :   FAILIF_C (! st.balance_ok,
     324              :             free_refresh (&rf); TDB_coin_free (&coin));
     325            1 :   FAILIF_C (st.found,
     326              :             free_refresh (&rf); TDB_coin_free (&coin));
     327            1 :   FAILIF_C (st.nonce_reuse,
     328              :             free_refresh (&rf); TDB_coin_free (&coin));
     329            1 :   FAILIF_C (1 != TDB_count (pg,
     330              :                             "FROM refresh"),
     331              :             free_refresh (&rf); TDB_coin_free (&coin));
     332              : 
     333              :   /* the melt is on file with everything it was created with */
     334            1 :   memset (&got,
     335              :           0,
     336              :           sizeof (got));
     337            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     338              :             TALER_EXCHANGEDB_get_refresh (pg,
     339              :                                           &rf.rc,
     340              :                                           &got),
     341              :             free_refresh (&rf); TDB_coin_free (&coin));
     342            1 :   FAILIF_C (0 != TALER_amount_cmp (&got.amount_with_fee,
     343              :                                    &expect_amount),
     344              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     345            1 :   FAILIF_C (0 != GNUNET_memcmp (&got.coin.coin_pub,
     346              :                                 &coin.coin_pub),
     347              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     348            1 :   FAILIF_C (0 != GNUNET_memcmp (&got.coin_sig,
     349              :                                 &rf.coin_sig),
     350              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     351            1 :   FAILIF_C (0 != GNUNET_memcmp (&got.refresh_seed,
     352              :                                 &rf.refresh_seed),
     353              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     354            1 :   FAILIF_C (1 != got.num_coins,
     355              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     356            1 :   FAILIF_C (denom.serial != got.denom_serials[0],
     357              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     358            1 :   FAILIF_C (rf.noreveal_index != got.noreveal_index,
     359              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     360            1 :   FAILIF_C (got.revealed,
     361              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     362            1 :   FAILIF_C (got.no_blinding_seed,
     363              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     364            1 :   FAILIF_C (TALER_REFRESH_COMMITMENT_VERSION_LEGACY_V27 != got.rc_version,
     365              :             free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     366            1 :   free_refresh (&got);
     367              : 
     368              :   /* the coin was debited */
     369            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     370              :             TALER_EXCHANGEDB_get_known_coin (pg,
     371              :                                              &coin.coin_pub,
     372              :                                              &got_coin),
     373              :             free_refresh (&rf); TDB_coin_free (&coin));
     374            1 :   TALER_denom_sig_free (&got_coin.denom_sig);
     375              :   {
     376            1 :     char *hex = TDB_hex (&coin.coin_pub,
     377              :                          sizeof (coin.coin_pub));
     378              : 
     379            1 :     FAILIF_C (1 != TDB_count (pg,
     380              :                               "FROM known_coins"
     381              :                               " WHERE coin_pub=decode('%s','hex')"
     382              :                               "   AND remaining=ROW(4,0)::taler_amount",
     383              :                               hex),
     384              :               GNUNET_free (hex);
     385              :               free_refresh (&rf); TDB_coin_free (&coin));
     386            1 :     GNUNET_free (hex);
     387              :   }
     388              : 
     389              :   /* a replay is idempotent and reports the index we chose */
     390            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     391              :             run_refresh (pg,
     392              :                          &rf,
     393              :                          false,
     394              :                          &st),
     395              :             free_refresh (&rf); TDB_coin_free (&coin));
     396            1 :   FAILIF_C (! st.found,
     397              :             free_refresh (&rf); TDB_coin_free (&coin));
     398            1 :   FAILIF_C (rf.noreveal_index != st.noreveal_index,
     399              :             free_refresh (&rf); TDB_coin_free (&coin));
     400            1 :   FAILIF_C (1 != TDB_count (pg,
     401              :                             "FROM refresh"),
     402              :             free_refresh (&rf); TDB_coin_free (&coin));
     403            1 :   free_refresh (&rf);
     404            1 :   TDB_coin_free (&coin);
     405            1 :   return 0;
     406              : }
     407              : 
     408              : 
     409              : /**
     410              :  * Reusing a blinding seed is refused.
     411              :  *
     412              :  * @param pg the database context
     413              :  * @return 0 on success
     414              :  */
     415              : static int
     416            1 : check_nonce_reuse (struct TALER_EXCHANGEDB_PostgresContext *pg)
     417              : {
     418              :   struct TALER_CoinPublicInfo coin;
     419              :   struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS rf;
     420              :   struct RefreshStatus st;
     421              : 
     422            1 :   TDB_coin (pg,
     423              :             &denom,
     424              :             20,
     425              :             &coin,
     426              :             NULL);
     427              :   /* a fresh commitment, but the blinding seed of check_refresh() */
     428            1 :   make_refresh (4,
     429              :                 "1",
     430              :                 &coin,
     431              :                 true,
     432              :                 &rf);
     433            1 :   TDB_fill (&rf.blinding_seed,
     434              :             sizeof (rf.blinding_seed),
     435              :             3);
     436            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     437              :             run_refresh (pg,
     438              :                          &rf,
     439              :                          false,
     440              :                          &st),
     441              :             free_refresh (&rf); TDB_coin_free (&coin));
     442            1 :   FAILIF_C (! st.nonce_reuse,
     443              :             free_refresh (&rf); TDB_coin_free (&coin));
     444            1 :   FAILIF_C (st.found,
     445              :             free_refresh (&rf); TDB_coin_free (&coin));
     446            1 :   free_refresh (&rf);
     447            1 :   TDB_coin_free (&coin);
     448            1 :   FAILIF (1 != TDB_count (pg,
     449              :                           "FROM refresh"));
     450            1 :   return 0;
     451              : }
     452              : 
     453              : 
     454              : /**
     455              :  * A melt that insists on a zombie coin is refused when the coin never was
     456              :  * one.
     457              :  *
     458              :  * @param pg the database context
     459              :  * @return 0 on success
     460              :  */
     461              : static int
     462            1 : check_zombie_required (struct TALER_EXCHANGEDB_PostgresContext *pg)
     463              : {
     464              :   struct TALER_CoinPublicInfo coin;
     465              :   struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS rf;
     466              :   struct RefreshStatus st;
     467              : 
     468            1 :   TDB_coin (pg,
     469              :             &denom,
     470              :             21,
     471              :             &coin,
     472              :             NULL);
     473            1 :   make_refresh (5,
     474              :                 "1",
     475              :                 &coin,
     476              :                 false,
     477              :                 &rf);
     478            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     479              :             run_refresh (pg,
     480              :                          &rf,
     481              :                          true,
     482              :                          &st),
     483              :             free_refresh (&rf); TDB_coin_free (&coin));
     484            1 :   FAILIF_C (! st.zombie_required,
     485              :             free_refresh (&rf); TDB_coin_free (&coin));
     486            1 :   FAILIF_C (st.balance_ok,
     487              :             free_refresh (&rf); TDB_coin_free (&coin));
     488            1 :   free_refresh (&rf);
     489            1 :   TDB_coin_free (&coin);
     490              :   /* the row went in before the zombie check, so the caller must roll back */
     491            1 :   FAILIF (2 != TDB_count (pg,
     492              :                           "FROM refresh"));
     493            1 :   FAILIF (GNUNET_OK !=
     494              :           TDB_exec (pg,
     495              :                     "DELETE FROM refresh WHERE NOT revealed"
     496              :                     " AND rc <> (SELECT rc FROM refresh"
     497              :                     "             ORDER BY refresh_id ASC LIMIT 1);"));
     498            1 :   return 0;
     499              : }
     500              : 
     501              : 
     502              : /**
     503              :  * A melt can be marked as revealed, and marking one that does not exist
     504              :  * does nothing.
     505              :  *
     506              :  * @param pg the database context
     507              :  * @return 0 on success
     508              :  */
     509              : static int
     510            1 : check_revealed (struct TALER_EXCHANGEDB_PostgresContext *pg)
     511              : {
     512              :   struct TALER_RefreshCommitmentP rc;
     513              :   struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS got;
     514              : 
     515            1 :   TDB_FILL (rc,
     516              :             99);
     517            1 :   FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
     518              :           TALER_EXCHANGEDB_update_to_refresh_revealed (pg,
     519              :                                                        &rc));
     520            1 :   FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
     521              :           TALER_EXCHANGEDB_get_refresh (pg,
     522              :                                         &rc,
     523              :                                         &got));
     524              : 
     525            1 :   TDB_FILL (rc,
     526              :             3);
     527            1 :   FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     528              :           TALER_EXCHANGEDB_update_to_refresh_revealed (pg,
     529              :                                                        &rc));
     530            1 :   memset (&got,
     531              :           0,
     532              :           sizeof (got));
     533            1 :   FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     534              :           TALER_EXCHANGEDB_get_refresh (pg,
     535              :                                         &rc,
     536              :                                         &got));
     537            1 :   FAILIF_C (! got.revealed,
     538              :             free_refresh (&got));
     539            1 :   free_refresh (&got);
     540              :   /* marking it again is still reported as a row touched */
     541            1 :   FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     542              :           TALER_EXCHANGEDB_update_to_refresh_revealed (pg,
     543              :                                                        &rc));
     544            1 :   return 0;
     545              : }
     546              : 
     547              : 
     548              : /**
     549              :  * Closure for #refreshes_cb().
     550              :  */
     551              : struct RefreshesContext
     552              : {
     553              :   /**
     554              :    * How many melts did the callback see?
     555              :    */
     556              :   unsigned int total;
     557              : 
     558              :   /**
     559              :    * Stop after this many melts; 0 for no limit.
     560              :    */
     561              :   unsigned int stop_after;
     562              : 
     563              :   /**
     564              :    * Row of the last melt.
     565              :    */
     566              :   uint64_t rowid;
     567              : 
     568              :   /**
     569              :    * Amount of the last melt.
     570              :    */
     571              :   struct TALER_Amount amount;
     572              : 
     573              :   /**
     574              :    * Number of new denominations of the last melt.
     575              :    */
     576              :   size_t num_nds;
     577              : };
     578              : 
     579              : 
     580              : /**
     581              :  * Callback for #TALER_EXCHANGEDB_iterate_refreshes_above_serial_id().
     582              :  *
     583              :  * @param cls a `struct RefreshesContext *`
     584              :  * @param rowid row of the melt
     585              :  * @param old_denom_pub denomination of the melted coin
     586              :  * @param coin_pub the melted coin
     587              :  * @param coin_sig signature authorising the melt
     588              :  * @param h_age_commitment age commitment of the coin, NULL if none
     589              :  * @param amount_with_fee how much was melted
     590              :  * @param num_nds length of @a new_denom_serials
     591              :  * @param new_denom_serials denominations of the fresh coins
     592              :  * @param rc commitment of the melt
     593              :  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to stop
     594              :  */
     595              : static enum GNUNET_GenericReturnValue
     596            3 : refreshes_cb (void *cls,
     597              :               uint64_t rowid,
     598              :               const struct TALER_DenominationPublicKey *old_denom_pub,
     599              :               const struct TALER_CoinSpendPublicKeyP *coin_pub,
     600              :               const struct TALER_CoinSpendSignatureP *coin_sig,
     601              :               const struct TALER_AgeCommitmentHashP *h_age_commitment,
     602              :               const struct TALER_Amount *amount_with_fee,
     603              :               size_t num_nds,
     604              :               uint64_t new_denom_serials[static num_nds],
     605              :               const struct TALER_RefreshCommitmentP *rc)
     606            3 : {
     607            3 :   struct RefreshesContext *ctx = cls;
     608              : 
     609              :   (void) old_denom_pub;
     610              :   (void) coin_pub;
     611              :   (void) coin_sig;
     612              :   (void) h_age_commitment;
     613              :   (void) new_denom_serials;
     614              :   (void) rc;
     615            3 :   ctx->total++;
     616            3 :   ctx->rowid = rowid;
     617            3 :   ctx->amount = *amount_with_fee;
     618            3 :   ctx->num_nds = num_nds;
     619            3 :   if ( (0 != ctx->stop_after) &&
     620            1 :        (ctx->total >= ctx->stop_after) )
     621            1 :     return GNUNET_SYSERR;
     622            2 :   return GNUNET_OK;
     623              : }
     624              : 
     625              : 
     626              : /**
     627              :  * The auditor's view walks the melts by serial and stops when asked to.
     628              :  *
     629              :  * @param pg the database context
     630              :  * @return 0 on success
     631              :  */
     632              : static int
     633            1 : check_iterate (struct TALER_EXCHANGEDB_PostgresContext *pg)
     634              : {
     635              :   struct TALER_CoinPublicInfo coin;
     636              :   struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS rf;
     637              :   struct RefreshStatus st;
     638              :   struct RefreshesContext ctx;
     639              :   uint64_t rows;
     640              : 
     641              :   /* one more melt, so that "stop after the first" is distinguishable
     642              :      from "saw everything" */
     643            1 :   TDB_coin (pg,
     644              :             &denom,
     645              :             42,
     646              :             &coin,
     647              :             NULL);
     648            1 :   make_refresh (42,
     649              :                 "1",
     650              :                 &coin,
     651              :                 false,
     652              :                 &rf);
     653            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     654              :             run_refresh (pg,
     655              :                          &rf,
     656              :                          false,
     657              :                          &st),
     658              :             free_refresh (&rf); TDB_coin_free (&coin));
     659            1 :   free_refresh (&rf);
     660            1 :   TDB_coin_free (&coin);
     661            1 :   FAILIF (! st.balance_ok);
     662            1 :   rows = TDB_count (pg,
     663              :                     "FROM refresh");
     664            1 :   FAILIF (2 != rows);
     665            1 :   memset (&ctx,
     666              :           0,
     667              :           sizeof (ctx));
     668            1 :   FAILIF (0 >=
     669              :           TALER_EXCHANGEDB_iterate_refreshes_above_serial_id (
     670              :             pg,
     671              :             0,
     672              :             &refreshes_cb,
     673              :             &ctx));
     674            1 :   FAILIF (rows != ctx.total);
     675              :   /* every melt here asked for exactly one fresh coin */
     676            1 :   FAILIF (1 != ctx.num_nds);
     677              : 
     678              :   /* everything above the last row is nothing */
     679            1 :   memset (&ctx,
     680              :           0,
     681              :           sizeof (ctx));
     682            1 :   FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
     683              :           TALER_EXCHANGEDB_iterate_refreshes_above_serial_id (
     684              :             pg,
     685              :             UINT32_MAX,
     686              :             &refreshes_cb,
     687              :             &ctx));
     688            1 :   FAILIF (0 != ctx.total);
     689              : 
     690              :   /* a callback that says stop is not called again */
     691            1 :   memset (&ctx,
     692              :           0,
     693              :           sizeof (ctx));
     694            1 :   ctx.stop_after = 1;
     695            1 :   FAILIF (0 >=
     696              :           TALER_EXCHANGEDB_iterate_refreshes_above_serial_id (
     697              :             pg,
     698              :             0,
     699              :             &refreshes_cb,
     700              :             &ctx));
     701            1 :   FAILIF (1 != ctx.total);
     702            1 :   return 0;
     703              : }
     704              : 
     705              : 
     706              : /**
     707              :  * vDOLDPLUS melts keep the version of their refresh commitment, which
     708              :  * must agree with the presence of the transfer public keys.  New rows
     709              :  * default to the current version.
     710              :  *
     711              :  * @param pg the database context
     712              :  * @return 0 on success
     713              :  */
     714              : static int
     715            1 : check_rc_version (struct TALER_EXCHANGEDB_PostgresContext *pg)
     716              : {
     717              :   static const enum TALER_RefreshCommitmentVersion versions[] = {
     718              :     TALER_REFRESH_COMMITMENT_VERSION_LEGACY_VDOLDPLUS_BROKEN,
     719              :     TALER_REFRESH_COMMITMENT_VERSION_CURRENT
     720              :   };
     721              : 
     722            1 :   FAILIF (1 != TDB_count (pg,
     723              :                           "FROM information_schema.columns"
     724              :                           " WHERE table_name='refresh'"
     725              :                           "   AND column_name='rc_version'"
     726              :                           "   AND column_default='2'"));
     727            3 :   for (unsigned int i = 0; i < sizeof (versions) / sizeof (versions[0]); i++)
     728              :   {
     729              :     struct TALER_CoinPublicInfo coin;
     730              :     struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS rf;
     731              :     struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS got;
     732              :     struct RefreshStatus st;
     733              :     char *hex;
     734              : 
     735            2 :     TDB_coin (pg,
     736              :               &denom,
     737              :               50 + i,
     738              :               &coin,
     739              :               NULL);
     740            2 :     make_refresh (50 + i,
     741              :                   "1",
     742              :                   &coin,
     743              :                   false,
     744              :                   &rf);
     745            2 :     rf.rc_version = versions[i];
     746            2 :     rf.transfer_pubs = GNUNET_new_array (rf.num_coins,
     747              :                                          struct TALER_TransferPublicKeyP);
     748            2 :     TDB_fill (rf.transfer_pubs,
     749            2 :               sizeof (*rf.transfer_pubs) * rf.num_coins,
     750              :               50 + i);
     751            2 :     FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     752              :               run_refresh (pg,
     753              :                            &rf,
     754              :                            false,
     755              :                            &st),
     756              :               free_refresh (&rf); TDB_coin_free (&coin));
     757            2 :     FAILIF_C (! st.balance_ok,
     758              :               free_refresh (&rf); TDB_coin_free (&coin));
     759            2 :     memset (&got,
     760              :             0,
     761              :             sizeof (got));
     762            2 :     FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     763              :               TALER_EXCHANGEDB_get_refresh (pg,
     764              :                                             &rf.rc,
     765              :                                             &got),
     766              :               free_refresh (&rf); TDB_coin_free (&coin));
     767            2 :     FAILIF_C (versions[i] != got.rc_version,
     768              :               free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     769            2 :     FAILIF_C ( (NULL == got.transfer_pubs) ||
     770              :                (0 != GNUNET_memcmp (&got.transfer_pubs[0],
     771              :                                     &rf.transfer_pubs[0])),
     772              :                free_refresh (&got); free_refresh (&rf); TDB_coin_free (&coin));
     773            2 :     free_refresh (&got);
     774              : 
     775              :     /* a row whose version contradicts its transfer public keys is refused */
     776            2 :     hex = TDB_hex (&rf.rc,
     777              :                    sizeof (rf.rc));
     778            2 :     FAILIF_C (GNUNET_OK !=
     779              :               TDB_exec (pg,
     780              :                         "UPDATE refresh SET rc_version=0"
     781              :                         " WHERE rc=decode('%s','hex');",
     782              :                         hex),
     783              :               GNUNET_free (hex); free_refresh (&rf); TDB_coin_free (&coin));
     784            2 :     GNUNET_free (hex);
     785            2 :     memset (&got,
     786              :             0,
     787              :             sizeof (got));
     788            2 :     FAILIF_C (GNUNET_DB_STATUS_HARD_ERROR !=
     789              :               TALER_EXCHANGEDB_get_refresh (pg,
     790              :                                             &rf.rc,
     791              :                                             &got),
     792              :               free_refresh (&rf); TDB_coin_free (&coin));
     793            2 :     free_refresh (&rf);
     794            2 :     TDB_coin_free (&coin);
     795              :   }
     796            1 :   return 0;
     797              : }
     798              : 
     799              : 
     800              : /**
     801              :  * Closure for #replication_cb().
     802              :  */
     803              : struct ReplicationContext
     804              : {
     805              :   /**
     806              :    * The melt we look for.
     807              :    */
     808              :   const struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS *rf;
     809              : 
     810              :   /**
     811              :    * How many records matched @e rf.
     812              :    */
     813              :   unsigned int seen;
     814              : 
     815              :   /**
     816              :    * Set if a matching record differed from @e rf.
     817              :    */
     818              :   bool mismatch;
     819              : 
     820              :   /**
     821              :    * Serial of the matching record.
     822              :    */
     823              :   uint64_t serial;
     824              : 
     825              :   /**
     826              :    * Execution date of the matching record.
     827              :    */
     828              :   struct GNUNET_TIME_Timestamp execution_date;
     829              : };
     830              : 
     831              : 
     832              : /**
     833              :  * Callback for #TALER_EXCHANGEDB_iterate_records_by_table().
     834              :  *
     835              :  * @param cls a `struct ReplicationContext *`
     836              :  * @param td the record
     837              :  * @return #GNUNET_OK to continue iterating
     838              :  */
     839              : static int
     840           10 : replication_cb (void *cls,
     841              :                 const struct TALER_EXCHANGEDB_TableData *td)
     842              : {
     843           10 :   struct ReplicationContext *rc = cls;
     844           10 :   const struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS *rf = rc->rf;
     845              : 
     846           10 :   if (TALER_EXCHANGEDB_RT_REFRESH != td->table)
     847              :   {
     848            0 :     rc->mismatch = true;
     849            0 :     return GNUNET_OK;
     850              :   }
     851           10 :   if (0 != GNUNET_memcmp (&td->details.refresh.rc,
     852              :                           &rf->rc))
     853            8 :     return GNUNET_OK;
     854            2 :   rc->seen++;
     855            2 :   rc->serial = td->serial;
     856            2 :   rc->execution_date = td->details.refresh.execution_date;
     857            2 :   if ( (rf->num_coins != td->details.refresh.num_coins) ||
     858            2 :        (NULL == td->details.refresh.transfer_pubs) ||
     859            2 :        (0 != GNUNET_memcmp (&td->details.refresh.transfer_pubs[0],
     860            2 :                             &rf->transfer_pubs[0])) ||
     861            2 :        (! td->details.refresh.revealed) ||
     862            2 :        (rf->rc_version != td->details.refresh.rc_version) )
     863            0 :     rc->mismatch = true;
     864            2 :   return GNUNET_OK;
     865              : }
     866              : 
     867              : 
     868              : /**
     869              :  * The auditor replication copies a melt with its transfer public keys,
     870              :  * reveal status and commitment version.
     871              :  *
     872              :  * @param pg the database context
     873              :  * @return 0 on success
     874              :  */
     875              : static int
     876            1 : check_replication (struct TALER_EXCHANGEDB_PostgresContext *pg)
     877              : {
     878              :   struct TALER_CoinPublicInfo coin;
     879              :   struct TALER_EXCHANGEDB_Refresh_vDOLDPLUS rf;
     880              :   struct RefreshStatus st;
     881            1 :   struct ReplicationContext rc = {
     882              :     .rf = &rf
     883              :   };
     884            1 :   struct TALER_EXCHANGEDB_TableData td = {
     885              :     .table = TALER_EXCHANGEDB_RT_REFRESH
     886              :   };
     887              :   char *hex;
     888              : 
     889            1 :   TDB_coin (pg,
     890              :             &denom,
     891              :             60,
     892              :             &coin,
     893              :             NULL);
     894            1 :   make_refresh (60,
     895              :                 "1",
     896              :                 &coin,
     897              :                 false,
     898              :                 &rf);
     899            1 :   TDB_coin_free (&coin);
     900            1 :   rf.rc_version = TALER_REFRESH_COMMITMENT_VERSION_CURRENT;
     901            1 :   rf.transfer_pubs = GNUNET_new_array (rf.num_coins,
     902              :                                        struct TALER_TransferPublicKeyP);
     903            1 :   TDB_fill (rf.transfer_pubs,
     904            1 :             sizeof (*rf.transfer_pubs) * rf.num_coins,
     905              :             60);
     906            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     907              :             run_refresh (pg,
     908              :                          &rf,
     909              :                          false,
     910              :                          &st),
     911              :             free_refresh (&rf));
     912            1 :   hex = TDB_hex (&rf.rc,
     913              :                  sizeof (rf.rc));
     914            1 :   FAILIF_C (GNUNET_OK !=
     915              :             TDB_exec (pg,
     916              :                       "UPDATE refresh SET revealed=TRUE"
     917              :                       " WHERE rc=decode('%s','hex');",
     918              :                       hex),
     919              :             GNUNET_free (hex); free_refresh (&rf));
     920            1 :   FAILIF_C (0 >=
     921              :             TALER_EXCHANGEDB_iterate_records_by_table (
     922              :               pg,
     923              :               TALER_EXCHANGEDB_RT_REFRESH,
     924              :               0,
     925              :               &replication_cb,
     926              :               &rc),
     927              :             GNUNET_free (hex); free_refresh (&rf));
     928            1 :   FAILIF_C ( (1 != rc.seen) || rc.mismatch,
     929              :              GNUNET_free (hex); free_refresh (&rf));
     930              : 
     931              :   /* drop the melt (and the coin history entry its insert trigger made)
     932              :      and replicate it back in */
     933            1 :   FAILIF_C (GNUNET_OK !=
     934              :             TDB_exec (pg,
     935              :                       "DELETE FROM refresh"
     936              :                       " WHERE rc=decode('%s','hex');",
     937              :                       hex),
     938              :             GNUNET_free (hex); free_refresh (&rf));
     939            1 :   FAILIF_C (GNUNET_OK !=
     940              :             TDB_exec (pg,
     941              :                       "DELETE FROM coin_history"
     942              :                       " WHERE table_name='refresh'"
     943              :                       "   AND serial_id=%llu;",
     944              :                       (unsigned long long) rc.serial),
     945              :             GNUNET_free (hex); free_refresh (&rf));
     946            1 :   GNUNET_free (hex);
     947            1 :   td.serial = rc.serial;
     948            1 :   td.details.refresh.rc = rf.rc;
     949            1 :   td.details.refresh.execution_date = rc.execution_date;
     950            1 :   td.details.refresh.amount_with_fee = rf.amount_with_fee;
     951            1 :   td.details.refresh.old_coin_pub = rf.coin.coin_pub;
     952            1 :   td.details.refresh.old_coin_sig = rf.coin_sig;
     953            1 :   td.details.refresh.refresh_seed = rf.refresh_seed;
     954            1 :   td.details.refresh.noreveal_index = rf.noreveal_index;
     955            1 :   td.details.refresh.planchets_h = rf.planchets_h;
     956            1 :   td.details.refresh.selected_h = rf.selected_h;
     957            1 :   td.details.refresh.no_blinding_seed = true;
     958            1 :   td.details.refresh.num_coins = rf.num_coins;
     959            1 :   td.details.refresh.denom_serials = rf.denom_serials;
     960            1 :   td.details.refresh.denom_sigs = rf.denom_sigs;
     961            1 :   td.details.refresh.transfer_pubs = rf.transfer_pubs;
     962            1 :   td.details.refresh.revealed = true;
     963            1 :   td.details.refresh.rc_version = rf.rc_version;
     964            1 :   FAILIF_C (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
     965              :             TALER_EXCHANGEDB_insert_records_by_table (pg,
     966              :                                                       &td),
     967              :             free_refresh (&rf));
     968            1 :   rc.seen = 0;
     969            1 :   FAILIF_C (0 >=
     970              :             TALER_EXCHANGEDB_iterate_records_by_table (
     971              :               pg,
     972              :               TALER_EXCHANGEDB_RT_REFRESH,
     973              :               0,
     974              :               &replication_cb,
     975              :               &rc),
     976              :             free_refresh (&rf));
     977            1 :   free_refresh (&rf);
     978            1 :   FAILIF ( (1 != rc.seen) || rc.mismatch);
     979            1 :   FAILIF (td.serial != rc.serial);
     980            1 :   return 0;
     981              : }
     982              : 
     983              : 
     984              : /**
     985              :  * The checks to run, in order.
     986              :  */
     987              : static const struct TDB_Test tests[] = {
     988              :   { "refresh-unknown-coin",
     989              :     &check_unknown_coin },
     990              :   { "refresh-insufficient-balance",
     991              :     &check_insufficient_balance },
     992              :   { "refresh-refresh",
     993              :     &check_refresh },
     994              :   { "refresh-nonce-reuse",
     995              :     &check_nonce_reuse },
     996              :   { "refresh-zombie-required",
     997              :     &check_zombie_required },
     998              :   { "refresh-revealed",
     999              :     &check_revealed },
    1000              :   { "refresh-iterate",
    1001              :     &check_iterate },
    1002              :   { "refresh-rc-version",
    1003              :     &check_rc_version },
    1004              :   { "refresh-replication",
    1005              :     &check_replication },
    1006              :   { NULL, NULL }
    1007              : };
    1008              : 
    1009              : 
    1010              : int
    1011            1 : main (int argc,
    1012              :       char *const *argv)
    1013              : {
    1014              :   int ret;
    1015              : 
    1016            1 :   ret = TDB_main (argc,
    1017              :                   argv,
    1018              :                   "test-refresh",
    1019              :                   "Tests for the exchangedb `refresh' table",
    1020              :                   tests);
    1021            1 :   TDB_denom_free (&denom);
    1022            1 :   return ret;
    1023              : }
    1024              : 
    1025              : 
    1026              : /* end of test_refresh.c */
        

Generated by: LCOV version 2.0-1