grinch 1.0.0

data/lib/cinch/plugin_list.rb

@@ -0,0 +1,38 @@
+module Cinch
+  # @since 2.0.0
+  class PluginList < Array
+    def initialize(bot)
+      @bot     = bot
+      super()
+    end
+
+    # @param [Class<Plugin>] plugin
+    def register_plugin(plugin)
+      self << plugin.new(@bot)
+    end
+
+    # @param [Array<Class<Plugin>>] plugins
+    def register_plugins(plugins)
+      plugins.each { |plugin| register_plugin(plugin) }
+    end
+
+    # @since 2.0.0
+    def unregister_plugin(plugin)
+      plugin.unregister
+      delete(plugin)
+    end
+
+    # @since 2.0.0
+    def unregister_plugins(plugins)
+      if plugins == self
+        plugins = self.dup
+      end
+      plugins.each { |plugin| unregister_plugin(plugin) }
+    end
+
+    # @since 2.0.0
+    def unregister_all
+      unregister_plugins(self)
+    end
+  end
+end

data/lib/cinch/rubyext/float.rb

@@ -0,0 +1,3 @@
+unless Float.const_defined?(:INFINITY)
+  Float::INFINITY = 1.0/0.0
+end

data/lib/cinch/rubyext/module.rb

@@ -0,0 +1,26 @@
+# Extensions to Ruby's Module class.
+class Module
+  # Like `attr_reader`, but for defining a synchronized attribute
+  # reader.
+  #
+  # @api private
+  def synced_attr_reader(attribute)
+    undef_method(attribute)
+    define_method(attribute) do
+      attr(attribute)
+    end
+
+    define_method("#{attribute}_unsynced") do
+      attr(attribute, false, true)
+    end
+  end
+
+  # Like `attr_accessor`, but for defining a synchronized attribute
+  # accessor
+  #
+  # @api private
+  def synced_attr_accessor(attr)
+    synced_attr_reader(attr)
+    attr_accessor(attr)
+  end
+end

data/lib/cinch/rubyext/string.rb

@@ -0,0 +1,33 @@
+# Extensions to Ruby's String class.
+class String
+  # Like `String#downcase`, but respecting different IRC casemaps.
+  #
+  # @param [:rfc1459, :"strict-rfc1459", :ascii] mapping
+  # @return [String]
+  def irc_downcase(mapping)
+    case mapping
+    when :rfc1459
+      self.tr("A-Z[]\\\\^", "a-z{}|~")
+    when :"strict-rfc1459"
+      self.tr("A-Z[]\\\\", "a-z{}|")
+    else
+      # when :ascii or unknown/nil
+      self.tr("A-Z", "a-z")
+    end
+  end
+
+  # Like `String#upcase`, but respecting different IRC casemaps.
+  #
+  # @param [:rfc1459, :"strict-rfc1459", :ascii] mapping
+  # @return [String]
+  def irc_upcase(mapping)
+    case mapping
+    when :ascii
+      self.tr("a-z", "A-Z")
+    when :rfc1459
+      self.tr("a-z{}|~", "A-Z[]\\\\^")
+    when :"strict-rfc1459"
+      self.tr("a-z{}|", "A-Z[]\\\\")
+    end
+  end
+end

data/lib/cinch/sasl.rb

@@ -0,0 +1,34 @@
+require "cinch/sasl/diffie_hellman"
+require "cinch/sasl/plain"
+require "cinch/sasl/dh_blowfish"
+
+module Cinch
+  # SASL is a modern way of authentication in IRC, solving problems
+  # such as transmitting passwords as plain text (see the DH-BLOWFISH
+  # mechanism) and fully identifying before joining any channels.
+  #
+  # Cinch automatically detects which mechanisms are supported by the
+  # IRC network and uses the best available one.
+  #
+  # # Supported Mechanisms
+  #
+  # - {SASL::DH_Blowfish DH-BLOWFISH}
+  # - {SASL::Plain PLAIN}
+  #
+  # # Configuration
+  # In order to use SASL one has to set the username and password
+  # options as follows:
+  #
+  #     configure do |c|
+  #        c.sasl.username = "foo"
+  #        c.sasl.password = "bar"
+  #     end
+  #
+  # @note All classes and modules in this module are for internal use by
+  #   Cinch only.
+  #
+  # @api private
+  # @since 2.0.0
+  module SASL
+  end
+end

data/lib/cinch/sasl/dh_blowfish.rb

@@ -0,0 +1,71 @@
+require "openssl"
+require "base64"
+require "cinch/sasl/mechanism"
+
+module Cinch
+  module SASL
+    # DH-BLOWFISH is a combination of Diffie-Hellman key exchange and
+    # the Blowfish encryption algorithm. Due to its nature it is more
+    # secure than transmitting the password unencrypted and can be
+    # used on potentially insecure networks.
+    class DH_Blowfish < Mechanism
+      class << self
+        # @return [String]
+        def mechanism_name
+          "DH-BLOWFISH"
+        end
+
+        # @return [Array(Numeric, Numeric, Numeric)] p, g and y for DH
+        def unpack_payload(payload)
+          pgy     = []
+          payload = payload.dup
+
+          3.times do
+            size = payload.unpack("n").first
+            payload.slice!(0, 2)
+            pgy << payload.unpack("a#{size}").first
+            payload.slice!(0, size)
+          end
+
+          pgy.map {|i| OpenSSL::BN.new(i, 2).to_i}
+        end
+
+        # @param [String] user
+        # @param [String] password
+        # @param [String] payload
+        # @return [String]
+        def generate(user, password, payload)
+          # duplicate the passed strings because we are modifying them
+          # later and they might come from the configuration store or
+          # similar
+          user     = user.dup
+          password = password.dup
+
+          data = Base64.decode64(payload).force_encoding("ASCII-8BIT")
+
+          p, g, y = unpack_payload(data)
+
+          dh      = DiffieHellman.new(p, g, 23)
+          pub_key = dh.generate
+          secret  = OpenSSL::BN.new(dh.secret(y).to_s).to_s(2)
+          public  = OpenSSL::BN.new(pub_key.to_s).to_s(2)
+
+          # Pad password so its length is a multiple of the cipher block size
+          password << "\0"
+          password << "." * (8 - (password.size % 8))
+
+          crypted = ""
+          cipher = OpenSSL::Cipher.new("BF-ECB")
+          cipher.key_len = 32 # OpenSSL's default of 16 doesn't work
+          cipher.encrypt
+          cipher.key = secret
+
+          crypted = cipher.update(password) # we do not want the content of cipher.final
+
+          answer = [public.bytesize, public, user, crypted].pack("na*Z*a*")
+          Base64.strict_encode64(answer)
+        end
+      end
+    end
+  end
+end

data/lib/cinch/sasl/diffie_hellman.rb

@@ -0,0 +1,47 @@
+module Cinch
+  module SASL
+    class DiffieHellman
+      attr_reader :p, :g, :q, :x, :e
+
+      def initialize(p, g, q)
+        @p = p
+        @g = g
+        @q = q
+      end
+
+      def generate(tries = 16)
+        tries.times do
+          @x = rand(@q)
+          @e = mod_exp(@g, @x, @p)
+          return @e if valid?
+        end
+        raise ArgumentError, "can't generate valid e"
+      end
+
+      # compute the shared secret, given the public key
+      def secret(f)
+        mod_exp(f, @x, @p)
+      end
+
+      private
+      # validate a public key
+      def valid?
+        @e && @e.between?(2, @p - 2) && bits_set(@e) > 1
+      end
+
+      def bits_set(e)
+        ("%b" % e).count('1')
+      end
+
+      def mod_exp(b, e, m)
+        result = 1
+        while e > 0
+          result = (result * b) % m if e[0] == 1
+          e = e >> 1
+          b = (b * b) % m
+        end
+        return result
+      end
+    end
+  end
+end

data/lib/cinch/sasl/mechanism.rb

@@ -0,0 +1,6 @@
+module Cinch
+  module SASL
+    class Mechanism
+    end
+  end
+end

data/lib/cinch/sasl/plain.rb

@@ -0,0 +1,26 @@
+require "base64"
+require "cinch/sasl/mechanism"
+
+module Cinch
+  module SASL
+    # The simplest mechanisms simply transmits the username and
+    # password without adding any encryption or hashing. As such it's more
+    # insecure than DH-BLOWFISH and should only be used in combination with
+    # SSL.
+    class Plain < Mechanism
+      class << self
+        # @return [String]
+        def mechanism_name
+          "PLAIN"
+        end
+
+        # @param [String] user
+        # @param [String] password
+        # @return [String]
+        def generate(user, password, _ = nil)
+          Base64.strict_encode64([user, user, password].join("\0"))
+        end
+      end
+    end
+  end
+end

data/lib/cinch/syncable.rb

@@ -0,0 +1,83 @@
+module Cinch
+  # Provide blocking access to user/channel information.
+  module Syncable
+    # Blocks until the object is synced.
+    #
+    # @return [void]
+    # @api private
+    def wait_until_synced(attr)
+      attr = attr.to_sym
+      waited = 0
+      while true
+        return if attribute_synced?(attr)
+        waited += 1
+
+        if waited % 100 == 0
+          bot.loggers.warn "A synced attribute ('%s' for %s) has not been available for %d seconds, still waiting" % [attr, self.inspect, waited / 10]
+          bot.loggers.warn caller.map {|s| "  #{s}"}
+
+          if waited / 10 >= 30
+            bot.loggers.warn "  Giving up..."
+            raise Exceptions::SyncedAttributeNotAvailable, "'%s' for %s" % [attr, self.inspect]
+          end
+        end
+        sleep 0.1
+      end
+    end
+
+    # @api private
+    # @return [void]
+    def sync(attribute, value, data = false)
+      if data
+        @data[attribute] = value
+      else
+        instance_variable_set("@#{attribute}", value)
+      end
+      @synced_attributes << attribute
+    end
+
+    # @return [Boolean]
+    # @api private
+    def attribute_synced?(attribute)
+      @synced_attributes.include?(attribute)
+    end
+
+    # @return [void]
+    # @api private
+    def unsync(attribute)
+      @synced_attributes.delete(attribute)
+    end
+
+    # @return [void]
+    # @api private
+    # @since 1.0.1
+    def unsync_all
+      @synced_attributes.clear
+    end
+
+    # @param [Symbol] attribute
+    # @param [Boolean] data
+    # @param [Boolean] unsync
+    # @api private
+    def attr(attribute, data = false, unsync = false)
+      unless unsync
+        if @when_requesting_synced_attribute
+          @when_requesting_synced_attribute.call(attribute)
+        end
+        wait_until_synced(attribute)
+      end
+
+      if data
+        return @data[attribute]
+      else
+        return instance_variable_get("@#{attribute}")
+      end
+    end
+
+    # @api private
+    # @return [void]
+    def mark_as_synced(attribute)
+      @synced_attributes << attribute
+    end
+  end
+end

data/lib/cinch/target.rb

@@ -0,0 +1,199 @@
+module Cinch
+  # @since 2.0.0
+  class Target
+    include Comparable
+
+    # @return [String]
+    attr_reader :name
+    # @return [Bot]
+    attr_reader :bot
+    def initialize(name, bot)
+      @name = name
+      @bot  = bot
+    end
+
+    # Sends a NOTICE to the target.
+    #
+    # @param [#to_s] text the message to send
+    # @return [void]
+    # @see #safe_notice
+    def notice(text)
+      send(text, true)
+    end
+
+    # Sends a PRIVMSG to the target.
+    #
+    # @param [#to_s] text the message to send
+    # @param [Boolean] notice Use NOTICE instead of PRIVMSG?
+    # @return [void]
+    # @see #safe_msg
+    # @note The aliases `msg` and `privmsg` are deprecated and will be
+    #   removed in a future version.
+    def send(text, notice = false)
+      # TODO deprecate `notice` argument, put splitting into own
+      # method
+      text = text.to_s
+      split_start = @bot.config.message_split_start || ""
+      split_end   = @bot.config.message_split_end   || ""
+      command = notice ? "NOTICE" : "PRIVMSG"
+      prefix = ":#{@bot.mask} #{command} #{@name} :"
+
+      text.lines.map(&:chomp).each do |line|
+        splitted = split_message(line, prefix, split_start, split_end)
+
+        splitted[0, (@bot.config.max_messages || splitted.size)].each do |string|
+          @bot.irc.send("#{command} #@name :#{string}")
+        end
+      end
+    end
+    alias_method :msg, :send # deprecated
+    alias_method :privmsg, :send # deprecated
+    undef_method(:msg) # yardoc hack
+    undef_method(:privmsg) # yardoc hack
+
+    # @deprecated
+    def msg(*args)
+      Cinch::Utilities::Deprecation.print_deprecation("2.2.0", "Target#msg", "Target#send")
+      send(*args)
+    end
+
+    # @deprecated
+    def privmsg(*args)
+      Cinch::Utilities::Deprecation.print_deprecation("2.2.0", "Target#privmsg", "Target#send")
+      send(*args)
+    end
+
+    # Like {#send}, but remove any non-printable characters from
+    # `text`. The purpose of this method is to send text of untrusted
+    # sources, like other users or feeds.
+    #
+    # Note: this will **break** any mIRC color codes embedded in the
+    # string. For more fine-grained control, use
+    # {Helpers#Sanitize} and
+    # {Formatting.unformat} directly.
+    #
+    # @return (see #send)
+    # @param (see #send)
+    # @see #send
+    def safe_send(text, notice = false)
+      send(Cinch::Helpers.sanitize(text), notice)
+    end
+    alias_method :safe_msg, :safe_send # deprecated
+    alias_method :safe_privmsg, :safe_msg # deprecated
+    undef_method(:safe_msg) # yardoc hack
+    undef_method(:safe_privmsg) # yardoc hack
+
+    # @deprecated
+    def safe_msg(*args)
+      Cinch::Utilities::Deprecation.print_deprecation("2.2.0", "Target#safe_msg", "Target#safe_send")
+      send(*args)
+    end
+
+    # @deprecated
+    def safe_privmsg(*args)
+      Cinch::Utilities::Deprecation.print_deprecation("2.2.0", "Target#safe_privmsg", "Target#safe_send")
+      send(*args)
+    end
+
+
+    # Like {#safe_msg} but for notices.
+    #
+    # @return (see #safe_msg)
+    # @param (see #safe_msg)
+    # @see #safe_notice
+    # @see #notice
+    def safe_notice(text)
+      safe_send(text, true)
+    end
+
+    # Invoke an action (/me) in/to the target.
+    #
+    # @param [#to_s] text the message to send
+    # @return [void]
+    # @see #safe_action
+    def action(text)
+      line = text.to_s.each_line.first.chomp
+      @bot.irc.send("PRIVMSG #@name :\001ACTION #{line}\001")
+    end
+
+    # Like {#action}, but remove any non-printable characters from
+    # `text`. The purpose of this method is to send text from
+    # untrusted sources, like other users or feeds.
+    #
+    # Note: this will **break** any mIRC color codes embedded in the
+    # string. For more fine-grained control, use
+    # {Helpers#Sanitize} and
+    # {Formatting.unformat} directly.
+    #
+    # @param (see #action)
+    # @return (see #action)
+    # @see #action
+    def safe_action(text)
+      action(Cinch::Helpers.sanitize(text))
+    end
+
+    # Send a CTCP to the target.
+    #
+    # @param [#to_s] message the ctcp message
+    # @return [void]
+    def ctcp(message)
+      send "\001#{message}\001"
+    end
+
+    def concretize
+      if @bot.isupport["CHANTYPES"].include?(@name[0])
+        @bot.channel_list.find_ensured(@name)
+      else
+        @bot.user_list.find_ensured(@name)
+      end
+    end
+
+    # @return [Boolean]
+    def eql?(other)
+      self == other
+    end
+
+    # @param [Target, String] other
+    # @return [-1, 0, 1, nil]
+    def <=>(other)
+      casemapping = @bot.irc.isupport["CASEMAPPING"]
+      left = @name.irc_downcase(casemapping)
+
+      if other.is_a?(Target)
+        left <=> other.name.irc_downcase(casemapping)
+      elsif other.is_a?(String)
+        left <=> other.irc_downcase(casemapping)
+      else
+        nil
+      end
+    end
+
+    private
+    def split_message(msg, prefix, split_start, split_end)
+      max_bytesize = 510 - prefix.bytesize
+      max_bytesize_without_end = max_bytesize - split_end.bytesize
+
+      if msg.bytesize <= max_bytesize
+        return [msg]
+      end
+
+      splitted = []
+      while msg.bytesize > max_bytesize_without_end
+        acc = 0
+        acc_rune_sizes = msg.each_char.map {|ch|
+          acc += ch.bytesize
+        }
+
+        max_rune = acc_rune_sizes.rindex {|bs| bs <= max_bytesize_without_end} || 0
+        r = [msg.rindex(/\s/, max_rune) || (max_rune + 1), 1].max
+
+        splitted << (msg[0...r] + split_end)
+        msg = split_start.tr(" ", "\cz") + msg[r..-1].lstrip
+      end
+      splitted << msg
+
+      # clean string from any substitute characters
+      splitted.map {|string| string.tr("\cz", " ")}
+    end
+  end
+end