perform cheap checks first
[tinc] / src / gcrypt / rsagen.c
1 /*
2     rsagen.c -- RSA key generation and export
3     Copyright (C) 2008-2012 Guus Sliepen <guus@tinc-vpn.org>
4
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14
15     You should have received a copy of the GNU General Public License along
16     with this program; if not, write to the Free Software Foundation, Inc.,
17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #include "system.h"
21
22 #include <gcrypt.h>
23
24 #include "rsagen.h"
25
26 #if 0
27 // Base64 encoding table
28
29 static const char b64e[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
30
31 // PEM encoding
32
33 static bool pem_encode(FILE *fp, const char *header, uint8_t *buf, size_t size) {
34         bool decode = false;
35         char line[1024];
36         uint32_t word = 0;
37         int shift = 0;
38         size_t i, j = 0;
39
40         fprintf(fp, "-----BEGIN %s-----\n", header);
41
42         for(i = 0; i < size; i += 3) {
43                 if(i <= size - 3) {
44                         word = buf[i] << 16 | buf[i + 1] << 8 | buf[i + 2];
45                 } else {
46                         word = buf[i] << 16;
47
48                         if(i == size - 2) {
49                                 word |= buf[i + 1] << 8;
50                         }
51                 }
52
53                 line[j++] = b64e[(word >> 18)       ];
54                 line[j++] = b64e[(word >> 12) & 0x3f];
55                 line[j++] = b64e[(word >>  6) & 0x3f];
56                 line[j++] = b64e[(word) & 0x3f];
57
58                 if(j >= 64) {
59                         line[j++] = '\n';
60                         line[j] = 0;
61                         fputs(line, fp);
62                         j = 0;
63                 }
64         }
65
66         if(size % 3 > 0) {
67                 if(size % 3 > 1) {
68                         line[j++] = '=';
69                 }
70
71                 line[j++] = '=';
72         }
73
74         if(j) {
75                 line[j++] = '\n';
76                 line[j] = 0;
77                 fputs(line, fp);
78         }
79
80         fprintf(fp, "-----END %s-----\n", header);
81
82         return true;
83 }
84
85
86 // BER encoding functions
87
88 static bool ber_write_id(uint8_t **p, size_t *buflen, int id) {
89         if(*buflen <= 0) {
90                 return false;
91         }
92
93         if(id >= 0x1f) {
94                 while(id) {
95                         if(*buflen <= 0) {
96                                 return false;
97                         }
98
99                         (*buflen)--;
100                         **p = id & 0x7f;
101                         id >>= 7;
102
103                         if(id) {
104                                 **p |= 0x80;
105                         }
106
107                         (*p)++;
108                 }
109         } else {
110                 (*buflen)--;
111                 *(*p)++ = id;
112         }
113
114         return true;
115 }
116
117 static bool ber_write_len(uint8_t **p, size_t *buflen, size_t len) {
118         do {
119                 if(*buflen <= 0) {
120                         return false;
121                 }
122
123                 (*buflen)--;
124                 **p = len & 0x7f;
125                 len >>= 7;
126
127                 if(len) {
128                         **p |= 0x80;
129                 }
130
131                 (*p)++;
132         } while(len);
133
134         return true;
135 }
136
137 static bool ber_write_sequence(uint8_t **p, size_t *buflen, uint8_t *seqbuf, size_t seqlen) {
138         if(!ber_write_id(p, buflen, 0x10) || !ber_write_len(p, buflen, seqlen) || *buflen < seqlen) {
139                 return false;
140         }
141
142         memcpy(*p, seqbuf, seqlen);
143         *p += seqlen;
144         *buflen -= seqlen;
145
146         return true;
147 }
148
149 static bool ber_write_mpi(uint8_t **p, size_t *buflen, gcry_mpi_t mpi) {
150         uint8_t tmpbuf[1024];
151         size_t tmplen = sizeof(tmpbuf);
152         gcry_error_t err;
153
154         err = gcry_mpi_aprint(GCRYMPI_FMT_USG, &tmpbuf, &tmplen, mpi);
155
156         if(err) {
157                 return false;
158         }
159
160         if(!ber_write_id(p, buflen, 0x02) || !ber_write_len(p, buflen, tmplen) || *buflen < tmplen) {
161                 return false;
162         }
163
164         memcpy(*p, tmpbuf, tmplen);
165         *p += tmplen;
166         *buflen -= tmplen;
167
168         return true;
169 }
170
171 // Write PEM RSA keys
172
173 bool rsa_write_pem_public_key(rsa_t *rsa, FILE *fp) {
174         uint8_t derbuf1[8096];
175         uint8_t derbuf2[8096];
176         uint8_t *derp1 = derbuf1;
177         uint8_t *derp2 = derbuf2;
178         size_t derlen1 = sizeof(derbuf1);
179         size_t derlen2 = sizeof(derbuf2);
180
181         if(!ber_write_mpi(&derp1, &derlen1, &rsa->n)
182                         || !ber_write_mpi(&derp1, &derlen1, &rsa->e)
183                         || !ber_write_sequence(&derp2, &derlen2, derbuf1, derlen1)) {
184                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while encoding RSA public key");
185                 return false;
186         }
187
188         if(!pem_encode(fp, "RSA PUBLIC KEY", derbuf2, derlen2)) {
189                 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to write RSA public key: %s", strerror(errno));
190                 return false;
191         }
192
193         return true;
194 }
195
196 bool rsa_write_pem_private_key(rsa_t *rsa, FILE *fp) {
197         uint8_t derbuf1[8096];
198         uint8_t derbuf2[8096];
199         uint8_t *derp1 = derbuf1;
200         uint8_t *derp2 = derbuf2;
201         size_t derlen1 = sizeof(derbuf1);
202         size_t derlen2 = sizeof(derbuf2);
203
204         if(!ber_write_mpi(&derp1, &derlen1, &bits)
205                         || ber_write_mpi(&derp1, &derlen1, &rsa->n) // modulus
206                         || ber_write_mpi(&derp1, &derlen1, &rsa->e) // public exponent
207                         || ber_write_mpi(&derp1, &derlen1, &rsa->d) // private exponent
208                         || ber_write_mpi(&derp1, &derlen1, &p)
209                         || ber_write_mpi(&derp1, &derlen1, &q)
210                         || ber_write_mpi(&derp1, &derlen1, &exp1)
211                         || ber_write_mpi(&derp1, &derlen1, &exp2)
212                         || ber_write_mpi(&derp1, &derlen1, &coeff)) {
213                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while encoding RSA private key");
214         }
215
216         return false;
217 }
218
219 if(!pem_encode(fp, "RSA PRIVATE KEY", derbuf2, derlen2)) {
220         logger(DEBUG_ALWAYS, LOG_ERR, "Unable to write RSA private key: %s", strerror(errno));
221         return false;
222 }
223
224 return true;
225 }
226 #endif
227
228 bool rsa_write_pem_public_key(rsa_t *rsa, FILE *fp) {
229         return false;
230 }
231
232 bool rsa_write_pem_private_key(rsa_t *rsa, FILE *fp) {
233         return false;
234 }
235
236 bool rsa_generate(rsa_t *rsa, size_t bits, unsigned long exponent) {
237         fprintf(stderr, "Generating RSA keys with libgcrypt not implemented yet\n");
238         return false;
239 }