cocoapods-keys 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8f23dba489a19e3db03b86ae34dd3ae84f9093a0
+  data.tar.gz: fe7c56f4c93c86636906a8133de150a1d3dafc9a
+SHA512:
+  metadata.gz: 8296b115b402a664ad3afc3402eb9d1490219e75506570afc82a5404f9acce206c4e6a2228120ce9cf274c28858454fe62b7ea0b656e8666f9b34474a8f0f806
+  data.tar.gz: 26b57d67e5b1bbd521b858db1a398182091107a3aecdfc1faae4ca62bc6748de6b9196791609801d29518b7d537f5084c40892d81178776ef3cb87f9903af434

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+pkg
+.idea/

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    cocoapods-keys (0.5.2)
+      osx_keychain
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    RubyInline (3.12.3)
+      ZenTest (~> 4.3)
+    ZenTest (4.10.1)
+    osx_keychain (1.0.0)
+      RubyInline (~> 3)
+    rake (10.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  cocoapods-keys!
+  rake

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Orta Therox <orta.therox@gmail.com>
+
+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,84 @@
+A key value store for enviroment and application keys.
+
+Its good security practice to keep production keys out of developer hands. CocoaPods-keys makes it easy to have per-user config settings stored securely in the developer's keychain, and not in the application source. It is a plugin that once installed will run on every `pod install` or `pod update`.
+
+## Requirements
+
+Requires CocoaPods 0.34+.
+
+## Installation
+
+    $ gem install cocoapods-keys
+
+## How it works
+
+Key names are stored in `~/cocoapods/keys/` and key values in the OS X keychain. When you run `pod install` or `pod update`, an Objective-C class is created with scrambled versions of the keys, making it difficult to just [dump](https://github.com/stefanesser/dumpdecrypted) the contents of the decrypted binary and extract the keys. At runtime, the keys are unscrambled for use in your app.
+
+The generated Objective-C classes are stored in the `Pods/Keys` directory, so if you're checking in your [Pods folder](http://guides.cocoapods.org/using/using-cocoapods.html#should-i-ignore-the-pods-directory-in-source-control), just add `Pods/Keys` to your `.gitignore` file.
+
+## Usage
+
+You can save keys on a per-project basis by running the command:
+
+    $ pod keys set KEY VALUE
+
+You can list all known keys by running:
+
+    $ pod keys
+
+For example:
+
+``` sh
+  $ cd MyApplication
+  $ pod keys set "NetworkAPIToken" "AH2ZMiraGQbyUd9GkNTNfWEdxlwXcmHciEOH"
+  Saved NetworkAPIToken to MyApplication.
+
+  $ pod keys set "AnalyticsToken" "6TYKGVCn7sBSBFpwfSUCclzDoSBtEXw7"
+  Saved AnalyticsToken to MyApplication.
+
+  $ pod keys
+  Keys for MyApplication
+   ├  NetworkAPIToken - AH2ZMiraGQbyUd9GkNTNfWEdxlwXcmHciEOH
+   └  AnalyticsToken - 6TYKGVCn7sBSBFpwfSUCclzDoSBtEXw7
+
+  GIFs - /Users/orta/dev/mac/GIFs
+   └ redditAPIToken & mixpanelAPIToken
+```
+
+After the next `pod install` or `pod update` keys will add a new Objective-C class to your Pods xcworkspace. This provides an API to your keys from Cocoa code. For example the application code above would look like:
+
+``` objc
+
+#import "ORAppDelegate.h"
+#import <CocoaPods-Keys/MyApplicationKeys.h>
+#import <ARAnalytics/ARAnalytics.h>
+
+@implementation ORAppDelegate
+
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
+{
+    MyApplicationKeys *keys = [[MyApplicationKeys alloc] init];
+    [ARAnalytics setupWithAnalytics:@{
+        ARGoogleAnalyticsID : keys.analyticsToken;
+    }];
+}
+
+@end
+
+```
+
+#### Security
+
+Key security is difficult. Right now even the biggest apps get their keys [leaked](https://threatpost.com/twitter-oauth-api-keys-leaked-030713/77597). This is neatly summed up by John Adams of the Twitter Security Team on [Quora](http://www.quora.com/Twitter-1/How-were-the-Twitter-iPhone-and-Android-OAuth-keys-leaked).
+
+> Putting this in the context of, "should you be storing keys in software", is more appropriate. Many companies do this. It's never a good idea.
+
+> When developers do that, other developers can use debuggers and string searching commands to extract those keys from the running application. There are numerous talks on how to do that, but leave that as an exercise to the reader to find those talks.
+
+> Many people believe that obfuscating these keys in code will help. It usually won't because you can just run a debugger and find the fully functional keys.
+
+So in summary, the ideal way to store keys is to not store keys. In reality though most Apps embed keys, and this does that and adds some rudimentary obfuscation to the keys. A well motivated app cracker could probably extract this within a few minutes however.
+
+#### Thanks
+
+This was built with a lot of help from [@segiddins](https://github.com/segiddins).

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/cocoapods_keys.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cocoapods_keys.rb'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cocoapods-keys"
+  spec.version       = CocoaPodsKeys::VERSION
+  spec.authors       = ["Orta Therox", 'Samuel E. Giddins']
+  spec.email         = ["orta.therox@gmail.com", 'segiddins@segiddins.me']
+  spec.description   = %q{A key value store for environment settings in Cocoa Apps.}
+  spec.summary       = %q{CocoaPods Keys will store sensitive data in your Mac's keychain. Then on running pod install they will be installed into your app's source code via the Pods library.}
+  spec.homepage      = "https://github.com/cocoapods/cocoapods-keys"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_runtime_dependency "osx_keychain"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/cocoapods_keys.rb

@@ -0,0 +1,3 @@
+module CocoaPodsKeys
+  VERSION = "0.5.2"
+end

data/lib/cocoapods_plugin.rb

@@ -0,0 +1,3 @@
+require "keyring"
+require 'pod/command/keys'
+require 'plugin'

data/lib/installer.rb

@@ -0,0 +1,43 @@
+module CocoaPodsKeys
+  class Installer
+    def initialize(sandbox_root)
+      @sandbox_root = sandbox_root
+    end
+
+    def install!
+      require 'key_master'
+      require 'keyring_liberator'
+
+      keyring = KeyringLiberator.get_keyring(Dir.getwd)
+
+      return unless keyring
+
+      Pod::UI.section 'Adding keys' do
+        key_master = KeyMaster.new(keyring)
+
+        keys_folder = File.join(@sandbox_root, 'Keys')
+        keys_headers_folder = File.join(@sandbox_root, 'Headers', 'CocoaPods-Keys')
+        interface_file = File.join(keys_headers_folder, key_master.name + '.h')
+        implementation_file = File.join(keys_folder, key_master.name + '.m')
+        Dir.mkdir keys_folder unless Dir.exists? keys_folder
+        Dir.mkdir keys_headers_folder unless Dir.exists? keys_headers_folder
+        File.open(interface_file, 'w') { |f| f.write(key_master.interface) }
+        File.open(implementation_file, 'w') { |f| f.write(key_master.implementation) }
+
+        project = Xcodeproj::Project.open File.join(@sandbox_root, 'Pods.xcodeproj')
+
+        group = project.new_group('Keys')
+        group.new_file(interface_file)
+        implementation = group.new_file(implementation_file)
+
+        pods_target = project.targets.detect { |t| t.name == 'Pods' }
+        unless pods_target
+          pods_target = project.targets.detect { |t| t.name == 'Pods-' + keyring.name }
+        end
+        pods_target.add_file_references [implementation]
+
+        project.save
+      end
+    end
+  end
+end

data/lib/key_master.rb

@@ -0,0 +1,134 @@
+require 'set'
+
+module CocoaPodsKeys
+  class KeyMaster
+
+    attr_accessor :name, :interface, :implementation
+
+    def initialize(keyring)
+      @keys = Hash[keyring.keychain_data.map { |(key, value)| [key[0].downcase + key[1..-1], value] }]
+      @name = keyring.code_name + 'Keys'
+      @used_indexes = Set.new
+      @indexed_keys = {}
+      @data = generate_data
+      @interface = generate_interface
+      @implementation = generate_implementation
+    end
+
+    def generate_data
+
+      # Generate a base64 hash string that is ~25 times the length of all keys
+
+      @data_length = @keys.values.map(&:length).reduce(:+) * (20 + rand(10))
+      data = `head -c #{@data_length} /dev/random | base64 | head -c #{@data_length}`
+      length = data.length
+
+      # Swap the characters within the hashed string with the characters from
+      # the keyring values. Then store that index in a index-ed copy of the values.
+
+      @keys.each do |key, value|
+        @indexed_keys[key] = []
+
+        value.chars.each_with_index do |char, char_index|
+          loop do
+
+            index = rand data.length
+            unless @used_indexes.include?(index)
+              data[index] = char
+
+              @used_indexes << index
+              @indexed_keys[key][char_index] = index
+              break
+            end
+
+          end
+        end
+      end
+
+      data
+    end
+
+    def generate_interface
+      erb = <<-SOURCE
+//
+// Generated by CocoaPods-Keys
+// on #{Time.now.strftime("%d/%m/%Y")}
+// For more information see https://github.com/cocoapods/cocoapods-keys
+//
+
+#import <Foundation/NSString.h>
+
+@interface <%= @name %> : NSObject
+<% @keys.each do |key, value| %>
+- (NSString *)<%= key %>;<% end %>
+
+@end
+SOURCE
+
+      render_erb(erb)
+    end
+
+    def generate_implementation
+      require 'digest'
+
+      erb = <<-SOURCE
+//
+// Generated by CocoaPods-Keys
+// on #{Time.now.strftime("%d/%m/%Y")}
+// For more information see https://github.com/cocoapods/cocoapods-keys
+//
+
+#import <objc/runtime.h>
+#import "<%= @name %>.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wincomplete-implementation"
+
+@implementation <%= @name %>
+
+#pragma clang diagnostic pop
+
++ (BOOL)resolveInstanceMethod:(SEL)name
+{
+  NSString *key = NSStringFromSelector(name);
+  NSString * (*implementation)(<%= name %> *, SEL) = NULL;
+<% @keys.each do |key, value| %>
+  if ([key isEqualToString:@"<%= key %>"]) {
+    implementation = _podKeys<%= Digest::MD5.hexdigest(key) %>;
+  }
+<% end %>
+  if (!implementation) {
+    return [super resolveInstanceMethod:name];
+  }
+
+  return class_addMethod([self class], name, (IMP)implementation, "@@:");
+}
+<% @keys.each do |key, value| %>
+static NSString *_podKeys<%= Digest::MD5.hexdigest(key) %>(<%= name %> *self, SEL _cmd)
+{
+  char cString[<%= @indexed_keys[key].length + 1 %>] = { <%= key_data_arrays[key] %>, '\\0' };
+  return [NSString stringWithCString:cString encoding:NSUTF8StringEncoding];
+}
+<% end %>
+
+static char <%= name %>Data[<%= @data_length %>] = "<%= @data %>";
+
+@end
+SOURCE
+
+      render_erb(erb)
+    end
+
+    :private
+
+    def render_erb(erb)
+      require 'erb'
+      ERB.new(erb).result(binding)
+    end
+
+    def key_data_arrays
+      Hash[@indexed_keys.map {|key, value| [key, value.map { |i| name + "Data[#{i}]" }.join(', ')]}]
+    end
+
+  end
+end

data/lib/keyring.rb

@@ -0,0 +1,42 @@
+require "osx_keychain"
+
+module CocoaPodsKeys
+  class Keyring
+    attr_accessor :keys, :path, :name
+
+    def initialize(name, path, keys=[])
+      @name = name
+      @path = path
+      @keys = keys
+    end
+
+    def self.from_hash(hash)
+      new(hash["name"], hash["path"], hash["keys"])
+    end
+
+    def to_hash
+      { "keys" => @keys, "path" => @path, "name" => @name }
+    end
+
+    def code_name
+      name.split(/[^a-zA-Z0-9_-]/).map { |s| s[0].upcase + s[1..-1] }.join('')
+    end
+
+    def save(key, value)
+      keychain = OSXKeychain.new
+      keychain[keychain_prefix + name, key] = value
+    end
+
+    def keychain_data
+      keychain = OSXKeychain.new
+      Hash[
+        @keys.map { |key| [key, keychain[keychain_prefix + name, key]] }
+      ]
+    end
+
+    def keychain_prefix
+      "cocoapods-keys-"
+    end
+
+  end
+end

data/lib/keyring_liberator.rb

@@ -0,0 +1,46 @@
+require "digest"
+require "yaml"
+require "pathname"
+
+module CocoaPodsKeys
+    class KeyringLiberator
+
+      # Gets given a gives back a Keyring for the project
+      # by basically parsing it out of ~/.cocoapods/keys/"pathMD5".yml
+
+      def self.keys_dir
+         Pathname.new("~/.cocoapods/keys/").expand_path.to_s
+      end
+
+      def self.yaml_path_for_path(path)
+        sha = Digest::MD5.hexdigest(path)
+        File.join(keys_dir, sha + '.yml')
+      end
+
+      def self.get_keyring(path)
+        get_keyring_at_path(yaml_path_for_path(path))
+      end
+
+      def self.save_keyring(keyring)
+        `mkdir -p #{keys_dir}`
+
+        File.open(yaml_path_for_path(keyring.path), 'w') {|f| f.write(YAML::dump(keyring.to_hash)) }
+      end
+
+      def self.get_all_keyrings()
+        return [] unless Dir.exist? keys_dir
+        rings = []
+        Dir.glob(keys_dir + "/*.yml").each do |path|
+          rings << get_keyring_at_path(path)
+        end
+        rings
+      end
+
+      :private
+
+      def self.get_keyring_at_path(path)
+        Keyring.from_hash(YAML.load(File.read(path))) if File.exist?(path)
+      end
+
+    end
+end

data/lib/name_whisperer.rb

@@ -0,0 +1,44 @@
+require 'cocoapods'
+
+module CocoaPodsKeys
+    class NameWhisperer
+
+      def self.get_project_name()
+        podfile = Pod::Podfile.from_file("Podfile") rescue nil
+        if podfile
+          user_xcodeproj = xcodeproj_from_podfile(podfile)
+        end
+        user_xcodeproj ||= self.search_folders_for_xcodeproj
+        user_xcodeproj.gsub(".xcodeproj", "")
+      end
+
+    :private
+
+      def self.xcodeproj_from_podfile(podfile)
+        if podfile.target_definition_list.length > 0
+          return podfile.target_definition_list[0].user_project_path
+        end
+        nil
+      end
+
+      def self.search_folders_for_xcodeproj
+        xcodeprojects = Dir.glob("**/**/*.xcodeproj")
+        if xcodeprojects.length == 1
+          Pathname.new(xcodeprojects[0]).basename.to_s
+        else
+          error_message = (xcodeprojects.length > 1) ? "found too many" : "couldn't find any"
+          puts "Hello there, we " + error_message + " xcodeprojects. Please give a name for this project."
+
+          answer = ""
+          loop do
+            print " > "
+            answer = STDIN.gets.chomp
+            break if answer.length > 0
+          end
+          answer
+
+        end
+      end
+
+    end
+end

data/lib/plugin.rb

@@ -0,0 +1,8 @@
+module CocoaPodsKeys
+
+  Pod::HooksManager.register(:post_install) do |options|
+    require 'installer'
+
+    Installer.new(options.sandbox_root).install!
+  end
+end

data/lib/pod/command/keys.rb

@@ -0,0 +1,19 @@
+module Pod
+  class Command
+
+    class Keys < Command
+      require 'pod/command/keys/list'
+      require 'pod/command/keys/set'
+
+      self.summary = "A key value store for environment settings in Cocoa Apps."
+
+      self.description = <<-DESC
+        CocoaPods Keys will store sensitive data in your Mac's keychain. Then on running pod install they will be installed into your app's source code via the Pods library.
+      DESC
+
+      self.abstract_command = true
+      self.default_subcommand = 'list'
+
+    end
+  end
+end

data/lib/pod/command/keys/list.rb

@@ -0,0 +1,55 @@
+require 'keyring_liberator'
+
+module Pod
+  class Command
+    class Keys
+
+      class List < Keys
+        self.summary = "Lists all known keys and values."
+
+        self.description = <<-DESC
+          Shows all the current keys and values for your current working directory.
+
+          Also lists all known projects with variable stores.
+        DESC
+
+        def run
+            # List all settings for current app
+            this_keyring = CocoaPodsKeys::KeyringLiberator.get_keyring(Dir.getwd)
+            if this_keyring
+              display_current_keyring this_keyring
+            end
+
+            # List all known bundle ids
+
+            all_keyrings = CocoaPodsKeys::KeyringLiberator.get_all_keyrings()
+            all_keyrings.each do |keyring|
+              display_keyring(keyring) if keyring.path != this_keyring.path
+            end
+        end
+
+        def display_current_keyring(keyring)
+          puts "Keys for #{keyring.name}"
+          data = keyring.keychain_data
+          data.each_with_index do |(key, value), index|
+            prefix = (index == data.length - 1) ? " └ ": " ├ "
+            puts prefix + " #{key} - #{ value}"
+          end
+          puts ""
+        end
+
+        def display_keyring(keyring)
+          puts "#{keyring.name} - #{keyring.path}"
+          if keyring.keys.length == 1
+            puts " └ " + keyring.keys[0]
+          else
+            puts " └ " + keyring.keys[0...-1].join(" ") + " & " + keyring.keys[-1]
+          end
+          puts ""
+        end
+
+        
+      end
+    end
+  end
+end

data/lib/pod/command/keys/set.rb

@@ -0,0 +1,64 @@
+require "keyring_liberator"
+require "name_whisperer"
+
+module Pod
+  class Command
+    class Keys
+
+      class Set < Keys
+        self.summary = "A set values for keys."
+
+        self.description = <<-DESC
+            Save a environment key to be added to your project on the next pod install.
+
+            If a third argument is given then that will be used as the project name if
+            you need to skip the project naming process.
+        DESC
+
+        self.arguments = [CLAide::Argument.new('key', true),
+                          CLAide::Argument.new('value', true),
+                          CLAide::Argument.new('project_name', false)]
+
+        def initialize(argv)
+          @key_name = argv.shift_argument
+          @key_value = argv.shift_argument
+          @project_name = argv.shift_argument
+          super
+        end
+
+        def validate!
+          super
+          verify_podfile_exists!
+          help! "A key name is required to save." unless @key_name
+          help! "A value is required for the key." unless @key_value
+        end
+
+        def run
+          # set a key to a folder id in ~/.cocoapods/keys
+          # info "Saving into the keychain."
+
+          keyring = current_keyring
+          keyring.keys << @key_name
+          CocoaPodsKeys::KeyringLiberator.save_keyring keyring
+
+          keyring.save @key_name, @key_value
+
+          puts "Saved #{@key_name} to #{keyring.name}."
+        end
+
+        def current_keyring
+          current_dir = Dir.getwd
+          keyring = CocoaPodsKeys::KeyringLiberator.get_keyring current_dir
+
+          unless keyring
+            name = @name || CocoaPodsKeys::NameWhisperer.get_project_name
+            keyring = CocoaPodsKeys::Keyring.new(name, current_dir, [])
+          end
+
+          keyring
+        end
+
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-keys
+version: !ruby/object:Gem::Version
+  version: 0.5.2
+platform: ruby
+authors:
+- Orta Therox
+- Samuel E. Giddins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: osx_keychain
+  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.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+description: A key value store for environment settings in Cocoa Apps.
+email:
+- orta.therox@gmail.com
+- segiddins@segiddins.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- cocoapods_keys.gemspec
+- lib/cocoapods_keys.rb
+- lib/cocoapods_plugin.rb
+- lib/installer.rb
+- lib/key_master.rb
+- lib/keyring.rb
+- lib/keyring_liberator.rb
+- lib/name_whisperer.rb
+- lib/plugin.rb
+- lib/pod/command/keys.rb
+- lib/pod/command/keys/list.rb
+- lib/pod/command/keys/set.rb
+homepage: https://github.com/cocoapods/cocoapods-keys
+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.0.6
+signing_key: 
+specification_version: 4
+summary: CocoaPods Keys will store sensitive data in your Mac's keychain. Then on
+  running pod install they will be installed into your app's source code via the Pods
+  library.
+test_files: []
+has_rdoc: