schleuder 3.2.2 → 3.5.2

data/lib/schleuder/plugins/attach_listkey.rb

@@ -1,16 +1,12 @@
 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}"
+      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

data/lib/schleuder/plugins/key_management.rb

@@ -1,7 +1,6 @@
 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)
@@ -9,15 +8,35 @@ module Schleuder
         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}"
+      import_stati = results.compact.collect(&:imports).flatten
+
+      if import_stati.blank?
+        return I18n.t('plugins.key_management.no_imports')
+      end
+
+      out = []
+
+      import_stati.each do |import_status|
+        if import_status.action == 'error'
+          out << I18n.t("plugins.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("plugins.key_management.key_import_status.#{import_status.action}", key_oneline: key.oneline)
+          end
+        end
       end
 
-      out.join("\n")
+      out.join("\n\n")
     end
 
     def self.delete_key(arguments, list, mail)
+      if arguments.blank?
+        return I18n.t(
+          "plugins.key_management.delete_key_requires_arguments"
+        )
+      end
+
       arguments.map do |argument|
         keys = list.keys(argument)
         case keys.size
@@ -26,9 +45,9 @@ module Schleuder
         when 1
           begin
             keys.first.delete!
-            I18n.t('plugins.key_management.deleted', key_string: keys.first.fingerprint)
+            I18n.t('plugins.key_management.deleted', key_string: keys.first.oneline)
           rescue GPGME::Error::Conflict
-            I18n.t('plugins.key_management.not_deletable', key_string: keys.first.fingerprint)
+            I18n.t('plugins.key_management.not_deletable', key_string: keys.first.oneline)
           end
         else
           I18n.t('errors.too_many_matching_keys', {
@@ -71,6 +90,12 @@ module Schleuder
     end
 
     def self.fetch_key(arguments, list, mail)
+      if arguments.blank?
+        return I18n.t(
+          "plugins.key_management.fetch_key_requires_arguments"
+        )
+      end
+
       arguments.map do |argument|
         list.fetch_keys(argument)
       end
@@ -79,35 +104,18 @@ module Schleuder
     # 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)
+        list.import_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)
+      list.import_key(key_material)
     end
   end
 end

data/lib/schleuder/plugins/resend.rb

@@ -56,6 +56,9 @@ module Schleuder
 
       # 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("plugins.resend.aborted", email: aborted_sender))
+        end
         return
       end
 
@@ -117,22 +120,22 @@ module Schleuder
       Array(recipients).inject({}) do |hash, email|
         keys = mail.list.keys(email)
         # Exclude unusable keys.
-        keys.select! { |key| key.usable_for?(:encrypt) }
-        case keys.size
+        usable_keys = keys.select { |key| key.usable_for?(:encrypt) }
+        case usable_keys.size
         when 1
-          hash[email] = keys.first
+          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_keys_error(mail, email, keys.size)
+            add_resend_msg(mail, 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_keys_error(mail, email, keys.size)
+          add_resend_msg(mail, email, :notice, 'not_resent_encrypted_no_keys', usable_keys.size, keys.size)
           if ! encrypted_only
             hash[email] = ''
           end
@@ -152,8 +155,8 @@ module Schleuder
       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))
+    def self.add_resend_msg(mail, email, severity, msg, usable_keys_size, all_keys_size)
+      mail.add_pseudoheader(severity, I18n.t("plugins.resend.#{msg}", email: email, usable_keys: usable_keys_size, all_keys: all_keys_size))
     end
 
     def self.add_error_header(mail, recipients_map)
@@ -163,15 +166,15 @@ module Schleuder
     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|
+        str = "\n" + recipients_map.map do |email, key|
           "#{email} (#{key.fingerprint})"
-        end.join(', ')
+        end.join(",\n")
       else
         prefix = I18n.t('plugins.resend.unencrypted_to')
-        str = recipients_map.keys.join(', ')
+        str = ' ' + recipients_map.keys.join(", ")
       end
       headername = resent_header_name(to_or_cc)
-      mail.add_pseudoheader(headername, "#{prefix} #{str}")
+      mail.add_pseudoheader(headername, "#{prefix}#{str}")
     end
 
     def self.resent_header_name(to_or_cc)

data/lib/schleuder/plugins/subscription_management.rb

@@ -1,12 +1,18 @@
 module Schleuder
   module RequestPlugins
     def self.subscribe(arguments, list, mail)
+      if arguments.blank?
+        return I18n.t(
+          "plugins.subscription_management.subscribe_requires_arguments"
+        )
+      end
+
       email = arguments.shift
 
       if arguments.present?
         # Collect all arguments that look like fingerprint-material
         fingerprint = ''
-        while arguments.first.present? && arguments.first.match(/\A(0x)?[a-f0-9]+/i)
+        while arguments.first.present? && arguments.first.match(/^(0x)?[a-f0-9]+$/i)
           fingerprint << arguments.shift
         end
         # Use possibly remaining args as flags.
@@ -37,6 +43,13 @@ module Schleuder
       # If no address was given we unsubscribe the sender.
       email = arguments.first.presence || mail.signer.email
 
+      # Refuse to unsubscribe the last admin.
+      if list.admins.size == 1 && list.admins.first.email == email
+        return I18n.t(
+          "plugins.subscription_management.cannot_unsubscribe_last_admin", email: email
+        )
+      end
+
       # TODO: May signers have multiple UIDs? We don't match those currently.
       if ! list.from_admin?(mail) && email != mail.signer.email
         # Only admins may unsubscribe others.
@@ -98,6 +111,12 @@ module Schleuder
     end
 
     def self.set_fingerprint(arguments, list, mail)
+      if arguments.blank?
+        return I18n.t(
+          "plugins.subscription_management.set_fingerprint_requires_arguments"
+        )
+      end
+
       if arguments.first.match(/@/)
         if arguments.first == mail.signer.email || list.from_admin?(mail)
           email = arguments.shift
@@ -118,8 +137,15 @@ module Schleuder
         )
       end
 
-      sub.fingerprint = arguments.join
+      fingerprint = arguments.join
+      unless GPGME::Key.valid_fingerprint?(fingerprint)
+        return I18n.t(
+          "plugins.subscription_management.set_fingerprint_requires_valid_fingerprint",
+          fingerprint: fingerprint
+        )
+      end
 
+      sub.fingerprint = fingerprint
       if sub.save
         I18n.t(
           "plugins.subscription_management.fingerprint_set",
@@ -130,7 +156,48 @@ module Schleuder
         I18n.t(
           "plugins.subscription_management.setting_fingerprint_failed",
           email: email,
-          fingerprint: arguments.last,
+          fingerprint: sub.fingerprint,
+          errors: sub.errors.to_a.join("\n")
+        )
+      end
+    end
+
+    def self.unset_fingerprint(arguments, list, mail)
+      if arguments.blank?
+        return I18n.t(
+          "plugins.subscription_management.unset_fingerprint_requires_arguments"
+        )
+      end
+
+      email = arguments.first
+      unless email == mail.signer.email || list.from_admin?(mail)
+          return I18n.t(
+            "plugins.subscription_management.unset_fingerprint_only_self"
+          )
+      end
+      if email == mail.signer.email && list.from_admin?(mail) && arguments.last != 'force'
+        return I18n.t(
+          "plugins.subscription_management.unset_fingerprint_requires_arguments"
+        )
+      end
+
+      sub = list.subscriptions.where(email: email).first
+      if sub.blank?
+        return I18n.t(
+          "plugins.subscription_management.is_not_subscribed", email: email
+        )
+      end
+
+      sub.fingerprint = ''
+      if sub.save
+        I18n.t(
+          "plugins.subscription_management.fingerprint_unset",
+          email: email
+        )
+      else
+        I18n.t(
+          "plugins.subscription_management.unsetting_fingerprint_failed",
+          email: email,
           errors: sub.errors.to_a.join("\n")
         )
       end

data/lib/schleuder/runner.rb

@@ -5,20 +5,48 @@ module Schleuder
       return error if error
 
       logger.info "Parsing incoming email."
+
+      # is it valid utf-8?
+      msg_scrubbed = false
+      unless msg.valid_encoding?
+        logger.warn "Converting message due to invalid characters"
+        detection = CharlockHolmes::EncodingDetector.detect(msg)
+        begin
+          msg = CharlockHolmes::Converter.convert(msg, detection[:encoding], 'UTF-8')
+        rescue ArgumentError
+          # it looks like even icu wasn't able to convert
+          # so we scrub the invalid characters to be able to
+          # at least parse the message somehow. Though this might
+          # result in data loss.
+          logger.warn "Scrubbing message due to invalid characters"
+          msg = msg.scrub
+          msg_scrubbed = true
+        end
+      end
+
       @mail = Mail.create_message_to_list(msg, recipient, list)
 
-      error = run_filters(Filters::Runner::PRE_SETUP_FILTERS)
+      if msg_scrubbed
+        @mail.add_pseudoheader(:note, I18n.t("pseudoheaders.scrubbed_message"))
+      end
+
+      error = run_filters('pre')
       return error if error
 
       begin
         # This decrypts, verifies, etc.
         @mail = @mail.setup
-      rescue GPGME::Error::DecryptFailed
+
+      rescue GPGME::Error::BadPassphrase,
+             GPGME::Error::DecryptFailed,
+             GPGME::Error::NoData,
+             GPGME::Error::NoSecretKey
+
         logger.warn "Decryption of incoming message failed."
         return Errors::DecryptionFailed.new(list)
       end
 
-      error = run_filters(Filters::Runner::POST_SETUP_FILTERS)
+      error = run_filters('post')
       return error if error
 
       if ! @mail.was_validly_signed?
@@ -45,8 +73,8 @@ module Schleuder
 
       # Subscriptions
       logger.debug "Creating clean copy of message"
-      copy = @mail.clean_copy(true)
-      list.send_to_subscriptions(copy)
+      copy = @mail.clean_copy(list.headers_to_meta.any?)
+      list.send_to_subscriptions(copy, @mail)
       nil
     end
 
@@ -56,8 +84,8 @@ module Schleuder
       @list
     end
 
-    def run_filters(filters)
-      error = filters_runner.run(@mail, filters)
+    def run_filters(filter_type)
+      error = filters_runner(filter_type).run(@mail)
       if error
         if list.bounces_notify_admins?
           text = "#{I18n.t('.bounces_notify_admins')}\n\n#{error}"
@@ -68,8 +96,19 @@ module Schleuder
       end
     end
 
-    def filters_runner
-      @filters_runner ||= Filters::Runner.new(list)
+    def filters_runner(filter_type)
+      if filter_type == 'pre'
+        filters_runner_pre_decryption
+      else
+        filters_runner_post_decryption
+      end
+    end
+
+    def filters_runner_pre_decryption
+      @filters_runner_pre_decryption ||= Filters::Runner.new(list,'pre')
+    end
+    def filters_runner_post_decryption
+      @filters_runner_post_decryption ||= Filters::Runner.new(list,'post')
     end
 
     def logger
@@ -94,7 +133,7 @@ module Schleuder
         return log_and_return(Errors::ListNotFound.new(recipient), true)
       end
 
-      # Check neccessary permissions of crucial files.
+      # Check necessary permissions of crucial files.
       if ! File.exist?(@list.listdir)
         return log_and_return(Errors::ListdirProblem.new(@list.listdir, :not_existing))
       elsif ! File.directory?(@list.listdir)

data/lib/schleuder/subscription.rb

@@ -23,10 +23,11 @@ module Schleuder
     end
 
     def fingerprint=(arg)
-      # Allow input to contain whitespace and '0x'-prefix, but don't store it
-      # into the DB.
-      value = arg.to_s.gsub(/\s*/, '').gsub(/^0x/, '').chomp
-      write_attribute(:fingerprint, value)
+      # Always assign the given value, because it must be possible to overwrite
+      # the previous fingerprint with an empty value. That value should better
+      # be nil instead of a blank string, but currently schleuder-cli (v0.1.0) expects
+      # only strings.
+      write_attribute(:fingerprint, arg.to_s.gsub(/\s*/, '').gsub(/^0x/, '').chomp.upcase)
     end
 
     def key
@@ -39,11 +40,6 @@ module Schleuder
     def send_mail(mail)
       list.logger.debug "Preparing sending to #{self.inspect}"
 
-      if ! self.delivery_enabled
-        list.logger.info "Not sending to #{self.email}: delivery is disabled."
-        return false
-      end
-
       mail = ensure_headers(mail)
       gpg_opts = self.list.gpg_sign_options
 

data/lib/schleuder/validators/fingerprint_validator.rb

@@ -1,6 +1,6 @@
 class FingerprintValidator <  ActiveModel::EachValidator
   def validate_each(record, attribute, value)
-    unless value =~ /\A[a-f0-9]{32,}\z/i
+    unless GPGME::Key.valid_fingerprint?(value)
       record.errors[attribute] << (options[:message] || I18n.t("errors.invalid_fingerprint"))
     end
   end