cinch 1.1.3 → 2.0.0.pre.1

data/lib/cinch/plugin_list.rb

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

@@ -1,4 +1,8 @@
+# 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)
     define_method(attribute) do
@@ -10,6 +14,9 @@ class Module
     end
   end
 
+  # Like `attr_accessor`, but for defining a synchronized attribute
+  # accessor
+  #
   # @api private
   def synced_attr_accessor(attr)
     synced_attr_reader(attr)

data/lib/cinch/rubyext/string.rb

@@ -1,4 +1,9 @@
+# Extensions to Ruby's String class.
 class String
+  # Like `String#downcase`, but respecting different IRC casemaps.
+  #
+  # @param [Symbol<:rfc1459, :strict-rfc1459, :ascii>] mapping
+  # @return [String]
   def irc_downcase(mapping)
     case mapping
     when :rfc1459
@@ -11,6 +16,10 @@ class String
     end
   end
 
+  # Like `String#upcase`, but respecting different IRC casemaps.
+  #
+  # @param [Symbol<:rfc1459, :strict-rfc1459, :ascii>] mapping
+  # @return [String]
   def irc_upcase(mapping)
     case mapping
     when :ascii

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<Number, Number, Number>] 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)
+          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")
+
+          while password.size > 0 do
+            # We have to reinitialize this every time because for OpenSSL, "BF" is synonynmous with "BF-CBC", and we do not want CBC
+            cipher.reset
+            cipher.key_len = 32 # OpenSSL's default of 16 doesn't work
+            cipher.encrypt
+            cipher.key = secret
+
+            clear = password.slice!(0, 8)
+            crypted << cipher.update(clear) # we do not want the content of cipher.final
+          end
+
+          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/storage.rb

@@ -0,0 +1,62 @@
+module Cinch
+  # @since 2.0.0
+  class Storage
+    include Enumerable
+
+    # @param [Hash] options
+    # @param [Plugin] plugin
+    def initialize(options, plugin)
+    end
+
+    # @param [Object] key
+    # @return [Object, nil]
+    def [](key)
+    end
+
+    # @param [Object] key
+    # @param [Object] value
+    # @return [value]
+    def []=(key, value)
+    end
+
+    # @return [self]
+    def each
+      self
+    end
+
+    # @return [self]
+    def each_key
+      self
+    end
+
+    # @return [self]
+    def each_value
+      self
+    end
+
+    # @param [Object] key
+    # @return [Boolean]
+    def has_key?(key)
+      false
+    end
+    alias_method :include?, :has_key?
+    alias_method :key?, :has_key?
+    alias_method :member?, :has_key?
+
+    # @param [Object] key
+    # @return [Object, nil] The deleted object
+    def delete(key)
+    end
+
+    # @return [self]
+    def delete_if
+      self
+    end
+
+    def save
+    end
+
+    def unload
+    end
+  end
+end

data/lib/cinch/storage/null.rb

@@ -0,0 +1,12 @@
+require "cinch/storage"
+
+module Cinch
+  class Storage
+    # The Null storage is the default storage (used if the user didn't
+    # supply a different storage) and will simply ignore all requests.
+    # This way, plugins will continue to work if programmed properly,
+    # but no data will be preserved.
+    class Null < Storage
+    end
+  end
+end

data/lib/cinch/storage/yaml.rb

@@ -0,0 +1,96 @@
+require "cinch/storage"
+require "yaml"
+
+module Cinch
+  class Storage
+    # A basic storage backed by YAML, using one file per plugin.
+    class YAML < Storage
+      # (see Storage#initialize)
+      def initialize(options, plugin)
+        # We are a basic example, so we load everything into memory. yey.
+        @file = options.basedir + plugin.class.plugin_name + ".yaml"
+        if File.exist?(@file)
+          @yaml = ::YAML.load_file(@file) || {}
+        else
+          @yaml = {}
+        end
+        @options = options
+
+        @mutex = Mutex.new
+      end
+
+      # (see Storage#[])
+      def [](key)
+        @yaml[key]
+      end
+
+      # (see Strage#[]=)
+      def []=(key, value)
+        @yaml[key] = value
+      end
+
+      # (see Storage#has_key?)
+      def has_key?(key)
+        @yaml.has_key?(key)
+      end
+      alias_method :include?, :has_key?
+      alias_method :key?, :has_key?
+      alias_method :member?, :has_key?
+
+      # (see Storage#each)
+      def each
+        @yaml.each {|e| yield(e)}
+
+        self
+      end
+
+      # (see Storage#each_key)
+      def each_key
+        @yaml.each_key {|e| yield(e)}
+
+        self
+      end
+
+      # (see Storage#each_value)
+      def each_value
+        @yaml.each_value {|e| yield(e)}
+
+        self
+      end
+
+      # (see Storage#delete)
+      def delete(key)
+        obj = @yaml.delete(key)
+
+        obj
+      end
+
+      # (see Storage#delete_if)
+      def delete_if
+        delete_keys = []
+        each do |key, value|
+          delete_keys << key if yield(key, value)
+        end
+
+        delete_keys.each do |key|
+          delete(key)
+        end
+
+        self
+      end
+
+      # (see Storage#save)
+      def save
+        @mutex.synchronize do
+          File.open(@file, "w") do |f|
+            f.write @yaml.to_yaml
+          end
+        end
+      end
+
+      # (see Storage#unload)
+      def unload
+      end
+    end
+  end
+end

data/lib/cinch/syncable.rb

@@ -1,4 +1,5 @@
 module Cinch
+  # Provide blocking access to user/channel information.
   module Syncable
     # Blocks until the object is synced.
     #
@@ -6,8 +7,16 @@ module Cinch
     # @api private
     def wait_until_synced(attr)
       attr = attr.to_sym
+      waited = 0
       while true
-        return if @synced_attributes.include?(attr)
+        return if synced?(attr)
+        waited += 1
+
+        if waited % 100 == 0
+          # TODO improve this message
+          bot.loggers.warn "A synced attribute ('%s') has not been available for %d seconds, still waiting" % [attr, waited / 10]
+          bot.loggers.warn caller.map {|s| "  #{s}"}
+        end
         sleep 0.1
       end
     end
@@ -42,6 +51,9 @@ module Cinch
       @synced_attributes.clear
     end
 
+    # @param [Symbol] attribute
+    # @param [Boolean] data
+    # @param [Boolean] unsync
     # @api private
     def attr(attribute, data = false, unsync = false)
       unless unsync