ruby-secret_service 0.0.5

data/.gitignore

@@ -0,0 +1,11 @@
+.bundle
+.DS_Store
+vendor/bundle
+default.pem
+*.swo
+resources_dump.json
+hosts.txt
+out
+coverage
+todo
+*.gem

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+gem "woof_util"
+gem "ruby-dbus"
+gem "rake"
+gem "bundler"

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    ruby-secret_service (0.0.5)
+      ruby-dbus
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    excon (0.16.10)
+    highline (1.6.19)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    ruby-dbus (0.9.2)
+    woof_util (0.0.16)
+      excon (~> 0.16.10)
+      highline (~> 1.6.15)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  rake
+  rspec
+  ruby-dbus
+  ruby-secret_service!
+  woof_util

data/README.md

@@ -0,0 +1,46 @@
+Ruby Secret Service
+===================
+
+Native Ruby bindings for [freedesktop.org's Secret Service](http://standards.freedesktop.org/secret-service/).  Uses [ruby-dbus](https://github.com/mvidner/ruby-dbus).
+
+##Usage
+```
+require "secret_service"
+
+ss = SecretService.new
+
+# create a secret in the default collection
+name = "my github password"
+secret = "s00p3r-s33|<r1+"
+
+ss.collection.create_item(name, secret)
+
+# and read it back
+round_trip_secret = ss.collection.get_secret(name)
+round_trip_secret == secret || raise "secret reading failed"
+
+# create new collections!
+other_coll_name = "other keyring"
+other_name = "my heroku password"
+other_secret = "1m s00 l33t"
+ss.create_collection(other_coll_name)
+
+ss.collection(other_coll_name).create_item(other_name, other_secret)
+round_trip_other = ss.collection(other_coll_name).get_secret(other_name)
+round_trip_other == other_secret || raise "can't read alt collection secret"
+```
+
+## Caveats
+
+   * Both KWallet and GNOME Keyring _REQUIRE_ the use of X11 to prompt
+   the user to decrypt ("unlock") the keychain.  While you can use
+   this in a terminal-only environment (e.g., ssh'd in from a
+   desktop/laptop without X11), you're going to get errors about
+   having to unlock collections, but there is literally no way in the
+   spec to pass the decryption password over DBus.
+   * This is written chiefly to provide a programmatic access to
+   Secret Service for one specific program - Heroku Toolbelt.  While
+   there's some basic support for multiple collections and
+   locking/unlocking, if you're doing anything moderately complex,
+   you're potentially better off [doing this in Python](https://bitbucket.org/kang/python-keyring-lib/overview)
+

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/setup"
+require "rspec/core/rake_task"
+require "woof_util/gem_rake_tasks"
+
+RSpec::Core::RakeTask.new "spec"
+WoofUtil::GemRakeTasks.create_tasks
+

data/VERSION

@@ -0,0 +1 @@
+0.0.5

data/bin/secretservice.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'secret_service'
+require 'optparse'
+
+options = {}
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} -s|-g NAME"
+  opts.on("-g", "--get NAME",
+          "Reads existing secret called NAME, prints secret to stdout") do |key|
+    options[:name] = key
+    options[:mode] = :get
+  end
+  opts.on("-s", "--set NAME",
+          "Creates new secret called NAME, reads secret from stdin") do |key|
+    options[:name] = key
+    options[:mode] = :set
+  end
+end
+opts.parse!
+
+ss = SecretService.new
+
+case options[:mode]
+when :set
+  new_secret = STDIN.read
+  typeinfo = nil
+  attrs = ["a{ss}", {"name" => options[:name].to_s }]
+
+  properties =
+    {"org.freedesktop.Secret.Item.Label" => options[:name],
+    "org.freedesktop.Secret.Item.Attributes" => attrs
+  }
+  item = ss.collection.create_item properties, new_secret
+when :get
+  item = ss.collection.unlocked_items({"name" => options[:name]})[0]
+  puts item.get_secret
+else
+  puts opts.help
+  exit 1
+end
+
+exit 0
+name = ARGV[0]
+
+item = ss.collection.unlocked_items({"name" => name})[0]
+puts "label: #{item.label}"
+puts "last modified #{item.modified}, locked: #{item.locked?}"
+puts "attributes: #{item.attributes.to_s}"
+
+# item.attributes = ["name", "test2"]
+#  {"magic" => "secret_service.rb", "name" => "test"}
+  
+
+#item = SecretService::Item.new(ss.bus, secret_path)
+
+#puts item.your_mom
+
+#puts ss.init_session[1]
+
+#item = SecretService::Item.new(session, secret_path)
+#
+#puts item.item["Modified"].class
+

data/lib/secret_service/collection.rb

@@ -0,0 +1,89 @@
+class SecretService
+class Collection
+  attr_accessor :service, :name, :path
+  
+  def initialize(service, name = DEFAULT_COLLECTION, path=nil)
+    @service = service
+    @name = name
+    @path = path || "#{COLLECTION_PREFIX}#{name}"
+    @proxy = @service.get_proxy(@path, IFACE[:collection])
+  end
+
+  def lock!
+    locked_objs, prompt_path = @service.proxy.Lock [@path]
+    return true if prompt_path == "/" and locked_objs.include?(@path)
+
+    # need to do the prompt dance
+    @service.prompt!(prompt_path)
+    locked?
+  end
+  
+  def unlock!
+    unlocked_objs, prompt_path = @service.proxy.Unlock [@path]
+    return true if prompt_path == "/" and unlocked_objs.include?(@path)
+
+    #nuts, stupid prompt
+    @service.prompt!(prompt_path)
+    ! locked?
+  end
+
+  def locked?
+    get_property(:locked)
+  end
+
+  def set_property name, new_val
+    @proxy.Set(IFACE[:item], name.to_s.downcase.capitalize, new_val)
+  end
+
+  def get_property name
+    @proxy.Get(IFACE[:collection], name.to_s.downcase.capitalize)[0]
+  end
+  
+  def session
+    @service.session
+  end
+
+  def unlocked_items(search_pred = {})
+    @proxy.SearchItems(search_pred)[0].map {|path| Item.new self, path }
+  end
+
+  def locked_items(search_pref = {})
+    @proxy.SearchItems(search_pred)[1].map {|path| Item.new self, path }
+  end
+
+  def create_item name, secret, properties=nil, replace=true
+    if properties.nil? 
+      # ruby-dbus's type inference system doesn't handle recursion for
+      # vaguely complicated structs, yet the protocol requires
+      # explicit type annotation.  Consequently, nontrivial structs
+      # require the user to provide their own annotation
+      attrs = ["a{ss}", {"name" => name.to_s }]
+
+      properties =
+        {"#{SS_PREFIX}Item.Label" => name.to_s,
+        "#{SS_PREFIX}Item.Attributes" => attrs
+      }
+    end
+    result = @proxy.CreateItem(properties, secret_encode(secret), replace)
+    new_item_path = result[0]
+    Item.new(self, new_item_path)
+  end
+
+  def get_secret name
+    (unlocked_items({"name" => name})[0]).get_secret
+  end
+  
+  def secret_encode secret_string
+    mime_type = "application/octet-stream"
+
+    if(secret_string.respond_to? "encoding" and
+       secret_string.encoding.to_s != "ASCII-8BIT")
+      secret_string.encode! "UTF-8"
+      #mime_type = "text/plain; charset=utf8"
+    end
+
+    [session[1], [], secret_string.bytes.to_a, mime_type]
+  end
+  
+end
+end

data/lib/secret_service/item.rb

@@ -0,0 +1,87 @@
+class SecretService
+class Item
+
+  attr_accessor :path
+  
+  def initialize(collection, path)
+    @collection = collection
+    @path = path
+    @proxy = collection.service.get_proxy @path, IFACE[:item]
+  end
+
+  def modified
+    Time.at get_property(:modified)
+  end
+
+  def created
+    Time.at get_property(:created)
+  end
+
+  def locked?
+    get_property(:locked)
+  end
+
+  def lock!
+    locked, prompt_path = @collection.service.proxy.Lock [@path]
+    return true if prompt_path == "/" and locked.include? @path
+
+    # otherwise we have to handle the prompt
+    @collection.service.prompt!(prompt_path)
+    get_property(:locked)
+  end
+  
+  def label
+    get_property(:label)
+  end
+
+  def label= new_label
+    set_property(:label, new_label)
+  end
+
+  def attributes
+    get_property(:attributes)
+  end
+
+  # TODO: this keeps throwing type errors
+  def attributes= new_attrs
+    set_property(:attributes, new_attrs)
+  end
+
+  def set_property name, new_val
+    @proxy.Set(IFACE[:item], name.to_s.downcase.capitalize, new_val)
+  end
+  
+  def get_property name
+    @proxy.Get(IFACE[:item], name.to_s.downcase.capitalize)[0]
+  end
+  
+  def session
+    @collection.session
+  end
+  
+  def get_secret
+    secret_decode(@proxy.GetSecret(session[1]))
+  end
+
+  # http://standards.freedesktop.org/secret-service/ch14.html#type-Secret
+  def secret_decode secret_arr
+    secret_struct = secret_arr[0]
+    s = {}
+    [:session, :params, :bytes, :mime].each do |x|
+      s[x] = secret_struct.shift
+    end
+
+    secret_string = (s[:bytes].map {|x| x.chr}).join
+    if(secret_string.respond_to? "encoding" and
+       s[:mime] != "application/octet-stream")
+      charset = s[:mime].match(/charset=(.+)/)[1]
+      unless charset.nil?
+        charset.upcase!.sub! /\AUTF([\w\d])/, "UTF-#{$1}"
+        secret_string.force_encoding charset
+      end
+    end
+    secret_string
+  end
+
+end
+end

data/lib/secret_service/prompt.rb

@@ -0,0 +1,30 @@
+class SecretService
+class Prompt
+
+  attr_accessor :path
+
+  class NoPromptRequired < Exception ; end
+  
+  def initialize service, object_path
+    raise NoPromptRequired if object_path == "/"
+    @service = service
+    @path = object_path
+    @proxy = service.get_proxy object_path, SecretService::IFACE[:prompt]
+  end
+
+  def prompt!
+    loop = DBus::Main.new
+    loop << @service.bus
+    @proxy.on_signal("Completed") do |dismissed, result|
+      loop.quit
+    end
+    @proxy.Prompt ""
+    loop.run
+  end
+
+  def dismiss
+    @proxy.Dismiss
+  end
+  
+end
+end

data/lib/secret_service/secret.rb

@@ -0,0 +1,86 @@
+# http://standards.freedesktop.org/secret-service/ch14.html#id481899
+# Creating a "secret"
+
+class SecretService
+class Secret
+
+  attr_accessor :session_path, :parameters, :content_type
+
+  def initialize attrs
+    @session_path = attrs[:session_path]
+    @parameters = attrs[:parameters] || []
+    @value = attrs[:value]
+    @content_type = attrs[:content_type] || sniff_content_type(@value)
+  end
+
+  def value
+    @value
+  end
+
+  def value= val
+    @value = val
+    @content_type = sniff_content_type attrs[:value]
+  end
+
+  # Create a new SecretService::Secret from the DBus Struct format
+  def self.from_struct s
+    initialize(:session_path => s[0][0],
+               :parameters => s[0][1],
+               :value => (s[0][2].map {|x| x.chr}).join,
+               :content_type => (s[0][3] == "") ? nil : s[0][3]
+               )
+  end
+
+  # Convert the human-readable version into the format expected
+  # by DBus.
+  def to_struct
+    [ "(oayays)",
+      [@session_path, @parameters, @value.bytes.to_a, @content_type]
+    ]
+  end
+
+  
+  # Take a string, guess what the Content-type should be.
+  # For Ruby < 1.9, assume binary encoding.  You can avoid this
+  # by passing in an explicit content_type to the initializer.
+  #
+  # Or, y'know, using a more recent version of the language.
+  def sniff_content_type str
+    if (str.nil? or
+        (not str.respond_to? :encoding ) or
+        (str.encoding.to_s == "ASCII-8BIT"))
+      "application/octet-stream"
+    else
+      "text/plain; charset=#{str.encoding}"
+    end
+  end
+
+  # Derive the Ruby String encoding from a given Content-type.
+  # When all else fails, assumes ASCII-8BIT (aka Binary)
+  def self.content_type_to_encoding content_type=nil
+    binary = "ASCII-8BIT"
+    
+    begin
+      case charset = content_type.match(/; charset=(.+)\z/)[1].upcase
+      when /\AUTF[^-]/
+        # "UTF8" is a common misspelling of "UTF-8".
+        charset.sub! /\AUTF/, "UTF-"
+      when /./
+        # Accept charset.upcase at face value & hope for the best
+        charset
+      else
+        # This is a technical violation of RFC 2616, sec. 3.7.1, which
+        # states ISO-8859-1 is the default for "text/*" when no
+        # charset is specified. However, I claim UTF-8 is a safer
+        # assumption on the modern Internet.
+        charset = content_type.match(/\Atext\//) ? "UTF-8" : binary
+      end
+      "".encode charset
+      charset
+    rescue
+      binary
+    end
+  end
+  
+end
+end

data/lib/secret_service.rb

@@ -0,0 +1,96 @@
+require 'dbus'
+
+require 'secret_service/collection'
+require 'secret_service/item'
+require 'secret_service/secret'
+require 'secret_service/prompt'
+
+class SecretService
+  SECRETS = 'org.freedesktop.secrets'
+  SS_PREFIX = 'org.freedesktop.Secret.'
+  SS_PATH = '/org/freedesktop/secrets'
+  COLLECTION_PREFIX =  '/org/freedesktop/secrets/aliases/'
+  DEFAULT_COLLECTION = "default"
+
+  ALGO = "plain"
+  
+  DBUS_UNKNOWN_METHOD  = 'org.freedesktop.DBus.Error.UnknownMethod'
+  DBUS_SERVICE_UNKNOWN = 'org.freedesktop.DBus.Error.ServiceUnknown'
+  DBUS_EXEC_FAILED     = 'org.freedesktop.DBus.Error.Spawn.ExecFailed'
+  DBUS_NO_REPLY        = 'org.freedesktop.DBus.Error.NoReply'
+  DBUS_NO_SUCH_OBJECT  = 'org.freedesktop.Secret.Error.NoSuchObject'
+
+  IFACE = {}
+  [:service, :item, :collection, :prompt].each do |x|
+    IFACE[x] = "#{SS_PREFIX}#{x.to_s.capitalize}"
+  end
+    
+  attr_accessor :bus, :proxy
+
+  class NoSessionBus < Exception
+  end
+  
+  def initialize
+    begin
+      @bus = DBus::SessionBus.instance
+
+      @proxy_maker = @bus.service SECRETS
+      @proxy = get_proxy SS_PATH, IFACE[:service]
+      @collections = {}
+
+      @collection_paths = self.list_collections
+    rescue
+      raise NoSessionBus
+    end
+  end
+
+  def get_proxy path, iface=nil
+    obj = @proxy_maker.object path
+    obj.introspect
+    obj.default_iface = iface unless iface.nil?
+    obj
+  end
+  
+  def session
+    @session ||= @proxy.OpenSession(ALGO, "")
+  end
+  
+  def collection(name=DEFAULT_COLLECTION, path=nil)
+    @collections[name.to_s] ||= Collection.new(self, name, path)
+  end
+
+  def list_collections
+    @proxy.Get(IFACE[:service], 'Collections')
+  end
+
+  def create_collection name, properties=nil
+    properties ||= {"#{SS_PREFIX}Collection.Label" => name}
+
+    coll, prompt_path = @proxy.CreateCollection properties, ""
+    prompt!(prompt_path) if prompt_path != "/"
+    collection(name, coll)
+  end
+
+  
+  def set_alias name, collection
+    @proxy.SetAlias name, (collection.class == String ? collection : collection.path)
+  end
+
+  def read_alias name
+    path = @proxy.ReadAlias name
+    collection(name, path)
+  end
+  
+  def search_items attrs={}
+    @proxy.SearchItems(attrs)
+  end
+
+  def unlock objects
+    @proxy.Unlock objects
+  end
+
+  def prompt!(prompt_path)
+    SecretService::Prompt.new(self, prompt_path).prompt!
+  end
+  
+end

data/ruby-secret_service.gemspec

@@ -0,0 +1,19 @@
+require 'find'
+
+Gem::Specification.new do |s|
+  s.name = 'ruby-secret_service'
+  s.version = File.read("VERSION").chomp
+  s.summary = 'Ruby bindings for GNOME Keyring & KWallet'
+  s.description = "Native bindings use the D-BUS Secret Service API, docs at http://standards.freedesktop.org/secret-service/"
+  s.authors = ["Tom Maher"]
+  s.email = "tmaher@pw0n.me"
+  s.license = "Apache 2.0"
+  s.files = `git ls-files`.split("\n")
+  s.require_path = ["lib"]
+  s.homepage = "https://github.com/tmaher/ruby-secret_service"
+  s.add_development_dependency "woof_util"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+
+  s.add_dependency "ruby-dbus"
+end

data/spec/rss_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe SecretService do
+
+  #it "aborts when it can't find dbus" do
+    #state = hide_dbus_configs
+    #SecretService.new
+    #expect {SecretService.new}.to raise_error
+    #restore_dbus_configs state
+  #end
+  
+  it "can create a session" do
+    SecretService.new.class.should_not be nil
+  end
+
+  it "has a default collection" do
+    SecretService.new.collection.should_not be nil
+  end
+
+  it "can lock and unlock collections" do
+    ss = SecretService.new
+    ss.collection.lock!.should eq true
+    ss.collection.locked?.should eq true
+    ss.collection.unlock!.should eq true
+    ss.collection.locked?.should eq false
+  end
+  
+  it "can create and read back objects" do
+    name = SecureRandom.hex(8).to_s
+    secret = SecureRandom.hex(8).to_s
+    ss = SecretService.new
+    ss.collection.unlock!
+    ss.collection.create_item("rspec_test_#{name}", secret).should_not be nil
+    ss.collection.get_secret("rspec_test_#{name}").should eq secret
+  end
+
+  it "can create a new collection" do
+    ss = SecretService.new
+    coll_label = "rspec_test_collection_#{SecureRandom.hex(4)}"
+    new_coll = ss.create_collection coll_label
+    new_coll.should_not be nil
+    new_coll.name.should eq coll_label
+  end
+  
+  it "can create and lock objects" do
+    name = SecureRandom.hex(8).to_s
+    secret = SecureRandom.hex(8).to_s
+    ss = SecretService.new
+    item = ss.collection.create_item("rspec_test_#{name}", secret)
+    item.lock!
+    item.locked?.should eq true
+  end
+
+  it "can find objects" do
+    ss = SecretService.new
+    unlocked, locked = ss.search_items
+    unlocked.kind_of?(Array).should eq true
+    locked.kind_of?(Array).should eq true
+    (locked + unlocked).each do |item|
+      item.match(/^\/org\/freedesktop\/secrets\/collection/).nil?.should eq false
+    end
+  end
+
+  it "can unlock objects" do
+    ss = SecretService.new
+    item_paths, prompt = ss.unlock(ss.search_items[1])
+  end
+
+  it "aborts on invalid prompt creation" do
+    ss = SecretService.new
+    expect {ss.prompt! "/"}.to raise_error SecretService::Prompt::NoPromptRequired
+  end
+
+  #it "can raise a prompt" do
+    #ss = SecretService.new
+    #item_paths, prompt = ss.unlock(ss.search_items[1])
+    #ss.prompt!(prompt)
+    #new_items, new_prompt = ss.unlock(ss.search_items[1])
+    #new_prompt.should be_nil
+    #puts "new_items: #{new_items}"
+  #end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'securerandom'
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'secret_service'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.order = 'random'
+  config.seed = SecureRandom.random_number(2 ** 24)
+  
+  # Use color not only in STDOUT but also in pagers and files
+  config.tty = true
+
+  # Use the specified formatter
+  #config.formatter = :documentation # :progress, :html, :textmate
+end
+
+def hide_dbus_configs
+  state = {:addr => ENV["DBUS_SESSION_BUS_ADDRESS"],
+    :display => ENV["DISPLAY"],
+    :dir => File.join(ENV["HOME"], ".dbus-#{SecureRandom.hex(4)}")
+  }
+  ENV.delete "DBUS_SESSION_BUS_ADDRESS"
+  ENV.delete "DISPLAY"
+  begin
+    File.rename File.join(ENV["HOME"], ".dbus"), state[:dir]
+  rescue; end
+  state
+end
+
+def restore_dbus_configs state
+  ENV["DBUS_SESSION_BUS_ADDRESS"] = state[:addr]
+  ENV["DISPLAY"] = state[:display]
+  begin
+    File.rename state[:dir], File.join(ENV["HOME"], ".dbus")
+  rescue; end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: ruby-secret_service
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
+platform: ruby
+authors:
+- Tom Maher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: woof_util
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-dbus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Native bindings use the D-BUS Secret Service API, docs at http://standards.freedesktop.org/secret-service/
+email: tmaher@pw0n.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- VERSION
+- bin/secretservice.rb
+- lib/secret_service.rb
+- lib/secret_service/collection.rb
+- lib/secret_service/item.rb
+- lib/secret_service/prompt.rb
+- lib/secret_service/secret.rb
+- ruby-secret_service.gemspec
+- spec/rss_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tmaher/ruby-secret_service
+licenses:
+- Apache 2.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- - lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Ruby bindings for GNOME Keyring & KWallet
+test_files: []