src/src/malware.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2003 - 2015
   6  * License: GPL
   7  * Copyright (c) The Exim Maintainers 2015 - 2018
   8  */
   9
  10 /* Code for calling virus (malware) scanners. Called from acl.c. */
  11
  12 #include "exim.h"
  13 #ifdef WITH_CONTENT_SCAN        /* entire file */
  14
  15 typedef enum {
  16 #ifndef DISABLE_MAL_FFROTD
  17         M_FPROTD,
  18 #endif
  19 #ifndef DISABLE_MAL_FFROT6D
  20         M_FPROT6D,
  21 #endif
  22 #ifndef DISABLE_MAL_DRWEB
  23         M_DRWEB,
  24 #endif
  25 #ifndef DISABLE_MAL_AVE
  26         M_AVES,
  27 #endif
  28 #ifndef DISABLE_MAL_FSECURE
  29         M_FSEC,
  30 #endif
  31 #ifndef DISABLE_MAL_KAV
  32         M_KAVD,
  33 #endif
  34 #ifndef DISABLE_MAL_SOPHIE
  35         M_SOPHIE,
  36 #endif
  37 #ifndef DISABLE_MAL_CLAM
  38         M_CLAMD,
  39 #endif
  40 #ifndef DISABLE_MAL_MKS
  41         M_MKSD,
  42 #endif
  43 #ifndef DISABLE_MAL_AVAST
  44         M_AVAST,
  45 #endif
  46 #ifndef DISABLE_MAL_SOCK
  47         M_SOCK,
  48 #endif
  49 #ifndef DISABLE_MAL_CMDLINE
  50         M_CMDL,
  51 #endif
  52         } scanner_t;
  53 typedef enum {MC_NONE, MC_TCP, MC_UNIX, MC_STRM} contype_t;
  54 static struct scan
  55 {
  56   scanner_t     scancode;
  57   const uschar * name;
  58   const uschar * options_default;
  59   contype_t     conn;
  60 } m_scans[] =
  61 {
  62 #ifndef DISABLE_MAL_FFROTD
  63   { M_FPROTD,   US"f-protd",    US"localhost 10200-10204",            MC_TCP },
  64 #endif
  65 #ifndef DISABLE_MAL_FFROT6D
  66   { M_FPROT6D,  US"f-prot6d",   US"localhost 10200",                  MC_TCP },
  67 #endif
  68 #ifndef DISABLE_MAL_DRWEB
  69   { M_DRWEB,    US"drweb",      US"/usr/local/drweb/run/drwebd.sock", MC_STRM },
  70 #endif
  71 #ifndef DISABLE_MAL_AVE
  72   { M_AVES,     US"aveserver",  US"/var/run/aveserver",               MC_UNIX },
  73 #endif
  74 #ifndef DISABLE_MAL_FSECURE
  75   { M_FSEC,     US"fsecure",    US"/var/run/.fsav",                   MC_UNIX },
  76 #endif
  77 #ifndef DISABLE_MAL_KAV
  78   { M_KAVD,     US"kavdaemon",  US"/var/run/AvpCtl",                  MC_UNIX },
  79 #endif
  80 #ifndef DISABLE_MAL_SOPHIE
  81   { M_SOPHIE,   US"sophie",     US"/var/run/sophie",                  MC_UNIX },
  82 #endif
  83 #ifndef DISABLE_MAL_CLAM
  84   { M_CLAMD,    US"clamd",      US"/tmp/clamd",                       MC_NONE },
  85 #endif
  86 #ifndef DISABLE_MAL_MKS
  87   { M_MKSD,     US"mksd",       NULL,                                 MC_NONE },
  88 #endif
  89 #ifndef DISABLE_MAL_AVAST
  90   { M_AVAST,    US"avast",      US"/var/run/avast/scan.sock",         MC_STRM },
  91 #endif
  92 #ifndef DISABLE_MAL_SOCK
  93   { M_SOCK,     US"sock",       US"/tmp/malware.sock",                MC_STRM },
  94 #endif
  95 #ifndef DISABLE_MAL_CMDLINE
  96   { M_CMDL,     US"cmdline",    NULL,                                 MC_NONE },
  97 #endif
  98   { -1,         NULL,           NULL, MC_NONE }         /* end-marker */
  99 };
 100
 101 /******************************************************************************/
 102 # ifdef MACRO_PREDEF            /* build solely to predefine macros */
 103
 104 #  include "macro_predef.h"
 105
 106 void
 107 features_malware(void)
 108 {
 109 const uschar * s;
 110 uschar * t;
 111 uschar buf[64];
 112
 113 spf(buf, sizeof(buf), US"_HAVE_MALWARE_");
 114
 115 for (const struct scan * sc = m_scans; sc->scancode != -1; sc++)
 116   {
 117   for (s = sc->name, t = buf+14; *s; s++) if (*s != '-')
 118     *t++ = toupper(*s);
 119   *t = '\0';
 120   builtin_macro_create(buf);
 121   }
 122 }
 123
 124 /******************************************************************************/
 125 # else  /*!MACRO_PREDEF, main build*/
 126
 127
 128 #define MALWARE_TIMEOUT 120     /* default timeout, seconds */
 129
 130 static const uschar * malware_regex_default = US ".+";
 131 static const pcre * malware_default_re = NULL;
 132
 133
 134
 135 #ifndef DISABLE_MAL_CLAM
 136 /* The maximum number of clamd servers that are supported in the configuration */
 137 # define MAX_CLAMD_SERVERS 32
 138 # define MAX_CLAMD_SERVERS_S "32"
 139
 140 typedef struct clamd_address {
 141   uschar * hostspec;
 142   unsigned tcp_port;
 143   unsigned retry;
 144 } clamd_address;
 145 #endif
 146
 147
 148 #ifndef DISABLE_MAL_DRWEB
 149 # define DRWEBD_SCAN_CMD             (1)     /* scan file, buffer or diskfile */
 150 # define DRWEBD_RETURN_VIRUSES       (1<<0)   /* ask daemon return to us viruses names from report */
 151 # define DRWEBD_IS_MAIL              (1<<19)  /* say to daemon that format is "archive MAIL" */
 152
 153 # define DERR_READ_ERR               (1<<0)   /* read error */
 154 # define DERR_NOMEMORY               (1<<2)   /* no memory */
 155 # define DERR_TIMEOUT                (1<<9)   /* scan timeout has run out */
 156 # define DERR_BAD_CALL               (1<<15)  /* wrong command */
 157
 158 static const uschar * drweb_re_str = US "infected\\swith\\s*(.+?)$";
 159 static const pcre * drweb_re = NULL;
 160 #endif
 161
 162 #ifndef DISABLE_MAL_FSECURE
 163 static const uschar * fsec_re_str = US "\\S{0,5}INFECTED\\t[^\\t]*\\t([^\\t]+)\\t\\S*$";
 164 static const pcre * fsec_re = NULL;
 165 #endif
 166
 167 #ifndef DISABLE_MAL_KAV
 168 static const uschar * kav_re_sus_str = US "suspicion:\\s*(.+?)\\s*$";
 169 static const uschar * kav_re_inf_str = US "infected:\\s*(.+?)\\s*$";
 170 static const pcre * kav_re_sus = NULL;
 171 static const pcre * kav_re_inf = NULL;
 172 #endif
 173
 174 #ifndef DISABLE_MAL_AVAST
 175 static const uschar * ava_re_clean_str = US "(?!\\\\)\\t\\[\\+\\]";
 176 static const uschar * ava_re_virus_str = US "(?!\\\\)\\t\\[L\\]\\d+\\.0\\t0\\s(.*)";
 177 static const uschar * ava_re_error_str = US "(?!\\\\)\\t\\[E\\]\\d+\\.0\\tError\\s\\d+\\s(.*)";
 178 static const pcre * ava_re_clean = NULL;
 179 static const pcre * ava_re_virus = NULL;
 180 static const pcre * ava_re_error = NULL;
 181 #endif
 182
 183 #ifndef DISABLE_MAL_FFROT6D
 184 static const uschar * fprot6d_re_error_str = US "^\\d+\\s<(.+?)>$";
 185 static const uschar * fprot6d_re_virus_str = US "^\\d+\\s<infected:\\s+(.+?)>\\s+.+$";
 186 static const pcre * fprot6d_re_error = NULL;
 187 static const pcre * fprot6d_re_virus = NULL;
 188 #endif
 189
 190
 191
 192 /******************************************************************************/
 193
 194 #ifndef DISABLE_MAL_KAV
 195 /* Routine to check whether a system is big- or little-endian.
 196    Ripped from http://www.faqs.org/faqs/graphics/fileformats-faq/part4/section-7.html
 197    Needed for proper kavdaemon implementation. Sigh. */
 198 # define BIG_MY_ENDIAN      0
 199 # define LITTLE_MY_ENDIAN   1
 200 static int test_byte_order(void);
 201 static inline int
 202 test_byte_order()
 203 {
 204   short int word = 0x0001;
 205   char *byte = CS  &word;
 206   return(byte[0] ? LITTLE_MY_ENDIAN : BIG_MY_ENDIAN);
 207 }
 208 #endif
 209
 210 BOOL malware_ok = FALSE;
 211
 212 /* Gross hacks for the -bmalware option; perhaps we should just create
 213 the scan directory normally for that case, but look into rigging up the
 214 needed header variables if not already set on the command-line? */
 215 extern int spool_mbox_ok;
 216 extern uschar spooled_message_id[MESSAGE_ID_LENGTH+1];
 217
 218
 219 /* Some (currently avast only) use backslash escaped whitespace,
 220 this function undoes these escapes */
 221
 222 static inline void
 223 unescape(uschar *p)
 224 {
 225 uschar *p0;
 226 for (; *p; ++p)
 227   if (*p == '\\' && (isspace(p[1]) || p[1] == '\\'))
 228     for (p0 = p; *p0; ++p0) *p0 = p0[1];
 229 }
 230
 231 /* --- malware_*_defer --- */
 232 static inline int
 233 malware_panic_defer(const uschar * str)
 234 {
 235 log_write(0, LOG_MAIN|LOG_PANIC, "malware acl condition: %s", str);
 236 return DEFER;
 237 }
 238 static inline int
 239 malware_log_defer(const uschar * str)
 240 {
 241 log_write(0, LOG_MAIN, "malware acl condition: %s", str);
 242 return DEFER;
 243 }
 244 /* --- m_*_defer --- */
 245 static inline int
 246 m_panic_defer(struct scan * scanent, const uschar * hostport,
 247   const uschar * str)
 248 {
 249 return malware_panic_defer(string_sprintf("%s %s : %s",
 250   scanent->name, hostport ? hostport : CUS"", str));
 251 }
 252 static inline int
 253 m_log_defer(struct scan * scanent, const uschar * hostport,
 254   const uschar * str)
 255 {
 256 return malware_log_defer(string_sprintf("%s %s : %s",
 257   scanent->name, hostport ? hostport : CUS"", str));
 258 }
 259 /* --- m_*_defer_3 */
 260 static inline int
 261 m_panic_defer_3(struct scan * scanent, const uschar * hostport,
 262   const uschar * str, int fd_to_close)
 263 {
 264 (void) close(fd_to_close);
 265 return m_panic_defer(scanent, hostport, str);
 266 }
 267
 268 /*************************************************/
 269
 270 #ifndef DISABLE_MAL_CLAM
 271 /* Only used by the Clamav code, which is working from a list of servers and
 272 uses the returned in_addr to get a second connection to the same system.
 273 */
 274 static inline int
 275 m_tcpsocket(const uschar * hostname, unsigned int port,
 276         host_item * host, uschar ** errstr, const blob * fastopen_blob)
 277 {
 278 return ip_connectedsocket(SOCK_STREAM, hostname, port, port, 5,
 279                           host, errstr, fastopen_blob);
 280 }
 281 #endif
 282
 283 static int
 284 m_sock_send(int sock, uschar * buf, int cnt, uschar ** errstr)
 285 {
 286 if (send(sock, buf, cnt, 0) < 0)
 287   {
 288   int err = errno;
 289   (void)close(sock);
 290   *errstr = string_sprintf("unable to send to socket (%s): %s",
 291          buf, strerror(err));
 292   return -1;
 293   }
 294 return sock;
 295 }
 296
 297 static const pcre *
 298 m_pcre_compile(const uschar * re, uschar ** errstr)
 299 {
 300 const uschar * rerror;
 301 int roffset;
 302 const pcre * cre;
 303
 304 cre = pcre_compile(CS re, PCRE_COPT, (const char **)&rerror, &roffset, NULL);
 305 if (!cre)
 306   *errstr= string_sprintf("regular expression error in '%s': %s at offset %d",
 307       re, rerror, roffset);
 308 return cre;
 309 }
 310
 311 uschar *
 312 m_pcre_exec(const pcre * cre, uschar * text)
 313 {
 314 int ovector[10*3];
 315 int i = pcre_exec(cre, NULL, CS text, Ustrlen(text), 0, 0,
 316               ovector, nelem(ovector));
 317 uschar * substr = NULL;
 318 if (i >= 2)                             /* Got it */
 319   pcre_get_substring(CS text, ovector, i, 1, (const char **) &substr);
 320 return substr;
 321 }
 322
 323 static const pcre *
 324 m_pcre_nextinlist(const uschar ** list, int * sep,
 325  char * listerr, uschar ** errstr)
 326 {
 327 const uschar * list_ele;
 328 const pcre * cre = NULL;
 329
 330 if (!(list_ele = string_nextinlist(list, sep, NULL, 0)))
 331   *errstr = US listerr;
 332 else
 333   {
 334   DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "RE: ",
 335     string_printing(list_ele));
 336   cre = m_pcre_compile(CUS list_ele, errstr);
 337   }
 338 return cre;
 339 }
 340
 341 /*
 342  Simple though inefficient wrapper for reading a line.  Drop CRs and the
 343  trailing newline. Can return early on buffer full. Null-terminate.
 344  Apply initial timeout if no data ready.
 345
 346  Return: number of chars - zero for an empty line
 347          -1 on EOF
 348          -2 on timeout or error
 349 */
 350 static int
 351 recv_line(int fd, uschar * buffer, int bsize, int tmo)
 352 {
 353 uschar * p = buffer;
 354 ssize_t rcv;
 355 BOOL ok = FALSE;
 356
 357 if (!fd_ready(fd, tmo-time(NULL)))
 358   return -2;
 359
 360 /*XXX tmo handling assumes we always get a whole line */
 361 /* read until \n */
 362 errno = 0;
 363 while ((rcv = read(fd, p, 1)) > 0)
 364   {
 365   ok = TRUE;
 366   if (p-buffer > bsize-2) break;
 367   if (*p == '\n') break;
 368   if (*p != '\r') p++;
 369   }
 370 if (!ok)
 371   {
 372   DEBUG(D_acl) debug_printf_indent("Malware scan: read %s (%s)\n",
 373                 rcv==0 ? "EOF" : "error", strerror(errno));
 374   return rcv==0 ? -1 : -2;
 375   }
 376 *p = '\0';
 377
 378 DEBUG(D_acl) debug_printf_indent("Malware scan: read '%s'\n", buffer);
 379 return p - buffer;
 380 }
 381
 382 /* return TRUE iff size as requested */
 383 static BOOL
 384 recv_len(int sock, void * buf, int size, int tmo)
 385 {
 386 return fd_ready(sock, tmo-time(NULL))
 387   ? recv(sock, buf, size, 0) == size
 388   : FALSE;
 389 }
 390
 391
 392
 393 #ifndef DISABLE_MAL_MKS
 394 /* ============= private routines for the "mksd" scanner type ============== */
 395
 396 # include <sys/uio.h>
 397
 398 static inline int
 399 mksd_writev (int sock, struct iovec * iov, int iovcnt)
 400 {
 401 int i;
 402
 403 for (;;)
 404   {
 405   do
 406     i = writev (sock, iov, iovcnt);
 407   while (i < 0 && errno == EINTR);
 408   if (i <= 0)
 409     {
 410     (void) malware_panic_defer(
 411             US"unable to write to mksd UNIX socket (/var/run/mksd/socket)");
 412     return -1;
 413     }
 414   for (;;)      /* check for short write */
 415     if (i >= iov->iov_len)
 416       {
 417       if (--iovcnt == 0)
 418         return 0;
 419       i -= iov->iov_len;
 420       iov++;
 421       }
 422     else
 423       {
 424       iov->iov_len -= i;
 425       iov->iov_base = CS iov->iov_base + i;
 426       break;
 427       }
 428   }
 429 }
 430
 431 static inline int
 432 mksd_read_lines (int sock, uschar *av_buffer, int av_buffer_size, int tmo)
 433 {
 434 client_conn_ctx cctx = {.sock = sock};
 435 int offset = 0;
 436 int i;
 437
 438 do
 439   {
 440   i = ip_recv(&cctx, av_buffer+offset, av_buffer_size-offset, tmo-time(NULL));
 441   if (i <= 0)
 442     {
 443     (void) malware_panic_defer(US"unable to read from mksd UNIX socket (/var/run/mksd/socket)");
 444     return -1;
 445     }
 446
 447   offset += i;
 448   /* offset == av_buffer_size -> buffer full */
 449   if (offset == av_buffer_size)
 450     {
 451     (void) malware_panic_defer(US"malformed reply received from mksd");
 452     return -1;
 453     }
 454   } while (av_buffer[offset-1] != '\n');
 455
 456 av_buffer[offset] = '\0';
 457 return offset;
 458 }
 459
 460 static inline int
 461 mksd_parse_line(struct scan * scanent, char * line)
 462 {
 463 char *p;
 464
 465 switch (*line)
 466   {
 467   case 'O': /* OK */
 468     return OK;
 469
 470   case 'E':
 471   case 'A': /* ERR */
 472     if ((p = strchr (line, '\n')) != NULL)
 473       *p = '\0';
 474     return m_panic_defer(scanent, NULL,
 475       string_sprintf("scanner failed: %s", line));
 476
 477   default: /* VIR */
 478     if ((p = strchr (line, '\n')) != NULL)
 479       {
 480       *p = '\0';
 481       if (  p-line > 5
 482          && line[3] == ' '
 483          && (p = strchr(line+4, ' ')) != NULL
 484          && p-line > 4
 485          )
 486         {
 487         *p = '\0';
 488         malware_name = string_copy(US line+4);
 489         return OK;
 490         }
 491       }
 492     return m_panic_defer(scanent, NULL,
 493       string_sprintf("malformed reply received: %s", line));
 494   }
 495 }
 496
 497 static int
 498 mksd_scan_packed(struct scan * scanent, int sock, const uschar * scan_filename,
 499   int tmo)
 500 {
 501 struct iovec iov[3];
 502 const char *cmd = "MSQ\n";
 503 uschar av_buffer[1024];
 504
 505 iov[0].iov_base = (void *) cmd;
 506 iov[0].iov_len = 3;
 507 iov[1].iov_base = (void *) scan_filename;
 508 iov[1].iov_len = Ustrlen(scan_filename);
 509 iov[2].iov_base = (void *) (cmd + 3);
 510 iov[2].iov_len = 1;
 511
 512 if (mksd_writev (sock, iov, 3) < 0)
 513   return DEFER;
 514
 515 if (mksd_read_lines (sock, av_buffer, sizeof (av_buffer), tmo) < 0)
 516   return DEFER;
 517
 518 return mksd_parse_line (scanent, CS av_buffer);
 519 }
 520 #endif  /* MKSD */
 521
 522
 523 #ifndef DISABLE_MAL_CLAM
 524 static int
 525 clamd_option(clamd_address * cd, const uschar * optstr, int * subsep)
 526 {
 527 uschar * s;
 528
 529 cd->retry = 0;
 530 while ((s = string_nextinlist(&optstr, subsep, NULL, 0)))
 531   if (Ustrncmp(s, "retry=", 6) == 0)
 532     {
 533     int sec = readconf_readtime((s += 6), '\0', FALSE);
 534     if (sec < 0)
 535       return FAIL;
 536     cd->retry = sec;
 537     }
 538   else
 539     return FAIL;
 540 return OK;
 541 }
 542 #endif
 543
 544
 545
 546 /*************************************************
 547 *          Scan content for malware              *
 548 *************************************************/
 549
 550 /* This is an internal interface for scanning an email; the normal interface
 551 is via malware(), or there's malware_in_file() used for testing/debugging.
 552
 553 Arguments:
 554   malware_re    match condition for "malware="
 555   scan_filename  the file holding the email to be scanned, if we're faking
 556                 this up for the -bmalware test, else NULL
 557   timeout       if nonzero, non-default timeoutl
 558
 559 Returns:        Exim message processing code (OK, FAIL, DEFER, ...)
 560                 where true means malware was found (condition applies)
 561 */
 562 static int
 563 malware_internal(const uschar * malware_re, const uschar * scan_filename,
 564   int timeout)
 565 {
 566 int sep = 0;
 567 const uschar *av_scanner_work = av_scanner;
 568 uschar *scanner_name;
 569 unsigned long mbox_size;
 570 FILE *mbox_file;
 571 const pcre *re;
 572 uschar * errstr;
 573 struct scan * scanent;
 574 const uschar * scanner_options;
 575 client_conn_ctx malware_daemon_ctx = {.sock = -1};
 576 time_t tmo;
 577 uschar * eml_filename, * eml_dir;
 578
 579 if (!malware_re)
 580   return FAIL;          /* empty means "don't match anything" */
 581
 582 /* Ensure the eml mbox file is spooled up */
 583
 584 if (!(mbox_file = spool_mbox(&mbox_size, scan_filename, &eml_filename)))
 585   return malware_panic_defer(US"error while creating mbox spool file");
 586
 587 /* None of our current scanners need the mbox file as a stream (they use
 588 the name), so we can close it right away.  Get the directory too. */
 589
 590 (void) fclose(mbox_file);
 591 eml_dir = string_copyn(eml_filename, Ustrrchr(eml_filename, '/') - eml_filename);
 592
 593 /* parse 1st option */
 594 if (strcmpic(malware_re, US"false") == 0  ||  Ustrcmp(malware_re,"0") == 0)
 595   return FAIL;          /* explicitly no matching */
 596
 597 /* special cases (match anything except empty) */
 598 if (  strcmpic(malware_re,US"true") == 0
 599    || Ustrcmp(malware_re,"*") == 0
 600    || Ustrcmp(malware_re,"1") == 0
 601    )
 602   {
 603   if (  !malware_default_re
 604      && !(malware_default_re = m_pcre_compile(malware_regex_default, &errstr)))
 605     return malware_panic_defer(errstr);
 606   malware_re = malware_regex_default;
 607   re = malware_default_re;
 608   }
 609
 610 /* compile the regex, see if it works */
 611 else if (!(re = m_pcre_compile(malware_re, &errstr)))
 612   return malware_panic_defer(errstr);
 613
 614 /* if av_scanner starts with a dollar, expand it first */
 615 if (*av_scanner == '$')
 616   {
 617   if (!(av_scanner_work = expand_string(av_scanner)))
 618     return malware_panic_defer(
 619          string_sprintf("av_scanner starts with $, but expansion failed: %s",
 620          expand_string_message));
 621
 622   DEBUG(D_acl)
 623     debug_printf_indent("Expanded av_scanner global: %s\n", av_scanner_work);
 624   /* disable result caching in this case */
 625   malware_name = NULL;
 626   malware_ok = FALSE;
 627   }
 628
 629 /* Do not scan twice (unless av_scanner is dynamic). */
 630 if (!malware_ok)
 631   {
 632   /* find the scanner type from the av_scanner option */
 633   if (!(scanner_name = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
 634     return malware_panic_defer(US"av_scanner configuration variable is empty");
 635   if (!timeout) timeout = MALWARE_TIMEOUT;
 636   tmo = time(NULL) + timeout;
 637
 638   for (scanent = m_scans; ; scanent++)
 639     {
 640     if (!scanent->name)
 641       return malware_panic_defer(string_sprintf("unknown scanner type '%s'",
 642         scanner_name));
 643     if (strcmpic(scanner_name, US scanent->name) != 0)
 644       continue;
 645     DEBUG(D_acl) debug_printf_indent("Malware scan:  %s tmo=%s\n",
 646       scanner_name, readconf_printtime(timeout));
 647
 648     if (!(scanner_options = string_nextinlist(&av_scanner_work, &sep, NULL, 0)))
 649       scanner_options = scanent->options_default;
 650     if (scanent->conn == MC_NONE)
 651       break;
 652
 653     DEBUG(D_acl) debug_printf_indent("%15s%10s%s\n", "", "socket: ", scanner_options);
 654     switch(scanent->conn)
 655     {
 656     case MC_TCP:
 657       malware_daemon_ctx.sock = ip_tcpsocket(scanner_options, &errstr, 5);      break;
 658     case MC_UNIX:
 659       malware_daemon_ctx.sock = ip_unixsocket(scanner_options, &errstr);        break;
 660     case MC_STRM:
 661       malware_daemon_ctx.sock = ip_streamsocket(scanner_options, &errstr, 5);   break;
 662     default:
 663       /* compiler quietening */ break;
 664     }
 665     if (malware_daemon_ctx.sock < 0)
 666       return m_panic_defer(scanent, CUS callout_address, errstr);
 667     break;
 668   }
 669
 670   switch (scanent->scancode)
 671     {
 672 #ifndef DISABLE_MAL_FFROTD
 673     case M_FPROTD: /* "f-protd" scanner type -------------------------------- */
 674       {
 675       uschar *fp_scan_option;
 676       unsigned int detected=0, par_count=0;
 677       uschar * scanrequest;
 678       uschar buf[32768], *strhelper, *strhelper2;
 679       uschar * malware_name_internal = NULL;
 680       int len;
 681
 682       scanrequest = string_sprintf("GET %s", eml_filename);
 683
 684       while ((fp_scan_option = string_nextinlist(&av_scanner_work, &sep,
 685                             NULL, 0)))
 686         {
 687         scanrequest = string_sprintf("%s%s%s", scanrequest,
 688                                   par_count ? "%20" : "?", fp_scan_option);
 689         par_count++;
 690         }
 691       scanrequest = string_sprintf("%s HTTP/1.0\r\n\r\n", scanrequest);
 692       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s: %s\n",
 693         scanner_name, scanrequest);
 694
 695       /* send scan request */
 696       if (m_sock_send(malware_daemon_ctx.sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
 697         return m_panic_defer(scanent, CUS callout_address, errstr);
 698
 699       while ((len = recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo)) >= 0)
 700         if (len > 0)
 701           {
 702           if (Ustrstr(buf, US"<detected type=\"") != NULL)
 703             detected = 1;
 704           else if (detected && (strhelper = Ustrstr(buf, US"<name>")))
 705             {
 706             if ((strhelper2 = Ustrstr(buf, US"</name>")) != NULL)
 707               {
 708               *strhelper2 = '\0';
 709               malware_name_internal = string_copy(strhelper+6);
 710               }
 711             }
 712           else if (Ustrstr(buf, US"<summary code=\""))
 713             {
 714             malware_name = Ustrstr(buf, US"<summary code=\"11\">")
 715                 ? malware_name_internal : NULL;
 716             break;
 717             }
 718           }
 719       if (len < -1)
 720         {
 721         (void)close(malware_daemon_ctx.sock);
 722         return DEFER;
 723         }
 724       break;
 725       } /* f-protd */
 726 #endif
 727
 728 #ifndef DISABLE_MAL_FFROT6D
 729     case M_FPROT6D: /* "f-prot6d" scanner type ----------------------------------- */
 730       {
 731       int bread;
 732       uschar * e;
 733       uschar * linebuffer;
 734       uschar * scanrequest;
 735       uschar av_buffer[1024];
 736
 737       if ((!fprot6d_re_virus && !(fprot6d_re_virus = m_pcre_compile(fprot6d_re_virus_str, &errstr)))
 738         || (!fprot6d_re_error && !(fprot6d_re_error = m_pcre_compile(fprot6d_re_error_str, &errstr))))
 739         return malware_panic_defer(errstr);
 740
 741       scanrequest = string_sprintf("SCAN FILE %s\n", eml_filename);
 742       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s: %s\n",
 743         scanner_name, scanrequest);
 744
 745       if (m_sock_send(malware_daemon_ctx.sock, scanrequest, Ustrlen(scanrequest), &errstr) < 0)
 746         return m_panic_defer(scanent, CUS callout_address, errstr);
 747
 748       bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL));
 749
 750       if (bread <= 0)
 751         return m_panic_defer_3(scanent, CUS callout_address,
 752           string_sprintf("unable to read from socket (%s)", strerror(errno)),
 753           malware_daemon_ctx.sock);
 754
 755       if (bread == sizeof(av_buffer))
 756         return m_panic_defer_3(scanent, CUS callout_address,
 757           US"buffer too small", malware_daemon_ctx.sock);
 758
 759       av_buffer[bread] = '\0';
 760       linebuffer = string_copy(av_buffer);
 761
 762       m_sock_send(malware_daemon_ctx.sock, US"QUIT\n", 5, 0);
 763
 764       if ((e = m_pcre_exec(fprot6d_re_error, linebuffer)))
 765         return m_panic_defer_3(scanent, CUS callout_address,
 766           string_sprintf("scanner reported error (%s)", e), malware_daemon_ctx.sock);
 767
 768       if (!(malware_name = m_pcre_exec(fprot6d_re_virus, linebuffer)))
 769         malware_name = NULL;
 770
 771       break;
 772       }  /* f-prot6d */
 773 #endif
 774
 775 #ifndef DISABLE_MAL_DRWEB
 776     case M_DRWEB: /* "drweb" scanner type ----------------------------------- */
 777   /* v0.1 - added support for tcp sockets          */
 778   /* v0.0 - initial release -- support for unix sockets      */
 779       {
 780       int result;
 781       off_t fsize;
 782       unsigned int fsize_uint;
 783       uschar * tmpbuf, *drweb_fbuf;
 784       int drweb_rc, drweb_cmd, drweb_flags = 0x0000, drweb_fd,
 785           drweb_vnum, drweb_slen, drweb_fin = 0x0000;
 786
 787       /* prepare variables */
 788       drweb_cmd = htonl(DRWEBD_SCAN_CMD);
 789       drweb_flags = htonl(DRWEBD_RETURN_VIRUSES | DRWEBD_IS_MAIL);
 790
 791       if (*scanner_options != '/')
 792         {
 793         /* calc file size */
 794         if ((drweb_fd = open(CCS eml_filename, O_RDONLY)) == -1)
 795           return m_panic_defer_3(scanent, NULL,
 796             string_sprintf("can't open spool file %s: %s",
 797               eml_filename, strerror(errno)),
 798             malware_daemon_ctx.sock);
 799
 800         if ((fsize = lseek(drweb_fd, 0, SEEK_END)) == -1)
 801           {
 802           int err;
 803 badseek:  err = errno;
 804           (void)close(drweb_fd);
 805           return m_panic_defer_3(scanent, NULL,
 806             string_sprintf("can't seek spool file %s: %s",
 807               eml_filename, strerror(err)),
 808             malware_daemon_ctx.sock);
 809           }
 810         fsize_uint = (unsigned int) fsize;
 811         if ((off_t)fsize_uint != fsize)
 812           {
 813           (void)close(drweb_fd);
 814           return m_panic_defer_3(scanent, NULL,
 815             string_sprintf("seeking spool file %s, size overflow",
 816               eml_filename),
 817             malware_daemon_ctx.sock);
 818           }
 819         drweb_slen = htonl(fsize);
 820         if (lseek(drweb_fd, 0, SEEK_SET) < 0)
 821           goto badseek;
 822
 823         DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s remote scan [%s]\n",
 824             scanner_name, scanner_options);
 825
 826         /* send scan request */
 827         if ((send(malware_daemon_ctx.sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
 828             (send(malware_daemon_ctx.sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
 829             (send(malware_daemon_ctx.sock, &drweb_fin, sizeof(drweb_fin), 0) < 0) ||
 830             (send(malware_daemon_ctx.sock, &drweb_slen, sizeof(drweb_slen), 0) < 0))
 831           {
 832           (void)close(drweb_fd);
 833           return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
 834             "unable to send commands to socket (%s)", scanner_options),
 835             malware_daemon_ctx.sock);
 836           }
 837
 838         if (!(drweb_fbuf = US malloc(fsize_uint)))
 839           {
 840           (void)close(drweb_fd);
 841           return m_panic_defer_3(scanent, NULL,
 842             string_sprintf("unable to allocate memory %u for file (%s)",
 843               fsize_uint, eml_filename),
 844             malware_daemon_ctx.sock);
 845           }
 846
 847         if ((result = read (drweb_fd, drweb_fbuf, fsize)) == -1)
 848           {
 849           int err = errno;
 850           (void)close(drweb_fd);
 851           free(drweb_fbuf);
 852           return m_panic_defer_3(scanent, NULL,
 853             string_sprintf("can't read spool file %s: %s",
 854               eml_filename, strerror(err)),
 855             malware_daemon_ctx.sock);
 856           }
 857         (void)close(drweb_fd);
 858
 859         /* send file body to socket */
 860         if (send(malware_daemon_ctx.sock, drweb_fbuf, fsize, 0) < 0)
 861           {
 862           free(drweb_fbuf);
 863           return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
 864             "unable to send file body to socket (%s)", scanner_options),
 865             malware_daemon_ctx.sock);
 866           }
 867         }
 868       else
 869         {
 870         drweb_slen = htonl(Ustrlen(eml_filename));
 871
 872         DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s local scan [%s]\n",
 873             scanner_name, scanner_options);
 874
 875         /* send scan request */
 876         if ((send(malware_daemon_ctx.sock, &drweb_cmd, sizeof(drweb_cmd), 0) < 0) ||
 877             (send(malware_daemon_ctx.sock, &drweb_flags, sizeof(drweb_flags), 0) < 0) ||
 878             (send(malware_daemon_ctx.sock, &drweb_slen, sizeof(drweb_slen), 0) < 0) ||
 879             (send(malware_daemon_ctx.sock, eml_filename, Ustrlen(eml_filename), 0) < 0) ||
 880             (send(malware_daemon_ctx.sock, &drweb_fin, sizeof(drweb_fin), 0) < 0))
 881           return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
 882             "unable to send commands to socket (%s)", scanner_options),
 883             malware_daemon_ctx.sock);
 884         }
 885
 886       /* wait for result */
 887       if (!recv_len(malware_daemon_ctx.sock, &drweb_rc, sizeof(drweb_rc), tmo))
 888         return m_panic_defer_3(scanent, CUS callout_address,
 889                     US"unable to read return code", malware_daemon_ctx.sock);
 890       drweb_rc = ntohl(drweb_rc);
 891
 892       if (!recv_len(malware_daemon_ctx.sock, &drweb_vnum, sizeof(drweb_vnum), tmo))
 893         return m_panic_defer_3(scanent, CUS callout_address,
 894                             US"unable to read the number of viruses", malware_daemon_ctx.sock);
 895       drweb_vnum = ntohl(drweb_vnum);
 896
 897       /* "virus(es) found" if virus number is > 0 */
 898       if (drweb_vnum)
 899         {
 900         gstring * g = NULL;
 901
 902         /* setup default virus name */
 903         malware_name = US"unknown";
 904
 905         /* set up match regex */
 906         if (!drweb_re)
 907           drweb_re = m_pcre_compile(drweb_re_str, &errstr);
 908
 909         /* read and concatenate virus names into one string */
 910         for (int i = 0; i < drweb_vnum; i++)
 911           {
 912           int ovector[10*3];
 913
 914           /* read the size of report */
 915           if (!recv_len(malware_daemon_ctx.sock, &drweb_slen, sizeof(drweb_slen), tmo))
 916             return m_panic_defer_3(scanent, CUS callout_address,
 917                               US"cannot read report size", malware_daemon_ctx.sock);
 918           drweb_slen = ntohl(drweb_slen);
 919           tmpbuf = store_get(drweb_slen);
 920
 921           /* read report body */
 922           if (!recv_len(malware_daemon_ctx.sock, tmpbuf, drweb_slen, tmo))
 923             return m_panic_defer_3(scanent, CUS callout_address,
 924                               US"cannot read report string", malware_daemon_ctx.sock);
 925           tmpbuf[drweb_slen] = '\0';
 926
 927           /* try matcher on the line, grab substring */
 928           result = pcre_exec(drweb_re, NULL, CS tmpbuf, Ustrlen(tmpbuf), 0, 0,
 929                                   ovector, nelem(ovector));
 930           if (result >= 2)
 931             {
 932             const char * pre_malware_nb;
 933
 934             pcre_get_substring(CS tmpbuf, ovector, result, 1, &pre_malware_nb);
 935
 936             if (i==0)   /* the first name we just copy to malware_name */
 937               g = string_cat(NULL, US pre_malware_nb);
 938
 939             /*XXX could be string_append_listele? */
 940             else        /* concatenate each new virus name to previous */
 941               g = string_append(g, 2, "/", pre_malware_nb);
 942
 943             pcre_free_substring(pre_malware_nb);
 944             }
 945           }
 946           malware_name = string_from_gstring(g);
 947         }
 948       else
 949         {
 950         const char *drweb_s = NULL;
 951
 952         if (drweb_rc & DERR_READ_ERR) drweb_s = "read error";
 953         if (drweb_rc & DERR_NOMEMORY) drweb_s = "no memory";
 954         if (drweb_rc & DERR_TIMEOUT)  drweb_s = "timeout";
 955         if (drweb_rc & DERR_BAD_CALL) drweb_s = "wrong command";
 956         /* retcodes DERR_SYMLINK, DERR_NO_REGFILE, DERR_SKIPPED.
 957          * DERR_TOO_BIG, DERR_TOO_COMPRESSED, DERR_SPAM,
 958          * DERR_CRC_ERROR, DERR_READSOCKET, DERR_WRITE_ERR
 959          * and others are ignored */
 960         if (drweb_s)
 961           return m_panic_defer_3(scanent, CUS callout_address,
 962             string_sprintf("drweb daemon retcode 0x%x (%s)", drweb_rc, drweb_s),
 963             malware_daemon_ctx.sock);
 964
 965         /* no virus found */
 966         malware_name = NULL;
 967         }
 968       break;
 969       } /* drweb */
 970 #endif
 971
 972 #ifndef DISABLE_MAL_AVE
 973     case M_AVES: /* "aveserver" scanner type -------------------------------- */
 974       {
 975       uschar buf[32768];
 976       int result;
 977
 978       /* read aveserver's greeting and see if it is ready (2xx greeting) */
 979       buf[0] = 0;
 980       recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo);
 981
 982       if (buf[0] != '2')                /* aveserver is having problems */
 983         return m_panic_defer_3(scanent, CUS callout_address,
 984           string_sprintf("unavailable (Responded: %s).",
 985                           ((buf[0] != 0) ? buf : US "nothing") ),
 986           malware_daemon_ctx.sock);
 987
 988       /* prepare our command */
 989       (void)string_format(buf, sizeof(buf), "SCAN bPQRSTUW %s\r\n",
 990                                                 eml_filename);
 991
 992       /* and send it */
 993       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s %s\n",
 994         scanner_name, buf);
 995       if (m_sock_send(malware_daemon_ctx.sock, buf, Ustrlen(buf), &errstr) < 0)
 996         return m_panic_defer(scanent, CUS callout_address, errstr);
 997
 998       malware_name = NULL;
 999       result = 0;
1000       /* read response lines, find malware name and final response */
1001       while (recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo) > 0)
1002         {
1003         if (buf[0] == '2')
1004           break;
1005         if (buf[0] == '5')              /* aveserver is having problems */
1006           {
1007           result = m_panic_defer(scanent, CUS callout_address,
1008              string_sprintf("unable to scan file %s (Responded: %s).",
1009                              eml_filename, buf));
1010           break;
1011           }
1012         if (Ustrncmp(buf,"322",3) == 0)
1013           {
1014           uschar *p = Ustrchr(&buf[4], ' ');
1015           *p = '\0';
1016           malware_name = string_copy(&buf[4]);
1017           }
1018         }
1019
1020       if (m_sock_send(malware_daemon_ctx.sock, US"quit\r\n", 6, &errstr) < 0)
1021         return m_panic_defer(scanent, CUS callout_address, errstr);
1022
1023       /* read aveserver's greeting and see if it is ready (2xx greeting) */
1024       buf[0] = 0;
1025       recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo);
1026
1027       if (buf[0] != '2')                /* aveserver is having problems */
1028         return m_panic_defer_3(scanent, CUS callout_address,
1029           string_sprintf("unable to quit dialogue (Responded: %s).",
1030                         ((buf[0] != 0) ? buf : US "nothing") ),
1031           malware_daemon_ctx.sock);
1032
1033       if (result == DEFER)
1034         {
1035         (void)close(malware_daemon_ctx.sock);
1036         return DEFER;
1037         }
1038       break;
1039       } /* aveserver */
1040 #endif
1041
1042 #ifndef DISABLE_MAL_FSECURE
1043     case M_FSEC: /* "fsecure" scanner type ---------------------------------- */
1044       {
1045       int i, bread = 0;
1046       uschar * file_name;
1047       uschar av_buffer[1024];
1048       static uschar *cmdopt[] = { US"CONFIGURE\tARCHIVE\t1\n",
1049                                       US"CONFIGURE\tTIMEOUT\t0\n",
1050                                       US"CONFIGURE\tMAXARCH\t5\n",
1051                                       US"CONFIGURE\tMIME\t1\n" };
1052
1053       malware_name = NULL;
1054
1055       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
1056           scanner_name, scanner_options);
1057       /* pass options */
1058       memset(av_buffer, 0, sizeof(av_buffer));
1059       for (i = 0; i != nelem(cmdopt); i++)
1060         {
1061
1062         if (m_sock_send(malware_daemon_ctx.sock, cmdopt[i], Ustrlen(cmdopt[i]), &errstr) < 0)
1063           return m_panic_defer(scanent, CUS callout_address, errstr);
1064
1065         bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL));
1066         if (bread > 0) av_buffer[bread]='\0';
1067         if (bread < 0)
1068           return m_panic_defer_3(scanent, CUS callout_address,
1069             string_sprintf("unable to read answer %d (%s)", i, strerror(errno)),
1070             malware_daemon_ctx.sock);
1071         for (int j = 0; j < bread; j++)
1072           if (av_buffer[j] == '\r' || av_buffer[j] == '\n')
1073             av_buffer[j] ='@';
1074         }
1075
1076       /* pass the mailfile to fsecure */
1077       file_name = string_sprintf("SCAN\t%s\n", eml_filename);
1078
1079       if (m_sock_send(malware_daemon_ctx.sock, file_name, Ustrlen(file_name), &errstr) < 0)
1080         return m_panic_defer(scanent, CUS callout_address, errstr);
1081
1082       /* set up match */
1083       /* todo also SUSPICION\t */
1084       if (!fsec_re)
1085         fsec_re = m_pcre_compile(fsec_re_str, &errstr);
1086
1087       /* read report, linewise. Apply a timeout as the Fsecure daemon
1088       sometimes wants an answer to "PING" but they won't tell us what */
1089         {
1090         uschar * p = av_buffer;
1091         uschar * q;
1092
1093         for (;;)
1094           {
1095           errno = ETIMEDOUT;
1096           i =  av_buffer+sizeof(av_buffer)-p;
1097           if ((bread= ip_recv(&malware_daemon_ctx, p, i-1, tmo-time(NULL))) < 0)
1098             return m_panic_defer_3(scanent, CUS callout_address,
1099               string_sprintf("unable to read result (%s)", strerror(errno)),
1100               malware_daemon_ctx.sock);
1101
1102           for (p[bread] = '\0'; (q = Ustrchr(p, '\n')); p = q+1)
1103             {
1104             *q = '\0';
1105
1106             /* Really search for virus again? */
1107             if (!malware_name)
1108               /* try matcher on the line, grab substring */
1109               malware_name = m_pcre_exec(fsec_re, p);
1110
1111             if (Ustrstr(p, "OK\tScan ok."))
1112               goto fsec_found;
1113             }
1114
1115           /* copy down the trailing partial line then read another chunk */
1116           i =  av_buffer+sizeof(av_buffer)-p;
1117           memmove(av_buffer, p, i);
1118           p = av_buffer+i;
1119           }
1120         }
1121
1122       fsec_found:
1123         break;
1124       } /* fsecure */
1125 #endif
1126
1127 #ifndef DISABLE_MAL_KAV
1128     case M_KAVD: /* "kavdaemon" scanner type -------------------------------- */
1129       {
1130       time_t t;
1131       uschar tmpbuf[1024];
1132       uschar * scanrequest;
1133       int kav_rc;
1134       unsigned long kav_reportlen;
1135       int bread;
1136       const pcre *kav_re;
1137       uschar *p;
1138
1139       /* get current date and time, build scan request */
1140       time(&t);
1141       /* pdp note: before the eml_filename parameter, this scanned the
1142       directory; not finding documentation, so we'll strip off the directory.
1143       The side-effect is that the test framework scanning may end up in
1144       scanning more than was requested, but for the normal interface, this is
1145       fine. */
1146
1147       strftime(CS tmpbuf, sizeof(tmpbuf), "%d %b %H:%M:%S", localtime(&t));
1148       scanrequest = string_sprintf("<0>%s:%s", CS tmpbuf, eml_filename);
1149       p = Ustrrchr(scanrequest, '/');
1150       if (p)
1151         *p = '\0';
1152
1153       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
1154           scanner_name, scanner_options);
1155
1156       /* send scan request */
1157       if (m_sock_send(malware_daemon_ctx.sock, scanrequest, Ustrlen(scanrequest)+1, &errstr) < 0)
1158         return m_panic_defer(scanent, CUS callout_address, errstr);
1159
1160       /* wait for result */
1161       if (!recv_len(malware_daemon_ctx.sock, tmpbuf, 2, tmo))
1162         return m_panic_defer_3(scanent, CUS callout_address,
1163                             US"unable to read 2 bytes from socket.", malware_daemon_ctx.sock);
1164
1165       /* get errorcode from one nibble */
1166       kav_rc = tmpbuf[ test_byte_order()==LITTLE_MY_ENDIAN ? 0 : 1 ] & 0x0F;
1167       switch(kav_rc)
1168       {
1169       case 5: case 6: /* improper kavdaemon configuration */
1170         return m_panic_defer_3(scanent, CUS callout_address,
1171                 US"please reconfigure kavdaemon to NOT disinfect or remove infected files.",
1172                 malware_daemon_ctx.sock);
1173       case 1:
1174         return m_panic_defer_3(scanent, CUS callout_address,
1175                 US"reported 'scanning not completed' (code 1).", malware_daemon_ctx.sock);
1176       case 7:
1177         return m_panic_defer_3(scanent, CUS callout_address,
1178                 US"reported 'kavdaemon damaged' (code 7).", malware_daemon_ctx.sock);
1179       }
1180
1181       /* code 8 is not handled, since it is ambiguous. It appears mostly on
1182       bounces where part of a file has been cut off */
1183
1184       /* "virus found" return codes (2-4) */
1185       if (kav_rc > 1 && kav_rc < 5)
1186         {
1187         int report_flag = 0;
1188
1189         /* setup default virus name */
1190         malware_name = US"unknown";
1191
1192         report_flag = tmpbuf[ test_byte_order() == LITTLE_MY_ENDIAN ? 1 : 0 ];
1193
1194         /* read the report, if available */
1195         if (report_flag == 1)
1196           {
1197           /* read report size */
1198           if (!recv_len(malware_daemon_ctx.sock, &kav_reportlen, 4, tmo))
1199             return m_panic_defer_3(scanent, CUS callout_address,
1200                   US"cannot read report size", malware_daemon_ctx.sock);
1201
1202           /* it's possible that avp returns av_buffer[1] == 1 but the
1203           reportsize is 0 (!?) */
1204           if (kav_reportlen > 0)
1205             {
1206             /* set up match regex, depends on retcode */
1207             if (kav_rc == 3)
1208               {
1209               if (!kav_re_sus) kav_re_sus = m_pcre_compile(kav_re_sus_str, &errstr);
1210               kav_re = kav_re_sus;
1211               }
1212             else
1213               {
1214               if (!kav_re_inf) kav_re_inf = m_pcre_compile(kav_re_inf_str, &errstr);
1215               kav_re = kav_re_inf;
1216               }
1217
1218             /* read report, linewise.  Using size from stream to read amount of data
1219             from same stream is safe enough. */
1220             /* coverity[tainted_data] */
1221             while (kav_reportlen > 0)
1222               {
1223               if ((bread = recv_line(malware_daemon_ctx.sock, tmpbuf, sizeof(tmpbuf), tmo)) < 0)
1224                 break;
1225               kav_reportlen -= bread+1;
1226
1227               /* try matcher on the line, grab substring */
1228               if ((malware_name = m_pcre_exec(kav_re, tmpbuf)))
1229                 break;
1230               }
1231             }
1232           }
1233         }
1234       else /* no virus found */
1235         malware_name = NULL;
1236
1237       break;
1238       }
1239 #endif
1240
1241 #ifndef DISABLE_MAL_CMDLINE
1242     case M_CMDL: /* "cmdline" scanner type ---------------------------------- */
1243       {
1244       const uschar *cmdline_scanner = scanner_options;
1245       const pcre *cmdline_trigger_re;
1246       const pcre *cmdline_regex_re;
1247       uschar * file_name;
1248       uschar * commandline;
1249       void (*eximsigchld)(int);
1250       void (*eximsigpipe)(int);
1251       FILE *scanner_out = NULL;
1252       int scanner_fd;
1253       FILE *scanner_record = NULL;
1254       uschar linebuffer[32767];
1255       int rcnt;
1256       int trigger = 0;
1257       uschar *p;
1258
1259       if (!cmdline_scanner)
1260         return m_panic_defer(scanent, NULL, errstr);
1261
1262       /* find scanner output trigger */
1263       cmdline_trigger_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1264                                 "missing trigger specification", &errstr);
1265       if (!cmdline_trigger_re)
1266         return m_panic_defer(scanent, NULL, errstr);
1267
1268       /* find scanner name regex */
1269       cmdline_regex_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1270                           "missing virus name regex specification", &errstr);
1271       if (!cmdline_regex_re)
1272         return m_panic_defer(scanent, NULL, errstr);
1273
1274       /* prepare scanner call; despite the naming, file_name holds a directory
1275       name which is documented as the value given to %s. */
1276
1277       file_name = string_copy(eml_filename);
1278       p = Ustrrchr(file_name, '/');
1279       if (p)
1280         *p = '\0';
1281       commandline = string_sprintf(CS cmdline_scanner, file_name);
1282
1283       /* redirect STDERR too */
1284       commandline = string_sprintf("%s 2>&1", commandline);
1285
1286       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
1287               scanner_name, commandline);
1288
1289       /* store exims signal handlers */
1290       eximsigchld = signal(SIGCHLD,SIG_DFL);
1291       eximsigpipe = signal(SIGPIPE,SIG_DFL);
1292
1293       if (!(scanner_out = popen(CS commandline,"r")))
1294         {
1295         int err = errno;
1296         signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1297         return m_panic_defer(scanent, NULL,
1298           string_sprintf("call (%s) failed: %s.", commandline, strerror(err)));
1299         }
1300       scanner_fd = fileno(scanner_out);
1301
1302       file_name = string_sprintf("%s/%s_scanner_output", eml_dir, message_id);
1303
1304       if (!(scanner_record = modefopen(file_name, "wb", SPOOL_MODE)))
1305         {
1306         int err = errno;
1307         (void) pclose(scanner_out);
1308         signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1309         return m_panic_defer(scanent, NULL, string_sprintf(
1310             "opening scanner output file (%s) failed: %s.",
1311             file_name, strerror(err)));
1312         }
1313
1314       /* look for trigger while recording output */
1315       while ((rcnt = recv_line(scanner_fd, linebuffer,
1316                       sizeof(linebuffer), tmo)))
1317         {
1318         if (rcnt < 0)
1319           {
1320           int err = errno;
1321           if (rcnt == -1)
1322             break;
1323           (void) pclose(scanner_out);
1324           signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1325           return m_panic_defer(scanent, NULL, string_sprintf(
1326               "unable to read from scanner (%s): %s",
1327               commandline, strerror(err)));
1328           }
1329
1330         if (Ustrlen(linebuffer) > fwrite(linebuffer, 1, Ustrlen(linebuffer), scanner_record))
1331           {
1332           /* short write */
1333           (void) pclose(scanner_out);
1334           signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1335           return m_panic_defer(scanent, NULL, string_sprintf(
1336             "short write on scanner output file (%s).", file_name));
1337           }
1338         putc('\n', scanner_record);
1339         /* try trigger match */
1340         if (  !trigger
1341            && regex_match_and_setup(cmdline_trigger_re, linebuffer, 0, -1)
1342            )
1343           trigger = 1;
1344         }
1345
1346       (void)fclose(scanner_record);
1347       sep = pclose(scanner_out);
1348       signal(SIGCHLD,eximsigchld); signal(SIGPIPE,eximsigpipe);
1349       if (sep != 0)
1350           return m_panic_defer(scanent, NULL,
1351               sep == -1
1352               ? string_sprintf("running scanner failed: %s", strerror(sep))
1353               : string_sprintf("scanner returned error code: %d", sep));
1354
1355       if (trigger)
1356         {
1357         uschar * s;
1358         /* setup default virus name */
1359         malware_name = US"unknown";
1360
1361         /* re-open the scanner output file, look for name match */
1362         scanner_record = fopen(CS file_name, "rb");
1363         while (fgets(CS linebuffer, sizeof(linebuffer), scanner_record))
1364           {
1365           /* try match */
1366           if ((s = m_pcre_exec(cmdline_regex_re, linebuffer)))
1367             malware_name = s;
1368           }
1369         (void)fclose(scanner_record);
1370         }
1371       else /* no virus found */
1372         malware_name = NULL;
1373       break;
1374       } /* cmdline */
1375 #endif
1376
1377 #ifndef DISABLE_MAL_SOPHIE
1378     case M_SOPHIE: /* "sophie" scanner type --------------------------------- */
1379       {
1380       int bread = 0;
1381       uschar *p;
1382       uschar * file_name;
1383       uschar av_buffer[1024];
1384
1385       /* pass the scan directory to sophie */
1386       file_name = string_copy(eml_filename);
1387       if ((p = Ustrrchr(file_name, '/')))
1388         *p = '\0';
1389
1390       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan [%s]\n",
1391           scanner_name, scanner_options);
1392
1393       if (  write(malware_daemon_ctx.sock, file_name, Ustrlen(file_name)) < 0
1394          || write(malware_daemon_ctx.sock, "\n", 1) != 1
1395          )
1396         return m_panic_defer_3(scanent, CUS callout_address,
1397           string_sprintf("unable to write to UNIX socket (%s)", scanner_options),
1398           malware_daemon_ctx.sock);
1399
1400       /* wait for result */
1401       memset(av_buffer, 0, sizeof(av_buffer));
1402       if ((bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL))) <= 0)
1403         return m_panic_defer_3(scanent, CUS callout_address,
1404           string_sprintf("unable to read from UNIX socket (%s)", scanner_options),
1405           malware_daemon_ctx.sock);
1406
1407       /* infected ? */
1408       if (av_buffer[0] == '1') {
1409         uschar * s = Ustrchr(av_buffer, '\n');
1410         if (s)
1411           *s = '\0';
1412         malware_name = string_copy(&av_buffer[2]);
1413       }
1414       else if (!strncmp(CS av_buffer, "-1", 2))
1415         return m_panic_defer_3(scanent, CUS callout_address,
1416                 US"scanner reported error", malware_daemon_ctx.sock);
1417       else /* all ok, no virus */
1418         malware_name = NULL;
1419
1420       break;
1421       }
1422 #endif
1423
1424 #ifndef DISABLE_MAL_CLAM
1425     case M_CLAMD: /* "clamd" scanner type ----------------------------------- */
1426       {
1427 /* This code was originally contributed by David Saez */
1428 /* There are three scanning methods available to us:
1429 *  (1) Use the SCAN command, pointing to a file in the filesystem
1430 *  (2) Use the STREAM command, send the data on a separate port
1431 *  (3) Use the zINSTREAM command, send the data inline
1432 * The zINSTREAM command was introduced with ClamAV 0.95, which marked
1433 * STREAM deprecated; see: http://wiki.clamav.net/bin/view/Main/UpgradeNotes095
1434 * In Exim, we use SCAN if using a Unix-domain socket or explicitly told that
1435 * the TCP-connected daemon is actually local; otherwise we use zINSTREAM
1436 * See Exim bug 926 for details.  */
1437
1438       uschar *p, *vname, *result_tag;
1439       int bread=0;
1440       uschar av_buffer[1024];
1441       uschar *hostname = US"";
1442       host_item connhost;
1443       uschar *clamav_fbuf;
1444       int clam_fd, result;
1445       off_t fsize;
1446       unsigned int fsize_uint;
1447       BOOL use_scan_command = FALSE;
1448       clamd_address * cv[MAX_CLAMD_SERVERS];
1449       int num_servers = 0;
1450       uint32_t send_size, send_final_zeroblock;
1451       blob cmd_str;
1452
1453       /*XXX if unixdomain socket, only one server supported. Needs fixing;
1454       there's no reason we should not mix local and remote servers */
1455
1456       if (*scanner_options == '/')
1457         {
1458         clamd_address * cd;
1459         const uschar * sublist;
1460         int subsep = ' ';
1461
1462         /* Local file; so we def want to use_scan_command and don't want to try
1463          * passing IP/port combinations */
1464         use_scan_command = TRUE;
1465         cd = (clamd_address *) store_get(sizeof(clamd_address));
1466
1467         /* extract socket-path part */
1468         sublist = scanner_options;
1469         cd->hostspec = string_nextinlist(&sublist, &subsep, NULL, 0);
1470
1471         /* parse options */
1472         if (clamd_option(cd, sublist, &subsep) != OK)
1473           return m_panic_defer(scanent, NULL,
1474             string_sprintf("bad option '%s'", scanner_options));
1475         cv[0] = cd;
1476         }
1477       else
1478         {
1479         /* Go through the rest of the list of host/port and construct an array
1480          * of servers to try. The first one is the bit we just passed from
1481          * scanner_options so process that first and then scan the remainder of
1482          * the address buffer */
1483         do
1484           {
1485           clamd_address * cd;
1486           const uschar * sublist;
1487           int subsep = ' ';
1488           uschar * s;
1489
1490           /* The 'local' option means use the SCAN command over the network
1491            * socket (ie common file storage in use) */
1492           /*XXX we could accept this also as a local option? */
1493           if (strcmpic(scanner_options, US"local") == 0)
1494             {
1495             use_scan_command = TRUE;
1496             continue;
1497             }
1498
1499           cd = (clamd_address *) store_get(sizeof(clamd_address));
1500
1501           /* extract host and port part */
1502           sublist = scanner_options;
1503           if (!(cd->hostspec = string_nextinlist(&sublist, &subsep, NULL, 0)))
1504             {
1505             (void) m_panic_defer(scanent, NULL,
1506                       string_sprintf("missing address: '%s'", scanner_options));
1507             continue;
1508             }
1509           if (!(s = string_nextinlist(&sublist, &subsep, NULL, 0)))
1510             {
1511             (void) m_panic_defer(scanent, NULL,
1512                       string_sprintf("missing port: '%s'", scanner_options));
1513             continue;
1514             }
1515           cd->tcp_port = atoi(CS s);
1516
1517           /* parse options */
1518           /*XXX should these options be common over scanner types? */
1519           if (clamd_option(cd, sublist, &subsep) != OK)
1520             return m_panic_defer(scanent, NULL,
1521               string_sprintf("bad option '%s'", scanner_options));
1522
1523           cv[num_servers++] = cd;
1524           if (num_servers >= MAX_CLAMD_SERVERS)
1525             {
1526             (void) m_panic_defer(scanent, NULL,
1527                   US"More than " MAX_CLAMD_SERVERS_S " clamd servers "
1528                   "specified; only using the first " MAX_CLAMD_SERVERS_S );
1529             break;
1530             }
1531           } while ((scanner_options = string_nextinlist(&av_scanner_work, &sep,
1532                                         NULL, 0)));
1533
1534         /* check if we have at least one server */
1535         if (!num_servers)
1536           return m_panic_defer(scanent, NULL,
1537             US"no useable server addresses in malware configuration option.");
1538         }
1539
1540       /* See the discussion of response formats below to see why we really
1541       don't like colons in filenames when passing filenames to ClamAV. */
1542       if (use_scan_command && Ustrchr(eml_filename, ':'))
1543         return m_panic_defer(scanent, NULL,
1544           string_sprintf("local/SCAN mode incompatible with" \
1545             " : in path to email filename [%s]", eml_filename));
1546
1547       /* Set up the very first data we will be sending */
1548       if (!use_scan_command)
1549         { cmd_str.data = US"zINSTREAM"; cmd_str.len = 10; }
1550       else
1551         {
1552         cmd_str.data = string_sprintf("SCAN %s\n", eml_filename);
1553         cmd_str.len = Ustrlen(cmd_str.data);
1554         }
1555
1556       /* We have some network servers specified */
1557       if (num_servers)
1558         {
1559         /* Confirmed in ClamAV source (0.95.3) that the TCPAddr option of clamd
1560          * only supports AF_INET, but we should probably be looking to the
1561          * future and rewriting this to be protocol-independent anyway. */
1562
1563         while (num_servers > 0)
1564           {
1565           int i = random_number(num_servers);
1566           clamd_address * cd = cv[i];
1567
1568           DEBUG(D_acl) debug_printf_indent("trying server name %s, port %u\n",
1569                          cd->hostspec, cd->tcp_port);
1570
1571           /* Lookup the host. This is to ensure that we connect to the same IP
1572            * on both connections (as one host could resolve to multiple ips) */
1573           for (;;)
1574             {
1575             /*XXX we trust that the cmd_str is ideempotent */
1576             if ((malware_daemon_ctx.sock = m_tcpsocket(cd->hostspec, cd->tcp_port,
1577                                     &connhost, &errstr, &cmd_str)) >= 0)
1578               {
1579               /* Connection successfully established with a server */
1580               hostname = cd->hostspec;
1581               cmd_str.len = 0;
1582               break;
1583               }
1584             if (cd->retry <= 0) break;
1585             while (cd->retry > 0) cd->retry = sleep(cd->retry);
1586             }
1587           if (malware_daemon_ctx.sock >= 0)
1588             break;
1589
1590           (void) m_panic_defer(scanent, CUS callout_address, errstr);
1591
1592           /* Remove the server from the list. XXX We should free the memory */
1593           num_servers--;
1594           for (; i < num_servers; i++)
1595             cv[i] = cv[i+1];
1596           }
1597
1598         if (num_servers == 0)
1599           return m_panic_defer(scanent, NULL, US"all servers failed");
1600         }
1601       else
1602         for (;;)
1603           {
1604           if ((malware_daemon_ctx.sock = ip_unixsocket(cv[0]->hostspec, &errstr)) >= 0)
1605             {
1606             hostname = cv[0]->hostspec;
1607             break;
1608             }
1609           if (cv[0]->retry <= 0)
1610             return m_panic_defer(scanent, CUS callout_address, errstr);
1611           while (cv[0]->retry > 0) cv[0]->retry = sleep(cv[0]->retry);
1612           }
1613
1614       /* have socket in variable "sock"; command to use is semi-independent of
1615        * the socket protocol.  We use SCAN if is local (either Unix/local
1616        * domain socket, or explicitly told local) else we stream the data.
1617        * How we stream the data depends upon how we were built.  */
1618
1619       if (!use_scan_command)
1620         {
1621         /* New protocol: "zINSTREAM\n" followed by a sequence of <length><data>
1622         chunks, <n> a 4-byte number (network order), terminated by a zero-length
1623         chunk. */
1624
1625         DEBUG(D_acl) debug_printf_indent(
1626             "Malware scan: issuing %s new-style remote scan (zINSTREAM)\n",
1627             scanner_name);
1628
1629         /* Pass the string to ClamAV (10 = "zINSTREAM\0"), if not already sent */
1630         if (cmd_str.len)
1631           if (send(malware_daemon_ctx.sock, cmd_str.data, cmd_str.len, 0) < 0)
1632             return m_panic_defer_3(scanent, CUS hostname,
1633               string_sprintf("unable to send zINSTREAM to socket (%s)",
1634                 strerror(errno)),
1635               malware_daemon_ctx.sock);
1636
1637         /* calc file size */
1638         if ((clam_fd = open(CS eml_filename, O_RDONLY)) < 0)
1639           {
1640           int err = errno;
1641           return m_panic_defer_3(scanent, NULL,
1642             string_sprintf("can't open spool file %s: %s",
1643               eml_filename, strerror(err)),
1644             malware_daemon_ctx.sock);
1645           }
1646         if ((fsize = lseek(clam_fd, 0, SEEK_END)) < 0)
1647           {
1648           int err;
1649 b_seek:   err = errno;
1650           (void)close(clam_fd);
1651           return m_panic_defer_3(scanent, NULL,
1652             string_sprintf("can't seek spool file %s: %s",
1653               eml_filename, strerror(err)),
1654             malware_daemon_ctx.sock);
1655           }
1656         fsize_uint = (unsigned int) fsize;
1657         if ((off_t)fsize_uint != fsize)
1658           {
1659           (void)close(clam_fd);
1660           return m_panic_defer_3(scanent, NULL,
1661             string_sprintf("seeking spool file %s, size overflow",
1662               eml_filename),
1663             malware_daemon_ctx.sock);
1664           }
1665         if (lseek(clam_fd, 0, SEEK_SET) < 0)
1666           goto b_seek;
1667
1668         if (!(clamav_fbuf = US malloc(fsize_uint)))
1669           {
1670           (void)close(clam_fd);
1671           return m_panic_defer_3(scanent, NULL,
1672             string_sprintf("unable to allocate memory %u for file (%s)",
1673               fsize_uint, eml_filename),
1674             malware_daemon_ctx.sock);
1675           }
1676
1677         if ((result = read(clam_fd, clamav_fbuf, fsize_uint)) < 0)
1678           {
1679           int err = errno;
1680           free(clamav_fbuf); (void)close(clam_fd);
1681           return m_panic_defer_3(scanent, NULL,
1682             string_sprintf("can't read spool file %s: %s",
1683               eml_filename, strerror(err)),
1684             malware_daemon_ctx.sock);
1685           }
1686         (void)close(clam_fd);
1687
1688         /* send file body to socket */
1689         send_size = htonl(fsize_uint);
1690         send_final_zeroblock = 0;
1691         if ((send(malware_daemon_ctx.sock, &send_size, sizeof(send_size), 0) < 0) ||
1692             (send(malware_daemon_ctx.sock, clamav_fbuf, fsize_uint, 0) < 0) ||
1693             (send(malware_daemon_ctx.sock, &send_final_zeroblock, sizeof(send_final_zeroblock), 0) < 0))
1694           {
1695           free(clamav_fbuf);
1696           return m_panic_defer_3(scanent, NULL,
1697             string_sprintf("unable to send file body to socket (%s)", hostname),
1698             malware_daemon_ctx.sock);
1699           }
1700
1701         free(clamav_fbuf);
1702         }
1703       else
1704         { /* use scan command */
1705         /* Send a SCAN command pointing to a filename; then in the then in the
1706          * scan-method-neutral part, read the response back */
1707
1708 /* ================================================================= */
1709
1710         /* Prior to the reworking post-Exim-4.72, this scanned a directory,
1711         which dates to when ClamAV needed us to break apart the email into the
1712         MIME parts (eg, with the now deprecated demime condition coming first).
1713         Some time back, ClamAV gained the ability to deconstruct the emails, so
1714         doing this would actually have resulted in the mail attachments being
1715         scanned twice, in the broken out files and from the original .eml.
1716         Since ClamAV now handles emails (and has for quite some time) we can
1717         just use the email file itself. */
1718         /* Pass the string to ClamAV (7 = "SCAN \n" + \0), if not already sent */
1719
1720         DEBUG(D_acl) debug_printf_indent(
1721             "Malware scan: issuing %s local-path scan [%s]\n",
1722             scanner_name, scanner_options);
1723
1724         if (cmd_str.len)
1725           if (send(malware_daemon_ctx.sock, cmd_str.data, cmd_str.len, 0) < 0)
1726             return m_panic_defer_3(scanent, CUS callout_address,
1727               string_sprintf("unable to write to socket (%s)", strerror(errno)),
1728               malware_daemon_ctx.sock);
1729
1730         /* Do not shut down the socket for writing; a user report noted that
1731          * clamd 0.70 does not react well to this. */
1732         }
1733       /* Commands have been sent, no matter which scan method or connection
1734        * type we're using; now just read the result, independent of method. */
1735
1736       /* Read the result */
1737       memset(av_buffer, 0, sizeof(av_buffer));
1738       bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL));
1739       (void)close(malware_daemon_ctx.sock);
1740       malware_daemon_ctx.sock = -1;
1741       malware_daemon_ctx.tls_ctx = NULL;
1742
1743       if (bread <= 0)
1744         return m_panic_defer(scanent, CUS callout_address,
1745           string_sprintf("unable to read from socket (%s)",
1746           errno == 0 ? "EOF" : strerror(errno)));
1747
1748       if (bread == sizeof(av_buffer))
1749         return m_panic_defer(scanent, CUS callout_address,
1750                 US"buffer too small");
1751       /* We're now assured of a NULL at the end of av_buffer */
1752
1753       /* Check the result. ClamAV returns one of two result formats.
1754       In the basic mode, the response is of the form:
1755         infected: -> "<filename>: <virusname> FOUND"
1756         not-infected: -> "<filename>: OK"
1757         error: -> "<filename>: <errcode> ERROR
1758       If the ExtendedDetectionInfo option has been turned on, then we get:
1759         "<filename>: <virusname>(<virushash>:<virussize>) FOUND"
1760       for the infected case.  Compare:
1761 /tmp/eicar.com: Eicar-Test-Signature FOUND
1762 /tmp/eicar.com: Eicar-Test-Signature(44d88612fea8a8f36de82e1278abb02f:68) FOUND
1763
1764       In the streaming case, clamd uses the filename "stream" which you should
1765       be able to verify with { ktrace clamdscan --stream /tmp/eicar.com }.  (The
1766       client app will replace "stream" with the original filename before returning
1767       results to stdout, but the trace shows the data).
1768
1769       We will assume that the pathname passed to clamd from Exim does not contain
1770       a colon.  We will have whined loudly above if the eml_filename does (and we're
1771       passing a filename to clamd). */
1772
1773       if (!(*av_buffer))
1774         return m_panic_defer(scanent, CUS callout_address,
1775                 US"ClamAV returned null");
1776
1777       /* strip newline at the end (won't be present for zINSTREAM)
1778       (also any trailing whitespace, which shouldn't exist, but we depend upon
1779       this below, so double-check) */
1780       p = av_buffer + Ustrlen(av_buffer) - 1;
1781       if (*p == '\n') *p = '\0';
1782
1783       DEBUG(D_acl) debug_printf_indent("Malware response: %s\n", av_buffer);
1784
1785       while (isspace(*--p) && (p > av_buffer))
1786         *p = '\0';
1787       if (*p) ++p;
1788
1789       /* colon in returned output? */
1790       if(!(p = Ustrchr(av_buffer,':')))
1791         return m_panic_defer(scanent, CUS callout_address, string_sprintf(
1792                   "ClamAV returned malformed result (missing colon): %s",
1793                   av_buffer));
1794
1795       /* strip filename */
1796       while (*p && isspace(*++p)) /**/;
1797       vname = p;
1798
1799       /* It would be bad to encounter a virus with "FOUND" in part of the name,
1800       but we should at least be resistant to it. */
1801       p = Ustrrchr(vname, ' ');
1802       result_tag = p ? p+1 : vname;
1803
1804       if (Ustrcmp(result_tag, "FOUND") == 0)
1805         {
1806         /* p should still be the whitespace before the result_tag */
1807         while (isspace(*p)) --p;
1808         *++p = '\0';
1809         /* Strip off the extended information too, which will be in parens
1810         after the virus name, with no intervening whitespace. */
1811         if (*--p == ')')
1812           {
1813           /* "(hash:size)", so previous '(' will do; if not found, we have
1814           a curious virus name, but not an error. */
1815           p = Ustrrchr(vname, '(');
1816           if (p)
1817             *p = '\0';
1818           }
1819         malware_name = string_copy(vname);
1820         DEBUG(D_acl) debug_printf_indent("Malware found, name \"%s\"\n", malware_name);
1821
1822         }
1823       else if (Ustrcmp(result_tag, "ERROR") == 0)
1824         return m_panic_defer(scanent, CUS callout_address,
1825           string_sprintf("ClamAV returned: %s", av_buffer));
1826
1827       else if (Ustrcmp(result_tag, "OK") == 0)
1828         {
1829         /* Everything should be OK */
1830         malware_name = NULL;
1831         DEBUG(D_acl) debug_printf_indent("Malware not found\n");
1832
1833         }
1834       else
1835         return m_panic_defer(scanent, CUS callout_address,
1836           string_sprintf("unparseable response from ClamAV: {%s}", av_buffer));
1837
1838       break;
1839       } /* clamd */
1840 #endif
1841
1842 #ifndef DISABLE_MAL_SOCK
1843     case M_SOCK: /* "sock" scanner type ------------------------------------- */
1844     /* This code was derived by Martin Poole from the clamd code contributed
1845        by David Saez and the cmdline code
1846     */
1847       {
1848       int bread;
1849       uschar * commandline;
1850       uschar av_buffer[1024];
1851       uschar * linebuffer;
1852       uschar * sockline_scanner;
1853       uschar sockline_scanner_default[] = "%s\n";
1854       const pcre *sockline_trig_re;
1855       const pcre *sockline_name_re;
1856
1857       /* find scanner command line */
1858       if (  (sockline_scanner = string_nextinlist(&av_scanner_work, &sep,
1859                                           NULL, 0))
1860          && *sockline_scanner
1861          )
1862       { /* check for no expansions apart from one %s */
1863         uschar * s = Ustrchr(sockline_scanner, '%');
1864         if (s++)
1865           if ((*s != 's' && *s != '%') || Ustrchr(s+1, '%'))
1866             return m_panic_defer_3(scanent, NULL,
1867                                   US"unsafe sock scanner call spec", malware_daemon_ctx.sock);
1868       }
1869       else
1870         sockline_scanner = sockline_scanner_default;
1871       DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "cmdline: ",
1872         string_printing(sockline_scanner));
1873
1874       /* find scanner output trigger */
1875       sockline_trig_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1876                                 "missing trigger specification", &errstr);
1877       if (!sockline_trig_re)
1878         return m_panic_defer_3(scanent, NULL, errstr, malware_daemon_ctx.sock);
1879
1880       /* find virus name regex */
1881       sockline_name_re = m_pcre_nextinlist(&av_scanner_work, &sep,
1882                           "missing virus name regex specification", &errstr);
1883       if (!sockline_name_re)
1884         return m_panic_defer_3(scanent, NULL, errstr, malware_daemon_ctx.sock);
1885
1886       /* prepare scanner call - security depends on expansions check above */
1887       commandline = string_sprintf( CS sockline_scanner, CS eml_filename);
1888       DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "expanded: ",
1889         string_printing(commandline));
1890
1891       /* Pass the command string to the socket */
1892       if (m_sock_send(malware_daemon_ctx.sock, commandline, Ustrlen(commandline), &errstr) < 0)
1893         return m_panic_defer(scanent, CUS callout_address, errstr);
1894
1895       /* Read the result */
1896       bread = ip_recv(&malware_daemon_ctx, av_buffer, sizeof(av_buffer), tmo-time(NULL));
1897
1898       if (bread <= 0)
1899         return m_panic_defer_3(scanent, CUS callout_address,
1900           string_sprintf("unable to read from socket (%s)", strerror(errno)),
1901           malware_daemon_ctx.sock);
1902
1903       if (bread == sizeof(av_buffer))
1904         return m_panic_defer_3(scanent, CUS callout_address,
1905                 US"buffer too small", malware_daemon_ctx.sock);
1906       av_buffer[bread] = '\0';
1907       linebuffer = string_copy(av_buffer);
1908       DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "answer: ",
1909         string_printing(linebuffer));
1910
1911       /* try trigger match */
1912       if (regex_match_and_setup(sockline_trig_re, linebuffer, 0, -1))
1913         {
1914         if (!(malware_name = m_pcre_exec(sockline_name_re, av_buffer)))
1915           malware_name = US "unknown";
1916         DEBUG(D_acl) debug_printf_indent("%15s%10s'%s'\n", "", "name: ",
1917           string_printing(malware_name));
1918         }
1919       else /* no virus found */
1920         malware_name = NULL;
1921       break;
1922       }
1923 #endif
1924
1925 #ifndef DISABLE_MAL_MKS
1926     case M_MKSD: /* "mksd" scanner type ------------------------------------- */
1927       {
1928       char *mksd_options_end;
1929       int mksd_maxproc = 1;  /* default, if no option supplied */
1930       int retval;
1931
1932       if (scanner_options)
1933         {
1934         mksd_maxproc = (int)strtol(CS scanner_options, &mksd_options_end, 10);
1935         if (  *scanner_options == '\0'
1936            || *mksd_options_end != '\0'
1937            || mksd_maxproc < 1
1938            || mksd_maxproc > 32
1939            )
1940           return m_panic_defer(scanent, CUS callout_address,
1941             string_sprintf("invalid option '%s'", scanner_options));
1942         }
1943
1944       if((malware_daemon_ctx.sock = ip_unixsocket(US "/var/run/mksd/socket", &errstr)) < 0)
1945         return m_panic_defer(scanent, CUS callout_address, errstr);
1946
1947       malware_name = NULL;
1948
1949       DEBUG(D_acl) debug_printf_indent("Malware scan: issuing %s scan\n", scanner_name);
1950
1951       if ((retval = mksd_scan_packed(scanent, malware_daemon_ctx.sock, eml_filename, tmo)) != OK)
1952         {
1953         close (malware_daemon_ctx.sock);
1954         return retval;
1955         }
1956       break;
1957       }
1958 #endif
1959
1960 #ifndef DISABLE_MAL_AVAST
1961     case M_AVAST: /* "avast" scanner type ----------------------------------- */
1962       {
1963       uschar buf[1024];
1964       uschar * scanrequest;
1965       enum {AVA_HELO, AVA_OPT, AVA_RSP, AVA_DONE} avast_stage;
1966       int nread;
1967       uschar * error_message = NULL;
1968       BOOL more_data = FALSE;
1969       BOOL strict = TRUE;
1970
1971       /* According to Martin Tuma @avast the protocol uses "escaped
1972       whitespace", that is, every embedded whitespace is backslash
1973       escaped, as well as backslash is protected by backslash.
1974       The returned lines contain the name of the scanned file, a tab
1975       and the [ ] marker.
1976       [+] - not infected
1977       [L] - infected
1978       [E] - some error occured
1979       Such marker follows the first non-escaped TAB.  For more information
1980       see avast-protocol(5)
1981
1982       We observed two cases:
1983       -> SCAN /file
1984       <- /file [E]0.0 Error 13 Permission denied
1985       <- 451 SCAN Engine error 13 permission denied
1986
1987       -> SCAN /file
1988       <- /file… [E]3.0 Error 41120 The file is a decompression bomb
1989       <- /file… [+]2.0
1990       <- /file… [+]2.0 0 Eicar Test Virus!!!
1991       <- 200 SCAN OK
1992
1993       If the scanner returns 4xx, DEFER is a good decision, combined
1994       with a panic log entry, to get the admin's attention.
1995
1996       If the scanner returns 200, we reject it as malware, if found any,
1997       or, in case of an error, we set the malware message to the error
1998       string.
1999
2000       Some of the >= 42000 errors are message related - usually some
2001       broken archives etc, but some of them are e.g. license related.
2002       Once the license expires the engine starts returning errors for
2003       every scanning attempt.  I¹ have the full list of the error codes
2004       but it is not a public API and is subject to change. It is hard
2005       for me to say what you should do in case of an engine error. You
2006       can have a “Treat * unscanned file as infection” policy or “Treat
2007       unscanned file as clean” policy.  ¹) Jakub Bednar
2008
2009        */
2010
2011       if (  (  !ava_re_clean
2012             && !(ava_re_clean = m_pcre_compile(ava_re_clean_str, &errstr)))
2013          || (  !ava_re_virus
2014             && !(ava_re_virus = m_pcre_compile(ava_re_virus_str, &errstr)))
2015          || (  !ava_re_error
2016             && !(ava_re_error = m_pcre_compile(ava_re_error_str, &errstr)))
2017          )
2018         return malware_panic_defer(errstr);
2019
2020       /* wait for result */
2021       for (avast_stage = AVA_HELO;
2022            (nread = recv_line(malware_daemon_ctx.sock, buf, sizeof(buf), tmo)) > 0;
2023           )
2024         {
2025         int slen = Ustrlen(buf);
2026         if (slen >= 1)
2027           {
2028
2029           /* Multi line responses are bracketed between 210 … and nnn … */
2030           if (Ustrncmp(buf, "210", 3) == 0)
2031             {
2032             more_data = 1;
2033             continue;
2034             }
2035           else if (more_data && isdigit(buf[0])) more_data = 0;
2036
2037           switch (avast_stage)
2038             {
2039             case AVA_HELO:
2040               if (more_data) continue;
2041               if (Ustrncmp(buf, "220", 3) != 0)
2042                 goto endloop;                   /* require a 220 */
2043               goto sendreq;
2044
2045             case AVA_OPT:
2046               if (more_data) continue;
2047               if (Ustrncmp(buf, "200", 3) != 0)
2048                 goto endloop;                   /* require a 200 */
2049
2050             sendreq:
2051               {
2052               int len;
2053               /* Check for another option to send. Newline-terminate it. */
2054               if ((scanrequest = string_nextinlist(&av_scanner_work, &sep,
2055                                 NULL, 0)))
2056                 {
2057                 if (Ustrcmp(scanrequest, "pass_unscanned") == 0)
2058                   {
2059                   DEBUG(D_acl) debug_printf_indent("pass unscanned files as clean\n");
2060                   strict = FALSE;
2061                   goto sendreq;
2062                   }
2063                 scanrequest = string_sprintf("%s\n", scanrequest);
2064                 avast_stage = AVA_OPT;          /* just sent option */
2065                 DEBUG(D_acl) debug_printf_indent("send to avast OPTION: %s", scanrequest);
2066                 }
2067               else
2068                 {
2069                 scanrequest = string_sprintf("SCAN %s\n", eml_dir);
2070                 avast_stage = AVA_RSP;          /* just sent command */
2071                 DEBUG(D_acl) debug_printf_indent("send to avast REQUEST: SCAN %s\n", eml_dir);
2072                 }
2073
2074               /* send config-cmd or scan-request to socket */
2075               len = Ustrlen(scanrequest);
2076               if (send(malware_daemon_ctx.sock, scanrequest, len, 0) == -1)
2077                 {
2078                 scanrequest[len-1] = '\0';
2079                 return m_panic_defer_3(scanent, CUS callout_address, string_sprintf(
2080                       "unable to send request '%s' to socket (%s): %s",
2081                       scanrequest, scanner_options, strerror(errno)), malware_daemon_ctx.sock);
2082                 }
2083               break;
2084               }
2085
2086             case AVA_RSP:
2087
2088               if (isdigit(buf[0]))  /* We're done */
2089                 goto endloop;
2090
2091               if (malware_name)     /* Nothing else matters, just read on */
2092                 break;
2093
2094               if (pcre_exec(ava_re_clean, NULL, CS buf, slen, 0, 0, NULL, 0) == 0)
2095                 break;
2096
2097               if ((malware_name = m_pcre_exec(ava_re_virus, buf)))
2098                 {
2099                 unescape(malware_name);
2100                 DEBUG(D_acl)
2101                   debug_printf_indent("unescaped malware name: '%s'\n", malware_name);
2102                 break;
2103                 }
2104
2105               if (strict)           /* treat scanner errors as malware */
2106                 {
2107                 if ((malware_name = m_pcre_exec(ava_re_error, buf)))
2108                   {
2109                   unescape(malware_name);
2110                   DEBUG(D_acl)
2111                     debug_printf_indent("unescaped error message: '%s'\n", malware_name);
2112                   break;
2113                   }
2114                 }
2115               else if (pcre_exec(ava_re_error, NULL, CS buf, slen, 0, 0, NULL, 0) == 0)
2116                 {
2117                 log_write(0, LOG_MAIN, "internal scanner error (ignored): %s", buf);
2118                 break;
2119                 }
2120
2121               /* here also for any unexpected response from the scanner */
2122               DEBUG(D_acl) debug_printf("avast response not handled: '%s'\n", buf);
2123
2124               goto endloop;
2125
2126             default:    log_write(0, LOG_PANIC, "%s:%d:%s: should not happen",
2127                             __FILE__, __LINE__, __FUNCTION__);
2128             }
2129           }
2130         }
2131
2132       endloop:
2133
2134       if (nread == -1) error_message = US"EOF from scanner";
2135       else if (nread < 0) error_message = US"timeout from scanner";
2136       else if (nread == 0) error_message = US"got nothing from scanner";
2137       else if (buf[0] != '2') error_message = buf;
2138
2139       DEBUG(D_acl) debug_printf_indent("sent to avast QUIT\n");
2140       if (send(malware_daemon_ctx.sock, "QUIT\n", 5, 0) == -1)
2141         return m_panic_defer_3(scanent, CUS callout_address,
2142           string_sprintf("unable to send quit request to socket (%s): %s",
2143             scanner_options, strerror(errno)), malware_daemon_ctx.sock);
2144
2145       if (error_message)
2146         return m_panic_defer_3(scanent, CUS callout_address, error_message, malware_daemon_ctx.sock);
2147
2148       }
2149 #endif
2150   }     /* scanner type switch */
2151
2152   if (malware_daemon_ctx.sock >= 0)
2153     (void) close (malware_daemon_ctx.sock);
2154   malware_ok = TRUE;                    /* set "been here, done that" marker */
2155   }
2156
2157 /* match virus name against pattern (caseless ------->----------v) */
2158 if (malware_name && regex_match_and_setup(re, malware_name, 0, -1))
2159   {
2160   DEBUG(D_acl) debug_printf_indent(
2161       "Matched regex to malware [%s] [%s]\n", malware_re, malware_name);
2162   return OK;
2163   }
2164 else
2165   return FAIL;
2166 }
2167
2168
2169 /*************************************************
2170 *          Scan an email for malware             *
2171 *************************************************/
2172
2173 /* This is the normal interface for scanning an email, which doesn't need a
2174 filename; it's a wrapper around the malware_file function.
2175
2176 Arguments:
2177   malware_re  match condition for "malware="
2178   timeout     if nonzero, timeout in seconds
2179
2180 Returns:      Exim message processing code (OK, FAIL, DEFER, ...)
2181               where true means malware was found (condition applies)
2182 */
2183 int
2184 malware(const uschar * malware_re, int timeout)
2185 {
2186 int ret = malware_internal(malware_re, NULL, timeout);
2187
2188 if (ret == DEFER) av_failed = TRUE;
2189 return ret;
2190 }
2191
2192
2193 /*************************************************
2194 *          Scan a file for malware               *
2195 *************************************************/
2196
2197 /* This is a test wrapper for scanning an email, which is not used in
2198 normal processing.  Scan any file, using the Exim scanning interface.
2199 This function tampers with various global variables so is unsafe to use
2200 in any other context.
2201
2202 Arguments:
2203   eml_filename  a file holding the message to be scanned
2204
2205 Returns:        Exim message processing code (OK, FAIL, DEFER, ...)
2206                 where true means malware was found (condition applies)
2207 */
2208 int
2209 malware_in_file(uschar *eml_filename)
2210 {
2211 uschar message_id_buf[64];
2212 int ret;
2213
2214 /* spool_mbox() assumes various parameters exist, when creating
2215 the relevant directory and the email within */
2216
2217 (void) string_format(message_id_buf, sizeof(message_id_buf),
2218     "dummy-%d", vaguely_random_number(INT_MAX));
2219 message_id = message_id_buf;
2220 sender_address = US"malware-sender@example.net";
2221 return_path = US"";
2222 recipients_list = NULL;
2223 receive_add_recipient(US"malware-victim@example.net", -1);
2224 f.enable_dollar_recipients = TRUE;
2225
2226 ret = malware_internal(US"*", eml_filename, 0);
2227
2228 Ustrncpy(spooled_message_id, message_id, sizeof(spooled_message_id));
2229 spool_mbox_ok = 1;
2230
2231 /* don't set no_mbox_unspool; at present, there's no way for it to become
2232 set, but if that changes, then it should apply to these tests too */
2233
2234 unspool_mbox();
2235
2236 /* silence static analysis tools */
2237 message_id = NULL;
2238
2239 return ret;
2240 }
2241
2242
2243 void
2244 malware_init(void)
2245 {
2246 if (!malware_default_re)
2247   malware_default_re = regex_must_compile(malware_regex_default, FALSE, TRUE);
2248
2249 #ifndef DISABLE_MAL_DRWEB
2250 if (!drweb_re)
2251   drweb_re = regex_must_compile(drweb_re_str, FALSE, TRUE);
2252 #endif
2253 #ifndef DISABLE_MAL_FSECURE
2254 if (!fsec_re)
2255   fsec_re = regex_must_compile(fsec_re_str, FALSE, TRUE);
2256 #endif
2257 #ifndef DISABLE_MAL_KAV
2258 if (!kav_re_sus)
2259   kav_re_sus = regex_must_compile(kav_re_sus_str, FALSE, TRUE);
2260 if (!kav_re_inf)
2261   kav_re_inf = regex_must_compile(kav_re_inf_str, FALSE, TRUE);
2262 #endif
2263 #ifndef DISABLE_MAL_AVAST
2264 if (!ava_re_clean)
2265   ava_re_clean = regex_must_compile(ava_re_clean_str, FALSE, TRUE);
2266 if (!ava_re_virus)
2267   ava_re_virus = regex_must_compile(ava_re_virus_str, FALSE, TRUE);
2268 if (!ava_re_error)
2269   ava_re_error = regex_must_compile(ava_re_error_str, FALSE, TRUE);
2270 #endif
2271 #ifndef DISABLE_MAL_FFROT6D
2272 if (!fprot6d_re_error)
2273   fprot6d_re_error = regex_must_compile(fprot6d_re_error_str, FALSE, TRUE);
2274 if (!fprot6d_re_virus)
2275   fprot6d_re_virus = regex_must_compile(fprot6d_re_virus_str, FALSE, TRUE);
2276 #endif
2277 }
2278
2279
2280 void
2281 malware_show_supported(FILE * f)
2282 {
2283 fprintf(f, "Malware:");
2284 for (struct scan * sc = m_scans; sc->scancode != (scanner_t)-1; sc++) fprintf(f, " %s", sc->name);
2285 fprintf(f, "\n");
2286 }
2287
2288
2289 # endif /*!MACRO_PREDEF*/
2290 #endif /*WITH_CONTENT_SCAN*/
2291 /*
2292  * vi: aw ai sw=2
2293  */