lib/opencdk/write-packet.c

   1 /* write-packet.c - Write OpenPGP packets
   2  * Copyright (C) 2001-2012 Free Software Foundation, Inc.
   3  *
   4  * Author: Timo Schulz
   5  *
   6  * This file is part of OpenCDK.
   7  *
   8  * The OpenCDK library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 3 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <assert.h>
  29
  30 #include "opencdk.h"
  31 #include "main.h"
  32
  33
  34 static int
  35 stream_write (cdk_stream_t s, const void *buf, size_t buflen)
  36 {
  37   int nwritten;
  38
  39   nwritten = cdk_stream_write (s, buf, buflen);
  40   if (nwritten == EOF)
  41     return _cdk_stream_get_errno (s);
  42   return 0;
  43 }
  44
  45
  46 static int
  47 stream_read (cdk_stream_t s, void *buf, size_t buflen, size_t * r_nread)
  48 {
  49   int nread;
  50
  51   assert (r_nread);
  52
  53   nread = cdk_stream_read (s, buf, buflen);
  54   if (nread == EOF)
  55     return _cdk_stream_get_errno (s);
  56   *r_nread = nread;
  57   return 0;
  58 }
  59
  60
  61 static int
  62 stream_putc (cdk_stream_t s, int c)
  63 {
  64   int nwritten = cdk_stream_putc (s, c);
  65   if (nwritten == EOF)
  66     return _cdk_stream_get_errno (s);
  67   return 0;
  68 }
  69
  70
  71 static int
  72 write_32 (cdk_stream_t out, u32 u)
  73 {
  74   byte buf[4];
  75
  76   buf[0] = u >> 24;
  77   buf[1] = u >> 16;
  78   buf[2] = u >> 8;
  79   buf[3] = u;
  80   return stream_write (out, buf, 4);
  81 }
  82
  83
  84 static int
  85 write_16 (cdk_stream_t out, u16 u)
  86 {
  87   byte buf[2];
  88
  89   buf[0] = u >> 8;
  90   buf[1] = u;
  91   return stream_write (out, buf, 2);
  92 }
  93
  94
  95 static size_t
  96 calc_mpisize (bigint_t mpi[MAX_CDK_PK_PARTS], size_t ncount)
  97 {
  98   size_t size, i;
  99
 100   size = 0;
 101   for (i = 0; i < ncount; i++)
 102     size += (_gnutls_mpi_get_nbits (mpi[i]) + 7) / 8 + 2;
 103   return size;
 104 }
 105
 106
 107 static int
 108 write_mpi (cdk_stream_t out, bigint_t m)
 109 {
 110   byte buf[MAX_MPI_BYTES + 2];
 111   size_t nbits, nread;
 112   int err;
 113
 114   if (!out || !m)
 115     return CDK_Inv_Value;
 116   nbits = _gnutls_mpi_get_nbits (m);
 117   if (nbits > MAX_MPI_BITS || nbits < 1)
 118     return CDK_MPI_Error;
 119
 120   nread = MAX_MPI_BYTES + 2;
 121   err = _gnutls_mpi_print_pgp (m, buf, &nread);
 122   if (err < 0)
 123     return map_gnutls_error (err);
 124   return stream_write (out, buf, nread);
 125 }
 126
 127
 128 static cdk_error_t
 129 write_mpibuf (cdk_stream_t out, bigint_t mpi[MAX_CDK_PK_PARTS], size_t count)
 130 {
 131   size_t i;
 132   cdk_error_t rc;
 133
 134   for (i = 0; i < count; i++)
 135     {
 136       rc = write_mpi (out, mpi[i]);
 137       if (rc)
 138         return rc;
 139     }
 140   return 0;
 141 }
 142
 143
 144 static cdk_error_t
 145 pkt_encode_len (cdk_stream_t out, size_t pktlen)
 146 {
 147   cdk_error_t rc;
 148
 149   assert (out);
 150
 151   rc = 0;
 152   if (!pktlen)
 153     {
 154       /* Block mode, partial bodies, with 'DEF_BLOCKSIZE' from main.h */
 155       rc = stream_putc (out, (0xE0 | DEF_BLOCKBITS));
 156     }
 157   else if (pktlen < 192)
 158     rc = stream_putc (out, pktlen);
 159   else if (pktlen < 8384)
 160     {
 161       pktlen -= 192;
 162       rc = stream_putc (out, (pktlen / 256) + 192);
 163       if (!rc)
 164         rc = stream_putc (out, (pktlen % 256));
 165     }
 166   else
 167     {
 168       rc = stream_putc (out, 255);
 169       if (!rc)
 170         rc = write_32 (out, pktlen);
 171     }
 172
 173   return rc;
 174 }
 175
 176
 177 static cdk_error_t
 178 write_head_new (cdk_stream_t out, size_t size, int type)
 179 {
 180   cdk_error_t rc;
 181
 182   assert (out);
 183
 184   if (type < 0 || type > 63)
 185     return CDK_Inv_Packet;
 186   rc = stream_putc (out, (0xC0 | type));
 187   if (!rc)
 188     rc = pkt_encode_len (out, size);
 189   return rc;
 190 }
 191
 192
 193 static cdk_error_t
 194 write_head_old (cdk_stream_t out, size_t size, int type)
 195 {
 196   cdk_error_t rc;
 197   int ctb;
 198
 199   assert (out);
 200
 201   if (type < 0 || type > 16)
 202     return CDK_Inv_Packet;
 203   ctb = 0x80 | (type << 2);
 204   if (!size)
 205     ctb |= 3;
 206   else if (size < 256)
 207     ;
 208   else if (size < 65536)
 209     ctb |= 1;
 210   else
 211     ctb |= 2;
 212   rc = stream_putc (out, ctb);
 213   if (!size)
 214     return rc;
 215   if (!rc)
 216     {
 217       if (size < 256)
 218         rc = stream_putc (out, size);
 219       else if (size < 65536)
 220         rc = write_16 (out, size);
 221       else
 222         rc = write_32 (out, size);
 223     }
 224
 225   return rc;
 226 }
 227
 228
 229 /* Write special PGP2 packet header. PGP2 (wrongly) uses two byte header
 230    length for signatures and keys even if the size is < 256. */
 231 static cdk_error_t
 232 pkt_write_head2 (cdk_stream_t out, size_t size, int type)
 233 {
 234   cdk_error_t rc;
 235
 236   rc = cdk_stream_putc (out, 0x80 | (type << 2) | 1);
 237   if (!rc)
 238     rc = cdk_stream_putc (out, size >> 8);
 239   if (!rc)
 240     rc = cdk_stream_putc (out, size & 0xff);
 241   return rc;
 242 }
 243
 244
 245 static int
 246 pkt_write_head (cdk_stream_t out, int old_ctb, size_t size, int type)
 247 {
 248   if (old_ctb)
 249     return write_head_old (out, size, type);
 250   return write_head_new (out, size, type);
 251 }
 252
 253
 254 static int
 255 write_pubkey_enc (cdk_stream_t out, cdk_pkt_pubkey_enc_t pke, int old_ctb)
 256 {
 257   size_t size;
 258   int rc, nenc;
 259
 260   assert (out);
 261   assert (pke);
 262
 263   if (pke->version < 2 || pke->version > 3)
 264     return CDK_Inv_Packet;
 265   if (!KEY_CAN_ENCRYPT (pke->pubkey_algo))
 266     return CDK_Inv_Algo;
 267
 268   if (DEBUG_PKT)
 269     _gnutls_write_log ("write_pubkey_enc:\n");
 270
 271   nenc = cdk_pk_get_nenc (pke->pubkey_algo);
 272   size = 10 + calc_mpisize (pke->mpi, nenc);
 273   rc = pkt_write_head (out, old_ctb, size, CDK_PKT_PUBKEY_ENC);
 274   if (rc)
 275     return rc;
 276
 277   rc = stream_putc (out, pke->version);
 278   if (!rc)
 279     rc = write_32 (out, pke->keyid[0]);
 280   if (!rc)
 281     rc = write_32 (out, pke->keyid[1]);
 282   if (!rc)
 283     rc = stream_putc (out, _cdk_pub_algo_to_pgp (pke->pubkey_algo));
 284   if (!rc)
 285     rc = write_mpibuf (out, pke->mpi, nenc);
 286   return rc;
 287 }
 288
 289
 290 static cdk_error_t
 291 write_mdc (cdk_stream_t out, cdk_pkt_mdc_t mdc)
 292 {
 293   cdk_error_t rc;
 294
 295   assert (mdc);
 296   assert (out);
 297
 298   if (DEBUG_PKT)
 299     _gnutls_write_log ("write_mdc:\n");
 300
 301   /* This packet requires a fixed header encoding */
 302   rc = stream_putc (out, 0xD3); /* packet ID and 1 byte length */
 303   if (!rc)
 304     rc = stream_putc (out, 0x14);
 305   if (!rc)
 306     rc = stream_write (out, mdc->hash, DIM (mdc->hash));
 307   return rc;
 308 }
 309
 310
 311 static size_t
 312 calc_subpktsize (cdk_subpkt_t s)
 313 {
 314   size_t nbytes;
 315
 316   /* In the count mode, no buffer is returned. */
 317   _cdk_subpkt_get_array (s, 1, &nbytes);
 318   return nbytes;
 319 }
 320
 321
 322 static cdk_error_t
 323 write_v3_sig (cdk_stream_t out, cdk_pkt_signature_t sig, int nsig)
 324 {
 325   size_t size;
 326   cdk_error_t rc;
 327
 328   size = 19 + calc_mpisize (sig->mpi, nsig);
 329   if (is_RSA (sig->pubkey_algo))
 330     rc = pkt_write_head2 (out, size, CDK_PKT_SIGNATURE);
 331   else
 332     rc = pkt_write_head (out, 1, size, CDK_PKT_SIGNATURE);
 333   if (!rc)
 334     rc = stream_putc (out, sig->version);
 335   if (!rc)
 336     rc = stream_putc (out, 5);
 337   if (!rc)
 338     rc = stream_putc (out, sig->sig_class);
 339   if (!rc)
 340     rc = write_32 (out, sig->timestamp);
 341   if (!rc)
 342     rc = write_32 (out, sig->keyid[0]);
 343   if (!rc)
 344     rc = write_32 (out, sig->keyid[1]);
 345   if (!rc)
 346     rc = stream_putc (out, _cdk_pub_algo_to_pgp (sig->pubkey_algo));
 347   if (!rc)
 348     rc = stream_putc (out, _gnutls_hash_algo_to_pgp (sig->digest_algo));
 349   if (!rc)
 350     rc = stream_putc (out, sig->digest_start[0]);
 351   if (!rc)
 352     rc = stream_putc (out, sig->digest_start[1]);
 353   if (!rc)
 354     rc = write_mpibuf (out, sig->mpi, nsig);
 355   return rc;
 356 }
 357
 358
 359 static cdk_error_t
 360 write_signature (cdk_stream_t out, cdk_pkt_signature_t sig, int old_ctb)
 361 {
 362   byte *buf;
 363   size_t nbytes, size, nsig;
 364   cdk_error_t rc;
 365
 366   assert (out);
 367   assert (sig);
 368
 369   if (!KEY_CAN_SIGN (sig->pubkey_algo))
 370     return CDK_Inv_Algo;
 371   if (sig->version < 2 || sig->version > 4)
 372     return CDK_Inv_Packet;
 373
 374   if (DEBUG_PKT)
 375     _gnutls_write_log ("write_signature:\n");
 376
 377   nsig = cdk_pk_get_nsig (sig->pubkey_algo);
 378   if (!nsig)
 379     return CDK_Inv_Algo;
 380   if (sig->version < 4)
 381     return write_v3_sig (out, sig, nsig);
 382
 383   size = 10 + calc_subpktsize (sig->hashed)
 384     + calc_subpktsize (sig->unhashed) + calc_mpisize (sig->mpi, nsig);
 385   rc = pkt_write_head (out, 0, size, CDK_PKT_SIGNATURE);
 386   if (!rc)
 387     rc = stream_putc (out, 4);
 388   if (!rc)
 389     rc = stream_putc (out, sig->sig_class);
 390   if (!rc)
 391     rc = stream_putc (out, _cdk_pub_algo_to_pgp (sig->pubkey_algo));
 392   if (!rc)
 393     rc = stream_putc (out, _gnutls_hash_algo_to_pgp (sig->digest_algo));
 394   if (!rc)
 395     rc = write_16 (out, sig->hashed_size);
 396   if (!rc)
 397     {
 398       buf = _cdk_subpkt_get_array (sig->hashed, 0, &nbytes);
 399       if (!buf)
 400         return CDK_Out_Of_Core;
 401       rc = stream_write (out, buf, nbytes);
 402       cdk_free (buf);
 403     }
 404   if (!rc)
 405     rc = write_16 (out, sig->unhashed_size);
 406   if (!rc)
 407     {
 408       buf = _cdk_subpkt_get_array (sig->unhashed, 0, &nbytes);
 409       if (!buf)
 410         return CDK_Out_Of_Core;
 411       rc = stream_write (out, buf, nbytes);
 412       cdk_free (buf);
 413     }
 414   if (!rc)
 415     rc = stream_putc (out, sig->digest_start[0]);
 416   if (!rc)
 417     rc = stream_putc (out, sig->digest_start[1]);
 418   if (!rc)
 419     rc = write_mpibuf (out, sig->mpi, nsig);
 420   return rc;
 421 }
 422
 423
 424 static cdk_error_t
 425 write_public_key (cdk_stream_t out, cdk_pkt_pubkey_t pk,
 426                   int is_subkey, int old_ctb)
 427 {
 428   int pkttype, ndays = 0;
 429   size_t npkey = 0, size = 6;
 430   cdk_error_t rc;
 431
 432   assert (out);
 433   assert (pk);
 434
 435   if (pk->version < 2 || pk->version > 4)
 436     return CDK_Inv_Packet;
 437
 438   if (DEBUG_PKT)
 439     _gnutls_write_log ("write_public_key: subkey=%d\n", is_subkey);
 440
 441   pkttype = is_subkey ? CDK_PKT_PUBLIC_SUBKEY : CDK_PKT_PUBLIC_KEY;
 442   npkey = cdk_pk_get_npkey (pk->pubkey_algo);
 443   if (!npkey)
 444     return CDK_Inv_Algo;
 445   if (pk->version < 4)
 446     size += 2;                  /* expire date */
 447   if (is_subkey)
 448     old_ctb = 0;
 449   size += calc_mpisize (pk->mpi, npkey);
 450   if (old_ctb)
 451     rc = pkt_write_head2 (out, size, pkttype);
 452   else
 453     rc = pkt_write_head (out, old_ctb, size, pkttype);
 454   if (!rc)
 455     rc = stream_putc (out, pk->version);
 456   if (!rc)
 457     rc = write_32 (out, pk->timestamp);
 458   if (!rc && pk->version < 4)
 459     {
 460       if (pk->expiredate)
 461         ndays = (u16) ((pk->expiredate - pk->timestamp) / 86400L);
 462       rc = write_16 (out, ndays);
 463     }
 464   if (!rc)
 465     rc = stream_putc (out, _cdk_pub_algo_to_pgp (pk->pubkey_algo));
 466   if (!rc)
 467     rc = write_mpibuf (out, pk->mpi, npkey);
 468   return rc;
 469 }
 470
 471
 472 static int
 473 calc_s2ksize (cdk_pkt_seckey_t sk)
 474 {
 475   size_t nbytes = 0;
 476
 477   if (!sk->is_protected)
 478     return 0;
 479   switch (sk->protect.s2k->mode)
 480     {
 481     case CDK_S2K_SIMPLE:
 482       nbytes = 2;
 483       break;
 484     case CDK_S2K_SALTED:
 485       nbytes = 10;
 486       break;
 487     case CDK_S2K_ITERSALTED:
 488       nbytes = 11;
 489       break;
 490     case CDK_S2K_GNU_EXT:
 491        nbytes = 2;
 492        break;
 493     }
 494   nbytes += sk->protect.ivlen;
 495   nbytes++;                     /* single cipher byte */
 496   return nbytes;
 497 }
 498
 499
 500 static cdk_error_t
 501 write_secret_key (cdk_stream_t out, cdk_pkt_seckey_t sk,
 502                   int is_subkey, int old_ctb)
 503 {
 504   cdk_pkt_pubkey_t pk = NULL;
 505   size_t size = 6, npkey, nskey;
 506   int pkttype, s2k_mode;
 507   cdk_error_t rc;
 508
 509   assert (out);
 510   assert (sk);
 511
 512   if (!sk->pk)
 513     return CDK_Inv_Value;
 514   pk = sk->pk;
 515   if (pk->version < 2 || pk->version > 4)
 516     return CDK_Inv_Packet;
 517
 518   if (DEBUG_PKT)
 519     _gnutls_write_log ("write_secret_key:\n");
 520
 521   npkey = cdk_pk_get_npkey (pk->pubkey_algo);
 522   nskey = cdk_pk_get_nskey (pk->pubkey_algo);
 523   if (!npkey || !nskey)
 524     {
 525       gnutls_assert ();
 526       return CDK_Inv_Algo;
 527     }
 528   if (pk->version < 4)
 529     size += 2;
 530   /* If the key is unprotected, the 1 extra byte:
 531      1 octet  - cipher algorithm byte (0x00)
 532      the other bytes depend on the mode:
 533      a) simple checksum -  2 octets
 534      b) sha-1 checksum  - 20 octets */
 535   size = !sk->is_protected ? size + 1 : size + 1 + calc_s2ksize (sk);
 536   size += calc_mpisize (pk->mpi, npkey);
 537   if (sk->version == 3 || !sk->is_protected)
 538     {
 539       if (sk->version == 3)
 540         {
 541           size += 2;            /* force simple checksum */
 542           sk->protect.sha1chk = 0;
 543         }
 544       else
 545         size += sk->protect.sha1chk ? 20 : 2;
 546       size += calc_mpisize (sk->mpi, nskey);
 547     }
 548   else                          /* We do not know anything about the encrypted mpi's so we
 549                                    treat the data as uint8_t. */
 550     size += sk->enclen;
 551
 552   pkttype = is_subkey ? CDK_PKT_SECRET_SUBKEY : CDK_PKT_SECRET_KEY;
 553   rc = pkt_write_head (out, old_ctb, size, pkttype);
 554   if (!rc)
 555     rc = stream_putc (out, pk->version);
 556   if (!rc)
 557     rc = write_32 (out, pk->timestamp);
 558   if (!rc && pk->version < 4)
 559     {
 560       u16 ndays = 0;
 561       if (pk->expiredate)
 562         ndays = (u16) ((pk->expiredate - pk->timestamp) / 86400L);
 563       rc = write_16 (out, ndays);
 564     }
 565   if (!rc)
 566     rc = stream_putc (out, _cdk_pub_algo_to_pgp (pk->pubkey_algo));
 567
 568   if (!rc)
 569     rc = write_mpibuf (out, pk->mpi, npkey);
 570
 571   if (!rc)
 572     {
 573       if (sk->is_protected == 0)
 574         rc = stream_putc (out, 0x00);
 575       else
 576         {
 577           if (is_RSA (pk->pubkey_algo) && pk->version < 4)
 578             rc = stream_putc (out, _gnutls_cipher_to_pgp (sk->protect.algo));
 579           else if (sk->protect.s2k)
 580             {
 581               s2k_mode = sk->protect.s2k->mode;
 582               rc = stream_putc (out, sk->protect.sha1chk ? 0xFE : 0xFF);
 583               if (!rc)
 584                 rc =
 585                   stream_putc (out, _gnutls_cipher_to_pgp (sk->protect.algo));
 586               if (!rc)
 587                 rc = stream_putc (out, sk->protect.s2k->mode);
 588               if (!rc)
 589                 rc = stream_putc (out, sk->protect.s2k->hash_algo);
 590               if (!rc && (s2k_mode == 1 || s2k_mode == 3))
 591                 {
 592                   rc = stream_write (out, sk->protect.s2k->salt, 8);
 593                   if (!rc && s2k_mode == 3)
 594                     rc = stream_putc (out, sk->protect.s2k->count);
 595                 }
 596             }
 597           else
 598             return CDK_Inv_Value;
 599           if (!rc)
 600             rc = stream_write (out, sk->protect.iv, sk->protect.ivlen);
 601         }
 602     }
 603   if (!rc && sk->is_protected && pk->version == 4)
 604     {
 605       if (sk->encdata && sk->enclen)
 606         rc = stream_write (out, sk->encdata, sk->enclen);
 607     }
 608   else
 609     {
 610       if (!rc)
 611         rc = write_mpibuf (out, sk->mpi, nskey);
 612       if (!rc)
 613         {
 614           if (!sk->csum)
 615             sk->csum = _cdk_sk_get_csum (sk);
 616           rc = write_16 (out, sk->csum);
 617         }
 618     }
 619
 620   return rc;
 621 }
 622
 623
 624 static cdk_error_t
 625 write_compressed (cdk_stream_t out, cdk_pkt_compressed_t cd)
 626 {
 627   cdk_error_t rc;
 628
 629   assert (out);
 630   assert (cd);
 631
 632   if (DEBUG_PKT)
 633     _gnutls_write_log ("packet: write_compressed\n");
 634
 635   /* Use an old (RFC1991) header for this packet. */
 636   rc = pkt_write_head (out, 1, 0, CDK_PKT_COMPRESSED);
 637   if (!rc)
 638     rc = stream_putc (out, cd->algorithm);
 639   return rc;
 640 }
 641
 642
 643 static cdk_error_t
 644 write_literal (cdk_stream_t out, cdk_pkt_literal_t pt, int old_ctb)
 645 {
 646   byte buf[BUFSIZE];
 647   size_t size;
 648   cdk_error_t rc;
 649
 650   assert (out);
 651   assert (pt);
 652
 653   /* We consider a packet without a body as an invalid packet.
 654      At least one octet must be present. */
 655   if (!pt->len)
 656     return CDK_Inv_Packet;
 657
 658   if (DEBUG_PKT)
 659     _gnutls_write_log ("write_literal:\n");
 660
 661   size = 6 + pt->namelen + pt->len;
 662   rc = pkt_write_head (out, old_ctb, size, CDK_PKT_LITERAL);
 663   if (rc)
 664     return rc;
 665
 666   rc = stream_putc (out, pt->mode);
 667   if (rc)
 668     return rc;
 669   rc = stream_putc (out, pt->namelen);
 670   if (rc)
 671     return rc;
 672
 673   if (pt->namelen > 0)
 674     rc = stream_write (out, pt->name, pt->namelen);
 675   if (!rc)
 676     rc = write_32 (out, pt->timestamp);
 677   if (rc)
 678     return rc;
 679
 680   while (!cdk_stream_eof (pt->buf) && !rc)
 681     {
 682       rc = stream_read (pt->buf, buf, DIM (buf), &size);
 683       if (!rc)
 684         rc = stream_write (out, buf, size);
 685     }
 686
 687   memset (buf, 0, sizeof (buf));
 688   return rc;
 689 }
 690
 691
 692 static cdk_error_t
 693 write_onepass_sig (cdk_stream_t out, cdk_pkt_onepass_sig_t sig)
 694 {
 695   cdk_error_t rc;
 696
 697   assert (out);
 698   assert (sig);
 699
 700   if (sig->version != 3)
 701     return CDK_Inv_Packet;
 702
 703   if (DEBUG_PKT)
 704     _gnutls_write_log ("write_onepass_sig:\n");
 705
 706   rc = pkt_write_head (out, 0, 13, CDK_PKT_ONEPASS_SIG);
 707   if (!rc)
 708     rc = stream_putc (out, sig->version);
 709   if (!rc)
 710     rc = stream_putc (out, sig->sig_class);
 711   if (!rc)
 712     rc = stream_putc (out, _gnutls_hash_algo_to_pgp (sig->digest_algo));
 713   if (!rc)
 714     rc = stream_putc (out, _cdk_pub_algo_to_pgp (sig->pubkey_algo));
 715   if (!rc)
 716     rc = write_32 (out, sig->keyid[0]);
 717   if (!rc)
 718     rc = write_32 (out, sig->keyid[1]);
 719   if (!rc)
 720     rc = stream_putc (out, sig->last);
 721   return rc;
 722 }
 723
 724
 725 static cdk_error_t
 726 write_user_id (cdk_stream_t out, cdk_pkt_userid_t id, int old_ctb,
 727                int pkttype)
 728 {
 729   cdk_error_t rc;
 730
 731   if (!out || !id)
 732     return CDK_Inv_Value;
 733
 734   if (pkttype == CDK_PKT_ATTRIBUTE)
 735     {
 736       if (!id->attrib_img)
 737         return CDK_Inv_Value;
 738       rc =
 739         pkt_write_head (out, old_ctb, id->attrib_len + 6, CDK_PKT_ATTRIBUTE);
 740       if (rc)
 741         return rc;
 742       /* Write subpacket part. */
 743       stream_putc (out, 255);
 744       write_32 (out, id->attrib_len + 1);
 745       stream_putc (out, 1);
 746       rc = stream_write (out, id->attrib_img, id->attrib_len);
 747     }
 748   else
 749     {
 750       if (!id->name)
 751         return CDK_Inv_Value;
 752       rc = pkt_write_head (out, old_ctb, id->len, CDK_PKT_USER_ID);
 753       if (!rc)
 754         rc = stream_write (out, id->name, id->len);
 755     }
 756
 757   return rc;
 758 }
 759
 760
 761 /**
 762  * cdk_pkt_write:
 763  * @out: the output stream handle
 764  * @pkt: the packet itself
 765  *
 766  * Write the contents of @pkt into the @out stream.
 767  * Return 0 on success.
 768  **/
 769 cdk_error_t
 770 cdk_pkt_write (cdk_stream_t out, cdk_packet_t pkt)
 771 {
 772   cdk_error_t rc;
 773
 774   if (!out || !pkt)
 775     return CDK_Inv_Value;
 776
 777   _gnutls_write_log ("write packet pkttype=%d\n", pkt->pkttype);
 778   switch (pkt->pkttype)
 779     {
 780     case CDK_PKT_LITERAL:
 781       rc = write_literal (out, pkt->pkt.literal, pkt->old_ctb);
 782       break;
 783     case CDK_PKT_ONEPASS_SIG:
 784       rc = write_onepass_sig (out, pkt->pkt.onepass_sig);
 785       break;
 786     case CDK_PKT_MDC:
 787       rc = write_mdc (out, pkt->pkt.mdc);
 788       break;
 789     case CDK_PKT_PUBKEY_ENC:
 790       rc = write_pubkey_enc (out, pkt->pkt.pubkey_enc, pkt->old_ctb);
 791       break;
 792     case CDK_PKT_SIGNATURE:
 793       rc = write_signature (out, pkt->pkt.signature, pkt->old_ctb);
 794       break;
 795     case CDK_PKT_PUBLIC_KEY:
 796       rc = write_public_key (out, pkt->pkt.public_key, 0, pkt->old_ctb);
 797       break;
 798     case CDK_PKT_PUBLIC_SUBKEY:
 799       rc = write_public_key (out, pkt->pkt.public_key, 1, pkt->old_ctb);
 800       break;
 801     case CDK_PKT_COMPRESSED:
 802       rc = write_compressed (out, pkt->pkt.compressed);
 803       break;
 804     case CDK_PKT_SECRET_KEY:
 805       rc = write_secret_key (out, pkt->pkt.secret_key, 0, pkt->old_ctb);
 806       break;
 807     case CDK_PKT_SECRET_SUBKEY:
 808       rc = write_secret_key (out, pkt->pkt.secret_key, 1, pkt->old_ctb);
 809       break;
 810     case CDK_PKT_USER_ID:
 811     case CDK_PKT_ATTRIBUTE:
 812       rc = write_user_id (out, pkt->pkt.user_id, pkt->old_ctb, pkt->pkttype);
 813       break;
 814     default:
 815       rc = CDK_Inv_Packet;
 816       break;
 817     }
 818
 819   if (DEBUG_PKT)
 820     _gnutls_write_log ("write_packet rc=%d pkttype=%d\n", rc, pkt->pkttype);
 821   return rc;
 822 }
 823
 824
 825 cdk_error_t
 826 _cdk_pkt_write2 (cdk_stream_t out, int pkttype, void *pktctx)
 827 {
 828   cdk_packet_t pkt;
 829   cdk_error_t rc;
 830
 831   rc = cdk_pkt_new (&pkt);
 832   if (rc)
 833     return rc;
 834
 835   switch (pkttype)
 836     {
 837     case CDK_PKT_PUBLIC_KEY:
 838     case CDK_PKT_PUBLIC_SUBKEY:
 839       pkt->pkt.public_key = pktctx;
 840       break;
 841     case CDK_PKT_SIGNATURE:
 842       pkt->pkt.signature = pktctx;
 843       break;
 844     case CDK_PKT_SECRET_KEY:
 845     case CDK_PKT_SECRET_SUBKEY:
 846       pkt->pkt.secret_key = pktctx;
 847       break;
 848
 849     case CDK_PKT_USER_ID:
 850       pkt->pkt.user_id = pktctx;
 851       break;
 852     }
 853   pkt->pkttype = pkttype;
 854   rc = cdk_pkt_write (out, pkt);
 855   cdk_free (pkt);
 856   return rc;
 857 }
 858
 859
 860 cdk_error_t
 861 _cdk_pkt_write_fp (FILE * out, cdk_packet_t pkt)
 862 {
 863   cdk_stream_t so;
 864   cdk_error_t rc;
 865
 866   rc = _cdk_stream_fpopen (out, 1, &so);
 867   if (rc)
 868     return rc;
 869   rc = cdk_pkt_write (so, pkt);
 870   cdk_stream_close (so);
 871   return rc;
 872 }