brownbeagle-gitauth 0.0.1

data/README.rdoc

@@ -0,0 +1,92 @@
+== GitAuth - SSH-based authentication for Shared Git Repositories.
+
+If you've heard of Gitosis before, GitAuth is like Gitosis but A) in Ruby, B) slightly simpler to get going and C) doesn't use a git repository to manage users.
+
+At the moment configuration / adding users is done via a single command - +gitauth+. For usage, see below.
+
+=== License
+
+GitAuth is licensed under AGPL, with parts of the code being derived
+from Gitorius - http://gitorious.org/
+
+=== Installing GitAuth
+
+Getting started is relatively simple. First of, you'll need to log onto the remote server / your git host. Next, you'll need to install the gem:
+
+  sudo gem install brownbeagle-gitauth --source=https://gems.github.com/
+  
+Once that's done, the +gitauth+ and +gitauth-shell+ commands should be in your path.
+Next, you'll want to (in most cases anyway) use a specific +git+ user to host repositories.
+
+Using the example of ubuntu, we'll add a git user under which all actions will now take place (note, this is essentially the same as gitosis):
+
+  sudo adduser --disabled-password --shell /bin/bash --group --home /home/git --system --gecos 'gitauth user for version control' git
+  
+Now, whenever you run the +gitauth+ executable, you'll do so as the user you just created
+above. For simplicity purposes, I added the the following to my zsh profile so I always
+had it available. If you don't wish to, just use as you would without the alias:
+
+  alias asgit='sudo -H -u git'
+  
+And finally, to create a settings file and initialize .ssh and authorized_keys, perform the
+following:
+
+  asgit gitauth install
+  
+Note that when it asks you for the gitauth shell path, the default will lock
+it to the current gitauth version SO if you want it to stay up to date between gem versions
+point it to the path for always-current executable (e.g. on Ubuntu 9.04 w/ apt-get ruby + gems,
++/var/lib/gems/1.8/bin/gitauth-shell+)  
+
+Also, Note that if you append a path to a public key to the end of the install command,
+it will initialize a new +admin+ user who can also login via SSH. e.g.
+
+  asgit gitauth install id_rsa.pub
+  
+Would initialize an admin user with the given public key.
+
+Note that from now on, all gitauth keys should be run either logged in as
+git (via the admin user and ssh) or by being prefixed with asgit or "sudo -H -u git"
+
+=== Adding Users
+
+Whenever you want to add a user, it's ass imple as:
+
+  gitauth adduser user-name path-to-public-key
+  
+Note that if the --admin option is specified, the user will
+be able to log in to the shell via SSH and will also be able
+to access any repository.
+
+=== Adding Repositories
+
+Adding a repository is a two step process. First, you create it:
+
+  gitauth addrepo repo-name
+  
+Then, for every user who needs access, you do:
+
+  gitauth permissions repo-name user-name permission-type
+  
+Where permission type is read, write or all. If permission
+type isn't specified, it will default to all.
+
+=== Accessing repos:
+
+Finally, once you've added users / repos, using them is as simple
+as doing the following on each users computer:
+
+  git clone git@your-remote-host:repo-name
+
+Or
+
+  git clone git@your-remote-host:repo-name.git
+  
+Either form working just as well.
+
+Note that for the first time you push, you will need
+to use the full form:
+
+  git push origin master
+
+As it starts as an empty repo.

data/bin/gitauth

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+#--
+#   Copyright (C) 2009 BrownBeagle
+#   Copyright (C) 2008 Darcy Laycock <sutto@sutto.net>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU Affero General Public License for more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'rubygems'
+require 'readline'
+require 'thor'
+require File.join(File.dirname(__FILE__), "..", "lib", "gitauth")
+
+
+class GitAuthRunner < Thor
+  
+  
+  desc "addrepo REPO-NAME [PATH-PART]", "Adds a new repository"
+  def addrepo(name, path = name)
+    GitAuth.setup!
+    if GitAuth::Repo.create(name, path)
+      $stdout.puts "Repo was successfully created"
+    else
+      $stderr.puts "There was an error creating the repo"
+      exit! 1
+    end
+  end
+  
+  desc "adduser NAME PATH-TO-PUBLIC-KEY [--admin]", "Adds a user"
+  method_options :admin => :boolean
+  def adduser(name, key_path)
+    GitAuth.setup!
+    admin = !!(options && options[:admin])
+    if GitAuth::Users.create(name, admin, File.read(key_path).strip)
+      $stdout.puts "User added"
+    else
+      $stderr.puts "There was an error adding the given user"
+      exit! 
+    end
+  end
+  
+  desc "repos", "Lists all the current repos"
+  def repos
+    GitAuth.setup!
+    $stdout.puts "repositories:"
+    GitAuth::Repo.all.each do |repo|
+      $stdout.puts " - #{repo.name}"
+    end
+  end
+  
+  desc "users", "Lists all users in the system"
+  def users
+    GitAuth.setup!
+    $stdout.puts "users:"
+    GitAuth::Users.all.each do |user|
+      $stdout.puts "- #{user.name}"
+    end
+  end
+  
+  
+  desc "permissions REPO USER [PERMISION=all,read,write]", "Adds Permissions for a user to a repository"
+  def permissions(repo, user, permissions = "all")
+    GitAuth.setup!
+    unless %w(read write all).include?(permissions)
+      $stderr.puts "Invalid permissions: #{permissions}"
+      exit! 1
+    end
+    repo = GitAuth::Repo.get(repo)
+    user = GitAuth::Users.get(user)
+    if repo.nil? || user.nil?
+      $stderr.puts "Invalid repository or user, please check the name"
+      exit! 1
+    end
+    repo.writeable_by(user) if %w(all write).include?(permissions)
+    repo.readable_by(user) if %w(all read).include?(permissions)
+    GitAuth::Users.save!
+    GitAuth::Repo.save!
+    $stdout.puts "Permissions Added"
+  end
+  
+  desc "install [ADMIN-PUBLIC-KEY]", "creates and sets the permissions for .ssh and .ssh/authorized keys"
+  method_options :force_config => :boolean
+  def install(public_key_path = nil)
+    $stdout.print "Are you logged in as the correct user? (y/n) "
+    answer = Readline.readline
+    if answer !~ /^y/i
+      $stderr.puts "Please log in as the correct user and re-run"
+      exit! 1
+    end
+    require 'fileutils'
+    folder = File.expand_path("~/.ssh")
+    if !File.exist?(folder) || !File.directory?(folder)
+      FileUtils.mkdir(folder)
+      FileUtils.chmod(0700, folder)
+    end
+    authorized_keys = File.join(folder, "authorized_keys")
+    if !File.exist?(authorized_keys)
+      File.open(authorized_keys, "w+") do |f|
+        f.puts "## GitAuth - DO NO EDIT BELOW THIS LINE ##"
+      end
+      FileUtils.chmod(0600, authorized_keys)
+    end
+    gitauth_folder = File.expand_path("~/.gitauth/")
+    FileUtils.mkdir(gitauth_folder) if !File.exist?(gitauth_folder) || !File.directory?(gitauth_folder)
+    gitauth_settings_path = File.join(gitauth_folder, "settings.yml")
+    unless File.exist?(gitauth_settings_path) || (options && options[:force_config])
+      print "Where did you want repositories to be stored? (default: ~/repositories/): "
+      path = Readline.readline.strip
+      path = File.expand_path("~/repositories") if path.empty?
+      begin
+        FileUtils.mkdir_p(path)
+      rescue
+        $stderr.puts "There was an error making the repository folder: #{path}"
+        $stderr.puts "Please check again"
+        exit! 1
+      end
+      current_gitauth_shell_path = File.join(GitAuth::BASE_DIR, "bin", "gitauth-shell")
+      $stdout.print "What is the path to your gitauth-shell (default: '#{current_gitauth_shell_path}'):  "
+      gitauth_shell_path = Readline.readline
+      gitauth_shell_path = current_gitauth_shell_path if gitauth_shell_path.empty?
+      File.open(gitauth_settings_path, "w+") do |f|
+        f.write({
+          "base_path"            => path,
+          "authorized_keys_file" => authorized_keys,
+          "shell_executable"     => gitauth_shell_path
+        }.to_yaml)
+      end
+      if !public_key_path.nil? && File.exist?(public_key_path)
+        GitAuth.setup!
+        created = GitAuth::Users.create("admin", true, File.read(public_key_path).strip)
+        if created
+          $stdout.puts "Admin User Created."
+        else
+          $stderr.puts "An admin user couldn't be created."
+          exit! 1
+        end
+      end
+    end
+  rescue Errno::EACCES
+      $stderr.puts "Hey, it looks you don't have access to that - sorry!"
+      exit! 1
+  end
+  
+end
+
+if ARGV.empty?
+  GitAuthRunner.new.help
+else
+  GitAuthRunner.start
+end

data/bin/gitauth-shell

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+#--
+#   Copyright (C) 2009 BrownBeagle
+#   Copyright (C) 2008 Darcy Laycock <sutto@sutto.net>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU Affero General Public License for more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+
+REAL_FILE = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+
+# Require the proper gitauth file.
+require File.expand_path(File.join(File.dirname(REAL_FILE), "..", "lib", "gitauth"))
+
+GitAuth.setup!
+
+# Gitorious does it so I should too!
+File.umask(0022)
+
+user_name = ARGV[0]
+command   = ENV["SSH_ORIGINAL_COMMAND"]
+
+GitAuth::Client.start!(user_name, command) do |c|
+  
+  c.on(:invalid_user) do |c|
+    c.exit_with_error "An invalid user / key was used. Please ensure it is setup with GitAuth"
+  end
+  
+  c.on(:invalid_command) do |c|
+    if c.user.shell_accessible?
+      exec(ENV["SHELL"])
+    else
+      c.exit_with_error "SSH_ORIGINAL_COMMAND is needed, mmmkay?"
+    end
+  end
+  
+  c.on(:invalid_repository) do |c|
+   c.exit_with_error "Ze repository you specified does not exist."
+  end
+  
+  c.on(:bad_command) do |c|
+    c.exit_with_error "A Bad Command Has Failed Ye, Thou Shalt Not Continue."
+  end
+
+  c.on(:access_denied) do |c|
+    c.exit_with_error "These are not the droids you are looking for"
+  end
+
+  c.on(:fatal_error) do |c|
+    c.exit_with_error "Holy crap, we've imploded cap'n!"
+  end
+  
+end
+

data/lib/gitauth/client.rb

@@ -0,0 +1,91 @@
+#--
+#   Copyright (C) 2009 Brown Beagle Software
+#   Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
+#   Copyright (C) 2007, 2008 Johan Sørensen <johan@johansorensen.com>
+#   Copyright (C) 2008 Tor Arne Vestbø <tavestbo@trolltech.com>
+#   Copyright (C) 2008 Darcy Laycock <sutto@sutto.net>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU Affero General Public License for more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module GitAuth
+  class Client
+    
+    attr_accessor :user, :command
+    
+    def initialize(user_name, command)
+      GitAuth.logger.debug "Initializing client with command: '#{command}' and user name '#{user_name}'"
+      @callbacks = Hash.new { |h,k| h[k] = [] }
+      @user      = GitAuth::Users.get(user_name.to_s.strip)
+      @command   = command
+    end
+    
+    def on(command, &blk)
+      @callbacks[command.to_sym] << blk
+    end
+    
+    def execute_callback!(command)
+      @callbacks[command.to_sym].each { |c| c.call(self) }
+    end
+    
+    def exit_with_error(error)
+      GitAuth.logger.warn "Exiting with error: #{error}"
+      $stderr.puts error
+      exit! 1
+    end
+    
+    def run!
+      if @user.nil?
+        execute_callback! :invalid_user
+      elsif @command.to_s.strip.empty?
+        execute_callback! :invalid_command
+      else
+        command   = Command.parse!(@command)
+        repo      = Repo.get(extract_repo_name(command))
+        if command.bad?
+          execute_callback! :bad_command
+        elsif repo.nil?
+          execute_callback! :invalid_repository
+        elsif user.can_execute?(command, repo)
+          # We can go ahead.
+          git_shell_argument = "#{command.verb} '#{repo.real_path}'"
+          # And execute that soab.
+          GitAuth.logger.info "Running command: #{git_shell_argument} for user: #{@user.name}"
+          exec("git-shell", "-c", git_shell_argument)
+        else
+          execute_callback! :access_denied
+        end
+      end
+    rescue Exception => e
+      GitAuth.logger.fatal "Exception: #{e.class.name}: #{e.message}"
+      e.backtrace.each do |l|
+        GitAuth.logger.fatal "  => #{l}"
+      end
+      execute_callback! :fatal_error
+    end
+    
+    def self.start!(user, command)
+      client = self.new(user, command)
+      yield client if block_given?
+      client.run!
+    end
+    
+    protected
+    
+    def extract_repo_name(command)
+      command.path.gsub(/\.git$/, "")
+    end
+    
+  end
+end

data/lib/gitauth/command.rb

@@ -0,0 +1,105 @@
+#--
+#   Copyright (C) 2009 Brown Beagle Software
+#   Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
+#   Copyright (C) 2007, 2008 Johan Sørensen <johan@johansorensen.com>
+#   Copyright (C) 2008 Tim Dysinger <tim@dysinger.net>
+#   Copyright (C) 2008 Tor Arne Vestbø <tavestbo@trolltech.com>
+#   Copyright (C) 2008 Darcy Laycock <sutto@sutto.net>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU Affero General Public License for more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+# This along with the associated gitauth-shell command are inspired by
+# (and essentially, derived from) gitosis (http://eagain.net/gitweb/?p=gitosis.git)
+# and gitorius (http://gitorius.org)
+# Gitosis is of this writing licensed under the GPLv2 and is copyright (c) Tommi Virtanen
+# and can be found at http://eagain.net/gitweb/?p=gitosis.git
+# GitAuth::Command is licensed under the same license
+
+module GitAuth
+  class Command
+    class BadCommandError < StandardError; end
+    
+    # Standard Commands
+    READ_COMMANDS  = ["git-upload-pack", "git upload-pack"]
+    WRITE_COMMANDS = ["git-receive-pack", "git receive-pack"]
+    PATH_REGEXP    = /^'([a-z0-9\-\+]+(\.git)?)'$/i.freeze
+    
+    attr_reader :path, :verb, :command
+    
+    def initialize(command)
+      @command     = command
+      @verb        = nil
+      @argument    = nil
+      @path        = nil
+      @bad_command = true
+    end
+    
+    def bad?
+      !!@bad_command
+    end
+    
+    def write?
+      !bad? && @verb_type == :write
+    end
+    
+    def read?
+      !bad? && !write?
+    end
+    
+    # These exceptions are FUGLY.
+    # Clean up, mmkay?
+    def process!
+      raise BadCommandError if @command.include?("\n")
+      @verb, @argument = split_command
+      raise BadCommandError if @argument.nil? || @argument.is_a?(Array) 
+      # Check if it's read / write
+      if READ_COMMANDS.include?(@verb)
+        @verb_type = :read
+      elsif WRITE_COMMANDS.include?(@verb)
+        @verb_type = :write
+      else
+        raise BadCommandError
+      end
+      if PATH_REGEXP =~ @argument
+        @path = $1
+        raise BadCommandError unless @path
+      else
+        raise BadCommandError
+      end
+      @bad_command = false
+    rescue BadCommandError
+    end
+    
+    def self.parse!(command)
+      command = self.new(command)
+      command.process!
+      command
+    end
+    
+    protected
+    
+    def split_command
+      parts = @command.split(" ")
+      if parts.size == 3
+        ["#{parts[0]} #{parts[1]}", parts[2]]
+      elsif parts.size == 2
+        parts
+      else
+        raise BadCommandError
+      end
+    end
+    
+  end
+end

data/lib/gitauth/repo.rb

@@ -0,0 +1,106 @@
+#--
+#   Copyright (C) 2009 Brown Beagle Software
+#   Copyright (C) 2008 Darcy Laycock <sutto@sutto.net>
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU Affero General Public License for more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'fileutils'
+module GitAuth
+  class Repo
+    REPOS_PATH = File.join(GitAuth::GITAUTH_DIR, "repositories.yml")
+    
+    def self.all
+      @@all_repositories ||= nil
+    end
+    
+    def self.load!
+      self.all = YAML.load_file(REPOS_PATH) rescue nil if File.exist?(REPOS_PATH)
+      self.all = [] unless self.all.is_a?(Array)
+    end
+    
+    def self.save!
+      load! if self.all.nil?
+      File.open(REPOS_PATH, "w+") do |f|
+        f.write self.all.to_yaml
+      end
+    end
+    
+    def self.all=(value)
+      @@all_repositories = value
+    end
+    
+    def self.get(name)
+      GitAuth.logger.debug "Getting Repo w/ name: '#{name}'"
+      self.all.detect { |r| r.name == name }
+    end
+    
+    def self.create(name, path = name)
+      return false unless self.get(name).nil?
+      repository = self.new(name, path)
+      if repository.create_repo!
+        self.load!
+        self.all << repository
+        self.save!
+        return true
+      else
+        return false
+      end
+    end
+    
+    attr_accessor :name, :path
+    
+    def initialize(name, path, auto_create = false)
+      @name, @path = name, path
+      @permissions = {}
+    end
+    
+    def writeable_by(user)
+      @permissions[:write] ||= []
+      @permissions[:write] << user.name
+      @permissions[:write].uniq!
+    end
+    
+    def readable_by(user)
+      @permissions[:read] ||= []
+      @permissions[:read] << user.name
+      @permissions[:read].uniq!
+    end
+    
+    def writeable_by?(user)
+      (@permissions[:write] || []).include? user.name
+    end
+    
+    def readable_by?(user)
+      (@permissions[:read] || []).include? user.name
+    end
+    
+    def real_path
+      File.join(GitAuth.settings.base_path, @path)
+    end
+    
+    def create_repo!
+      path = self.real_path
+      unless File.exist?(path) && File.directory?(path)
+        FileUtils.mkdir_p(path)
+        output = ""
+        Dir.chdir(path) do
+          IO.popen("git init --bare") { |f| output << f.read }
+        end
+        return !!(output =~ /Initialized empty Git repository/)
+      end
+    end
+    
+  end
+end