schleuder 3.5.3 → 4.0.2

data/lib/schleuder/gpgme/key.rb

@@ -26,8 +26,8 @@ module GPGME
       expired.present?
     end
 
-    def oneline
-      @oneline ||= 
+    def summary
+      @summary ||= 
         begin
           datefmt = '%Y-%m-%d'
           attribs = [
@@ -41,7 +41,7 @@ module GPGME
               attribs << "[expired: #{expires.strftime(datefmt)}]"
             when :revoked
               # TODO: add revocation date when it's available.
-              attribs << "[revoked]"
+              attribs << '[revoked]'
             else
               attribs << "[#{usability_issue}]"
             end
@@ -75,144 +75,12 @@ module GPGME
       if trust.present?
         trust
       elsif ! usable_for?(:encrypt)
-        "not capable of encryption"
+        'not capable of encryption'
       else
         nil
       end
     end
 
-    def set_primary_uid(email)
-      # We rely on the order of UIDs here. Seems to work.
-      index = self.uids.map(&:email).index(email)
-      uid_number = index + 1
-      primary_set = false
-      args = "--edit-key '#{self.fingerprint}' #{uid_number}"
-      errors, _ = GPGME::Ctx.gpgcli_expect(args) do |line|
-        case line.chomp
-        when /keyedit.prompt/
-          if ! primary_set
-            primary_set = true
-            "primary"
-          else
-            "save"
-          end
-        else
-          nil
-        end
-      end
-      errors.join
-    end
-
-    def adduid(uid, email)
-      # This block can be deleted once we cease to support gnupg 2.0.
-      if ! GPGME::Ctx.sufficient_gpg_version?('2.1.4')
-        return adduid_expect(uid, email)
-      end
-
-      # Specifying the key via fingerprint apparently doesn't work.
-      errors, _ = GPGME::Ctx.gpgcli("--quick-adduid #{uid} '#{uid} <#{email}>'")
-      errors.join
-    end
-
-    # This method can be deleted once we cease to support gnupg 2.0.
-    def adduid_expect(uid, email)
-      args = "--allow-freeform-uid --edit-key '#{self.fingerprint}' adduid"
-      errors, _ = GPGME::Ctx.gpgcli_expect(args) do |line|
-        case line.chomp
-        when /keygen.name/
-          uid
-        when /keygen.email/
-          email
-        when /keygen.comment/
-          ''
-        when /keyedit.prompt/
-          "save"
-        else
-          nil
-        end
-      end
-      errors.join
-    end
-
-    def clearpassphrase(oldpw)
-      # This block can be deleted once we cease to support gnupg 2.0.
-      if ! GPGME::Ctx.sufficient_gpg_version?('2.1.0')
-        return clearpassphrase_v20(oldpw)
-      end
-
-      oldpw_given = false
-      # Don't use '--passwd', it claims to fail (even though it factually doesn't).
-      args = "--pinentry-mode loopback --edit-key '#{self.fingerprint}' passwd"
-      errors, _, exitcode = GPGME::Ctx.gpgcli_expect(args) do |line|
-        case line
-        when /passphrase.enter/
-          if ! oldpw_given
-            oldpw_given = true
-            oldpw
-          else
-            ""
-          end
-        when /BAD_PASSPHRASE/
-          [false, 'bad passphrase']
-        when /change_passwd.empty.okay/
-          'y'
-        when /keyedit.prompt/
-          "save"
-        else
-          nil
-        end
-      end
-
-      # Only show errors if something apparently went wrong. Otherwise we might
-      # leak useless strings from gpg and make the caller report errors even
-      # though this method succeeded.
-      if exitcode > 0
-        errors.join
-      else
-        nil
-      end
-    end
-
-    # This method can be deleted once we cease to support gnupg 2.0.
-    def clearpassphrase_v20(oldpw)
-      start_gpg_agent(oldpw)
-      # Don't use '--passwd', it claims to fail (even though it factually doesn't).
-      errors, _, exitcode = GPGME::Ctx.gpgcli_expect("--edit-key '#{self.fingerprint}' passwd") do |line|
-        case line
-        when /BAD_PASSPHRASE/
-          [false, 'bad passphrase']
-        when /change_passwd.empty.okay/
-          'y'
-        when /keyedit.prompt/
-          "save"
-        else
-          nil
-        end
-      end
-      stop_gpg_agent
-
-      # Only show errors if something apparently went wrong. Otherwise we might
-      # leak useless strings from gpg and make the caller report errors even
-      # though this method succeeded.
-      if exitcode > 0
-        errors.join
-      else
-        nil
-      end
-    end
-
-    # This method can be deleted once we cease to support gnupg 2.0.
-    def stop_gpg_agent
-      # gpg-agent terminates itself if its socket goes away.
-      GPGME::Ctx.delete_daemon_socket('gpg-agent')
-    end
-
-    def start_gpg_agent(oldpw)
-      ENV['PINENTRY_USER_DATA'] = oldpw
-      pinentry = File.join(ENV['SCHLEUDER_ROOT'], 'bin', 'pinentry-clearpassphrase')
-      GPGME::Ctx.spawn_daemon('gpg-agent', "--use-standard-socket --pinentry-program #{pinentry}")
-    end
-
     def self.valid_fingerprint?(fp)
       fp =~ Schleuder::Conf::FINGERPRINT_REGEXP
     end

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.raw_source)
+        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