schleuder 2.2.0

data/lib/schleuder/archiver.rb

@@ -0,0 +1,46 @@
+module Schleuder
+  class Archiver
+    def archive(mail)
+      Schleuder.log.info "Archiving email"
+      mail2archive = mail.individualize_member(_receiver)
+
+      # TODO: wrap that duplicated code out into it's dedicated method
+      begin
+        encrypted, errmsg = mail2archive.encrypt!(_receiver)
+      rescue GPGME::Error::UnusablePublicKey => e
+        # This exception is thrown, if the public key of a certain list
+        # member is not usable (because it is revoked, expired, disabled or
+        # invalid).
+        k = e.keys.first
+        key = mail2archive.crypt.get_key(k.fpr).first
+        errmsg = "#{e.message}: (#{k.class})\n#{key.to_s}"
+        encrypted = false
+      rescue GPGME::Error::General => e
+        errmsg = e.message
+        encrypted = false
+      end
+
+      if encrypted
+        _dump(mail2archive)
+      else
+        Schleuder.log.error("Could not encrypt message with list's key to archive it. Skipping archiving of message...\n\nError Message: #{errmsg}")
+      end
+    end
+
+    private
+
+    def _dump(mail)
+      now = Time.now
+      dump_dir = File.join(Schleuder.list.listdir,'archive',[:year,:month,:day].collect{|m| now.send(m).to_s })
+      require 'fileutils'
+      FileUtils.mkdir_p dump_dir unless File.directory? dump_dir
+      msg_file = File.join(dump_dir,"#{Time.now.strftime('%H%M%S')}-#{mail.message_id[1..-2]}")
+      Schleuder.log.info("Archiving message to #{msg_file}")
+      File.open(msg_file,"w") { |f| f << mail.to_s }
+    end
+
+    def _receiver
+      @receiver ||= Member.new('email' => Schleuder.list.config.myaddr)
+    end
+  end
+end

data/lib/schleuder/crypt.rb

@@ -0,0 +1,188 @@
+module Schleuder
+    # Wrapper for ruby-gpgme. Method naming is not strictly logical, this might
+    # change but aliases will be set up then.
+    class Crypt
+      # Instantiates and stores password
+      def initialize(password)
+        # Check file permissions. ruby-gpgme unfortunately returns unspecific
+        # errors if it can't read files.
+        %w(pubring.gpg secring.gpg trustdb.gpg).each do |fn|
+          f = File.join(ENV['GNUPGHOME'], fn)
+          if ! File.readable?(f)
+            raise Errno::EACCES.new('%s is not readable' % f)
+          elsif ! File.writable?(f)
+            raise Errno::EACCES.new('%s is not writable' % f)
+          end
+        end
+
+        @password = password
+        if GPGME.respond_to? 'check_version'
+          GPGME::check_version('0.0.0')
+        end
+        @ctx = GPGME::Ctx.new
+        # feed the passphrase into the Context
+        @ctx.set_passphrase_cb(method(:passfunc))		
+      end
+
+      # Verify a gpg-signature. Use +signed_string+ if the signature is
+      # detached. Returns a GPGME::SignatureResult
+      def verify(sig, signed_string='')
+        in_signed = ''
+        if signed_string.empty?
+          # verify +sig+ as cleartext (aka pgp/inline) signature
+          Schleuder.log.debug 'No extra signed_string, verifying cleartext signature'
+          output = GPGME.verify(sig) do |sig|
+            in_signed = sig
+          end
+        else
+          # verify detached signature
+          Schleuder.log.debug 'Verifying detached signature'
+          # Don't know why we need a GPGME::Data object this time but without gpgme throws exceptions
+          plain = GPGME::Data.new
+          GPGME.verify(sig, signed_string, plain) do |sig|
+            in_signed = sig
+          end
+          output = signed_string
+          
+        end
+        Schleuder.log.debug 'verify_result: ' + in_signed.inspect
+        
+        [output, in_signed]
+      end
+      
+      # Decrypt a string.
+      def decrypt(str)
+        output = ""
+        in_encrypted = nil
+        in_signed = nil
+        
+        # TODO: return ciphertext if missing key. Sensible e.g. if it is part
+        # of a nested MIME-message and encrypted to someone else on purpose.
+        # Breaking if even the whole message is not decryptable is a job for
+        # the processor.
+        
+        # return input instead of empty String if not encrypted.
+        # String#content_type is provided by filemagic/ext.
+        unless str =~ /^-----BEGIN PGP MESSAGE-----/ || str.content_type.split('/').last.eql?('pgp')
+            output, in_signed = verify(str)
+          # match pgp-mime- and inline-pgp-signatures
+          if str =~ /^-----BEGIN PGP SIG/
+            Schleuder.log.debug 'found signed, not encrypted message, verifying'
+            output, in_signed = verify(str)
+          else
+            Schleuder.log.debug 'found not signed, not encrypted message, returning input'
+            output = str
+          end
+        else
+          Schleuder.log.debug 'found pgp content, decrypting and verifying with gpgme'
+          in_encrypted = true
+          output = GPGME.decrypt(str, :passphrase_callback => method(:passfunc)) do |sig|
+            in_signed = sig
+          end
+          if output.empty?
+            Exception.new("Output from GPGME.decrypt was empty!")
+          end
+          # TODO: return mailadresses or keys instead of signature-objects?
+        end
+        [output, in_encrypted, in_signed]
+      end
+      
+      # Encrypt a string to a single receiver and sign it. +receiver+ must be a
+      # Schleuder::Member
+      def encrypt_str(str, receiver)
+        # encrypt and sign and return encrypted data as string
+        # For some reason sometimes the last two characters of str are stolen
+        # unless we append a blank or newline... Life is hard...
+        GPGME.encrypt([receiver.key],
+                      "#{str} ",
+                      {:passphrase_callback => method(:passfunc),
+                       :armor => true,
+                       :sign => true,
+                       :always_trust => true
+                      })
+      end
+      
+      # Lists all public keys matching +pattern+. Returns an array of
+      # GPGME::GpgKey's
+      def list_keys(pattern='')
+        GPGME.list_keys(pattern)
+      end
+
+      # Returns the GPGME::GpgKey matching +pattern+. Log an error if more than
+      # one matches, because duplicated user-ids is a sensitive issue.
+      def get_key(pattern, only_valid_keys=false)
+        pattern = "<#{pattern}>" if pattern =~ /.*@.*/ && !(pattern =~ /^<.*>$/)
+        keys = list_keys(pattern)
+
+        keys.reject! { |key| [:revoked,:expired].include?(key.trust) } if only_valid_keys
+
+        if keys.empty?
+          [false, "no key found for #{pattern}."]
+        elsif keys.length > 1
+          Schleuder.log.warn "There's more than one key matching the pattern you gave me!"
+          Schleuder.log.debug { "Pattern: #{pattern.inspect}" }
+          Schleuder.log.debug { "Keys: #{keys.inspect}" }
+          [false, "no distinct key for #{pattern.inspect} found. Matching keys: #{key_infos(keys,only_valid_keys).join(', ')}"]
+        else
+          [keys.first]
+        end
+      end
+      
+      # Signs +string+ with the private key of the list (aka detached signature)
+      def sign(string)
+        GPGME::detach_sign(string, {:armor => true, :passphrase_callback => method(:passfunc)})
+      end
+
+      # Clearsigns +string+ with the private key of the list
+      def clearsign(string)
+        GPGME::clearsign(string, {:armor => true, :passphrase_callback => method(:passfunc)})
+      end
+      
+      # Exports the public key matching +keyid+ as ascii key block.
+      def export(keyid)
+        GPGME.export(keyid, :armor=>:true)
+      end
+      
+      # Delete the public key matching +pattern+ from the public key ring of the
+      # list
+      def delete_key(key)
+        msg = nil
+        key, msg = get_key(key) if key.kind_of?(String)
+
+        if key
+          @ctx.delete_key(key)
+          return true
+        else
+          msg
+        end
+      rescue => e
+        return e
+      end
+      
+      # Import +keydata+ into public key ring of the list
+      def add_key(keydata)
+        GPGME.import(keydata)
+      end
+
+      def add_key_from_file(keyfile)
+        add_key(File.read(keyfile))
+      end
+
+      def key_descr(key)
+        key.to_s.split("\n").first.split[1..2].join(' ')
+      end
+
+      private
+
+      def key_infos(keys, only_valid_keys=false)
+        keys.collect { |key| key_descr(key) + (!only_valid_keys && [:revoked, :expired].include?(key.trust)) ? " *#{key.trust}*" : '' }
+      end
+
+      def passfunc(hook, uid_hint, passphrase_info, prev_was_bad, fd)
+        io = IO.for_fd(fd, 'w')
+        io.puts @password
+        io.flush
+      end
+
+    end
+end

data/lib/schleuder/errors.rb

@@ -0,0 +1,5 @@
+
+class SchleuderError < RuntimeError 
+end
+class NewListError < SchleuderError 
+end

data/lib/schleuder/list.rb

@@ -0,0 +1,177 @@
+module Schleuder
+  # Represents a single list: name, config, members.
+  class List
+    # Name of this list. Must match the name of the subdirectory in
+    # +SchleuderConfig::lists_dir+
+    attr_reader :listname
+    
+    # Prepare some variables, set up the SchleuderLogger and set GNUPGHOME
+    def initialize(listname,newlist=false)
+      @listname = listname
+      @config = _load_config(false) if newlist
+      @log = ListLogger.new listname, listdir, config
+      
+      # setting GNUPGHOME to list's home, to make use of the keys there
+      Schleuder.log.debug "setting ENV[GNUPGHOME] to #{listdir}"
+      ENV["GNUPGHOME"] = listdir
+      @members = nil
+    end
+    
+    # Provides an array of Schleuder::Member's, read from +members.conf+
+    def members
+      unless @members
+        Schleuder.log.debug("reading #{members_file}")
+        @members = YAML::load_file(members_file).collect do |h|
+          h.kind_of?(Schleuder::Member) ? h : Schleuder::Member.new(h,false)
+        end
+      end
+      @members
+    end
+
+    def members_file
+      @members_file ||= File.join(listdir, Schleuder.config.lists_memberfile)
+    end
+    
+    # Saves an array of Schleuder::Member's into +members.conf++
+    def members=(arr)
+      Schleuder.log.debug 'writing members'
+      Schleuder.log.info("writing #{members_file}")
+      @members = arr.collect { |m| m.kind_of?(Hash) ? Member.new(m,false) : m }
+      _write(YAML.dump(@members.collect { |m| m.to_hash }), members_file)
+      @members
+    end
+    
+    # Finds a member by email address.
+    def find_member_by_email(addresses)
+      addresses = Array(addresses)
+      members.detect { |m| addresses.include?(m.email) } || false
+    end
+
+    def find_admin_by_email(addresses)
+      addresses = Array(addresses)
+      if admin_email = self.config.admins.detect { |a| addresses.include?(a.email) }
+        Member.new(:email => admin_email)
+      else
+        false
+      end
+    end
+
+    def find_member_by_key(key)
+      Schleuder.log.debug "Looking for member for key #{key}"
+      find_by_key(members, key)
+    end
+
+    def find_admin_by_key(key)
+      Schleuder.log.debug "Looking for admin for key #{key}"
+      find_by_key(config.admins, key)
+    end
+
+    def find_admin_by_address(address)
+      config.admins.detect { |admin| admin.email == address }
+    end
+
+    def find_member_by_address(address)
+      members.detect { |member| member.email == address }
+    end
+
+    # Provides the list config as Schleuder::ListConfig-object 
+    def config
+      @config ||= _load_config
+    end
+
+    # Saves +data+ into the list-config-file (default: list.conf). +data+ must
+    # be a Schleuder::ListConfig or valid input to +ListConfig.new+
+    def config=(data)
+      Schleuder.log.info("writing list-config for: #{listname}")
+      if data.is_a?(ListConfig)
+        @config = data
+      else
+        @config = ListConfig.new(data)
+      end
+      _write(YAML::dump(@config.to_hash), File.join(listdir, Schleuder.config.lists_configfile))
+      @config
+    end
+    
+    # Builds the bounce-address for the list
+    def bounce_addr
+      @bounce_addr ||= self.config.myaddr.gsub(/^(.*)@(.*)$/, '\1-bounce@\2')
+    end
+
+    # Builds the owner-address for the list
+    def owner_addr
+      @owner_addr ||= self.config.myaddr.gsub(/^(.*)@(.*)$/, '\1-owner@\2')
+    end
+
+    # Builds the request-address for the list
+    def request_addr
+      @request_addr ||= self.config.myaddr.gsub(/^(.*)@(.*)$/, '\1-request@\2')
+    end
+
+    # builds the send-key-command-address for the list
+    def sendkey_addr
+      self.config.myaddr.gsub(/^(.*)@(.*)$/, '\1-sendkey@\2')
+    end
+
+    def self.listdir(listname)
+      name = listname.split('@')
+      if name.size < 2
+        Schleuder.log.warn 'Listname should be a full email-address, using only the local part is deprecated. Please fix this!'
+      end
+      File.expand_path(File.join([Schleuder.config.lists_dir, name.reverse].flatten))
+    end
+
+    def listdir
+      @listdir ||=  List.listdir(@listname)
+    end
+
+    def listid
+      @listid ||= config.myaddr.gsub(/@/, '.')
+    end
+
+    def key
+      @key ||= lookup_list_key
+    end
+
+    def key_fingerprint
+      key.subkeys.first.fingerprint
+    end
+
+    def archive(mail)
+      @list_archiver ||= Schleuder::Archiver.new
+      @list_archiver.archive(mail)
+    end
+
+    private
+
+    # Loads the configuration
+    # fromfile = Whether to load the config from file.
+    def _load_config(fromfile=true)
+        Schleuder.log.debug("reading list-config for: #{@listname}") unless Schleuder.log.nil?
+        @config = ListConfig.new(File.join(listdir, Schleuder.config.lists_configfile),fromfile)
+    end
+
+    def find_by_key(ary, key)
+      return false unless key.kind_of?(GPGME::Key)
+      res = ary.detect { |elem| elem.kind_of?(Member) && elem.uses_key?(key) }
+      Schleuder.log.debug "Found #{res} for #{key}" unless res.nil?
+      res || false
+    end
+
+    def _write(data,filename)
+      File.open(filename, 'w') { |f| f << data }
+    end
+
+    def lookup_list_key
+      key, msg = crypt.get_key(config.key_fingerprint||config.myaddr)
+      unless key
+        raise "Could not find a key for this List! Reason: #{msg}"
+      end
+      key
+    end
+
+    def crypt
+      @@crypt ||= Crypt.new(nil)
+    end
+
+  end
+end

data/lib/schleuder/list_config.rb

@@ -0,0 +1,146 @@
+# the list config class - a simple container
+
+module Schleuder
+  class ListConfig < Storage
+
+    # Options and their defaults
+    # If you want to change the defaults, edit conf/default-list.conf
+
+    # Emailaddress of the list
+    schleuder_attr :myaddr, ''
+
+    # Realname of this list address (mainly used for gpg key)
+    schleuder_attr :myname, ''
+
+    # Listadmin's emailaddress(es). Must be an array.
+    schleuder_attr :admins, []
+
+    # Default mime setting
+    schleuder_attr :default_mime, 'MIME'
+
+    # The gpg password
+    schleuder_attr :gpg_password, nil
+
+    # The fingerprint of the key used for this list
+    schleuder_attr :key_fingerprint, nil
+
+    # Wether sending emails in the clear is allowed or not.
+    schleuder_attr :send_encrypted_only, false
+
+    # Wether to accept only incoming emails that are encrypted
+    schleuder_attr :receive_encrypted_only, false
+
+    # Wether to accept only emails that are validly signed
+    schleuder_attr :receive_signed_only, false
+
+    # Wether to accept only emails that are validly signed by a list-member's key
+    schleuder_attr :receive_authenticated_only, false
+
+    # Wether to accept only emails that are validly signed by a list-admin's key
+    schleuder_attr :receive_admin_only, false
+
+    # Whether to accept only emails that are sent from a members address.
+    # NOTE: better rely on :receive_authenticated_only and ignore that option.
+    schleuder_attr :receive_from_member_emailaddresses_only, false
+
+    # Wether to keep the msgid or not
+    schleuder_attr :keep_msgid, true
+
+    # Footer for outgoing mails
+    schleuder_attr :public_footer, ''
+
+    # Subject prefix for incoming (signed) mails from listmembers
+    schleuder_attr :prefix, ''
+
+    # Subject prefix for incoming mails
+    schleuder_attr :prefix_in, ''
+
+    # Subject prefix for outgoing mails
+    schleuder_attr :prefix_out, ''
+
+    # The log_level (ERROR || WARN || INFO || DEBUG)
+    schleuder_attr :log_level, 'ERROR'
+
+    # Log to SYSLOG?
+    schleuder_attr :log_syslog, false
+
+    # Log to IO (writing into STDIN of another process/executable)
+    schleuder_attr :log_io, false
+
+    # Log to a file? If the path doesn't start with a slash the list-dir will
+    # be prefixed.
+    schleuder_attr :log_file, 'list.log'
+
+    # Which headers from original mail to include into the internal meta data
+    schleuder_attr :headers_to_meta, [:from, :to, :cc, :date]
+
+    # Restrict specific plugins to admin
+    schleuder_attr :keywords_admin_only,  ['SAVE-MEMBERS', 'DEL-KEY']
+
+    # Notify admin if these keywords triggered commands.
+    schleuder_attr :keywords_admin_notify, [ 'X-ADD-KEY' ]
+
+    # Drop any bounces (incoming email not passing the receive_*_only-rules)
+    schleuder_attr :bounces_drop_all, false
+
+    # Drop bounces if they match one of these headers. Must be a hash, keys and values are case insensitive.
+    schleuder_attr :bounces_drop_on_headers,  {'x-spam-flag' => 'yes'}
+
+    # Send a notice to admin(s) on bouncing or dropping
+    schleuder_attr :bounces_notify_admin, true
+
+    # Include RFC-compliant List-* Headers into member mails
+    schleuder_attr :include_list_headers, true
+
+    # Include OpenPGP-Header
+    schleuder_attr :include_openpgp_header, true
+    # Preferred way to receive emails to note in OpenPGP-Header ('sign'|'encrypt'|'signencrypt'|'unprotected'|'none')
+    # 'none' to not include a preference
+    # default: 'signencrypt'
+    schleuder_attr :openpgp_header_preference, 'signencrypt'
+
+    # If we want to dump the original incoming mail.
+    # ATTENTION: this stores the incoming e-mail on disk!
+    schleuder_attr :dump_incoming_mail, false
+
+    # Maximum size of message allowed on the list in kilobyte. All others will be bounced.
+    schleuder_attr :max_message_size, 10240 # 10MB
+
+    # Whether to archive messages sent to list members or not.
+    # default: false
+    schleuder_attr :archive, false
+
+    ### END OF CONFIG OPTIONS
+
+    def initialize(config_file, fromfile=true)
+      # First Overload with default-list.conf then load our config
+      overload_from_file!(Schleuder.config.lists_default_conf)
+      # overload with config_file
+      super(config_file, fromfile)
+
+      # load admins as members
+      self.admins = self.admins
+      # compress fingerprint
+      self.key_fingerprint = self.key_fingerprint
+    end
+
+    def key_fingerprint=(fpr)
+      schleuder_attributes['key_fingerprint'] = Schleuder::Utils.compress_fingerprint(fpr)
+    end
+
+    def admins=(ary)
+      schleuder_attributes['admins'] = Array(ary).collect { |mem|
+        if mem.kind_of?(Member)
+          mem
+        else
+          if mem.kind_of?(Hash) && mem.has_key?("email")
+            Member.new(mem)
+          else
+            Schleuder.log.error "Wrong input: #{mem.inspect} is not suitable data for a Member."
+            nil
+          end
+        end
+      }.compact
+    end
+  end
+end