ldap_tools 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: caa6dd479a62ca4b75d94ec3a14d3f5087b09b06
+  data.tar.gz: 8aab3638ac10b7346e61d80b48e99bdd1b020541
+SHA512:
+  metadata.gz: 931365eb56cf362723e430bab17e881d624cc4bde9a988c17bf2b31ee4e8169321b8d96c64ec454f862b54a16924a1b1d4ae661043f78611faeb49b6e871d78e
+  data.tar.gz: 7f0f97d5a554fbe5a2bf2d1e84010a2f3c285d87f3a206dc75cdd5be75560731a2a0df65c79cc7bc03f0ef42ac35cd79143bbcf6097af47e76e5108e7e495d63

data/bin/ldaptools

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require 'tapjoy/ldap'
+
+def commands(synopsis, object, sub_commands)
+  Trollop::options do
+    usage "#{object} [SUB_COMMAND] [options]"
+    synopsis "\n#{synopsis}.\nAvailable subcommands are: #{sub_commands}"
+    stop_on sub_commands
+  end
+end
+
+SUB_COMMANDS = %w(user group key audit)
+commands('Tool to manage LDAP resources', '', SUB_COMMANDS)
+
+cmd = ARGV.shift # get the subcommand
+case cmd
+when "user"  # run commands associated with user object
+  USER_SUB_COMMANDS = %w(create delete)
+  commands('This object is used for user management', cmd, USER_SUB_COMMANDS)
+  Tapjoy::LDAP::User.new
+when 'group'
+  GROUP_SUB_COMMANDS = %w(create delete add_user)
+  commands('This object is used for group management', cmd, GROUP_SUB_COMMANDS)
+  Tapjoy::LDAP::Group.new
+when 'key'
+  KEY_SUB_COMMANDS = %w(add remove install)
+  commands('This object is used for group management', cmd, KEY_SUB_COMMANDS)
+  Tapjoy::LDAP::Key.new
+when 'audit'
+  AUDIT_SUB_COMMANDS = %w(by_user by_group raw)
+  commands('This object is used for auditing LDAP permissions', cmd, AUDIT_SUB_COMMANDS)
+  Tapjoy::LDAP::Audit.new
+else
+  raise Tapjoy::LDAP::InvalidArgument
+end

data/lib/tapjoy/ldap/audit.rb

@@ -0,0 +1,88 @@
+module Tapjoy
+  module LDAP
+    class Audit
+
+      # Instantiate class
+      def initialize
+        command = ARGV.shift
+
+        case command
+        when 'by_user', 'by_group', 'raw'
+          send(command)
+        else
+          raise Tapjoy::LDAP::InvalidArgument
+        end
+      end
+
+      private
+
+      # Clean output of hashes
+      def print_hash(header_string, object_hash)
+        puts header_string
+        puts "=" * header_string.length
+        object_hash.each_pair do |key, values|
+          next if values.empty?
+          puts "- #{key}"
+          values.each { |value| puts "  - #{value}" }
+        end
+      end
+
+      # Get list of users
+      def get_users
+        user_list = Array.new
+
+        filter = Net::LDAP::Filter.eq('objectclass', 'posixAccount')
+        attributes = ['uid']
+
+        results = Tapjoy::LDAP::client.search(attributes, filter)
+        results.each do |entry|
+          user_list << entry['uid'].first
+        end
+
+        return user_list.sort
+      end
+
+      # Get hash of groups with list of members of each group
+      def get_groups_with_membership
+        filter = Net::LDAP::Filter.eq('objectclass', 'posixGroup')
+        attributes = ['cn', 'memberUid']
+
+        results = Tapjoy::LDAP::client.search(attributes, filter)
+
+      end
+
+      # Get a group to user mapping
+      def by_user
+        user_groups = Hash.new
+        user_list = get_users
+        group_results = get_groups_with_membership
+
+        user_list.each do |user|
+          user_groups[user] = Array.new
+          group_results.each do |entry|
+            user_groups[user] << entry['cn'].first if entry['memberUid'].include?(user)
+          end
+        end
+
+        print_hash('Groups by user', user_groups)
+      end
+
+      # Get a user to group mapping
+      def by_group
+        group_membership = Hash.new
+
+        get_groups_with_membership.each do |entry|
+          group_membership[entry['cn'].first] = entry['memberUid']
+        end
+
+        print_hash('Users in groups', group_membership)
+      end
+
+      # Print raw output
+      def raw
+        results = Tapjoy::LDAP::client.search
+        puts results.inspect
+      end
+    end
+  end
+end

data/lib/tapjoy/ldap/base.rb

@@ -0,0 +1,180 @@
+module Tapjoy
+  module LDAP
+    class Base
+
+      attr_reader :hosts, :basedn, :conn, :service_ou, :group, :key
+
+      # Instantiate class
+      def initialize
+        ldap_config_file = "#{ldap_config_directory}/ldap_info.yaml"
+        ldap_password_file = "#{ldap_config_directory}/ldap.secret"
+        @ldap_info    = YAML.load_file(ldap_config_file)
+        @hosts        = @ldap_info['servers']
+        @basedn       = @ldap_info['basedn']
+        @conn         = find_valid_host(ldap_password_file)
+        @service_ou   = @ldap_info['service_ou']
+        @email_domain = @ldap_info['email_domain']
+      end
+
+      # Set LDAP Config Directory
+      def ldap_config_directory
+        return "#{ENV['LDAP_CONFIG_DIR'] ? ENV['LDAP_CONFIG_DIR'] : ENV['HOME'] + '/.ldap'}"
+      end
+
+      # Search the LDAP directory
+      def search(attributes = ['*'],
+                 filter = Net::LDAP::Filter.eq('objectclass','*'))
+        @entries = []
+        if @conn
+          @conn.search :base => @basedn,
+                       :filter => filter,
+                       :attributes => attributes do |entry|
+            @entries.push(entry)
+          end
+        else
+          abort('Could not connect to any LDAP servers')
+        end
+
+        return @entries
+      end
+
+      # Add objects to LDAP
+      def add(dn, attributes)
+        @conn.add(:dn => dn, :attributes => attributes)
+        return return_result
+      end
+
+      # Modify objects in LDAP
+      def modify(dn, operations)
+        @conn.modify(:dn => dn, :operations => operations)
+        return return_result
+      end
+
+      # Delete objects from LDAP
+      def delete(dn)
+        @conn.delete(:dn => dn)
+        return return_result
+      end
+
+      # Format return codes
+      def return_result
+        msg1 = "Return Code: #{ @conn.get_operation_result.code }\n"
+        msg2 = "Message: #{ @conn.get_operation_result.message }"
+        return msg1 + msg2
+      end
+
+      # Get highest used ID
+      def get_max_id(object_type, role)
+        case object_type
+        when 'user'
+          objectclass = 'person'
+          ldap_attr   = 'uidNumber'
+        when 'group'
+          objectclass = 'posixGroup'
+          ldap_attr   = 'gidNumber'
+        else
+          abort('Unknown object type')
+        end
+
+        minID, maxID = set_id_boundary(role)
+
+        # LDAP Filters
+        oc_filter   = Net::LDAP::Filter.eq('objectclass', objectclass)
+        attr_filter = Net::LDAP::Filter.eq(ldap_attr, '*')
+        filter      = Net::LDAP::Filter.join(oc_filter, attr_filter)
+
+        highid = minID - 1  #subtract 1, so we can add 1 later
+
+        id_list = search([ldap_attr], filter)
+        id_list.each do |item|
+
+          # parse attribute associated with object
+          # users => uidnumber
+          # groups => gidnumber
+          if object_type == 'user'
+            id = item.uidnumber[0].to_i
+          elsif object_type == 'group'
+            id = item.gidnumber[0].to_i
+          else
+            abort('Unknown object')
+          end
+
+          # Now that we have the appropriate attribute
+          # let's find the first useable id.
+          # I *really* hate the pattern I use here, but
+          # can't think of a better one atm.
+          if id > highid
+            highid = id
+          end
+          if maxID.nil?
+            next
+          else
+            if id > maxID
+              highid = maxID
+            end
+          end
+        end
+
+        if !highid.nil?
+          id = highid + 1
+          return id.to_s
+        else
+          abort("Unable to find highest #{ldap_attr}")
+        end
+      end
+
+
+      ## Private methods start here ##
+      private
+
+      # Connect to LDAP server
+      def ldap_connect(host, ldap_password_file)
+        port = @ldap_info['port']
+        auth = {
+          :method   => :simple,
+          :username => @ldap_info['rootdn'],
+          :password => File.read(ldap_password_file).chomp
+        }
+
+        ldap = Net::LDAP.new :host => host,
+                             :port => port,
+                             :base => @basedn,
+                             :auth => auth
+        return ldap
+      end
+
+      # Find valid LDAP host
+      def find_valid_host(ldap_password_file)
+        @hosts.each do |host|
+          @ldap = ldap_connect(host, ldap_password_file)
+          begin
+            if @ldap.bind
+              return @ldap
+            else
+              next
+            end
+          rescue Net::LDAP::LdapError
+            next
+          end
+        end
+        abort('Could not connect to any LDAP servers')
+      end
+
+      # Set acceptable range for IDs
+      def set_id_boundary(role)
+        case role
+        when 'user'
+          minID = 10000
+          maxID = 19999
+        when 'service'
+          minID = 20000
+          maxID = nil
+        else
+          abort('Unknown role')
+        end
+
+        return minID, maxID
+      end
+    end
+  end
+end

data/lib/tapjoy/ldap/group.rb

@@ -0,0 +1,109 @@
+module Tapjoy
+  module LDAP
+    class Group
+
+      attr_reader :groupname, :servers, :conn
+
+      # Instantiate class
+      def initialize
+        # This is a necessary construct, because init could be called from
+        # places other than the commandline.  As result, we want to overload
+        # init, without *really* overloading it.
+        if ARGV.length >= 1
+          command = ARGV.shift
+
+          case command
+          when 'create', 'delete', 'add_user'
+            send(command)
+          else
+            raise Tapjoy::LDAP::InvalidArgument
+          end
+        end
+      end
+
+      # Lookup GID for the given group
+      def lookup_id(groupname)
+        gidnumber = []
+
+        oc_filter = Net::LDAP::Filter.eq('objectclass', 'posixGroup')
+        cn_filter = Net::LDAP::Filter.eq('cn', groupname)
+        filter    = Net::LDAP::Filter.join(oc_filter, cn_filter)
+
+        results = Tapjoy::LDAP::client.search(['gidNumber'], filter)
+
+        # Make sure we return one, and only one group
+        if results.size < 1
+          abort('Group not found')
+        elsif results.size > 1
+          abort('Multiple groups found. Please narrow your search.')
+        end
+
+        results.each { |result| gidnumber = result.gidnumber }
+        return gidnumber[0]
+      end
+
+      private
+      # Create group
+      def create
+        opts = Trollop::options do
+          # Set help message
+          banner("#{$0} group create [options]")
+
+          opt :name, 'Specify group to create', :type => :string
+          opt :type, 'Specfy if this is a user or service group', :type => :string, :default => 'user'
+        end
+
+        Trollop::die :name, 'argument count must be one' if opts[:name].nil?
+        Trollop::die :type, "argument must be 'user' or 'service'" unless ['user', 'service'].include?opts[:type]
+
+        dn = "cn=#{ opts[:name] },ou=Group,#{ Tapjoy::LDAP::client.basedn }"
+
+        ldap_attr = {
+          :cn          => opts[:name],
+          :objectclass => ['top','posixGroup'],
+          :gidnumber   => Tapjoy::LDAP::client.get_max_id('group', opts[:type])
+        }
+        puts Tapjoy::LDAP::client.add(dn, ldap_attr)
+      end
+
+      # Delete group
+      def delete
+        opts = Trollop::options do
+          # Set help message
+          banner("#{$0} group delete [options]")
+
+          opt(:group, 'Specify group', :type => :string, :required => true)
+          opt(:force, 'Force delete')
+        end
+
+        dn = "cn=#{ opts[:group] },ou=Group,#{ Tapjoy::LDAP::client.basedn }"
+        unless opts[:force]
+          puts "Confirm that you want to delete group: #{ opts[:group] }"
+          print '>'
+          confirm = STDIN.gets.chomp().downcase
+          unless confirm.eql?('y') || confirm.eql?('yes')
+            abort("Deletion of #{ opts[:group] } aborted")
+          end
+        end
+
+        puts Tapjoy::LDAP::client.delete(dn)
+      end
+
+      # Add user to group
+      def add_user
+        opts = Trollop::options do
+          banner("#{0} group add_user [options]")
+
+          opt(:group, 'Specify group', :type => :string, :required => true)
+          opt(:username, 'Specify username', :type => :string, :required => true)
+        end
+
+        dn = "cn=#{ opts[:group] },ou=Group,#{ Tapjoy::LDAP::client.basedn }"
+        operations = [
+          [:add, :memberUid, opts[:username]]
+        ]
+        puts Tapjoy::LDAP::client.modify(dn, operations)
+      end
+    end
+  end
+end

data/lib/tapjoy/ldap/key.rb

@@ -0,0 +1,187 @@
+module Tapjoy
+  module LDAP
+    class Key
+
+      # Instantiate class
+      def initialize
+        command = ARGV.shift
+
+        case command
+        when 'add', 'remove', 'install'
+          send(command)
+        else
+          raise Tapjoy::LDAP::InvalidArgument
+        end
+      end
+
+      ## Private methods start here ##
+      private
+      # Get key listing from LDAP
+      def get_keys_from_ldap
+
+        key_results = {}
+
+        results = Tapjoy::LDAP::client.search(attributes = ['uid', 'sshPublicKey'],
+                    filter = Net::LDAP::Filter.eq('sshPublicKey', '*'))
+
+        results.each { |result| key_results[result.uid[0]] = result.sshPublicKey }
+
+        return key_results
+      end
+
+      # Retrieve keys from file/stdin
+      def get_keys_from_commandline(filename)
+        return_keys = []
+
+        if filename.eql?('-')
+          STDIN.each do |str|
+            return_keys << str.chomp!
+          end
+        else
+          return_keys = Array(File.open(filename))
+        end
+
+        return_keys.each { |key| verify(key) }
+        return return_keys
+      end
+
+      # Verify key format
+      def verify(key)
+        unless key.start_with?('ssh')
+          puts "Invalid key due to missing ssh key type:\n\n"
+          puts "\t#{ key }\n\n"
+          abort "Please verify your key and try again"
+        end
+      end
+
+      # Add key to LDAP
+      def add
+        opts = Trollop::options do
+          # Set help message
+          banner("#{$0} key add [options]")
+
+          opt :user, 'Specify username to add key to', :type => :string,
+              :required => true
+          opt :filename, 'File to load keys from', :type => :string, :default => '-'
+        end
+
+        keys = get_keys_from_commandline(opts[:filename])
+
+        filter = Net::LDAP::Filter.eq('uid', opts[:user])
+        results = Tapjoy::LDAP::client.search(attributes = ['*'], filter = filter)
+
+        # Make sure we return one, and only one user DN
+        if results.size < 1
+          abort 'user not found'
+        elsif results.size > 1
+          abort 'Multiple users found. Please narrow your search.'
+        end
+
+        results.each  do |result|
+          unless result.objectclass.include?('ldapPublicKey')
+            puts 'LDAP Public Key Object Class not found.'
+            abort 'Please ensure user was created correctly.'
+          end
+          keys.each do |key|
+            Tapjoy::LDAP::client.conn.add_attribute(result.dn, :sshPublicKey, key)
+            puts Tapjoy::LDAP::client.return_result
+          end
+        end
+      end
+
+      # Remove key from LDAP
+      def remove
+        opts = Trollop::options do
+          # Set help message
+          banner("#{$0} key remove [options]")
+
+          opt :user, 'Specify username to delete key from', :type => :string,
+              :required => true
+          opt :filename, 'File to load key deletion list from', :type => :string,
+              :default => '-'
+          opt(:force, 'Force delete')
+        end
+
+        keys = get_keys_from_commandline(opts[:filename])
+
+        filter = Net::LDAP::Filter.eq('uid', opts[:user])
+        attributes = ['sshPublicKey']
+        old_array = []
+
+        new_array = []
+
+        results = Tapjoy::LDAP::client.search(attributes, filter)
+        if results.size < 1
+          puts "User (#{ opts[:user] }) not found."
+          abort 'Please check the username and try again'
+        elsif results.size > 1
+          abort 'Multiple users found. Please narrow your search.'
+        end
+
+        results.each do |result|
+          @user_dn = result.dn
+          puts "User DN: #{ @user_dn }"
+          old_array = result.sshPublicKey
+        end
+
+        keep_keys = old_array - keys
+        delete_keys = old_array & keys
+        keys_not_found = keys - old_array
+
+        puts 'Please confirm the following operations:'
+        puts "Keep these keys:\n\n"
+        print "\t #{ keep_keys }\n\n"
+        puts "Delete these keys:\n\n"
+        print "\t #{ delete_keys }\n\n"
+        puts "Ignore these keys (not found in LDAP for #{ opts[:user]}):\n\n"
+        print "\t #{ keys_not_found }\n\n"
+
+        # We have to create a new stdin here, because we already use stdin
+        # in the get_keys_from_commandline method.
+        fd = IO.sysopen('/dev/tty', 'w+')
+        unless opts[:force]
+          print '>'
+          confirm = ''
+          IO.open(fd, 'w+')  { |io| confirm = io.gets.chomp }
+          unless confirm.eql?('y') || confirm.eql?('yes')
+            abort("Deletion of #{ opts[:user] } aborted")
+          end
+        end
+
+        Tapjoy::LDAP::client.conn.replace_attribute(@user_dn, :sshPublicKey, keep_keys)
+      end
+
+      # Install key on localhost
+      def install
+        opts = Trollop::options do
+          # Set help message
+          banner("#{$0} key install [options]")
+
+          opt :debug, 'Enable debug/dry-run mode'
+        end
+
+        # Store results of query
+        if opts[:debug]
+          puts search_results
+          exit 1
+        end
+
+        get_keys_from_ldap.each do |key,values|
+          directory = "/etc/ssh/users/#{key}"
+          FileUtils.mkdir_p(directory) unless File.exists?directory
+          keypath = "#{directory}/authorized_keys"
+          if File.exists?(keypath)
+            keys = File.read(keypath)
+          else
+            keys = []
+          end
+          File.open(keypath, 'a+') do |file|
+            file.puts values.reject { |value| keys.include?(value) }
+          end
+        end
+
+        # TODO method to remove from authorized_keys any key that is not in LDAP
+      end
+    end
+  end
+end

data/lib/tapjoy/ldap/user.rb

@@ -0,0 +1,114 @@
+require 'digest'
+require 'securerandom'
+
+module Tapjoy
+  module LDAP
+    class User
+
+      # Instantiate class
+      def initialize
+        command = ARGV.shift
+
+        case command
+        when 'create', 'delete'
+          send(command)
+        else
+          raise Tapjoy::LDAP::InvalidArgument
+        end
+      end
+
+      private
+      # Create user in LDAP
+      def create
+        opts = Trollop::options do
+          # Set help message
+          usage "user create [options]"
+
+          # Username is two arguments
+          # Trollop will accept more, but we will only parse two later
+          # TODO: support given names that include a space
+          opt(:user, "Specify user's first and last name",
+              :type => :strings, :required => true)
+
+          # Groupname is a single string, for primary group setting
+          opt(:group, 'Specify name of primary group', :type => :string, :required => true)
+
+          opt(:type, 'Specfy if this is a user or service account',
+              :type => :string, :default => 'user')
+        end
+
+        Trollop::die :user, 'argument count must be two' if opts[:user].size != 2
+        Trollop::die :type, "argument must be 'user' or 'service'" unless ['user', 'service'].include?opts[:type]
+
+        fname, lname = opts[:user]
+
+        # format username
+        username = "#{fname}.#{lname}"
+        username = username.downcase
+        group = Tapjoy::LDAP::Group.new
+
+        uidnumber = Tapjoy::LDAP::client.get_max_id('user', opts[:type])
+        gidnumber = group.lookup_id(opts[:group])
+
+        case opts[:type]
+        when 'user'
+          ou = 'People'
+        when 'service'
+          ou = Tapjoy::LDAP::client.service_ou
+        else
+          puts 'Unknown type'
+        end
+
+        # Super-Salt: bad for blood pressure, good for secure passwords
+        # We can get away with this, since we're not planning on using passwords
+        salt = SecureRandom.base64(32)
+        password = SecureRandom.base64(64)
+        password = Digest::SHA1.base64digest(password + salt)
+        dn = "uid=#{ username },ou=People,#{ Tapjoy::LDAP::client.basedn }"
+        ldap_attr = {
+          :uid           => username,
+          :cn            => "#{ fname } #{ lname }",
+          :objectclass   => ['top','posixAccount','shadowAccount','inetOrgPerson',
+                             'organizationalPerson','person', 'ldapPublicKey'],
+          :sn            => lname,
+          :givenname     => fname,
+          :homedirectory => "/home/#{ username }",
+          :loginshell    => '/bin/bash',
+          :mail          => "#{fname}.#{lname}@tapjoy.com".downcase,
+          :uidnumber     => uidnumber,
+          :gidnumber     => gidnumber,
+          :userpassword  => '{SSHA}' + password
+        }
+        puts Tapjoy::LDAP::client.add(dn, ldap_attr)
+
+      end
+
+      # Delete user from LDAP
+      def delete
+        options = {}
+        prompt = '>'
+
+        opts = Trollop::options do
+          # Set help message
+          usage "user delete [options]"
+
+          opt(:user, 'Specify username', :type => :string, :required => true)
+          opt(:force, 'Force delete')
+        end
+
+        dn = "uid=#{ opts[:user] },ou=People,#{ Tapjoy::LDAP::client.basedn }"
+        unless opts[:force]
+          puts "Confirm that you want to delete user: #{ opts[:user] }"
+          print prompt
+          confirm = STDIN.gets.chomp().downcase
+          unless confirm.eql?('y') || confirm.eql?('yes')
+            abort("Deletion of #{ opts[:user] } aborted")
+          end
+        end
+
+        puts Tapjoy::LDAP::client.delete(dn)
+      end
+
+    end
+  end
+end

data/lib/tapjoy/ldap.rb

@@ -0,0 +1,23 @@
+require 'net/ldap'
+require 'yaml'
+require 'trollop'
+require_relative 'ldap/base'
+require_relative 'ldap/group'
+require_relative 'ldap/key'
+require_relative 'ldap/user'
+require_relative 'ldap/audit'
+
+module Tapjoy
+  module LDAP
+
+    def self.client
+      @@client ||= Tapjoy::LDAP::Base.new
+    end
+
+    class InvalidArgument < ArgumentError
+      def initialize
+        Trollop::educate
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: ldap_tools
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ali Tayarani
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: net-ldap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.11'
+description: A set of tools to make managing LDAP users, groups, and keys easier
+email: ali.tayarani@tapjoy.com
+executables:
+- ldaptools
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ldaptools
+- lib/tapjoy/ldap.rb
+- lib/tapjoy/ldap/audit.rb
+- lib/tapjoy/ldap/base.rb
+- lib/tapjoy/ldap/group.rb
+- lib/tapjoy/ldap/key.rb
+- lib/tapjoy/ldap/user.rb
+homepage: https://github.com/Tapjoy/ops-toolbox-internal/tree/master/scripts/ldap-tools
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Tapjoy LDAP Tools
+test_files: []