auth_keys_chain 0.0.1

data/README.md

@@ -0,0 +1,64 @@
+# AuthKeys
+
+Saving and Editing passwords more easily.
+Using ~/.auth_keys file , this is space seperated file.
+
+## Usage
+
+AuthKeys uses CSV/TSV passwod list.
+File format is TSV(space sperated) for easy to edit.
+
+## example of ~/.auth_keys
+    softbank    080xxxxxxxxx              12345678
+    mobilepoint example@i.softbank.jp     passs
+    starbucks   example@gmail.com         passssss
+    au          example@au                passssss
+    wi2         example@au                passssss
+    7spot       example@gmail.com         passssss
+
+## Example 
+    #/usr/bin/env ruby 
+    require 'auth_keys'
+    AuthKeys["site_name"]
+
+~/.auth_keys to store id/pass pair.
+
+| key(site_name) | login_id | password |
+|----------------|----------|----------|
+|mixi| username@example.com | my_pass  |
+
+# execute from CLI  (bin/auth_keys)
+
+Space sperateted is very easy for editing and reading, but not enough secure.
+So auth_keys comannd is available, for easy to encrypt and to decrypt ~/.auth_keys from CLI.
+
+    $ auth_keys -e  #encrypt ~/.auth_keys  after edit
+    $ auth_keys -d  #decrypt ~/.auth_keys  before edit
+    $ auth_keys -l  #list key names  ~/.auth_keys 
+    $ auth_keys -k key  #retrieve id/pass pair from  ~/.auth_keys 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'auth_keys_chain'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install auth_keys_chain
+
+## Contributing
+
+1. Fork it ( https://github.com/takuya/auth_keys/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,2 @@
+require "bundler/gem_tasks"
+

data/auth_keys_chain.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'auth_keys/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "auth_keys_chain"
+  spec.version       = AuthKey::VERSION
+  spec.authors       = ["takuya"]
+  spec.email         = ["takuy.a.1st+nospam@gmail.com"]
+  spec.summary       = %q{Passwords saves/load in ~/.auth_keys }
+  spec.description   = %q{Passwords save/load in ~/.auth_keys(plain text table) } 
+  spec.homepage      = "https://github.com/takuya/auth_key"
+  spec.license       = "GPLv3"
+
+  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_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/bin/auth_keys

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby 
+
+def load_path
+  path = File.expand_path( "../lib", File.dirname(File.realpath(__FILE__))  )
+  $:.unshift path
+end
+load_path;
+
+require 'pp'
+require 'auth_keys'
+require 'optparse'
+require 'json'
+
+opt = []
+keys = []
+ARGV << "-h" unless ARGV.size > 0
+op = OptionParser.new
+op.on("-e","--encrypt", "#{AuthKeys::KEY_PATH}を暗号化"){ opt <<  "encrypt"}
+op.on("-d","--decrypt", "#{AuthKeys::KEY_PATH}を平文化"){ opt <<  "decrypt" }
+op.on("-k [key]","--key", "#{AuthKeys::KEY_PATH}に含まれる識別子から検索"){|key| if key then opt << "key" ;keys << key else  opt<<"list" end }
+op.on("-l", "--list",   "#{AuthKeys::KEY_PATH}に含まれる識別子を一覧"){ opt << "list" }
+
+op.parse!(ARGV)
+
+
+
+
+case opt
+when ["encrypt"] then AuthKeys.encrypt 
+when ["decrypt"] then AuthKeys.decrypt
+when ["list"]    then puts AuthKeys.keys
+when ["key"]     then keys.each{|e| o={};o[e]=AuthKeys[e]; puts JSON.dump(o) }
+end

data/lib/auth_keys/version.rb

@@ -0,0 +1,3 @@
+module AuthKey
+  VERSION = "0.0.1"
+end

data/lib/auth_keys.rb

@@ -0,0 +1,90 @@
+
+require 'openssl'
+class AuthKeys
+    KEY_PATH = "~/.auth_keys"
+    MASTER_KEY = "~/.ssh/id_rsa"
+    class << self
+        def encrypt_data(data,pass)
+            cipher = OpenSSL::Cipher::Cipher.new("AES-256-CBC")
+            salt = OpenSSL::Random.random_bytes(8)
+            cipher.encrypt
+            cipher.pkcs5_keyivgen(pass, salt)
+            data = cipher.update(data) + cipher.final
+            ## salted
+            data = "Salted__" + salt + data
+        end
+        def encrypt()
+            data = self.read
+            return  if is_encrypted?(data)
+            data = encrypt_data(data, self.master_key)
+            save(data)
+        end
+        def master_key
+            path = File.expand_path(MASTER_KEY)
+            raise unless File.exists?(path)
+            open(path).read
+        end
+        def decrypt_data(data,pass)
+            data = data.force_encoding("ASCII-8BIT")
+            salt = data[8,8]
+            data = data[16, data.size]
+            cipher = OpenSSL::Cipher::Cipher.new("AES-256-CBC")
+            cipher.decrypt
+            cipher.pkcs5_keyivgen(pass, salt)
+            cipher.update(data) + cipher.final
+        end
+
+        def decrypt()
+            data = self.read
+            data = data.force_encoding("ASCII-8BIT")
+            return unless is_encrypted?(data)
+            data = self.decrypt_data(data,self.master_key)
+            self.save(data)
+        end
+        def is_encrypted?(str)
+            /Salted__/ === str[0,8] 
+        end
+        def save(content)
+            path = File.expand_path(KEY_PATH)
+            raise "#{path} not found." unless File.exists?(path)
+            open(path, "w"){|f| 
+                f.write content
+            }
+        end
+
+        def load()
+            content = self.read
+            content = self.decrypt_data(content,self.master_key) if is_encrypted?(content)
+            array = content 
+                        .split("\n")
+                        .reject{|e| e.strip =~/^#/}
+                        .map(&:split).map{|e| [e[0],[   e[1],e[2]  ] ] }
+            password_table = Hash[array]
+        end
+        def read()
+            path = File.expand_path(KEY_PATH)
+            raise unless File.exists?(path)
+            content = open(path).read
+        end
+        def get(key)
+            hash = self.load
+            hash.key?(key) ? hash[key] : nil ; 
+        end
+        def [](key)
+            self.get(key)
+        end
+        def keys
+            self.load.keys
+        end
+    end
+end
+
+
+if $0 == __FILE__ then
+    require 'pp'
+    pp AuthKeys.load
+    pp AuthKeys.keys
+    pp AuthKeys["softbank"]
+    pp AuthKeys.encrypt
+end
+

data/vendor/bundle/gems/auth_keys-0.0.1/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/vendor/bundle/gems/auth_keys-0.0.1/Gemfile

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