leeloo 0.0.16 → 0.4.1

data/lib/leeloo/keystore.rb

@@ -1,40 +1,207 @@
-require 'fileutils'
 require 'gpgme'
+require 'fileutils'
 require 'git'
+require 'base64'
 
 module Leeloo
+
+  class KeystoreFactory
+    def self.create keystore
+        keystore_created = nil
+        case keystore["cypher"]
+        when "gpg"
+            keystore_created = GpgPrivateLocalFileSystemKeystore.new keystore["name"], keystore["path"] 
+        else
+            keystore_created = PrivateLocalFileSystemKeystore.new keystore["name"], keystore["path"]
+        end
+
+        case keystore["vc"]
+        when "git"
+            GitKeystoreDecorator.new keystore_created
+        else
+            keystore_created
+        end
+    end
+  end
+
   class Keystore
 
-    def self.secret_key_empty?
-      GPGME::Key.find(:secret, nil, ).empty?
+    attr_reader :name
+
+    def initialize name
+      @name = name
+    end
+
+    def secrets
+      # returns the secrets list
     end
 
-    def self.add_keystore name, path
-      FileUtils.mkdir_p path
-      FileUtils.mkdir_p "#{path}/secrets/"
-      FileUtils.mkdir_p "#{path}/keys/"
+    def secret_of path
+      # returns a secret object
+    end
+
+    def secret_from_name name
+      # returns a secret object
+    end
+
+    def sync
+      # synchronizes the keystore
+    end
+
+    def init
+      # initialize the keystore
+    end
+
+    def footprint name
+      # footprint a given secret path
+    end
 
-      GPGME::Key.find(:public, nil, ).each do |key|
-        key.export(:output => File.open("#{path}/keys/#{key.uids.first.email}", "w+"))
+    def secret_from_footprint footprint
+      # returns a secret object
+    end
+
+    def == keystore
+      self.name == keystore.name
+    end
+  end
+
+  class PrivateLocalFileSystemKeystore < Keystore
+
+    attr_reader :path
+
+    def initialize name, path
+      super name
+      @path = path
+      FileUtils.mkdir_p "#{@path}/secrets"
+    end
+
+    def secrets
+      find_secrets "#{@path}/secrets"
+    end
+
+    def find_secrets path
+      elements = []
+      Dir.glob("#{path}/**") do |element|
+        elements << secret_of(element) unless Dir.exist? element
+        elements << find_secrets(element) if Dir.exist? element
       end
+      return elements.flatten
+    end
+
+    def == keystore
+      self.name == keystore.name && self.path == keystore.path
+    end
 
-      g = Git.init path
-      g.add
-      g.commit "keystore #{path} added"
+    def secret_of path
+      name = path.gsub("#{@path}/secrets/", "")
+      LocalFileSystemSecret.new path, name
     end
 
-    def self.add_remote path, remote
-      g = Git.open path
-      g.add_remote 'origin', remote
+    def secret_from_name name
+      secret_of "#{path}/secrets/#{name}"
     end
 
-    def self.sync_keystore path
-      g = Git.open path
-      unless g.remotes.empty?
-        g.pull
-        g.push
+    def footprint_of name
+      secret = secret_from_name name
+      { "footprint" => secret.footprint, "keystore" => self.name, "secret" => secret.name }
+    end
+
+    def secret_from_footprint footprint
+      secret = secret_from_name footprint["secret"]
+      unless secret.footprint == footprint["footprint"]
+        raise "footprint is not valid"
       end
-      return !g.remotes.empty?
+      secret
+    end
+
+  end
+
+  class GpgPrivateLocalFileSystemKeystore < PrivateLocalFileSystemKeystore
+
+    def initialize name, path
+      super name, path
+      FileUtils.mkdir_p "#{@path}/keys"
+
+      @recipients = []
+      Dir.glob("#{path}/keys/*") { |key| @recipients << File.basename(key) }
+      @recipients.each { |key| GPGME::Key.import(File.open("#{path}/keys/#{key}")) }
+    end
+
+    def init
+      super
+      GPGME::Key.find(:public, nil, ).each { |key| key.export(:output => File.open("#{path}/keys/#{key.uids.first.email}", "w+")) }
+    end
+
+    def secret_of path
+      name = path.gsub("#{@path}/secrets/", "").gsub(".gpg", "")
+      GpgLocalFileSystemSecret.new path, name, @recipients
+    end
+
+    def secret_from_name name
+      secret_of "#{path}/secrets/#{name}.gpg"
+    end
+
+    def footprint_of name
+      footprint = super name
+      footprint["sign"] = Base64.strict_encode64 GPGME::Crypto.new.sign(footprint["footprint"]).to_s
+      footprint
+    end
+
+    def secret_from_footprint footprint
+      data = GPGME::Crypto.new.verify(Base64.strict_decode64 footprint["sign"]) { |signature| signature.valid? }
+      if data.read == footprint["footprint"]
+        super footprint
+      else
+        raise "signature is not valid"
+      end
+    end
+  end
+
+  class GitKeystoreDecorator < Keystore
+    def initialize keystore
+      @keystore = keystore
+      Git.init @keystore.path
+      @git = Git.open keystore.path
+    end
+
+    def secret_of element
+      GitSecretDecorator.new(@git, element)
+    end
+
+    def secret_from_name element
+      secret_of @keystore.secret_from_name(element)
+    end
+
+    def secrets
+      @keystore.secrets
+    end
+
+    def name
+      @keystore.name
+    end
+
+    def path
+      @keystore.path
+    end
+
+    def footprint_of element
+      @keystore.footprint_of element
+    end
+
+    def secret_from_footprint footprint
+      @keystore.secret_from_footprint footprint
+    end
+
+    def sync
+      @git.pull
+      @keystore.sync
+      @git.push
+    end
+
+    def init
+      @keystore.init
+      @git.add
+      @git.commit "keystore #{@keystore.name} added"
     end
 
   end

data/lib/leeloo/output.rb

@@ -0,0 +1,149 @@
+require 'clipboard'
+require 'tty-table'
+require 'tty-tree'
+require 'json'
+require 'base64'
+require 'socket'
+
+module Leeloo
+
+    class Output
+
+        def render_preferences preferences
+        end
+
+        def render_secrets secrets
+        end
+
+        def render_secret secret
+        end
+
+        def render_text text
+        end
+
+        def render_footprint footprint
+        end
+
+        def render_share footprint
+        end
+    end
+
+    class Ascii < Output
+
+        def render_preferences preferences
+            preferences.keystores.each { |keystore| puts keystore.name }
+        end
+
+        def render_secrets secrets
+            secrets.sort_by(&:name).each {|secret| puts secret.name}
+        end
+
+        def render_secret secret
+            begin
+                puts secret.read
+            rescue => exception
+                puts "#{secret.name} doesn't exist"
+            end
+        end
+
+        def render_text text
+            puts text
+        end
+
+        def render_footprint footprint
+            puts "token:"
+            puts Base64.strict_encode64 footprint.to_json
+        end
+    end
+
+    class Terminal < Ascii
+
+        def render_preferences preferences
+            rows = []
+            default_keystore = preferences.default
+            preferences.keystores.each do |keystore|
+                is_default = '*' if keystore.name == default_keystore
+                rows << [keystore.name, keystore.path, is_default ]
+              end
+              puts TTY::Table.new(header: ['Name', 'Path', 'Default'], rows: rows).render(:ascii)
+        end
+
+        def render_secrets secrets
+            hash = {:secrets => []}
+            secrets.sort_by(&:name).each { |secret| sort(hash[:secrets], secret.name) }
+            puts TTY::Tree.new(hash).render
+        end
+
+        def sort array, element
+            if element
+                e = element.split("/", 2)
+                if e.length > 1
+                    found = false
+                    array.each do |a|
+                        if a.is_a? Hash
+                            if a[e.first]
+                                found = true
+                                sort(a[e.first], e.last)
+                                break
+                            end
+                        end
+                    end
+
+                    unless found
+                        array << { e.first => sort([], e.last) }
+                    end
+                else
+                    array << e.last
+                end
+            end
+            array
+        end
+    end
+
+    class ClipboardOutputDecorator < Output
+
+        def initialize output
+            @output = output
+        end
+
+        def render_preferences preferences
+            @output.render_preferences preferences
+        end
+
+        def render_secrets secrets
+            @output.render_secrets secrets
+        end
+
+        def render_text text
+            @output.render_text text
+        end
+
+        def render_secret secret
+
+            Signal.trap("INT") do
+                Clipboard.clear
+                abort "cleared"
+            end
+
+            Clipboard.copy secret.read
+            wait = Thread.new do
+               puts "cleaning in 30s"
+               30.times {
+                   print "."
+                   sleep 1
+               }
+            end
+            wait.join
+            Clipboard.clear
+        end
+
+        def render_footprint footprint
+            @output.render_footprint footprint
+        end
+
+        def render_share footprint
+            @output.render_share footprint
+        end
+    end
+
+end

data/lib/leeloo/preferences.rb

@@ -0,0 +1,100 @@
+require 'yaml'
+
+module Leeloo
+    class Preferences
+
+        attr_reader :default
+
+        def initialize
+            @keystores = []
+            @default = nil
+        end
+
+        def load
+            # this method loads all preferences
+            self
+        end
+
+        def set_default_keystore name
+            @default = name
+        end
+
+        def keystore name=nil
+            keystores.find { |k| k.name == (name||@default) }
+        end
+
+        def keystores
+            @keystores.map { |k| KeystoreFactory::create k }
+        end
+
+        def add_keystore keystore
+            unless @keystores.include? keystore
+                @keystores << keystore
+            end
+        end
+
+        def remove_keystore name
+            abort "you can not remove default keystore" if name == @default
+            keystore = @keystores.find { |k| k["name"] == name }
+            if keystore != nil
+                @keystores.delete keystore
+            end
+        end
+    end
+
+    class PrivateLocalFileSystemPreferences < Preferences
+
+        DEFAULT_PATH = "#{Dir.home}/.leeloo"
+        
+        def load(path=DEFAULT_PATH)
+            @path = path
+
+            if File.exist? "#{path}/keystores"
+                @keystores = YAML.load_file "#{path}/keystores"
+            end
+
+            if File.exist? "#{path}/config"
+                config = YAML.load_file "#{path}/config"
+                set_default_keystore config["keystore"]
+            else
+                default_keystore = {
+                    'name'      => "private",
+                    'path'      => "#{path}/private",
+                    'cypher'    => "gpg",
+                    'vc'        => "git"
+                }
+                add_keystore default_keystore
+                set_default_keystore "private"
+                keystore_of("private").init
+            end
+
+            self
+        end
+
+        def keystore_of name
+            keystore = @keystores.find { |keystore| keystore["name"] == name }
+            KeystoreFactory::create keystore
+        end
+
+        def set_default_keystore name
+            super name
+            config = {
+                "keystore" => name
+            }
+            File.write("#{@path}/config", config.to_yaml)
+        end
+
+        def add_keystore keystore
+            super keystore
+            FileUtils.mkdir_p keystore["path"]
+            File.write("#{@path}/keystores", @keystores.to_yaml)
+        end
+
+        def remove_keystore name
+            super name
+            File.write("#{@path}/keystores", @keystores.to_yaml)
+        end
+
+    end
+
+end