SPDX: Mass-update to GPL-2.0-or-later
[exim.git] / src / src / dkim_transport.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
9
10 /* Transport shim for dkim signing */
11
12
13 #include "exim.h"
14
15 #ifndef DISABLE_DKIM    /* rest of file */
16
17
18 static BOOL
19 dkt_sign_fail(struct ob_dkim * dkim, int * errp)
20 {
21 if (dkim->dkim_strict)
22   {
23   uschar * dkim_strict_result = expand_string(dkim->dkim_strict);
24
25   if (dkim_strict_result)
26     if (  strcmpic(dkim_strict_result, US"1") == 0
27        || strcmpic(dkim_strict_result, US"true") == 0)
28       {
29       /* Set errno to something halfway meaningful */
30       *errp = EACCES;
31       log_write(0, LOG_MAIN, "DKIM: message could not be signed,"
32         " and dkim_strict is set. Deferring message delivery.");
33       return FALSE;
34       }
35   }
36 return TRUE;
37 }
38
39 /* Send the file at in_fd down the output fd */
40
41 static BOOL
42 dkt_send_file(int out_fd, int in_fd, off_t off
43 #ifdef OS_SENDFILE
44   , size_t size
45 #endif
46   )
47 {
48 #ifdef OS_SENDFILE
49 DEBUG(D_transport) debug_printf("send file fd=%d size=%u\n", out_fd, (unsigned)(size - off));
50 #else
51 DEBUG(D_transport) debug_printf("send file fd=%d\n", out_fd);
52 #endif
53
54 /*XXX should implement timeout, like transport_write_block_fd() ? */
55
56 #ifdef OS_SENDFILE
57 /* We can use sendfile() to shove the file contents
58    to the socket. However only if we don't use TLS,
59    as then there's another layer of indirection
60    before the data finally hits the socket. */
61 if (tls_out.active.sock != out_fd)
62   {
63   ssize_t copied = 0;
64
65   while(copied >= 0 && off < size)
66     copied = os_sendfile(out_fd, in_fd, &off, size - off);
67   if (copied < 0)
68     return FALSE;
69   }
70 else
71
72 #endif
73
74   {
75   int sread, wwritten;
76
77   /* Rewind file */
78   if (lseek(in_fd, off, SEEK_SET) < 0) return FALSE;
79
80   /* Send file down the original fd */
81   while((sread = read(in_fd, deliver_out_buffer, DELIVER_OUT_BUFFER_SIZE)) > 0)
82     {
83     uschar * p = deliver_out_buffer;
84     /* write the chunk */
85
86     while (sread)
87       {
88 #ifndef DISABLE_TLS
89       wwritten = tls_out.active.sock == out_fd
90         ? tls_write(tls_out.active.tls_ctx, p, sread, FALSE)
91         : write(out_fd, CS p, sread);
92 #else
93       wwritten = write(out_fd, CS p, sread);
94 #endif
95       if (wwritten == -1)
96         return FALSE;
97       p += wwritten;
98       sread -= wwritten;
99       }
100     }
101
102   if (sread == -1)
103     return FALSE;
104   }
105
106 return TRUE;
107 }
108
109
110
111
112 /* This function is a wrapper around transport_write_message().
113    It is only called from the smtp transport if DKIM or Domainkeys support
114    is active and no transport filter is to be used.
115
116 Arguments:
117   As for transport_write_message() in transort.c, with additional arguments
118   for DKIM.
119
120 Returns:       TRUE on success; FALSE (with errno) for any failure
121 */
122
123 static BOOL
124 dkt_direct(transport_ctx * tctx, struct ob_dkim * dkim,
125   const uschar ** err)
126 {
127 int save_fd = tctx->u.fd;
128 int save_options = tctx->options;
129 BOOL save_wireformat = f.spool_file_wireformat;
130 uschar * hdrs;
131 gstring * dkim_signature;
132 int hsize;
133 const uschar * errstr;
134 BOOL rc;
135
136 DEBUG(D_transport) debug_printf("dkim signing direct-mode\n");
137
138 /* Get headers in string for signing and transmission.  Do CRLF
139 and dotstuffing (but no body nor dot-termination) */
140
141 tctx->u.msg = NULL;
142 tctx->options = tctx->options & ~(topt_end_dot | topt_use_bdat)
143   | topt_output_string | topt_no_body;
144
145 rc = transport_write_message(tctx, 0);
146 hdrs = string_from_gstring(tctx->u.msg);
147 hsize = tctx->u.msg->ptr;
148
149 tctx->u.fd = save_fd;
150 tctx->options = save_options;
151 if (!rc) return FALSE;
152
153 /* Get signatures for headers plus spool data file */
154
155 #ifdef EXPERIMENTAL_ARC
156 arc_sign_init();
157 #endif
158
159 /* The dotstuffed status of the datafile depends on whether it was stored
160 in wireformat. */
161
162 dkim->dot_stuffed = f.spool_file_wireformat;
163 if (!(dkim_signature = dkim_exim_sign(deliver_datafile, SPOOL_DATA_START_OFFSET,
164                                     hdrs, dkim, &errstr)))
165   if (!(rc = dkt_sign_fail(dkim, &errno)))
166     {
167     *err = errstr;
168     return FALSE;
169     }
170
171 #ifdef EXPERIMENTAL_ARC
172 if (dkim->arc_signspec)                 /* Prepend ARC headers */
173   {
174   uschar * e = NULL;
175   if (!(dkim_signature = arc_sign(dkim->arc_signspec, dkim_signature, &e)))
176     {
177     *err = e;
178     return FALSE;
179     }
180   }
181 #endif
182
183 /* Write the signature and headers into the deliver-out-buffer.  This should
184 mean they go out in the same packet as the MAIL, RCPT and (first) BDAT commands
185 (transport_write_message() sizes the BDAT for the buffered amount) - for short
186 messages, the BDAT LAST command.  We want no dotstuffing expansion here, it
187 having already been done - but we have to say we want CRLF output format, and
188 temporarily set the marker for possible already-CRLF input. */
189
190 tctx->options &= ~topt_escape_headers;
191 f.spool_file_wireformat = TRUE;
192 transport_write_reset(0);
193 if (  (  dkim_signature
194       && dkim_signature->ptr > 0
195       && !write_chunk(tctx, dkim_signature->s, dkim_signature->ptr)
196       )
197    || !write_chunk(tctx, hdrs, hsize)
198    )
199   return FALSE;
200
201 f.spool_file_wireformat = save_wireformat;
202 tctx->options = save_options | topt_no_headers | topt_continuation;
203
204 if (!(transport_write_message(tctx, 0)))
205   return FALSE;
206
207 tctx->options = save_options;
208 return TRUE;
209 }
210
211
212 /* This function is a wrapper around transport_write_message().
213    It is only called from the smtp transport if DKIM or Domainkeys support
214    is active and a transport filter is to be used.  The function sets up a
215    replacement fd into a -K file, then calls the normal function. This way, the
216    exact bits that exim would have put "on the wire" will end up in the file
217    (except for TLS encapsulation, which is the very very last thing). When we
218    are done signing the file, send the signed message down the original fd (or
219    TLS fd).
220
221 Arguments:
222   As for transport_write_message() in transort.c, with additional arguments
223   for DKIM.
224
225 Returns:       TRUE on success; FALSE (with errno) for any failure
226 */
227
228 static BOOL
229 dkt_via_kfile(transport_ctx * tctx, struct ob_dkim * dkim, const uschar ** err)
230 {
231 int dkim_fd;
232 int save_errno = 0;
233 BOOL rc;
234 uschar * dkim_spool_name;
235 gstring * dkim_signature;
236 int options, dlen;
237 off_t k_file_size;
238 const uschar * errstr;
239
240 dkim_spool_name = spool_fname(US"input", message_subdir, message_id,
241                     string_sprintf("-%d-K", (int)getpid()));
242
243 DEBUG(D_transport) debug_printf("dkim signing via file %s\n", dkim_spool_name);
244
245 if ((dkim_fd = Uopen(dkim_spool_name, O_RDWR|O_CREAT|O_TRUNC, SPOOL_MODE)) < 0)
246   {
247   /* Can't create spool file. Ugh. */
248   rc = FALSE;
249   save_errno = errno;
250   *err = string_sprintf("dkim spoolfile create: %s", strerror(errno));
251   goto CLEANUP;
252   }
253
254 /* Call transport utility function to write the -K file; does the CRLF expansion
255 (but, in the CHUNKING case, neither dot-stuffing nor dot-termination). */
256
257   {
258   int save_fd = tctx->u.fd;
259   tctx->u.fd = dkim_fd;
260   options = tctx->options;
261   tctx->options &= ~topt_use_bdat;
262
263   rc = transport_write_message(tctx, 0);
264
265   tctx->u.fd = save_fd;
266   tctx->options = options;
267   }
268
269 /* Save error state. We must clean up before returning. */
270 if (!rc)
271   {
272   save_errno = errno;
273   goto CLEANUP;
274   }
275
276 #ifdef EXPERIMENTAL_ARC
277 arc_sign_init();
278 #endif
279
280 /* Feed the file to the goats^W DKIM lib.  At this point the dotstuffed
281 status of the file depends on the output of transport_write_message() just
282 above, which should be the result of the end_dot flag in tctx->options. */
283
284 dkim->dot_stuffed = !!(options & topt_end_dot);
285 if (!(dkim_signature = dkim_exim_sign(dkim_fd, 0, NULL, dkim, &errstr)))
286   {
287   dlen = 0;
288   if (!(rc = dkt_sign_fail(dkim, &save_errno)))
289     {
290     *err = errstr;
291     goto CLEANUP;
292     }
293   }
294 else
295   dlen = dkim_signature->ptr;
296
297 #ifdef EXPERIMENTAL_ARC
298 if (dkim->arc_signspec)                         /* Prepend ARC headers */
299   {
300   if (!(dkim_signature = arc_sign(dkim->arc_signspec, dkim_signature, USS err)))
301     goto CLEANUP;
302   dlen = dkim_signature->ptr;
303   }
304 #endif
305
306 #ifndef OS_SENDFILE
307 if (options & topt_use_bdat)
308 #endif
309   if ((k_file_size = lseek(dkim_fd, 0, SEEK_END)) < 0)
310     {
311     *err = string_sprintf("dkim spoolfile seek: %s", strerror(errno));
312     goto CLEANUP;
313     }
314
315 if (options & topt_use_bdat)
316   {
317   /* On big messages output a precursor chunk to get any pipelined
318   MAIL & RCPT commands flushed, then reap the responses so we can
319   error out on RCPT rejects before sending megabytes. */
320
321   if (  dlen + k_file_size > DELIVER_OUT_BUFFER_SIZE
322      && dlen > 0)
323     {
324     if (  tctx->chunk_cb(tctx, dlen, 0) != OK
325        || !transport_write_block(tctx,
326                     dkim_signature->s, dlen, FALSE)
327        || tctx->chunk_cb(tctx, 0, tc_reap_prev) != OK
328        )
329       goto err;
330     dlen = 0;
331     }
332
333   /* Send the BDAT command for the entire message, as a single LAST-marked
334   chunk. */
335
336   if (tctx->chunk_cb(tctx, dlen + k_file_size, tc_chunk_last) != OK)
337     goto err;
338   }
339
340 if(dlen > 0 && !transport_write_block(tctx, dkim_signature->s, dlen, TRUE))
341   goto err;
342
343 if (!dkt_send_file(tctx->u.fd, dkim_fd, 0
344 #ifdef OS_SENDFILE
345   , k_file_size
346 #endif
347   ))
348   {
349   save_errno = errno;
350   rc = FALSE;
351   }
352
353 CLEANUP:
354   /* unlink -K file */
355   if (dkim_fd >= 0) (void)close(dkim_fd);
356   Uunlink(dkim_spool_name);
357   errno = save_errno;
358   return rc;
359
360 err:
361   save_errno = errno;
362   rc = FALSE;
363   goto CLEANUP;
364 }
365
366
367
368 /***************************************************************************************************
369 *    External interface to write the message, while signing it with DKIM and/or Domainkeys         *
370 ***************************************************************************************************/
371
372 /* This function is a wrapper around transport_write_message().
373    It is only called from the smtp transport if DKIM or Domainkeys support
374    is compiled in.
375
376 Arguments:
377   As for transport_write_message() in transort.c, with additional arguments
378   for DKIM.
379
380 Returns:       TRUE on success; FALSE (with errno) for any failure
381 */
382
383 BOOL
384 dkim_transport_write_message(transport_ctx * tctx,
385   struct ob_dkim * dkim, const uschar ** err)
386 {
387 /* If we can't sign, just call the original function. */
388
389 if (  !(dkim->dkim_private_key && dkim->dkim_domain && dkim->dkim_selector)
390    && !dkim->force_bodyhash)
391   return transport_write_message(tctx, 0);
392
393 /* If there is no filter command set up, construct the message and calculate
394 a dkim signature of it, send the signature and a reconstructed message. This
395 avoids using a temprary file. */
396
397 if (  !transport_filter_argv
398    || !*transport_filter_argv
399    || !**transport_filter_argv
400    )
401   return dkt_direct(tctx, dkim, err);
402
403 /* Use the transport path to write a file, calculate a dkim signature,
404 send the signature and then send the file. */
405
406 return dkt_via_kfile(tctx, dkim, err);
407 }
408
409 #endif  /* whole file */
410
411 /* vi: aw ai sw=2
412 */
413 /* End of dkim_transport.c */