gen_pkcs3: Terminate string before calling BH_hex2bn()
[exim.git] / src / util / gen_pkcs3.c
1 /* Copyright (C) 2012,2016 Phil Pennock.
2  * This is distributed as part of Exim and licensed under the GPL.
3  * See the file "NOTICE" for more details.
4  */
5
6 /* Build with:
7  * c99 $(pkg-config --cflags openssl) gen_pkcs3.c $(pkg-config --libs openssl)
8  */
9
10 /*
11  * Rationale:
12  * The Diffie-Hellman primes which are embedded into Exim as named primes for
13  * the tls_dhparam option are in the std-crypto.c file.  The source for those
14  * comes from various RFCs, where they are given in hexadecimal form.
15  *
16  * This tool provides convenient conversion, to reduce the risk of human
17  * error in transcription.
18  */
19
20 #include <ctype.h>
21 #include <errno.h>
22 #include <stdbool.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27
28 #include <openssl/bio.h>
29 #include <openssl/bn.h>
30 #include <openssl/dh.h>
31 #include <openssl/err.h>
32 #include <openssl/pem.h>
33
34 extern const char *__progname;
35
36
37 void __attribute__((__noreturn__)) __attribute__((__format__(printf, 1, 2)))
38 die(const char *fmt, ...)
39 {
40   va_list ap;
41
42   fflush(NULL);
43   fprintf(stderr, "%s: ", __progname);
44   va_start(ap, fmt);
45   vfprintf(stderr, fmt, ap);
46   va_end(ap);
47   fprintf(stderr, "\n");
48   fflush(stderr);
49   exit(1);
50 }
51
52
53 void __attribute__((__noreturn__))
54 die_openssl_err(const char *msg)
55 {
56   char err_string[250];
57
58   ERR_error_string_n(ERR_get_error(), err_string, sizeof(err_string));
59   die("%s: %s", msg, err_string);
60 }
61
62
63 static BIGNUM *
64 bn_from_text(const char *text)
65 {
66   BIGNUM *b;
67   char *p, *spaceless;
68   const char *q, *end;
69   size_t len;
70   int rc;
71
72   len = strlen(text);
73   spaceless = malloc(len + 1);
74   if (!spaceless)
75     die("malloc(%zu) failed: %s", len + 1, strerror(errno));
76
77   for (p = spaceless, q = text, end = text + len;
78        q < end;
79        ++q) {
80     if (!isspace(*q))
81       *p++ = *q;
82   }
83   len = p - spaceless;
84   *p++ = '\0';
85
86   b = NULL;
87   rc = BN_hex2bn(&b, spaceless);
88
89   if (rc != (int)len)
90     die("BN_hex2bn did not convert entire input; took %d of %zu bytes",
91         rc, len);
92
93   return b;
94 }
95
96
97 static void
98 our_dh_check(DH *dh)
99 {
100   int rc, errflags = 0;
101
102   rc = DH_check(dh, &errflags);
103   if (!rc) die_openssl_err("DH_check() could not be performed");;
104
105   /* We ignore DH_UNABLE_TO_CHECK_GENERATOR because some of the invocations
106    * deliberately provide generators other than 2 or 5. */
107
108   if (errflags & DH_CHECK_P_NOT_SAFE_PRIME)
109     die("DH_check(): p not a safe prime");
110   if (errflags & DH_NOT_SUITABLE_GENERATOR)
111     die("DH_check(): g not suitable as generator");
112 }
113
114
115 static void
116 emit_c_format_dh(FILE *stream, DH *dh)
117 {
118   BIO *bio;
119   long length;
120   char *data, *end, *p, *nl;
121
122   bio = BIO_new(BIO_s_mem());
123   PEM_write_bio_DHparams(bio, dh);
124   length = BIO_get_mem_data(bio, &data);
125   if (!length)
126     die("no data in memory BIO to format for printing");
127   if (length < 0)
128     die("grr, negative length memory not supported");
129   end = data + length;
130
131   for (p = data; p < end; /**/) {
132     nl = strchr(p, '\n');
133     if (!nl) {
134       fprintf(stream, "\"%s\\n\"\n/* missing final newline */\n", p);
135       break;
136     }
137     *nl = '\0';
138     fprintf(stream, "\"%s\\n\"%s\n", p, (nl == end - 1 ? ";" : ""));
139     p = nl + 1;
140   }
141 }
142
143
144 void __attribute__((__noreturn__))
145 usage(FILE *stream, int exitcode)
146 {
147   fprintf(stream, "Usage: %s [-CPcst] <dh_p> <dh_g> [<dh_q>]\n"
148 "Both dh_p and dh_g should be hex strings representing the numbers\n"
149 "The same applies to the optional dh_q (prime-order subgroup).\n"
150 "They may contain whitespace.\n"
151 "Older values, dh_g is often just '2', not a long string.\n"
152 "\n"
153 " -C      show C string form of PEM result\n"
154 " -P      do not show PEM\n"
155 " -c      run OpenSSL DH_check() on the DH object\n"
156 " -s      show the parsed p and g\n"
157 " -t      show text form of certificate\n"
158
159       , __progname);
160   exit(exitcode);
161 }
162
163
164 int
165 main(int argc, char *argv[])
166 {
167   BIGNUM *p, *g, *q;
168   DH *dh;
169   int ch;
170   bool perform_dh_check = false;
171   bool show_c_form = false;
172   bool show_numbers = false;
173   bool show_pem = true;
174   bool show_text = false;
175   bool given_q = false;
176
177   while ((ch = getopt(argc, argv, "CPcsth")) != -1) {
178     switch (ch) {
179       case 'C':
180         show_c_form = true;
181         break;
182       case 'P':
183         show_pem = false;
184         break;
185       case 'c':
186         perform_dh_check = true;
187         break;
188       case 's':
189         show_numbers = true;
190         break;
191       case 't':
192         show_text = true;
193         break;
194
195       case 'h':
196         usage(stdout, 0);
197       case '?':
198         die("Unknown option or missing argument -%c", optopt);
199       default:
200         die("Unhandled option -%c", ch);
201     }
202   }
203
204   optind -= 1;
205   argc -= optind;
206   argv += optind;
207
208   if ((argc < 3) || (argc > 4)) {
209     fprintf(stderr, "argc: %d\n", argc);
210     usage(stderr, 1);
211   }
212
213   // If we use DH_set0_pqg instead of setting dh fields directly; the q value
214   // is optional and may be NULL.
215   // Just blank them all.
216   p = g = q = NULL;
217
218   p = bn_from_text(argv[1]);
219   g = bn_from_text(argv[2]);
220   if (argc >= 4) {
221     q = bn_from_text(argv[3]);
222     given_q = true;
223   }
224
225   if (show_numbers) {
226     printf("p = ");
227     BN_print_fp(stdout, p);
228     printf("\ng = ");
229     BN_print_fp(stdout, g);
230     if (given_q) {
231       printf("\nq = ");
232       BN_print_fp(stdout, q);
233     }
234     printf("\n");
235   }
236
237   dh = DH_new();
238   // The documented method for setting q appeared in OpenSSL 1.1.0.
239 #if OPENSSL_VERSION_NUMBER >= 0x1010000f
240   // NULL okay for q; yes, the optional value is in the middle.
241   if (DH_set0_pqg(dh, p, q, g) != 1) {
242     die_openssl_err("initialising DH pqg values failed");
243   }
244 #else
245   dh->p = p;
246   dh->g = g;
247   if (given_q) {
248     dh->q = q;
249   }
250 #endif
251
252   if (perform_dh_check)
253     our_dh_check(dh);
254
255   if (show_text)
256     DHparams_print_fp(stdout, dh);
257
258   if (show_pem) {
259     if (show_c_form)
260       emit_c_format_dh(stdout, dh);
261     else
262       PEM_write_DHparams(stdout, dh);
263   }
264
265   DH_free(dh); /* should free p,g (& q if non-NULL) too */
266   return 0;
267 }