fd9831c43470ed84ceda9ec271c38fbff81c0ffb
[users/jgh/exim.git] / src / src / spf.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* SPF support.
6    Copyright (c) Tom Kistner <tom@duncanthrax.net> 2004 - 2014
7    License: GPL
8    Copyright (c) The Exim Maintainers 2015 - 2020
9 */
10
11 /* Code for calling spf checks via libspf-alt. Called from acl.c. */
12
13 #include "exim.h"
14 #ifdef SUPPORT_SPF
15
16 /* must be kept in numeric order */
17 static spf_result_id spf_result_id_list[] = {
18   /* name               value */
19   { US"invalid",        0},
20   { US"neutral",        1 },
21   { US"pass",           2 },
22   { US"fail",           3 },
23   { US"softfail",       4 },
24   { US"none",           5 },
25   { US"temperror",      6 }, /* RFC 4408 defined */
26   { US"permerror",      7 }  /* RFC 4408 defined */
27 };
28
29 SPF_server_t    *spf_server = NULL;
30 SPF_request_t   *spf_request = NULL;
31 SPF_response_t  *spf_response = NULL;
32 SPF_response_t  *spf_response_2mx = NULL;
33
34 SPF_dns_rr_t  * spf_nxdomain = NULL;
35
36
37 void
38 spf_lib_version_report(FILE * fp)
39 {
40 int maj, min, patch;
41 SPF_get_lib_version(&maj, &min, &patch);
42 fprintf(fp, "Library version: spf2: Compile: %d.%d.%d\n",
43         SPF_LIB_VERSION_MAJOR, SPF_LIB_VERSION_MINOR, SPF_LIB_VERSION_PATCH);
44 fprintf(fp, "                       Runtime: %d.%d.%d\n",
45          maj, min, patch);
46 }
47
48
49
50 static SPF_dns_rr_t *
51 SPF_dns_exim_lookup(SPF_dns_server_t *spf_dns_server,
52   const char *domain, ns_type rr_type, int should_cache)
53 {
54 dns_answer * dnsa = store_get_dns_answer();
55 dns_scan dnss;
56 SPF_dns_rr_t * spfrr;
57 unsigned found = 0;
58
59 SPF_dns_rr_t srr = {
60   .domain = CS domain,                  /* query information */
61   .domain_buf_len = 0,
62   .rr_type = rr_type,
63
64   .rr_buf_len = 0,                      /* answer information */
65   .rr_buf_num = 0, /* no free of s */
66   .utc_ttl = 0,
67
68   .hook = NULL,                         /* misc information */
69   .source = spf_dns_server
70 };
71 int dns_rc;
72
73 DEBUG(D_receive) debug_printf("SPF_dns_exim_lookup '%s'\n", domain);
74
75 /* Shortcircuit SPF RR lookups by returning HOST_NOT_FOUND (shortest code path
76 in libspf2).  They were obsoleted by RFC 6686/7208 years ago. see bug #1294
77 */
78
79 if (rr_type == T_SPF)
80   {
81   HDEBUG(D_host_lookup) debug_printf("faking HOST_NOT_FOUND for SPF RR(99) lookup\n");
82   srr.herrno = HOST_NOT_FOUND;
83   SPF_dns_rr_dup(&spfrr, &srr);
84   return spfrr;
85   }
86
87 switch (dns_rc = dns_lookup(dnsa, US domain, rr_type, NULL))
88   {
89   case DNS_SUCCEED:     srr.herrno = NETDB_SUCCESS;     break;
90   case DNS_AGAIN:       srr.herrno = TRY_AGAIN;         break;
91   case DNS_NOMATCH:     srr.herrno = HOST_NOT_FOUND;    break;
92   case DNS_NODATA:      srr.herrno = NO_DATA;           break;
93   case DNS_FAIL:
94   default:              srr.herrno = NO_RECOVERY;       break;
95   } 
96
97 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
98      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
99   if (rr->type == rr_type) found++;
100
101 if (found == 0)
102   {
103   SPF_dns_rr_dup(&spfrr, &srr);
104   return spfrr;
105   }
106
107 srr.rr = store_malloc(sizeof(SPF_dns_rr_data_t) * found);
108
109 found = 0;
110 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
111    rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
112   if (rr->type == rr_type)
113     {
114     const uschar * s = rr->data;
115
116     srr.ttl = rr->ttl;
117     switch(rr_type)
118       {
119       case T_MX:
120         s += 2; /* skip the MX precedence field */
121       case T_PTR:
122         {
123         uschar * buf = store_malloc(256);
124         (void)dn_expand(dnsa->answer, dnsa->answer + dnsa->answerlen, s,
125           (DN_EXPAND_ARG4_TYPE)buf, 256);
126         s = buf;
127         break;
128         }
129
130       case T_TXT:
131         {
132         gstring * g = NULL;
133         uschar chunk_len;
134
135         if (strncmpic(rr->data+1, US SPF_VER_STR, 6) != 0)
136           {
137           HDEBUG(D_host_lookup) debug_printf("not an spf record: %.*s\n",
138             (int) s[0], s+1);
139           continue;
140           }
141
142         for (int off = 0; off < rr->size; off += chunk_len)
143           {
144           if (!(chunk_len = s[off++])) break;
145           g = string_catn(g, s+off, chunk_len);
146           }
147         if (!g)
148           continue;
149         gstring_release_unused(g);
150         s = string_copy_malloc(string_from_gstring(g));
151         DEBUG(D_receive) debug_printf("SPF_dns_exim_lookup '%s'\n", s);
152         break;
153         }
154
155       case T_A:
156       case T_AAAA:
157       default:
158         {
159         uschar * buf = store_malloc(dnsa->answerlen + 1);
160         s = memcpy(buf, s, dnsa->answerlen + 1);
161         break;
162         }
163       }
164     srr.rr[found++] = (void *) s;
165     }
166
167 /* Did we filter out all TXT RRs? Return NO_DATA instead of SUCCESS with
168 empty ANSWER section. */
169
170 if (!(srr.num_rr = found))
171   srr.herrno = NO_DATA;
172
173 /* spfrr->rr must have been malloc()d for this */
174 SPF_dns_rr_dup(&spfrr, &srr);
175 return spfrr;
176 }
177
178
179
180 SPF_dns_server_t *
181 SPF_dns_exim_new(int debug)
182 {
183 SPF_dns_server_t * spf_dns_server = store_malloc(sizeof(SPF_dns_server_t));
184
185 DEBUG(D_receive) debug_printf("SPF_dns_exim_new\n");
186
187 memset(spf_dns_server, 0, sizeof(SPF_dns_server_t));
188 spf_dns_server->destroy      = NULL;
189 spf_dns_server->lookup       = SPF_dns_exim_lookup;
190 spf_dns_server->get_spf      = NULL;
191 spf_dns_server->get_exp      = NULL;
192 spf_dns_server->add_cache    = NULL;
193 spf_dns_server->layer_below  = NULL;
194 spf_dns_server->name         = "exim";
195 spf_dns_server->debug        = debug;
196
197 /* XXX This might have to return NO_DATA sometimes. */
198
199 spf_nxdomain = SPF_dns_rr_new_init(spf_dns_server,
200   "", ns_t_any, 24 * 60 * 60, HOST_NOT_FOUND);
201 if (!spf_nxdomain)
202   {
203   free(spf_dns_server);
204   return NULL;
205   }
206
207 return spf_dns_server;
208 }
209
210
211
212
213 /* Construct the SPF library stack.
214    Return: Boolean success.
215 */
216
217 BOOL
218 spf_init(void)
219 {
220 SPF_dns_server_t * dc;
221 int debug = 0;
222
223 DEBUG(D_receive) debug = 1;
224
225 /* We insert our own DNS access layer rather than letting the spf library
226 do it, so that our dns access path is used for debug tracing and for the
227 testsuite. */
228
229 if (!(dc = SPF_dns_exim_new(debug)))
230   {
231   DEBUG(D_receive) debug_printf("spf: SPF_dns_exim_new() failed\n");
232   return FALSE;
233   }
234 if (!(dc = SPF_dns_cache_new(dc, NULL, debug, 8)))
235   {
236   DEBUG(D_receive) debug_printf("spf: SPF_dns_cache_new() failed\n");
237   return FALSE;
238   }
239 if (!(spf_server = SPF_server_new_dns(dc, debug)))
240   {
241   DEBUG(D_receive) debug_printf("spf: SPF_server_new() failed.\n");
242   return FALSE;
243   }
244   /* Quick hack to override the outdated explanation URL.
245   See https://www.mail-archive.com/mailop@mailop.org/msg08019.html */
246   SPF_server_set_explanation(spf_server, "Please%_see%_http://www.open-spf.org/Why?id=%{S}&ip=%{C}&receiver=%{R}", &spf_response);
247   if (SPF_response_errcode(spf_response) != SPF_E_SUCCESS)
248     log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", SPF_strerror(SPF_response_errcode(spf_response)));
249
250 return TRUE;
251 }
252
253
254 /* Set up a context that can be re-used for several
255    messages on the same SMTP connection (that come from the
256    same host with the same HELO string).
257
258 Return: Boolean success
259 */
260
261 BOOL
262 spf_conn_init(uschar * spf_helo_domain, uschar * spf_remote_addr)
263 {
264 DEBUG(D_receive)
265   debug_printf("spf_conn_init: %s %s\n", spf_helo_domain, spf_remote_addr);
266
267 if (!spf_server && !spf_init()) return FALSE;
268
269 if (SPF_server_set_rec_dom(spf_server, CS primary_hostname))
270   {
271   DEBUG(D_receive) debug_printf("spf: SPF_server_set_rec_dom(\"%s\") failed.\n",
272     primary_hostname);
273   spf_server = NULL;
274   return FALSE;
275   }
276
277 spf_request = SPF_request_new(spf_server);
278
279 if (  SPF_request_set_ipv4_str(spf_request, CS spf_remote_addr)
280    && SPF_request_set_ipv6_str(spf_request, CS spf_remote_addr)
281    )
282   {
283   DEBUG(D_receive)
284     debug_printf("spf: SPF_request_set_ipv4_str() and "
285       "SPF_request_set_ipv6_str() failed [%s]\n", spf_remote_addr);
286   spf_server = NULL;
287   spf_request = NULL;
288   return FALSE;
289   }
290
291 if (SPF_request_set_helo_dom(spf_request, CS spf_helo_domain))
292   {
293   DEBUG(D_receive) debug_printf("spf: SPF_set_helo_dom(\"%s\") failed.\n",
294     spf_helo_domain);
295   spf_server = NULL;
296   spf_request = NULL;
297   return FALSE;
298   }
299
300 return TRUE;
301 }
302
303
304 void
305 spf_response_debug(SPF_response_t * spf_response)
306 {
307 if (SPF_response_messages(spf_response) == 0)
308   debug_printf(" (no errors)\n");
309 else for (int i = 0; i < SPF_response_messages(spf_response); i++)
310   {
311   SPF_error_t * err = SPF_response_message(spf_response, i);
312   debug_printf( "%s_msg = (%d) %s\n",
313                   (SPF_error_errorp(err) ? "warn" : "err"),
314                   SPF_error_code(err),
315                   SPF_error_message(err));
316   }
317 }
318
319
320 /* spf_process adds the envelope sender address to the existing
321    context (if any), retrieves the result, sets up expansion
322    strings and evaluates the condition outcome.
323
324 Return: OK/FAIL  */
325
326 int
327 spf_process(const uschar **listptr, uschar *spf_envelope_sender, int action)
328 {
329 int sep = 0;
330 const uschar *list = *listptr;
331 uschar *spf_result_id;
332 int rc = SPF_RESULT_PERMERROR;
333
334 DEBUG(D_receive) debug_printf("spf_process\n");
335
336 if (!(spf_server && spf_request))
337   /* no global context, assume temp error and skip to evaluation */
338   rc = SPF_RESULT_PERMERROR;
339
340 else if (SPF_request_set_env_from(spf_request, CS spf_envelope_sender))
341   /* Invalid sender address. This should be a real rare occurrence */
342   rc = SPF_RESULT_PERMERROR;
343
344 else
345   {
346   /* get SPF result */
347   if (action == SPF_PROCESS_FALLBACK)
348     {
349     SPF_request_query_fallback(spf_request, &spf_response, CS spf_guess);
350     spf_result_guessed = TRUE;
351     }
352   else
353     SPF_request_query_mailfrom(spf_request, &spf_response);
354
355   /* set up expansion items */
356   spf_header_comment     = US SPF_response_get_header_comment(spf_response);
357   spf_received           = US SPF_response_get_received_spf(spf_response);
358   spf_result             = US SPF_strresult(SPF_response_result(spf_response));
359   spf_smtp_comment       = US SPF_response_get_smtp_comment(spf_response);
360
361   rc = SPF_response_result(spf_response);
362
363   DEBUG(D_acl) spf_response_debug(spf_response);
364   }
365
366 /* We got a result. Now see if we should return OK or FAIL for it */
367 DEBUG(D_acl) debug_printf("SPF result is %s (%d)\n", SPF_strresult(rc), rc);
368
369 if (action == SPF_PROCESS_GUESS && (!strcmp (SPF_strresult(rc), "none")))
370   return spf_process(listptr, spf_envelope_sender, SPF_PROCESS_FALLBACK);
371
372 while ((spf_result_id = string_nextinlist(&list, &sep, NULL, 0)))
373   {
374   BOOL negate, result;
375
376   if ((negate = spf_result_id[0] == '!'))
377     spf_result_id++;
378
379   result = Ustrcmp(spf_result_id, spf_result_id_list[rc].name) == 0;
380   if (negate != result) return OK;
381   }
382
383 /* no match */
384 return FAIL;
385 }
386
387
388
389 gstring *
390 authres_spf(gstring * g)
391 {
392 uschar * s;
393 if (!spf_result) return g;
394
395 g = string_append(g, 2, US";\n\tspf=", spf_result);
396 if (spf_result_guessed)
397   g = string_cat(g, US" (best guess record for domain)");
398
399 s = expand_string(US"$sender_address_domain");
400 return s && *s
401   ? string_append(g, 2, US" smtp.mailfrom=", s)
402   : string_cat(g, US" smtp.mailfrom=<>");
403 }
404
405
406 #endif