← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libotr/oneiric-security

« back to all changes in this revision

Viewing changes to toolkit/parse.c

  • Committer: Bazaar Package Importer
  • Author(s): Thibaut VARENE
  • Date: 2006-01-02 19:52:18 UTC
  • mfrom: (2.1.1 dapper)
  • Revision ID: james.westby@ubuntu.com-20060102195218-wb8803196y9mycx6
Tags: 3.0.0-2
http://bugs.debian.org/345400
Fix typo: "malformed messahes" (Closes: #345400)

Show diffs side-by-side

added added

removed removed

Lines of Context:
toolkit/parse.c
182
182
    free(keyexch);
183
183
}
184
184
 
 
185
/* Parse a D-H Commit Message into a newly-allocated CommitMsg structure */
 
186
CommitMsg parse_commit(const char *msg)
 
187
{
 
188
    CommitMsg cmsg = NULL;
 
189
    size_t lenp;
 
190
    unsigned char *raw = decode(msg, &lenp);
 
191
    unsigned char *bufp = raw;
 
192
    if (!raw) goto inv;
 
193
 
 
194
    cmsg = calloc(1, sizeof(struct s_CommitMsg));
 
195
    if (!cmsg) {
 
196
        free(raw);
 
197
        goto inv;
 
198
    }
 
199
 
 
200
    cmsg->raw = raw;
 
201
 
 
202
    require_len(3);
 
203
    if (memcmp(bufp, "\x00\x02\x02", 3)) goto inv;
 
204
    bufp += 3; lenp -= 3;
 
205
 
 
206
    read_int(cmsg->enckeylen);
 
207
    cmsg->enckey = malloc(cmsg->enckeylen);
 
208
    if (!cmsg->enckey && cmsg->enckeylen > 0) goto inv;
 
209
    read_raw(cmsg->enckey, cmsg->enckeylen);
 
210
 
 
211
    read_int(cmsg->hashkeylen);
 
212
    cmsg->hashkey = malloc(cmsg->hashkeylen);
 
213
    if (!cmsg->hashkey && cmsg->hashkeylen > 0) goto inv;
 
214
    read_raw(cmsg->hashkey, cmsg->hashkeylen);
 
215
 
 
216
    if (lenp != 0) goto inv;
 
217
 
 
218
    return cmsg;
 
219
inv:
 
220
    free_commit(cmsg);
 
221
    return NULL;
 
222
}
 
223
 
 
224
/* Deallocate a CommitMsg and all of the data it points to */
 
225
void free_commit(CommitMsg cmsg)
 
226
{
 
227
    if (!cmsg) return;
 
228
    free(cmsg->raw);
 
229
    free(cmsg->enckey);
 
230
    free(cmsg->hashkey);
 
231
    free(cmsg);
 
232
}
 
233
 
 
234
/* Parse a D-H Key Message into a newly-allocated KeyMsg structure */
 
235
KeyMsg parse_key(const char *msg)
 
236
{
 
237
    KeyMsg kmsg = NULL;
 
238
    size_t lenp;
 
239
    unsigned char *raw = decode(msg, &lenp);
 
240
    unsigned char *bufp = raw;
 
241
    if (!raw) goto inv;
 
242
 
 
243
    kmsg = calloc(1, sizeof(struct s_KeyMsg));
 
244
    if (!kmsg) {
 
245
        free(raw);
 
246
        goto inv;
 
247
    }
 
248
 
 
249
    kmsg->raw = raw;
 
250
 
 
251
    require_len(3);
 
252
    if (memcmp(bufp, "\x00\x02\x0a", 3)) goto inv;
 
253
    bufp += 3; lenp -= 3;
 
254
 
 
255
    read_mpi(kmsg->y);
 
256
 
 
257
    if (lenp != 0) goto inv;
 
258
 
 
259
    return kmsg;
 
260
inv:
 
261
    free_key(kmsg);
 
262
    return NULL;
 
263
}
 
264
 
 
265
/* Deallocate a KeyMsg and all of the data it points to */
 
266
void free_key(KeyMsg kmsg)
 
267
{
 
268
    if (!kmsg) return;
 
269
    free(kmsg->raw);
 
270
    gcry_mpi_release(kmsg->y);
 
271
    free(kmsg);
 
272
}
 
273
 
 
274
/* Parse a Reveal Signature Message into a newly-allocated RevealSigMsg
 
275
 * structure */
 
276
RevealSigMsg parse_revealsig(const char *msg)
 
277
{
 
278
    RevealSigMsg rmsg = NULL;
 
279
    size_t lenp;
 
280
    unsigned char *raw = decode(msg, &lenp);
 
281
    unsigned char *bufp = raw;
 
282
    if (!raw) goto inv;
 
283
 
 
284
    rmsg = calloc(1, sizeof(struct s_RevealSigMsg));
 
285
    if (!rmsg) {
 
286
        free(raw);
 
287
        goto inv;
 
288
    }
 
289
 
 
290
    rmsg->raw = raw;
 
291
 
 
292
    require_len(3);
 
293
    if (memcmp(bufp, "\x00\x02\x11", 3)) goto inv;
 
294
    bufp += 3; lenp -= 3;
 
295
 
 
296
    read_int(rmsg->keylen);
 
297
    rmsg->key = malloc(rmsg->keylen);
 
298
    if (!rmsg->key && rmsg->keylen > 0) goto inv;
 
299
    read_raw(rmsg->key, rmsg->keylen);
 
300
 
 
301
    read_int(rmsg->encsiglen);
 
302
    rmsg->encsig = malloc(rmsg->encsiglen);
 
303
    if (!rmsg->encsig && rmsg->encsiglen > 0) goto inv;
 
304
    read_raw(rmsg->encsig, rmsg->encsiglen);
 
305
 
 
306
    read_raw(rmsg->mac, 20);
 
307
 
 
308
    if (lenp != 0) goto inv;
 
309
 
 
310
    return rmsg;
 
311
inv:
 
312
    free_revealsig(rmsg);
 
313
    return NULL;
 
314
}
 
315
 
 
316
/* Deallocate a RevealSigMsg and all of the data it points to */
 
317
void free_revealsig(RevealSigMsg rmsg)
 
318
{
 
319
    if (!rmsg) return;
 
320
    free(rmsg->raw);
 
321
    free(rmsg->key);
 
322
    free(rmsg->encsig);
 
323
    free(rmsg);
 
324
}
 
325
 
 
326
/* Parse a Signature Message into a newly-allocated SignatureMsg structure */
 
327
SignatureMsg parse_signature(const char *msg)
 
328
{
 
329
    SignatureMsg smsg = NULL;
 
330
    size_t lenp;
 
331
    unsigned char *raw = decode(msg, &lenp);
 
332
    unsigned char *bufp = raw;
 
333
    if (!raw) goto inv;
 
334
 
 
335
    smsg = calloc(1, sizeof(struct s_SignatureMsg));
 
336
    if (!smsg) {
 
337
        free(raw);
 
338
        goto inv;
 
339
    }
 
340
 
 
341
    smsg->raw = raw;
 
342
 
 
343
    require_len(3);
 
344
    if (memcmp(bufp, "\x00\x02\x12", 3)) goto inv;
 
345
    bufp += 3; lenp -= 3;
 
346
 
 
347
    read_int(smsg->encsiglen);
 
348
    smsg->encsig = malloc(smsg->encsiglen);
 
349
    if (!smsg->encsig && smsg->encsiglen > 0) goto inv;
 
350
    read_raw(smsg->encsig, smsg->encsiglen);
 
351
 
 
352
    read_raw(smsg->mac, 20);
 
353
 
 
354
    if (lenp != 0) goto inv;
 
355
 
 
356
    return smsg;
 
357
inv:
 
358
    free_signature(smsg);
 
359
    return NULL;
 
360
}
 
361
 
 
362
/* Deallocate a SignatureMsg and all of the data it points to */
 
363
void free_signature(SignatureMsg smsg)
 
364
{
 
365
    if (!smsg) return;
 
366
    free(smsg->raw);
 
367
    free(smsg->encsig);
 
368
    free(smsg);
 
369
}
 
370
 
185
371
/* Parse a Data Message into a newly-allocated DataMsg structure */
186
372
DataMsg parse_datamsg(const char *msg)
187
373
{
189
375
    size_t lenp;
190
376
    unsigned char *raw = decode(msg, &lenp);
191
377
    unsigned char *bufp = raw;
 
378
    unsigned char version;
192
379
    if (!raw) goto inv;
193
380
 
194
381
    datam = calloc(1, sizeof(struct s_DataMsg));
202
389
    datam->macstart = bufp;
203
390
 
204
391
    require_len(3);
205
 
    if (memcmp(bufp, "\x00\x01\x03", 3)) goto inv;
 
392
    if (memcmp(bufp, "\x00\x01\x03", 3) && memcmp(bufp, "\x00\x02\x03", 3))
 
393
        goto inv;
 
394
    version = bufp[1];
206
395
    bufp += 3; lenp -= 3;
207
396
 
 
397
    if (version == 2) {
 
398
        require_len(1);
 
399
        datam->flags = bufp[0];
 
400
        bufp += 1; lenp -= 1;
 
401
    } else {
 
402
        datam->flags = -1;
 
403
    }
208
404
    read_int(datam->sender_keyid);
209
405
    read_int(datam->rcpt_keyid);
210
406
    read_mpi(datam->y);
239
435
    size_t base64len;
240
436
    char *outmsg;
241
437
    unsigned char *raw, *bufp;
 
438
    unsigned char version = (datamsg->flags >= 0 ? 2 : 1);
242
439
    
243
440
    /* Calculate the size of the message that will result */
244
441
    gcry_mpi_print(GCRYMPI_FMT_USG, NULL, 0, &ylen, datamsg->y);
245
 
    rawlen = 3 + 4 + 4 + 4 + ylen + 8 + 4 + datamsg->encmsglen + 20 +
246
 
        4 + datamsg->mackeyslen;
 
442
    rawlen = 3 + (version == 2 ? 1 : 0) + 4 + 4 + 4 + ylen + 8 + 4 +
 
443
        datamsg->encmsglen + 20 + 4 + datamsg->mackeyslen;
247
444
 
248
445
    /* Construct the new raw message (note that some of the pieces may
249
446
     * have been altered, so we construct it from scratch). */
260
457
    datamsg->raw = raw;
261
458
    datamsg->rawlen = rawlen;
262
459
 
263
 
    memmove(bufp, "\x00\x01\x03", 3);
 
460
    if (version == 1) {
 
461
        memmove(bufp, "\x00\x01\x03", 3);
 
462
    } else {
 
463
        memmove(bufp, "\x00\x02\x03", 3);
 
464
    }
264
465
    bufp += 3; lenp -= 3;
 
466
    if (version == 2) {
 
467
        bufp[0] = datamsg->flags;
 
468
        bufp += 1; lenp -= 1;
 
469
    }
265
470
    write_int(datamsg->sender_keyid);
266
471
    write_int(datamsg->rcpt_keyid);
267
472
    write_mpi(datamsg->y, ylen);
295
500
 
296
501
/* Assemble a new Data Message from its pieces.  Return a
297
502
 * newly-allocated string containing the base64 representation. */
298
 
char *assemble_datamsg(unsigned char mackey[20], unsigned int sender_keyid,
299
 
        unsigned int rcpt_keyid, gcry_mpi_t y, unsigned char ctr[8],
300
 
        unsigned char *encmsg, size_t encmsglen, unsigned char *mackeys,
301
 
        size_t mackeyslen)
 
503
char *assemble_datamsg(unsigned char mackey[20], int flags,
 
504
        unsigned int sender_keyid, unsigned int rcpt_keyid, gcry_mpi_t y,
 
505
        unsigned char ctr[8], unsigned char *encmsg, size_t encmsglen,
 
506
        unsigned char *mackeys, size_t mackeyslen)
302
507
{
303
508
    DataMsg datam = calloc(1, sizeof(struct s_DataMsg));
304
509
    char *newmsg = NULL;
305
510
    if (!datam) goto inv;
 
511
    datam->flags = flags;
306
512
    datam->sender_keyid = sender_keyid;
307
513
    datam->rcpt_keyid = rcpt_keyid;
308
514
    datam->y = gcry_mpi_copy(y);