encinch 0.0.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edb2e2e7c096ffda8693dcd2c641689724862796
-  data.tar.gz: 2d8fcb47f7ee5ef3673503654d9cb6224f86d07f
+  metadata.gz: eef846946cd6db68553cec479300a1a1ccdda651
+  data.tar.gz: 94241b2ebd043cd8487a6830f22c2493a278c135
 SHA512:
-  metadata.gz: 589cea1054cbf7f40b792fd6e52b9e51b4d69f81171f13819d204be8616c3576586f44a19a1590cc54a0e1efe80aaa393fe7a1dcf1717a4a8b190c18018ea36f
-  data.tar.gz: 5f640b06f13ca5e1c253ee0bae607762c22dec34e11b7201121a6f02e410cd7377c35825d49e41453448e035defc703bacbfc296377f886aa56ffa6badc97580
+  metadata.gz: 7d31b2e1bbdb8bb29b73621252a4fc429029c19f053e0424398ac4de72c226d0ff371d7a623a276be7ab510fbc7c74f25fc95228d192953371a420116e7aa567
+  data.tar.gz: 57041d4c9528d1f4f20ebb7ebf38bcfe5560d875e8ced00d2a4a056cd6f4f9895aa55676c34696b8f7ed83a05e15cf1c5d2dc6d9814d2aac37f6c2d25f635ec0

data/.gitignore

@@ -21,3 +21,5 @@ tmp
 *.o
 *.a
 mkmf.log
+bot.rb
+*.yml

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Jason Franz
+Copyright (c) 2016 Jason Franz
 
 MIT License
 

data/README.md

@@ -11,7 +11,7 @@ https://github.com/cinchrb/cinch
   $[sudo] gem install encinch
 
 ## Example
-  ```
+  ```ruby
   require 'cinch'
   require 'cinch/plugins/encinch'
 
@@ -22,18 +22,21 @@ https://github.com/cinchrb/cinch
       c.server          = "irc.freenode.org"
       c.port            = 7000
       c.ssl.use         = true
-      c.channels        = ["#cryptedchan", "#plaintext"]
+      c.channels        = ["#cryptedchan", "#plaintext", "#ignorechannel"]
 
       c.plugins.plugins = [Cinch::Plugins::EnCinch] # optionally add more plugins
 
       c.plugins.options[Cinch::Plugins::EnCinch] = {
-        :ignore     => ["#ignorechannel", "ignoreperson"],
+        :drop       => true,
+        :key_file   => 'keys/key.yml',
+        :uncrypted  => ["#plaintext"],
+        :ignore     => ["#ignorechan", "ignoreperson"],
         :encrypt    => {
-          '#cryptedchan'  => "myfishkey",
-          'cryptednick'   => "notmyfishkey",
-          :default        => "adefaultfishkey"
-        },
-        :uncrypted  => ["#plaintext"]
+          '#cryptedchan'  => 'myfishkey',
+          '#ignorechan'   => 'ignoretargetscanhaveencryptionkeys'
+          'cryptednick'   => 'mypersonalfishkey',
+          :default        => 'defaultfishkey'
+        }
       }
     end
   end
@@ -41,25 +44,38 @@ https://github.com/cinchrb/cinch
   bot.start
   ```
 
+## Features
+  - Simple transparent message encryption for your Cinch IRC bot.
+  - Nicks with personal keys are updated on nick change.
+  - Ignore incoming encrypted messages from specific channels or users.
+  - Allow unencrypted messages to specific channels or users.
+  - Drop messages if target key not found.
+  - Ability to define default encryption key.
+  - Keys and options stored in yaml.
+
 ## Commands
-  None, yet. 
+  None. You should write your own plugin to add or remove keys, tailored to your particular needs.
 
 
 ## Options
 ### :encrypt
 A hash of encryption targets and their corresponding encryption keys. Targets should all be lowercase.
-:default can provide a general purpose key, generally good for private communications with the bot.
-The :encrypt option must be set, :default is optional.
+`:default` can provide a general purpose key, possibly good for private communications with the bot or ensuring it does not respond unencrypted.
 
 ### :uncrypted
-An array of channels and individuals from which the bot will not encrypt messages. All entries must be lowercase. This option must be set. If there are no desired unencrypted targets set an empty array.
+An array of channels and individuals from which the bot will not encrypt messages. All entries must be lowercase.
+`:uncrypted` is optional.
 
 ### :ignore
-An array of channels and individuals (other bots?) to ignore encrypted messages. All entries must be lower case.
-:ignore is optional.
+An array of channels and individuals (other bots?) to ignore encrypted messages. All entries must be lower case. Note that it will not drop messages sent from the bot.
+`:ignore` is optional.
+
+### :drop
+Boolean value indicating if unencrypted messages should be dropped. Targets in the `:uncrypted` array are not affected. Unnecessary if a `:default` key is set.
+
+### :key_file
+Options are now stored in yaml. The default location is 'keys/encinch.yml'. Supply an alternate location if you so desire. Location will be created if it does not exist.
 
 ## TODO
-  1) keyexchange
-  2) maybe store keys to a file?
-  3) add commands for updating, removing and adding keys and other settings?
-  4) user feedback... :-)
+  1. key exchange
+  2. user feedback... :-)

data/Rakefile

@@ -0,0 +1,24 @@
+task default: :test
+
+task :test do
+  require 'rake/testtask'
+
+  files_list = Dir[File.join "test", "**", "*.rb"]
+  files      = ENV['file'].split(',') rescue nil
+  verbose    = !!ENV['verbose']
+
+  Rake::TestTask.new do |t|
+    t.verbose = verbose
+    t.test_files = if files
+                     files.unshift "helper.rb"
+                     files.map do |file|
+                       unless index = files_list.index { |f| f.match(/\/#{file}$/) }
+                         raise "UnknownFileError #{ file }"
+                       end
+                       files_list[index]
+                     end
+                   else
+                     files_list
+                   end
+  end
+end

data/encinch.gemspec

@@ -5,7 +5,7 @@ require 'cinch/plugins/encinch/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "encinch"
-  spec.version       = EnCinch::Version::VERSION
+  spec.version       = ::Cinch::Plugins::EnCinch::VERSION
   spec.authors       = ["jfrazx"]
   spec.email         = ["staringblind@gmail.com"]
   spec.summary       = %q{Transparent blowfish encryption plugin for Cinch: An IRC Bot Building Framework}
@@ -20,5 +20,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "cinch", "~> 2.0"
+  spec.add_runtime_dependency "cinch-storage", "~> 1.2"
   spec.add_runtime_dependency "crypt", "~> 2.0"
+
+  spec.add_development_dependency "rake", "~> 11.0"
+  spec.add_development_dependency "minitest", "~> 5.8"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1"
 end

data/lib/cinch/plugins/encinch.rb

@@ -1,5 +1,9 @@
 require 'cinch'
+require 'cinch/storage'
 require 'crypt/blowfish'
+
 require "cinch/plugins/encinch/encryption"
+require "cinch/plugins/encinch/storage"
 require "cinch/plugins/encinch/encinch"
 require "cinch/plugins/encinch/extend"
+require "cinch/plugins/encinch/version"

data/lib/cinch/plugins/encinch/encinch.rb

@@ -1,137 +1,123 @@
 
 module Cinch
   module Plugins
-      class EnCinch
-        include Cinch::Plugin
+    class EnCinch
+      include Cinch::Plugin
 
-        def initialize(*)
-          super
+      def initialize(*)
+        super
+        config[:uncrypted] ||= Array.new
+        config[:ignore]    ||= Array.new
+        config[:encrypt]   ||= Hash.new
 
-          # does Cinch have something to checked required options already???
-          raise MissingRequiredPluginOptions unless config[:encrypt]
-          raise MissingRequiredPluginOptions unless config[:uncrypted]
-
-        end
-
-        #
-        # All blowfish communication should be prefixed with +OK
-        # capture this to start the process
-        #
-
-        match(/\+OK (\S+)/, use_prefix: false, strip_colors: true, method: :capture)
-
-        def capture(m, message)
-          target = (m.channel ? m.channel.name : m.user.nick).downcase
-          message = strip(m, message)
-
-          return if config[:ignore].include?(target) rescue nil
-          @key = config[:encrypt][target] || config[:encrypt][:default] rescue nil
+        shared[:encinch] = EnCinch::Storage.new(bot, config.dup)
+      end
 
-          return unless @key
+      #
+      # All blowfish communication should be prefixed with +OK
+      # capture this to start the process
+      #
 
-          blowfish(@key)
+      match(/\+OK (\S+)/, use_prefix: false, strip_colors: true, method: :capture)
+      def capture(m, message)
+        target = (m.channel? ? m.channel.name : m.user.nick).downcase
 
-          decrypted = decrypt(message)
-          decrypted << '\u0001' if m.action?
+        options = shared[:encinch].storage.data
 
-          raw = modify_raw(m.raw, decrypted)
+        return if options[:ignore].include?(target)
+        return unless key = options[:encrypt][target] || options[:encrypt][:default]
 
-          dispatch(Message.new(raw, m.bot))
-        end
+        blowfish(key)
 
-        #
-        # matching for key exchange
-        # NOT WORKING YET
-        # It appears Cinch does not emit a :notice event, unfortunate
-        #
+        message = strip(message)
+        decrypted = decrypt(message)
 
-        match(/DH1080_INIT/, use_prefix: false, react_on: [:private, :notice], method: :key_exchange)
+        @fish = nil
 
-        def key_exchange(m)
-          return if m.channel?
+        decrypted << '\u0001' if m.action?
+        raw = modify_raw(m.raw, decrypted)
 
-          debug "captured key exchange event with key: #{m.message}"
+        dispatch(Message.new(raw, m.bot))
+      end
 
-          #TODO -- everything
-        end
+      #
+      # matching for key exchange
+      # NOT WORKING YET
+      #
+      # DH1080_INIT U5bsJHJUvzIeflIxOvz+wht3LojOx8JEz83wa5ByfN9yQlT2AlW6fjp277w4TmElwwLzOxhBA/W/7kwW5FJ4MxmZuxT9q2caMS2jbGXKpW5P6UcIQ7fg2yLqyl8KgU4X5JnC61zeoF5QwyemXdegstq90V6Cn3MqRPeeN2A7HCOeU0O52YD4A
+      match(/DH1080_INIT (\S+)\s*(cbc|CBC)?/, use_prefix: false, react_on: :notice, method: :key_exchange)
+      def key_exchange(m, key, cbc = false)
+        return if m.channel?
 
-        # not sure this is actually needed
-        def encrypt(message)
-          @fish.encrypt(message)
-        end
+        debug "captured key exchange event with key: #{m.message}"
 
-        def decrypt(message)
-          @fish.decrypt(message)
-        end
+        #TODO -- everything
+      end
 
-        def blowfish(key)
-          @fish = Cinch::Plugins::EnCinch::Encryption.new(key)
-        end
+      def encrypt(message)
+        @fish.encrypt(message)
+      end
 
-        private
+      def decrypt(message)
+        @fish.decrypt(message)
+      end
 
-        def dispatch(msg)
-          events = [[:catchall]]
+      def blowfish(key)
+        @fish = Encryption.new(key)
+      end
 
-          if ["PRIVMSG", "NOTICE"].include?(msg.command)
-            events << [:ctcp] if msg.ctcp?
+      def encrypted?(data)
+        !!data.match(/\+OK \S+/)
+      end
 
-            if msg.channel?
-              events << [:channel]
-            else
-              events << [:private]
-            end
+      private
+      def dispatch(msg)
+        events = [[:catchall]]
 
-            if msg.command == "PRIVMSG"
-              events << [:message]
-            else 
-              events << [:notice]
-            end
+        if ["PRIVMSG", "NOTICE"].include?(msg.command)
+          events << [:ctcp] if msg.ctcp?
 
-            if msg.action?
-              events << [:action]
-            end
+          if msg.channel?
+            events << [:channel]
+          else
+            events << [:private]
           end
 
-          meth = "on_#{msg.command.downcase}"
-          __send__(meth, msg, events) if respond_to?(meth, true)
+          if msg.command == "PRIVMSG"
+            events << [:message]
+          end
 
-          if msg.error?
-            events << [:error]
+          if msg.action?
+            events << [:action]
           end
+        end
 
-          events << [msg.command.downcase.to_sym]
+        meth = "on_#{msg.command.downcase}"
+        __send__(meth, msg, events) if respond_to?(meth, true)
 
-          msg.events = events
+        events << [:error] if msg.error?
 
-          #if its still encrypted for whatever reason we will not be processing it again
-          msg.events.each do |event, *args|
-            msg.bot.handlers.dispatch(event, msg, *args)
-          end unless encrypted?(msg.raw) 
-        end
+        events << [msg.command.downcase.intern]
 
-        # 
-        # TODO: strip ctcp? others?
-        #
+        msg.events = events
 
-        def strip(m, data)
-          data.sub!(/\u0001$/, '') if m.action?
-
-          data
-        end
+        #if its still encrypted for whatever reason we will not be processing it again
+        msg.events.each do |event, *args|
+          msg.bot.handlers.dispatch(event, msg, *args)
+        end unless encrypted?(msg.raw)
+      end
 
-        def encrypted?(data)
-          !!data.match(/\+OK \S+/)
-        end
+      def strip(data)
+        data.sub(/\u0001$/, '')
+      end
 
-        #
-        # replace the encrypted message with the decrypted
-        #
+      #
+      # replace the encrypted message with the decrypted
+      #
 
-        def modify_raw(data, decrypted)
-          data.sub!(/\+OK \S+(\s+)?(\S+)?/, decrypted)
-          data
-        end
+      def modify_raw(data, decrypted)
+        data.sub(/\+OK \S+(\s+\S+)?/, decrypted)
       end
+    end
   end
 end

data/lib/cinch/plugins/encinch/encryption.rb

@@ -3,14 +3,14 @@
 # https://github.com/cinchrb/cinch/tree/feature/fish
 # or from weechat's fish plugin
 # https://github.com/weechat/scripts/blob/master/ruby/weefish.rb
-# 
+#
 
 module Cinch
   module Plugins
     class EnCinch
       class Encryption
         module Base64
-        
+
           Alphabet = "./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".freeze
 
           def self.encode(data)
@@ -31,28 +31,28 @@ module Cinch
               end
             end
 
-            return res
+            res
           end
 
           def self.decode(data)
             res = String.new
             data = data.dup.force_encoding("BINARY")
+
             data.chars.each_slice(12) do |slice|
               slice = slice.join
               left = right = 0
-
-              slice[0..5].each_char.with_index do |p, i|
-                right |= Alphabet.index(p) << (i * 6)
+              slice[0..5].each_char.with_index do |pi, i|
+                right |= Alphabet.index(pi) << (i * 6)
               end
 
-              slice[6..11].each_char.with_index do |p, i|
-                left |= Alphabet.index(p) << (i * 6)
+              slice[6..11].each_char.with_index do |pi, i|
+                left |= Alphabet.index(pi) << (i * 6)
               end
 
               res << [left, right].pack('L>L>')
             end
 
-            return res
+            res
           end
         end
 
@@ -60,48 +60,45 @@ module Cinch
         def initialize(key)
           @blowfish = Crypt::Blowfish.new(key)
         end
-        
-        def encrypt(text)
-          text = pad(text, 8)
+
+        def encrypt(data)
+          data = pad(data, 8)
           result = String.new
-          
-          num_block = text.length / 8
+
+          num_block = data.length / 8
           num_block.times do |n|
-            block = text[n*8..(n+1)*8-1]
+            block = data[n * 8..(n + 1) * 8 - 1]
             enc = @blowfish.encrypt_block(block)
             result += Base64.encode(enc)
           end
-          
-          return "+OK " << result
+
+          "+OK " << result
         end
-        
-        def decrypt(text)
-          return nil if not text.length % 12 == 0
-          
+
+        def decrypt(data)
+          data.sub!(/^\+OK\s+/, '')
+
+          return nil if not data.length % 12 == 0
+
           result = String.new
-          
-          num_block = (text.length / 12).to_i
+
+          num_block = (data.length / 12).to_i
           num_block.times do |n|
-            block = Base64.decode( text[n*12..(n+1)*12-1] )
+            block = Base64.decode( data[n*12..(n + 1)*12-1] )
             result += @blowfish.decrypt_block(block)
           end
-          
-          return result.gsub(/\0*$/, "")
-        end
 
-        def self.generate
-          # generate a key for key exchange
+          result.gsub(/\0*$/, '')
         end
-        
+
         private
-        
-        def pad(text, n=8)
-          pad_num = n - (text.length % n)
-          if pad_num > 0 and pad_num != n
-            pad_num.times { text += 0.chr }
-          end
 
-          return text
+        def pad(data, n=8)
+          pad_num = n - (data.length % n)
+
+          pad_num.times { data += 0.chr } if pad_num > 0 and pad_num != n
+
+          data
         end
       end
     end

data/lib/cinch/plugins/encinch/extend.rb

@@ -1,47 +1,46 @@
 
 module Cinch
-  module Exceptions
-
-    # error to raise for missing required plugin options
-    class MissingRequiredPluginOptions < Generic
-    end
-  end
-
-
   class IRC
 
+    # alias instead of modify directly
+    alias :encinch_send :send
+
     # Send a message to the server.
     # @param [String] msg
     # @return [void]
     def send(msg)
-
-      # TODO match and modify ACTION
       if msg.match(/(PRIVMSG|NOTICE)/) && !msg.match(/\+OK (\S+)/)
+        _, _, target, message = *msg.match(/(\S+) (\S+) :(.*)/m)
+        target.downcase!
 
-        verb, target, *message = msg.split
-        message = message.join(' ')[1..-1] rescue nil
+        unless message.empty?
+          # retrieve bot options
+          options = @bot.config.shared[:encinch].storage.data
 
-        # retrieve bot options
-        if (message && !message.empty?) && options = @bot.config.plugins.options[Cinch::Plugins::EnCinch]
+          # ignore if target is in the 'uncrypted' array
+          unless options[:uncrypted].include?(target)
 
-          # key exists
-          if key = (options[:encrypt][target.downcase] || options[:encrypt][:default])
+            # match ctcp? and action messages
+            if matched = message.match(/\001ACTION\s(.+)\001/)
+              message = matched[-1]
+            elsif message =~ /\001.+\001/
+              return encinch_send(msg)
+            end
 
-            # ignore if target is in the 'uncrypted' array
-            unless options[:uncrypted].include?(target.downcase)
+            # key exists
+            if key = (options[:encrypt][target] || options[:encrypt][:default])
 
-              fish = Cinch::Plugins::EnCinch::Encryption.new(key)
-              encrypted = fish.encrypt(message)
+              encrypted = Cinch::Plugins::EnCinch::Encryption.new(key).encrypt(message)
               msg.sub!(message, encrypted)
+
+            else
+              return if options[:drop]
             end
           end
         end
-      end   
+      end
 
-      @queue.queue(msg)
+      encinch_send(msg)
     end
-
-    private
-
   end
 end

data/lib/cinch/plugins/encinch/storage.rb

@@ -0,0 +1,66 @@
+module Cinch
+  module Plugins
+    class EnCinch
+      class Storage
+        include Cinch::Plugin
+
+        attr_reader :storage
+
+        def initialize(bot, data)
+          super(bot)
+
+          file = data.delete(:key_file) || 'keys/encinch.yml'
+          make_dirp(file)
+
+          @storage = ::Cinch::Storage.new(file, data)
+
+          @storage.data.merge!(data) do |key, x, y|
+            case x
+            when Hash
+              x.merge!(y || {})
+            when Array
+              x.concat(y || []).uniq
+            when NilClass
+              y
+            else
+              if y.nil? || y.empty?
+                x
+              else
+                y
+              end
+            end
+          end
+
+          @storage.data[:drop] ||= false
+
+          save
+        end
+
+        # listen to nick change and update
+
+        listen_to :nick
+        def listen(m)
+          if @storage.data[:encrypt][m.user.last_nick.downcase]
+            @storage.data[:encrypt][m.user.nick.downcase] = @storage.data[:encrypt].delete(m.user.last_nick.downcase)
+            save
+          end
+        end
+
+        #
+        # save keys in yaml
+        #
+        def save
+          synchronize(:encinch_storage_save) do
+            @storage.save
+          end
+        end
+
+        def make_dirp(file)
+          path = File.expand_path(File.dirname(file))
+          FileUtils.mkdir_p(path) unless Dir.exist?(path)
+        end
+        private :make_dirp
+      end
+    end
+  end
+end

data/lib/cinch/plugins/encinch/version.rb

@@ -1,6 +1,7 @@
-
-class EnCinch
-  class Version
-    VERSION = "0.0.3"
+module Cinch
+  module Plugins
+    class EnCinch
+      VERSION = "0.1.5"
+    end
   end
 end

data/test/helper.rb

@@ -0,0 +1,83 @@
+require 'minitest/autorun'
+require 'minitest/reporters'
+require_relative '../lib/cinch/plugins/encinch'
+
+reporter_options = { color: true, slow_count: 5 }
+Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new(reporter_options)]
+
+if ENV["SIMPLECOV"]
+  begin
+    require 'simplecov'
+    SimpleCov.start
+  rescue LoadError
+  end
+end
+
+unless Object.const_defined? 'Cinch'
+  $:.unshift File.expand_path('../../lib', __FILE__)
+  require 'cinch'
+end
+
+
+class TestCase < MiniTest::Test
+  def self.test(name, &block)
+    define_method("test_" + name, &block) if block
+  end
+end
+
+class Bot
+  attr_accessor :ulist
+  attr_reader :message, :event
+
+  @@defined = false
+
+  def initialize(*)
+    @opts = Hash.new
+    @ulist = Array.new
+    @share = Hash.new
+    method_maker unless @@defined
+  end
+
+  def method_maker
+    [
+      :config, :plugins, :loggers, :handlers, :debug, :register,
+      :warn, :prefix, :suffix,:irc, :network, :user_list
+    ].each do |method|
+      self.class.send :define_method, method do |*|
+        self
+      end
+    end
+
+    @@defined = true
+  end
+
+  def isupport(*)
+    []
+  end
+
+  def find_ensured(*)
+    @ulist.first
+  end
+  private :method_maker
+
+  def options
+    @opts
+  end
+
+  def synchronize(name, &block)
+    yield block if block_given?
+  end
+
+  def shared
+    @share
+  end
+
+  def ngametv?
+    false
+  end
+
+  def dispatch(event, message, *args)
+    @event = event
+    @message = message
+  end
+end

data/test/lib/encinch/encinch_spec.rb

@@ -0,0 +1,100 @@
+module Cinch
+  module Plugins
+    class EnCinch
+
+      def config
+        @bot.options[self.class]
+      end
+    end
+  end
+
+  class Message
+    def privmsg_channel_name(s)
+      nil
+    end
+  end
+end
+
+class EnCinchTest < TestCase
+  parallelize_me!
+
+  def setup
+    bot = Bot.new
+    bot.options[Cinch::Plugins::EnCinch] = { encrypt: Hash.new }
+    @encinch = Cinch::Plugins::EnCinch.new(bot)
+    @message = ":encrypt_me!~encrypt_me@192.168.1.1 PRIVMSG #encinch :hello"
+    @encrypted_message = ":encrypt_me!~encrypt_me@192.168.1.1 PRIVMSG #encinch :+OK 3hcMC.j7WrK."
+    @key = "thisisafishkey"
+  end
+
+  def test_plugin_options_retrieval
+    assert_equal @encinch.shared[:encinch].storage.data, { ignore: [], uncrypted:[], encrypt: {}, drop: false }
+  end
+
+  def test_encrypt_message
+    encrypted = @encinch.blowfish(@key).encrypt(@message)
+    assert_equal false, @encinch.encrypted?(@message)
+    assert_equal true, @encinch.encrypted?(encrypted)
+  end
+
+  def test_decrypt_message
+    encrypted = @encinch.blowfish(@key).encrypt(@message)
+    assert_equal false, @encinch.encrypted?(@message)
+    assert_equal true, @encinch.encrypted?(encrypted)
+
+    decrypted = @encinch.decrypt(encrypted)
+
+    assert_equal @message, decrypted
+  end
+
+  def test_add_user_to_ignore
+    @encinch.shared[:encinch].storage.data[:ignore] << "ignore_me"
+    assert_equal ["ignore_me"], @encinch.shared[:encinch].storage.data[:ignore]
+  end
+
+  def test_add_user_to_uncrypted
+    @encinch.shared[:encinch].storage.data[:uncrypted] << "plain_text"
+    assert_equal ["plain_text"], @encinch.shared[:encinch].storage.data[:uncrypted]
+  end
+
+  def test_add_user_to_encrypted
+    @encinch.shared[:encinch].storage.data[:encrypt]["encrypt_me"] = "myencryptionkey"
+    expected = { "encrypt_me" => "myencryptionkey" }
+    assert_equal expected, @encinch.shared[:encinch].storage.data[:encrypt]
+  end
+
+  def test_capture_ignore_user
+    @encinch.shared[:encinch].storage.data[:ignore] << ignore = "ignore_me"
+    encrypted_message = ":encrypt_me!~encrypt_me@192.168.1.1 PRIVMSG ignore_me :+OK 3hcMC.j7WrK."
+
+    user = Cinch::User.new(ignore, @encinch.bot)
+    @encinch.bot.ulist << user
+
+    message = Cinch::Message.new(encrypted_message, @encinch.bot)
+
+    result = @encinch.capture(message, message.message)
+
+    assert_nil result
+  end
+
+  def test_capture_no_key
+    encrypted_message = ":encrypt_me!~encrypt_me@192.168.1.1 PRIVMSG no_key :+OK 3hcMC.j7WrK."
+    user = Cinch::User.new("no_key", @encinch.bot)
+    @encinch.bot.ulist << user
+    message = Cinch::Message.new(encrypted_message, @encinch.bot)
+    result = @encinch.capture(message, message.message)
+
+    assert_nil result
+  end
+
+  def test_capture_user_encrypted_message
+    @encinch.shared[:encinch].storage.data[:encrypt]["encrypt_me"] = @key
+    user = Cinch::User.new("encrypt_me", @encinch.bot)
+    @encinch.bot.ulist << user
+
+    message = Cinch::Message.new(@encrypted_message, @encinch.bot)
+
+    @encinch.capture(message, message.message)
+    assert_equal "hello", @encinch.bot.message.message
+  end
+end

data/test/lib/encinch/extend_spec.rb

@@ -0,0 +1,171 @@
+module Cinch
+  class IRC
+    attr_reader :message
+    def encinch_send(msg)
+      @message = msg
+    end
+  end
+end
+
+class ExtendTest < TestCase
+  parallelize_me!
+
+  def setup
+    bot = Bot.new
+    bot.options[Cinch::Plugins::EnCinch] = { encrypt: Hash.new }
+    @irc = Cinch::IRC.new(bot)
+    @encinch = Cinch::Plugins::EnCinch.new(bot)
+    @message = "hello"
+    @channel = "PRIVMSG #encinch :"
+    @user = "PRIVMSG encinch :"
+    @key = "thisisafishkey"
+    @encrypted = @encinch.blowfish(@key).encrypt(@message)
+    @lines = ["Lorem ipsum dolor sit amet", "dicat admodum est cu", "ne ferri soleat dolorum usu.", "Mel cu aliquid docendi temporibus", "at pri odio congue interesset. Quot assentior vis te", "ius ad wisi placerat deserunt", "facete insolens pri ex. An duo tantas veritus. Augue commodo sed ei", "ius quod eruditi lobortis id", "ne epicurei consetetur vim. Quo no debitis electram deseruisse", "quis senserit ei vis."]
+  end
+
+  def test_send_encrypted_message_pass_through
+    @irc.send(@channel + @encrypted)
+    assert_equal @channel + @encrypted, @irc.message
+  end
+
+  def test_send_uncrypted_message_encrypt
+    @encinch.shared[:encinch].storage.data[:encrypt]["#encinch"] = @key
+    @irc.send(@channel + @message)
+    assert_equal @channel + @encrypted, @irc.message
+  end
+
+  def test_send_larger_chunks
+    @encinch.shared[:encinch].storage.data[:encrypt]["#encinch"] = @key
+    @lines.each do |line|
+      @irc.send(@channel + line)
+      crypted = @encinch.blowfish(@key).encrypt(line)
+      assert_equal @channel + crypted, @irc.message
+    end
+  end
+
+  def test_send_default_key
+    default = "thisisdefaultkey"
+    @encinch.shared[:encinch].storage.data[:encrypt][:default] = default
+
+    @lines.each do |line|
+      @irc.send(@channel + line)
+      crypted = @encinch.blowfish(default).encrypt(line)
+      assert_equal @channel + crypted, @irc.message
+    end
+  end
+
+  def test_send_uncrypted_message_bypass
+    @encinch.shared[:encinch].storage.data[:uncrypted] << '#encinch'
+    @irc.send(@channel + @message)
+    assert_equal @channel + @message, @irc.message
+  end
+
+  def test_send_user_default_key
+    default = "thisisdefaultkey"
+    @encinch.shared[:encinch].storage.data[:encrypt][:default] = default
+
+    @lines.each do |line|
+      @irc.send(@user + line)
+      crypted = @encinch.blowfish(default).encrypt(line)
+      assert_equal @user + crypted, @irc.message
+    end
+  end
+
+  def test_send_text_with_newline_character
+    string = "this is some text with \n a new line character"
+    @encinch.shared[:encinch].storage.data[:encrypt]["encinch"] = @key
+    @irc.send(@user + string)
+
+    crypted = @encinch.blowfish(@key).encrypt(string)
+
+    assert_equal @user + crypted, @irc.message
+  end
+
+  def test_send_text_with_return_character
+    string = "this is some text with \r a return character"
+    @encinch.shared[:encinch].storage.data[:encrypt]["encinch"] = @key
+    @irc.send(@user + string)
+
+    crypted = @encinch.blowfish(@key).encrypt(string)
+
+    assert_equal @user + crypted, @irc.message
+  end
+
+  def test_send_text_with_tab_character
+    string = "this is some text with \t a tab character"
+    @encinch.shared[:encinch].storage.data[:encrypt]["encinch"] = @key
+    @irc.send(@user + string)
+
+    crypted = @encinch.blowfish(@key).encrypt(string)
+
+    assert_equal @user + crypted, @irc.message
+  end
+
+  def test_send_text_with_newline_return_tab_characters
+    string = "this is some text with \t a tab character and a \r return character, and a \n newline character"
+    @encinch.shared[:encinch].storage.data[:encrypt]["encinch"] = @key
+    @irc.send(@user + string)
+
+    crypted = @encinch.blowfish(@key).encrypt(string)
+
+    assert_equal @user + crypted, @irc.message
+  end
+
+  def test_send_action_message
+    string = "this is some action text"
+    @encinch.shared[:encinch].storage.data[:encrypt]["encinch"] = @key
+    @irc.send("#{ @user }\u0001ACTION #{ string }\u0001")
+    crypted = @encinch.blowfish(@key).encrypt(string)
+
+    assert_equal "#{ @user }\u0001ACTION #{ crypted }\u0001", @irc.message
+  end
+
+  def test_send_finger_pass_through
+    @encinch.shared[:encinch].storage.data[:encrypt]["encinch"] = @key
+    @irc.send("#{ @user }\u0001FINGER\u0001")
+
+    assert_equal "#{ @user }\u0001FINGER\u0001", @irc.message
+  end
+
+  def test_send_empty_message
+    @encinch.shared[:encinch].storage.data[:encrypt]["encinch"] = @key
+    @irc.send(@user + String.new)
+
+    assert_equal @user + String.new, @irc.message
+  end
+
+  def test_send_long_empty_message
+    string = "         "
+    @encinch.shared[:encinch].storage.data[:encrypt]["encinch"] = @key
+    @irc.send(@user + string)
+    crypted = @encinch.blowfish(@key).encrypt(string)
+
+    assert_equal @user + crypted, @irc.message
+  end
+
+  def test_send_drop_channel_message
+    @encinch.shared[:encinch].storage.data[:drop] = true
+    @irc.send(@channel + @message)
+    assert_nil @irc.message
+  end
+
+  def test_send_drop_user_message
+    @encinch.shared[:encinch].storage.data[:drop] = true
+    @irc.send(@user + @message)
+    assert_nil @irc.message
+  end
+
+  def test_send_allow_uncrypted_channel_no_drop
+    @encinch.shared[:encinch].storage.data[:drop] = true
+    @encinch.shared[:encinch].storage.data[:uncrypted] << '#encinch'
+    @irc.send(@channel + @message)
+    assert_equal @channel + @message, @irc.message
+  end
+
+  def test_send_allow_uncrypted_user_no_drop
+    @encinch.shared[:encinch].storage.data[:drop] = true
+    @encinch.shared[:encinch].storage.data[:uncrypted] << 'encinch'
+    @irc.send(@user + @message)
+    assert_equal @user + @message, @irc.message
+  end
+end

data/test/lib/encinch/storage_spec.rb

@@ -0,0 +1,54 @@
+class StorageTest < TestCase
+  def setup
+    bot = Bot.new
+    @options = {
+      ignore: Array.new,
+      uncrypted: Array.new,
+      encrypt: Hash.new
+    }
+
+    @storage = Cinch::Plugins::EnCinch::Storage.new(bot, @options)
+  end
+
+  def test_retrieve_options
+    @options[:drop] = false
+    assert_equal @options, options
+  end
+
+  def test_add_ignore_options
+    opts = options[:ignore]
+    assert_equal @options[:ignore], opts
+
+    opts << 'ignore_me'
+
+    assert_equal opts, options[:ignore]
+  end
+
+  def test_add_uncrypted_options
+    opts = options[:uncrypted]
+    assert_equal @options[:uncrypted], opts
+
+    opts << 'uncrypt_me'
+
+    assert_equal opts, options[:uncrypted]
+  end
+
+  def test_add_encryption_target
+    opts = options[:encrypt]
+
+    assert_equal @options[:encrypt], opts
+
+    opts[:default] = 'thisisafishkey'
+
+    assert_equal options[:encrypt], opts
+  end
+
+  def test_save_storage
+    assert_instance_of File, @storage.save
+  end
+
+  def options
+    @storage.storage.data
+  end
+  private :options
+end

data/test/lib/encinch/version_spec.rb

@@ -0,0 +1,11 @@
+class VersionTest < TestCase
+  parallelize_me!
+
+  def test_version_should_be_a_string
+    assert_instance_of String, ::Cinch::Plugins::EnCinch::VERSION
+  end
+
+  def test_version_string_should_be_series_of_integers
+    refute_empty ::Cinch::Plugins::EnCinch::VERSION.scan(/\d+/).map(&:to_i)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: encinch
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.5
 platform: ruby
 authors:
 - jfrazx
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-28 00:00:00.000000000 Z
+date: 2016-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cinch
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: cinch-storage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: crypt
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: ''
 email:
 - staringblind@gmail.com
@@ -48,12 +104,19 @@ files:
 - ".gitignore"
 - LICENSE.txt
 - README.md
+- Rakefile
 - encinch.gemspec
 - lib/cinch/plugins/encinch.rb
 - lib/cinch/plugins/encinch/encinch.rb
 - lib/cinch/plugins/encinch/encryption.rb
 - lib/cinch/plugins/encinch/extend.rb
+- lib/cinch/plugins/encinch/storage.rb
 - lib/cinch/plugins/encinch/version.rb
+- test/helper.rb
+- test/lib/encinch/encinch_spec.rb
+- test/lib/encinch/extend_spec.rb
+- test/lib/encinch/storage_spec.rb
+- test/lib/encinch/version_spec.rb
 homepage: https://github.com/jfrazx/EnCinch
 licenses:
 - MIT
@@ -78,4 +141,10 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: 'Transparent blowfish encryption plugin for Cinch: An IRC Bot Building Framework'
-test_files: []
+test_files:
+- test/helper.rb
+- test/lib/encinch/encinch_spec.rb
+- test/lib/encinch/extend_spec.rb
+- test/lib/encinch/storage_spec.rb
+- test/lib/encinch/version_spec.rb
+has_rdoc: