smtp.cpp

   1 #include <gflags/gflags.h>
   2 namespace gflags {
   3 }
   4
   5 // These need to be at least the length of any string it's trying to match.
   6 DEFINE_uint64(cmd_bfr_size, 4 * 1024, "command parser buffer size");
   7 DEFINE_uint64(data_bfr_size, 64 * 1024, "data parser buffer size");
   8
   9 DEFINE_uint64(max_xfer_size, 64 * 1024, "maximum BDAT transfer size");
  10
  11 #include <seccomp.h>
  12
  13 #include <fstream>
  14
  15 #include "Session.hpp"
  16 #include "esc.hpp"
  17 #include "fs.hpp"
  18 #include "iobuffer.hpp"
  19 #include "osutil.hpp"
  20
  21 #include <cstdlib>
  22 #include <memory>
  23
  24 #include <signal.h>
  25
  26 #include <tao/pegtl.hpp>
  27 #include <tao/pegtl/contrib/abnf.hpp>
  28
  29 using namespace tao::pegtl;
  30 using namespace tao::pegtl::abnf;
  31
  32 namespace RFC5321 {
  33
  34 struct Ctx {
  35   Session session;
  36
  37   std::string mb_loc;
  38   std::string mb_dom;
  39
  40   std::pair<std::string, std::string>          param;
  41   std::unordered_map<std::string, std::string> parameters;
  42
  43   std::streamsize chunk_size;
  44
  45   Ctx(fs::path config_path, std::function<void(void)> read_hook)
  46     : session(config_path, read_hook)
  47   {
  48   }
  49 };
  50
  51 #include "UTF8.hpp"
  52
  53 // clang-format off
  54
  55 struct quoted_pair : seq<one<'\\'>, sor<VCHAR, WSP>> {};
  56
  57 using dot = one<'.'>;
  58 using colon = one<':'>;
  59 using dash = one<'-'>;
  60
  61 struct u_let_dig : sor<ALPHA, DIGIT, UTF8_non_ascii> {};
  62
  63 struct u_ldh_tail : star<sor<seq<plus<one<'-'>>, u_let_dig>, u_let_dig>> {};
  64
  65 struct u_label : seq<u_let_dig, u_ldh_tail> {};
  66
  67 struct let_dig : sor<ALPHA, DIGIT> {};
  68
  69 struct ldh_tail : star<sor<seq<plus<one<'-'>>, let_dig>, let_dig>> {};
  70
  71 struct ldh_str : seq<let_dig, ldh_tail> {};
  72
  73 // struct label : seq<let_dig, opt<ldh_str>> {};
  74
  75 struct sub_domain : u_label {};
  76
  77 struct domain : list_tail<sub_domain, dot> {};
  78
  79 struct dec_octet : sor<seq<string<'2','5'>, range<'0','5'>>,
  80                        seq<one<'2'>, range<'0','4'>, DIGIT>,
  81                        seq<range<'0', '1'>, rep<2, DIGIT>>,
  82                        rep_min_max<1, 2, DIGIT>> {};
  83
  84 struct IPv4_address_literal
  85     : seq<dec_octet, dot, dec_octet, dot, dec_octet, dot, dec_octet> {};
  86
  87 struct h16 : rep_min_max<1, 4, HEXDIG> {};
  88
  89 struct ls32 : sor<seq<h16, colon, h16>, IPv4_address_literal> {};
  90
  91 struct dcolon : two<':'> {};
  92
  93 struct IPv6address : sor<seq<                                          rep<6, h16, colon>, ls32>,
  94                          seq<                                  dcolon, rep<5, h16, colon>, ls32>,
  95                          seq<opt<h16                        >, dcolon, rep<4, h16, colon>, ls32>,
  96                          seq<opt<h16,     opt<   colon, h16>>, dcolon, rep<3, h16, colon>, ls32>,
  97                          seq<opt<h16, rep_opt<2, colon, h16>>, dcolon, rep<2, h16, colon>, ls32>,
  98                          seq<opt<h16, rep_opt<3, colon, h16>>, dcolon,        h16, colon,  ls32>,
  99                          seq<opt<h16, rep_opt<4, colon, h16>>, dcolon,                     ls32>,
 100                          seq<opt<h16, rep_opt<5, colon, h16>>, dcolon,                      h16>,
 101                          seq<opt<h16, rep_opt<6, colon, h16>>, dcolon                          >> {};
 102
 103 struct IPv6_address_literal : seq<TAO_PEGTL_ISTRING("IPv6:"), IPv6address> {};
 104
 105 struct dcontent : ranges<33, 90, 94, 126> {};
 106
 107 struct standardized_tag : ldh_str {};
 108
 109 struct general_address_literal : seq<standardized_tag, colon, plus<dcontent>> {};
 110
 111 // See rfc 5321 Section 4.1.3
 112 struct address_literal : seq<one<'['>,
 113                              sor<IPv4_address_literal,
 114                                  IPv6_address_literal,
 115                                  general_address_literal>,
 116                              one<']'>> {};
 117
 118 struct at_domain : seq<one<'@'>, domain> {};
 119
 120 // The qtextSMTP rule explained: it's ASCII...
 121 // excluding all the control chars below SPACE
 122 //           34 '"' the double quote
 123 //           92 '\\' the back slash
 124 //           DEL
 125 // So including:
 126 // 32-33:  ' ' and '!'
 127 // 35-91:  "#$%&'()*+,-./" 0-9 ":;<=>?@"  A-Z  '['
 128 // 93-126: "]^_`"  a-z  "{|}~"
 129
 130 struct qtextSMTP : sor<ranges<32, 33, 35, 91, 93, 126>, UTF8_non_ascii> {};
 131
 132 struct graphic : range<32, 126> {};
 133
 134 struct quoted_pairSMTP : seq<one<'\\'>, graphic> {};
 135
 136 struct qcontentSMTP : sor<qtextSMTP, quoted_pairSMTP> {};
 137
 138 struct quoted_string : seq<one<'"'>, plus<qcontentSMTP>, one<'"'>> {};
 139
 140 // excluded from atext are the “specials”: "()<>[]:;@\\,."
 141
 142 struct atext : sor<ALPHA, DIGIT,
 143                    one<'!', '#',
 144                        '$', '%',
 145                        '&', '\'',
 146                        '*', '+',
 147                        '-', '/',
 148                        '=', '?',
 149                        '^', '_',
 150                        '`', '{',
 151                        '|', '}',
 152                        '~'>,
 153                    UTF8_non_ascii> {};
 154
 155 struct atom : plus<atext> {};
 156
 157 struct dot_string : list<atom, dot> {};
 158
 159 struct local_part : sor<dot_string, quoted_string> {};
 160
 161 struct non_local_part : sor<domain, address_literal> {};
 162
 163 struct mailbox : seq<local_part, one<'@'>, non_local_part> {};
 164
 165 struct path : seq<one<'<'>, mailbox, one<'>'>> {};
 166
 167 struct bounce_path : TAO_PEGTL_ISTRING("<>") {};
 168
 169 struct reverse_path : sor<path, bounce_path> {};
 170
 171 struct magic_postmaster : TAO_PEGTL_ISTRING("<Postmaster>") {};
 172
 173 struct forward_path : sor<path, magic_postmaster> {};
 174
 175 struct esmtp_keyword : seq<sor<ALPHA, DIGIT>, star<sor<ALPHA, DIGIT, dash>>> {};
 176
 177 struct esmtp_value : plus<sor<range<33, 60>, range<62, 126>, UTF8_non_ascii>> {};
 178
 179 struct esmtp_param : seq<esmtp_keyword, opt<seq<one<'='>, esmtp_value>>> {};
 180
 181 struct mail_parameters : list<esmtp_param, SP> {};
 182
 183 struct rcpt_parameters : list<esmtp_param, SP> {};
 184
 185 struct string : sor<quoted_string, atom> {};
 186
 187 struct helo : seq<TAO_PEGTL_ISTRING("HELO"),
 188                   SP,
 189                   sor<domain, address_literal>,
 190                   CRLF> {};
 191
 192 struct ehlo : seq<TAO_PEGTL_ISTRING("EHLO"),
 193                   SP,
 194                   sor<domain, address_literal>,
 195                   CRLF> {};
 196
 197 struct mail_from : seq<TAO_PEGTL_ISTRING("MAIL"),
 198                        TAO_PEGTL_ISTRING(" FROM:"),
 199                        opt<SP>, // common enough error, we'll allow it
 200                        reverse_path,
 201                        opt<seq<SP, mail_parameters>>,
 202                        CRLF> {};
 203
 204 struct rcpt_to : seq<TAO_PEGTL_ISTRING("RCPT"),
 205                      TAO_PEGTL_ISTRING(" TO:"),
 206                      opt<SP>, // common error
 207                      forward_path,
 208                      opt<seq<SP, rcpt_parameters>>,
 209                      CRLF> {};
 210
 211 struct chunk_size : plus<DIGIT> {};
 212
 213 struct last : TAO_PEGTL_ISTRING("LAST") {};
 214
 215 struct bdat : seq<TAO_PEGTL_ISTRING("BDAT"), SP, chunk_size, CRLF> {};
 216
 217 struct bdat_last : seq<TAO_PEGTL_ISTRING("BDAT"), SP, chunk_size, SP, last, CRLF> {};
 218
 219 struct data : seq<TAO_PEGTL_ISTRING("DATA"), CRLF> {};
 220
 221 // ## below: DATA sub parse ##
 222
 223 struct data_end : seq<dot, CRLF> {};
 224
 225 struct data_blank : CRLF {};
 226
 227 // This particular crud will trigger an error return with the "no bare
 228 // LF" message.
 229
 230 struct data_not_end : seq<dot, LF> {};
 231
 232 struct data_also_not_end : seq<LF, dot, CRLF> {};
 233
 234
 235 // RFC 5321 text line length section 4.5.3.1.6.
 236 struct data_plain : seq<rep_min_max<1, 998, not_one<'\r', '\n'>>, CRLF> {};
 237
 238 struct data_dot : seq<one<'.'>, rep_min_max<1, 998, not_one<'\r', '\n'>>, CRLF> {};
 239
 240 struct data_long : seq<star<not_one<'\r', '\n'>>, CRLF> {};
 241
 242 struct data_line : seq<sor<data_blank,
 243                            data_not_end,
 244                            data_also_not_end,
 245                            data_dot,
 246                            data_plain,
 247                            data_long>,
 248                        discard> {};
 249
 250 struct data_grammar : until<data_end, data_line> {};
 251
 252 // ## above: DATA sub parse ##
 253
 254 struct rset : seq<TAO_PEGTL_ISTRING("RSET"), CRLF> {};
 255
 256 struct noop : seq<TAO_PEGTL_ISTRING("NOOP"), opt<seq<SP, string>>, CRLF> {};
 257
 258 struct vrfy : seq<TAO_PEGTL_ISTRING("VRFY"), opt<seq<SP, string>>, CRLF> {};
 259
 260 struct help : seq<TAO_PEGTL_ISTRING("HELP"), opt<seq<SP, string>>, CRLF> {};
 261
 262 struct starttls
 263     : seq<TAO_PEGTL_ISTRING("STAR"), TAO_PEGTL_ISTRING("TTLS"), CRLF> {};
 264
 265 struct quit : seq<TAO_PEGTL_ISTRING("QUIT"), CRLF> {};
 266
 267 // Anti-AUTH support
 268
 269 // base64-char     = ALPHA / DIGIT / "+" / "/"
 270 //                   ;; Case-sensitive
 271
 272 struct base64_char : sor<ALPHA, DIGIT, one<'+', '/'>> {};
 273
 274 // base64-terminal = (2base64-char "==") / (3base64-char "=")
 275
 276 struct base64_terminal : sor<seq<rep<2, base64_char>, TAO_PEGTL_ISTRING("==")>,
 277                              seq<rep<3, base64_char>, one<'='>>
 278                              > {};
 279
 280 // base64          = base64-terminal /
 281 //                   ( 1*(4base64-char) [base64-terminal] )
 282
 283 struct base64 : sor<base64_terminal,
 284                     seq<plus<rep<4, base64_char>>,
 285                         opt<base64_terminal>>
 286                     > {};
 287
 288 // initial-response= base64 / "="
 289
 290 struct initial_response : sor<base64, one<'='>> {};
 291
 292 // cancel-response = "*"
 293
 294 struct cancel_response : one<'*'> {};
 295
 296 struct UPPER_ALPHA : range<'A', 'Z'> {};
 297
 298 using HYPHEN = one<'-'>;
 299 using UNDERSCORE = one<'_'>;
 300
 301 struct mech_char : sor<UPPER_ALPHA, DIGIT, HYPHEN, UNDERSCORE> {};
 302 struct sasl_mech : rep_min_max<1, 20, mech_char> {};
 303
 304 // auth-command    = "AUTH" SP sasl-mech [SP initial-response]
 305 //                   *(CRLF [base64]) [CRLF cancel-response]
 306 //                   CRLF
 307 //                   ;; <sasl-mech> is defined in RFC 4422
 308
 309 struct auth : seq<TAO_PEGTL_ISTRING("AUTH"), SP, sasl_mech,
 310                   opt<seq<SP, initial_response>>,
 311                   // star<CRLF, opt<base64>>,
 312                   // opt<seq<CRLF, cancel_response>>,
 313                   CRLF> {};
 314 // bad commands:
 315
 316 struct bogus_cmd_short : seq<rep_min_max<0, 3, not_one<'\r', '\n'>>, CRLF> {};
 317 struct bogus_cmd_long : seq<rep_min_max<4, 1000, not_one<'\r', '\n'>>, CRLF> {};
 318
 319 // commands in size order
 320
 321 struct any_cmd : seq<sor<bogus_cmd_short,
 322                          data,
 323                          quit,
 324                          rset,
 325                          noop,
 326                          vrfy,
 327                          help,
 328                          helo,
 329                          ehlo,
 330                          bdat,
 331                          bdat_last,
 332                          starttls,
 333                          rcpt_to,
 334                          mail_from,
 335                          auth,
 336                          bogus_cmd_long>,
 337                      discard> {};
 338
 339 struct grammar : plus<any_cmd> {};
 340
 341 // clang-format on
 342
 343 template <typename Rule>
 344 struct action : nothing<Rule> {
 345 };
 346
 347 template <typename Rule>
 348 struct data_action : nothing<Rule> {
 349 };
 350
 351 template <>
 352 struct action<bogus_cmd_short> {
 353   template <typename Input>
 354   static void apply(Input const& in, Ctx& ctx)
 355   {
 356     LOG(INFO) << "bogus_cmd_short";
 357     ctx.session.cmd_unrecognized(in.string());
 358   }
 359 };
 360
 361 template <>
 362 struct action<bogus_cmd_long> {
 363   template <typename Input>
 364   static void apply(Input const& in, Ctx& ctx)
 365   {
 366     LOG(INFO) << "bogus_cmd_long";
 367     ctx.session.cmd_unrecognized(in.string());
 368   }
 369 };
 370
 371 template <>
 372 struct action<esmtp_keyword> {
 373   template <typename Input>
 374   static void apply(Input const& in, Ctx& ctx)
 375   {
 376     ctx.param.first = in.string();
 377   }
 378 };
 379
 380 template <>
 381 struct action<esmtp_value> {
 382   template <typename Input>
 383   static void apply(Input const& in, Ctx& ctx)
 384   {
 385     ctx.param.second = in.string();
 386   }
 387 };
 388
 389 template <>
 390 struct action<esmtp_param> {
 391   template <typename Input>
 392   static void apply(Input const& in, Ctx& ctx)
 393   {
 394     ctx.parameters.insert(ctx.param);
 395     ctx.param.first.clear();
 396     ctx.param.second.clear();
 397   }
 398 };
 399
 400 template <>
 401 struct action<local_part> {
 402   template <typename Input>
 403   static void apply(Input const& in, Ctx& ctx)
 404   {
 405     ctx.mb_loc = in.string();
 406     // RFC 5321, section 4.5.3.1.1.
 407     if (ctx.mb_loc.length() > 64) {
 408       LOG(WARNING) << "local part length == " << ctx.mb_loc.length();
 409     }
 410   }
 411 };
 412
 413 template <>
 414 struct action<non_local_part> {
 415   template <typename Input>
 416   static void apply(Input const& in, Ctx& ctx)
 417   {
 418     ctx.mb_dom = in.string();
 419     // RFC 5321, section 4.5.3.1.2.
 420     if (ctx.mb_dom.length() > 255) {
 421       LOG(WARNING) << "domain name or number too long " << ctx.mb_dom;
 422     }
 423   }
 424 };
 425
 426 template <>
 427 struct action<magic_postmaster> {
 428   static void apply0(Ctx& ctx)
 429   {
 430     ctx.mb_loc = std::string{"Postmaster"};
 431     ctx.mb_dom.clear();
 432   }
 433 };
 434
 435 template <>
 436 struct action<helo> {
 437   template <typename Input>
 438   static void apply(Input const& in, Ctx& ctx)
 439   {
 440     auto const b = begin(in) + 5; // +5 for the length of "HELO "
 441     auto const e = std::find(b, end(in) - 2, ' '); // -2 for the CRLF
 442     ctx.session.helo(std::string_view(b, e - b));
 443   }
 444 };
 445
 446 template <>
 447 struct action<ehlo> {
 448   template <typename Input>
 449   static void apply(Input const& in, Ctx& ctx)
 450   {
 451     auto const b = begin(in) + 5; // +5 for the length of "EHLO "
 452     auto const e = std::find(b, end(in) - 2, ' '); // -2 for the CRLF
 453     ctx.session.ehlo(std::string_view(b, e - b));
 454   }
 455 };
 456
 457 template <>
 458 struct action<mail_from> {
 459   static void apply0(Ctx& ctx)
 460   {
 461     ctx.session.mail_from(Mailbox{ctx.mb_loc, ctx.mb_dom}, ctx.parameters);
 462     ctx.mb_loc.clear();
 463     ctx.mb_dom.clear();
 464     ctx.parameters.clear();
 465   }
 466 };
 467
 468 template <>
 469 struct action<rcpt_to> {
 470   static void apply0(Ctx& ctx)
 471   {
 472     ctx.session.rcpt_to(Mailbox{ctx.mb_loc, ctx.mb_dom}, ctx.parameters);
 473     ctx.mb_loc.clear();
 474     ctx.mb_dom.clear();
 475     ctx.parameters.clear();
 476   }
 477 };
 478
 479 template <>
 480 struct action<chunk_size> {
 481   template <typename Input>
 482   static void apply(Input const& in, Ctx& ctx)
 483   {
 484     ctx.chunk_size = std::strtoull(in.string().c_str(), nullptr, 10);
 485   }
 486 };
 487
 488 void bdat_act(Ctx& ctx, bool last)
 489 {
 490   auto status_returned = false;
 491
 492   if (!ctx.session.bdat_start(ctx.chunk_size))
 493     status_returned = true;
 494
 495   auto to_xfer = ctx.chunk_size;
 496
 497   auto const bfr_size{std::min(to_xfer, std::streamsize(FLAGS_max_xfer_size))};
 498   iobuffer<char> bfr(bfr_size);
 499
 500   while (to_xfer) {
 501     auto const xfer_sz{std::min(to_xfer, bfr_size)};
 502
 503     ctx.session.in().read(bfr.data(), xfer_sz);
 504     if (!ctx.session.in()) {
 505       LOG(ERROR) << "attempt to read " << xfer_sz << " octets but only got "
 506                  << ctx.session.in().gcount();
 507       if (ctx.session.maxed_out()) {
 508         LOG(ERROR) << "input maxed out";
 509         if (!status_returned)
 510           ctx.session.bdat_size_error();
 511       }
 512       else if (ctx.session.timed_out()) {
 513         LOG(ERROR) << "input timed out";
 514         if (!status_returned)
 515           ctx.session.bdat_io_error();
 516       }
 517       else if (ctx.session.in().eof()) {
 518         LOG(ERROR) << "EOF in BDAT";
 519         if (!status_returned)
 520           ctx.session.bdat_io_error();
 521       }
 522       else {
 523         LOG(ERROR) << "I/O error in BDAT";
 524         if (!status_returned)
 525           ctx.session.bdat_io_error();
 526       }
 527       return;
 528     }
 529     if (!status_returned && !ctx.session.msg_write(bfr.data(), xfer_sz)) {
 530       status_returned = true;
 531     }
 532
 533     to_xfer -= xfer_sz;
 534   }
 535
 536   if (!status_returned) {
 537     ctx.session.bdat_done(ctx.chunk_size, last);
 538   }
 539 }
 540
 541 template <>
 542 struct action<bdat> {
 543   static void apply0(Ctx& ctx)
 544   {
 545     bdat_act(ctx, false);
 546   }
 547 };
 548
 549 template <>
 550 struct action<bdat_last> {
 551   static void apply0(Ctx& ctx)
 552   {
 553     bdat_act(ctx, true);
 554   }
 555 };
 556
 557 template <>
 558 struct data_action<data_end> {
 559   static void apply0(Ctx& ctx) { ctx.session.data_done(); }
 560 };
 561
 562 template <>
 563 struct data_action<data_blank> {
 564   static void apply0(Ctx& ctx)
 565   {
 566     constexpr char CRLF[]{'\r', '\n'};
 567     ctx.session.msg_write(CRLF, sizeof(CRLF));
 568   }
 569 };
 570
 571 template <>
 572 struct data_action<data_plain> {
 573   template <typename Input>
 574   static void apply(Input const& in, Ctx& ctx)
 575   {
 576     auto const len{end(in) - begin(in)};
 577     ctx.session.msg_write(begin(in), len);
 578   }
 579 };
 580
 581 template <>
 582 struct data_action<data_dot> {
 583   template <typename Input>
 584   static void apply(Input const& in, Ctx& ctx)
 585   {
 586     auto const len{end(in) - begin(in) - 1};
 587     ctx.session.msg_write(begin(in) + 1, len);
 588   }
 589 };
 590
 591 template <>
 592 struct data_action<data_long> {
 593   template <typename Input>
 594   static void apply(Input const& in, Ctx& ctx)
 595   {
 596     LOG(WARNING) << "garbage in data stream: \"" << esc(in.string()) << "\"";
 597     auto const len{end(in) - begin(in)};
 598     if (len)
 599       ctx.session.msg_write(begin(in), len);
 600     if (len > 1000) {
 601       LOG(WARNING) << "line too long at " << len << " octets";
 602     }
 603   }
 604 };
 605
 606 template <>
 607 struct data_action<data_not_end> {
 608   static void apply0(Ctx& ctx) __attribute__((noreturn))
 609   {
 610     ctx.session.bare_lf();
 611   }
 612 };
 613
 614 template <>
 615 struct data_action<data_also_not_end> {
 616   static void apply0(Ctx& ctx) __attribute__((noreturn))
 617   {
 618     ctx.session.bare_lf();
 619   }
 620 };
 621
 622 template <>
 623 struct action<data> {
 624   template <typename Input>
 625   static void apply(Input const& in, Ctx& ctx)
 626   {
 627     if (ctx.session.data_start()) {
 628       auto din = istream_input<eol::crlf, 1>(ctx.session.in(),
 629                                              FLAGS_data_bfr_size, "data");
 630       try {
 631         if (!parse_nested<RFC5321::data_grammar, RFC5321::data_action>(in, din,
 632                                                                        ctx)) {
 633           ctx.session.log_stats();
 634           if (!(ctx.session.maxed_out() || ctx.session.timed_out())) {
 635             ctx.session.error("bad DATA syntax");
 636           }
 637         }
 638         return;
 639       }
 640       catch (parse_error const& e) {
 641         LOG(WARNING) << e.what();
 642         ctx.session.error("unable to parse DATA stream");
 643       }
 644       catch (std::exception const& e) {
 645         LOG(WARNING) << e.what();
 646         ctx.session.error("unknown problem in DATA stream");
 647       }
 648     }
 649   }
 650 };
 651
 652 template <>
 653 struct action<rset> {
 654   static void apply0(Ctx& ctx) { ctx.session.rset(); }
 655 };
 656
 657 template <typename Input>
 658 std::string_view get_string_view(Input const& in)
 659 {
 660   auto const b   = begin(in) + 4;
 661   auto const len = end(in) - b;
 662   auto       str = std::string_view(b, len);
 663   if (str.front() == ' ')
 664     str.remove_prefix(1);
 665   return str;
 666 }
 667
 668 template <>
 669 struct action<noop> {
 670   template <typename Input>
 671   static void apply(Input const& in, Ctx& ctx)
 672   {
 673     auto const str = get_string_view(in);
 674     ctx.session.noop(str);
 675   }
 676 };
 677
 678 template <>
 679 struct action<vrfy> {
 680   template <typename Input>
 681   static void apply(Input const& in, Ctx& ctx)
 682   {
 683     auto const str = get_string_view(in);
 684     ctx.session.vrfy(str);
 685   }
 686 };
 687
 688 template <>
 689 struct action<help> {
 690   template <typename Input>
 691   static void apply(Input const& in, Ctx& ctx)
 692   {
 693     auto const str = get_string_view(in);
 694     ctx.session.help(str);
 695   }
 696 };
 697
 698 template <>
 699 struct action<starttls> {
 700   static void apply0(Ctx& ctx) { ctx.session.starttls(); }
 701 };
 702
 703 template <>
 704 struct action<quit> {
 705   static void apply0(Ctx& ctx) __attribute__((noreturn)) { ctx.session.quit(); }
 706 };
 707
 708 template <>
 709 struct action<auth> {
 710   static void apply0(Ctx& ctx) __attribute__((noreturn)) { ctx.session.auth(); }
 711 };
 712 } // namespace RFC5321
 713
 714 void timeout(int signum) __attribute__((noreturn));
 715 void timeout(int signum)
 716 {
 717   const char errmsg[] = "421 4.4.2 time-out\r\n";
 718   write(STDOUT_FILENO, errmsg, sizeof errmsg - 1);
 719   _Exit(1);
 720 }
 721
 722 void install_syscall_filter()
 723 {
 724   /// scmp_filter_ctx ctx = CHECK_NOTNULL(seccomp_init(SCMP_ACT_ERRNO(EPERM)));
 725   scmp_filter_ctx ctx = CHECK_NOTNULL(seccomp_init(SCMP_ACT_LOG));
 726
 727   auto rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
 728   CHECK_EQ(rc, 0) << "seccomp_rule_add write failed";
 729
 730   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
 731   CHECK_EQ(rc, 0) << "seccomp_rule_add read failed";
 732
 733   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(close), 0);
 734   CHECK_EQ(rc, 0) << "seccomp_rule_add close failed";
 735
 736   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigprocmask), 0);
 737   CHECK_EQ(rc, 0) << "seccomp_rule_add rt_sigprocmask failed";
 738
 739   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigreturn), 0);
 740   CHECK_EQ(rc, 0) << "seccomp_rule_add rt_sigreturn failed";
 741
 742   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rt_sigaction), 0);
 743   CHECK_EQ(rc, 0) << "seccomp_rule_add rt_sigaction failed";
 744
 745   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(newfstatat), 0);
 746   CHECK_EQ(rc, 0) << "seccomp_rule_add newfstatat failed";
 747
 748   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(openat), 0);
 749   CHECK_EQ(rc, 0) << "seccomp_rule_add openat failed";
 750
 751   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(socket), 0);
 752   CHECK_EQ(rc, 0) << "seccomp_rule_add socket failed";
 753
 754   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(connect), 0);
 755   CHECK_EQ(rc, 0) << "seccomp_rule_add connect failed";
 756
 757   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(poll), 0);
 758   CHECK_EQ(rc, 0) << "seccomp_rule_add poll failed";
 759
 760   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sendto), 0);
 761   CHECK_EQ(rc, 0) << "seccomp_rule_add sendto failed";
 762
 763   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(recvfrom), 0);
 764   CHECK_EQ(rc, 0) << "seccomp_rule_add recvfrom failed";
 765
 766   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sigaltstack), 0);
 767   CHECK_EQ(rc, 0) << "seccomp_rule_add sigaltstack failed";
 768
 769   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(prctl), 0);
 770   CHECK_EQ(rc, 0) << "seccomp_rule_add prctl failed";
 771
 772   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(gettid), 0);
 773   CHECK_EQ(rc, 0) << "seccomp_rule_add gettid failed";
 774
 775   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0);
 776   CHECK_EQ(rc, 0) << "seccomp_rule_add getpid failed";
 777
 778   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getppid), 0);
 779   CHECK_EQ(rc, 0) << "seccomp_rule_add getppid failed";
 780
 781   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(newfstatat), 0);
 782   CHECK_EQ(rc, 0) << "seccomp_rule_add newfstatat failed";
 783
 784   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(tgkill), 0);
 785   CHECK_EQ(rc, 0) << "seccomp_rule_add tgkill failed";
 786
 787   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(dup), 0);
 788   CHECK_EQ(rc, 0) << "seccomp_rule_add dup failed";
 789
 790   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mmap), 0);
 791   CHECK_EQ(rc, 0) << "seccomp_rule_add mmap failed";
 792
 793   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(munmap), 0);
 794   CHECK_EQ(rc, 0) << "seccomp_rule_add munmap failed";
 795
 796   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(pipe2), 0);
 797   CHECK_EQ(rc, 0) << "seccomp_rule_add pipe2 failed";
 798
 799   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(readlinkat), 0);
 800   CHECK_EQ(rc, 0) << "seccomp_rule_add readlinkat failed";
 801
 802   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(pselect6), 0);
 803   CHECK_EQ(rc, 0) << "seccomp_rule_add pselect6 failed";
 804
 805   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(uname), 0);
 806   CHECK_EQ(rc, 0) << "seccomp_rule_add uname failed";
 807
 808   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(fcntl), 0);
 809   CHECK_EQ(rc, 0) << "seccomp_rule_add fcntl failed";
 810
 811   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(unlink), 0);
 812   CHECK_EQ(rc, 0) << "seccomp_rule_add unlink failed";
 813
 814   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(symlink), 0);
 815   CHECK_EQ(rc, 0) << "seccomp_rule_add symlink failed";
 816
 817   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(madvise), 0);
 818   CHECK_EQ(rc, 0) << "seccomp_rule_add madvise failed";
 819
 820   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(mprotect), 0);
 821   CHECK_EQ(rc, 0) << "seccomp_rule_add mprotect failed";
 822
 823   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(futex), 0);
 824   CHECK_EQ(rc, 0) << "seccomp_rule_add futex failed";
 825
 826   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(writev), 0);
 827   CHECK_EQ(rc, 0) << "seccomp_rule_add writev failed";
 828
 829   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sysinfo), 0);
 830   CHECK_EQ(rc, 0) << "seccomp_rule_add sysinfo failed";
 831
 832   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0);
 833   CHECK_EQ(rc, 0) << "seccomp_rule_add brk failed";
 834
 835   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getrandom), 0);
 836   CHECK_EQ(rc, 0) << "seccomp_rule_add getrandom failed";
 837
 838   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getdents64), 0);
 839   CHECK_EQ(rc, 0) << "seccomp_rule_add getdents64 failed";
 840
 841   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(lseek), 0);
 842   CHECK_EQ(rc, 0) << "seccomp_rule_add lseek failed";
 843
 844   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(setsockopt), 0);
 845   CHECK_EQ(rc, 0) << "seccomp_rule_add setsockopt failed";
 846
 847   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(alarm), 0);
 848   CHECK_EQ(rc, 0) << "seccomp_rule_add alarm failed";
 849
 850   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(rename), 0);
 851   CHECK_EQ(rc, 0) << "seccomp_rule_add rename failed";
 852
 853   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(clock_gettime), 0);
 854   CHECK_EQ(rc, 0) << "seccomp_rule_add clock_gettime failed";
 855
 856   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);
 857   CHECK_EQ(rc, 0) << "seccomp_rule_add exit_group failed";
 858
 859   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit), 0);
 860   CHECK_EQ(rc, 0) << "seccomp_rule_add exit failed";
 861
 862   // for sanitize
 863
 864   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(clone), 0);
 865   CHECK_EQ(rc, 0) << "seccomp_rule_add clone failed";
 866
 867   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(wait4), 0);
 868   CHECK_EQ(rc, 0) << "seccomp_rule_add wait4 failed";
 869
 870   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sched_yield), 0);
 871   CHECK_EQ(rc, 0) << "seccomp_rule_add sched_yield failed";
 872
 873   rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(ptrace), 0);
 874   CHECK_EQ(rc, 0) << "seccomp_rule_add ptrace failed";
 875
 876   rc = seccomp_load(ctx);
 877   CHECK_EQ(rc, 0) << "seccomp_load failed";
 878
 879   // seccomp_export_pfc(ctx, STDERR_FILENO);
 880
 881   seccomp_release(ctx);
 882 }
 883
 884 int main(int argc, char* argv[])
 885 {
 886   std::ios::sync_with_stdio(false);
 887
 888   { // Need to work with either namespace.
 889     using namespace gflags;
 890     using namespace google;
 891     ParseCommandLineFlags(&argc, &argv, true);
 892   }
 893
 894   // Set timeout signal handler to limit total run time.
 895   struct sigaction sact {};
 896   PCHECK(sigemptyset(&sact.sa_mask) == 0);
 897   sact.sa_flags   = 0;
 898   sact.sa_handler = timeout;
 899   PCHECK(sigaction(SIGALRM, &sact, nullptr) == 0);
 900
 901   auto const log_dir{getenv("GOOGLE_LOG_DIR")};
 902   if (log_dir) {
 903     error_code ec;
 904     fs::create_directories(log_dir, ec);
 905   }
 906
 907   google::InitGoogleLogging(argv[0]);
 908
 909   std::unique_ptr<RFC5321::Ctx> ctx;
 910
 911   // Don't wait for STARTTLS to fail if no cert.
 912   auto const config_path = osutil::get_config_dir();
 913   auto const certs = osutil::list_directory(config_path, Config::cert_fn_re);
 914   CHECK_GE(certs.size(), 1) << "no certs found";
 915
 916   auto const read_hook{[&ctx]() { ctx->session.flush(); }};
 917   ctx = std::make_unique<RFC5321::Ctx>(config_path, read_hook);
 918
 919   ctx->session.greeting();
 920
 921   install_syscall_filter();
 922
 923   istream_input<eol::crlf, 1> in{ctx->session.in(), FLAGS_cmd_bfr_size,
 924                                  "session"};
 925
 926   int ret = 0;
 927   try {
 928     ret = !parse<RFC5321::grammar, RFC5321::action>(in, *ctx);
 929   }
 930   catch (std::exception const& e) {
 931     LOG(WARNING) << e.what();
 932   }
 933
 934   if (ctx->session.maxed_out()) {
 935     ctx->session.max_out();
 936   }
 937   else if (ctx->session.timed_out()) {
 938     ctx->session.time_out();
 939   }
 940   // else {
 941   //   ctx->session.error("session end without QUIT command from client");
 942   // }
 943
 944   return ret;
 945 }