rubymta 0.0.1

data/lib/rubymta/server.rb

@@ -0,0 +1,306 @@
+require 'logger'
+require 'socket'
+require 'ostruct'
+require 'optparse'
+require 'openssl'
+require 'sequel'
+require 'sqlite3'
+require 'etc'
+require 'pretty_inspect'
+
+class Terminate < Exception; end
+class Quit < Exception; end
+
+# Set up the $app hash for systemwide parameters
+$app = {}
+$app[:path] = Dir::pwd
+$app[:mode] = ENV['MODE']
+
+require './config'
+include Config
+$app[:uinfo] = Etc::getpwnam(UserName) if UserName
+$app[:ginfo] = Etc::getgrnam(GroupName) if GroupName
+
+require_relative 'receiver'
+
+# get setup and open the log
+LOG = Logger::new(LogPathAndFile, LogFileLife)
+LOG.formatter = proc do |severity, datetime, progname, msg|
+  pname = if progname then '('+progname+') ' else nil end
+  "#{datetime.strftime("%Y-%m-%d %H:%M:%S")} [#{severity}] #{pname}#{msg}\n"
+end
+
+# Make sure the MODE environmental variable is valid
+if ['dev','live'].index(ENV['MODE']).nil?
+  msg = "Environmental variable MODE not set properly--must be dev or live"
+  LOG.fatal(msg)
+  puts msg
+  exit(1)
+end
+
+# set the owner of the LOG file to UserName and
+# GroupName--this is because otherwise, a new log file
+# will be created as root:root, and run_queue won't be
+# able to open it--this only is needed if 'server' is
+# running as root; same for the sqlite database
+if !UserName.nil?
+  File::chown($app[:uinfo].uid, $app[:ginfo].gid, LogPathAndFile)
+  File::chown($app[:uinfo].uid, $app[:ginfo].gid, S3DBPath)
+end
+
+# Open the sqlite3 database for rubymta use
+S3DB = Sequel.connect("sqlite://#{S3DBPath}")
+LOG.info("Database '#{S3DBPath}' opened")
+
+# Create the tables we need if they don't already exist
+
+# The contacts table is just used to count the number of 'hits' for
+# a particular IP address in order to choose between sending an
+# "Access TEMPORARILY denied" or just slam the port shut
+S3DB::create_table?(:contacts) do
+  primary_key(:id)
+  string(:remote_ip)
+  integer(:hits)
+  integer(:locks)
+  integer(:violations)
+  datetime(:expires_at)
+  datetime(:created_at)
+  datetime(:updated_at)
+  index(:remote_ip)
+end
+
+# The queue table is used to track the emails server/receiver receive. The
+# queue runner will read this queue and attempt to deliver the emails.
+S3DB::create_table?(:parcels) do
+  primary_key(:id)
+  string(:mail_id)
+  string(:from_url)
+  string(:to_url)
+  string(:delivery) # 'local' or 'remote'
+  datetime(:delivery_at)
+  text(:delivery_msg)
+  datetime(:retry_at)
+  datetime(:created_at)
+  datetime(:updated_at)
+  index([:mail_id,:from_url])
+  index([:mail_id,:to_url])
+end
+
+# load the DKIM private key for this domain, if any
+$app[:dkim] = nil
+File::open(DKIMPrivateKeyFile, "r") { |f| $app[:dkim] = f.read } if DKIMPrivateKeyFile
+
+# MAIN server class -- starts at Server#start
+class Server
+
+  include Socket::Constants
+
+#  def restart
+#    # handle a HUP request here
+#  end
+
+  # this is the code executed after the process has been
+  # forked and root privileges have been dropped
+  def process_call(connection, local_port, remote_port, remote_ip, remote_hostname, remote_service)
+    begin
+      Signal.trap("INT") { } # ignore ^C in the child process
+      LOG.info("%06d"%Process::pid) {"Connection accepted on port #{local_port} from port #{remote_port} at #{remote_ip} (#{remote_hostname})"}
+
+      # a new object is created here to provide separation between server and receiver
+      # this call receives the email and does basic validation
+      Receiver::new(connection).receive(local_port, Socket::gethostname, remote_port, remote_hostname, remote_ip)
+    rescue Quit
+      # nothing to do here
+    ensure
+      # close the database (the child's copy)
+      S3DB.disconnect if S3DB
+      nil # don't return the Receiver object
+    end
+  end
+
+  # this method drops the process's root privileges for security reasons
+  def drop_root_privileges
+    if Process::Sys.getuid==0
+      Dir.chdir($app[:path]) if not $app[:path].nil?
+      Process::GID.change_privilege($app[:ginfo].gid)
+      Process::UID.change_privilege($app[:uinfo].uid)
+    end
+  end
+
+  # both the AF_INET and AF_INET6 families use this DRY method
+  def bind_socket(family,port,ip)
+    socket = Socket.new(family, SOCK_STREAM, 0)
+    sockaddr = Socket.sockaddr_in(port.to_i,ip)
+    socket.setsockopt(:SOCKET, :REUSEADDR, true)
+    socket.bind(sockaddr)
+    socket.listen(0)
+    return socket
+  end
+
+  # the listening thread is established in this method depending on the ListenPort
+  # argument passed to it -- it can be '<ipv6>/<port>', '<ipv4>:<port>', or just '<port>'
+  def listening_thread(local_port)
+    LOG.info("%06d"%Process::pid) {"listening on port #{local_port}..."}
+
+    # establish an SSL context
+    $ctx = OpenSSL::SSL::SSLContext.new
+    $ctx.key = $prv
+    $ctx.cert = $crt
+    
+    # check the parameter to see if it's valid
+    m = /^(([0-9a-fA-F]{0,4}:{0,1}){1,8})\/([0-9]{1,5})|(([0-9]{1,3}\.{0,1}){4}):([0-9]{1,5})|([0-9]{1,5})$/.match(local_port)
+    #<MatchData "2001:4800:7817:104:be76:4eff:fe05:3b18/2000" 1:"2001:4800:7817:104:be76:4eff:fe05:3b18" 2:"3b18" 3:"2000" 4:nil 5:nil 6:nil 7:nil>
+    #<MatchData "23.253.107.107:2000" 1:nil 2:nil 3:nil 4:"23.253.107.107" 5:"107" 6:"2000" 7:nil>
+    #<MatchData "2000" 1:nil 2:nil 3:nil 4:nil 5:nil 6:nil 7:"2000">
+    case
+      when !m[1].nil? # its AF_INET6
+        socket = bind_socket(AF_INET6,m[3],m[1])
+      when !m[4].nil? # its AF_INET
+        socket = bind_socket(AF_INET,m[6],m[4])
+      when !m[7].nil?
+        socket = bind_socket(AF_INET6,m[7],"0:0:0:0:0:0:0:0")
+      else
+        raise ArgumentError.new(local_port)
+    end
+    ssl_server = OpenSSL::SSL::SSLServer.new(socket, $ctx);
+
+    # main listening loop starts in non-encrypted mode
+    ssl_server.start_immediately = false
+    loop do
+      # we can't use threads because if we drop root privileges on any thread,
+      # they will be dropped for all threads in the process--so we have to fork
+      # a process here in order that the reception be able to drop root privileges
+      # and run at a user level--this is a security precaution
+      connection = ssl_server.accept
+      Process::fork do
+        begin
+          drop_root_privileges if !UserName.nil?
+          remote_hostname, remote_service = connection.io.remote_address.getnameinfo
+          remote_ip, remote_port = connection.io.remote_address.ip_unpack
+          process_call(connection, local_port, remote_port.to_s, remote_ip, remote_hostname, remote_service)
+          LOG.info("%06d"%Process::pid) {"Connection closed on port #{local_port} by #{ServerName}"}
+        rescue Errno::ENOTCONN => e
+          LOG.info("%06d"%Process::pid) {"Remote Port scan on port #{local_port}"}
+        ensure
+          # here we close the child's copy of the connection --
+          # since the parent already closed it's copy, this
+          # one will send a FIN to the client, so the client
+          # can terminate gracefully
+          connection.close
+          # and finally, close the child's link to the log
+          LOG.close
+        end
+      end
+      # here we close the parent's copy of the connection --
+      # the child (created by the Process::fork above) has another copy --
+      # if this one is not closed, when the child closes it's copy,
+      # the child's copy won't send a FIN to the client -- the FIN
+      # is only sent when the last process holding a copy to the
+      # socket closes it's copy
+      connection.close
+    end
+  end
+
+  # this method parses the command line options
+  def process_options
+    options = OpenStruct.new
+    options.log = Logger::INFO
+    options.daemonize = false
+    begin
+      OptionParser.new do |opts|
+        opts.on("--debug",  "Log all messages")     { |v| options.log = Logger::DEBUG }
+        opts.on("--info",   "Log all messages")     { |v| options.log = Logger::INFO }
+        opts.on("--warn",   "Log all messages")     { |v| options.log = Logger::WARN }
+        opts.on("--error",  "Log all messages")     { |v| options.log = Logger::ERROR }
+        opts.on("--fatal",  "Log all messages")     { |v| options.log = Logger::FATAL }
+        opts.on("--daemonize", "Run as system daemon") { |v| options.daemonize = true }
+      end.parse!
+    rescue OptionParser::InvalidOption => e
+      LOG.warn("%06d"%Process::pid) {"#{e.inspect}"}
+    end
+    options
+  end # process_options
+
+  def start
+    # generate the first log messages
+    LOG.info("%06d"%Process::pid) {"Starting RubyMTA at #{Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")}, pid=#{Process::pid}"}
+    LOG.info("%06d"%Process::pid) {"Options specified: #{ARGV.join(", ")}"} if ARGV.size>0
+
+    # get the options from the command line
+    @options = process_options
+    LOG.level = @options.log
+
+    # get the certificates, if any; they're needed for STARTTLS
+    # we do this before daemonizing because the working folder might change
+    $prv = if PrivateKey then OpenSSL::PKey::RSA.new File.read(PrivateKey) else nil end
+    $crt = if Certificate then OpenSSL::X509::Certificate.new File.read(Certificate) else nil end
+
+    # daemonize it if the option was set--it doesn't have to be root to daemonize it
+    Process::daemon if @options.daemonize
+
+    # get the process ID and the user id AFTER demonizing, if that was requested
+    pid = Process::pid
+    uid = Process::Sys.getuid
+    gid = Process::Sys.getgid
+    
+    LOG.info("%06d"%Process::pid) {"Daemonized at #{Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")}, pid=#{pid}, uid=#{uid}, gid=#{gid}"} #if @options.daemonize
+
+    # store the pid of the server session
+    begin
+      LOG.info("%06d"%Process::pid) {"RubyMTA running as PID=>#{pid}, UID=>#{uid}, GID=>#{gid}"}
+      File::open("#{PidPath}/rubymta.pid","w") { |f| f.write(pid.to_s) }
+    rescue Errno::EACCES => e
+      LOG.warn("%06d"%Process::pid) {"The pid couldn't be written. To save the pid, create a directory '#{PidPath}' with r/w permissions for this user."}
+      LOG.warn("%06d"%Process::pid) {"Proceeding without writing the pid."}
+    end
+
+    # if rubymta was started as root, make sure UserName and
+    # GroupName have values because we have to drop root privileges
+    # after we fork a process for the receiver
+    if uid==0 # it's root
+      if UserName.nil? || GroupName.nil?
+        LOG.error("%06d"%Process::pid) {"rubymta can't be started as root unless UserName and GroupName are set."}
+        exit(1)
+      end
+    end
+
+    # this is the main loop which runs until admin enters ^C
+    Signal.trap("INT") { raise Terminate.new }
+    Signal.trap("HUP") { restart if defined?(restart) }
+    Signal.trap("CHLD") do
+      begin
+      Process.wait(-1, Process::WNOHANG)
+      rescue Errno::ECHILD => e
+        # ignore the error
+      end
+    end
+    threads = []
+    # start the server on multiple ports (the usual case)
+    begin
+      ListeningPorts.each do |port|
+        threads << Thread.start(port) do |port|
+          listening_thread(port)
+        end
+      end
+      # the joins are done ONLY after all threads are started
+      threads.each { |thread| thread.join }
+    rescue Terminate
+      LOG.info("%06d"%Process::pid) {"#{ServerName} terminated by admin ^C"}
+    end
+
+  ensure
+
+    # attempt to remove the pid file
+    begin
+      File.delete("#{PidPath}/rubymta.pid")
+    rescue Errno::ENOENT => e
+      LOG.warn("%06d"%Process::pid) {"No such file: #{e.inspect}"}
+    rescue Errno::EACCES, Errno::EPERM
+      LOG.warn("%06d"%Process::pid) {"Permission denied: #{e.inspect}"}
+    end
+
+    # close the log
+    LOG.close if LOG
+  end
+
+end

data/lib/rubymta/version.rb

@@ -0,0 +1,5 @@
+module Version
+  VERSION = "0.0.1"
+  MODIFIED = "2017-07-29"
+end
+

data/lib/rubymta.rb

@@ -0,0 +1,2 @@
+require_relative "rubymta/version"
+require_relative "rubymta/server"

data/rubymta.gemspec

@@ -0,0 +1,15 @@
+require_relative 'lib/rubymta/version'
+include Version
+Gem::Specification.new do |s|
+  s.author        = "Michael J. Welch, Ph.D."
+  s.files         = Dir.glob(["CHANGELOG.md", "LICENSE.md", "README.md", "rubymta.gemspec", "lib/*", "lib/rubymta/*", "spec/*", ".gitignore"])
+  s.name          = 'rubymta'
+  s.require_paths = ["lib"]
+  s.summary       = "A Ruby Gem providing a complete Mail Transport Agent package."
+  s.version       = VERSION
+  s.date          = MODIFIED
+  s.email         = 'mjwelchphd@gmail.com'
+  s.homepage      = 'http://rubygems.org/gems/rubymta'
+  s.license       = 'MIT'
+  s.description   = "RubyMta is an experimental mail transport agent written in Ruby. See the README."
+end

data/spec/coco

@@ -0,0 +1,3 @@
+coco@tzarmail.com
+my-password
+

data/spec/rubymta.rb

@@ -0,0 +1,199 @@
+#require "bacon"
+require 'sequel'
+require "sqlite3"
+
+Sender = "mjwelchphd@gmail.com"
+Recipient = "coco@tzarmail.com"
+S3DBPath = "gmta-dev.db"
+RemoteIP = "2001:4800:7811:513:be76:4eff:fe04:f0b4"
+EhloDomainRequired = true
+
+
+# Open the sqlite3 database for rubymta use
+S3DB = Sequel.connect("sqlite://#{S3DBPath}")
+
+# swaks -tls -s mail.tzarmail.com:25 -t mike@tzarmail.com -f mjwelchphd@gmail.com --ehlo bluecrapduck345at789zappo.com
+
+# {:id=>5, :remote_ip=>"::ffff:107.185.187.182", :hits=>142, :locks=>1, :violations=>1,
+#  :expires_at=>2017-07-07 22:44:52 +0000, :created_at=>2017-05-22 19:58:51 +0000,
+#  :updated_at=>2017-07-07 22:41:11 +0000}
+ds = S3DB[:contacts].where(:remote_ip=>RemoteIP)
+
+describe "Rubymta Gem 'contacts table' Tests" do
+
+  # be sure we can set/reset the contacts table
+  it "reset the test contact record" do
+    ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+    rs = ds.select(:locks, :violations).first
+    (rs.inspect).should.be.equal "{:locks=>0, :violations=>0}"
+  end
+
+  # send a simple email just as a sanity check
+  it "the MTA should accept a simple email" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t #{Recipient} -f #{Sender}`
+    ok = response.index("250 2.0.0 OK id=")
+    ok.should.not.equal 0
+  end
+
+  # 1st violation -- reject a relay attempt
+  it "1st violation -- reject a relay attempt" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t mike.w@tzarmail.com -f #{Sender}`
+    ok = response.index("556 5.7.27 Czar Mail does not support relaying")
+    ok.should.not.equal 0
+  end
+
+  # the first failure should have set violations=1
+  it "should have 1 violation" do
+    rs = ds.select(:locks, :violations).first
+    (rs.inspect).should.be.equal "{:locks=>0, :violations=>1}"
+  end
+
+  # 2nd violation -- reject a relay attempt
+  it "2nd violation -- reject a relay attempt" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t mike.w@tzarmail.com -f #{Sender}`
+    ok = response.index("556 5.7.27 Czar Mail does not support relaying")
+    ok.should.not.equal 0
+  end
+
+  # the second failure should have set violations=2
+  it "should have 2 violations" do
+    rs = ds.select(:locks, :violations).first
+    (rs.inspect).should.be.equal "{:locks=>0, :violations=>2}"
+  end
+
+  # 3rd violation -- reject a relay attempt
+  it "3rd violation -- reject a relay attempt" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t mike.w@tzarmail.com -f #{Sender}`
+    ok = response.index("556 5.7.27 Czar Mail does not support relaying")
+    ok.should.not.equal 0
+  end
+
+  # the third failure should have set violations=3
+  it "should have 3 violations" do
+    rs = ds.select(:locks, :violations).first
+    (rs.inspect).should.be.equal "{:locks=>0, :violations=>3}"
+  end
+
+  # the 4th violation should respond with a message and set the lock
+  it "the 4th violation should set the lock" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t mike.w@tzarmail.com -f #{Sender}`
+    ok = response.index("454 4.7.1 Access TEMPORARILY denied")
+    ok.should.not.equal 0
+  end
+
+  # the fourth failure should have set violations=4 and locks=1
+  it "should have 4 violations and 1 lock" do
+    rs = ds.select(:locks, :violations).first
+    (rs.inspect).should.be.equal "{:locks=>1, :violations=>4}"
+  end
+
+  # the 5th (and following) violations should have to door slammed
+  it "5th violation -- slam the connection shut" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t mike.w@tzarmail.com -f #{Sender}`
+    ok = response.end_with?("=== Connected to mail.tzarmail.com.\n")
+    ok.inspect.should.equal "true"
+  end
+
+  # the 5th failure doesn't change the lock or violations
+  it "5th failure should still have 4 violations and 1 lock" do
+    rs = ds.select(:locks, :violations).first
+    (rs.inspect).should.be.equal "{:locks=>1, :violations=>4}"
+  end
+
+end
+
+describe "Rubymta Gem EHLO Tests" do
+
+  if EhloDomainRequired
+    ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+    it "EHLO requires a domain" do
+      response = `swaks -tls -s mail.tzarmail.com:25 -t #{Recipient} -f #{Sender} --ehlo 'not-valid-domain'`
+      ok = response.index("454 4.7.1 Access TEMPORARILY denied")
+      ok.should.not.equal 0
+    end
+
+    ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+    it "the EHLO domain must be found in the DNS" do
+      response = `swaks -tls -s mail.tzarmail.com:25 -t #{Recipient} -f #{Sender} --ehlo 'domain-not-in-dns.lost'`
+      ok = response.index("was not found in the DNS system")
+      ok.should.not.equal 0
+    end
+  end
+
+end
+
+describe "Rubymta Gem MAIL FROM Tests" do
+
+  ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+  it "the MAIL FROM line must have a sender" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t #{Recipient} -f mr-nobody`
+    ok = response.index("No proper sender (<...>) on the MAIL part line")
+    ok.should.not.equal 0
+  end
+
+  ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+  it "the MAIL FROM sender cannot have '.' as the first character" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t #{Recipient} -f .dennis@gmail.com`
+    ok = response.index("550 5.1.7 beginning or ending '.' or 2 or more '.'s in a row")
+    ok.should.not.equal 0
+  end
+
+  ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+  it "the MAIL FROM sender cannot have '.' as the last character" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t #{Recipient} -f dennis.@gmail.com`
+    ok = response.index("550 5.1.7 beginning or ending '.' or 2 or more '.'s in a row")
+    ok.should.not.equal 0
+  end
+
+  ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+  it "the MAIL FROM sender cannot have two '.'s in a row" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t #{Recipient} -f dennis..george@gmail.com`
+    ok = response.index("550 5.1.7 beginning or ending '.' or 2 or more '.'s in a row")
+    ok.should.not.equal 0
+  end
+
+  # send a MAIL FROM <a member>
+  ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+  it "the MTA expects member mail on port 587" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t #{Sender} -f #{Recipient}`
+    ok = response.index("556 5.7.27 Czar Mail members must use port 587 to send mail")
+    ok.should.not.equal 0
+  end
+
+  ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+  it "traffic on port 587 must be authenticated" do
+    response = `swaks -tls -s mail.tzarmail.com:587 -t #{Sender} -f #{Recipient}`
+    ok = response.index("556 5.7.27 Traffic on port 587 must be authenticated")
+    ok.should.not.equal 0
+  end
+
+  ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+  it "traffic on port 587 needs to be encrypted" do
+    response = `swaks -a PLAIN -s mail.tzarmail.com:587 -t #{Sender} -f #{Recipient} < spec/coco`
+    ok = response.index("556 5.7.27 Traffic on port 587 must be encrypted")
+    ok.should.not.equal 0
+  end
+
+  # send mail from a <non-member>
+  ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+  it "the MTA expects non-member mail on port 25" do
+    response = `swaks -tls -s mail.tzarmail.com:587 -t #{Recipient} -f #{Sender}`
+    ok = response.index("556 5.7.27 Non Czar Mail members must use port 25 to send mail")
+    ok.should.not.equal 0
+  end
+
+end
+
+describe "Rubymta Gem RCPT TO Tests" do
+
+  ds.update(:locks=>0, :violations=>0, :expires_at=>Time.now)
+  it "the RCPT TO line must have a recipient" do
+    response = `swaks -tls -s mail.tzarmail.com:25 -t mrs-nobody -f #{Sender}`
+    ok = response.index("No proper recipient (<...>) on the RCPT part line")
+    ok.should.not.equal 0
+  end
+
+end
+
+# There is only 1 unreachable test in DATA (I think it's unreachable),
+# so the DATA tests here have been omitted.

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: rubymta
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael J. Welch, Ph.D.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-29 00:00:00.000000000 Z
+dependencies: []
+description: RubyMta is an experimental mail transport agent written in Ruby. See
+  the README.
+email: mjwelchphd@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- README.md
+- lib/rubymta.rb
+- lib/rubymta/base-x.rb
+- lib/rubymta/contact.rb
+- lib/rubymta/deepclone.rb
+- lib/rubymta/extended_classes.rb
+- lib/rubymta/item_of_mail.rb
+- lib/rubymta/queue_runner.rb
+- lib/rubymta/receiver.rb
+- lib/rubymta/server.rb
+- lib/rubymta/version.rb
+- rubymta.gemspec
+- spec/coco
+- spec/rubymta.rb
+homepage: http://rubygems.org/gems/rubymta
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A Ruby Gem providing a complete Mail Transport Agent package.
+test_files: []