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