1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
/* 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 <http://www.gnu.org/licenses/>.
*/
/**
* @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);
}
|
