ava 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 26caff3f5177418fa60e596d8d579f3253f50833
+  data.tar.gz: aa1fb1423b4c703d933b12e822c6496b444f712d
+SHA512:
+  metadata.gz: ff5ec728964e1f5ebddf8bc002474323a50efa2ca07a34b8e473f3af3c3e271b376a8da97c4943d22b631c629cd9d43a03286ea2b76a0c1e5147dc76c579ba12
+  data.tar.gz: b9a5d57116f34a00b3faf5b543adeeaa8b93b7967d94941f5184fc861ed2903800632f8ada32caa85554aab1345eb40a50bd3e1c7a43dbf8dc3384814baa13e1

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.4
+before_install: gem install bundler -v 1.11.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at d2sm10@hotmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ava.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Brandon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,209 @@
+# Meet Ava
+
+Ava allows you to remotely execute code from another Ruby process or another system, similar to DRb (but different). With Ava, you register individual objects and then white or black list methods to then be called remotely via Ava's client class. Ava is both simple, lightweight and powerful.
+
+See how it all works below! It's easy and (mostly) secure!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ava'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ava
+
+## Usage
+
+Ava is comprised of three classes. The two most important are the Controller (the server) and the Client (the, well, client...). The third is called Replicant and is discussed in further detail below.
+
+### Starting a Server
+
+Starting an Ava Controller is simple:
+
+```ruby
+controller = Ava::Controller.new start: true, key: 'test', port: 2016
+```
+#### Available Params for Initialization
+* __start__: When the named argument start is set to true the server is automatically started during initialization. If this is not passed in, _start_ must be called later to initiate the server.
+* __key__: The secret key is the password that each client must have in order to authenticate. This is irrelevant if _encrypt_ is set to false as the key will not be needed.
+* __encrypt__: Settings this to true will ensure all content sent to clients is encrypted and require the key to authenticate.
+* __port__: Sets the TCP port for the server to run on. The default is 2016. The port needs to be open for remote connections to work.
+
+Once the server is up and running it needs to have objects registered to it that it will allow remote control over. Any Ruby object can be added and will be referenced by the name provided during registration. Names must be unique.
+
+```ruby
+# Create a couple objects to control
+timer = BBLib::TaskTimer.new
+cron_parser = BBLib::Cron.new '* * * * * *'
+
+controller.register timer: timer, cron: cron_parser
+```
+
+### Setting up a Client
+
+As soon as the items have been registered they can be controlled using a client. The following code illustrates how to create a client to connect to the server shown above.
+
+```ruby
+client = Ava::Client.new host: 'localhost', port: 2016, key: 'test'
+
+# Get the list of registered objects from the server
+client.registered_objects
+#=> [:controller, :timer, :cron]
+```
+
+If the client_id is out of sync or you need to reconnect the client you can call the *get_id* method and pass in the server key. This will ask the server for a new client ID and encryption key. This will have to occur if the server is fully restarted as it will purge its known connections and keys. The call will return true if the server accepts the key.
+
+```ruby
+client.get_id 'test'
+#=> true
+```
+
+__NOTE:__The key is never stored in the client, so it must be passed back in with each call to get_id if a new client_id is needed.
+
+### Using the Client
+
+Once a server is running and a client has been connected you may begin making calls the registered objects on the server (or to the server itself). There are a couple of ways to interact. The first is using requests.
+
+#### Requests
+
+Requests can be sent to the server and passed on to its objects in one of two ways. The request method allows an object name, method name and arguments to be sent to the server. The object name must match a registered object to return a result. For example:
+
+```ruby
+# Below the first argument is the object name, followed by the method to call on that object.
+# Arguments can also be forwarded following the method argument.
+client.request :timer, :start
+#=> 0
+
+sleep(5)
+
+client.request :timer, :stop
+#=> 5
+```
+
+Similarly, you can call a method directly on the client that matches the name of the registered object. For example:
+
+```ruby
+# Call the :next method on the cron object
+client.cron :next
+#=> '2016-04-10 03:14:00.000'
+
+# You can also add additional arguments
+client.cron :next, count: 2
+#=> ['2016-04-10 03:14:00.000', '2016-04-10 03:15:00.000']
+```
+
+As shown above, any number of arguments may be called, whether they are ordered and explicit or named parameters. The order passed in is enforced when they are sent to the server.
+
+#### Replicants
+
+Replicants provide an even more convenient means to interact with remote objects hosted by Ava. Replicants are pseudo versions of the objects on the server that can be interacted with as though they existed in the local scope.
+
+To create a Replicant all you need to do is make a call to the client using the object name as the method. See the example below.
+
+```ruby
+timer = client.timer
+#=> "#<Ava::Replicant>"
+
+# Now, we can interact with the variable timer as though it was created within the client's local scope.
+timer.start :my_task
+#=> 0
+timer.stop :my_task
+#=> 0.001213
+
+# This makes passing arguments more natural
+c = client.cron
+
+c.next '* * * * * *', count:1, time: Time.now
+#=> '2016-04-10 03:22:00.000'
+```
+
+_NOTE_: Nearly all methods in a Replicant return the result of the object from the server, so calling _class_ on a Replicant actually returns the class of the object on the server side. Some comparison operations may fail in Ava's current state such as the === operator.
+
+### Environment
+
+Because Ava passes deserialized objects and can reconstitute them on the client side it may be important for the client to have the same classes available as the server. There are a few methods included to help automate this where possible. These features are experimental.
+
+```ruby
+# Determine what gems were required on the server
+client.required_gems
+#=> ["bblib", "json", "psych", "mini_portile2", "nokogiri"]
+
+# List the gems required on the server that are not currently required on the client
+client.missings_gems
+#=> ["mini_portile2", "nokogiri"]
+
+# Attempt to import missing gems.
+client.require_missing_gems
+#=> {"mini_portile2" => true, "nokogiri" => true}
+
+# Check for anything missing following the bulk include
+client.missing_gems
+#=> []
+```
+
+The gems must be installed on the client side in order for them to actually be imported manually, so this will not cover all cases. Also, if you prefer not to blindly import everything you can use the missing_gems method to determine what the difference in environments is and manually import only the gems you need.
+
+### Security
+
+Various security functions are available in Ava currently to prevent unwanted access.
+
+#### Methods
+
+Methods can either be blacklisted or whitelisted to allow or disallow access to them via Ava. The whitelist takes precedence over the blacklist, so a whitelisted method will still be available even if it is listed in the blacklist. By default, all methods other than :eval are accessible on objects until explicitly stated in the white or black lists.
+
+Methods may be listed per object or across all objects.
+
+```ruby
+# Prevent access to timer's start and stop methods
+controller.blacklist :timer, :start, :stop
+
+# Allow access to timer's :tasks method
+controller.whitelist :timer, :tasks
+
+# Block access to the method :eval on all objects
+controller.blacklist_global :eval
+
+# Block all methods on the cron object
+controller.blacklist_all :cron
+```
+
+Clients attempting to call blacklisted methods will raise an unauthorized error.
+
+#### IP Filtering
+
+IPs can be allowed via the allow_connections method. IPs can be added as explicit strings or as regular expressions to match by subnets or other. By default all IPs are allowed to connect. If allowed_connections includes any IPs or patterns all other IPs not matching its contents will be blocked.
+
+```ruby
+# Allow access to a specific IP or from any IP starting with 10.30
+controller.allow_connections '10.10.156.1', /10\.30\.*/
+
+# Passing nil will allow all connections. This is the default behavior.
+controller.allow_connections nil
+```
+
+#### Encryption
+
+Encryption is enabled by default on the controller. When asking for a client ID a matching encryption key will be sent to the client so that it can decrypt messages from the controller. Each key is specific to the IP of the Client. It is recommended that encryption remain enabled. It can be toggled via the _encrypt_ method on the Controller.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ava. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/ava.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ava/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ava"
+  spec.version       = Ava::VERSION
+  spec.authors       = ["Brandon"]
+  spec.email         = ["d2sm10@hotmail.com"]
+
+  spec.summary       = %q{Ava is a remote control class for Ruby using TCP sockets.}
+  spec.description   = %q{Ava allows you to remotely control code in another process or on another system using TCP sockets.}
+  spec.homepage      = "http://github.com/bblack16/ava-ruby"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_runtime_dependency "bblib"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ava"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ava.rb

@@ -0,0 +1,15 @@
+require_relative "ava/version"
+require_relative 'client/client'
+require_relative 'controller/controller'
+
+require 'bblib'
+require 'socket'
+require 'json'
+require 'yaml'
+require 'securerandom'
+require 'openssl'
+require 'digest/sha1'
+
+module Ava
+
+end

data/lib/ava/version.rb

@@ -0,0 +1,3 @@
+module Ava
+  VERSION = "0.1.0"
+end

data/lib/client/client.rb

@@ -0,0 +1,107 @@
+require_relative  'replicant'
+
+module Ava
+
+  class Client
+    attr_accessor :host, :port, :socket, :response
+
+    def initialize host: 'localhost', port: 2016, key: nil
+      self.host = host
+      self.port = port
+      @client_id = {key: nil, iv: nil, encrypt: false}
+      get_id(key) if key
+    end
+
+    def inspect
+      "#<#{self.class}:#{self.object_id}>"
+    end
+
+    def connect
+      @socket = TCPSocket.open(@host, @port)
+    end
+
+    def close
+      @socket.close if defined?(@socket)
+    end
+
+    def get_id key
+      @client_id[:encrypt] = false
+      response = request :controller, :secret_key, key
+      if response
+        @client_id = response
+        true
+      else
+        false
+      end
+    end
+
+    def registered_objects
+      request(:controller, :registered_objects)
+    end
+
+    def required_gems
+      request(:controller, :required_gems)
+    end
+
+    def missing_gems
+      required_gems - Gem.loaded_specs.keys
+    end
+
+    def require_missing_gems
+      missing_gems.map do |gem|
+        begin
+          require gem
+          [gem, true]
+        rescue
+          [gem, false]
+        end
+      end.to_h
+    end
+
+    def method_missing *args, **named
+      if args.size == 1 && (named == {} || named.nil?) && registered_objects.any?{ |o| o.to_sym == args.first}
+        Replicant.new args.first, self
+      else
+        request args.first, args[1], *args[2..-1], **named
+      end
+    end
+
+    def request object, method, *args, **named
+      connect
+      argument = (named.nil? ? {} : named).merge({args:args})
+      request = {object => { method => argument }, client_id: @client_id[:key] }
+      @socket.puts encrypt_msg(request.to_yaml)
+      lines = Array.new
+      while line = @socket.gets
+        lines << line
+      end
+      @response = decrypt_msg(YAML.load(lines.join)).map{ |k,v| [k.to_sym, v]}.to_h
+      close
+      @response[:response] ? @response[:response] : (raise @response[:error])
+    end
+
+    def encrypt_msg msg
+      return msg if !@client_id[:encrypt]
+      cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
+      cipher.encrypt
+      cipher.key = @client_id[:key]
+      cipher.iv = @client_id[:iv]
+      enc = cipher.update msg.to_yaml
+      enc << cipher.final
+      {encrypted: enc, client_id: @client_id[:key]}.to_yaml
+    end
+
+    def decrypt_msg msg
+      return msg if !@client_id[:encrypt] || !msg.include?(:encrypted)
+      cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
+      cipher.decrypt
+      cipher.key = @client_id[:key]
+      cipher.iv = @client_id[:iv]
+      dec = cipher.update msg[:encrypted]
+      dec << cipher.final
+      YAML.load(YAML.load(dec))
+    end
+
+  end
+
+end

data/lib/client/replicant.rb

@@ -0,0 +1,21 @@
+module Ava
+
+  class Replicant < BasicObject
+    attr_accessor :object, :client
+
+    def initialize object, client
+      self.object = object
+      self.client = client
+    end
+
+    def is_replicant?
+      true
+    end
+
+    def method_missing *args, **named
+      @client.send @object, args.first, *args[1..-1], **named
+    end
+
+  end
+
+end

data/lib/controller/controller.rb

@@ -0,0 +1,249 @@
+module Ava
+
+  class Controller
+    attr_reader :objects, :blacklist, :whitelist, :key, :port, :thread, :connections,
+                :allowed_connections, :encrypt
+
+    def initialize *args, **named
+      @objects, @connections = {}, {}
+      @whitelist, @blacklist = {methods:[]}, {methods:[:eval]}
+      @allowed_connections = nil
+      setup_defaults
+      self.key = named.include?(:key) ? named[:key] : SecureRandom.hex(20)
+      self.port = named.include?(:port) ? named[:port] : 2016
+      self.encrypt = named.include?(:encrypt) ? named[:encrypt] : true
+      listen if named.include?(:start) && named[:start]
+    end
+
+    def encrypt= e
+      @encrypt = e == true
+    end
+
+    def key= key
+      @key = key.to_s
+    end
+
+    def port= port
+      @port = BBLib::keep_between(port, 1, nil)
+    end
+
+    def start
+      listen unless defined?(@thread) && @thread.alive?
+      running?
+    end
+
+    def stop
+      @thread.kill if defined?(@thread) && @thread.alive?
+      !running?
+    end
+
+    def restart
+      stop && start
+    end
+
+    def running?
+      defined?(@thread) && @thread.alive?
+    end
+
+    def register **objects
+      objects.each do |name, object|
+        name = name.to_sym
+        raise "Cannot name an object :controller, it is reserved." if name == :controller
+        @objects[name] = object
+      end
+    end
+
+    def allow_connections *connections
+      @allowed_connections = connections.first.nil? ? nil : connections
+    end
+
+    def remove name
+      @objects.delete name unless name == :controller
+    end
+
+    def whitelist name, *methods
+      name = name.to_sym
+      raise ArgumentError, "You cannot whitelist methods for :controller." if name == :controller
+      if @whitelist.include?(name)
+        (@whitelist[name]+=methods).uniq!
+      else
+        @whitelist[name] = methods
+      end
+    end
+
+    def whitelist_method *methods
+      @whitelist[:methods]+=methods
+    end
+
+    def blacklist name, *methods
+      if @blacklist.include?(name)
+        (@blacklist[name]+=methods).uniq!
+      else
+        @blacklist[name] = methods
+      end
+    end
+
+    def blacklist_all object
+      blacklist object, :_all
+    end
+
+    def blacklist_global *methods
+      @blacklist[:methods]+=methods
+    end
+
+    def registered_objects
+      @objects.keys
+    end
+
+    def required_gems
+      Gem.loaded_specs.keys
+    end
+
+    def parse_command cmd
+      begin
+        object = cmd.keys.first
+        method = cmd[object].keys.first
+        args = cmd[object][method].delete :args
+        named = cmd[object][method]
+        run_method(object, method, *args, **named)
+      rescue StandardError, Exception => e
+        {status: 500, error: "#{e}\n#{e.backtrace.join("\n")}"}
+      end
+    end
+
+    def run_method object, method, *args, **named
+      if @objects.include?(object)
+        return {status: 401, error: "You are not authorized to run '#{method}' on '#{object}'."} unless validate_method(object, method)
+        obj = @objects[object]
+
+        a = !args.nil? && (!args.is_a?(Array) || !args.empty?)
+        n = !named.nil? && !named.empty?
+        begin
+          if a && n
+            res = obj.send(method, *args, **named)
+          elsif !a && n
+            res = obj.send(method, **named)
+          elsif a && !n
+            res = obj.send(method, *args)
+          else
+            res = obj.send(method)
+          end
+          {status: 200, response: res}
+        rescue StandardError, Exception => e
+          {status: 501, error: "#{e}\n#{e.backtrace.join("\n")}"}
+        end
+      else
+        {status: 404, error: "Object '#{object}' does not exist."}
+      end
+    end
+
+    protected
+
+      def validate_method object, method
+        return true if @whitelist[:methods].include?(method) || @whitelist.include?(object) && @whitelist[object].include?(method)
+        return false if @blacklist[:methods].include?(method) || @blacklist.include?(object) && (@blacklist[object].include?(method) || @blacklist[object].include?(:_all))
+        return true
+      end
+
+      def listen
+        @thread = Thread.new {
+          begin
+            server = TCPServer.new(@port)
+            loop do
+              Thread.start(server.accept) do |client|
+                sock_domain, remote_port, remote_hostname, remote_ip = client.peeraddr
+                begin
+                  encrypt = true
+                  msg = decrypt_msg(remote_ip, YAML.load(client.recv(100000)))
+                  if msg[:controller] && msg[:controller][:secret_key]
+                    if msg[:controller][:secret_key][:args].first == @key
+                      response = {status:200, response: register_client(remote_ip)}
+                      encrypt = false
+                    else
+                      response = {status:401, error: ArgumentError.new('Invalid secret key.')}
+                      encrypt = false
+                    end
+                  elsif verify_connection(remote_ip, msg)
+                    response =  parse_command(msg)
+                  else
+                    response = {status: 401, error: ArgumentError.new("Invalid or missing client ID.")}
+                    encrypt = false
+                  end
+                rescue StandardError, Exception => e
+                  response = {status: 501, error: "#{e}\n#{e.backtrace.join}"}
+                  encrypt = false
+                end
+                response.hash_path_set 'time' => Time.now
+                client.puts(encrypt ? encrypt_msg(remote_ip, response.to_yaml) : response.to_yaml)
+                client.close
+              end
+            end
+          rescue StandardError, Exception => e
+            e
+          end
+        }
+      end
+
+      def register_client addr
+        return "Your IP is not allowed: #{addr}" unless validate_ip(addr)
+        client_id = Digest::SHA1.hexdigest("#{addr}|#{@key}")
+        iv = @cipher.random_iv
+        @connections[addr] = {key: client_id, iv: iv, encrypt: @encrypt}
+      end
+
+      def validate_ip addr
+        return true if @allowed_connections.nil?
+        match = false
+        [@allowed_connections].flatten.each do |format|
+          if String === format
+            match = true if addr == format
+          elsif Regexp === format
+            match = true if addr =~ format
+          end
+        end
+        match
+      end
+
+      def verify_connection ip, msg
+        return false unless msg.include?(:client_id)
+        @connections.include?(ip) && @connections[ip][:key] == msg.delete(:client_id)
+      end
+
+      def setup_defaults
+        @objects[:controller] = self
+        blacklist_all :controller
+        @whitelist[:controller] = [
+          :port,
+          :restart,
+          :running?,
+          :registered_objects,
+          :required_gems
+        ]
+        @cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
+      end
+
+      def encrypt_msg addr, msg
+        return msg if !@encrypt
+        cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
+        cipher.encrypt
+        cipher.key = @connections[addr][:key]
+        cipher.iv = @connections[addr][:iv]
+        enc = cipher.update msg.to_yaml
+        enc << cipher.final
+        {encrypted: enc}.to_yaml
+      end
+
+      def decrypt_msg addr, msg
+        return msg if !@encrypt || !msg.include?(:encrypted)
+        raise ArgumentError, "Unregistered client. You must get a client_id first for #{addr}" unless @connections.include?(addr)
+        cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
+        cipher.decrypt
+        cipher.key = @connections[addr][:key]
+        cipher.iv = @connections[addr][:iv]
+        dec = cipher.update msg[:encrypted]
+        dec << cipher.final
+        YAML.load(YAML.load(dec))
+      end
+  end
+
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: ava
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brandon
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bblib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ava allows you to remotely control code in another process or on another
+  system using TCP sockets.
+email:
+- d2sm10@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ava.gemspec
+- bin/console
+- bin/setup
+- lib/ava.rb
+- lib/ava/version.rb
+- lib/client/client.rb
+- lib/client/replicant.rb
+- lib/controller/controller.rb
+homepage: http://github.com/bblack16/ava-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Ava is a remote control class for Ruby using TCP sockets.
+test_files: []