dotgpg 0.3

data/lib/dotgpg/key.rb

@@ -0,0 +1,105 @@
+class Dotgpg
+  class Key
+
+    def self.read(file)
+      GPGME::Key.import(file).imports.map do |import|
+        GPGME::Key.find(:public, import.fingerprint)
+      end.flatten.first
+    end
+
+    def self.secret_key(email=nil, force_new=nil)
+      new.secret_key(email, force_new)
+    end
+
+    def secret_key(email=nil, force_new=nil)
+      existing = existing_key(email)
+      if existing && !force_new
+        existing
+      else
+        create_new_key email
+      end
+    end
+
+    private
+
+    def existing_key(email=nil)
+      existing_private_keys.detect do |k|
+        email.nil? || k.email == email
+      end
+    end
+
+    def create_new_key(email=nil)
+      name = guess_name
+      email ||= guess_email
+
+      if email
+        puts "Creating a new GPG key: #{name} <#{email}>"
+        passphrase = get_passphrase
+      else
+        puts "Creating a new GPG key for #{name}"
+        email = get_email
+        passphrase = get_passphrase
+      end
+
+      puts "Generating large prime numbers, please wait..."
+      ctx = GPGME::Ctx.new
+      ctx.genkey(<<EOF, nil, nil)
+<GnupgKeyParms format="internal">
+Key-Type: RSA
+Key-Length: 2048
+Subkey-Type: RSA
+Subkey-Length: 2048
+Name-Real: #{name}
+Name-Comment: dotgpg
+Name-Email: #{email}
+Expire-Date: 0
+Passphrase: #{passphrase}
+</GnupgKeyParms>
+EOF
+
+      # return the most recently created key (race!)
+      GPGME::Key.find(:secret).sort_by{ |key|
+        key.primary_subkey.timestamp
+      }.last
+    end
+
+    def guess_name
+      name = `git config user.name 2>/dev/null`.strip
+      name = `whoami`.strip if name == ""
+      name
+    end
+
+    def guess_email
+      email = `git config user.email 2>/dev/null`.strip
+      email if email != ""
+    end
+
+    def get_email
+      email = ""
+      until email =~ /@/
+        email = Dotgpg.read_input "Email address: "
+      end
+      email
+    end
+
+    def get_passphrase
+      passphrase = confirmation = nil
+      until passphrase && passphrase == confirmation
+        times = 0
+        until passphrase && passphrase.length >= 10
+          times += 1
+          $stderr.puts "Passphrases should be secure! (>=10 chars)" if times >= 2
+          passphrase = Dotgpg.read_passphrase("Passphrase: ")
+        end
+        until confirmation && confirmation.length >= 10
+          confirmation = Dotgpg.read_passphrase("Passphrase confirmation: ")
+        end
+      end
+      passphrase
+    end
+
+    def existing_private_keys
+      GPGME::Key.find(:secret)
+    end
+  end
+end

data/lib/dotgpg/template/README.md

@@ -0,0 +1,20 @@
+This directory contains GPG-encrypted files managed by `dotgpg`.
+
+Getting started
+---------------
+
+To read files in this directory, send the output of running `dotgpg key` to someone
+who has access already. They will be able to run `dotgpg add` on your behalf.
+
+Usage
+-----
+
+You can edit any file with `dotgpg edit FILE`, and read any file with `dotgpg cat FILE`.
+
+The edit command looks at the value of `$EDITOR`, the internet will have a tutorial on
+how to set this up with your favourite editor.
+
+Details
+-------
+
+For more information, please see `dotgpg --help`, or the [README](https://github.com/ConradIrwin/dotgpg).

data/lib/dotgpg.rb

@@ -0,0 +1,96 @@
+require 'pathname'
+require 'fileutils'
+require 'tempfile'
+require 'shellwords'
+
+require 'gpgme'
+require 'thor'
+
+require "dotgpg/key.rb"
+require "dotgpg/dir.rb"
+require "dotgpg/cli.rb"
+
+class Dotgpg
+
+  class Failure < RuntimeError; end
+  class InvalidSignature < RuntimeError; end
+
+  # This method copied directly from Pry and is
+  # Copyright (c) 2013 John Mair (banisterfiend)
+  # https://github.com/pry/pry/blob/master/LICENSE
+  def self.editor
+    configured = ENV["VISUAL"] || ENV["EDITOR"] || guess_editor
+    case configured
+    when /^mate/, /^subl/
+      configured << " -w"
+    when /^[gm]vim/
+      configured << " --nofork"
+    when /^jedit/
+      configured << " -wait"
+    end
+
+    configured
+  end
+
+  def self.guess_editor
+    %w(subl sublime-text sensible-editor editor mate nano vim vi open).detect do |editor|
+      system("which #{editor} > /dev/null 2>&1")
+    end
+  end
+
+  def self.read_input(prompt)
+    $stderr.print prompt
+    $stderr.flush
+    $stdin.readline.strip
+  end
+
+  def self.read_passphrase(prompt)
+    `stty -echo`
+    read_input prompt
+  ensure
+    $stderr.print "\n"
+    `stty echo`
+  end
+
+  def self.interactive=(bool)
+    @interactive = bool
+    if interactive?
+      # get rid of stack trace on <ctrl-c>
+      trap(:INT){ exit 2 }
+    else
+      trap(:INT, "DEFAULT")
+    end
+  end
+
+  def self.interactive?
+    !!@interactive
+  end
+
+  # TODO: it'd be nice not to store the passphrase in
+  # plaintext in RAM.
+  def self.passphrase=(passphrase)
+    @passphrase = passphrase
+  end
+
+  def self.warn(context, error)
+    if interactive?
+      $stderr.puts "#{context}: #{error.message}"
+    else
+      puts "raising warning"
+      raise error
+    end
+  end
+
+  def self.passfunc(hook, uid_hint, passphrase_info, prev_was_bad, fd)
+    if interactive? && (!@passphrase || prev_was_bad != 0)
+      uid_hint = $1 if uid_hint =~ /<(.*)>/
+      @passphrase = read_passphrase "GPG passphrase for #{uid_hint}: "
+    elsif !@passphrase
+      raise "You must set Dotgpg.password or Dotgpg.interactive"
+    end
+
+    io = IO.for_fd(fd, 'w')
+    io.puts(@passphrase)
+    io.flush
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,255 @@
+require "./spec/helper"
+
+describe Dotgpg::Cli do
+  before do
+    @dotgpg = Dotgpg::Cli.new
+  end
+
+  describe "init" do
+    it "should default to the current directory" do
+      $fixture.join("create-0").mkdir
+      Dir.chdir $fixture.join("create-0") do
+        @dotgpg.invoke(:init, [])
+        assert $fixture.join("create-0", ".gpg", "test@example.com").exist?
+      end
+    end
+
+    it "should create a .gpg directory" do
+      refute $fixture.join("create-1", ".gpg").exist?
+      @dotgpg.invoke(:init, [($fixture + "create-1").to_s])
+      assert $fixture.join("create-1", ".gpg").exist?
+    end
+
+    it "should add the user's secret key to the .gpg directory" do
+      @dotgpg.invoke(:init, [($fixture + "create-2").to_s])
+      assert_equal $fixture.join("create-2", ".gpg", "test@example.com").read, GPGME::Key.find(:secret).first.export(armor: true).to_s
+    end
+
+    it "should add a README to the directory" do
+      @dotgpg.invoke(:init, [($fixture + "create-3").to_s])
+      assert_equal $fixture.join("create-3", ".gpg", "test@example.com").read, GPGME::Key.find(:secret).first.export(armor: true).to_s
+    end
+
+    it "should fail if the .gpg directory already exists" do
+      FileUtils.mkdir_p $fixture + "create-4" + ".gpg"
+      assert_fails(/\.gpg already exists/) do
+        @dotgpg.invoke(:init, [($fixture + "create-4").to_s])
+      end
+    end
+
+    it "can succeed if the directory itself already exists" do
+      FileUtils.mkdir_p $fixture + "create-5"
+      @dotgpg.invoke(:init, [($fixture + "create-5").to_s])
+      assert $fixture.join("create-5", ".gpg").exist?
+    end
+  end
+
+  describe "key" do
+    it "should output the secret key" do
+      assert_outputs GPGME::Key.find(:secret).first.export(armor: true).to_s do
+        @dotgpg.invoke(:key)
+      end
+    end
+  end
+
+  describe "add" do
+    before do
+      @path = $fixture + rand.to_s.gsub(".", "")
+      @path.mkdir
+      Dir.chdir @path do
+        Dotgpg::Cli.new.invoke(:init, [])
+      end
+    end
+
+    it "should add the specified key" do
+      key_path = ($fixture + "add1.key").to_s
+      Dir.chdir @path do
+        @dotgpg.invoke(:add, [key_path])
+      end
+      assert Dotgpg::Dir.new(@path).has_key? Dotgpg::Key.read(File.read(key_path))
+    end
+
+    it "should abort if the current working directory is not dotgpg" do
+      key_path = ($fixture + "add1.key").to_s
+      assert_fails(/not in a dotgpg directory/) do
+        @dotgpg.invoke(:add, [key_path])
+      end
+    end
+
+    it "should abort if the key cannot be read" do
+      key_path = ($fixture + "no-add1.key").to_s
+      Dir.chdir @path do
+        assert_fails(/no-add1.key: not a valid GPG key/) do
+          @dotgpg.invoke(:add, [key_path])
+        end
+      end
+    end
+
+    it "should abort if the key already exists" do
+      key_path = ($fixture + "add1.key").to_s
+      Dir.chdir @path do
+        Dotgpg::Cli.new.invoke(:add, [key_path])
+
+        assert_fails(/add1@example.com: already exists/) do
+          @dotgpg.invoke(:add, [key_path])
+        end
+      end
+    end
+
+    it "should do nothing if the key exists and --force is specified" do
+      key_path = ($fixture + "add1.key").to_s
+      Dir.chdir @path do
+        Dotgpg::Cli.new.invoke(:add, [key_path])
+
+        @dotgpg.invoke(:add, [key_path], force: true)
+      end
+    end
+  end
+
+  describe "rm" do
+    before do
+      @path = $fixture + rand.to_s.gsub(".", "")
+      @path.mkdir
+      Dir.chdir @path do
+        Dotgpg::Cli.new.invoke(:init, [])
+        Dotgpg::Cli.new.invoke(:add, [($fixture + "add1.key").to_s])
+      end
+    end
+
+    it "should remove the specified key" do
+      Dir.chdir @path do
+        @dotgpg.invoke :rm, [".gpg/add1@example.com"]
+      end
+      refute Dotgpg::Dir.new(@path).has_key? Dotgpg::Key.read(File.read($fixture + "add1.key"))
+    end
+
+    it "should find the key by email" do
+      Dir.chdir @path do
+        @dotgpg.invoke :rm, ["add1@example.com"]
+      end
+      refute Dotgpg::Dir.new(@path).has_key? Dotgpg::Key.read(File.read($fixture + "add1.key"))
+    end
+
+    it "should abort if the key doesn't exist" do
+      Dir.chdir @path do
+        assert_fails(/add2@example.com: not a valid GPG key/) do
+          @dotgpg.invoke :rm, ["add2@example.com"]
+        end
+      end
+    end
+
+    it "should abort if the key is the user's secret key" do
+      Dir.chdir @path do
+        assert_fails(/test@example.com: refusing to remove your own secret key/) do
+          @dotgpg.invoke :rm, ["test@example.com"]
+        end
+      end
+    end
+
+    it "should do nothing if they key doesn't exist and --force is specified" do
+      Dir.chdir @path do
+        @dotgpg.invoke :rm, ["add2@example.com"], force: true
+      end
+    end
+
+    it "should remove a secret key if --force is given" do
+      key = Dotgpg::Key.read(File.read(@path + ".gpg" + "test@example.com"))
+      Dir.chdir @path do
+        @dotgpg.invoke :rm, ["test@example.com"], force: true
+      end
+
+      refute Dotgpg::Dir.new(@path).has_key? key
+    end
+  end
+
+  describe "cat" do
+    before do
+      Dotgpg.passphrase = 'test'
+
+      @path = $fixture + rand.to_s.gsub(".", "")
+      Dotgpg::Cli.new.invoke(:init, [@path.to_s])
+      Dotgpg::Dir.new(@path).encrypt @path + "a", "Test\n"
+    end
+
+    it "should cat an existing encrypted file" do
+      assert_outputs "Test\n" do
+        @dotgpg.invoke :cat, [(@path + "a").to_s]
+      end
+    end
+
+    it "should warn if a file doesn't exist" do
+      assert_warns "#{@path + "b"}: No such file or directory" do
+        @dotgpg.invoke :cat, [(@path + "b").to_s]
+      end
+    end
+
+    it "should cat the existing files if a mixture is specified" do
+      assert_outputs "Test\n" do
+        assert_warns  "#{@path + "b"}: No such file or directory" do
+          @dotgpg.invoke :cat, [(@path + "b").to_s, (@path + "a").to_s]
+        end
+      end
+    end
+
+    it "should fail if the file is not in a .gpg directory" do
+      assert_fails "not in a dotgpg directory" do
+        @dotgpg.invoke :cat, ["/tmp/b"]
+      end
+    end
+
+    it "should fail if the passphrase is wrong" do
+      Dotgpg.passphrase = 'wrong'
+      assert_fails "Bad passphrase" do
+        @dotgpg.invoke :cat, [(@path + "a").to_s]
+      end
+    end
+  end
+
+  describe "edit" do
+    before do
+      Dotgpg.passphrase = 'test'
+
+      @path = $fixture + rand.to_s.gsub(".", "")
+      Dotgpg::Cli.new.invoke(:init, [@path.to_s])
+      Dotgpg::Dir.new(@path).encrypt @path + "a", "Bad test\n"
+
+    end
+
+    it "should let you edit an existing file" do
+      ENV['EDITOR'] = "sed -i '' s/Bad/Good/"
+      path = (@path + "a").to_s
+      @dotgpg.invoke(:edit, [path])
+      assert_outputs "Good test\n" do
+        Dotgpg::Dir.new(@path).decrypt path, $stdout
+      end
+    end
+
+    it "should open a non-existing file as blank" do
+      ENV['EDITOR'] = "ruby -e 'File.write(ARGV[0], %(Good test\n)) if File.read(ARGV[0]) == %()'"
+      path = (@path + "b").to_s
+      @dotgpg.invoke(:edit, [path])
+      assert_outputs "Good test\n" do
+        Dotgpg::Dir.new(@path).decrypt path, $stdout
+      end
+    end
+
+    it "should warn if a file cannot be decrypted" do
+      File.write(@path + "d", "not encrypted...")
+      path = (@path + "d").to_s
+      assert_warns "#{@path + "d"}: No data" do
+        @dotgpg.invoke(:edit, [path])
+      end
+    end
+
+    it "should fail if invoking the editor doesn't work" do
+      ENV['EDITOR'] = 'not-an-editor'
+      assert_fails "Problem with editor. Not saving changes" do
+        @dotgpg.invoke :edit, [(@path + "a").to_s]
+      end
+    end
+
+    it "should edit the existing files if a mixture is specified" do
+
+    end
+  end
+end

data/spec/dir_spec.rb

@@ -0,0 +1,214 @@
+require "./spec/helper"
+
+describe Dotgpg::Dir do
+  before do
+    @dir = Dotgpg::Dir.new($basic)
+  end
+
+  describe ".closest" do
+    it "should find the current directory" do
+      Dir.chdir $basic do
+        assert_equal @dir, Dotgpg::Dir.closest(".")
+      end
+    end
+
+    it "should find a specified directory" do
+      assert_equal @dir, Dotgpg::Dir.closest($basic)
+    end
+
+    it "should find the directory containing the given file" do
+      assert_equal @dir, Dotgpg::Dir.closest($basic + "a")
+    end
+
+    it "should find the ancestor of the directory containing the given file" do
+      assert_equal @dir, Dotgpg::Dir.closest($basic + "b" + "c")
+    end
+
+    it "should not find a directory that does not exist" do
+      assert_nil Dotgpg::Dir.closest("/tmp")
+    end
+
+    it "should not find a directory that only some of the files are in" do
+      assert_equal nil, Dotgpg::Dir.closest($basic, "/tmp")
+    end
+
+    it "should find a directory that all of the files are in" do
+      assert_equal @dir, Dotgpg::Dir.closest($basic, $basic + "a", $basic + "b" + "c")
+    end
+  end
+
+  describe "dotgpg?" do
+    it 'should be true in a directory managed by dotgpg' do
+      assert_equal true, @dir.dotgpg?
+    end
+
+    it 'should not be true in a random directory' do
+      assert_equal false, Dotgpg::Dir.new(".").dotgpg?
+    end
+
+    it "should not be true in a directory that doesn't exist" do
+      assert_equal false, Dotgpg::Dir.new(rand.to_s).dotgpg?
+    end
+  end
+
+  describe "known_keys" do
+    before do
+      @keys = @dir.known_keys
+    end
+
+    it "should return private keys in the truststore" do
+      assert_includes @keys, GPGME::Key.find(:secret, "test@example.com").first
+    end
+
+    it "should return public keys not yet in the truststore" do
+      assert_includes @keys.map(&:email), "test2@example.com"
+    end
+
+    it "should return public keys in the truststore" do
+      assert_includes @keys.map(&:email), "test2@example.com"
+    end
+  end
+
+  describe "all_encrypted_files" do
+    before do
+      @files = @dir.all_encrypted_files
+    end
+
+    it "should find files in the top-level" do
+      assert_includes @files, $basic + "a"
+    end
+
+    it "should find files in sub-directories" do
+      assert_includes @files, $basic + "b" + "c"
+    end
+
+    it "should not find unencrypted files" do
+      readme = $basic + "README.md"
+      assert readme.exist?
+      refute_includes @files, $basic + "README.md"
+    end
+
+    it "should not find files through symlinks" do
+      duplicate_a = $basic + "c" + "basic" + "a"
+      assert duplicate_a.exist?
+      refute_includes @files, duplicate_a
+    end
+  end
+
+  describe "decrypt" do
+    before do
+      Dotgpg.passphrase = "test"
+    end
+
+    it "should be able to decrypt files for which the secret is known" do
+      s = StringIO.new
+      @dir.decrypt $basic + "a", s
+      s.rewind
+      assert_equal "Test\n", s.read
+    end
+
+    it "should warn if the file cannot be read" do
+      assert_warns "#{$basic + "404"}: No such file or directory" do
+        @dir.decrypt $basic + "404", StringIO.new
+      end
+    end
+
+    it "should warn if the file cannot be decrypted" do
+      assert_warns "#{$basic + "README.md"}: No data" do
+        @dir.decrypt $basic + "README.md", StringIO.new
+      end
+    end
+
+    it "should raise on bad passphrase" do
+      Dotgpg.passphrase = 'wrong'
+      assert_raises GPGME::Error::BadPassphrase do
+        assert_warns nil do
+          @dir.decrypt $basic + "a", StringIO.new
+        end
+      end
+    end
+  end
+
+  describe "encrypt" do
+    before do
+      Dotgpg.passphrase = 'test'
+    end
+
+    after do
+      FileUtils.rm_f $basic + "test-armor"
+      FileUtils.rm_f $basic + "test-recipients"
+    end
+
+    it "should armor files" do
+      @dir.encrypt $basic + "test-armor", 'test'
+      assert_match(/-----BEGIN PGP MESSAGE-----/, File.read($basic + "test-armor"))
+    end
+
+    it "should encrypt files to all recipients" do
+      @dir.encrypt $basic + "test-recipients", 'test'
+
+      ["D1B8548C844F4881", "54907534D1B5A86B", "8490321363F14C03"].each do |keyid|
+        assert_contains_keyid keyid, File.read($basic + "test-recipients")
+      end
+    end
+  end
+
+  describe "add_key" do
+    before do
+      Dotgpg.passphrase = 'test'
+    end
+
+    it "should create the file in the .gpg directory" do
+      add1 = Dotgpg::Key.read $fixture + "add1.key"
+      refute $basic.join(".gpg", "add1@example.com").exist?
+      @dir.add_key add1
+      assert $basic.join(".gpg", "add1@example.com").exist?
+    end
+
+    it "should add the key as a recipient on all the files" do
+      add2 = Dotgpg::Key.read $fixture + "add2.key"
+      refute_contains_keyid add2.subkeys.last.keyid, File.read($basic + "a")
+      @dir.add_key add2
+      assert_contains_keyid add2.subkeys.last.keyid, File.read($basic + "a")
+    end
+
+    it "should not add the key if re-encryption fails" do
+      Dotgpg.passphrase = 'wrong'
+      add3 = Dotgpg::Key.read $fixture + "add3.key"
+      assert_raises GPGME::Error::BadPassphrase do
+        @dir.add_key add3
+      end
+      refute $basic.join(".gpg", "add3@example.com").exist?
+      refute_contains_keyid add3.subkeys.last.keyid, File.read($basic + "a")
+    end
+  end
+
+  describe "remove_key" do
+    before do
+      Dotgpg.passphrase = 'test'
+    end
+
+    it "should remove the file from the .gpg directory" do
+      removed1 = Dotgpg::Key.read $basic.join(".gpg", "removed1@example.com")
+      assert $basic.join(".gpg", "removed1@example.com").exist?
+      @dir.remove_key removed1
+      refute $basic.join(".gpg", "removed1@example.com").exist?
+    end
+
+    it "should remove the key as a recipient from all the files" do
+      removed2 = Dotgpg::Key.read $basic.join(".gpg", "removed2@example.com")
+      assert_contains_keyid removed2.subkeys.last.keyid, File.read($basic + "a")
+      @dir.remove_key removed2
+      refute_contains_keyid removed2.subkeys.last.keyid, File.read($basic + "a")
+    end
+
+    it "should not remove the key if re-encryption fails" do
+      Dotgpg.passphrase = 'wrong'
+      removed3 = Dotgpg::Key.read $basic.join(".gpg", "removed3@example.com")
+      assert_raises GPGME::Error::BadPassphrase do
+        @dir.add_key removed3
+      end
+      assert $basic.join(".gpg", "removed3@example.com").exist?
+    end
+  end
+end