/* This file is part of libbrandt. * Copyright (C) 2016 GNUnet e.V. * * libbrandt is free software: you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation, either version 3 of the License, or (at your option) any later * version. * * libbrandt is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR * A PARTICULAR PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along with * libbrandt. If not, see . */ /** * @file brandt.c * @brief Implementation of the high level libbrandt interface. * @author Markus Teich */ #include "brandt_config.h" #include "crypto.h" #include "internals.h" #include "util.h" void BRANDT_init (struct GNUNET_CRYPTO_EccDlogContext *dlogctx) { gcry_error_t err = 0; if (!gcry_check_version ("1.7.0")) eprintf ("libgcrypt version mismatch"); /* SECMEM cannot be resized dynamically. We do not know how much we need */ if ((err = gcry_control (GCRYCTL_DISABLE_SECMEM, 0))) weprintf ("failed to set libgcrypt option DISABLE_SECMEM: %s", gcry_strerror (err)); /* ecc is slow otherwise and we don't create long term keys anyway. */ if ((err = gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0))) weprintf ("failed to set libgcrypt option ENABLE_QUICK_RANDOM: %s", gcry_strerror (err)); gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0); brandt_crypto_init (dlogctx); } static void start_auction (void *arg) { struct BRANDT_Auction *ad = (struct BRANDT_Auction *)arg; /* \todo: broadcast start message to all participants */ } struct BRANDT_Auction * BRANDT_new (BRANDT_CbBroadcast broadcast, BRANDT_CbResult result, void *auction_closure, void **auction_data, size_t *auction_data_len, struct GNUNET_TIME_Absolute time_start, struct GNUNET_TIME_Relative time_round, void *description, uint32_t description_len, uint16_t num_prices, uint16_t m, int outcome_public) { struct BRANDT_Auction *ret = GNUNET_new (struct BRANDT_Auction); struct BRANDT_DescrP *desc = GNUNET_new (struct BRANDT_DescrP); struct GNUNET_TIME_Relative until_start; struct GNUNET_HashContext *hc = GNUNET_CRYPTO_hash_context_start (); desc->time_start = GNUNET_TIME_absolute_hton (time_start); desc->time_round = GNUNET_TIME_relative_hton (time_round); desc->description_len = htonl (description_len); desc->k = htons (num_prices); desc->m = htons (m); desc->outcome_public = htons (outcome_public); GNUNET_CRYPTO_hash_context_read (hc, &desc->time_start, sizeof (*desc) - sizeof (desc->hash)); GNUNET_CRYPTO_hash_context_read (hc, description, description_len); GNUNET_CRYPTO_hash_context_finish (hc, &desc->hash); ret->time_start = time_start; ret->time_round = time_round; ret->k = num_prices; ret->m = m; ret->outcome_public = outcome_public; ret->cur_round = msg_join; ret->round_progress = gcry_mpi_new (256); /* we are the seller */ ret->seller_mode = 1; /* callback interface with application */ ret->closure = auction_closure; ret->bcast = broadcast; ret->result = result; until_start = GNUNET_TIME_absolute_get_remaining (time_start); /* \todo: store returned task somewhere to cancel it on shutdown */ ret->task = GNUNET_SCHEDULER_add_delayed (until_start, &start_auction, ret); *auction_data_len = sizeof (struct BRANDT_DescrP); *auction_data = desc; return ret; } struct BRANDT_Auction * BRANDT_join (BRANDT_CbBroadcast broadcast, BRANDT_CbUnicast unicast, BRANDT_CbResult result, void *auction_closure, const void *auction_data, size_t auction_data_len) { struct BRANDT_Auction *ret = GNUNET_new (struct BRANDT_Auction); struct BRANDT_DescrP *desc = (struct BRANDT_DescrP *)auction_data; ret->time_start = GNUNET_TIME_absolute_ntoh (desc->time_start); ret->time_round = GNUNET_TIME_relative_ntoh (desc->time_round); ret->k = ntohs (desc->k); ret->m = ntohs (desc->m); ret->outcome_public = ntohs (desc->outcome_public); ret->cur_round = msg_join; ret->round_progress = gcry_mpi_new (256); /* we are the seller */ ret->seller_mode = 0; /* callback interface with application */ ret->closure = auction_closure; ret->bcast = broadcast; ret->ucast = unicast; ret->result = result; return ret; } void BRANDT_destroy (struct BRANDT_Auction *auction) { GNUNET_SCHEDULER_cancel (auction->task); } static void advance_round (struct BRANDT_Auction *ad, enum auction_type atype, enum outcome_type outcome) { unsigned char *buf; size_t buflen; /* if we got the current round message from all participants, advance to * next round */ for (uint16_t i = 0; i < ad->n; i++) if (!gcry_mpi_test_bit (ad->round_progress, i)) return; gcry_mpi_clear_highbit (ad->round_progress, 0); if (msg_last == ++(ad->cur_round)) { /** \todo: finish */ } if (!handler_out[atype][outcome][ad->cur_round] || !(buf = handler_out[atype][outcome][ad->cur_round](ad, &buflen))) { /** \todo */ weprintf ("wow fail out"); return; } /** \todo: add msgtype header in the handler_out functions */ /* last message only sent to seller, others are broadcasted */ if (msg_decrypt == ad->cur_round) ad->ucast (ad->closure, buf, buflen); else ad->bcast (ad->closure, buf, buflen); } void BRANDT_got_message (struct BRANDT_Auction *auction, uint16_t sender, const unsigned char *msg, size_t msg_len) { uint16_t mtype = *(uint16_t *)msg; enum auction_type atype; enum outcome_type outcome; enum rounds round = auction->cur_round; atype = auction->m > 0 ? auction_mPlusFirstPrice : auction_firstPrice; outcome = auction->outcome_public ? outcome_public : outcome_private; /** \todo: cache out of order messages */ /* check if we already got that round message from the same user */ if (gcry_mpi_test_bit (auction->round_progress, sender)) { weprintf ("got a duplicate message from user %d", sender); return; } if (!handler_in[atype][outcome][round] || !handler_in[atype][outcome][round](auction, msg + sizeof (mtype), msg_len - sizeof (mtype), sender)) { /** \todo */ weprintf ("wow fail in"); return; } gcry_mpi_set_bit (auction->round_progress, sender); /** \todo: seller_mode and new task for round timing */ advance_round (auction, atype, outcome); }