schleuder 2.2.4 → 3.2.2

data/lib/schleuder/mail/parts_list.rb

@@ -0,0 +1,9 @@
+module Mail
+  class PartsList
+    # Disable sorting of mime-parts completely.
+    # Can't be done during runtime on the body-instance (`body#set_sort_order`)
+    # because MailGpg exchanges the body-instances when encrypting/signing.
+    def sort!(*args)
+    end
+  end
+end

data/lib/schleuder/plugin_runners/base.rb

@@ -0,0 +1,91 @@
+module Schleuder
+  module PluginRunners
+    module Base
+      def run(list, mail)
+        list.logger.debug "Starting #{self}"
+        @list = list
+        @mail = mail
+        setup
+
+        output = mail.keywords.map do |keyword, arguments|
+          run_plugin(keyword, arguments)
+        end
+
+        output.flatten.compact
+      end
+
+
+      private
+
+
+      def run_plugin(keyword, arguments)
+        @list.logger.debug "Running keyword '#{keyword}'"
+
+        error = check_admin_only(keyword)
+        return error if error
+
+        command = keyword.gsub('-', '_')
+        if ['list_name', 'listname'].include? (command)
+          return nil
+        elsif ! @plugin_module.respond_to?(command)
+          return I18n.t('plugins.unknown_keyword', keyword: keyword)
+        else
+          response = run_command(command, arguments)
+          if @list.keywords_admin_notify.include?(keyword)
+            notify_admins(keyword, arguments, response)
+          end
+          return response
+        end
+      rescue => exc
+        # Log to system, this information is probably more useful for
+        # system-admins than for list-admins.
+        Schleuder.logger.error(exc.message_with_backtrace)
+        I18n.t("plugins.plugin_failed", keyword: keyword)
+      end
+
+      def run_command(command, arguments)
+        out = @plugin_module.send(command, arguments, @list, @mail)
+        Array(out).flatten
+      end
+
+      def check_admin_only(keyword)
+        if @list.admin_only?(keyword) && ! @list.from_admin?(@mail)
+          @list.logger.debug "Error: Keyword is admin-only, sent by non-admin"
+          Schleuder::Errors::KeywordAdminOnly.new(keyword).to_s
+        else
+          false
+        end
+      end
+
+      def setup
+        check_listname_keyword
+        load_plugin_files
+        @plugin_module = self.name.demodulize.gsub("Runner", "").constantize
+      end
+
+      def check_listname_keyword
+        return nil if @mail.keywords.blank?
+
+        listname_kw = @mail.keywords.assoc('list-name') || @mail.keywords.assoc('listname')
+        if listname_kw.blank?
+          @mail.reply_to_signer I18n.t(:missing_listname_keyword_error)
+          exit
+        else
+          listname_args = listname_kw.last
+          if ! [@list.email, @list.request_address].include?(listname_args.first)
+            @mail.reply_to_signer I18n.t(:wrong_listname_keyword_error)
+            exit
+          end
+        end
+      end
+
+      def load_plugin_files
+        @list.logger.debug "Loading plugins"
+        Dir["#{Schleuder::Conf.plugins_dir}/*.rb"].each do |file|
+          require file
+        end
+      end
+
+    end
+  end
+end

data/lib/schleuder/plugin_runners/list_plugins_runner.rb

@@ -0,0 +1,24 @@
+module Schleuder
+  module PluginRunners
+    module ListPluginsRunner
+      extend Base
+
+      def self.notify_admins(keyword, arguments, response)
+        if arguments.blank?
+          msg = I18n.t('plugins.keyword_admin_notify_lists_without_arguments',
+                                signer: @mail.signer,
+                                keyword: keyword
+                            )
+        else
+          msg = I18n.t('plugins.keyword_admin_notify_lists',
+                                signer: @mail.signer,
+                                keyword: keyword,
+                                arguments: arguments.join(' ')
+                            )
+        end
+        @list.logger.notify_admin(msg, nil, 'Notice')
+      end
+
+    end
+  end
+end

data/lib/schleuder/plugin_runners/request_plugins_runner.rb

@@ -0,0 +1,27 @@
+module Schleuder
+  module PluginRunners
+    module RequestPluginsRunner
+      extend Base
+
+      def self.notify_admins(keyword, arguments, response)
+        if arguments.blank?
+          explanation = I18n.t('plugins.keyword_admin_notify_request_without_arguments',
+                                signer: @mail.signer,
+                                keyword: keyword
+                            )
+        else
+          explanation = I18n.t('plugins.keyword_admin_notify_request',
+                                signer: @mail.signer,
+                                keyword: keyword,
+                                arguments: arguments.join(' ')
+                            )
+        end
+        response = response.join("\n\n")
+        msg = "#{explanation}\n\n#{response}"
+        @list.logger.notify_admin(msg, nil, 'Notice')
+      end
+
+    end
+  end
+end
+

data/lib/schleuder/plugins/attach_listkey.rb

@@ -0,0 +1,17 @@
+module Schleuder
+  module ListPlugins
+    def self.attach_listkey(arguments, list, mail)
+      filename = "#{list.fingerprint}.pgpkey"
+      # "Mail" only really converts to multipart if the content-type is blank.
+      mail.content_type = nil
+      mail.add_file({
+        filename: filename,
+        content: list.export_key
+      })
+      mail.attachments[filename].content_type = 'application/pgp-keys'
+      mail.attachments[filename].content_description = "OpenPGP public key of #{list.email}"
+      mail.attachments[filename].content_disposition = "attachment; filename=#{filename}"
+      nil
+    end
+  end
+end

data/lib/schleuder/plugins/get_version.rb

@@ -0,0 +1,7 @@
+module Schleuder
+  module RequestPlugins
+    def self.get_version(arguments, list, mail)
+      Schleuder::VERSION
+    end
+  end
+end

data/lib/schleuder/plugins/key_management.rb

@@ -0,0 +1,113 @@
+module Schleuder
+  module RequestPlugins
+    def self.add_key(arguments, list, mail)
+      out = [I18n.t('plugins.key_management.import_result')]
+
+      if mail.has_attachments?
+        results = self.import_keys_from_attachments(list, mail)
+      else
+        results = [self.import_key_from_body(list, mail)]
+      end
+
+      out << results.compact.collect(&:imports).flatten.map do |import_status|
+        str = I18n.t("plugins.key_management.key_import_status.#{import_status.action}")
+        "#{import_status.fpr}: #{str}"
+      end
+
+      out.join("\n")
+    end
+
+    def self.delete_key(arguments, list, mail)
+      arguments.map do |argument|
+        keys = list.keys(argument)
+        case keys.size
+        when 0
+          I18n.t("errors.no_match_for", input: argument)
+        when 1
+          begin
+            keys.first.delete!
+            I18n.t('plugins.key_management.deleted', key_string: keys.first.fingerprint)
+          rescue GPGME::Error::Conflict
+            I18n.t('plugins.key_management.not_deletable', key_string: keys.first.fingerprint)
+          end
+        else
+          I18n.t('errors.too_many_matching_keys', {
+              input: argument,
+              key_strings: keys.map(&:to_s).join("\n")
+            })
+        end
+      end.join("\n\n")
+    end
+
+    def self.list_keys(arguments, list, mail)
+      args = Array(arguments.presence || '')
+      args.map do |argument|
+        # In this case it shall be allowed to match keys by arbitrary
+        # sub-strings, therefore we use `list.gpg` directly to not have the
+        # input filtered.
+        list.gpg.keys(argument).map do |key|
+          key.to_s
+        end
+      end.join("\n\n")
+    end
+
+    def self.get_key(arguments, list, mail)
+      arguments.map do |argument|
+        keys = list.keys(argument)
+        if keys.blank?
+          I18n.t("errors.no_match_for", input: argument)
+        else
+          result = [I18n.t('plugins.key_management.matching_keys_intro', input: argument)]
+          keys.each do |key|
+            atchm = Mail::Part.new
+            atchm.body = key.armored
+            atchm.content_type = 'application/pgp-keys'
+            atchm.content_disposition = "attachment; filename=#{key.fingerprint}.asc"
+            result << atchm
+          end
+          result.flatten
+        end
+      end
+    end
+
+    def self.fetch_key(arguments, list, mail)
+      arguments.map do |argument|
+        list.fetch_keys(argument)
+      end
+    end
+
+    # helper methods
+    private
+
+    def self.is_armored_key?(material)
+      return false unless /^-----BEGIN PGP PUBLIC KEY BLOCK-----$/ =~ material
+      return false unless /^-----END PGP PUBLIC KEY BLOCK-----$/ =~ material
+
+      lines = material.split("\n").reject(&:empty?)
+      # remove header
+      lines.shift
+      # remove tail
+      lines.pop
+      # verify the rest
+      # TODO: verify length except for lasts lines?
+      # headers according to https://tools.ietf.org/html/rfc4880#section-6.2
+      lines.map do |line|
+        /\A((comment|version|messageid|hash|charset):.*|[0-9a-z\/=+]+)\Z/i =~ line
+      end.all?
+    end
+
+    def self.import_keys_from_attachments(list, mail)
+      mail.attachments.map do |attachment|
+        material = attachment.body.to_s
+
+        list.import_key(material) if self.is_armored_key?(material)
+      end
+    end
+
+    def self.import_key_from_body(list, mail)
+      key_material = mail.first_plaintext_part.body.to_s
+
+      list.import_key(key_material) if self.is_armored_key?(key_material)
+    end
+  end
+end

data/lib/schleuder/plugins/list_management.rb

@@ -0,0 +1,15 @@
+module Schleuder
+  module RequestPlugins
+    def self.get_logfile(arguments, list, mail)
+      if File.readable?(list.logfile)
+        attachment = Mail::Part.new
+        attachment.body = File.read(list.logfile)
+        attachment.content_disposition = "inline; filename=#{list.email}.log"
+        intro = I18n.t("plugins.list_management.logfile_attached", listname: list.email)
+        [intro, attachment]
+      else
+        I18n.t("plugins.list_management.no_logfile", listname: list.email)
+      end
+    end
+  end
+end

data/lib/schleuder/plugins/resend.rb

@@ -0,0 +1,196 @@
+module Schleuder
+  module ListPlugins
+    def self.resend(arguments, list, mail)
+      resend_it(arguments, mail, false)
+    end
+
+    def self.resend_enc(arguments, list, mail)
+      resend_encrypted_only(arguments, list, mail)
+    end
+
+    def self.resend_encrypted_only(arguments, list, mail)
+      resend_it(arguments, mail, true)
+    end
+
+    def self.resend_cc(arguments, list, mail)
+      resend_it_cc(arguments, mail, false)
+    end
+
+    def self.resend_cc_enc(arguments, list, mail)
+      resend_cc_encrypted_only(arguments, list, mail)
+    end
+
+    def self.resend_cc_encrypted_only(arguments, list, mail)
+      resend_it_cc(arguments, mail, true)
+    end
+
+    def self.resend_unencrypted(arguments, list, mail)
+      do_resend_unencrypted(arguments, list, mail, :to)
+    end
+
+    def self.resend_cc_unencrypted(arguments, list, mail)
+      do_resend_unencrypted(arguments, list, mail, :cc)
+    end
+
+    # helper methods
+    private
+
+    def self.do_resend_unencrypted(arguments, list, mail, target)
+      if ! resend_recipients_valid?(mail, arguments)
+        return false
+      end
+
+      recip_map = Hash[Array(arguments).map{|email| [email,''] }]
+
+      if do_resend(mail, recip_map, target, false)
+        mail.add_subject_prefix_out!
+      end
+    end
+
+    def self.resend_it_cc(arguments, mail, encrypted_only)
+      if ! resend_recipients_valid?(mail, arguments)
+        return false
+      end
+
+      recip_map = map_with_keys(mail, arguments, encrypted_only)
+
+      # Only continue if all recipients are still here.
+      if recip_map.size < arguments.size
+        return
+      end
+
+      if do_resend(mail, recip_map, :cc, encrypted_only)
+        mail.add_subject_prefix_out!
+      end
+    end
+
+    def self.resend_it(arguments, mail, encrypted_only)
+      if ! resend_recipients_valid?(mail, arguments)
+        return false
+      end
+
+      recip_map = map_with_keys(mail, arguments, encrypted_only)
+
+      resent_stati = recip_map.map do |email, key|
+        do_resend(mail, {email => key}, :to, encrypted_only)
+      end
+
+      if resent_stati.include?(true)
+        # At least one message has been resent
+        mail.add_subject_prefix_out!
+      end
+    end
+
+    def self.do_resend(mail, recipients_map, to_or_cc, encrypted_only)
+      if recipients_map.empty?
+        return
+      end
+
+      gpg_opts = make_gpg_opts(mail, recipients_map, encrypted_only)
+      if gpg_opts == false
+        return false
+      end
+
+      # Compose and send email
+      new = mail.clean_copy
+      new[to_or_cc] = recipients_map.keys
+      new.add_public_footer!
+      new.sender = mail.list.bounce_address
+      # `dup` gpg_opts because `deliver` changes their value and we need them
+      # below to determine encryption!
+      new.gpg gpg_opts.dup
+
+      if new.deliver
+        add_resent_headers(mail, recipients_map, to_or_cc, gpg_opts[:encrypt])
+        return true
+      else
+        add_error_header(mail, recipients_map)
+        return false
+      end
+    rescue Net::SMTPFatalError => exc
+      add_error_header(mail, recipients_map)
+      logger.error "Error while sending: #{exc}"
+      return false
+    end
+
+    def self.map_with_keys(mail, recipients, encrypted_only)
+      Array(recipients).inject({}) do |hash, email|
+        keys = mail.list.keys(email)
+        # Exclude unusable keys.
+        keys.select! { |key| key.usable_for?(:encrypt) }
+        case keys.size
+        when 1
+          hash[email] = keys.first
+        when 0
+          if encrypted_only
+            # Don't add the email to the result to exclude it from the
+            # recipients.
+            add_keys_error(mail, email, keys.size)
+          else
+            hash[email] = ''
+          end
+        else
+          # Always report this situation, regardless of sending or not. It's
+          # bad and should be fixed.
+          add_keys_error(mail, email, keys.size)
+          if ! encrypted_only
+            hash[email] = ''
+          end
+        end
+        hash
+      end
+    end
+
+    def self.make_gpg_opts(mail, recipients_map, encrypted_only)
+      gpg_opts = mail.list.gpg_sign_options
+      # Do all recipients have a key?
+      if recipients_map.values.map(&:class).uniq == [GPGME::Key]
+        gpg_opts.merge!(encrypt: true)
+      elsif encrypted_only
+        false
+      end
+      gpg_opts
+    end
+
+    def self.add_keys_error(mail, email, keys_size)
+      mail.add_pseudoheader(:error, I18n.t("plugins.resend.not_resent_no_keys", email: email, num_keys: keys_size))
+    end
+
+    def self.add_error_header(mail, recipients_map)
+      mail.add_pseudoheader(:error, "Resending to #{recipients_map.keys.join(', ')} failed, please check the logs!")
+    end
+
+    def self.add_resent_headers(mail, recipients_map, to_or_cc, sent_encrypted)
+      if sent_encrypted
+        prefix = I18n.t('plugins.resend.encrypted_to')
+        str = recipients_map.map do |email, key|
+          "#{email} (#{key.fingerprint})"
+        end.join(', ')
+      else
+        prefix = I18n.t('plugins.resend.unencrypted_to')
+        str = recipients_map.keys.join(', ')
+      end
+      headername = resent_header_name(to_or_cc)
+      mail.add_pseudoheader(headername, "#{prefix} #{str}")
+    end
+
+    def self.resent_header_name(to_or_cc)
+      if to_or_cc.to_s == 'to'
+        'resent'
+      else
+        'resent_cc'
+      end
+    end
+
+    def self.resend_recipients_valid?(mail, recipients)
+      all_valid = true
+      Array(recipients).each do |address|
+        if ! address.match(Conf::EMAIL_REGEXP)
+          mail.add_pseudoheader(:error, I18n.t("plugins.resend.invalid_recipient", address: address))
+          all_valid = false
+        end
+      end
+      all_valid
+    end
+  end
+end