schleuder 3.5.0 → 4.0.0

data/bin/pinentry-clearpassphrase

@@ -1,72 +0,0 @@
-#!/usr/bin/env ruby
-
-# This file can be deleted once we cease to support gnupg 2.0.
-
-require 'fileutils'
-require 'cgi'
-require 'openssl'
-
-def respond(msg, flush=true)
-  $stdout.puts msg
-  if flush
-    $stdout.flush
-  end
-end
-
-def send_ok(flush=true)
-  respond 'OK', flush
-end
-
-def send_password
-  if File.exist?(OLDPWDSENTFILE)
-    pwd = ''
-    if File.exist?(EMPTYPWDSENTFILE1)
-      FileUtils.touch(EMPTYPWDSENTFILE2)
-    else
-      FileUtils.touch(EMPTYPWDSENTFILE1)
-    end
-  else
-    pwd = OLDPASSWD
-    FileUtils.touch(OLDPWDSENTFILE)
-  end
-  respond "D #{pwd}"
-end
-
-def do_exit
-  if File.exist?(EMPTYPWDSENTFILE2)
-    FileUtils.rm_rf(TMPDIR)
-  end
-  exit 0
-end
-
-OLDPASSWD = CGI.escape(ENV['PINENTRY_USER_DATA'].to_s)
-if OLDPASSWD.empty?
-  respond "Fatal error: passed PINENTRY_USER_DATA was empty, cannot continue"
-  exit 1
-end
-
-# We need a static directory name to maintain the state across invocations of
-# this file.
-TMPDIR = File.join(ENV['GNUPGHOME'], '.tmp-pinentry-clearpassphrase')
-OLDPWDSENTFILE = File.join(TMPDIR, '1')
-EMPTYPWDSENTFILE1 = File.join(TMPDIR, '2')
-EMPTYPWDSENTFILE2 = File.join(TMPDIR, '3')
-if ! Dir.exist?(TMPDIR)
-  Dir.mkdir(TMPDIR)
-end
-
-respond "OK - what's up?"
-
-while line = $stdin.gets do
-  case line
-  when /^GETPIN/
-    send_password
-    send_ok
-  when /^BYE/
-    send_ok false
-    do_exit
-  else
-    send_ok
-  end
-end
-

data/lib/schleuder/plugin_runners/base.rb

@@ -1,91 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,13 +0,0 @@
-module Schleuder
-  module ListPlugins
-    def self.attach_listkey(arguments, list, mail)
-      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

data/lib/schleuder/plugins/get_version.rb

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

data/lib/schleuder/plugins/key_management.rb

@@ -1,138 +0,0 @@
-module Schleuder
-  module RequestPlugins
-    def self.add_key(arguments, list, mail)
-
-      if mail.has_attachments?
-        results = self.import_keys_from_attachments(list, mail)
-      else
-        results = [self.import_key_from_body(list, mail)]
-      end
-
-      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\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
-        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.oneline)
-          rescue GPGME::Error::Conflict
-            I18n.t('plugins.key_management.not_deletable', key_string: keys.first.oneline)
-          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)
-      if arguments.blank?
-        return I18n.t(
-          "plugins.key_management.fetch_key_requires_arguments"
-        )
-      end
-
-      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

@@ -1,15 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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
-        recip_map.keys.each do |aborted_sender|
-          mail.add_pseudoheader(:error, I18n.t("plugins.resend.aborted", email: aborted_sender))
-        end
-        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.
-        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(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_resend_msg(mail, email, :notice, 'not_resent_encrypted_no_keys', usable_keys.size, 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_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)
-      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 = "\n" + recipients_map.map do |email, key|
-          "#{email} (#{key.fingerprint})"
-        end.join(",\n")
-      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