diff options
author | Martin Schanzenbach <schanzen@gnunet.org> | 2023-07-16 19:26:09 +0200 |
---|---|---|
committer | Martin Schanzenbach <schanzen@gnunet.org> | 2023-07-16 19:26:09 +0200 |
commit | a2c3a72d0157c0de4966cea417d1802727c3ed1e (patch) | |
tree | 6e938c29b09fb646a387f3ca55528dc999ece248 /src/messenger/messenger_api_message.c | |
parent | 7eb848d29db698432b25283b994383d2f35465b5 (diff) | |
download | gnunet-a2c3a72d0157c0de4966cea417d1802727c3ed1e.tar.gz gnunet-a2c3a72d0157c0de4966cea417d1802727c3ed1e.zip |
NEWS: Added new CCA-secure KEM and use in IDENTITY encryption
Diffstat (limited to 'src/messenger/messenger_api_message.c')
-rw-r--r-- | src/messenger/messenger_api_message.c | 492 |
1 files changed, 280 insertions, 212 deletions
diff --git a/src/messenger/messenger_api_message.c b/src/messenger/messenger_api_message.c index ac63f16ca..0e27588ba 100644 --- a/src/messenger/messenger_api_message.c +++ b/src/messenger/messenger_api_message.c | |||
@@ -41,7 +41,8 @@ struct GNUNET_MESSENGER_ShortMessage | |||
41 | struct GNUNET_MESSENGER_Message* | 41 | struct GNUNET_MESSENGER_Message* |
42 | create_message (enum GNUNET_MESSENGER_MessageKind kind) | 42 | create_message (enum GNUNET_MESSENGER_MessageKind kind) |
43 | { | 43 | { |
44 | struct GNUNET_MESSENGER_Message *message = GNUNET_new(struct GNUNET_MESSENGER_Message); | 44 | struct GNUNET_MESSENGER_Message *message = GNUNET_new (struct |
45 | GNUNET_MESSENGER_Message); | ||
45 | 46 | ||
46 | message->header.kind = kind; | 47 | message->header.kind = kind; |
47 | 48 | ||
@@ -67,32 +68,36 @@ create_message (enum GNUNET_MESSENGER_MessageKind kind) | |||
67 | return message; | 68 | return message; |
68 | } | 69 | } |
69 | 70 | ||
71 | |||
70 | struct GNUNET_MESSENGER_Message* | 72 | struct GNUNET_MESSENGER_Message* |
71 | copy_message (const struct GNUNET_MESSENGER_Message *message) | 73 | copy_message (const struct GNUNET_MESSENGER_Message *message) |
72 | { | 74 | { |
73 | GNUNET_assert(message); | 75 | GNUNET_assert (message); |
74 | 76 | ||
75 | struct GNUNET_MESSENGER_Message *copy = GNUNET_new(struct GNUNET_MESSENGER_Message); | 77 | struct GNUNET_MESSENGER_Message *copy = GNUNET_new (struct |
78 | GNUNET_MESSENGER_Message); | ||
76 | 79 | ||
77 | GNUNET_memcpy(copy, message, sizeof(struct GNUNET_MESSENGER_Message)); | 80 | GNUNET_memcpy (copy, message, sizeof(struct GNUNET_MESSENGER_Message)); |
78 | 81 | ||
79 | switch (message->header.kind) | 82 | switch (message->header.kind) |
80 | { | 83 | { |
81 | case GNUNET_MESSENGER_KIND_NAME: | 84 | case GNUNET_MESSENGER_KIND_NAME: |
82 | copy->body.name.name = GNUNET_strdup(message->body.name.name); | 85 | copy->body.name.name = GNUNET_strdup (message->body.name.name); |
83 | break; | 86 | break; |
84 | case GNUNET_MESSENGER_KIND_TEXT: | 87 | case GNUNET_MESSENGER_KIND_TEXT: |
85 | copy->body.text.text = GNUNET_strdup(message->body.text.text); | 88 | copy->body.text.text = GNUNET_strdup (message->body.text.text); |
86 | break; | 89 | break; |
87 | case GNUNET_MESSENGER_KIND_FILE: | 90 | case GNUNET_MESSENGER_KIND_FILE: |
88 | copy->body.file.uri = GNUNET_strdup(message->body.file.uri); | 91 | copy->body.file.uri = GNUNET_strdup (message->body.file.uri); |
89 | break; | 92 | break; |
90 | case GNUNET_MESSENGER_KIND_PRIVATE: | 93 | case GNUNET_MESSENGER_KIND_PRIVATE: |
91 | copy->body.privacy.data = copy->body.privacy.length ? GNUNET_malloc(copy->body.privacy.length) : NULL; | 94 | copy->body.privacy.data = copy->body.privacy.length ? GNUNET_malloc ( |
95 | copy->body.privacy.length) : NULL; | ||
92 | 96 | ||
93 | if (copy->body.privacy.data) | 97 | if (copy->body.privacy.data) |
94 | { | 98 | { |
95 | GNUNET_memcpy(copy->body.privacy.data, message->body.privacy.data, copy->body.privacy.length); | 99 | GNUNET_memcpy (copy->body.privacy.data, message->body.privacy.data, |
100 | copy->body.privacy.length); | ||
96 | } | 101 | } |
97 | 102 | ||
98 | break; | 103 | break; |
@@ -103,6 +108,7 @@ copy_message (const struct GNUNET_MESSENGER_Message *message) | |||
103 | return copy; | 108 | return copy; |
104 | } | 109 | } |
105 | 110 | ||
111 | |||
106 | static void | 112 | static void |
107 | destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind, | 113 | destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind, |
108 | struct GNUNET_MESSENGER_MessageBody *body) | 114 | struct GNUNET_MESSENGER_MessageBody *body) |
@@ -110,44 +116,47 @@ destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind, | |||
110 | switch (kind) | 116 | switch (kind) |
111 | { | 117 | { |
112 | case GNUNET_MESSENGER_KIND_NAME: | 118 | case GNUNET_MESSENGER_KIND_NAME: |
113 | GNUNET_free(body->name.name); | 119 | GNUNET_free (body->name.name); |
114 | break; | 120 | break; |
115 | case GNUNET_MESSENGER_KIND_TEXT: | 121 | case GNUNET_MESSENGER_KIND_TEXT: |
116 | GNUNET_free(body->text.text); | 122 | GNUNET_free (body->text.text); |
117 | break; | 123 | break; |
118 | case GNUNET_MESSENGER_KIND_FILE: | 124 | case GNUNET_MESSENGER_KIND_FILE: |
119 | GNUNET_free(body->file.uri); | 125 | GNUNET_free (body->file.uri); |
120 | break; | 126 | break; |
121 | case GNUNET_MESSENGER_KIND_PRIVATE: | 127 | case GNUNET_MESSENGER_KIND_PRIVATE: |
122 | GNUNET_free(body->privacy.data); | 128 | GNUNET_free (body->privacy.data); |
123 | break; | 129 | break; |
124 | default: | 130 | default: |
125 | break; | 131 | break; |
126 | } | 132 | } |
127 | } | 133 | } |
128 | 134 | ||
135 | |||
129 | void | 136 | void |
130 | cleanup_message (struct GNUNET_MESSENGER_Message *message) | 137 | cleanup_message (struct GNUNET_MESSENGER_Message *message) |
131 | { | 138 | { |
132 | GNUNET_assert(message); | 139 | GNUNET_assert (message); |
133 | 140 | ||
134 | destroy_message_body (message->header.kind, &(message->body)); | 141 | destroy_message_body (message->header.kind, &(message->body)); |
135 | } | 142 | } |
136 | 143 | ||
144 | |||
137 | void | 145 | void |
138 | destroy_message (struct GNUNET_MESSENGER_Message *message) | 146 | destroy_message (struct GNUNET_MESSENGER_Message *message) |
139 | { | 147 | { |
140 | GNUNET_assert(message); | 148 | GNUNET_assert (message); |
141 | 149 | ||
142 | destroy_message_body (message->header.kind, &(message->body)); | 150 | destroy_message_body (message->header.kind, &(message->body)); |
143 | 151 | ||
144 | GNUNET_free(message); | 152 | GNUNET_free (message); |
145 | } | 153 | } |
146 | 154 | ||
155 | |||
147 | int | 156 | int |
148 | is_message_session_bound (const struct GNUNET_MESSENGER_Message *message) | 157 | is_message_session_bound (const struct GNUNET_MESSENGER_Message *message) |
149 | { | 158 | { |
150 | GNUNET_assert(message); | 159 | GNUNET_assert (message); |
151 | 160 | ||
152 | if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) || | 161 | if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) || |
153 | (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind) || | 162 | (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind) || |
@@ -159,15 +168,18 @@ is_message_session_bound (const struct GNUNET_MESSENGER_Message *message) | |||
159 | return GNUNET_NO; | 168 | return GNUNET_NO; |
160 | } | 169 | } |
161 | 170 | ||
171 | |||
162 | static void | 172 | static void |
163 | fold_short_message (const struct GNUNET_MESSENGER_Message *message, | 173 | fold_short_message (const struct GNUNET_MESSENGER_Message *message, |
164 | struct GNUNET_MESSENGER_ShortMessage *shortened) | 174 | struct GNUNET_MESSENGER_ShortMessage *shortened) |
165 | { | 175 | { |
166 | shortened->kind = message->header.kind; | 176 | shortened->kind = message->header.kind; |
167 | 177 | ||
168 | GNUNET_memcpy(&(shortened->body), &(message->body), sizeof(struct GNUNET_MESSENGER_MessageBody)); | 178 | GNUNET_memcpy (&(shortened->body), &(message->body), sizeof(struct |
179 | GNUNET_MESSENGER_MessageBody)); | ||
169 | } | 180 | } |
170 | 181 | ||
182 | |||
171 | static void | 183 | static void |
172 | unfold_short_message (struct GNUNET_MESSENGER_ShortMessage *shortened, | 184 | unfold_short_message (struct GNUNET_MESSENGER_ShortMessage *shortened, |
173 | struct GNUNET_MESSENGER_Message *message) | 185 | struct GNUNET_MESSENGER_Message *message) |
@@ -176,9 +188,11 @@ unfold_short_message (struct GNUNET_MESSENGER_ShortMessage *shortened, | |||
176 | 188 | ||
177 | message->header.kind = shortened->kind; | 189 | message->header.kind = shortened->kind; |
178 | 190 | ||
179 | GNUNET_memcpy(&(message->body), &(shortened->body), sizeof(struct GNUNET_MESSENGER_MessageBody)); | 191 | GNUNET_memcpy (&(message->body), &(shortened->body), sizeof(struct |
192 | GNUNET_MESSENGER_MessageBody)); | ||
180 | } | 193 | } |
181 | 194 | ||
195 | |||
182 | #define member_size(type, member) sizeof(((type*) NULL)->member) | 196 | #define member_size(type, member) sizeof(((type*) NULL)->member) |
183 | 197 | ||
184 | static uint16_t | 198 | static uint16_t |
@@ -189,40 +203,43 @@ get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind) | |||
189 | switch (kind) | 203 | switch (kind) |
190 | { | 204 | { |
191 | case GNUNET_MESSENGER_KIND_INFO: | 205 | case GNUNET_MESSENGER_KIND_INFO: |
192 | length += member_size(struct GNUNET_MESSENGER_Message, body.info.messenger_version); | 206 | length += member_size (struct GNUNET_MESSENGER_Message, |
207 | body.info.messenger_version); | ||
193 | break; | 208 | break; |
194 | case GNUNET_MESSENGER_KIND_PEER: | 209 | case GNUNET_MESSENGER_KIND_PEER: |
195 | length += member_size(struct GNUNET_MESSENGER_Message, body.peer.peer); | 210 | length += member_size (struct GNUNET_MESSENGER_Message, body.peer.peer); |
196 | break; | 211 | break; |
197 | case GNUNET_MESSENGER_KIND_ID: | 212 | case GNUNET_MESSENGER_KIND_ID: |
198 | length += member_size(struct GNUNET_MESSENGER_Message, body.id.id); | 213 | length += member_size (struct GNUNET_MESSENGER_Message, body.id.id); |
199 | break; | 214 | break; |
200 | case GNUNET_MESSENGER_KIND_MISS: | 215 | case GNUNET_MESSENGER_KIND_MISS: |
201 | length += member_size(struct GNUNET_MESSENGER_Message, body.miss.peer); | 216 | length += member_size (struct GNUNET_MESSENGER_Message, body.miss.peer); |
202 | break; | 217 | break; |
203 | case GNUNET_MESSENGER_KIND_MERGE: | 218 | case GNUNET_MESSENGER_KIND_MERGE: |
204 | length += member_size(struct GNUNET_MESSENGER_Message, body.merge.previous); | 219 | length += member_size (struct GNUNET_MESSENGER_Message, |
220 | body.merge.previous); | ||
205 | break; | 221 | break; |
206 | case GNUNET_MESSENGER_KIND_REQUEST: | 222 | case GNUNET_MESSENGER_KIND_REQUEST: |
207 | length += member_size(struct GNUNET_MESSENGER_Message, body.request.hash); | 223 | length += member_size (struct GNUNET_MESSENGER_Message, body.request.hash); |
208 | break; | 224 | break; |
209 | case GNUNET_MESSENGER_KIND_INVITE: | 225 | case GNUNET_MESSENGER_KIND_INVITE: |
210 | length += member_size(struct GNUNET_MESSENGER_Message, body.invite.door); | 226 | length += member_size (struct GNUNET_MESSENGER_Message, body.invite.door); |
211 | length += member_size(struct GNUNET_MESSENGER_Message, body.invite.key); | 227 | length += member_size (struct GNUNET_MESSENGER_Message, body.invite.key); |
212 | break; | 228 | break; |
213 | case GNUNET_MESSENGER_KIND_TEXT: | 229 | case GNUNET_MESSENGER_KIND_TEXT: |
214 | break; | 230 | break; |
215 | case GNUNET_MESSENGER_KIND_FILE: | 231 | case GNUNET_MESSENGER_KIND_FILE: |
216 | length += member_size(struct GNUNET_MESSENGER_Message, body.file.key); | 232 | length += member_size (struct GNUNET_MESSENGER_Message, body.file.key); |
217 | length += member_size(struct GNUNET_MESSENGER_Message, body.file.hash); | 233 | length += member_size (struct GNUNET_MESSENGER_Message, body.file.hash); |
218 | length += member_size(struct GNUNET_MESSENGER_Message, body.file.name); | 234 | length += member_size (struct GNUNET_MESSENGER_Message, body.file.name); |
219 | break; | 235 | break; |
220 | case GNUNET_MESSENGER_KIND_PRIVATE: | 236 | case GNUNET_MESSENGER_KIND_PRIVATE: |
221 | length += member_size(struct GNUNET_MESSENGER_Message, body.privacy.key); | 237 | length += member_size (struct GNUNET_MESSENGER_Message, body.privacy.key); |
222 | break; | 238 | break; |
223 | case GNUNET_MESSENGER_KIND_DELETE: | 239 | case GNUNET_MESSENGER_KIND_DELETE: |
224 | length += member_size(struct GNUNET_MESSENGER_Message, body.deletion.hash); | 240 | length += member_size (struct GNUNET_MESSENGER_Message, body.deletion.hash); |
225 | length += member_size(struct GNUNET_MESSENGER_Message, body.deletion.delay); | 241 | length += member_size (struct GNUNET_MESSENGER_Message, |
242 | body.deletion.delay); | ||
226 | break; | 243 | break; |
227 | default: | 244 | default: |
228 | break; | 245 | break; |
@@ -231,6 +248,7 @@ get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind) | |||
231 | return length; | 248 | return length; |
232 | } | 249 | } |
233 | 250 | ||
251 | |||
234 | typedef uint32_t kind_t; | 252 | typedef uint32_t kind_t; |
235 | 253 | ||
236 | uint16_t | 254 | uint16_t |
@@ -241,9 +259,9 @@ get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind, | |||
241 | 259 | ||
242 | if (GNUNET_YES == include_header) | 260 | if (GNUNET_YES == include_header) |
243 | { | 261 | { |
244 | length += member_size(struct GNUNET_MESSENGER_Message, header.timestamp); | 262 | length += member_size (struct GNUNET_MESSENGER_Message, header.timestamp); |
245 | length += member_size(struct GNUNET_MESSENGER_Message, header.sender_id); | 263 | length += member_size (struct GNUNET_MESSENGER_Message, header.sender_id); |
246 | length += member_size(struct GNUNET_MESSENGER_Message, header.previous); | 264 | length += member_size (struct GNUNET_MESSENGER_Message, header.previous); |
247 | } | 265 | } |
248 | 266 | ||
249 | length += sizeof(kind_t); | 267 | length += sizeof(kind_t); |
@@ -251,6 +269,7 @@ get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind, | |||
251 | return length + get_message_body_kind_size (kind); | 269 | return length + get_message_body_kind_size (kind); |
252 | } | 270 | } |
253 | 271 | ||
272 | |||
254 | static uint16_t | 273 | static uint16_t |
255 | get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, | 274 | get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, |
256 | const struct GNUNET_MESSENGER_MessageBody *body) | 275 | const struct GNUNET_MESSENGER_MessageBody *body) |
@@ -260,16 +279,16 @@ get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, | |||
260 | switch (kind) | 279 | switch (kind) |
261 | { | 280 | { |
262 | case GNUNET_MESSENGER_KIND_INFO: | 281 | case GNUNET_MESSENGER_KIND_INFO: |
263 | length += GNUNET_IDENTITY_public_key_get_length(&(body->info.host_key)); | 282 | length += GNUNET_IDENTITY_public_key_get_length (&(body->info.host_key)); |
264 | break; | 283 | break; |
265 | case GNUNET_MESSENGER_KIND_JOIN: | 284 | case GNUNET_MESSENGER_KIND_JOIN: |
266 | length += GNUNET_IDENTITY_public_key_get_length(&(body->join.key)); | 285 | length += GNUNET_IDENTITY_public_key_get_length (&(body->join.key)); |
267 | break; | 286 | break; |
268 | case GNUNET_MESSENGER_KIND_NAME: | 287 | case GNUNET_MESSENGER_KIND_NAME: |
269 | length += (body->name.name ? strlen (body->name.name) : 0); | 288 | length += (body->name.name ? strlen (body->name.name) : 0); |
270 | break; | 289 | break; |
271 | case GNUNET_MESSENGER_KIND_KEY: | 290 | case GNUNET_MESSENGER_KIND_KEY: |
272 | length += GNUNET_IDENTITY_public_key_get_length(&(body->key.key)); | 291 | length += GNUNET_IDENTITY_public_key_get_length (&(body->key.key)); |
273 | break; | 292 | break; |
274 | case GNUNET_MESSENGER_KIND_TEXT: | 293 | case GNUNET_MESSENGER_KIND_TEXT: |
275 | length += strlen (body->text.text); | 294 | length += strlen (body->text.text); |
@@ -287,16 +306,18 @@ get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, | |||
287 | return length; | 306 | return length; |
288 | } | 307 | } |
289 | 308 | ||
309 | |||
290 | uint16_t | 310 | uint16_t |
291 | get_message_size (const struct GNUNET_MESSENGER_Message *message, | 311 | get_message_size (const struct GNUNET_MESSENGER_Message *message, |
292 | int include_header) | 312 | int include_header) |
293 | { | 313 | { |
294 | GNUNET_assert(message); | 314 | GNUNET_assert (message); |
295 | 315 | ||
296 | uint16_t length = 0; | 316 | uint16_t length = 0; |
297 | 317 | ||
298 | if (GNUNET_YES == include_header) | 318 | if (GNUNET_YES == include_header) |
299 | length += GNUNET_IDENTITY_signature_get_length(&(message->header.signature)); | 319 | length += GNUNET_IDENTITY_signature_get_length ( |
320 | &(message->header.signature)); | ||
300 | 321 | ||
301 | length += get_message_kind_size (message->header.kind, include_header); | 322 | length += get_message_kind_size (message->header.kind, include_header); |
302 | length += get_message_body_size (message->header.kind, &(message->body)); | 323 | length += get_message_body_size (message->header.kind, &(message->body)); |
@@ -304,6 +325,7 @@ get_message_size (const struct GNUNET_MESSENGER_Message *message, | |||
304 | return length; | 325 | return length; |
305 | } | 326 | } |
306 | 327 | ||
328 | |||
307 | static uint16_t | 329 | static uint16_t |
308 | get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message, | 330 | get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message, |
309 | int include_body) | 331 | int include_body) |
@@ -312,19 +334,24 @@ get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message, | |||
312 | 334 | ||
313 | if (message) | 335 | if (message) |
314 | return minimum_size + get_message_body_kind_size (message->kind) | 336 | return minimum_size + get_message_body_kind_size (message->kind) |
315 | + (include_body == GNUNET_YES? get_message_body_size (message->kind, &(message->body)) : 0); | 337 | + (include_body == GNUNET_YES? get_message_body_size (message->kind, |
338 | &(message->body)) | ||
339 | : 0); | ||
316 | else | 340 | else |
317 | return minimum_size; | 341 | return minimum_size; |
318 | } | 342 | } |
319 | 343 | ||
344 | |||
320 | static uint16_t | 345 | static uint16_t |
321 | calc_usual_padding () | 346 | calc_usual_padding () |
322 | { | 347 | { |
323 | uint16_t padding = 0; | 348 | uint16_t padding = 0; |
324 | uint16_t kind_size; | 349 | uint16_t kind_size; |
325 | 350 | ||
326 | for (int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++) { | 351 | for (int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++) |
327 | kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i, GNUNET_YES); | 352 | { |
353 | kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i, | ||
354 | GNUNET_YES); | ||
328 | 355 | ||
329 | if (kind_size > padding) | 356 | if (kind_size > padding) |
330 | padding = kind_size; | 357 | padding = kind_size; |
@@ -333,6 +360,7 @@ calc_usual_padding () | |||
333 | return padding + GNUNET_MESSENGER_PADDING_MIN; | 360 | return padding + GNUNET_MESSENGER_PADDING_MIN; |
334 | } | 361 | } |
335 | 362 | ||
363 | |||
336 | #define max(x, y) (x > y? x : y) | 364 | #define max(x, y) (x > y? x : y) |
337 | 365 | ||
338 | static uint16_t | 366 | static uint16_t |
@@ -340,13 +368,13 @@ calc_padded_length (uint16_t length) | |||
340 | { | 368 | { |
341 | static uint16_t usual_padding = 0; | 369 | static uint16_t usual_padding = 0; |
342 | 370 | ||
343 | if (!usual_padding) | 371 | if (! usual_padding) |
344 | usual_padding = calc_usual_padding(); | 372 | usual_padding = calc_usual_padding (); |
345 | 373 | ||
346 | const uint16_t padded_length = max( | 374 | const uint16_t padded_length = max ( |
347 | length + GNUNET_MESSENGER_PADDING_MIN, | 375 | length + GNUNET_MESSENGER_PADDING_MIN, |
348 | usual_padding | 376 | usual_padding |
349 | ); | 377 | ); |
350 | 378 | ||
351 | if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL0) | 379 | if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL0) |
352 | return GNUNET_MESSENGER_PADDING_LEVEL0; | 380 | return GNUNET_MESSENGER_PADDING_LEVEL0; |
@@ -361,35 +389,36 @@ calc_padded_length (uint16_t length) | |||
361 | 389 | ||
362 | } | 390 | } |
363 | 391 | ||
392 | |||
364 | #define min(x, y) (x < y? x : y) | 393 | #define min(x, y) (x < y? x : y) |
365 | 394 | ||
366 | #define encode_step_ext(dst, offset, src, size) do { \ | 395 | #define encode_step_ext(dst, offset, src, size) do { \ |
367 | GNUNET_memcpy(dst + offset, src, size); \ | 396 | GNUNET_memcpy (dst + offset, src, size); \ |
368 | offset += size; \ | 397 | offset += size; \ |
369 | } while (0) | 398 | } while (0) |
370 | 399 | ||
371 | #define encode_step(dst, offset, src) do { \ | 400 | #define encode_step(dst, offset, src) do { \ |
372 | encode_step_ext(dst, offset, src, sizeof(*src)); \ | 401 | encode_step_ext (dst, offset, src, sizeof(*src)); \ |
373 | } while (0) | 402 | } while (0) |
374 | 403 | ||
375 | #define encode_step_key(dst, offset, src, length) do { \ | 404 | #define encode_step_key(dst, offset, src, length) do { \ |
376 | ssize_t result = GNUNET_IDENTITY_write_public_key_to_buffer( \ | 405 | ssize_t result = GNUNET_IDENTITY_write_public_key_to_buffer ( \ |
377 | src, dst + offset, length - offset \ | 406 | src, dst + offset, length - offset \ |
378 | ); \ | 407 | ); \ |
379 | if (result < 0) \ | 408 | if (result < 0) \ |
380 | GNUNET_break (0); \ | 409 | GNUNET_break (0); \ |
381 | else \ | 410 | else \ |
382 | offset += result; \ | 411 | offset += result; \ |
383 | } while (0) | 412 | } while (0) |
384 | 413 | ||
385 | #define encode_step_signature(dst, offset, src, length) do { \ | 414 | #define encode_step_signature(dst, offset, src, length) do { \ |
386 | ssize_t result = GNUNET_IDENTITY_write_signature_to_buffer( \ | 415 | ssize_t result = GNUNET_IDENTITY_write_signature_to_buffer ( \ |
387 | src, dst + offset, length - offset \ | 416 | src, dst + offset, length - offset \ |
388 | ); \ | 417 | ); \ |
389 | if (result < 0) \ | 418 | if (result < 0) \ |
390 | GNUNET_break (0); \ | 419 | GNUNET_break (0); \ |
391 | else \ | 420 | else \ |
392 | offset += result; \ | 421 | offset += result; \ |
393 | } while (0) | 422 | } while (0) |
394 | 423 | ||
395 | static void | 424 | static void |
@@ -403,56 +432,64 @@ encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, | |||
403 | switch (kind) | 432 | switch (kind) |
404 | { | 433 | { |
405 | case GNUNET_MESSENGER_KIND_INFO: | 434 | case GNUNET_MESSENGER_KIND_INFO: |
406 | version = GNUNET_htobe32(body->info.messenger_version); | 435 | version = GNUNET_htobe32 (body->info.messenger_version); |
407 | 436 | ||
408 | encode_step_key(buffer, offset, &(body->info.host_key), length); | 437 | encode_step_key (buffer, offset, &(body->info.host_key), length); |
409 | encode_step(buffer, offset, &version); | 438 | encode_step (buffer, offset, &version); |
410 | break; | 439 | break; |
411 | case GNUNET_MESSENGER_KIND_JOIN: | 440 | case GNUNET_MESSENGER_KIND_JOIN: |
412 | encode_step_key(buffer, offset, &(body->join.key), length); | 441 | encode_step_key (buffer, offset, &(body->join.key), length); |
413 | break; | 442 | break; |
414 | case GNUNET_MESSENGER_KIND_NAME: | 443 | case GNUNET_MESSENGER_KIND_NAME: |
415 | if (body->name.name) | 444 | if (body->name.name) |
416 | encode_step_ext(buffer, offset, body->name.name, min(length - offset, strlen(body->name.name))); | 445 | encode_step_ext (buffer, offset, body->name.name, min (length - offset, |
446 | strlen ( | ||
447 | body->name.name))); | ||
417 | break; | 448 | break; |
418 | case GNUNET_MESSENGER_KIND_KEY: | 449 | case GNUNET_MESSENGER_KIND_KEY: |
419 | encode_step_key(buffer, offset, &(body->key.key), length); | 450 | encode_step_key (buffer, offset, &(body->key.key), length); |
420 | break; | 451 | break; |
421 | case GNUNET_MESSENGER_KIND_PEER: | 452 | case GNUNET_MESSENGER_KIND_PEER: |
422 | encode_step(buffer, offset, &(body->peer.peer)); | 453 | encode_step (buffer, offset, &(body->peer.peer)); |
423 | break; | 454 | break; |
424 | case GNUNET_MESSENGER_KIND_ID: | 455 | case GNUNET_MESSENGER_KIND_ID: |
425 | encode_step(buffer, offset, &(body->id.id)); | 456 | encode_step (buffer, offset, &(body->id.id)); |
426 | break; | 457 | break; |
427 | case GNUNET_MESSENGER_KIND_MISS: | 458 | case GNUNET_MESSENGER_KIND_MISS: |
428 | encode_step(buffer, offset, &(body->miss.peer)); | 459 | encode_step (buffer, offset, &(body->miss.peer)); |
429 | break; | 460 | break; |
430 | case GNUNET_MESSENGER_KIND_MERGE: | 461 | case GNUNET_MESSENGER_KIND_MERGE: |
431 | encode_step(buffer, offset, &(body->merge.previous)); | 462 | encode_step (buffer, offset, &(body->merge.previous)); |
432 | break; | 463 | break; |
433 | case GNUNET_MESSENGER_KIND_REQUEST: | 464 | case GNUNET_MESSENGER_KIND_REQUEST: |
434 | encode_step(buffer, offset, &(body->request.hash)); | 465 | encode_step (buffer, offset, &(body->request.hash)); |
435 | break; | 466 | break; |
436 | case GNUNET_MESSENGER_KIND_INVITE: | 467 | case GNUNET_MESSENGER_KIND_INVITE: |
437 | encode_step(buffer, offset, &(body->invite.door)); | 468 | encode_step (buffer, offset, &(body->invite.door)); |
438 | encode_step(buffer, offset, &(body->invite.key)); | 469 | encode_step (buffer, offset, &(body->invite.key)); |
439 | break; | 470 | break; |
440 | case GNUNET_MESSENGER_KIND_TEXT: | 471 | case GNUNET_MESSENGER_KIND_TEXT: |
441 | encode_step_ext(buffer, offset, body->text.text, min(length - offset, strlen(body->text.text))); | 472 | encode_step_ext (buffer, offset, body->text.text, min (length - offset, |
473 | strlen ( | ||
474 | body->text.text))); | ||
442 | break; | 475 | break; |
443 | case GNUNET_MESSENGER_KIND_FILE: | 476 | case GNUNET_MESSENGER_KIND_FILE: |
444 | encode_step(buffer, offset, &(body->file.key)); | 477 | encode_step (buffer, offset, &(body->file.key)); |
445 | encode_step(buffer, offset, &(body->file.hash)); | 478 | encode_step (buffer, offset, &(body->file.hash)); |
446 | encode_step_ext(buffer, offset, body->file.name, sizeof(body->file.name)); | 479 | encode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name)); |
447 | encode_step_ext(buffer, offset, body->file.uri, min(length - offset, strlen(body->file.uri))); | 480 | encode_step_ext (buffer, offset, body->file.uri, min (length - offset, |
481 | strlen ( | ||
482 | body->file.uri))); | ||
448 | break; | 483 | break; |
449 | case GNUNET_MESSENGER_KIND_PRIVATE: | 484 | case GNUNET_MESSENGER_KIND_PRIVATE: |
450 | encode_step(buffer, offset, &(body->privacy.key)); | 485 | encode_step (buffer, offset, &(body->privacy.key)); |
451 | encode_step_ext(buffer, offset, body->privacy.data, min(length - offset, body->privacy.length)); | 486 | encode_step_ext (buffer, offset, body->privacy.data, min (length - offset, |
487 | body->privacy. | ||
488 | length)); | ||
452 | break; | 489 | break; |
453 | case GNUNET_MESSENGER_KIND_DELETE: | 490 | case GNUNET_MESSENGER_KIND_DELETE: |
454 | encode_step(buffer, offset, &(body->deletion.hash)); | 491 | encode_step (buffer, offset, &(body->deletion.hash)); |
455 | encode_step(buffer, offset, &(body->deletion.delay)); | 492 | encode_step (buffer, offset, &(body->deletion.delay)); |
456 | break; | 493 | break; |
457 | default: | 494 | default: |
458 | break; | 495 | break; |
@@ -464,43 +501,48 @@ encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, | |||
464 | const uint16_t padding = length - offset; | 501 | const uint16_t padding = length - offset; |
465 | const uint16_t used_padding = sizeof(padding) + sizeof(char); | 502 | const uint16_t used_padding = sizeof(padding) + sizeof(char); |
466 | 503 | ||
467 | GNUNET_assert(padding >= used_padding); | 504 | GNUNET_assert (padding >= used_padding); |
468 | 505 | ||
469 | buffer[offset++] = '\0'; | 506 | buffer[offset++] = '\0'; |
470 | 507 | ||
471 | if (padding > used_padding) | 508 | if (padding > used_padding) |
472 | GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, buffer + offset, padding - used_padding); | 509 | GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, buffer + offset, |
510 | padding - used_padding); | ||
473 | 511 | ||
474 | GNUNET_memcpy(buffer + length - sizeof(padding), &padding, sizeof(padding)); | 512 | GNUNET_memcpy (buffer + length - sizeof(padding), &padding, sizeof(padding)); |
475 | } | 513 | } |
476 | 514 | ||
515 | |||
477 | void | 516 | void |
478 | encode_message (const struct GNUNET_MESSENGER_Message *message, | 517 | encode_message (const struct GNUNET_MESSENGER_Message *message, |
479 | uint16_t length, | 518 | uint16_t length, |
480 | char *buffer, | 519 | char *buffer, |
481 | int include_header) | 520 | int include_header) |
482 | { | 521 | { |
483 | GNUNET_assert((message) && (buffer)); | 522 | GNUNET_assert ((message) && (buffer)); |
484 | 523 | ||
485 | uint16_t offset = 0; | 524 | uint16_t offset = 0; |
486 | 525 | ||
487 | if (GNUNET_YES == include_header) | 526 | if (GNUNET_YES == include_header) |
488 | encode_step_signature(buffer, offset, &(message->header.signature), length); | 527 | encode_step_signature (buffer, offset, &(message->header.signature), |
528 | length); | ||
489 | 529 | ||
490 | const kind_t kind = GNUNET_htobe32((kind_t) message->header.kind); | 530 | const kind_t kind = GNUNET_htobe32 ((kind_t) message->header.kind); |
491 | 531 | ||
492 | if (GNUNET_YES == include_header) | 532 | if (GNUNET_YES == include_header) |
493 | { | 533 | { |
494 | encode_step(buffer, offset, &(message->header.timestamp)); | 534 | encode_step (buffer, offset, &(message->header.timestamp)); |
495 | encode_step(buffer, offset, &(message->header.sender_id)); | 535 | encode_step (buffer, offset, &(message->header.sender_id)); |
496 | encode_step(buffer, offset, &(message->header.previous)); | 536 | encode_step (buffer, offset, &(message->header.previous)); |
497 | } | 537 | } |
498 | 538 | ||
499 | encode_step(buffer, offset, &kind); | 539 | encode_step (buffer, offset, &kind); |
500 | 540 | ||
501 | encode_message_body (message->header.kind, &(message->body), length, buffer, offset); | 541 | encode_message_body (message->header.kind, &(message->body), length, buffer, |
542 | offset); | ||
502 | } | 543 | } |
503 | 544 | ||
545 | |||
504 | static void | 546 | static void |
505 | encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message, | 547 | encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message, |
506 | uint16_t length, | 548 | uint16_t length, |
@@ -509,46 +551,47 @@ encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message, | |||
509 | struct GNUNET_HashCode hash; | 551 | struct GNUNET_HashCode hash; |
510 | uint16_t offset = sizeof(hash); | 552 | uint16_t offset = sizeof(hash); |
511 | 553 | ||
512 | const kind_t kind = GNUNET_htobe32((kind_t) message->kind); | 554 | const kind_t kind = GNUNET_htobe32 ((kind_t) message->kind); |
513 | 555 | ||
514 | encode_step(buffer, offset, &kind); | 556 | encode_step (buffer, offset, &kind); |
515 | 557 | ||
516 | encode_message_body (message->kind, &(message->body), length, buffer, offset); | 558 | encode_message_body (message->kind, &(message->body), length, buffer, offset); |
517 | 559 | ||
518 | GNUNET_CRYPTO_hash( | 560 | GNUNET_CRYPTO_hash ( |
519 | buffer + sizeof(hash), | 561 | buffer + sizeof(hash), |
520 | length - sizeof(hash), | 562 | length - sizeof(hash), |
521 | &hash | 563 | &hash |
522 | ); | 564 | ); |
523 | 565 | ||
524 | GNUNET_memcpy(buffer, &hash, sizeof(hash)); | 566 | GNUNET_memcpy (buffer, &hash, sizeof(hash)); |
525 | } | 567 | } |
526 | 568 | ||
569 | |||
527 | #define decode_step_ext(src, offset, dst, size) do { \ | 570 | #define decode_step_ext(src, offset, dst, size) do { \ |
528 | GNUNET_memcpy(dst, src + offset, size); \ | 571 | GNUNET_memcpy (dst, src + offset, size); \ |
529 | offset += size; \ | 572 | offset += size; \ |
530 | } while (0) | 573 | } while (0) |
531 | 574 | ||
532 | #define decode_step(src, offset, dst) do { \ | 575 | #define decode_step(src, offset, dst) do { \ |
533 | decode_step_ext(src, offset, dst, sizeof(*dst)); \ | 576 | decode_step_ext (src, offset, dst, sizeof(*dst)); \ |
534 | } while (0) | 577 | } while (0) |
535 | 578 | ||
536 | #define decode_step_malloc(src, offset, dst, size, zero) do { \ | 579 | #define decode_step_malloc(src, offset, dst, size, zero) do { \ |
537 | dst = GNUNET_malloc(size + zero); \ | 580 | dst = GNUNET_malloc (size + zero); \ |
538 | if (zero) dst[size] = 0; \ | 581 | if (zero) dst[size] = 0; \ |
539 | decode_step_ext(src, offset, dst, size); \ | 582 | decode_step_ext (src, offset, dst, size); \ |
540 | } while (0) | 583 | } while (0) |
541 | 584 | ||
542 | #define decode_step_key(src, offset, dst, length) do { \ | 585 | #define decode_step_key(src, offset, dst, length) do { \ |
543 | enum GNUNET_GenericReturnValue result; \ | 586 | enum GNUNET_GenericReturnValue result; \ |
544 | size_t read; \ | 587 | size_t read; \ |
545 | result = GNUNET_IDENTITY_read_public_key_from_buffer( \ | 588 | result = GNUNET_IDENTITY_read_public_key_from_buffer ( \ |
546 | src + offset, length - offset, dst, &read \ | 589 | src + offset, length - offset, dst, &read \ |
547 | ); \ | 590 | ); \ |
548 | if (GNUNET_SYSERR == result) \ | 591 | if (GNUNET_SYSERR == result) \ |
549 | GNUNET_break(0); \ | 592 | GNUNET_break (0); \ |
550 | else \ | 593 | else \ |
551 | offset += read; \ | 594 | offset += read; \ |
552 | } while (0) | 595 | } while (0) |
553 | 596 | ||
554 | static uint16_t | 597 | static uint16_t |
@@ -560,7 +603,7 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, | |||
560 | { | 603 | { |
561 | uint16_t padding = 0; | 604 | uint16_t padding = 0; |
562 | 605 | ||
563 | GNUNET_memcpy(&padding, buffer + length - sizeof(padding), sizeof(padding)); | 606 | GNUNET_memcpy (&padding, buffer + length - sizeof(padding), sizeof(padding)); |
564 | 607 | ||
565 | if (padding > length - offset) | 608 | if (padding > length - offset) |
566 | padding = 0; | 609 | padding = 0; |
@@ -576,60 +619,60 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, | |||
576 | switch (*kind) | 619 | switch (*kind) |
577 | { | 620 | { |
578 | case GNUNET_MESSENGER_KIND_INFO: { | 621 | case GNUNET_MESSENGER_KIND_INFO: { |
579 | decode_step_key(buffer, offset, &(body->info.host_key), length); | 622 | decode_step_key (buffer, offset, &(body->info.host_key), length); |
580 | decode_step(buffer, offset, &version); | 623 | decode_step (buffer, offset, &version); |
581 | 624 | ||
582 | body->info.messenger_version = GNUNET_be32toh(version); | 625 | body->info.messenger_version = GNUNET_be32toh (version); |
583 | break; | 626 | break; |
584 | } case GNUNET_MESSENGER_KIND_JOIN: { | 627 | } case GNUNET_MESSENGER_KIND_JOIN: { |
585 | decode_step_key(buffer, offset, &(body->join.key), length); | 628 | decode_step_key (buffer, offset, &(body->join.key), length); |
586 | break; | 629 | break; |
587 | } case GNUNET_MESSENGER_KIND_NAME: | 630 | } case GNUNET_MESSENGER_KIND_NAME: |
588 | if (length - offset > 0) | 631 | if (length - offset > 0) |
589 | decode_step_malloc(buffer, offset, body->name.name, length - offset, 1); | 632 | decode_step_malloc (buffer, offset, body->name.name, length - offset, 1); |
590 | else | 633 | else |
591 | body->name.name = NULL; | 634 | body->name.name = NULL; |
592 | break; | 635 | break; |
593 | case GNUNET_MESSENGER_KIND_KEY: | 636 | case GNUNET_MESSENGER_KIND_KEY: |
594 | decode_step_key(buffer, offset, &(body->key.key), length); | 637 | decode_step_key (buffer, offset, &(body->key.key), length); |
595 | break; | 638 | break; |
596 | case GNUNET_MESSENGER_KIND_PEER: | 639 | case GNUNET_MESSENGER_KIND_PEER: |
597 | decode_step(buffer, offset, &(body->peer.peer)); | 640 | decode_step (buffer, offset, &(body->peer.peer)); |
598 | break; | 641 | break; |
599 | case GNUNET_MESSENGER_KIND_ID: | 642 | case GNUNET_MESSENGER_KIND_ID: |
600 | decode_step(buffer, offset, &(body->id.id)); | 643 | decode_step (buffer, offset, &(body->id.id)); |
601 | break; | 644 | break; |
602 | case GNUNET_MESSENGER_KIND_MISS: | 645 | case GNUNET_MESSENGER_KIND_MISS: |
603 | decode_step(buffer, offset, &(body->miss.peer)); | 646 | decode_step (buffer, offset, &(body->miss.peer)); |
604 | break; | 647 | break; |
605 | case GNUNET_MESSENGER_KIND_MERGE: | 648 | case GNUNET_MESSENGER_KIND_MERGE: |
606 | decode_step(buffer, offset, &(body->merge.previous)); | 649 | decode_step (buffer, offset, &(body->merge.previous)); |
607 | break; | 650 | break; |
608 | case GNUNET_MESSENGER_KIND_REQUEST: | 651 | case GNUNET_MESSENGER_KIND_REQUEST: |
609 | decode_step(buffer, offset, &(body->request.hash)); | 652 | decode_step (buffer, offset, &(body->request.hash)); |
610 | break; | 653 | break; |
611 | case GNUNET_MESSENGER_KIND_INVITE: | 654 | case GNUNET_MESSENGER_KIND_INVITE: |
612 | decode_step(buffer, offset, &(body->invite.door)); | 655 | decode_step (buffer, offset, &(body->invite.door)); |
613 | decode_step(buffer, offset, &(body->invite.key)); | 656 | decode_step (buffer, offset, &(body->invite.key)); |
614 | break; | 657 | break; |
615 | case GNUNET_MESSENGER_KIND_TEXT: | 658 | case GNUNET_MESSENGER_KIND_TEXT: |
616 | decode_step_malloc(buffer, offset, body->text.text, length - offset, 1); | 659 | decode_step_malloc (buffer, offset, body->text.text, length - offset, 1); |
617 | break; | 660 | break; |
618 | case GNUNET_MESSENGER_KIND_FILE: | 661 | case GNUNET_MESSENGER_KIND_FILE: |
619 | decode_step(buffer, offset, &(body->file.key)); | 662 | decode_step (buffer, offset, &(body->file.key)); |
620 | decode_step(buffer, offset, &(body->file.hash)); | 663 | decode_step (buffer, offset, &(body->file.hash)); |
621 | decode_step_ext(buffer, offset, body->file.name, sizeof(body->file.name)); | 664 | decode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name)); |
622 | decode_step_malloc(buffer, offset, body->file.uri, length - offset, 1); | 665 | decode_step_malloc (buffer, offset, body->file.uri, length - offset, 1); |
623 | break; | 666 | break; |
624 | case GNUNET_MESSENGER_KIND_PRIVATE: | 667 | case GNUNET_MESSENGER_KIND_PRIVATE: |
625 | decode_step(buffer, offset, &(body->privacy.key)); | 668 | decode_step (buffer, offset, &(body->privacy.key)); |
626 | 669 | ||
627 | body->privacy.length = (length - offset); | 670 | body->privacy.length = (length - offset); |
628 | decode_step_malloc(buffer, offset, body->privacy.data, length - offset, 0); | 671 | decode_step_malloc (buffer, offset, body->privacy.data, length - offset, 0); |
629 | break; | 672 | break; |
630 | case GNUNET_MESSENGER_KIND_DELETE: | 673 | case GNUNET_MESSENGER_KIND_DELETE: |
631 | decode_step(buffer, offset, &(body->deletion.hash)); | 674 | decode_step (buffer, offset, &(body->deletion.hash)); |
632 | decode_step(buffer, offset, &(body->deletion.delay)); | 675 | decode_step (buffer, offset, &(body->deletion.delay)); |
633 | break; | 676 | break; |
634 | default: | 677 | default: |
635 | *kind = GNUNET_MESSENGER_KIND_UNKNOWN; | 678 | *kind = GNUNET_MESSENGER_KIND_UNKNOWN; |
@@ -639,6 +682,7 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, | |||
639 | return padding; | 682 | return padding; |
640 | } | 683 | } |
641 | 684 | ||
685 | |||
642 | int | 686 | int |
643 | decode_message (struct GNUNET_MESSENGER_Message *message, | 687 | decode_message (struct GNUNET_MESSENGER_Message *message, |
644 | uint16_t length, | 688 | uint16_t length, |
@@ -646,19 +690,20 @@ decode_message (struct GNUNET_MESSENGER_Message *message, | |||
646 | int include_header, | 690 | int include_header, |
647 | uint16_t *padding) | 691 | uint16_t *padding) |
648 | { | 692 | { |
649 | GNUNET_assert( | 693 | GNUNET_assert ( |
650 | (message) && | 694 | (message) && |
651 | (buffer) && | 695 | (buffer) && |
652 | (length >= get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN, include_header)) | 696 | (length >= get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN, |
653 | ); | 697 | include_header)) |
698 | ); | ||
654 | 699 | ||
655 | uint16_t offset = 0; | 700 | uint16_t offset = 0; |
656 | 701 | ||
657 | if (GNUNET_YES == include_header) | 702 | if (GNUNET_YES == include_header) |
658 | { | 703 | { |
659 | ssize_t result = GNUNET_IDENTITY_read_signature_from_buffer( | 704 | ssize_t result = GNUNET_IDENTITY_read_signature_from_buffer ( |
660 | &(message->header.signature), buffer, length - offset | 705 | &(message->header.signature), buffer, length - offset |
661 | ); | 706 | ); |
662 | 707 | ||
663 | if (result < 0) | 708 | if (result < 0) |
664 | return GNUNET_NO; | 709 | return GNUNET_NO; |
@@ -668,26 +713,30 @@ decode_message (struct GNUNET_MESSENGER_Message *message, | |||
668 | 713 | ||
669 | const uint16_t count = length - offset; | 714 | const uint16_t count = length - offset; |
670 | 715 | ||
671 | if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN, include_header)) | 716 | if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN, |
717 | include_header)) | ||
672 | return GNUNET_NO; | 718 | return GNUNET_NO; |
673 | 719 | ||
674 | kind_t kind; | 720 | kind_t kind; |
675 | 721 | ||
676 | if (GNUNET_YES == include_header) | 722 | if (GNUNET_YES == include_header) |
677 | { | 723 | { |
678 | decode_step(buffer, offset, &(message->header.timestamp)); | 724 | decode_step (buffer, offset, &(message->header.timestamp)); |
679 | decode_step(buffer, offset, &(message->header.sender_id)); | 725 | decode_step (buffer, offset, &(message->header.sender_id)); |
680 | decode_step(buffer, offset, &(message->header.previous)); | 726 | decode_step (buffer, offset, &(message->header.previous)); |
681 | } | 727 | } |
682 | 728 | ||
683 | decode_step(buffer, offset, &kind); | 729 | decode_step (buffer, offset, &kind); |
684 | 730 | ||
685 | message->header.kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh(kind); | 731 | message->header.kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh ( |
732 | kind); | ||
686 | 733 | ||
687 | if (count < get_message_kind_size (message->header.kind, include_header)) | 734 | if (count < get_message_kind_size (message->header.kind, include_header)) |
688 | return GNUNET_NO; | 735 | return GNUNET_NO; |
689 | 736 | ||
690 | const uint16_t result = decode_message_body (&(message->header.kind), &(message->body), length, buffer, offset); | 737 | const uint16_t result = decode_message_body (&(message->header.kind), |
738 | &(message->body), length, buffer, | ||
739 | offset); | ||
691 | 740 | ||
692 | if (padding) | 741 | if (padding) |
693 | *padding = result; | 742 | *padding = result; |
@@ -695,6 +744,7 @@ decode_message (struct GNUNET_MESSENGER_Message *message, | |||
695 | return GNUNET_YES; | 744 | return GNUNET_YES; |
696 | } | 745 | } |
697 | 746 | ||
747 | |||
698 | static int | 748 | static int |
699 | decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, | 749 | decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, |
700 | uint16_t length, | 750 | uint16_t length, |
@@ -706,27 +756,28 @@ decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, | |||
706 | if (length < get_short_message_size (NULL, GNUNET_NO)) | 756 | if (length < get_short_message_size (NULL, GNUNET_NO)) |
707 | return GNUNET_NO; | 757 | return GNUNET_NO; |
708 | 758 | ||
709 | GNUNET_memcpy(&hash, buffer, sizeof(hash)); | 759 | GNUNET_memcpy (&hash, buffer, sizeof(hash)); |
710 | 760 | ||
711 | GNUNET_CRYPTO_hash( | 761 | GNUNET_CRYPTO_hash ( |
712 | buffer + sizeof(hash), | 762 | buffer + sizeof(hash), |
713 | length - sizeof(hash), | 763 | length - sizeof(hash), |
714 | &expected | 764 | &expected |
715 | ); | 765 | ); |
716 | 766 | ||
717 | if (0 != GNUNET_CRYPTO_hash_cmp(&hash, &expected)) | 767 | if (0 != GNUNET_CRYPTO_hash_cmp (&hash, &expected)) |
718 | return GNUNET_NO; | 768 | return GNUNET_NO; |
719 | 769 | ||
720 | kind_t kind; | 770 | kind_t kind; |
721 | 771 | ||
722 | decode_step(buffer, offset, &kind); | 772 | decode_step (buffer, offset, &kind); |
723 | 773 | ||
724 | message->kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh(kind); | 774 | message->kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh (kind); |
725 | 775 | ||
726 | if (length < get_short_message_size (message, GNUNET_NO)) | 776 | if (length < get_short_message_size (message, GNUNET_NO)) |
727 | return GNUNET_NO; | 777 | return GNUNET_NO; |
728 | 778 | ||
729 | decode_message_body (&(message->kind), &(message->body), length, buffer, offset); | 779 | decode_message_body (&(message->kind), &(message->body), length, buffer, |
780 | offset); | ||
730 | 781 | ||
731 | if (GNUNET_MESSENGER_KIND_UNKNOWN == message->kind) | 782 | if (GNUNET_MESSENGER_KIND_UNKNOWN == message->kind) |
732 | return GNUNET_NO; | 783 | return GNUNET_NO; |
@@ -734,21 +785,23 @@ decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, | |||
734 | return GNUNET_YES; | 785 | return GNUNET_YES; |
735 | } | 786 | } |
736 | 787 | ||
788 | |||
737 | void | 789 | void |
738 | hash_message (const struct GNUNET_MESSENGER_Message *message, | 790 | hash_message (const struct GNUNET_MESSENGER_Message *message, |
739 | uint16_t length, | 791 | uint16_t length, |
740 | const char *buffer, | 792 | const char *buffer, |
741 | struct GNUNET_HashCode *hash) | 793 | struct GNUNET_HashCode *hash) |
742 | { | 794 | { |
743 | GNUNET_assert((message) && (buffer) && (hash)); | 795 | GNUNET_assert ((message) && (buffer) && (hash)); |
744 | 796 | ||
745 | const ssize_t offset = GNUNET_IDENTITY_signature_get_length( | 797 | const ssize_t offset = GNUNET_IDENTITY_signature_get_length ( |
746 | &(message->header.signature) | 798 | &(message->header.signature) |
747 | ); | 799 | ); |
748 | 800 | ||
749 | GNUNET_CRYPTO_hash (buffer + offset, length - offset, hash); | 801 | GNUNET_CRYPTO_hash (buffer + offset, length - offset, hash); |
750 | } | 802 | } |
751 | 803 | ||
804 | |||
752 | void | 805 | void |
753 | sign_message (struct GNUNET_MESSENGER_Message *message, | 806 | sign_message (struct GNUNET_MESSENGER_Message *message, |
754 | uint16_t length, | 807 | uint16_t length, |
@@ -756,26 +809,27 @@ sign_message (struct GNUNET_MESSENGER_Message *message, | |||
756 | const struct GNUNET_HashCode *hash, | 809 | const struct GNUNET_HashCode *hash, |
757 | const struct GNUNET_MESSENGER_Ego *ego) | 810 | const struct GNUNET_MESSENGER_Ego *ego) |
758 | { | 811 | { |
759 | GNUNET_assert((message) && (buffer) && (hash) && (ego)); | 812 | GNUNET_assert ((message) && (buffer) && (hash) && (ego)); |
760 | 813 | ||
761 | struct GNUNET_MESSENGER_MessageSignature signature; | 814 | struct GNUNET_MESSENGER_MessageSignature signature; |
762 | 815 | ||
763 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); | 816 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); |
764 | signature.purpose.size = htonl (sizeof(signature)); | 817 | signature.purpose.size = htonl (sizeof(signature)); |
765 | 818 | ||
766 | GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); | 819 | GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); |
767 | GNUNET_IDENTITY_sign(&(ego->priv), &signature, &(message->header.signature)); | 820 | GNUNET_IDENTITY_sign (&(ego->priv), &signature, &(message->header.signature)); |
768 | 821 | ||
769 | uint16_t offset = 0; | 822 | uint16_t offset = 0; |
770 | encode_step_signature(buffer, offset, &(message->header.signature), length); | 823 | encode_step_signature (buffer, offset, &(message->header.signature), length); |
771 | } | 824 | } |
772 | 825 | ||
826 | |||
773 | int | 827 | int |
774 | verify_message (const struct GNUNET_MESSENGER_Message *message, | 828 | verify_message (const struct GNUNET_MESSENGER_Message *message, |
775 | const struct GNUNET_HashCode *hash, | 829 | const struct GNUNET_HashCode *hash, |
776 | const struct GNUNET_IDENTITY_PublicKey *key) | 830 | const struct GNUNET_IDENTITY_PublicKey *key) |
777 | { | 831 | { |
778 | GNUNET_assert((message) && (hash) && (key)); | 832 | GNUNET_assert ((message) && (hash) && (key)); |
779 | 833 | ||
780 | if (ntohl (key->type) != ntohl (message->header.signature.type)) | 834 | if (ntohl (key->type) != ntohl (message->header.signature.type)) |
781 | return GNUNET_SYSERR; | 835 | return GNUNET_SYSERR; |
@@ -785,67 +839,77 @@ verify_message (const struct GNUNET_MESSENGER_Message *message, | |||
785 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); | 839 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); |
786 | signature.purpose.size = htonl (sizeof(signature)); | 840 | signature.purpose.size = htonl (sizeof(signature)); |
787 | 841 | ||
788 | GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); | 842 | GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); |
789 | 843 | ||
790 | return GNUNET_IDENTITY_signature_verify(GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature, | 844 | return GNUNET_IDENTITY_signature_verify ( |
791 | &(message->header.signature), key); | 845 | GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature, |
846 | &(message->header.signature), key); | ||
792 | } | 847 | } |
793 | 848 | ||
849 | |||
794 | int | 850 | int |
795 | encrypt_message (struct GNUNET_MESSENGER_Message *message, | 851 | encrypt_message (struct GNUNET_MESSENGER_Message *message, |
796 | const struct GNUNET_IDENTITY_PublicKey *key) | 852 | const struct GNUNET_IDENTITY_PublicKey *key) |
797 | { | 853 | { |
798 | GNUNET_assert((message) && (key)); | 854 | GNUNET_assert ((message) && (key)); |
799 | 855 | ||
800 | struct GNUNET_MESSENGER_ShortMessage shortened; | 856 | struct GNUNET_MESSENGER_ShortMessage shortened; |
801 | 857 | ||
802 | fold_short_message (message, &shortened); | 858 | fold_short_message (message, &shortened); |
803 | 859 | ||
804 | const uint16_t length = get_short_message_size (&shortened, GNUNET_YES); | 860 | const uint16_t length = get_short_message_size (&shortened, GNUNET_YES); |
805 | const uint16_t padded_length = calc_padded_length(length); | 861 | const uint16_t padded_length = calc_padded_length (length); |
806 | 862 | ||
807 | message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE; | 863 | message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE; |
808 | message->body.privacy.data = GNUNET_malloc(padded_length); | 864 | message->body.privacy.data = GNUNET_malloc (padded_length); |
809 | message->body.privacy.length = padded_length; | 865 | message->body.privacy.length = padded_length; |
810 | 866 | ||
811 | encode_short_message (&shortened, padded_length, message->body.privacy.data); | 867 | encode_short_message (&shortened, padded_length, message->body.privacy.data); |
812 | 868 | ||
813 | if (padded_length == GNUNET_IDENTITY_encrypt (message->body.privacy.data, padded_length, key, | 869 | if (padded_length == GNUNET_IDENTITY_encrypt_old (message->body.privacy.data, |
814 | &(message->body.privacy.key), | 870 | padded_length, key, |
815 | message->body.privacy.data)) | 871 | &(message->body.privacy.key), |
872 | message->body.privacy.data)) | ||
816 | { | 873 | { |
817 | destroy_message_body (shortened.kind, &(shortened.body)); | 874 | destroy_message_body (shortened.kind, &(shortened.body)); |
818 | return GNUNET_YES; | 875 | return GNUNET_YES; |
819 | } | 876 | } |
820 | else | 877 | else |
821 | { | 878 | { |
822 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n"); | 879 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n"); |
823 | 880 | ||
824 | unfold_short_message (&shortened, message); | 881 | unfold_short_message (&shortened, message); |
825 | return GNUNET_NO; | 882 | return GNUNET_NO; |
826 | } | 883 | } |
827 | } | 884 | } |
828 | 885 | ||
886 | |||
829 | int | 887 | int |
830 | decrypt_message (struct GNUNET_MESSENGER_Message *message, | 888 | decrypt_message (struct GNUNET_MESSENGER_Message *message, |
831 | const struct GNUNET_IDENTITY_PrivateKey *key) | 889 | const struct GNUNET_IDENTITY_PrivateKey *key) |
832 | { | 890 | { |
833 | GNUNET_assert((message) && (key)); | 891 | GNUNET_assert ((message) && (key)); |
834 | 892 | ||
835 | if (message->body.privacy.length != GNUNET_IDENTITY_decrypt (message->body.privacy.data, message->body.privacy.length, | 893 | if (message->body.privacy.length != GNUNET_IDENTITY_decrypt_old ( |
836 | key, &(message->body.privacy.key), | 894 | message->body.privacy.data, message->body.privacy.length, |
837 | message->body.privacy.data)) | 895 | key, |
896 | &(message->body.privacy.key), | ||
897 | message->body. | ||
898 | privacy.data)) | ||
838 | { | 899 | { |
839 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Decrypting message failed!\n"); | 900 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Decrypting message failed!\n"); |
840 | 901 | ||
841 | return GNUNET_NO; | 902 | return GNUNET_NO; |
842 | } | 903 | } |
843 | 904 | ||
844 | struct GNUNET_MESSENGER_ShortMessage shortened; | 905 | struct GNUNET_MESSENGER_ShortMessage shortened; |
845 | 906 | ||
846 | if (GNUNET_YES != decode_short_message (&shortened, message->body.privacy.length, message->body.privacy.data)) | 907 | if (GNUNET_YES != decode_short_message (&shortened, |
908 | message->body.privacy.length, | ||
909 | message->body.privacy.data)) | ||
847 | { | 910 | { |
848 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Decoding decrypted message failed!\n"); | 911 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
912 | "Decoding decrypted message failed!\n"); | ||
849 | 913 | ||
850 | return GNUNET_NO; | 914 | return GNUNET_NO; |
851 | } | 915 | } |
@@ -855,31 +919,34 @@ decrypt_message (struct GNUNET_MESSENGER_Message *message, | |||
855 | return GNUNET_YES; | 919 | return GNUNET_YES; |
856 | } | 920 | } |
857 | 921 | ||
922 | |||
858 | struct GNUNET_MQ_Envelope* | 923 | struct GNUNET_MQ_Envelope* |
859 | pack_message (struct GNUNET_MESSENGER_Message *message, | 924 | pack_message (struct GNUNET_MESSENGER_Message *message, |
860 | struct GNUNET_HashCode *hash, | 925 | struct GNUNET_HashCode *hash, |
861 | const struct GNUNET_MESSENGER_Ego *ego, | 926 | const struct GNUNET_MESSENGER_Ego *ego, |
862 | int mode) | 927 | int mode) |
863 | { | 928 | { |
864 | GNUNET_assert(message); | 929 | GNUNET_assert (message); |
865 | 930 | ||
866 | if (ego) | 931 | if (ego) |
867 | message->header.signature.type = ego->priv.type; | 932 | message->header.signature.type = ego->priv.type; |
868 | 933 | ||
869 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Packing message kind=%u and sender: %s\n", | 934 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
870 | message->header.kind, GNUNET_sh2s(&(message->header.sender_id))); | 935 | "Packing message kind=%u and sender: %s\n", |
936 | message->header.kind, GNUNET_sh2s (&(message->header.sender_id))); | ||
871 | 937 | ||
872 | struct GNUNET_MessageHeader *header; | 938 | struct GNUNET_MessageHeader *header; |
873 | 939 | ||
874 | const uint16_t length = get_message_size (message, GNUNET_YES); | 940 | const uint16_t length = get_message_size (message, GNUNET_YES); |
875 | const uint16_t padded_length = calc_padded_length(length); | 941 | const uint16_t padded_length = calc_padded_length (length); |
876 | 942 | ||
877 | struct GNUNET_MQ_Envelope *env; | 943 | struct GNUNET_MQ_Envelope *env; |
878 | char *buffer; | 944 | char *buffer; |
879 | 945 | ||
880 | if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode) | 946 | if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode) |
881 | { | 947 | { |
882 | env = GNUNET_MQ_msg_extra(header, padded_length, GNUNET_MESSAGE_TYPE_CADET_CLI); | 948 | env = GNUNET_MQ_msg_extra (header, padded_length, |
949 | GNUNET_MESSAGE_TYPE_CADET_CLI); | ||
883 | 950 | ||
884 | buffer = (char*) &(header[1]); | 951 | buffer = (char*) &(header[1]); |
885 | } | 952 | } |
@@ -887,7 +954,7 @@ pack_message (struct GNUNET_MESSENGER_Message *message, | |||
887 | { | 954 | { |
888 | env = NULL; | 955 | env = NULL; |
889 | 956 | ||
890 | buffer = GNUNET_malloc(padded_length); | 957 | buffer = GNUNET_malloc (padded_length); |
891 | } | 958 | } |
892 | 959 | ||
893 | encode_message (message, padded_length, buffer, GNUNET_YES); | 960 | encode_message (message, padded_length, buffer, GNUNET_YES); |
@@ -901,11 +968,12 @@ pack_message (struct GNUNET_MESSENGER_Message *message, | |||
901 | } | 968 | } |
902 | 969 | ||
903 | if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode) | 970 | if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode) |
904 | GNUNET_free(buffer); | 971 | GNUNET_free (buffer); |
905 | 972 | ||
906 | return env; | 973 | return env; |
907 | } | 974 | } |
908 | 975 | ||
976 | |||
909 | int | 977 | int |
910 | filter_message_sending (const struct GNUNET_MESSENGER_Message *message) | 978 | filter_message_sending (const struct GNUNET_MESSENGER_Message *message) |
911 | { | 979 | { |