tormanager 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04505aabbc5658c80ee5124866e5fa939a1d42d1
+  data.tar.gz: 7798de7e4ac6228cc2afd6e2bf68873d94fcbc82
+SHA512:
+  metadata.gz: cf53e41f6cab0da777462c69a526e63de3dc5802fac1b07b82425d5ba66cadcd3f62b115fb948354e4dcbd9417aa15d5eb8410686558a86a9cfe381191c87726
+  data.tar.gz: e7828a3ae09c95e22ee3f04dbb5abcf71efc7264a024da5f6ec441e3f3f35b40cd58c0973b8f1022d784b2898cc4e029c327651cb343344edc00e26ad350ab90

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea
+
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.14.6

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tormanager.gemspec
+gemspec
+
+gem 'tor', :git => 'https://github.com/bendiken/tor-ruby.git', :ref => '08e589d17196a5dc640e7b38cb1acc5b4c5ced05'
+#gem 'tor', :git => 'https://github.com/dryruby/tor.rb.git'
+group :development, :test do
+  gem "rb-fsevent", :require => false if RUBY_PLATFORM =~ /darwin/i
+  gem "guard-rspec"
+end

data/Guardfile

@@ -0,0 +1,18 @@
+guard :rspec, cmd: 'bundle exec rspec' do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  #watch(%r{^spec/.+_spec\.rb$})
+  #watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  #watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 joshweir
+
+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,195 @@
+# Tor Manager
+
+Ruby gem that provides a Tor interface with functionality: 
+
+- Start and stop and monitor a Tor process. 
+The Tor Process is monitored using [Eye](https://github.com/kostya/eye). 
+- Retrieve the current Tor IP address and get new ip address upon request.
+- Proxy web client requests through Tor.
+
+## Installation
+
+Install Tor: 
+
+`sudo apt-get install tor`
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tormanager'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tormanager
+
+## Usage
+
+### Tor Process 
+
+This section shows how to start, stop and manage Tor processes. 
+
+Start a Tor process with default settings:
+
+    tor_process = TorManager::TorProcess.new
+    tor_process.start
+	
+	#you can get the control password for the Tor process if you want: 
+	tor_process.settings[:control_password]
+
+By default, the Tor process will use using port `9050` and control port `50500` and
+will be spawned using [Eye](https://github.com/kostya/eye) ensuring that the process remains in a healthy state. 
+Eye will generate a config file based on the default [template](https://github.com/joshweir/tormanager/blob/master/lib/tormanager/eye/tor.template.eye.rb). 
+Eye will invoke the Tor process with command which looks like this:
+
+    tor --SocksPort 9050 --ControlPort 50500 --CookieAuthentication 0 --HashedControlPassword "<hashedpassword from the :control_password>" --NewCircuitPeriod 60
+
+Eye will restart the Tor process if a cpu percentage exceeds 10% for 3 consecutive readings (checked every 30 seconds). Eye will 
+restart the Tor process if its memory exceeds 200MB for 3 consecutive readings (checked every 60 seconds). By default, will do minimal logging and 
+will create a random `:control_password` which is used to generate the `HashedControlPassword` used to change the Tor password on request. 
+More information can be found in the `TorManager::TorProcess` parameters table below.
+
+You can also spawn a Tor process with control over parameters:
+
+    tor_process = 
+	  TorManager::TorProcess.new tor_port: 9051, 
+	                             control_port: 50501, 
+                                 pid_dir: '/my/pid/dir',
+                                 log_dir: '/my/log/dir',
+                                 tor_data_dir: '/my/tor/datadir',
+                                 tor_new_circuit_period: 120,
+                                 max_tor_memory_usage_mb: 400,
+                                 max_tor_cpu_percentage: 15,
+                                 control_password: 'mycontrolpass',
+                                 eye_logging: true,
+                                 tor_logging: true
+    tor_process.start
+
+See the table below for more info.	
+	
+When done with the Tor process, `stop` it: 
+
+    tor_process.stop 
+	
+The following table describes the `TorManager::TorProcess` parameters:
+	
+| Parameter | Default Value | Description |
+| --- | --- | --- |
+| `:tor_port` | `9050` | The listening port of the Tor process. |
+| `:control_port` | `50500` | The control port of the Tor process. |
+| `:pid_dir` | `/tmp` | Eye will create a pid file in this location which stores the pid of the Tor process. The name of the pid file is of format: `tormanager-tor-<tor_port>-<parent_pid>.pid` **_†_**. |
+| `:log_dir` | `/tmp` | If `:eye_logging` is `true`, Eye will create a log (`tormanager.eye.log`) in this location. If `:tor_logging` is `true`, Tor `stdall` is redirected to log (`tormanager-tor-<tor_port>-<parent_pid>.log` **_†_**) in this location. |
+| `:tor_data_dir` | `nil` | If specified, Tor will use this directory location as the `--DataDirectory`. |
+| `:tor_new_circuit_period` | `60` | In seconds, specifies the `--NewCircuitPeriod` that Tor should use. |
+| `:max_tor_memory_usage_mb` | `200` | In megabytes, Eye will restart the Tor process if its memory exceeds this value for 3 consecutive readings (checked every 60 seconds). |
+| `:max_tor_cpu_percentage` | `10` | Percentage value, Eye will restart the Tor process if it's cpu percentage exceeds this value for 3 consecutive readings (checked every 30 seconds). |
+| `:eye_tor_config_template` | `tormanager/eye/tor.template.eye.rb` | Specify your own eye config template, it is recommended to use the default [template](https://github.com/joshweir/tormanager/blob/master/lib/tormanager/eye/tor.template.eye.rb) as your starting point.  |
+| `:control_password` | Randomly generated by default. | By default, will do minimal logging and will create a random `:control_password` which is used to generate the `HashedControlPassword` used to change the Tor password on request. |
+| `:tor_log_switch` | `nil` | If specified, sets the Tor `--Log` switch, for example a value of `notice syslog` will add `--Log "notice syslog"` to the Tor command. |
+| `:eye_logging` | `nil` | If set to `true` will enable Eye logging in the `:log_dir` location, eye log: `tormanager.eye.log`  |
+| `:tor_logging` | `nil` | If set to `true`, Tor `stdall` is redirected to log (`tormanager-tor-<tor_port>-<parent_pid>.log` **_†_**) in this location. |
+| `:dont_remove_tor_config` | `nil` | By default, an eye configuration file is generated for the current Tor instance based on the `:eye_tor_config_template` stored in the `:log_dir` with name `tormanager.tor.<tor_port>.<parent_pid>.eye.rb` **_†_**. This generated file is removed when the Tor process is stopped by default. Setting `:dont_remove_tor_config` to `true` will not remove this file. |
+
+**_†_** where `<tor_port>` is the `:tor_port` of the Tor process and `<parent_pid>` is the pid of the ruby process spawning the Tor process.
+
+To stop any Tor instances that have been previously started by Tor Manager but were not stopped (say in the event of a parent process crash) **_††_**: 
+
+    TorProcess.stop_obsolete_processes 
+	
+Query whether Tor Manager has any Tor processes running on a particular port **_††_**: 
+
+    TorProcess.tor_running_on? port: 9050 
+
+Query whether Tor Manager has any Tor processes running on a particular port associated to a particular parent ruby pid **_††_**:
+
+    TorProcess.tor_running_on? port: 9050, parent_pid: 12345
+
+**_††_** Note that this command applies only to Tor processes that were started by Tor Manager. 
+Tor processes that have been started external to Tor Manager will not be impacted.  
+
+### Proxy Through Tor, Query IP Address, Change IP Address
+
+Once you have a `TorProcess` started, you can: 
+
+- [Proxy web client requests through Tor.](#proxy-through-tor)
+- [Query the current Tor endpoint IP address.](#query-ip-address) 
+- [Change the Tor endpoint IP address.](#change-ip-address) 
+
+The remaining examples assume that you have instantiated a `TorProcess` ie: 
+
+    tor_process = TorManager::TorProcess.new
+    tor_process.start
+
+#### Proxy Through Tor
+	
+    tor_proxy = TorManager::Proxy.new tor_process: tor_process 
+    tor_proxy.proxy do 
+      tor_ip = RestClient::Request.execute(
+                 method: :get,
+                 url: 'http://bot.whatismyipaddress.com').to_str
+    end
+	my_ip = RestClient::Request.execute(
+	             method: :get,
+                 url: 'http://bot.whatismyipaddress.com').to_str
+	
+Note that in the above code the `RestClient::Request` returning `tor_ip` is routed through the Tor endpoint because it is yielded 
+through the `TorManager::Proxy#proxy` block. The following request returning `my_ip` will not be routed through the Tor endpoint 
+hence returning your current IP address.
+
+You could route [Capybara](https://github.com/teamcapybara/capybara) requests through the proxy (just make sure you use the `:poltergeist` driver and set the proxy 
+to use the Tor socks proxy): 
+
+    Capybara.default_driver = :poltergeist
+    Capybara.register_driver :poltergeist do |app|
+      Capybara::Poltergeist::Driver.new(app, {
+        :phantomjs => Phantomjs.path,
+        :phantomjs_options => ["--proxy-type=socks5", "--proxy=127.0.0.1:9050"]
+      })
+    end
+    tor_proxy = TorManager::Proxy.new tor_process: tor_process 
+    tor_proxy.proxy do 
+      tor_ip = Capybara.visit('http://bot.whatismyipaddress.com').text
+    end
+
+#### Query IP Address 
+
+Query the Tor endpoint for the current IP address: 
+
+    tor_proxy = TorManager::Proxy.new tor_process: tor_process 	
+    tor_ip_control = 
+	  TorManager::IpAddressControl.new tor_process: tor_process, 
+                                       tor_proxy: tor_proxy 
+    tor_ip_control.get_ip									   
+	
+When the `TorManager::IpAddressControl#get_ip` method is called, the IP address is stored in instance variable: 
+
+    tor_ip_control.ip 
+
+	
+#### Change IP Address
+
+Get a new IP address: 
+
+    tor_proxy = TorManager::Proxy.new tor_process: tor_process 	
+    tor_ip_control = 
+	  TorManager::IpAddressControl.new tor_process: tor_process, 
+                                       tor_proxy: tor_proxy 
+    tor_ip_control.get_new_ip									   
+	
+When the `TorManager::IpAddressControl#get_new_ip` method is called, the IP address is stored in instance variable: 
+
+    tor_ip_control.ip
+
+	
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/joshweir/tormanager.
+
+
+## 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/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tormanager"
+
+# 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(__FILE__)

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/tormanager/eye/eye.tor.test.rb

@@ -0,0 +1,34 @@
+require 'eye'
+
+# Adding application
+Eye.application 'tormanager-tor-9250-1234' do
+  # All options inherits down to the config leafs.
+  # except `env`, which merging down
+
+  # uid "user_name" # run app as a user_name (optional) - available only on ruby >= 2.0
+  # gid "group_name" # run app as a group_name (optional) - available only on ruby >= 2.0
+
+  #working_dir File.expand_path(File.join(File.dirname(__FILE__), %w[ processes ]))
+  stdall '/tmp/tortrash.log' # stdout,err logs for processes by default
+  #env 'APP_ENV' => 'production' # global env for each processes
+  trigger :flapping, times: 10, within: 1.minute, retry_in: 10.minutes
+  check :cpu, every: 30.seconds, below: 10, times: 3 # global check for all processes
+  check :memory, every: 60.seconds, below: 200.megabytes, times: 3
+  process :sample1 do
+    pid_file '1.pid' # pid_path will be expanded with the working_dir
+    start_command "tor --SocksPort 9250 --ControlPort 52500 " +
+                      "--CookieAuthentication 0 --HashedControlPassword \"16:3E49D6163CCA95F2605B339" +
+                      "E07F753C8F567DE4200E33FDF4CC6B84E44\" --NewCircuitPeriod " +
+                      "60 --DataDirectory /tmp/tor_data/9250/ --Log \"notice syslog\""
+
+    daemonize true
+    #stdall 'sample1.log'
+  end
+
+=begin
+  group 'samples' do
+    chain grace: 5.seconds # chained start-restart with 5s interval, one by one.
+
+  end
+=end
+end

data/lib/tormanager/eye/sugar.rb

@@ -0,0 +1,62 @@
+class Numeric
+  # Public: Units of seconds.
+  def seconds
+    self
+  end
+
+  # Public: Units of seconds.
+  alias :second :seconds
+
+  # Public: Units of minutes (60 seconds).
+  def minutes
+    self * 60
+  end
+
+  # Public: Units of minutes (60 seconds).
+  alias :minute :minutes
+
+  # Public: Units of hours (3600 seconds).
+  def hours
+    self * 3600
+  end
+
+  # Public: Units of hours (3600 seconds).
+  alias :hour :hours
+
+  # Public: Units of days (86400 seconds).
+  def days
+    self * 86400
+  end
+
+  # Public: Units of days (86400 seconds).
+  alias :day :days
+
+  # Units of kilobytes.
+  def kilobytes
+    self
+  end
+
+  # Units of kilobytes.
+  alias :kilobyte :kilobytes
+
+  # Units of megabytes (1024 kilobytes).
+  def megabytes
+    self * 1024
+  end
+
+  # Units of megabytes (1024 kilobytes).
+  alias :megabyte :megabytes
+
+  # Units of gigabytes (1,048,576 kilobytes).
+  def gigabytes
+    self * (1024 ** 2)
+  end
+
+  # Units of gigabytes (1,048,576 kilobytes).
+  alias :gigabyte :gigabytes
+
+  # Units of percent. e.g. 50.percent.
+  def percent
+    self
+  end
+end

data/lib/tormanager/eye/tor.god.rb

@@ -0,0 +1,105 @@
+require 'fileutils'
+
+opts = {}
+opts[:parent_id] = ARGV[0]
+opts[:tor_port] = ARGV[1] || 9050
+opts[:control_port] = ARGV[2] || 50500
+opts[:pid_dir] = ARGV[3] || "/tmp"
+opts[:log_dir] = ARGV[4] || "/tmp"
+opts[:tor_data_dir] = ARGV[5] || "/tmp/tor_data/"
+opts[:tor_new_circuit_period] = ARGV[6] || 60
+opts[:max_tor_memory_usage_mb] = ARGV[7] || 200
+opts[:max_tor_cpu_percentage] = ARGV[8] || 10
+opts[:max_tor_memory_usage_times] = [3,5]
+opts[:max_tor_cpu_percentage_times] = [3,5]
+
+raise 'parent_id is required' unless opts[:parent_id]
+
+module God
+  module Behaviors
+    class WaitBehavior < Behavior
+      attr_accessor :delay
+
+      def after_start
+        sleep delay.to_i if delay.to_i > 0
+      end
+    end
+  end
+end
+
+God.watch do |w|
+  the_name = "tormanager-tor-#{opts[:tor_port]}-#{opts[:parent_id]}"
+  w.name = the_name
+  w.start = "tor --SocksPort #{opts[:tor_port]} --ControlPort #{opts[:control_port]} " +
+      "--CookieAuthentication 0 --HashedControlPassword \"16:3E49D6163CCA95F2605B339" +
+      "E07F753C8F567DE4200E33FDF4CC6B84E44\" --NewCircuitPeriod " +
+      "#{opts[:tor_new_circuit_period]} --DataDirectory " +
+      File.join(opts[:tor_data_dir], opts[:tor_port]) + " --Log \"notice syslog\""
+  #w.pid_file = File.join(opts[:pid_dir], "#{the_name}.pid")
+  #w.log = File.join(opts[:log_dir], "#{the_name}.log") if opts[:log_dir].length > 0
+  w.keepalive
+
+  # clean pid files before start if necessary
+  w.behavior(:clean_pid_file)
+  w.behavior(:wait_behavior) do |b|
+    b.delay = 10
+  end
+
+=begin
+  # determine the state on startup
+  w.transition(:init, { true => :up, false => :start }) do |on|
+    sleep 5
+    on.condition(:process_running) do |c|
+      c.interval = 5
+      c.running = true
+    end
+  end
+
+  # determine when process has finished starting
+  w.transition([:start, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.interval = 20
+      c.running = true
+    end
+
+    # failsafe
+    on.condition(:tries) do |c|
+      c.interval = 20
+      c.times = 5
+      c.transition = :start
+    end
+  end
+
+  # start if process is not running
+  #w.transition(:up, :start) do |on|
+  #  on.condition(:process_exits) do |c|
+  #    c.interval = 20
+  #  end
+  #end
+
+  # restart if memory or cpu is too high
+  w.transition(:up, :restart) do |on|
+    on.condition(:memory_usage) do |c|
+      c.interval = 20
+      c.above = opts[:max_tor_memory_usage_mb]
+      c.times = opts[:max_tor_memory_usage_times]
+    end
+
+    on.condition(:cpu_usage) do |c|
+      c.interval = 10
+      c.above = opts[:max_tor_cpu_percentage]
+      c.times = opts[:max_tor_cpu_percentage_times]
+    end
+  end
+
+  # lifecycle
+  w.lifecycle do |on|
+    on.condition(:flapping) do |c|
+      c.to_state = [:start, :restart]
+      c.times = 5
+      c.within = 5.minute
+      c.transition = :unmonitored
+    end
+  end
+=end
+end

data/lib/tormanager/eye/tor.template.eye.rb

@@ -0,0 +1,27 @@
+require 'eye'
+
+if %w(true 1).include?('[[[eye_logging]]]')
+  Eye.config do
+    logger File.join('[[[log_dir]]]', 'tormanager.eye.log')
+  end
+end
+
+Eye.application 'tormanager-tor-[[[tor_port]]]-[[[parent_pid]]]' do
+  stdall File.join('[[[log_dir]]]', 'tormanager-tor-[[[tor_port]]]-[[[parent_pid]]].log') if %w(true 1).include?('[[[tor_logging]]]')
+  trigger :flapping, times: 10, within: 1.minute, retry_in: 10.minutes
+  check :cpu, every: 30.seconds, below: [[[max_tor_cpu_percentage]]], times: 3
+  check :memory, every: 60.seconds, below: [[[max_tor_memory_usage_mb]]].megabytes, times: 3
+  process :tor do
+    pid_file File.join('[[[pid_dir]]]', 'tormanager-tor-[[[tor_port]]]-[[[parent_pid]]].pid')
+    start_command "tor --SocksPort [[[tor_port]]] --ControlPort [[[control_port]]] " +
+                      "--CookieAuthentication 0 --HashedControlPassword \"[[[hashed_control_password]]]\" --NewCircuitPeriod " +
+                      "[[[tor_new_circuit_period]]] " +
+                      ('[[[tor_data_dir]]]'.length > 0 ?
+                          "--DataDirectory #{File.join('[[[tor_data_dir]]]',
+                                                       '[[[tor_port]]]')} " :
+                          "") +
+                      ('[[[tor_log_switch]]]'.length > 0 ?
+                          "--Log \"[[[tor_log_switch]]]\" " : "")
+    daemonize true
+  end
+end

data/lib/tormanager/ip_address_control.rb

@@ -0,0 +1,80 @@
+require 'tor'
+require 'rest-client'
+
+module TorManager
+  class IpAddressControl
+    attr_accessor :ip
+
+    def initialize params={}
+      @tor_process = params.fetch(:tor_process, nil)
+      @tor_proxy = params.fetch(:tor_proxy, nil)
+      @ip = nil
+      @endpoint_change_attempts = 5
+    end
+
+    def get_ip
+      ensure_tor_is_available
+      @ip = tor_endpoint_ip
+    end
+
+    def get_new_ip
+      ensure_tor_is_available
+      get_new_tor_endpoint_ip
+    end
+
+    private
+
+    def ensure_tor_is_available
+      raise "Cannot proceed, Tor is not running on port " +
+                "#{@tor_process.settings[:tor_port]}" unless
+          TorProcess.tor_running_on? port: @tor_process.settings[:tor_port],
+              parent_pid: @tor_process.settings[:parent_pid]
+    end
+
+    def tor_endpoint_ip
+      try_getting_endpoint_ip_restart_tor_and_retry_on_fail attempts: 2
+    rescue Exception => ex
+      puts "Error getting ip: #{ex.to_s}"
+      return nil
+    end
+
+    def try_getting_endpoint_ip_restart_tor_and_retry_on_fail params={}
+      ip = nil
+      (params[:attempts] || 2).times do |attempt|
+        begin
+          @tor_proxy.proxy do
+            ip = RestClient::Request
+                     .execute(method: :get,
+                              url: 'http://bot.whatismyipaddress.com')
+                     .to_str
+          end
+          break if ip
+        rescue Exception => ex
+          @tor_process.stop
+          @tor_process.start
+        end
+      end
+      ip
+    end
+
+    def get_new_tor_endpoint_ip
+      @endpoint_change_attempts.times do |i|
+        tor_switch_endpoint
+        new_ip = tor_endpoint_ip
+        if new_ip.to_s.length > 0 && new_ip != @ip
+          @ip = new_ip
+          break
+        end
+      end
+      @ip
+    end
+
+    def tor_switch_endpoint
+      Tor::Controller.connect(:port => @tor_process.settings[:control_port]) do |tor|
+        tor.authenticate("")
+        tor.signal("newnym")
+        sleep 10
+      end
+    end
+  end
+end

data/lib/tormanager/process_helper.rb

@@ -0,0 +1,76 @@
+require 'socket'
+
+module TorManager
+  class ProcessHelper
+    class << self
+      def query_process query
+        return [] unless query
+        query_process_bash_cmd(query).split("\n").map{ |query_output_line|
+          get_pid_from_query_process_output_line(query_output_line)
+        }.compact
+      end
+
+      def kill_process pids
+        to_array(pids).each do |pid|
+          try_to_kill pid: pid, attempts: 5
+        end
+      end
+
+      def process_pid_running? pid
+        begin
+          return false if pid.to_s == ''.freeze
+          ipid = pid.to_i
+          return false if ipid <= 0
+          Process.kill(0, ipid)
+          return true
+        rescue
+          return false
+        end
+      end
+
+      def port_is_open? port
+        begin
+          server = TCPServer.new('127.0.0.1', port)
+          server.close
+          return true
+        rescue Errno::EADDRINUSE;
+          return false
+        end
+      end
+
+      private
+
+      def query_process_bash_cmd query
+        `ps -ef | #{query_grep_pipe_chain(query)} | grep -v grep`
+      end
+
+      def query_grep_pipe_chain query
+        to_array(query)
+            .map{|q| "grep '#{q}'"}
+            .join(' | ')
+      end
+
+      def get_pid_from_query_process_output_line query_output_line
+        output_parts = query_output_line.gsub(/\s\s+/, ' ').strip.split
+        output_parts.size >= 3 && output_parts[1].to_i > 0 ?
+            output_parts[1].to_i : nil
+      end
+
+      def to_array v
+        (v.kind_of?(Array) ? v : [v])
+      end
+
+      def try_to_kill params={}
+        pid = params.fetch(:pid, nil)
+        return unless pid && process_pid_running?(pid)
+        params.fetch(:attempts, 5).times do |k|
+          k < 3 ? Process.kill('TERM', pid) :
+            Process.kill('KILL', pid)
+          sleep 0.5
+          break unless process_pid_running? pid
+          raise "Couldnt kill pid: #{pid}" if k >= 4
+        end
+      end
+    end
+  end
+end

data/lib/tormanager/proxy.rb

@@ -0,0 +1,30 @@
+require 'socksify'
+
+module TorManager
+  class Proxy
+    #Socksify::debug = true
+
+    def initialize params={}
+      @tor_process = params.fetch(:tor_process, nil)
+    end
+
+    def proxy
+      enable_socks_server
+      yield.tap { disable_socks_server }
+    ensure
+      disable_socks_server
+    end
+
+    private
+
+    def enable_socks_server
+      TCPSocket::socks_server = "127.0.0.1"
+      TCPSocket::socks_port = @tor_process.settings[:tor_port]
+    end
+
+    def disable_socks_server
+      TCPSocket::socks_server = nil
+      TCPSocket::socks_port = nil
+    end
+  end
+end

data/lib/tormanager/tor_process.rb

@@ -0,0 +1,193 @@
+require 'eye'
+require 'eyemanager'
+require 'fileutils'
+require 'securerandom'
+
+module TorManager
+  class TorProcess
+    attr_accessor :settings
+
+    def initialize params={}
+      @settings = {}
+      @settings[:tor_port] = params.fetch(:tor_port, 9050)
+      @settings[:control_port] = params.fetch(:control_port, 50500)
+      @settings[:pid_dir] = params.fetch(:pid_dir, '/tmp'.freeze)
+      @settings[:log_dir] = params.fetch(:log_dir, '/tmp'.freeze)
+      @settings[:tor_data_dir] = params.fetch(:tor_data_dir, nil)
+      @settings[:tor_new_circuit_period] = params.fetch(:tor_new_circuit_period, 60)
+      @settings[:max_tor_memory_usage_mb] = params.fetch(:max_tor_memory_usage, 200)
+      @settings[:max_tor_cpu_percentage] = params.fetch(:max_tor_cpu_percentage, 10)
+      @settings[:eye_tor_config_template] =
+          params.fetch(:eye_tor_config_template,
+            File.join(File.dirname(__dir__),'tormanager/eye/tor.template.eye.rb'))
+      @settings[:parent_pid] = Process.pid
+      @settings[:control_password] = params.fetch(:control_password, random_password)
+      @settings[:hashed_control_password] =
+          tor_hash_password_from(@settings[:control_password])
+      @settings[:tor_log_switch] = params.fetch(:tor_log_switch, nil)
+      @settings[:eye_logging] = params.fetch(:eye_logging, nil)
+      @settings[:tor_logging] = params.fetch(:tor_logging, nil)
+      @settings[:dont_remove_tor_config] = params.fetch(:dont_remove_tor_config, nil)
+    end
+
+    def start
+      prepare_tor_start_and_monitor if tor_ports_are_open?
+    end
+
+    def stop
+      EyeManager.stop application: eye_app_name, process: 'tor'
+      remove_eye_tor_config unless @settings[:dont_remove_tor_config]
+      ensure_tor_is_down
+    end
+
+    class << self
+      def stop_obsolete_processes
+        (EyeManager.list_apps || []).each do |app|
+          EyeManager.stop(application: app, process: 'tor') unless
+              ProcessHelper.process_pid_running? pid_of_tor_eye_process(app)
+        end
+      end
+
+      def tor_running_on? params={}
+        is_running = false
+        (EyeManager.list_apps || []).each do |app|
+          if port_and_or_pid_matches_eye_tor_name?(app, params) &&
+             EyeManager.status(application: app,
+                               process: 'tor') == 'up'
+            is_running = true
+            break
+          end
+        end
+        is_running
+      end
+
+      private
+
+      def port_and_or_pid_matches_eye_tor_name? app, params={}
+        (params[:port] || params[:parent_pid]) &&
+        (!params[:port] || port_of_tor_eye_process(app).to_i == params[:port].to_i) &&
+        (!params[:parent_pid] || pid_of_tor_eye_process(app).to_i == params[:parent_pid].to_i)
+      end
+
+      def pid_of_tor_eye_process app
+        app.to_s.split('-').last
+      end
+
+      def port_of_tor_eye_process app
+        app_name_split = app.to_s.split('-')
+        app_name_split.length >= 3 ?
+            app_name_split[2].to_i : nil
+      end
+    end
+
+    private
+
+    def tor_ports_are_open?
+      tor_port_is_open? &&
+      control_port_is_open?
+    end
+
+    def tor_port_is_open?
+      raise "Cannot spawn Tor process as port " +
+                "#{@settings[:tor_port]} is in use" unless
+          ProcessHelper.port_is_open?(@settings[:tor_port])
+      true
+    end
+
+    def control_port_is_open?
+      raise "Cannot spawn Tor process as control port " +
+                "#{@settings[:control_port]} is in use" unless
+          ProcessHelper.port_is_open?(@settings[:control_port])
+      true
+    end
+
+    def prepare_tor_start_and_monitor
+      build_eye_config_from_template
+      make_dirs
+      start_tor_and_monitor
+    end
+
+    def build_eye_config_from_template
+      File.open(eye_config_filename, "w") do |file|
+        file.puts read_eye_tor_config_template_and_substitute_keywords
+      end
+    end
+
+    def eye_config_filename
+      @eye_config_filename || File.join(@settings[:log_dir],
+                "tormanager.tor.#{@settings[:tor_port]}.#{Process.pid}.eye.rb")
+    end
+
+    def eye_app_name
+      @eye_app_name || "tormanager-tor-#{@settings[:tor_port]}-#{Process.pid}"
+    end
+
+    def read_eye_tor_config_template_and_substitute_keywords
+      text = File.read(@settings[:eye_tor_config_template])
+      eye_tor_config_template_substitution_keywords.each do |keyword|
+        text = text.gsub(/\[\[\[#{keyword}\]\]\]/, @settings[keyword.to_sym].to_s)
+      end
+      text
+    end
+
+    def eye_tor_config_template_substitution_keywords
+      remove_settings_that_are_not_eye_tor_config_template_keywords(
+          @settings.keys.map(&:to_s))
+    end
+
+    def remove_settings_that_are_not_eye_tor_config_template_keywords keywords
+      keywords - ['eye_tor_config_template', 'control_password', 'dont_remove_tor_config']
+    end
+
+    def make_dirs
+      [@settings[:log_dir], @settings[:pid_dir],
+       @settings[:tor_data_dir]].each do |path|
+        FileUtils.mkpath(path) if path && !File.exists?(path)
+      end
+    end
+
+    def start_tor_and_monitor
+      EyeManager.start config: eye_config_filename,
+                       application: eye_app_name
+      ensure_tor_is_up
+    end
+
+    def ensure_tor_is_up
+      10.times do |i|
+        break if
+            EyeManager.status(
+                application: eye_app_name,
+                process: 'tor') == 'up'
+        sleep 2
+        raise "Tor didnt start up after 20 seconds! See log: " +
+                  "#{File.join(@settings[:log_dir],
+                               eye_app_name + ".log")}" if i >= 9
+      end
+    end
+
+    def ensure_tor_is_down
+      10.times do |i|
+        tor_status = EyeManager.status(
+            application: eye_app_name,
+            process: 'tor')
+        break if ['unknown','unmonitored'].include?(tor_status)
+        sleep 2
+        raise "Tor didnt stop after 20 seconds! Last status: #{tor_status} See log: " +
+                  "#{File.join(@settings[:log_dir],
+                               eye_app_name + ".log")}" if i >= 9
+      end
+    end
+
+    def remove_eye_tor_config
+      File.delete(eye_config_filename) if File.exists?(eye_config_filename)
+    end
+
+    def random_password
+      SecureRandom.random_number(36**12).to_s(36).rjust(12, "0")
+    end
+
+    def tor_hash_password_from password
+      `tor --quiet --hash-password '#{password}'`.strip
+    end
+  end
+end

data/lib/tormanager/version.rb

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

data/lib/tormanager.rb

@@ -0,0 +1,6 @@
+require "tormanager/version"
+require "tormanager/process_helper"
+require "tormanager/tor_process"
+require "tormanager/proxy"
+require "tormanager/ip_address_control"
+

data/tormanager.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tormanager/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tormanager"
+  spec.version       = TorManager::VERSION
+  spec.authors       = ["joshweir"]
+  spec.email         = ["joshua.weir@gmail.com"]
+
+  spec.summary       = %q{Start, stop, monitor, control and proxy through a Tor process using Ruby.}
+  #spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/joshweir/tormanager"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-rails", "~> 3.5"
+  spec.add_dependency "rest-client"
+  spec.add_dependency "eye"
+  spec.add_dependency "eyemanager"
+  spec.add_dependency "gem-release"
+  spec.add_dependency "socksify"
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: tormanager
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- joshweir
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-08-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  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'
+- !ruby/object:Gem::Dependency
+  name: eye
+  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'
+- !ruby/object:Gem::Dependency
+  name: eyemanager
+  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'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  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'
+- !ruby/object:Gem::Dependency
+  name: socksify
+  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: 
+email:
+- joshua.weir@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/tormanager.rb
+- lib/tormanager/eye/eye.tor.test.rb
+- lib/tormanager/eye/sugar.rb
+- lib/tormanager/eye/tor.god.rb
+- lib/tormanager/eye/tor.template.eye.rb
+- lib/tormanager/ip_address_control.rb
+- lib/tormanager/process_helper.rb
+- lib/tormanager/proxy.rb
+- lib/tormanager/tor_process.rb
+- lib/tormanager/version.rb
+- tormanager.gemspec
+homepage: https://github.com/joshweir/tormanager
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Start, stop, monitor, control and proxy through a Tor process using Ruby.
+test_files: []