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

cleaning up mint_db API

Browse Source
This commit is contained in:
Christian Grothoff 2015-01-28 22:18:53 +01:00
parent fd1bcfecfa
commit 1466048e4d
6 changed files with 922 additions and 689 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/mint/mint.h
View File

@ -35,36 +35,6 @@
/**
* Information we keep for a withdrawn coin to reproduce
* the /withdraw operation if needed, and to have proof
* that a reserve was drained by this amount.
*/
struct CollectableBlindcoin
{
/**
* Our signature over the (blinded) coin.
*/
struct GNUNET_CRYPTO_rsa_Signature *sig;
/**
* Denomination key (which coin was generated).
*/
struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub;
/**
* Public key of the reserve that was drained.
*/
struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
/**
* Signature confirming the withdrawl, matching @e reserve_pub,
* @e denom_pub and @e h_blind.
*/
struct GNUNET_CRYPTO_EddsaSignature reserve_sig;
};
/**
* Global information for a refreshing session.

974
src/mint/mint_db.c
View File

File diff suppressed because it is too large Load Diff

465
src/mint/mint_db.h
View File

@ -30,59 +30,14 @@
#include "mint.h"
/**
* FIXME.
*/
int
TALER_MINT_DB_prepare (PGconn *db_conn);
/**
* Locate the response for a /withdraw request under the
* key of the hash of the blinded message.
*
* @param db_conn database connection to use
* @param h_blind hash of the blinded message
* @param collectable corresponding collectable coin (blind signature)
* if a coin is found
* @return #GNUNET_SYSERR on internal error
* #GNUNET_NO if the collectable was not found
* #GNUNET_YES on success
*/
int
TALER_MINT_DB_get_collectable_blindcoin (PGconn *db_conn,
const struct GNUNET_HashCode *h_blind,
struct CollectableBlindcoin *collectable);
/**
* Store collectable bit coin under the corresponding
* hash of the blinded message.
*
* @param db_conn database connection to use
* @param h_blind hash of the blinded message
* @param collectable corresponding collectable coin (blind signature)
* if a coin is found
* @return #GNUNET_SYSERR on internal error
* #GNUNET_NO if the collectable was not found
* #GNUNET_YES on success
*/
int
TALER_MINT_DB_insert_collectable_blindcoin (PGconn *db_conn,
const struct GNUNET_HashCode *h_blind,
const struct CollectableBlindcoin *collectable);
int
TALER_MINT_DB_rollback (PGconn *db_conn);
int
TALER_MINT_DB_transaction (PGconn *db_conn);
int
TALER_MINT_DB_commit (PGconn *db_conn);
/**
* Reserve row. Corresponds to table 'reserves' in the mint's
* database. FIXME: not sure this is how we want to store this
@ -151,6 +106,9 @@ TALER_MINT_DB_update_reserve (PGconn *db_conn,
int
TALER_MINT_DB_insert_refresh_order (PGconn *db_conn,
uint16_t newcoin_index,
@ -163,8 +121,6 @@ TALER_MINT_DB_get_refresh_session (PGconn *db_conn,
struct RefreshSession *r_session);
/**
* FIXME
*/
@ -201,10 +157,6 @@ TALER_MINT_DB_insert_known_coin (PGconn *db_conn,
const struct KnownCoin *known_coin);
int
TALER_MINT_DB_create_refresh_session (PGconn *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub);
@ -276,19 +228,6 @@ TALER_MINT_DB_set_reveal_ok (PGconn *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub);
int
TALER_MINT_DB_insert_refresh_melt (PGconn *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
uint16_t oldcoin_index,
const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
const struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub);
int
TALER_MINT_DB_get_refresh_melt (PGconn *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *session_pub,
uint16_t oldcoin_index,
struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub);
/**
@ -320,13 +259,139 @@ TALER_db_get_transfer (PGconn *db_conn,
struct GNUNET_CRYPTO_EcdsaPublicKey *transfer_pub,
struct GNUNET_HashCode *shared_secret_enc);
int
TALER_MINT_DB_init_deposits (PGconn *db_conn, int temporary);
int
TALER_MINT_DB_prepare_deposits (PGconn *db_conn);
TALER_TALER_DB_extract_amount (PGresult *result,
unsigned int row,
int indices[3],
struct TALER_Amount *denom);
int
TALER_TALER_DB_extract_amount_nbo (PGresult *result,
unsigned int row,
int indices[3],
struct TALER_AmountNBO *denom_nbo);
// Chaos
////////////////////////////////////////////////////////////////
// Order
/**
* Initialize database subsystem.
*/
int
TALER_MINT_DB_init (const char *connection_cfg);
/**
* Get the thread-local database-handle.
* Connect to the db if the connection does not exist yet.
*
* @param the database connection, or NULL on error
*/
PGconn *
TALER_MINT_DB_get_connection (void);
/**
* Start a transaction.
*
* @return #GNUNET_OK on success
*/
int
TALER_MINT_DB_transaction (PGconn *db_conn);
/**
* Commit a transaction.
*
* @return #GNUNET_OK on success
*/
int
TALER_MINT_DB_commit (PGconn *db_conn);
/**
* Abort/rollback a transaction.
*
* @return #GNUNET_OK on success
*/
int
TALER_MINT_DB_rollback (PGconn *db_conn);
/**
* Information we keep for a withdrawn coin to reproduce
* the /withdraw operation if needed, and to have proof
* that a reserve was drained by this amount.
*/
struct CollectableBlindcoin
{
/**
* Our signature over the (blinded) coin.
*/
struct GNUNET_CRYPTO_rsa_Signature *sig;
/**
* Denomination key (which coin was generated).
*/
struct GNUNET_CRYPTO_rsa_PublicKey *denom_pub;
/**
* Public key of the reserve that was drained.
*/
struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
/**
* Signature confirming the withdrawl, matching @e reserve_pub,
* @e denom_pub and @e h_blind.
*/
struct GNUNET_CRYPTO_EddsaSignature reserve_sig;
};
/**
* Locate the response for a /withdraw request under the
* key of the hash of the blinded message.
*
* @param db_conn database connection to use
* @param h_blind hash of the blinded message
* @param collectable corresponding collectable coin (blind signature)
* if a coin is found
* @return #GNUNET_SYSERR on internal error
* #GNUNET_NO if the collectable was not found
* #GNUNET_YES on success
*/
int
TALER_MINT_DB_get_collectable_blindcoin (PGconn *db_conn,
const struct GNUNET_HashCode *h_blind,
struct CollectableBlindcoin *collectable);
/**
* Store collectable bit coin under the corresponding
* hash of the blinded message.
*
* @param db_conn database connection to use
* @param h_blind hash of the blinded message
* @param collectable corresponding collectable coin (blind signature)
* if a coin is found
* @return #GNUNET_SYSERR on internal error
* #GNUNET_NO if the collectable was not found
* #GNUNET_YES on success
*/
int
TALER_MINT_DB_insert_collectable_blindcoin (PGconn *db_conn,
const struct GNUNET_HashCode *h_blind,
const struct CollectableBlindcoin *collectable);
/**
@ -384,59 +449,253 @@ struct Deposit
*/
struct TALER_Amount amount;
/**
* Type of the deposit (also purpose of the signature). Either
* #TALER_SIGNATURE_DEPOSIT or #TALER_SIGNATURE_INCREMENTAL_DEPOSIT.
*/
uint32_t purpose; // FIXME: bad type, use ENUM!
};
/**
* Check if we have the specified deposit already in the database.
*
* @param db_conn database connection
* @param deposit deposit to search for
* @return #GNUNET_YES if we know this operation,
* #GNUNET_NO if this deposit is unknown to us,
* #GNUNET_SYSERR on internal error
*/
int
TALER_MINT_DB_have_deposit (PGconn *db_conn,
const struct Deposit *deposit);
/**
* Insert information about deposited coin into the
* database.
*
* @param db_conn connection to the database
* @param deposit deposit information to store
* @return #GNUNET_OK on success, #GNUNET_SYSERR on error
*/
int
TALER_MINT_DB_insert_deposit (PGconn *db_conn,
const struct Deposit *deposit);
// FIXME: with fractional deposits, we need more than
// just the coin key to lookup deposits...
int
TALER_MINT_DB_get_deposit (PGconn *db_conn,
const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub,
struct Deposit *r_deposit);
/**
* Specification for a /refresh/melt operation.
*/
struct RefreshMelt
{
/**
* Information about the coin that is being melted.
*/
struct TALER_CoinPublicInfo coin;
/**
* Public key of the melting session.
*/
struct GNUNET_CRYPTO_EddsaPublicKey session_pub;
/**
* Signature over the melting operation.
*/
struct GNUNET_CRYPTO_EcdsaSignature coin_sig;
/**
* How much value is being melted?
*/
struct TALER_Amount amount;
/**
* What is the index of this coin in the melting session?
*/
uint16_t oldcoin_index;
};
/**
* Get the thread-local database-handle.
* Connect to the db if the connection does not exist yet.
* Test if the given /refresh/melt request is known to us.
*
* @param the database connection, or NULL on error
* @param db_conn database connection
* @param melt melt operation
* @return #GNUNET_YES if known,
* #GNUENT_NO if not,
* #GNUNET_SYSERR on internal error
*/
PGconn *
TALER_MINT_DB_get_connection (void);
int
TALER_MINT_DB_init (const char *connection_cfg);
TALER_MINT_DB_have_refresh_melt (PGconn *db_conn,
const struct RefreshMelt *melt);
/**
* Store the given /refresh/melt request in the database.
*
* @param db_conn database connection
* @param melt melt operation
* @return #GNUNET_OK on success
* #GNUNET_SYSERR on internal error
*/
int
TALER_TALER_DB_extract_amount (PGresult *result,
unsigned int row,
int indices[3],
struct TALER_Amount *denom);
TALER_MINT_DB_insert_refresh_melt (PGconn *db_conn,
const struct RefreshMelt *melt);
/**
* Get information about melted coin details from the database.
*
* @param db_conn database connection
* @param session session key of the melt operation
* @param oldcoin_index index of the coin to retrieve
* @param melt melt data to fill in
* @return #GNUNET_OK on success
* #GNUNET_SYSERR on internal error
*/
int
TALER_TALER_DB_extract_amount_nbo (PGresult *result,
unsigned int row,
int indices[3],
struct TALER_AmountNBO *denom_nbo);
TALER_MINT_DB_get_refresh_melt (PGconn *db_conn,
const struct GNUNET_CRYPTO_EddsaPublicKey *session,
uint16_t oldcoin_index,
struct RefreshMelt *melt);
/**
* Specification for a /lock operation.
*/
struct Lock
{
/**
* Information about the coin that is being melted.
*/
struct TALER_CoinPublicInfo coin;
/**
* Signature over the melting operation.
*/
const struct GNUNET_CRYPTO_EcdsaSignature coin_sig;
/**
* How much value is being melted?
*/
struct TALER_Amount amount;
// FIXME: more needed...
};
/**
* Test if the given /lock request is known to us.
*
* @param db_conn database connection
* @param lock lock operation
* @return #GNUNET_YES if known,
* #GNUENT_NO if not,
* #GNUNET_SYSERR on internal error
*/
int
TALER_MINT_DB_have_lock (PGconn *db_conn,
const struct Lock *lock);
/**
* Store the given /lock request in the database.
*
* @param db_conn database connection
* @param lock lock operation
* @return #GNUNET_OK on success
* #GNUNET_SYSERR on internal error
*/
int
TALER_MINT_DB_insert_lock (PGconn *db_conn,
const struct Lock *lock);
/**
* Enumeration to classify the different types of transactions
* that can be done with a coin.
*/
enum TALER_MINT_DB_TransactionType
{
/**
* /deposit operation.
*/
TALER_MINT_DB_TT_DEPOSIT = 0,
/**
* /refresh/melt operation.
*/
TALER_MINT_DB_TT_REFRESH_MELT = 1,
/**
* /lock operation.
*/
TALER_MINT_DB_TT_LOCK = 2
};
/**
* List of transactions we performed for a particular coin.
*/
struct TALER_MINT_DB_TransactionList
{
/**
* Next pointer in the NULL-terminated linked list.
*/
struct TALER_MINT_DB_TransactionList *next;
/**
* Type of the transaction, determines what is stored in @e details.
*/
enum TALER_MINT_DB_TransactionType type;
/**
* Details about the transaction, depending on @e type.
*/
union
{
/**
* Details if transaction was a /deposit operation.
*/
struct Deposit *deposit;
/**
* Details if transaction was a /refresh/melt operation.
*/
struct RefreshMelt *melt;
/**
* Details if transaction was a /lock operation.
*/
struct Lock *lock;
} details;
};
/**
* Compile a list of all (historic) transactions performed
* with the given coin (/refresh/melt and /deposit operations).
*
* @param db_conn database connection
* @param coin_pub coin to investigate
* @return list of transactions, NULL if coin is fresh
*/
struct TALER_MINT_DB_TransactionList *
TALER_MINT_DB_get_coin_transactions (PGconn *db_conn,
const struct GNUNET_CRYPTO_EcdsaPublicKey *coin_pub);
/**
* Free linked list of transactions.
*
* @param list list to free
*/
void
TALER_MINT_DB_free_coin_transaction_list (struct TALER_MINT_DB_TransactionList *list);
#endif /* _NEURO_MINT_DB_H */

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

@ -55,31 +55,35 @@ TALER_MINT_db_execute_deposit (struct MHD_Connection *connection,
const struct Deposit *deposit)
{
PGconn *db_conn;
struct Deposit existing_deposit;
int res;
struct TALER_MINT_DB_TransactionList *tl;
if (NULL == (db_conn = TALER_MINT_DB_get_connection ()))
{
GNUNET_break (0);
return TALER_MINT_reply_internal_db_error (connection);
}
res = TALER_MINT_DB_get_deposit (db_conn,
&deposit->coin.coin_pub,
&existing_deposit);
if (GNUNET_YES == res)
if (GNUNET_YES ==
TALER_MINT_DB_have_deposit (db_conn,
deposit))
{
return TALER_MINT_reply_deposit_success (connection,
&deposit->coin.coin_pub,
&deposit->h_wire,
&deposit->h_contract,
deposit->transaction_id,
&deposit->merchant_pub,
&deposit->amount);
}
if (GNUNET_OK !=
TALER_MINT_DB_transaction (db_conn))
{
GNUNET_break (0);
return TALER_MINT_reply_internal_db_error (connection);
}
tl = TALER_MINT_DB_get_coin_transactions (db_conn,
&deposit->coin.coin_pub);
if (NULL != tl)
{
// FIXME: memory leak
// FIXME: memcmp will not actually work here
if (0 == memcmp (&existing_deposit,
deposit,
sizeof (struct Deposit)))
return TALER_MINT_reply_deposit_success (connection,
&deposit->coin.coin_pub,
&deposit->h_wire,
&deposit->h_contract,
deposit->transaction_id,
&deposit->merchant_pub,
&deposit->amount);
// FIXME: in the future, check if there's enough credits
// left on the coin. For now: refuse
// FIXME: return more information here
@ -87,15 +91,9 @@ TALER_MINT_db_execute_deposit (struct MHD_Connection *connection,
MHD_HTTP_FORBIDDEN,
"{s:s}",
"error",
"double spending");
"double spending");
}
if (GNUNET_SYSERR == res)
{
GNUNET_break (0);
/* FIXME: return error message to client via MHD! */
return MHD_NO;
}
{
struct KnownCoin known_coin;
@ -153,6 +151,14 @@ TALER_MINT_db_execute_deposit (struct MHD_Connection *connection,
}
/**
* Sign a reserve's status with the current signing key.
* FIXME: not sure why we do this. Should just return
@ -474,6 +480,7 @@ refresh_accept_melts (struct MHD_Connection *connection,
struct KnownCoin known_coin;
// money the customer gets by melting the current coin
struct TALER_Amount coin_gain;
struct RefreshMelt melt;
dki = &(TALER_MINT_get_denom_key (key_state,
coin_public_infos[i].denom_pub)->issue);
@ -523,10 +530,17 @@ refresh_accept_melts (struct MHD_Connection *connection,
return GNUNET_SYSERR;
}
// FIXME: test first if coin was already melted
// in this session, etc.
melt.coin = coin_public_infos[i];
melt.session_pub = *session_pub;
// melt.coin_sig = FIXME;
// melt.amount = FIXME;
melt.oldcoin_index = i;
if (GNUNET_OK !=
TALER_MINT_DB_insert_refresh_melt (db_conn, session_pub, i,
&coin_public_infos[i].coin_pub,
coin_public_infos[i].denom_pub))
TALER_MINT_DB_insert_refresh_melt (db_conn,
&melt))
{
GNUNET_break (0);
return GNUNET_SYSERR;
@ -934,9 +948,9 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
for (j = 0; j < refresh_session.num_oldcoins; j++)
{
struct RefreshCommitLink commit_link;
struct GNUNET_CRYPTO_EcdsaPublicKey coin_pub;
struct TALER_TransferSecret transfer_secret;
struct TALER_LinkSecret shared_secret;
struct RefreshMelt melt;
res = TALER_MINT_DB_get_refresh_commit_link (db_conn,
refresh_session_pub,
@ -949,7 +963,10 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
return MHD_NO;
}
res = TALER_MINT_DB_get_refresh_melt (db_conn, refresh_session_pub, j, &coin_pub);
res = TALER_MINT_DB_get_refresh_melt (db_conn,
refresh_session_pub,
j,
&melt);
if (GNUNET_OK != res)
{
GNUNET_break (0);
@ -962,7 +979,7 @@ TALER_MINT_db_execute_refresh_reveal (struct MHD_Connection *connection,
/* FIXME: ECDHE/ECDSA-key type confusion! Can we reduce/avoid this? */
if (GNUNET_OK !=
GNUNET_CRYPTO_ecc_ecdh ((const struct GNUNET_CRYPTO_EcdhePrivateKey *) &transfer_privs[i+off][j],
(const struct GNUNET_CRYPTO_EcdhePublicKey *) &coin_pub,
(const struct GNUNET_CRYPTO_EcdhePublicKey *) &melt.coin.coin_pub,
&transfer_secret.key))
{
GNUNET_break (0);

23
src/mint/taler-mint-httpd_deposit.c
View File

@ -112,8 +112,6 @@ verify_and_execute_deposit (struct MHD_Connection *connection,
*
* @param connection the MHD connection to handle
* @param root root of the posted JSON
* @param purpose is this a #TALER_SIGNATURE_WALLET_DEPOSIT or
* #TALER_SIGNATURE_INCREMENTAL_WALLET_DEPOSIT // FIXME: bad type, use enum!
* @param amount how much should be deposited
* @param wire json describing the wire details (?)
* @return MHD result code
@ -121,7 +119,6 @@ verify_and_execute_deposit (struct MHD_Connection *connection,
static int
parse_and_handle_deposit_request (struct MHD_Connection *connection,
const json_t *root,
uint32_t purpose,
const struct TALER_Amount *amount,
const json_t *wire)
{
@ -187,7 +184,6 @@ parse_and_handle_deposit_request (struct MHD_Connection *connection,
GNUNET_free (wire_enc);
deposit.wire = wire;
deposit.purpose = purpose;
deposit.amount = *amount;
res = verify_and_execute_deposit (connection,
&deposit);
@ -223,9 +219,7 @@ TALER_MINT_handler_deposit (struct RequestHandler *rh,
{
json_t *json;
json_t *wire;
const char *deposit_type;
int res;
uint32_t purpose;
struct TALER_Amount amount;
json_t *f;
@ -240,7 +234,6 @@ TALER_MINT_handler_deposit (struct RequestHandler *rh,
return MHD_YES;
if (-1 == json_unpack (json,
"{s:s, s:o, f:o}",
"type", &deposit_type,
"wire", &wire,
"f", &f))
{
@ -267,24 +260,8 @@ TALER_MINT_handler_deposit (struct RequestHandler *rh,
json_decref (json);
return MHD_YES;
}
/* FIXME: use array search and enum, this is ugly */
if (0 == strcmp ("DIRECT_DEPOSIT", deposit_type))
purpose = TALER_SIGNATURE_WALLET_DEPOSIT;
else if (0 == strcmp ("INCREMENTAL_DEPOSIT", deposit_type))
purpose = TALER_SIGNATURE_INCREMENTAL_WALLET_DEPOSIT;
else
{
GNUNET_break_op (0);
json_decref (wire);
json_decref (json);
return TALER_MINT_reply_json_pack (connection,
MHD_HTTP_BAD_REQUEST,
"{s:s}",
"error", "Bad format");
}
res = parse_and_handle_deposit_request (connection,
json,
purpose,
&amount,
wire);
json_decref (wire);

40
src/mint/test_mint_deposits.c
View File

@ -52,6 +52,44 @@ static int persistent;
static int result;
int
TALER_MINT_DB_init_deposits (PGconn *conn, int tmp)
{
const char *tmp_str = (1 == tmp) ? "TEMPORARY" : "";
char *sql;
PGresult *res;
int ret;
res = NULL;
(void) GNUNET_asprintf (&sql,
"CREATE %1$s TABLE IF NOT EXISTS deposits ("
" coin_pub BYTEA NOT NULL PRIMARY KEY CHECK (length(coin_pub)=32)"
",denom_pub BYTEA NOT NULL CHECK (length(denom_pub)=32)"
",transaction_id INT8 NOT NULL"
",amount_value INT4 NOT NULL"
",amount_fraction INT4 NOT NULL"
",amount_currency VARCHAR(4) NOT NULL"
",merchant_pub BYTEA NOT NULL"
",h_contract BYTEA NOT NULL CHECK (length(h_contract)=64)"
",h_wire BYTEA NOT NULL CHECK (length(h_wire)=64)"
",coin_sig BYTEA NOT NULL CHECK (length(coin_sig)=64)"
",wire TEXT NOT NULL"
")",
tmp_str);
res = PQexec (conn, sql);
GNUNET_free (sql);
if (PGRES_COMMAND_OK != PQresultStatus (res))
{
break_db_err (res);
ret = GNUNET_SYSERR;
}
else
ret = GNUNET_OK;
PQclear (res);
return ret;
}
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
@ -89,7 +127,7 @@ run (void *cls, char *const *args, const char *cfgfile,
&do_shutdown, NULL);
EXITIF (NULL == (conn = PQconnectdb(DB_URI)));
EXITIF (GNUNET_OK != TALER_MINT_DB_init_deposits (conn, !persistent));
EXITIF (GNUNET_OK != TALER_MINT_DB_prepare_deposits (conn));
EXITIF (GNUNET_OK != TALER_MINT_DB_prepare (conn));
deposit = GNUNET_malloc (sizeof (struct Deposit) + sizeof (wire));
/* Makeup a random coin public key */
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,