schleuder 3.6.0 → 4.0.0

data/lib/schleuder/gpgme/user_id.rb

@@ -3,9 +3,11 @@ module GPGME
     def name
       sanitize_encoding(@name)
     end
+
     def comment
       sanitize_encoding(@comment)
     end
+
     def uid
       sanitize_encoding(@uid)
     end

data/lib/schleuder/keyword_handlers/attach_list_key.rb

@@ -0,0 +1,17 @@
+module Schleuder
+  module KeywordHandlers
+    class AttachListKey < Base
+      handles_list_keyword 'attach-listkey', with_method: :attach_list_key
+
+      def attach_list_key
+        new_part = Mail::Part.new
+        new_part.body = @list.export_key
+        new_part.content_type = 'application/pgp-keys'
+        new_part.content_description = "OpenPGP public key of #{@list.email}"
+        new_part.content_disposition = "attachment; filename=#{@list.fingerprint}.pgpkey"
+        @mail.add_part new_part
+        nil
+      end
+    end
+  end
+end

data/lib/schleuder/keyword_handlers/base.rb

@@ -0,0 +1,36 @@
+module Schleuder
+  module KeywordHandlers
+    class Base
+      class << self
+        def handles_request_keyword(keyword, with_method:, has_aliases: [])
+          KeywordHandlersRunner.register_keyword(
+            type: :request,
+            keyword: keyword,
+            handler_class: self,
+            handler_method: with_method,
+            aliases: has_aliases
+          )
+        end
+
+        def handles_list_keyword(keyword, with_method:, has_aliases: [])
+          KeywordHandlersRunner.register_keyword(
+            type: :list,
+            keyword: keyword,
+            handler_class: self,
+            handler_method: with_method,
+            aliases: has_aliases
+          )
+        end
+      end
+
+      attr_reader :arguments
+      attr_reader :mail
+
+      def initialize(mail:, arguments:)
+        @arguments = arguments
+        @mail = mail
+        @list = mail.list
+      end
+    end
+  end
+end

data/lib/schleuder/keyword_handlers/get_version.rb

@@ -0,0 +1,11 @@
+module Schleuder
+  module KeywordHandlers
+    class GetVersion < Base
+      handles_request_keyword 'get-version', with_method: :get_version
+
+      def get_version
+        Schleuder::VERSION
+      end
+    end
+  end
+end

data/lib/schleuder/keyword_handlers/key_management.rb

@@ -0,0 +1,141 @@
+module Schleuder
+  module KeywordHandlers
+    class KeyManagement < Base
+      handles_request_keyword 'add-key', with_method: 'add_key'
+      handles_request_keyword 'delete-key', with_method: 'delete_key'
+      handles_request_keyword 'list-keys', with_method: 'list_keys'
+      handles_request_keyword 'get-key', with_method: 'get_key'
+      handles_request_keyword 'fetch-key', with_method: 'fetch_key'
+      
+      def add_key
+        results = 
+          if @mail.has_attachments?
+            import_keys_from_attachments
+          elsif @mail.first_plaintext_part.body.to_s.present?
+            import_key_from_body
+          else
+            @list.logger.debug 'Found no attachments and an empty body - sending error message'
+            I18n.t('keyword_handlers.key_management.no_content_found')
+          end
+
+        import_stati = results.compact.collect(&:imports).flatten
+
+        if import_stati.blank?
+          return I18n.t('keyword_handlers.key_management.no_imports')
+        end
+
+        out = []
+
+        import_stati.each do |import_status|
+          if import_status.action == 'error'
+            out << I18n.t('keyword_handlers.key_management.key_import_status.error', fingerprint: import_status.fingerprint)
+          else
+            key = @list.gpg.find_distinct_key(import_status.fingerprint)
+            if key
+              out << I18n.t("keyword_handlers.key_management.key_import_status.#{import_status.action}", key_summary: key.summary)
+            end
+          end
+        end
+
+        out.join("\n\n")
+      end
+
+      def delete_key
+        if @arguments.blank?
+          return I18n.t(
+            'keyword_handlers.key_management.delete_key_requires_arguments'
+          )
+        end
+
+        @arguments.map do |argument|
+          # Force GPG to match only fingerprints.
+          if argument[0..1] == '0x'
+            fingerprint = argument
+          else
+            fingerprint = "0x#{argument}"
+          end
+
+          keys = @list.keys(fingerprint)
+          case keys.size
+          when 0
+            I18n.t('keyword_handlers.key_management.key_not_found', fingerprint: argument)
+          when 1
+            begin
+              keys.first.delete!
+              I18n.t('keyword_handlers.key_management.deleted', key_string: keys.first.summary)
+            rescue GPGME::Error::Conflict
+              I18n.t('keyword_handlers.key_management.not_deletable', key_string: keys.first.summary)
+            end
+          else
+            # Shouldn't happen, but who knows.
+            I18n.t('errors.too_many_matching_keys', {
+                input: argument,
+                key_strings: keys.map(&:to_s).join("\n")
+              })
+          end
+        end.join("\n\n")
+      end
+
+      def list_keys
+        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 get_key
+        @arguments.map do |argument|
+          keys = @list.keys(argument)
+          if keys.blank?
+            I18n.t('errors.no_match_for', input: argument)
+          else
+            result = [I18n.t('keyword_handlers.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 fetch_key
+        if @arguments.blank?
+          return I18n.t(
+            'keyword_handlers.key_management.fetch_key_requires_arguments'
+          )
+        end
+
+        @arguments.map do |argument|
+          @list.fetch_keys(argument)
+        end
+      end
+
+
+      private
+
+
+      def import_keys_from_attachments
+        @mail.attachments.map do |attachment|
+          import_from_string(attachment.body.to_s)
+        end
+      end
+
+      def import_key_from_body
+        [import_from_string(@mail.first_plaintext_part.body.to_s)]
+      end
+
+      def import_from_string(string)
+        @list.import_key(string)
+      end
+    end
+  end
+end

data/lib/schleuder/keyword_handlers/list_management.rb

@@ -0,0 +1,19 @@
+module Schleuder
+  module KeywordHandlers
+    class ListManagement < Base
+      handles_request_keyword 'get-logfile', with_method: 'get_logfile'
+
+      def get_logfile
+        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('keyword_handlers.list_management.logfile_attached', listname: @list.email)
+          [intro, attachment]
+        else
+          I18n.t('keyword_handlers.list_management.no_logfile', listname: @list.email)
+        end
+      end
+    end
+  end
+end

data/lib/schleuder/keyword_handlers/resend.rb

@@ -0,0 +1,208 @@
+module Schleuder
+  module KeywordHandlers
+    class Resend < Base
+      handles_list_keyword 'resend-encrypted-only', with_method: :resend_encrypted_only, has_aliases: 'resend-enc'
+
+      handles_list_keyword 'resend', with_method: :resend
+
+      handles_list_keyword 'resend-cc', with_method: :resend_cc
+
+      handles_list_keyword 'resend-cc-encrypted-only', with_method: :resend_cc_encrypted_only, has_aliases: 'resend-cc-enc'
+
+      handles_list_keyword 'resend-unencrypted', with_method: :resend_unencrypted
+
+      handles_list_keyword 'resend-cc-unencrypted', with_method: :resend_cc_unencrypted
+
+
+      def resend
+        resend_it
+      end
+
+      def resend_encrypted_only
+        resend_it(encrypted_only: true)
+      end
+
+      def resend_cc
+        resend_it_cc
+      end
+
+      def resend_cc_encrypted_only
+        resend_it_cc(encrypted_only: true)
+      end
+
+      def resend_unencrypted
+        do_resend_unencrypted(:to)
+      end
+
+      def resend_cc_unencrypted
+        do_resend_unencrypted(:cc)
+      end
+
+
+      private
+
+
+      def do_resend_unencrypted(target)
+        if ! resend_recipients_valid?
+          return false
+        end
+
+        recip_map = Hash[Array(@arguments).map { |email| [email, ''] } ]
+
+        if do_resend(recip_map, target, false)
+          mail.add_subject_prefix_out!
+        end
+      end
+
+      def resend_it_cc(encrypted_only: false)
+        if ! resend_recipients_valid?
+          return false
+        end
+
+        recip_map = map_with_keys(encrypted_only: encrypted_only)
+
+        # Only continue if all recipients are still here.
+        if recip_map.size < @arguments.size
+          recip_map.keys.each do |aborted_sender|
+            @mail.add_pseudoheader(:error, I18n.t('keyword_handlers.resend.aborted', email: aborted_sender))
+          end
+          return
+        end
+
+        if do_resend(recip_map, :cc, encrypted_only)
+          @mail.add_subject_prefix_out!
+        end
+      end
+
+      def resend_it(encrypted_only: false)
+        if ! resend_recipients_valid?
+          return false
+        end
+
+        recip_map = map_with_keys(encrypted_only: encrypted_only)
+
+        resent_stati = recip_map.map do |email, key|
+          do_resend({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 do_resend(recipients_map, to_or_cc, encrypted_only)
+        if recipients_map.empty?
+          return
+        end
+
+        gpg_opts = make_gpg_opts(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 = @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(recipients_map, to_or_cc, gpg_opts[:encrypt])
+          return true
+        else
+          add_error_header(recipients_map)
+          return false
+        end
+      rescue Net::SMTPFatalError => exc
+        add_error_header(recipients_map)
+        logger.error "Error while sending: #{exc}"
+        return false
+      end
+
+      def map_with_keys(encrypted_only:)
+        Array(@arguments).inject({}) do |hash, email|
+          keys = @list.keys(email)
+          # Exclude unusable keys.
+          usable_keys = keys.select { |key| key.usable_for?(:encrypt) }
+          case usable_keys.size
+          when 1
+            hash[email] = usable_keys.first
+          when 0
+            if encrypted_only
+              # Don't add the email to the result to exclude it from the
+              # recipients.
+              add_resend_msg(email, :error, 'not_resent_no_keys', usable_keys.size, keys.size)
+            else
+              hash[email] = ''
+            end
+          else
+            # Always report this situation, regardless of sending or not. It's
+            # bad and should be fixed.
+            add_resend_msg(email, :notice, 'not_resent_encrypted_no_keys', usable_keys.size, keys.size)
+            if ! encrypted_only
+              hash[email] = ''
+            end
+          end
+          hash
+        end
+      end
+
+      def make_gpg_opts(recipients_map, encrypted_only)
+        gpg_opts = @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 add_resend_msg(email, severity, msg, usable_keys_size, all_keys_size)
+        @mail.add_pseudoheader(severity, I18n.t("keyword_handlers.resend.#{msg}", email: email, usable_keys: usable_keys_size, all_keys: all_keys_size))
+      end
+
+      def add_error_header(recipients_map)
+        @mail.add_pseudoheader(:error, "Resending to #{recipients_map.keys.join(', ')} failed, please check the logs!")
+      end
+
+      def add_resent_headers(recipients_map, to_or_cc, sent_encrypted)
+        if sent_encrypted
+          prefix = I18n.t('keyword_handlers.resend.encrypted_to')
+          str = "\n" + recipients_map.map do |email, key|
+            "#{email} (#{key.fingerprint})"
+          end.join(",\n")
+        else
+          prefix = I18n.t('keyword_handlers.resend.unencrypted_to')
+          str = ' ' + recipients_map.keys.join(', ')
+        end
+        headername = resent_header_name(to_or_cc)
+        @mail.add_pseudoheader(headername, "#{prefix}#{str}")
+      end
+
+      def resent_header_name(to_or_cc)
+        if to_or_cc.to_s == 'to'
+          'resent'
+        else
+          'resent_cc'
+        end
+      end
+
+      def resend_recipients_valid?
+        all_valid = true
+        Array(@arguments).each do |address|
+          if ! address.match(Conf::EMAIL_REGEXP)
+            mail.add_pseudoheader(:error, I18n.t('keyword_handlers.resend.invalid_recipient', address: address))
+            all_valid = false
+          end
+        end
+        all_valid
+      end
+
+    end
+  end
+end