zimbra_intercepting_proxy 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b8fc64cce8ebee058df8af6636304827251ff52
+  data.tar.gz: ac0562ae52e4aba1d0b4d33fe6cb4711ec26c8b4
+SHA512:
+  metadata.gz: 9d2ef644be75708386f0fcad9e741f59500fa6887343aaeae862a8c3fb7c9acfe852ce10543187be1f8a3fe4a4315677b064009a569e02e5aa4fb30674920c0d
+  data.tar.gz: 02f4cba8f32ad848ed7557edbb5784f51e67f13d935bcea69e00e163766fb1114703ef89ce960d28600eee224b921283f9043f2ce142a8b411b74c242c783311

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Patricio Bruna
+
+MIT License
+
+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,38 @@
+# ZimbraInterceptingProxy
+
+TODO: Write a gem description
+
+
+## TODO:
+
+1. Logger
+2. Iniciar con parametros
+3. Iniciar el segundo plano
+4. Paquetizar
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zimbra_proxy_spy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zimbra_proxy_spy
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/zimbra_proxy_spy/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs << %w(test lib)
+  task.pattern = 'test/test_*.rb'
+end
+
+task :default => :test

data/bin/zimbra_intercepting_proxy

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'zimbra_intercepting_proxy'
+require 'optparse'
+
+# host, port
+ARGV << '-h' if ARGV.empty?
+
+options = {}
+
+optparse = OptionParser.new do |opts|
+  
+  opts.banner = "Usage: zimbra_intercepting_proxy [options]"
+  
+  opts.on("-dDOMAIN", "--domain=DOMAIN", "Email domain of the mailboxes") do |o|
+    options[:domain] = o
+  end
+  
+  opts.on("-fFILE", "--usersfile=FILE", "YAML file with the list of migrated users") do |o|
+    options[:migrated_users_file] = o
+  end
+  
+  opts.on("-omSERVER", "--oldmailbox=SERVER", "Hostname or IP of the mailbox from where we are migrating") do |o|
+    options[:old_backend] = o
+  end
+  
+  opts.on("-nmSERVER", "--newmailbox=SERVER", "Hostname or IP of the mailbox to where we are migrating") do |o|
+    options[:new_backend] = o
+  end
+  
+  opts.on("-baADDRESS", "--bindaddress=ADDRESS", "The IP Address to bind to. Default 0.0.0.0") do |o|
+    options[:bind_address] = o
+  end
+  
+  opts.on("-bpPORT", "--bindport=PORT", "The Port to bind to. Default 0.0.0.0") do |o|
+    options[:bind_port] = o
+  end
+  
+  opts.on("-v", "--verbose", "Save logs information to /var/log/zimbra_intercepting_proxy.log") do |o|
+    options[:debug] = true
+  end
+    
+  opts.on("-h", "--help", "Prints this help") do
+   puts opts
+   exit
+  end
+  
+end
+
+optparse.parse!
+ZimbraInterceptingProxy.start options

data/lib/zimbra_intercepting_proxy.rb

@@ -0,0 +1,33 @@
+require "yaml"
+require "uuid"
+require 'em-proxy'
+require 'http/parser'
+require "addressable/uri"
+require 'logger'
+require "zimbra_intercepting_proxy/version"
+require "zimbra_intercepting_proxy/user"
+require "zimbra_intercepting_proxy/config"
+require "zimbra_intercepting_proxy/backend"
+require "zimbra_intercepting_proxy/request"
+require "zimbra_intercepting_proxy/server"
+require "zimbra_intercepting_proxy/debug"
+require "zimbra_intercepting_proxy/connection"
+
+module ZimbraInterceptingProxy
+  
+  def self.start(options)
+    config!(options)
+    ZimbraInterceptingProxy::Server.run
+  end
+  
+  def self.config!(options)
+    ZimbraInterceptingProxy::Config.domain = options[:domain]
+    ZimbraInterceptingProxy::Config.migrated_users_file = options[:migrated_users_file]
+    ZimbraInterceptingProxy::Config.old_backend = options[:old_backend]
+    ZimbraInterceptingProxy::Config.new_backend = options[:new_backend]
+    ZimbraInterceptingProxy::Config.bind_address = options[:bind_address] || "0.0.0.0"
+    ZimbraInterceptingProxy::Config.bind_port = options[:bind_port]
+    ZimbraInterceptingProxy::Config.debug = options[:debug]
+  end
+  
+end

data/lib/zimbra_intercepting_proxy/backend.rb

@@ -0,0 +1,10 @@
+module ZimbraInterceptingProxy
+  module Backend
+   
+    def self.for_user(user)
+      return ZimbraInterceptingProxy::Config.new_backend if user.migrated?
+      ZimbraInterceptingProxy::Config.old_backend
+    end
+    
+  end
+end

data/lib/zimbra_intercepting_proxy/config.rb

@@ -0,0 +1,74 @@
+module ZimbraInterceptingProxy
+  module Config
+    attr_accessor :new_backend, :old_backend
+    
+    ROUTE_URL = "/service/extension/nginx-lookup"
+    ROUTE_REQUEST_PORT = 7072
+    AUTH_REQUEST_PORT = 80
+    
+    def self.domain=(domain)
+      @domain = domain
+    end
+    
+    def self.domain
+      @domain
+    end
+    
+    def self.migrated_users_file=(file)
+      @migrated_users_file = file
+    end
+    
+    def self.migrated_users_file
+      @migrated_users_file
+    end
+    
+    def self.backend_port=(port)
+      @backend_port
+    end
+    
+    def self.backend_port
+      @backend_port
+    end
+    
+    def self.old_backend=(old_backend)
+      @old_backend = old_backend
+    end
+    
+    def self.new_backend=(new_backend)
+      @new_backend = new_backend
+    end
+    
+    def self.old_backend
+      @old_backend
+    end
+    
+    def self.new_backend
+      @new_backend
+    end
+    
+    def self.bind_port=(bind_port)
+      @bind_port = bind_port
+    end
+    
+    def self.bind_port
+      @bind_port
+    end
+    
+    def self.bind_address=(bind_address)
+      @bind_address = bind_address
+    end
+    
+    def self.bind_address
+      @bind_address
+    end
+    
+    def self.debug=(debug)
+      @debug = debug
+    end
+    
+    def self.debug
+      @debug
+    end
+    
+  end
+end

data/lib/zimbra_intercepting_proxy/connection.rb

@@ -0,0 +1,15 @@
+module ZimbraInterceptingProxy
+  class Connection
+
+    attr_accessor :headers, :body, :started, :done, :buffer
+
+    def initialize
+      @headers = nil
+      @body = ""
+      @started = false
+      @done = false
+      @buffer = ''
+    end
+
+  end
+end

data/lib/zimbra_intercepting_proxy/debug.rb

@@ -0,0 +1,15 @@
+module ZimbraInterceptingProxy
+  module Debug
+
+    require 'logger'
+
+    def self.logger(data)
+      return unless ZimbraInterceptingProxy::Config.debug
+      return if data.nil?
+      logger = Logger.new(STDOUT)
+      logger.info { data }
+    end
+    
+  end
+end
+    

data/lib/zimbra_intercepting_proxy/request.rb

@@ -0,0 +1,46 @@
+module ZimbraInterceptingProxy
+  class Request
+    require 'pp'
+    
+    attr_accessor :body, :headers, :parser
+    
+    def initialize(connection, parser)
+      @body = connection.body
+      @headers = connection.headers
+      @parser = parser
+    end
+    
+    def auth_request?
+      @parser.http_method == "POST" && @parser.request_url == "/zimbra/" && @headers["Cookie"] = "ZM_TEST=true" && auth_request_params?
+    end
+    
+    def auth_request_params?
+      uri = Addressable::URI.parse("http://localhost/?#{@body}")
+      uri.query_values["loginOp"] == "login"
+    end
+    
+    def route_request?
+      @parser.request_url == ZimbraInterceptingProxy::Config::ROUTE_URL
+    end
+    
+    def port
+      return ZimbraInterceptingProxy::Config::ROUTE_REQUEST_PORT if route_request?
+      return ZimbraInterceptingProxy::Config::AUTH_REQUEST_PORT if auth_request?
+    end
+    
+    def user_token
+      return auth_username if auth_request?
+      return auth_zimbraId if route_request?
+    end
+    
+    def auth_zimbraId
+      headers["Auth-User"]
+    end
+    
+    def auth_username
+      uri = Addressable::URI.parse("http://localhost/?#{@body}")
+      uri.query_values["username"]
+    end
+    
+  end
+end

data/lib/zimbra_intercepting_proxy/server.rb

@@ -0,0 +1,68 @@
+module ZimbraInterceptingProxy
+  
+  module Server
+    require 'pp'
+    
+    def run
+      debug = ZimbraInterceptingProxy::Debug
+      host = ZimbraInterceptingProxy::Config.bind_address
+      port = ZimbraInterceptingProxy::Config.bind_port
+
+      Proxy.start(:host => host, :port => port) do |conn|
+        
+        debug.logger "Starting server on #{host}:#{port}"
+        
+        @backend = {host: ZimbraInterceptingProxy::Config.old_backend, port: 80}
+        connection = ZimbraInterceptingProxy::Connection.new
+
+        @parser = Http::Parser.new
+        @parser.on_message_begin = proc{ connection.started = true }
+        @parser.on_headers_complete = proc { |e| connection.headers = e }
+        @parser.on_body = proc { |chunk| connection.body << chunk }
+        @parser.on_message_complete = proc do |p|
+          
+          request = ZimbraInterceptingProxy::Request.new(connection, @parser)
+                  
+          if request.auth_request? || request.route_request?
+            user = User.new(request.user_token)
+            @backend[:host] = user.backend if user.migrated?
+            @backend[:port] = request.port
+          end
+          
+          conn.server @backend[:host], :host => @backend[:host], :port => @backend[:port]
+          conn.relay_to_servers connection.buffer
+          
+          connection.buffer.clear
+          
+        end
+        
+        conn.on_connect do |data,b|
+          debug.logger [:on_connect, data, b]
+        end
+
+        conn.on_data do |data|
+          debug.logger [:on_data, data]
+          connection.buffer << data
+          @parser << data
+
+          data
+        end
+
+        conn.on_response do |backend, resp|
+          new_resp = resp.gsub(/Auth-Server: .*/, "Auth-Server: #{ZimbraInterceptingProxy::Config.new_backend}")
+          debug.logger [:on_response, backend, new_resp]
+          new_resp
+        end
+
+        conn.on_finish do |backend, name|
+          debug.logger [:on_finish, name].inspect
+        end
+        
+      end
+      
+    end
+    
+    module_function :run
+  end
+end
+

data/lib/zimbra_intercepting_proxy/user.rb

@@ -0,0 +1,60 @@
+module ZimbraInterceptingProxy
+  
+  class User
+    attr_accessor :email, :zimbraId
+    
+    # user_identifier can be an email address, zimbraId UUID or just the
+    # local part of an email address, like user in user@example.com
+    def initialize(user_identifier)
+      @zimbraId = set_zimbraId user_identifier
+      @email = set_email user_identifier
+      User.load_migrated_users
+    end
+    
+    # If user has email (unless email.nil?)
+    def migrated?
+      !find_in_db.nil?
+    end
+    
+    def backend
+      return ZimbraInterceptingProxy::Config.new_backend if migrated?
+      ZimbraInterceptingProxy::Config.old_backend
+    end
+    
+    def find_in_db
+      return User.DB[email] if has_email?
+      return User.DB.invert[zimbraId] if has_zimbraId?
+    end
+    
+    def has_email?
+      !email.nil?
+    end
+    
+    def has_zimbraId?
+      !zimbraId.nil?
+    end
+
+    def self.load_migrated_users
+      YAML.load_file ZimbraInterceptingProxy::Config.migrated_users_file
+    end
+    
+    def self.DB
+      load_migrated_users
+    end
+    
+    private
+    def set_zimbraId user_identifier
+      return user_identifier if UUID.validate user_identifier
+      nil
+    end
+    
+    def set_email user_identifier
+      return user_identifier if user_identifier.match(/@/)
+      return "#{user_identifier}@#{ZimbraInterceptingProxy::Config.domain}" unless UUID.validate user_identifier
+      nil
+    end
+
+    
+  end
+  
+end

data/lib/zimbra_intercepting_proxy/version.rb

@@ -0,0 +1,3 @@
+module ZimbraInterceptingProxy
+  VERSION = "0.0.2"
+end

data/test/fixtures/auth_80.txt

@@ -0,0 +1,14 @@
+POST /zimbra/ HTTP/1.0
+X-Forwarded-For: 186.67.32.114
+Host: 200.91.20.185
+Connection: close
+Content-Type: application/x-www-form-urlencoded
+Origin: http://190.196.208.85
+Cookie: ZM_TEST=true; ZM_TEST=true
+Content-Length: 66
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_3) AppleWebKit/600.5.17 (KHTML, like Gecko) Version/8.0.5 Safari/600.5.17
+Accept-Language: es-es
+Accept-Encoding: gzip, deflate
+
+loginOp=login&username=pbruna&password=5693537374&client=preferred

data/test/fixtures/route_7072.txt

@@ -0,0 +1,9 @@
+GET /service/extension/nginx-lookup HTTP/1.0
+Host: 127.0.0.1
+Auth-Method: zimbraId
+Auth-User: 251b1902-2250-4477-bdd1-8a101f7e7e4e
+Auth-Pass: XXX
+Auth-Salt: SSS
+Auth-Protocol: http
+Auth-Login-Attempt: 0
+X-Proxy-Host: 200.91.20.186

data/test/fixtures/users.yml

@@ -0,0 +1,6 @@
+pato@example.com: "7b562ae0-be97-0132-9a66-482a1423458f"
+max@example.com: "7b562c60-be97-0132-9a66-482a1423458f"
+moliery@example.com: "7b562ce0-be97-0132-9a66-482a1423458f"
+watson@example.com: "251b1902-2250-4477-bdd1-8a101f7e7e4e"
+sherlock@example.com: "7b562dd0-be97-0132-9a66-482a1423458f"
+pbruna@itlinux.cl: "cfd6e914-4f00-440c-9a57-e1a9327128b9"

data/test/test_backend.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class Backend < Minitest::Test
+  
+  def setup
+    @user_migrated_email = ZimbraInterceptingProxy::User.new("watson@example.com")
+    @user_migrated_zimbraId = ZimbraInterceptingProxy::User.new("251b1902-2250-4477-bdd1-8a101f7e7e4e")
+    @user_not_migrated_email = ZimbraInterceptingProxy::User.new("jackbower@example.com")
+    @user_not_migrated_zimbraId = ZimbraInterceptingProxy::User.new("251b1902-2250-4477-bdd1-8a101f7e7333")
+  end
+  
+  def test_should_return_old_backend_if_user_email_is_not_migrated
+    backend = ZimbraInterceptingProxy::Backend.for_user @user_not_migrated_email
+    assert_equal(ZimbraInterceptingProxy::Config.old_backend, backend)
+  end
+
+  def test_should_return_old_backend_if_user_zimbraID_is_not_migrated
+    backend = ZimbraInterceptingProxy::Backend.for_user @user_not_migrated_zimbraId
+    assert_equal(ZimbraInterceptingProxy::Config.old_backend, backend)
+  end
+
+  def test_should_return_new_backend_if_user_email_was_migrated
+    backend = ZimbraInterceptingProxy::Backend.for_user @user_migrated_email
+    assert_equal(ZimbraInterceptingProxy::Config.new_backend, backend)
+  end
+
+  def test_should_return_new_backend_if_user_zimbraID_was_migrated
+    backend = ZimbraInterceptingProxy::Backend.for_user @user_migrated_zimbraId
+    assert_equal(ZimbraInterceptingProxy::Config.new_backend, backend)
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require "zimbra_intercepting_proxy"
+
+require 'minitest/autorun'
+require 'minitest/reporters' # requires the gem
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new # spec-like progress
+
+ZimbraInterceptingProxy::Config.domain="example.com"
+ZimbraInterceptingProxy::Config.migrated_users_file="./test/fixtures/users.yml"
+ZimbraInterceptingProxy::Config.old_backend = "old-mailbox.example.com"
+ZimbraInterceptingProxy::Config.new_backend = "new-mailbox.zboxapp.com"

data/test/test_request.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class Request < Minitest::Test
+  
+  def setup
+    @auth_request = IO.read("./test/fixtures/auth_80.txt")
+    @route_request = IO.read("./test/fixtures/route_7072.txt")
+  end
+  
+  # def test_should_return_user_token_from_auth_request
+  #   request = ZimbraInterceptingProxy::Request.new @auth_request
+  #   assert_equal("pbruna", request.user_token)
+  # end
+  #
+  # def test_should_return_user_token_from_route_request
+  #   request = ZimbraInterceptingProxy::Request.new @route_request
+  #   assert_equal("251b1902-2250-4477-bdd1-8a101f7e7e4e", request.user_token)
+  # end
+  #
+end

data/test/test_user.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class User < Minitest::Test
+  
+  def setup
+    @user = {email: "watson@example.com", zimbraId: "251b1902-2250-4477-bdd1-8a101f7e7e4e"}
+  end
+  
+  def test_only_set_zimbraId_when_passed_a_zimbraId
+    u = ZimbraInterceptingProxy::User.new(@user[:zimbraId])
+    assert_equal(u.zimbraId, @user[:zimbraId])
+    assert_nil(u.email)
+  end
+  
+  def test_only_set_email_when_passed_an_email
+    u = ZimbraInterceptingProxy::User.new(@user[:email])
+    assert_equal(u.email, @user[:email])
+    assert_nil(u.zimbraId)
+  end
+  
+  def test_return_email_when_passed_just_an_username
+    u = ZimbraInterceptingProxy::User.new("watson")
+    assert_equal(u.email, @user[:email])
+    assert_nil(u.zimbraId)
+  end
+  
+  def test_should_load_db_user_file_to_global_hash
+    assert_equal(ZimbraInterceptingProxy::User.DB.class, Hash)
+  end
+  
+  def test_db_should_have_emails_when_email_is_passed
+    assert(ZimbraInterceptingProxy::User.DB["watson@example.com"])
+  end
+
+  def test_return_true_if_migrated_user_with_zimbraId
+    u = ZimbraInterceptingProxy::User.new("7b562ce0-be97-0132-9a66-482a1423458f")
+    assert(u.migrated?, "Failure message.")
+  end
+  
+  def test_return_false_if_not_migrated_user_with_zimbraId
+    u = ZimbraInterceptingProxy::User.new("7b562ce0-be97-0132-9a66-482a14234333")
+    assert(!u.migrated?, "Failure message.")
+  end
+  
+  def test_return_true_if_migrated_user_with_email
+    u = ZimbraInterceptingProxy::User.new(@user[:email])
+    assert(u.migrated?, "Failure message.")
+  end
+  
+  def test_return_false_if_no_migrated_user_with_email
+    u = ZimbraInterceptingProxy::User.new("pbruna")
+    assert(!u.migrated?, "Failure message.")
+  end
+  
+end

data/zimbra_intercepting_proxy.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zimbra_intercepting_proxy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zimbra_intercepting_proxy"
+  spec.version       = ZimbraInterceptingProxy::VERSION
+  spec.authors       = ["Patricio Bruna"]
+  spec.email         = ["pbruna@itlinux.cl"]
+  spec.summary       = "A HTTP intercepting Proxy for the Zimbra Proxy"
+  spec.description   = spec.summary
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency 'em-proxy'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'uuid'
+  spec.add_dependency 'http_parser.rb'
+  spec.add_dependency 'addressable'
+
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest-reporters"
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: zimbra_intercepting_proxy
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Patricio Bruna
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-proxy
+  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: thor
+  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: uuid
+  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: http_parser.rb
+  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: addressable
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A HTTP intercepting Proxy for the Zimbra Proxy
+email:
+- pbruna@itlinux.cl
+executables:
+- zimbra_intercepting_proxy
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/zimbra_intercepting_proxy
+- lib/zimbra_intercepting_proxy.rb
+- lib/zimbra_intercepting_proxy/backend.rb
+- lib/zimbra_intercepting_proxy/config.rb
+- lib/zimbra_intercepting_proxy/connection.rb
+- lib/zimbra_intercepting_proxy/debug.rb
+- lib/zimbra_intercepting_proxy/request.rb
+- lib/zimbra_intercepting_proxy/server.rb
+- lib/zimbra_intercepting_proxy/user.rb
+- lib/zimbra_intercepting_proxy/version.rb
+- test/fixtures/auth_80.txt
+- test/fixtures/route_7072.txt
+- test/fixtures/users.yml
+- test/test_backend.rb
+- test/test_helper.rb
+- test/test_request.rb
+- test/test_user.rb
+- zimbra_intercepting_proxy.gemspec
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A HTTP intercepting Proxy for the Zimbra Proxy
+test_files:
+- test/fixtures/auth_80.txt
+- test/fixtures/route_7072.txt
+- test/fixtures/users.yml
+- test/test_backend.rb
+- test/test_helper.rb
+- test/test_request.rb
+- test/test_user.rb
+has_rdoc: