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

store and retrieve arrays from database where arrays are the unit of transaction, to reduce number of DB interactions

Browse Source
This commit is contained in:
Christian Grothoff 2015-03-22 14:21:16 +01:00
parent 3a94a76aac
commit 81e234e723
4 changed files with 233 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
src/mint/plugin_mintdb_postgres.c
View File

@ -1637,8 +1637,8 @@ postgres_get_refresh_melt (void *cls,
* @param cls the `struct PostgresClosure` with the plugin-specific state * @param cls the `struct PostgresClosure` with the plugin-specific state
* @param session database connection * @param session database connection
* @param session_pub refresh session key * @param session_pub refresh session key
* @param newcoin_index index of the coin to generate * @param num_newcoins number of coins to generate, size of the @a denom_pubs array
* @param denom_pub denomination of the coin to create * @param denom_pubs array denominations of the coins to create
* @return #GNUNET_OK on success * @return #GNUNET_OK on success
* #GNUNET_SYSERR on internal error * #GNUNET_SYSERR on internal error
*/ */
@ -1646,16 +1646,16 @@ static int
postgres_insert_refresh_order (void *cls, postgres_insert_refresh_order (void *cls,
struct TALER_MINTDB_Session *session, struct TALER_MINTDB_Session *session,
const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
uint16_t newcoin_index, uint16_t num_newcoins,
const struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub) struct GNUNET_CRYPTO_rsa_PublicKey *const*denom_pubs)
{ {
// FIXME: check logic // FIXME: check logic: was written for just one COIN!
uint16_t newcoin_index_nbo = htons (newcoin_index); uint16_t newcoin_index_nbo = htons (num_newcoins);
char *buf; char *buf;
size_t buf_size; size_t buf_size;
PGresult *result; PGresult *result;
buf_size = GNUNET_CRYPTO_rsa_public_key_encode (denom_pub, buf_size = GNUNET_CRYPTO_rsa_public_key_encode (*denom_pubs,
&buf); &buf);
{ {
@ -1687,27 +1687,28 @@ postgres_insert_refresh_order (void *cls,
/** /**
* Lookup in the database the @a newcoin_index coin that we want to * Lookup in the database the coins that we want to
* create in the given refresh operation. * create in the given refresh operation.
* *
* @param cls the `struct PostgresClosure` with the plugin-specific state * @param cls the `struct PostgresClosure` with the plugin-specific state
* @param session database connection * @param session database connection
* @param session_pub refresh session key * @param session_pub refresh session key
* @param newcoin_index index of the coin to generate * @param newcoin_index array of the @a denom_pubs array
* @param denom_pub denomination of the coin to create * @param denom_pubs where to store the deomination keys
* @return NULL on error (not found or internal error) * @return #GNUNET_OK on success
* #GNUNET_SYSERR on internal error
*/ */
static struct GNUNET_CRYPTO_rsa_PublicKey * static int
postgres_get_refresh_order (void *cls, postgres_get_refresh_order (void *cls,
struct TALER_MINTDB_Session *session, struct TALER_MINTDB_Session *session,
const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
uint16_t newcoin_index) uint16_t num_newcoins,
struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs)
{ {
// FIXME: check logic // FIXME: check logic -- was written for just one coin!
char *buf; char *buf;
size_t buf_size; size_t buf_size;
struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub; uint16_t newcoin_index_nbo = htons (num_newcoins);
uint16_t newcoin_index_nbo = htons (newcoin_index);
struct TALER_DB_QueryParam params[] = { struct TALER_DB_QueryParam params[] = {
TALER_DB_QUERY_PARAM_PTR(session_pub), TALER_DB_QUERY_PARAM_PTR(session_pub),
@ -1715,20 +1716,21 @@ postgres_get_refresh_order (void *cls,
TALER_DB_QUERY_PARAM_END TALER_DB_QUERY_PARAM_END
}; };
PGresult *result = TALER_DB_exec_prepared (session->conn, "get_refresh_order", params); PGresult *result = TALER_DB_exec_prepared (session->conn,
"get_refresh_order", params);
if (PGRES_TUPLES_OK != PQresultStatus (result)) if (PGRES_TUPLES_OK != PQresultStatus (result))
{ {
BREAK_DB_ERR (result); BREAK_DB_ERR (result);
PQclear (result); PQclear (result);
return NULL; return GNUNET_SYSERR;
} }
if (0 == PQntuples (result)) if (0 == PQntuples (result))
{ {
PQclear (result); PQclear (result);
/* FIXME: may want to distinguish between different error cases! */ /* FIXME: may want to distinguish between different error cases! */
return NULL; return GNUNET_SYSERR;
} }
GNUNET_assert (1 == PQntuples (result)); GNUNET_assert (1 == PQntuples (result));
struct TALER_DB_ResultSpec rs[] = { struct TALER_DB_ResultSpec rs[] = {
@ -1739,12 +1741,12 @@ postgres_get_refresh_order (void *cls,
{ {
PQclear (result); PQclear (result);
GNUNET_break (0); GNUNET_break (0);
return NULL; return GNUNET_SYSERR;
} }
PQclear (result); PQclear (result);
denom_pub = GNUNET_CRYPTO_rsa_public_key_decode (buf, buf_size); denom_pubs[0] = GNUNET_CRYPTO_rsa_public_key_decode (buf, buf_size);
GNUNET_free (buf); GNUNET_free (buf);
return denom_pub; return GNUNET_OK;
} }
@ -1757,34 +1759,36 @@ postgres_get_refresh_order (void *cls,
* @param session database connection to use * @param session database connection to use
* @param refresh_session_pub refresh session this commitment belongs to * @param refresh_session_pub refresh session this commitment belongs to
* @param i set index (1st dimension) * @param i set index (1st dimension)
* @param j coin index (2nd dimension), corresponds to refreshed (new) coins * @param num_newcoins coin index size of the @a commit_coins array
* @param commit_coin coin commitment to store * @param commit_coins array of coin commitments to store
* @return #GNUNET_OK on success * @return #GNUNET_OK on success
* #GNUNET_SYSERR on error * #GNUNET_SYSERR on error
*/ */
static int static int
postgres_insert_refresh_commit_coin (void *cls, postgres_insert_refresh_commit_coins (void *cls,
struct TALER_MINTDB_Session *session, struct TALER_MINTDB_Session *session,
const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
unsigned int i, unsigned int i,
unsigned int j, unsigned int num_newcoins,
const struct RefreshCommitCoin *commit_coin) const struct RefreshCommitCoin *commit_coins)
{ {
// FIXME: check logic! // FIXME: check logic! -- was written for single commit_coin!
uint16_t cnc_index_nbo = htons (i); uint16_t cnc_index_nbo = htons (i);
uint16_t newcoin_index_nbo = htons (j); uint16_t newcoin_index_nbo = htons (num_newcoins);
struct TALER_DB_QueryParam params[] = { struct TALER_DB_QueryParam params[] = {
TALER_DB_QUERY_PARAM_PTR(refresh_session_pub), TALER_DB_QUERY_PARAM_PTR(refresh_session_pub),
TALER_DB_QUERY_PARAM_PTR_SIZED(commit_coin->coin_ev, commit_coin->coin_ev_size), TALER_DB_QUERY_PARAM_PTR_SIZED(commit_coins->coin_ev, commit_coins->coin_ev_size),
TALER_DB_QUERY_PARAM_PTR(&cnc_index_nbo), TALER_DB_QUERY_PARAM_PTR(&cnc_index_nbo),
TALER_DB_QUERY_PARAM_PTR(&newcoin_index_nbo), TALER_DB_QUERY_PARAM_PTR(&newcoin_index_nbo),
TALER_DB_QUERY_PARAM_PTR_SIZED(commit_coin->refresh_link->coin_priv_enc, TALER_DB_QUERY_PARAM_PTR_SIZED(commit_coins->refresh_link->coin_priv_enc,
commit_coin->refresh_link->blinding_key_enc_size + commit_coins->refresh_link->blinding_key_enc_size +
sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)), sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)),
TALER_DB_QUERY_PARAM_END TALER_DB_QUERY_PARAM_END
}; };
PGresult *result = TALER_DB_exec_prepared (session->conn, "insert_refresh_commit_coin", params); PGresult *result = TALER_DB_exec_prepared (session->conn,
"insert_refresh_commit_coin",
params);
if (PGRES_COMMAND_OK != PQresultStatus (result)) if (PGRES_COMMAND_OK != PQresultStatus (result))
{ {
@ -1819,7 +1823,7 @@ postgres_insert_refresh_commit_coin (void *cls,
* #GNUNET_SYSERR on error * #GNUNET_SYSERR on error
*/ */
static int static int
postgres_get_refresh_commit_coin (void *cls, postgres_get_refresh_commit_coins (void *cls,
struct TALER_MINTDB_Session *session, struct TALER_MINTDB_Session *session,
const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
unsigned int cnc_index, unsigned int cnc_index,
@ -1841,7 +1845,9 @@ postgres_get_refresh_commit_coin (void *cls,
size_t rl_buf_size; size_t rl_buf_size;
struct TALER_RefreshLinkEncrypted *rl; struct TALER_RefreshLinkEncrypted *rl;
PGresult *result = TALER_DB_exec_prepared (session->conn, "get_refresh_commit_coin", params); PGresult *result = TALER_DB_exec_prepared (session->conn,
"get_refresh_commit_coin",
params);
if (PGRES_TUPLES_OK != PQresultStatus (result)) if (PGRES_TUPLES_OK != PQresultStatus (result))
{ {
@ -1897,7 +1903,7 @@ postgres_get_refresh_commit_coin (void *cls,
* @return #GNUNET_SYSERR on internal error, #GNUNET_OK on success * @return #GNUNET_SYSERR on internal error, #GNUNET_OK on success
*/ */
static int static int
postgres_insert_refresh_commit_link (void *cls, postgres_insert_refresh_commit_links (void *cls,
struct TALER_MINTDB_Session *session, struct TALER_MINTDB_Session *session,
const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
unsigned int i, unsigned int i,
@ -1946,23 +1952,23 @@ postgres_insert_refresh_commit_link (void *cls,
* @param refresh_session_pub public key of the refresh session this * @param refresh_session_pub public key of the refresh session this
* commitment belongs with * commitment belongs with
* @param i set index (1st dimension) * @param i set index (1st dimension)
* @param j coin index (2nd dimension), corresponds to melted (old) coins * @param num_links size of the @a commit_link array
* @param cc[OUT] link information to return * @param links[OUT] array of link information to return
* @return #GNUNET_SYSERR on internal error, * @return #GNUNET_SYSERR on internal error,
* #GNUNET_NO if commitment was not found * #GNUNET_NO if commitment was not found
* #GNUNET_OK on success * #GNUNET_OK on success
*/ */
static int static int
postgres_get_refresh_commit_link (void *cls, postgres_get_refresh_commit_links (void *cls,
struct TALER_MINTDB_Session *session, struct TALER_MINTDB_Session *session,
const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
unsigned int cnc_index, unsigned int i,
unsigned int oldcoin_index, unsigned int num_links,
struct RefreshCommitLink *cc) struct RefreshCommitLink *links)
{ {
// FIXME: check logic! // FIXME: check logic: was written for a single link!
uint16_t cnc_index_nbo = htons (cnc_index); uint16_t cnc_index_nbo = htons (i);
uint16_t oldcoin_index_nbo = htons (oldcoin_index); uint16_t oldcoin_index_nbo = htons (num_links);
struct TALER_DB_QueryParam params[] = { struct TALER_DB_QueryParam params[] = {
TALER_DB_QUERY_PARAM_PTR(refresh_session_pub), TALER_DB_QUERY_PARAM_PTR(refresh_session_pub),
@ -1988,15 +1994,14 @@ postgres_get_refresh_commit_link (void *cls,
} }
struct TALER_DB_ResultSpec rs[] = { struct TALER_DB_ResultSpec rs[] = {
TALER_DB_RESULT_SPEC("transfer_pub", &cc->transfer_pub), TALER_DB_RESULT_SPEC("transfer_pub", &links->transfer_pub),
TALER_DB_RESULT_SPEC("link_secret_enc", &cc->shared_secret_enc), TALER_DB_RESULT_SPEC("link_secret_enc", &links->shared_secret_enc),
TALER_DB_RESULT_SPEC_END TALER_DB_RESULT_SPEC_END
}; };
if (GNUNET_YES != TALER_DB_extract_result (result, rs, 0)) if (GNUNET_YES != TALER_DB_extract_result (result, rs, 0))
{ {
PQclear (result); PQclear (result);
GNUNET_free (cc);
return GNUNET_SYSERR; return GNUNET_SYSERR;
} }
@ -2318,10 +2323,10 @@ libtaler_plugin_mintdb_postgres_init (void *cls)
plugin->get_refresh_melt = &postgres_get_refresh_melt; plugin->get_refresh_melt = &postgres_get_refresh_melt;
plugin->insert_refresh_order = &postgres_insert_refresh_order; plugin->insert_refresh_order = &postgres_insert_refresh_order;
plugin->get_refresh_order = &postgres_get_refresh_order; plugin->get_refresh_order = &postgres_get_refresh_order;
plugin->insert_refresh_commit_coin = &postgres_insert_refresh_commit_coin; plugin->insert_refresh_commit_coins = &postgres_insert_refresh_commit_coins;
plugin->get_refresh_commit_coin = &postgres_get_refresh_commit_coin; plugin->get_refresh_commit_coins = &postgres_get_refresh_commit_coins;
plugin->insert_refresh_commit_link = &postgres_insert_refresh_commit_link; plugin->insert_refresh_commit_links = &postgres_insert_refresh_commit_links;
plugin->get_refresh_commit_link = &postgres_get_refresh_commit_link; plugin->get_refresh_commit_links = &postgres_get_refresh_commit_links;
plugin->insert_refresh_collectable = &postgres_insert_refresh_collectable; plugin->insert_refresh_collectable = &postgres_insert_refresh_collectable;
plugin->get_link_data_list = &postgres_get_link_data_list; plugin->get_link_data_list = &postgres_get_link_data_list;
plugin->free_link_data_list = &common_free_link_data_list; plugin->free_link_data_list = &common_free_link_data_list;

162
src/mint/taler-mint-httpd_db.c
View File

@ -609,7 +609,6 @@ TALER_MINT_db_execute_refresh_melt (struct MHD_Connection *connection,
struct TALER_MINTDB_Session *session; struct TALER_MINTDB_Session *session;
int res; int res;
unsigned int i; unsigned int i;
unsigned int j;
if (NULL == (session = plugin->get_session (plugin->cls, if (NULL == (session = plugin->get_session (plugin->cls,
GNUNET_NO))) GNUNET_NO)))
@ -667,57 +666,48 @@ TALER_MINT_db_execute_refresh_melt (struct MHD_Connection *connection,
TALER_MINT_key_state_release (key_state); TALER_MINT_key_state_release (key_state);
/* store requested new denominations */ /* store requested new denominations */
for (i=0;i<num_new_denoms;i++)
{
if (GNUNET_OK != if (GNUNET_OK !=
plugin->insert_refresh_order (plugin->cls, plugin->insert_refresh_order (plugin->cls,
session, session,
refresh_session_pub, refresh_session_pub,
i, num_new_denoms,
denom_pubs[i])) denom_pubs))
{ {
plugin->rollback (plugin->cls, plugin->rollback (plugin->cls,
session); session);
return TALER_MINT_reply_internal_db_error (connection); return TALER_MINT_reply_internal_db_error (connection);
} }
}
for (i = 0; i < kappa; i++) for (i = 0; i < kappa; i++)
{
for (j = 0; j < num_new_denoms; j++)
{ {
if (GNUNET_OK != if (GNUNET_OK !=
plugin->insert_refresh_commit_coin (plugin->cls, plugin->insert_refresh_commit_coins (plugin->cls,
session, session,
refresh_session_pub, refresh_session_pub,
i, i,
j, num_new_denoms,
&commit_coin[i][j])) commit_coin[i]))
{ {
plugin->rollback (plugin->cls, plugin->rollback (plugin->cls,
session); session);
return TALER_MINT_reply_internal_db_error (connection); return TALER_MINT_reply_internal_db_error (connection);
} }
} }
}
for (i = 0; i < kappa; i++) for (i = 0; i < kappa; i++)
{
for (j = 0; j < coin_count; j++)
{ {
if (GNUNET_OK != if (GNUNET_OK !=
plugin->insert_refresh_commit_link (plugin->cls, plugin->insert_refresh_commit_links (plugin->cls,
session, session,
refresh_session_pub, refresh_session_pub,
i, i,
j, coin_count,
&commit_link[i][j])) commit_link[i]))
{ {
plugin->rollback (plugin->cls, plugin->rollback (plugin->cls,
session); session);
return TALER_MINT_reply_internal_db_error (connection); return TALER_MINT_reply_internal_db_error (connection);
} }
} }
}
/* store 'global' session data */ /* store 'global' session data */
@ -783,44 +773,48 @@ check_commitment (struct MHD_Connection *connection,
const struct GNUNET_CRYPTO_EcdsaPrivateKey *transfer_privs, const struct GNUNET_CRYPTO_EcdsaPrivateKey *transfer_privs,
const struct RefreshMelt *melts, const struct RefreshMelt *melts,
unsigned int num_newcoins, unsigned int num_newcoins,
struct GNUNET_CRYPTO_rsa_PublicKey *const*denom_pubs) struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs)
{ {
unsigned int j; unsigned int j;
int res;
struct TALER_LinkSecret last_shared_secret; struct TALER_LinkSecret last_shared_secret;
int secret_initialized = GNUNET_NO; int secret_initialized = GNUNET_NO;
struct GNUNET_CRYPTO_EcdhePublicKey coin_ecdhe; struct GNUNET_CRYPTO_EcdhePublicKey coin_ecdhe;
struct GNUNET_CRYPTO_EcdhePrivateKey transfer_ecdhe; struct GNUNET_CRYPTO_EcdhePrivateKey transfer_ecdhe;
struct RefreshCommitLink *commit_links;
struct RefreshCommitCoin *commit_coins;
for (j = 0; j < num_oldcoins; j++) commit_links = GNUNET_malloc (num_oldcoins *
{ sizeof (struct RefreshCommitLink));
struct RefreshCommitLink commit_link; if (GNUNET_OK !=
struct TALER_TransferSecret transfer_secret; plugin->get_refresh_commit_links (plugin->cls,
struct TALER_LinkSecret shared_secret;
struct GNUNET_CRYPTO_EcdsaPublicKey transfer_pub_check;
res = plugin->get_refresh_commit_link (plugin->cls,
session, session,
refresh_session, refresh_session,
off, off,
j, num_oldcoins,
&commit_link); commit_links))
if (GNUNET_OK != res)
{ {
GNUNET_break (0); GNUNET_break (0);
GNUNET_free (commit_links);
return (MHD_YES == TALER_MINT_reply_internal_db_error (connection)) return (MHD_YES == TALER_MINT_reply_internal_db_error (connection))
? GNUNET_NO : GNUNET_SYSERR; ? GNUNET_NO : GNUNET_SYSERR;
} }
for (j = 0; j < num_oldcoins; j++)
{
struct TALER_TransferSecret transfer_secret;
struct TALER_LinkSecret shared_secret;
struct GNUNET_CRYPTO_EcdsaPublicKey transfer_pub_check;
GNUNET_CRYPTO_ecdsa_key_get_public (&transfer_privs[j], GNUNET_CRYPTO_ecdsa_key_get_public (&transfer_privs[j],
&transfer_pub_check); &transfer_pub_check);
if (0 != if (0 !=
memcmp (&transfer_pub_check, memcmp (&transfer_pub_check,
&commit_link.transfer_pub, &commit_links[j].transfer_pub,
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))) sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
{ {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"transfer keys do not match\n"); "transfer keys do not match\n");
GNUNET_free (commit_links);
/* FIXME: return more specific error with original signature (#3712) */ /* FIXME: return more specific error with original signature (#3712) */
return (MHD_YES == return (MHD_YES ==
TALER_MINT_reply_refresh_reveal_missmatch (connection, TALER_MINT_reply_refresh_reveal_missmatch (connection,
@ -843,17 +837,19 @@ check_commitment (struct MHD_Connection *connection,
{ {
GNUNET_break (0); GNUNET_break (0);
GNUNET_CRYPTO_ecdhe_key_clear (&transfer_ecdhe); GNUNET_CRYPTO_ecdhe_key_clear (&transfer_ecdhe);
GNUNET_free (commit_links);
return (MHD_YES == TALER_MINT_reply_internal_error (connection, return (MHD_YES == TALER_MINT_reply_internal_error (connection,
"ECDH error")) "ECDH error"))
? GNUNET_NO : GNUNET_SYSERR; ? GNUNET_NO : GNUNET_SYSERR;
} }
GNUNET_CRYPTO_ecdhe_key_clear (&transfer_ecdhe); GNUNET_CRYPTO_ecdhe_key_clear (&transfer_ecdhe);
if (GNUNET_OK != if (GNUNET_OK !=
TALER_transfer_decrypt (&commit_link.shared_secret_enc, TALER_transfer_decrypt (&commit_links[j].shared_secret_enc,
&transfer_secret, &transfer_secret,
&shared_secret)) &shared_secret))
{ {
GNUNET_break (0); GNUNET_break (0);
GNUNET_free (commit_links);
return (MHD_YES == return (MHD_YES ==
TALER_MINT_reply_internal_error (connection, TALER_MINT_reply_internal_error (connection,
"Decryption error")) "Decryption error"))
@ -871,6 +867,7 @@ check_commitment (struct MHD_Connection *connection,
{ {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"shared secrets do not match\n"); "shared secrets do not match\n");
GNUNET_free (commit_links);
/* FIXME: return more specific error with original signature (#3712) */ /* FIXME: return more specific error with original signature (#3712) */
return (MHD_YES == return (MHD_YES ==
TALER_MINT_reply_refresh_reveal_missmatch (connection, TALER_MINT_reply_refresh_reveal_missmatch (connection,
@ -881,36 +878,40 @@ check_commitment (struct MHD_Connection *connection,
} }
} }
GNUNET_break (GNUNET_YES == secret_initialized); GNUNET_break (GNUNET_YES == secret_initialized);
GNUNET_free (commit_links);
/* Check that the commitments for all new coins were correct */ /* Check that the commitments for all new coins were correct */
commit_coins = GNUNET_malloc (num_newcoins *
sizeof (struct RefreshCommitCoin));
if (GNUNET_OK !=
plugin->get_refresh_commit_coins (plugin->cls,
session,
refresh_session,
off,
num_newcoins,
commit_coins))
{
GNUNET_break (0);
GNUNET_free (commit_coins);
return (MHD_YES == TALER_MINT_reply_internal_db_error (connection))
? GNUNET_NO : GNUNET_SYSERR;
}
for (j = 0; j < num_newcoins; j++) for (j = 0; j < num_newcoins; j++)
{ {
struct RefreshCommitCoin commit_coin;
struct TALER_RefreshLinkDecrypted *link_data; struct TALER_RefreshLinkDecrypted *link_data;
struct GNUNET_CRYPTO_EcdsaPublicKey coin_pub; struct GNUNET_CRYPTO_EcdsaPublicKey coin_pub;
struct GNUNET_HashCode h_msg; struct GNUNET_HashCode h_msg;
char *buf; char *buf;
size_t buf_len; size_t buf_len;
res = plugin->get_refresh_commit_coin (plugin->cls, link_data = TALER_refresh_decrypt (commit_coins[j].refresh_link,
session,
refresh_session,
off,
j,
&commit_coin);
if (GNUNET_OK != res)
{
GNUNET_break (0);
return (MHD_YES == TALER_MINT_reply_internal_db_error (connection))
? GNUNET_NO : GNUNET_SYSERR;
}
link_data = TALER_refresh_decrypt (commit_coin.refresh_link,
&last_shared_secret); &last_shared_secret);
if (NULL == link_data) if (NULL == link_data)
{ {
GNUNET_break (0); GNUNET_break (0);
GNUNET_free (commit_coins);
return (MHD_YES == TALER_MINT_reply_internal_error (connection, return (MHD_YES == TALER_MINT_reply_internal_error (connection,
"Decryption error")) "Decryption error"))
? GNUNET_NO : GNUNET_SYSERR; ? GNUNET_NO : GNUNET_SYSERR;
@ -932,14 +933,15 @@ check_commitment (struct MHD_Connection *connection,
{ {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"blind failed\n"); "blind failed\n");
GNUNET_free (commit_coins);
return (MHD_YES == TALER_MINT_reply_internal_error (connection, return (MHD_YES == TALER_MINT_reply_internal_error (connection,
"Blinding error")) "Blinding error"))
? GNUNET_NO : GNUNET_SYSERR; ? GNUNET_NO : GNUNET_SYSERR;
} }
if ( (buf_len != commit_coin.coin_ev_size) || if ( (buf_len != commit_coins[j].coin_ev_size) ||
(0 != memcmp (buf, (0 != memcmp (buf,
commit_coin.coin_ev, commit_coins[j].coin_ev,
buf_len)) ) buf_len)) )
{ {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@ -947,6 +949,7 @@ check_commitment (struct MHD_Connection *connection,
off, off,
(int) j); (int) j);
/* FIXME: return more specific error with original signature (#3712) */ /* FIXME: return more specific error with original signature (#3712) */
GNUNET_free (commit_coins);
return (MHD_YES == return (MHD_YES ==
TALER_MINT_reply_refresh_reveal_missmatch (connection, TALER_MINT_reply_refresh_reveal_missmatch (connection,
off, off,
@ -956,6 +959,7 @@ check_commitment (struct MHD_Connection *connection,
} }
GNUNET_free (buf); GNUNET_free (buf);
} }
GNUNET_free (commit_coins);
return GNUNET_OK; return GNUNET_OK;
} }
@ -970,8 +974,7 @@ check_commitment (struct MHD_Connection *connection,
* @param refresh_session session to query * @param refresh_session session to query
* @param key_state key state to lookup denomination pubs * @param key_state key state to lookup denomination pubs
* @param denom_pub denomination key for the coin to create * @param denom_pub denomination key for the coin to create
* @param noreveal_index which index should we use to obtain the * @param commit_coin the coin that was committed
* envelope for the coin, based on cut-and-choose
* @param coin_off number of the coin * @param coin_off number of the coin
* @return NULL on error, otherwise signature over the coin * @return NULL on error, otherwise signature over the coin
*/ */
@ -981,25 +984,12 @@ refresh_mint_coin (struct MHD_Connection *connection,
const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session, const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session,
struct MintKeyState *key_state, struct MintKeyState *key_state,
const struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub, const struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub,
unsigned int noreveal_index, const struct RefreshCommitCoin *commit_coin,
unsigned int coin_off) unsigned int coin_off)
{ {
struct RefreshCommitCoin commit_coin;
struct TALER_MINT_DenomKeyIssuePriv *dki; struct TALER_MINT_DenomKeyIssuePriv *dki;
struct GNUNET_CRYPTO_rsa_Signature *ev_sig; struct GNUNET_CRYPTO_rsa_Signature *ev_sig;
int res;
res = plugin->get_refresh_commit_coin (plugin->cls,
session,
refresh_session,
noreveal_index,
coin_off,
&commit_coin);
if (GNUNET_OK != res)
{
GNUNET_break (0);
return NULL;
}
dki = TALER_MINT_get_denom_key (key_state, denom_pub); dki = TALER_MINT_get_denom_key (key_state, denom_pub);
if (NULL == dki) if (NULL == dki)
{ {
@ -1007,8 +997,8 @@ refresh_mint_coin (struct MHD_Connection *connection,
return NULL; return NULL;
} }
ev_sig = GNUNET_CRYPTO_rsa_sign (dki->denom_priv, ev_sig = GNUNET_CRYPTO_rsa_sign (dki->denom_priv,
commit_coin.coin_ev, commit_coin->coin_ev,
commit_coin.coin_ev_size); commit_coin->coin_ev_size);
if (NULL == ev_sig) if (NULL == ev_sig)
{ {
GNUNET_break (0); GNUNET_break (0);
@ -1057,6 +1047,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
struct RefreshMelt *melts; struct RefreshMelt *melts;
struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs; struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs;
struct GNUNET_CRYPTO_rsa_Signature **ev_sigs; struct GNUNET_CRYPTO_rsa_Signature **ev_sigs;
struct RefreshCommitCoin *commit_coins;
unsigned int i; unsigned int i;
unsigned int j; unsigned int j;
unsigned int off; unsigned int off;
@ -1101,23 +1092,19 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
} }
denom_pubs = GNUNET_malloc (refresh_session.num_newcoins * denom_pubs = GNUNET_malloc (refresh_session.num_newcoins *
sizeof (struct GNUNET_CRYPTO_rsa_PublicKey *)); sizeof (struct GNUNET_CRYPTO_rsa_PublicKey *));
for (j=0;j<refresh_session.num_newcoins;j++) if (GNUNET_OK !=
{ plugin->get_refresh_order (plugin->cls,
denom_pubs[j] = plugin->get_refresh_order (plugin->cls,
session, session,
refresh_session_pub, refresh_session_pub,
j); refresh_session.num_newcoins,
if (NULL == denom_pubs[j]) denom_pubs))
{ {
GNUNET_break (0); GNUNET_break (0);
for (i=0;i<j;i++)
GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[i]);
GNUNET_free (denom_pubs); GNUNET_free (denom_pubs);
GNUNET_free (melts); GNUNET_free (melts);
return (MHD_YES == TALER_MINT_reply_internal_db_error (connection)) return (MHD_YES == TALER_MINT_reply_internal_db_error (connection))
? GNUNET_NO : GNUNET_SYSERR; ? GNUNET_NO : GNUNET_SYSERR;
} }
}
off = 0; off = 0;
@ -1157,6 +1144,23 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
return TALER_MINT_reply_internal_db_error (connection); return TALER_MINT_reply_internal_db_error (connection);
} }
commit_coins = GNUNET_malloc (refresh_session.num_newcoins *
sizeof (struct RefreshCommitCoin));
if (GNUNET_OK !=
plugin->get_refresh_commit_coins (plugin->cls,
session,
refresh_session_pub,
refresh_session.noreveal_index,
refresh_session.num_newcoins,
commit_coins))
{
GNUNET_break (0);
GNUNET_free (commit_coins);
for (j=0;j<refresh_session.num_newcoins;j++)
GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
GNUNET_free (denom_pubs);
return TALER_MINT_reply_internal_db_error (connection);
}
ev_sigs = GNUNET_malloc (refresh_session.num_newcoins * ev_sigs = GNUNET_malloc (refresh_session.num_newcoins *
sizeof (struct GNUNET_CRYPTO_rsa_Signature *)); sizeof (struct GNUNET_CRYPTO_rsa_Signature *));
key_state = TALER_MINT_key_state_acquire (); key_state = TALER_MINT_key_state_acquire ();
@ -1167,7 +1171,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
refresh_session_pub, refresh_session_pub,
key_state, key_state,
denom_pubs[j], denom_pubs[j],
refresh_session.noreveal_index, &commit_coins[j],
j); j);
if (NULL == ev_sigs[j]) if (NULL == ev_sigs[j])
{ {
@ -1178,6 +1182,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
for (j=0;j<refresh_session.num_newcoins;j++) for (j=0;j<refresh_session.num_newcoins;j++)
GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]); GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
GNUNET_free (denom_pubs); GNUNET_free (denom_pubs);
GNUNET_free (commit_coins);
return TALER_MINT_reply_internal_db_error (connection); return TALER_MINT_reply_internal_db_error (connection);
} }
} }
@ -1185,6 +1190,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
for (j=0;j<refresh_session.num_newcoins;j++) for (j=0;j<refresh_session.num_newcoins;j++)
GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]); GNUNET_CRYPTO_rsa_public_key_free (denom_pubs[j]);
GNUNET_free (denom_pubs); GNUNET_free (denom_pubs);
GNUNET_free (commit_coins);
if (GNUNET_OK != if (GNUNET_OK !=
plugin->commit (plugin->cls, plugin->commit (plugin->cls,

1
src/mint/taler-mint-httpd_db.h
View File

@ -126,7 +126,6 @@ struct MeltDetails
* future) * future)
* @return MHD result code * @return MHD result code
*/ */
// FIXME: see #3635.
int int
TALER_MINT_db_execute_refresh_melt (struct MHD_Connection *connection, TALER_MINT_db_execute_refresh_melt (struct MHD_Connection *connection,
const struct GNUNET_HashCode *melt_hash, const struct GNUNET_HashCode *melt_hash,

60
src/mint/taler_mintdb_plugin.h
View File

@ -781,8 +781,8 @@ struct TALER_MINTDB_Plugin
* @param cls the @e cls of this struct with the plugin-specific state * @param cls the @e cls of this struct with the plugin-specific state
* @param db_conn database connection * @param db_conn database connection
* @param session_pub refresh session key * @param session_pub refresh session key
* @param newcoin_index index of the coin to generate * @param num_newcoins number of coins to generate, size of the @a denom_pubs array
* @param denom_pub denomination of the coin to create * @param denom_pubs array denominations of the coins to create
* @return #GNUNET_OK on success * @return #GNUNET_OK on success
* #GNUNET_SYSERR on internal error * #GNUNET_SYSERR on internal error
*/ */
@ -790,48 +790,50 @@ struct TALER_MINTDB_Plugin
(*insert_refresh_order) (void *cls, (*insert_refresh_order) (void *cls,
struct TALER_MINTDB_Session *db_conn, struct TALER_MINTDB_Session *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
uint16_t newcoin_index, uint16_t num_newcoins,
const struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub); struct GNUNET_CRYPTO_rsa_PublicKey *const*denom_pubs);
/** /**
* Lookup in the database the @a newcoin_index coin that we want to * Lookup in the database for the @a num_newcoins coins that we want to
* create in the given refresh operation. * create in the given refresh operation.
* *
* @param cls the @e cls of this struct with the plugin-specific state * @param cls the @e cls of this struct with the plugin-specific state
* @param db_conn database connection * @param db_conn database connection
* @param session_pub refresh session key * @param session_pub refresh session key
* @param newcoin_index index of the coin to generate * @param num_newcoins size of the @a denom_pubs array
* @param denom_pub denomination of the coin to create * @param denom_pubs[OUT] where to write @a num_newcoins denomination keys
* @return NULL on error (not found or internal error) * @return #GNUNET_OK on success
* #GNUNET_SYSERR on internal error
*/ */
struct GNUNET_CRYPTO_rsa_PublicKey * int
(*get_refresh_order) (void *cls, (*get_refresh_order) (void *cls,
struct TALER_MINTDB_Session *db_conn, struct TALER_MINTDB_Session *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
uint16_t newcoin_index); uint16_t num_newcoins,
struct GNUNET_CRYPTO_rsa_PublicKey **denom_pubs);
/** /**
* Store information about the commitment of the * Store information about the commitments of the given index @a i
* given coin for the given refresh session in the database. * for the given refresh session in the database.
* *
* @param cls the @e cls of this struct with the plugin-specific state * @param cls the @e cls of this struct with the plugin-specific state
* @param db_conn database connection to use * @param db_conn database connection to use
* @param refresh_session_pub refresh session this commitment belongs to * @param refresh_session_pub refresh session this commitment belongs to
* @param i set index (1st dimension) * @param i set index (1st dimension), relating to kappa
* @param j coin index (2nd dimension), corresponds to refreshed (new) coins * @param num_newcoins coin index size of the @a commit_coins array
* @param commit_coin coin commitment to store * @param commit_coin array of coin commitments to store
* @return #GNUNET_OK on success * @return #GNUNET_OK on success
* #GNUNET_SYSERR on error * #GNUNET_SYSERR on error
*/ */
int int
(*insert_refresh_commit_coin) (void *cls, (*insert_refresh_commit_coins) (void *cls,
struct TALER_MINTDB_Session *db_conn, struct TALER_MINTDB_Session *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
unsigned int i, unsigned int i,
unsigned int j, unsigned int num_newcoins,
const struct RefreshCommitCoin *commit_coin); const struct RefreshCommitCoin *commit_coins);
/** /**
@ -849,7 +851,7 @@ struct TALER_MINTDB_Plugin
* #GNUNET_SYSERR on error * #GNUNET_SYSERR on error
*/ */
int int
(*get_refresh_commit_coin) (void *cls, (*get_refresh_commit_coins) (void *cls,
struct TALER_MINTDB_Session *db_conn, struct TALER_MINTDB_Session *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
unsigned int i, unsigned int i,
@ -865,18 +867,18 @@ struct TALER_MINTDB_Plugin
* @param db_conn database connection to use * @param db_conn database connection to use
* @param refresh_session_pub public key of the refresh session this * @param refresh_session_pub public key of the refresh session this
* commitment belongs with * commitment belongs with
* @param i set index (1st dimension) * @param i set index (1st dimension), relating to kappa
* @param j coin index (2nd dimension), corresponds to melted (old) coins * @param num_links size of the @a commit_link array
* @param commit_link link information to store * @param commit_links array of link information to store
* @return #GNUNET_SYSERR on internal error, #GNUNET_OK on success * @return #GNUNET_SYSERR on internal error, #GNUNET_OK on success
*/ */
int int
(*insert_refresh_commit_link) (void *cls, (*insert_refresh_commit_links) (void *cls,
struct TALER_MINTDB_Session *db_conn, struct TALER_MINTDB_Session *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
unsigned int i, unsigned int i,
unsigned int j, unsigned int num_links,
const struct RefreshCommitLink *commit_link); const struct RefreshCommitLink *commit_links);
/** /**
* Obtain the commited (encrypted) refresh link data * Obtain the commited (encrypted) refresh link data
@ -887,19 +889,19 @@ struct TALER_MINTDB_Plugin
* @param refresh_session_pub public key of the refresh session this * @param refresh_session_pub public key of the refresh session this
* commitment belongs with * commitment belongs with
* @param i set index (1st dimension) * @param i set index (1st dimension)
* @param j coin index (2nd dimension), corresponds to melted (old) coins * @param num_links size of the @links array to return
* @param cc[OUT] link information to return * @param links[OUT] array link information to return
* @return #GNUNET_SYSERR on internal error, * @return #GNUNET_SYSERR on internal error,
* #GNUNET_NO if commitment was not found * #GNUNET_NO if commitment was not found
* #GNUNET_OK on success * #GNUNET_OK on success
*/ */
int int
(*get_refresh_commit_link) (void *cls, (*get_refresh_commit_links) (void *cls,
struct TALER_MINTDB_Session *db_conn, struct TALER_MINTDB_Session *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub, const struct GNUNET_CRYPTO_EddsaPublicKey *refresh_session_pub,
unsigned int i, unsigned int i,
unsigned int j, unsigned int j,
struct RefreshCommitLink *cc); struct RefreshCommitLink *links);
/** /**