smtp/conn.go

   1 package smtp
   2
   3 import (
   4         "crypto/rand"
   5         "crypto/tls"
   6         "fmt"
   7         "net"
   8         "net/mail"
   9         "net/textproto"
  10         "strings"
  11         "time"
  12
  13         "github.com/uber-go/zap"
  14 )
  15
  16 type state int
  17
  18 const (
  19         stateNew state = iota // Before EHLO.
  20         stateInitial
  21         stateMail
  22         stateRecipient
  23         stateData
  24 )
  25
  26 type connection struct {
  27         server Server
  28
  29         tp *textproto.Conn
  30
  31         nc         net.Conn
  32         tlsNc      *tls.Conn
  33         remoteAddr net.Addr
  34
  35         esmtp bool
  36
  37         log zap.Logger
  38
  39         state
  40         line string
  41
  42         ehlo     string
  43         mailFrom *mail.Address
  44         rcptTo   []mail.Address
  45 }
  46
  47 func AcceptConnection(netConn net.Conn, server Server, log zap.Logger) {
  48         conn := connection{
  49                 server:     server,
  50                 tp:         textproto.NewConn(netConn),
  51                 nc:         netConn,
  52                 remoteAddr: netConn.RemoteAddr(),
  53                 log:        log.With(zap.Stringer("client", netConn.RemoteAddr())),
  54                 state:      stateNew,
  55         }
  56
  57         conn.writeReply(220, fmt.Sprintf("%s ESMTP [%s] (mailpopbox)", server.Name(), netConn.LocalAddr()))
  58
  59         for {
  60                 var err error
  61                 conn.line, err = conn.tp.ReadLine()
  62                 if err != nil {
  63                         conn.log.Error("ReadLine()", zap.Error(err))
  64                         conn.tp.Close()
  65                         break
  66                 }
  67
  68                 conn.log.Info("ReadLine()", zap.String("line", conn.line))
  69
  70                 var cmd string
  71                 if _, err = fmt.Sscanf(conn.line, "%s", &cmd); err != nil {
  72                         conn.reply(ReplyBadSyntax)
  73                         continue
  74                 }
  75
  76                 switch strings.ToUpper(cmd) {
  77                 case "QUIT":
  78                         conn.writeReply(221, "Goodbye")
  79                         conn.tp.Close()
  80                         break
  81                 case "HELO":
  82                         conn.esmtp = false
  83                         fallthrough
  84                 case "EHLO":
  85                         conn.esmtp = true
  86                         conn.doEHLO()
  87                 case "STARTTLS":
  88                         conn.doSTARTTLS()
  89                 case "MAIL":
  90                         conn.doMAIL()
  91                 case "RCPT":
  92                         conn.doRCPT()
  93                 case "DATA":
  94                         conn.doDATA()
  95                 case "RSET":
  96                         conn.doRSET()
  97                 case "VRFY":
  98                         conn.writeReply(252, "I'll do my best")
  99                 case "EXPN":
 100                         conn.writeReply(550, "access denied")
 101                 case "NOOP":
 102                         conn.reply(ReplyOK)
 103                 case "HELP":
 104                         conn.writeReply(250, "https://tools.ietf.org/html/rfc5321")
 105                 default:
 106                         conn.writeReply(500, "unrecognized command")
 107                 }
 108         }
 109 }
 110
 111 func (conn *connection) reply(reply ReplyLine) error {
 112         return conn.writeReply(reply.Code, reply.Message)
 113 }
 114
 115 func (conn *connection) writeReply(code int, msg string) error {
 116         conn.log.Info("writeReply", zap.Int("code", code))
 117         var err error
 118         if len(msg) > 0 {
 119                 err = conn.tp.PrintfLine("%d %s", code, msg)
 120         } else {
 121                 err = conn.tp.PrintfLine("%d", code)
 122         }
 123         if err != nil {
 124                 conn.log.Error("writeReply",
 125                         zap.Int("code", code),
 126                         zap.Error(err))
 127         }
 128         return err
 129 }
 130
 131 // parsePath parses out either a forward-, reverse-, or return-path from the
 132 // current connection line. Returns a (valid-path, ReplyOK) if it was
 133 // successfully parsed.
 134 func (conn *connection) parsePath(command string) (string, ReplyLine) {
 135         if len(conn.line) < len(command) {
 136                 return "", ReplyBadSyntax
 137         }
 138         if strings.ToUpper(command) != strings.ToUpper(conn.line[:len(command)]) {
 139                 return "", ReplyLine{500, "unrecognized command"}
 140         }
 141         return conn.line[len(command):], ReplyOK
 142 }
 143
 144 func (conn *connection) doEHLO() {
 145         conn.resetBuffers()
 146
 147         var cmd string
 148         _, err := fmt.Sscanf(conn.line, "%s %s", &cmd, &conn.ehlo)
 149         if err != nil {
 150                 conn.reply(ReplyBadSyntax)
 151                 return
 152         }
 153
 154         if cmd == "HELO" {
 155                 conn.writeReply(250, fmt.Sprintf("Hello %s [%s]", conn.ehlo, conn.remoteAddr))
 156         } else {
 157                 conn.tp.PrintfLine("250-Hello %s [%s]", conn.ehlo, conn.remoteAddr)
 158                 if conn.server.TLSConfig() != nil && conn.tlsNc == nil {
 159                         conn.tp.PrintfLine("250-STARTTLS")
 160                 }
 161                 conn.tp.PrintfLine("250 SIZE %d", 40960000)
 162         }
 163
 164         conn.log.Info("doEHLO()", zap.String("ehlo", conn.ehlo))
 165
 166         conn.state = stateInitial
 167 }
 168
 169 func (conn *connection) doSTARTTLS() {
 170         if conn.state != stateInitial {
 171                 conn.reply(ReplyBadSequence)
 172                 return
 173         }
 174
 175         tlsConfig := conn.server.TLSConfig()
 176         if !conn.esmtp || tlsConfig == nil {
 177                 conn.writeReply(500, "unrecognized command")
 178                 return
 179         }
 180
 181         conn.log.Info("doSTARTTLS()")
 182         conn.writeReply(220, "initiate TLS connection")
 183
 184         newConn := tls.Server(conn.nc, tlsConfig)
 185         if err := newConn.Handshake(); err != nil {
 186                 return
 187         }
 188
 189         conn.tlsNc = newConn
 190         conn.tp = textproto.NewConn(conn.tlsNc)
 191         conn.state = stateInitial
 192
 193         conn.log.Info("HELO again")
 194
 195         conn.writeReply(220, fmt.Sprintf("%s ESMTPS [%s] (mailpopbox)",
 196                 conn.server.Name(), newConn.LocalAddr()))
 197 }
 198
 199 func (conn *connection) doMAIL() {
 200         if conn.state != stateInitial {
 201                 conn.reply(ReplyBadSequence)
 202                 return
 203         }
 204
 205         mailFrom, reply := conn.parsePath("MAIL FROM:")
 206         if reply != ReplyOK {
 207                 conn.reply(reply)
 208                 return
 209         }
 210
 211         var err error
 212         conn.mailFrom, err = mail.ParseAddress(mailFrom)
 213         if err != nil {
 214                 conn.reply(ReplyBadSyntax)
 215                 return
 216         }
 217
 218         conn.log.Info("doMAIL()", zap.String("address", conn.mailFrom.Address))
 219
 220         conn.state = stateMail
 221         conn.reply(ReplyOK)
 222 }
 223
 224 func (conn *connection) doRCPT() {
 225         if conn.state != stateMail && conn.state != stateRecipient {
 226                 conn.reply(ReplyBadSequence)
 227                 return
 228         }
 229
 230         rcptTo, reply := conn.parsePath("RCPT TO:")
 231         if reply != ReplyOK {
 232                 conn.reply(reply)
 233                 return
 234         }
 235
 236         address, err := mail.ParseAddress(rcptTo)
 237         if err != nil {
 238                 conn.reply(ReplyBadSyntax)
 239         }
 240
 241         if reply := conn.server.VerifyAddress(*address); reply != ReplyOK {
 242                 conn.log.Warn("invalid address",
 243                         zap.String("address", address.Address),
 244                         zap.Stringer("reply", reply))
 245                 conn.reply(reply)
 246                 return
 247         }
 248
 249         conn.log.Info("doRCPT()", zap.String("address", address.Address))
 250
 251         conn.rcptTo = append(conn.rcptTo, *address)
 252
 253         conn.state = stateRecipient
 254         conn.reply(ReplyOK)
 255 }
 256
 257 func (conn *connection) doDATA() {
 258         if conn.state != stateRecipient {
 259                 conn.reply(ReplyBadSequence)
 260                 return
 261         }
 262
 263         conn.writeReply(354, "Start mail input; end with <CRLF>.<CRLF>")
 264         conn.log.Info("doDATA()")
 265
 266         data, err := conn.tp.ReadDotBytes()
 267         if err != nil {
 268                 conn.log.Error("failed to ReadDotBytes()",
 269                         zap.Error(err),
 270                         zap.String("bytes", fmt.Sprintf("%x", data)))
 271                 conn.writeReply(552, "transaction failed")
 272                 return
 273         }
 274
 275         received := time.Now()
 276         env := Envelope{
 277                 RemoteAddr: conn.remoteAddr,
 278                 EHLO:       conn.ehlo,
 279                 MailFrom:   *conn.mailFrom,
 280                 RcptTo:     conn.rcptTo,
 281                 Received:   received,
 282                 ID:         conn.envelopeID(received),
 283         }
 284
 285         conn.log.Info("received message",
 286                 zap.Int("bytes", len(data)),
 287                 zap.Time("date", received),
 288                 zap.String("id", env.ID))
 289
 290         trace := conn.getReceivedInfo(env)
 291
 292         env.Data = append(trace, data...)
 293
 294         if reply := conn.server.OnMessageDelivered(env); reply != nil {
 295                 conn.log.Warn("message was rejected", zap.String("id", env.ID))
 296                 conn.reply(*reply)
 297                 return
 298         }
 299
 300         conn.state = stateInitial
 301         conn.reply(ReplyOK)
 302 }
 303
 304 func (conn *connection) envelopeID(t time.Time) string {
 305         var idBytes [4]byte
 306         rand.Read(idBytes[:])
 307         return fmt.Sprintf("m.%d.%x", t.UnixNano(), idBytes)
 308 }
 309
 310 func (conn *connection) getReceivedInfo(envelope Envelope) []byte {
 311         rhost, _, err := net.SplitHostPort(conn.remoteAddr.String())
 312         if err != nil {
 313                 rhost = conn.remoteAddr.String()
 314         }
 315
 316         rhosts, err := net.LookupAddr(rhost)
 317         if err == nil {
 318                 rhost = fmt.Sprintf("%s [%s]", rhosts[0], rhost)
 319         }
 320
 321         base := fmt.Sprintf("Received: from %s (%s)\r\n        ", conn.ehlo, rhost)
 322
 323         with := "SMTP"
 324         if conn.esmtp {
 325                 with = "E" + with
 326         }
 327         if conn.tlsNc != nil {
 328                 with += "S"
 329         }
 330         base += fmt.Sprintf("by %s (mailpopbox) with %s id %s\r\n        ", conn.server.Name(), with, envelope.ID)
 331
 332         base += fmt.Sprintf("for <%s>\r\n        ", envelope.RcptTo[0].Address)
 333
 334         transport := conn.getTransportString()
 335         date := envelope.Received.Format(time.RFC1123Z) // Same as RFC 5322 § 3.3
 336         base += fmt.Sprintf("(using %s);\r\n        %s\r\n", transport, date)
 337
 338         return []byte(base)
 339 }
 340
 341 func (conn *connection) getTransportString() string {
 342         if conn.tlsNc == nil {
 343                 return "PLAINTEXT"
 344         }
 345
 346         ciphers := map[uint16]string{
 347                 tls.TLS_RSA_WITH_RC4_128_SHA:                "TLS_RSA_WITH_RC4_128_SHA",
 348                 tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA:           "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
 349                 tls.TLS_RSA_WITH_AES_128_CBC_SHA:            "TLS_RSA_WITH_AES_128_CBC_SHA",
 350                 tls.TLS_RSA_WITH_AES_256_CBC_SHA:            "TLS_RSA_WITH_AES_256_CBC_SHA",
 351                 tls.TLS_RSA_WITH_AES_128_GCM_SHA256:         "TLS_RSA_WITH_AES_128_GCM_SHA256",
 352                 tls.TLS_RSA_WITH_AES_256_GCM_SHA384:         "TLS_RSA_WITH_AES_256_GCM_SHA384",
 353                 tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA:        "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",
 354                 tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA:    "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
 355                 tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:    "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
 356                 tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA:          "TLS_ECDHE_RSA_WITH_RC4_128_SHA",
 357                 tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA:     "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
 358                 tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA:      "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
 359                 tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:      "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",
 360                 tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:   "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
 361                 tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
 362                 tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:   "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
 363                 tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384: "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
 364         }
 365         versions := map[uint16]string{
 366                 tls.VersionSSL30: "SSLv3.0",
 367                 tls.VersionTLS10: "TLSv1.0",
 368                 tls.VersionTLS11: "TLSv1.1",
 369                 tls.VersionTLS12: "TLSv1.2",
 370         }
 371
 372         state := conn.tlsNc.ConnectionState()
 373
 374         version := versions[state.Version]
 375         cipher := ciphers[state.CipherSuite]
 376
 377         if version == "" {
 378                 version = fmt.Sprintf("%x", state.Version)
 379         }
 380         if cipher == "" {
 381                 cipher = fmt.Sprintf("%x", state.CipherSuite)
 382         }
 383
 384         name := ""
 385         if state.ServerName != "" {
 386                 name = fmt.Sprintf(" name=%s", state.ServerName)
 387         }
 388
 389         return fmt.Sprintf("%s cipher=%s%s", version, cipher, name)
 390 }
 391
 392 func (conn *connection) doRSET() {
 393         conn.log.Info("doRSET()")
 394         conn.state = stateInitial
 395         conn.resetBuffers()
 396         conn.reply(ReplyOK)
 397 }
 398
 399 func (conn *connection) resetBuffers() {
 400         conn.mailFrom = nil
 401         conn.rcptTo = make([]mail.Address, 0)
 402 }