schleuder 2.2.4 → 3.2.2

data/lib/schleuder/plugins/sign_this.rb

@@ -0,0 +1,46 @@
+module Schleuder
+  module RequestPlugins
+    def self.sign_this(arguments, list, mail)
+      if mail.has_attachments?
+        list.logger.debug "Signing each attachment's body"
+        intro = I18n.t('plugins.signatures_attached')
+        parts = mail.attachments.map do |attachment|
+          make_signature_part(attachment, list)
+        end
+        [intro, parts].flatten
+      else
+        list.logger.debug "Clear-signing first available text/plain part"
+        clearsign(mail.first_plaintext_part)
+      end
+    end
+
+    # helper methods
+    private
+
+    def self.make_signature_part(attachment, list)
+      material = attachment.body.to_s
+      return nil if material.strip.blank?
+      file_basename = attachment.filename.presence || Digest::SHA256.hexdigest(material)
+      list.logger.debug "Signing #{file_basename}"
+      filename = "#{file_basename}.sig"
+      part = Mail::Part.new
+      part.body = detachsign(material)
+      part.content_type = 'application/pgp-signature'
+      part.content_disposition = "attachment; filename=#{filename}"
+      part.content_description = "OpenPGP signature for '#{file_basename}'"
+      part
+    end
+
+    def self.detachsign(thing)
+      crypto.sign(thing, mode: GPGME::SIG_MODE_DETACH).to_s
+    end
+
+    def self.clearsign(mail)
+      crypto.clearsign(mail.body.to_s).to_s
+    end
+
+    def self.crypto
+      @crypto ||= GPGME::Crypto.new(armor: true)
+    end
+  end
+end

data/lib/schleuder/plugins/subscription_management.rb

@@ -0,0 +1,140 @@
+module Schleuder
+  module RequestPlugins
+    def self.subscribe(arguments, list, mail)
+      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)
+          fingerprint << arguments.shift
+        end
+        # Use possibly remaining args as flags.
+        adminflag = arguments.shift
+        deliveryflag = arguments.shift
+      end
+
+      sub, _ = list.subscribe(email, fingerprint, adminflag, deliveryflag)
+
+      if sub.persisted?
+        I18n.t(
+          "plugins.subscription_management.subscribed",
+          email: sub.email,
+          fingerprint: sub.fingerprint,
+          admin: sub.admin,
+          delivery_enabled: sub.delivery_enabled
+        )
+      else
+        I18n.t(
+          "plugins.subscription_management.subscribing_failed",
+          email: sub.email,
+          errors: sub.errors.full_messages.join(".\n")
+        )
+      end
+    end
+
+    def self.unsubscribe(arguments, list, mail)
+      # If no address was given we unsubscribe the sender.
+      email = arguments.first.presence || mail.signer.email
+
+      # 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.
+        return I18n.t(
+          "plugins.subscription_management.forbidden", email: email
+        )
+      end
+
+      sub = list.subscriptions.where(email: email).first
+
+      if sub.blank?
+        return I18n.t(
+          "plugins.subscription_management.is_not_subscribed", email: email
+        )
+      end
+
+      if res = sub.delete
+        I18n.t(
+          "plugins.subscription_management.unsubscribed", email: email
+        )
+      else
+        I18n.t(
+          "plugins.subscription_management.unsubscribing_failed",
+          email: email,
+          error: res.errors.to_a
+        )
+      end
+    end
+
+    def self.list_subscriptions(arguments, list, mail)
+      subs = if arguments.blank?
+                list.subscriptions.all.to_a
+             else
+               arguments.map do |argument|
+                 list.subscriptions.where("email like ?", "%#{argument}%").to_a
+               end.flatten
+             end
+
+      if subs.blank?
+        return nil
+      end
+
+      out = [ I18n.t("plugins.subscription_management.list_of_subscriptions") ]
+
+      out << subs.map do |subscription|
+        # Fingerprints are at most 40 characters long, and lines shouldn't
+        # exceed 80 characters if possible.
+        s = subscription.email
+        if subscription.fingerprint.present?
+          s << "\t0x#{subscription.fingerprint}"
+        end
+        if ! subscription.delivery_enabled?
+          s << "\tDelivery disabled!"
+        end
+        s
+      end
+
+      out.join("\n")
+    end
+
+    def self.set_fingerprint(arguments, list, mail)
+      if arguments.first.match(/@/)
+        if arguments.first == mail.signer.email || list.from_admin?(mail)
+          email = arguments.shift
+        else
+          return I18n.t(
+            "plugins.subscription_management.set_fingerprint_only_self"
+          )
+        end
+      else
+        email = mail.signer.email
+      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 = arguments.join
+
+      if sub.save
+        I18n.t(
+          "plugins.subscription_management.fingerprint_set",
+          email: email,
+          fingerprint: sub.fingerprint
+        )
+      else
+        I18n.t(
+          "plugins.subscription_management.setting_fingerprint_failed",
+          email: email,
+          fingerprint: arguments.last,
+          errors: sub.errors.to_a.join("\n")
+        )
+      end
+    end
+  end
+end
+

data/lib/schleuder/runner.rb

@@ -0,0 +1,130 @@
+module Schleuder
+  class Runner
+    def run(msg, recipient)
+      error = setup_list(recipient)
+      return error if error
+
+      logger.info "Parsing incoming email."
+      @mail = Mail.create_message_to_list(msg, recipient, list)
+
+      error = run_filters(Filters::Runner::PRE_SETUP_FILTERS)
+      return error if error
+
+      begin
+        # This decrypts, verifies, etc.
+        @mail = @mail.setup
+      rescue GPGME::Error::DecryptFailed
+        logger.warn "Decryption of incoming message failed."
+        return Errors::DecryptionFailed.new(list)
+      end
+
+      error = run_filters(Filters::Runner::POST_SETUP_FILTERS)
+      return error if error
+
+      if ! @mail.was_validly_signed?
+        logger.debug "Message was not validly signed, adding subject_prefix_in"
+        @mail.add_subject_prefix_in!
+      end
+
+      if ! @mail.was_encrypted?
+        logger.debug "Message was not encrypted, skipping plugins"
+      elsif @mail.was_validly_signed?
+        # Plugins
+        logger.debug "Message was encrypted and validly signed"
+        PluginRunners::ListPluginsRunner.run(list, @mail).compact
+      end
+
+      # Don't send empty messages over the list.
+      if @mail.empty?
+        logger.info "Message found empty, not sending it to list."
+        return Errors::MessageEmpty.new(@list)
+      end
+
+      logger.debug "Adding subject_prefix"
+      @mail.add_subject_prefix!
+
+      # Subscriptions
+      logger.debug "Creating clean copy of message"
+      copy = @mail.clean_copy(true)
+      list.send_to_subscriptions(copy)
+      nil
+    end
+
+    private
+
+    def list
+      @list
+    end
+
+    def run_filters(filters)
+      error = filters_runner.run(@mail, filters)
+      if error
+        if list.bounces_notify_admins?
+          text = "#{I18n.t('.bounces_notify_admins')}\n\n#{error}"
+          # TODO: raw_source is mostly blank?
+          logger.notify_admin text, @mail.original_message, I18n.t('notice')
+        end
+        return error
+      end
+    end
+
+    def filters_runner
+      @filters_runner ||= Filters::Runner.new(list)
+    end
+
+    def logger
+      list.present? && list.logger || Schleuder.logger
+    end
+
+    def log_and_return(error, reveal_error=false)
+      Schleuder.logger.error(error)
+      if reveal_error
+        error
+      else
+        # Return an unrevealing error, the sender and all bystanders don't need to know these details.
+        Errors::FatalError.new
+      end
+    end
+
+    def setup_list(recipient)
+      return @list if @list
+
+      logger.info "Loading list '#{recipient}'"
+      if ! @list = List.by_recipient(recipient)
+        return log_and_return(Errors::ListNotFound.new(recipient), true)
+      end
+
+      # Check neccessary 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)
+        return log_and_return(Errors::ListdirProblem.new(@list.listdir, :not_a_directory))
+      elsif ! File.readable?(@list.listdir)
+        return log_and_return(Errors::ListdirProblem.new(@list.listdir, :not_readable))
+      elsif ! File.writable?(@list.listdir)
+        return log_and_return(Errors::ListdirProblem.new(@list.listdir, :not_writable))
+      else
+        if File.exist?(@list.logfile) && ! File.writable?(@list.logfile)
+          return log_and_return(Errors::ListdirProblem.new(@list.logfile, :not_writable))
+        end
+      end
+
+      # Check basic sanity of list.
+      %w[fingerprint key secret_key admins].each do |attrib|
+        if @list.send(attrib).blank?
+          return log_and_return(Errors::ListPropertyMissing.new(@list.listdir, attrib))
+        end
+      end
+
+      # Set locale
+      if I18n.available_locales.include?(@list.language.to_sym)
+        I18n.locale = @list.language.to_sym
+      end
+
+      # This cannot be put in List, as Mail wouldn't know it then.
+      logger.debug "Setting GNUPGHOME to #{@list.listdir}"
+      ENV['GNUPGHOME'] = @list.listdir
+      nil
+    end
+  end
+end

data/lib/schleuder/subscription.rb

@@ -0,0 +1,98 @@
+module Schleuder
+  class Subscription < ActiveRecord::Base
+    belongs_to :list
+
+    validates :list_id, inclusion: {
+                          in: -> (id) { List.pluck(:id) },
+                          message: "must refer to an existing list"
+                        }
+    validates :email, presence: true, email: true, uniqueness: {scope: :list_id}
+    validates :fingerprint, allow_blank: true, fingerprint: true
+    validates :delivery_enabled, :admin, boolean: true
+
+    default_scope { order(:email) }
+
+    scope :without_fingerprint, -> { where(fingerprint: [nil,'']) }
+
+    def to_s
+      email
+    end
+
+    def self.configurable_attributes
+      [:fingerprint, :admin, :delivery_enabled]
+    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)
+    end
+
+    def key
+      # TODO: make key-related methods a concern, so we don't have to go
+      # through the list and neither re-implement the methods here.
+      # Prefix '0x' to force GnuPG to match only hex-values, not UIDs.
+      list.keys("0x#{self.fingerprint}").first
+    end
+
+    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
+
+      if self.key.blank?
+        if self.list.send_encrypted_only?
+          notify_of_missed_message(:absent)
+          return false
+        else
+          list.logger.warn "Sending plaintext because no key is present!"
+        end
+      elsif ! self.key.usable?
+        if self.list.send_encrypted_only?
+          notify_of_missed_message(key.usability_issue)
+          return false
+        else
+          list.logger.warn "Sending plaintext because assigned key is #{key.usability_issue}!"
+        end
+      else
+        gpg_opts.merge!(encrypt: true, keys: {self.email => "0x#{self.fingerprint}"})
+      end
+
+      list.logger.info "Sending message to #{self.email}"
+      mail.gpg gpg_opts
+      mail.deliver
+    end
+
+    def ensure_headers(mail)
+      mail.to = self.email
+      mail.from = self.list.email
+      mail.sender = self.list.bounce_address
+      mail
+    end
+
+    def notify_of_missed_message(reason)
+      self.list.logger.warn "Not sending to #{self.email}: key is unusable because it is #{reason} and sending plain text not allowed"
+      mail = ensure_headers(Mail.new)
+      mail.subject = I18n.t('notice')
+      mail.body = I18n.t("missed_message_due_to_unusable_key", list_email: self.list.email) + I18n.t('errors.signoff')
+      mail.gpg self.list.gpg_sign_options
+      mail.deliver
+    end
+
+    def admin?
+      self.admin == true
+    end
+
+    def delete_key
+      list.delete_key(self.fingerprint)
+    end
+
+  end
+end

data/lib/schleuder/validators/boolean_validator.rb

@@ -0,0 +1,7 @@
+class BooleanValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    if ! [true, false].include?(value)
+      record.errors.add(attribute, I18n.t("errors.must_be_boolean"))
+    end
+  end
+end

data/lib/schleuder/validators/email_validator.rb

@@ -0,0 +1,7 @@
+class EmailValidator <  ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    unless value =~ Conf::EMAIL_REGEXP
+      record.errors[attribute] << (options[:message] || I18n.t("errors.invalid_email"))
+    end
+  end
+end

data/lib/schleuder/validators/fingerprint_validator.rb

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

data/lib/schleuder/validators/greater_than_zero_validator.rb

@@ -0,0 +1,7 @@
+class GreaterThanZeroValidator <  ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    if value.to_i == 0
+      record.errors.add(attribute, I18n.t("errors.must_be_greater_than_zero"))
+    end
+  end
+end