[Title] Extract nettle-2.1.tar.gz from Nettle's official repository.
[external/nettle.git] / pgp-encode.c
1 /* pgp.c
2  *
3  * PGP related functions.
4  */
5
6 /* nettle, low-level cryptographics library
7  *
8  * Copyright (C) 2001, 2002 Niels Möller
9  *  
10  * The nettle library is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation; either version 2.1 of the License, or (at your
13  * option) any later version.
14  * 
15  * The nettle library is distributed in the hope that it will be useful, but
16  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
18  * License for more details.
19  * 
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with the nettle library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
23  * MA 02111-1307, USA.
24  */
25
26 #if HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #include <assert.h>
31 #include <stdlib.h>
32 #include <string.h>
33
34 #include "pgp.h"
35
36 #include "base64.h"
37 #include "buffer.h"
38 #include "macros.h"
39 #include "rsa.h"
40
41 int
42 pgp_put_uint32(struct nettle_buffer *buffer, uint32_t i)
43 {
44   uint8_t *p = nettle_buffer_space(buffer, 4);
45   if (!p)
46     return 0;
47   
48   WRITE_UINT32(p, i);
49   return 1;
50 }
51
52 int
53 pgp_put_uint16(struct nettle_buffer *buffer, unsigned i)
54 {
55   uint8_t *p = nettle_buffer_space(buffer, 2);
56   if (!p)
57     return 0;
58   
59   WRITE_UINT16(p, i);
60   return 1;
61 }
62
63 int
64 pgp_put_mpi(struct nettle_buffer *buffer, const mpz_t x)
65 {
66   unsigned bits = mpz_sizeinbase(x, 2);
67   unsigned octets = (bits + 7) / 8;
68
69   uint8_t *p;
70
71   /* FIXME: What's the correct representation of zero? */
72   if (!pgp_put_uint16(buffer, bits))
73     return 0;
74   
75   p = nettle_buffer_space(buffer, octets);
76
77   if (!p)
78     return 0;
79   
80   nettle_mpz_get_str_256(octets, p, x);
81
82   return 1;
83 }
84
85 int
86 pgp_put_string(struct nettle_buffer *buffer,
87                unsigned length,
88                const uint8_t *s)
89 {
90   return nettle_buffer_write(buffer, length, s);
91 }
92
93 #if 0
94 static unsigned
95 length_field(unsigned length)
96 {
97   if (length < PGP_LENGTH_TWO_OCTET)
98     return 1;
99   else if (length < PGP_LENGTH_FOUR_OCTETS)
100     return 2;
101   else return 4;
102 }
103 #endif
104
105 /*   bodyLen = ((1st_octet - 192) << 8) + (2nd_octet) + 192
106  *   ==> bodyLen - 192 + 192 << 8 = (1st_octet << 8) + (2nd_octet) 
107  */
108
109 #define LENGTH_TWO_OFFSET (192 * 255)
110
111 int
112 pgp_put_length(struct nettle_buffer *buffer,
113                unsigned length)
114 {
115   if (length < PGP_LENGTH_TWO_OCTETS)
116     return NETTLE_BUFFER_PUTC(buffer, length);
117
118   else if (length < PGP_LENGTH_FOUR_OCTETS)
119     return pgp_put_uint16(buffer, length + LENGTH_TWO_OFFSET);
120   else
121     return NETTLE_BUFFER_PUTC(buffer, 0xff) && pgp_put_uint32(buffer, length);
122 }
123
124 /* Uses the "new" packet format */
125 int
126 pgp_put_header(struct nettle_buffer *buffer,
127                unsigned tag, unsigned length)
128 {
129   assert(tag < 0x40);
130
131   return (NETTLE_BUFFER_PUTC(buffer, 0xC0 | tag)
132           && pgp_put_length(buffer, length));  
133 }
134
135 /* FIXME: Should we abort or return error if the length and the field
136  * size don't match? */
137 void
138 pgp_put_header_length(struct nettle_buffer *buffer,
139                       /* start of the header */
140                       unsigned start,
141                       unsigned field_size)
142 {
143   unsigned length;
144   switch (field_size)
145     {
146     case 1:
147       length = buffer->size - (start + 2);
148       assert(length < PGP_LENGTH_TWO_OCTETS);
149       buffer->contents[start + 1] = length;
150       break;
151     case 2:
152       length = buffer->size - (start + 3);
153       assert(length < PGP_LENGTH_FOUR_OCTETS
154              && length >= PGP_LENGTH_TWO_OCTETS);
155       WRITE_UINT16(buffer->contents + start + 1, length + LENGTH_TWO_OFFSET);
156       break;
157     case 4:
158       length = buffer->size - (start + 5);
159       WRITE_UINT32(buffer->contents + start + 2, length);
160       break;
161     default:
162       abort();
163     }
164 }
165
166 int
167 pgp_put_userid(struct nettle_buffer *buffer,
168                unsigned length,
169                const uint8_t *name)
170 {
171   return (pgp_put_header(buffer, PGP_TAG_USERID, length)
172           && pgp_put_string(buffer, length, name));
173 }
174
175 unsigned
176 pgp_sub_packet_start(struct nettle_buffer *buffer)
177 {
178   return nettle_buffer_space(buffer, 2) ? buffer->size : 0;
179 }
180
181 int
182 pgp_put_sub_packet(struct nettle_buffer *buffer,
183                    unsigned type,
184                    unsigned length,
185                    const uint8_t *data)
186 {
187   return (pgp_put_length(buffer, length + 1)
188           && NETTLE_BUFFER_PUTC(buffer, type)
189           && pgp_put_string(buffer, length, data));
190 }
191
192 void
193 pgp_sub_packet_end(struct nettle_buffer *buffer, unsigned start)
194 {
195   unsigned length;
196   
197   assert(start >= 2);
198   assert(start <= buffer->size);
199
200   length = buffer->size - start;
201   WRITE_UINT32(buffer->contents + start - 2, length);
202 }
203
204 int
205 pgp_put_public_rsa_key(struct nettle_buffer *buffer,
206                        const struct rsa_public_key *pub,
207                        time_t timestamp)
208 {
209   /* Public key packet, version 4 */
210   unsigned start;
211   unsigned length;
212
213   /* Size of packet is 16 + the size of e and n */
214   length = (4 * 4
215           + nettle_mpz_sizeinbase_256_u(pub->n)
216           + nettle_mpz_sizeinbase_256_u(pub->e));
217
218   if (!pgp_put_header(buffer, PGP_TAG_PUBLIC_KEY, length))
219     return 0;
220
221   start = buffer->size;
222   
223   if (! (pgp_put_header(buffer, PGP_TAG_PUBLIC_KEY,
224                         /* Assume that we need two octets */
225                         PGP_LENGTH_TWO_OCTETS)
226          && pgp_put_uint32(buffer, 4)        /* Version */  
227          && pgp_put_uint32(buffer, timestamp)/* Time stamp */
228          && pgp_put_uint32(buffer, PGP_RSA)  /* Algorithm */
229          && pgp_put_mpi(buffer, pub->n)
230          && pgp_put_mpi(buffer, pub->e)) )
231     return 0;
232
233   assert(buffer->size == start + length);
234
235   return 1;
236 }
237
238 int
239 pgp_put_rsa_sha1_signature(struct nettle_buffer *buffer,
240                            const struct rsa_private_key *key,
241                            const uint8_t *keyid,
242                            unsigned type,
243                            struct sha1_ctx *hash)
244 {
245   unsigned signature_start = buffer->size;
246   unsigned hash_end;
247   unsigned sub_packet_start;
248   uint8_t trailer[6];
249   uint8_t digest16[2];
250   mpz_t s;
251   
252   /* Signature packet. The packet could reasonably be both smaller and
253    * larger than 192, so for simplicity we use the 4 octet header
254    * form. */
255
256   if (! (pgp_put_header(buffer, PGP_TAG_SIGNATURE, PGP_LENGTH_FOUR_OCTETS)
257          && NETTLE_BUFFER_PUTC(buffer, 4)  /* Version */
258          && NETTLE_BUFFER_PUTC(buffer, type)
259          /* Could also be PGP_RSA_SIGN */
260          && NETTLE_BUFFER_PUTC(buffer, PGP_RSA)
261          && NETTLE_BUFFER_PUTC(buffer, PGP_SHA1)
262          && pgp_put_uint16(buffer, 0)))  /* Hashed subpacket length */
263     return 0;
264
265   hash_end = buffer->size;
266
267   sha1_update(hash,
268               hash_end - signature_start,
269               buffer->contents + signature_start);
270
271   trailer[0] = 4; trailer[1] = 0xff;
272   WRITE_UINT32(trailer + 2, buffer->size - signature_start);
273
274   sha1_update(hash, sizeof(trailer), trailer);
275
276   {
277     struct sha1_ctx hcopy = *hash;
278     uint8_t *p = nettle_buffer_space(buffer, 2);
279     if (!p)
280       return 0;
281     
282     sha1_digest(&hcopy, 2, p);
283   }
284
285   /* One "sub-packet" field with the issuer keyid */
286   sub_packet_start = pgp_sub_packet_start(buffer);
287   if (!sub_packet_start)
288     return 0;
289
290   if (pgp_put_sub_packet(buffer, PGP_SUBPACKET_ISSUER_KEY_ID, 8, keyid))
291     {
292       pgp_sub_packet_end(buffer, sub_packet_start);
293       return 0;
294     }
295     
296   mpz_init(s);
297   if (!(rsa_sha1_sign(key, hash, s)
298         && pgp_put_mpi(buffer, s)))
299     {
300       mpz_clear(s);
301       return 0;
302     }
303
304   mpz_clear(s);
305   pgp_put_header_length(buffer, signature_start, 4);
306
307   return 1;
308 }
309
310 #define CRC24_INIT 0x0b704ceL
311 #define CRC24_POLY 0x1864cfbL
312
313 uint32_t
314 pgp_crc24(unsigned length, const uint8_t *data)
315 {
316   uint32_t crc = CRC24_INIT;
317
318   unsigned i;
319   for (i = 0; i<length; i++)
320     {
321       unsigned j;
322       crc ^= ((unsigned) (data[i]) << 16);
323       for (j = 0; j<8; j++)
324         {
325           crc <<= 1;
326           if (crc & 0x1000000)
327             crc ^= CRC24_POLY;
328         }
329     }
330   assert(crc < 0x1000000);
331   return crc;
332 }
333
334
335 #define WRITE(buffer, s) (nettle_buffer_write(buffer, strlen((s)), (s)))
336
337 /* 15 base 64 groups data per line */
338 #define BINARY_PER_LINE 45
339 #define TEXT_PER_LINE BASE64_ENCODE_LENGTH(BINARY_PER_LINE)
340
341 int
342 pgp_armor(struct nettle_buffer *buffer,
343           const char *tag,
344           unsigned length,
345           const uint8_t *data)
346 {
347   struct base64_encode_ctx ctx;
348   
349   unsigned crc = pgp_crc24(length, data);
350
351   base64_encode_init(&ctx);
352   
353   if (! (WRITE(buffer, "BEGIN PGP ")
354          && WRITE(buffer, tag)
355          && WRITE(buffer, "\nComment: Nettle\n\n")))
356     return 0;
357
358   for (;
359        length >= BINARY_PER_LINE;
360        length -= BINARY_PER_LINE, data += BINARY_PER_LINE)
361     {
362       unsigned done;
363       uint8_t *p
364         = nettle_buffer_space(buffer, TEXT_PER_LINE);
365       
366       if (!p)
367         return 0;
368
369       done = base64_encode_update(&ctx, p, BINARY_PER_LINE, data);
370       assert(done <= TEXT_PER_LINE);
371
372       /* FIXME: Create some official way to do this */
373       buffer->size -= (TEXT_PER_LINE - done);
374       
375       if (!NETTLE_BUFFER_PUTC(buffer, '\n'))
376         return 0;
377     }
378
379   if (length)
380     {
381       unsigned text_size = BASE64_ENCODE_LENGTH(length)
382         + BASE64_ENCODE_FINAL_LENGTH;
383       unsigned done;
384       
385       uint8_t *p
386         = nettle_buffer_space(buffer, text_size);
387       if (!p)
388         return 0;
389
390       done = base64_encode_update(&ctx, p, length, data);
391       done += base64_encode_final(&ctx, p + done);
392
393       /* FIXME: Create some official way to do this */
394       buffer->size -= (text_size - done);
395       
396       if (!NETTLE_BUFFER_PUTC(buffer, '\n'))
397         return 0;
398     }
399   /* Checksum */
400   if (!NETTLE_BUFFER_PUTC(buffer, '='))
401     return 0;
402
403   {
404     uint8_t *p = nettle_buffer_space(buffer, 4);
405     if (!p)
406       return 0;
407     base64_encode_group(p, crc);
408   }
409   
410   return (WRITE(buffer, "\nBEGIN PGP ")
411           && WRITE(buffer, tag)
412           && NETTLE_BUFFER_PUTC(buffer, '\n'));
413 }