ssh-allow 0.6.0

data/lib/ssh/allow/version.rb

@@ -0,0 +1,5 @@
+module SSH
+  module Allow
+    VERSION = "0.6.0"
+  end
+end

data/spec/acceptance/acceptance_helper.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'aruba/api'
+
+RSpec.configure do |config|
+  config.include Aruba::Api
+  config.include CLIHelpers
+
+  config.before(:all) do
+    @__aruba_original_paths = (ENV['PATH'] || '').split(File::PATH_SEPARATOR)
+    ENV['PATH'] = ([File.expand_path('bin')] + @__aruba_original_paths).join(File::PATH_SEPARATOR)
+    FileUtils.rm_rf(current_dir)
+    @aruba_io_wait_seconds = 1.5
+  end
+
+  config.after(:all) do
+    ENV['PATH'] = @__aruba_original_paths.join(File::PATH_SEPARATOR)
+    restore_env
+  end
+
+end
+

data/spec/acceptance/cli_spec.rb

@@ -0,0 +1,47 @@
+require 'acceptance/acceptance_helper'
+
+describe "Executing the ssh-allow CLI" do
+  context "GIVEN: a path-limited 'ls' config file" do
+    before(:each) do
+      @file = 'test.rules'
+      @dir_path = File.expand_path(current_dir + '/../')
+      @allow = %(
+      allow!("ls") do
+        opts "-ld"
+        args "#{@dir_path}/.*"
+      end
+      ).gsub(/^ {6}/, '')
+      write_file(@file, @allow)
+      @cmd = "ssh-allow guard --rules=#{File.expand_path(current_dir)}/#{@file} --echo"
+    end
+
+    context "WHEN: we run 'ssh-allow guard --echo' with an allowed path" do
+      before(:each) do
+        @ssh = ssh_command %(ls -ld #{@dir_path}/*)
+        run_simple(@cmd)
+      end
+
+      context "THEN: the output of the run" do
+        it "should contain the remote command" do
+          all_output.should include(@ssh)
+        end
+
+        it "should contain a listing for the 'tmp/aruba' directory" do
+          all_output.should match(/tmp\/aruba$/)
+        end
+      end
+    end
+
+    context "WHEN: we run 'ssh-allow guard --echo' with an disallowed path" do
+      before(:each) do
+        @ssh = ssh_command %(ls -ld /foo/bar/*)
+        run_simple(@cmd)
+      end
+
+      it "standard error indicates a bad command" do
+        all_stderr.should match(/Remote Command Not Allowed: #{@ssh}/)
+      end
+    end
+
+  end
+end

data/spec/command_line_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe "The CommandLine parser" do
+  before(:each) do
+    @parser = CommandLineParser.new
+  end
+
+  context "with only the command" do
+    before(:each) do
+      @cmd = '/bin/ls'
+    end
+
+    context "when not quoted" do
+      before(:each) do
+        @parsed_cmd = @parser.parse(@cmd)
+      end
+
+      it "parses the command" do
+        @parsed_cmd.name.text_value.should == @cmd
+      end
+    end
+
+    context "when quoted" do
+      before(:each) do
+        @parsed_cmd = @parser.parse("\"#{@cmd}\"")
+      end
+
+      it "parses the quoted command" do
+        @parsed_cmd.text_value.should == "\"#{@cmd}\""
+      end
+    end
+  end
+
+  context "with just options" do
+    before(:each) do
+      @cmd = 'ls'
+      @opts = []
+    end
+
+    context "one short" do
+      before(:each) do
+        @opts << '-l'
+        @parsed_cmd = @parser.parse("#{@cmd} #{@opts.join(' ')}")
+      end
+
+      it "parses the list of options" do
+        @parsed_cmd.option_list.should == ['l']
+      end
+    end
+
+    context "one long" do
+      before(:each) do
+        @opts << '--long'
+        @parsed_cmd = @parser.parse("#{@cmd} #{@opts.join(' ')}")
+      end
+
+      it "parses the list of options" do
+        @parsed_cmd.option_list.should == ['long']
+      end
+    end
+
+    context "one long and one short" do
+      before(:each) do
+        @opts = ['--long', '-a']
+        @parsed_cmd = @parser.parse("#{@cmd} #{@opts.join(' ')}")
+      end
+
+      it "parses the list of options" do
+        @parsed_cmd.option_list.should == ['long', 'a']
+      end
+    end
+
+    context "one short w/argument" do
+      before(:each) do
+        @opts << '-l=foo/bar'
+        @parsed_cmd = @parser.parse("#{@cmd} #{@opts.join(' ')}")
+      end
+
+      it "parses the list of options" do
+        @parsed_cmd.option_list.should == ['l']
+      end
+
+      it "parses the list of arguments" do
+        @parsed_cmd.argument_list.should == ['foo/bar']
+      end
+    end
+
+    context "one long w/argument" do
+      before(:each) do
+        @opts << '--long=foo/bar'
+        @parsed_cmd = @parser.parse("#{@cmd} #{@opts.join(' ')}")
+      end
+
+      it "parses the list of options" do
+        @parsed_cmd.option_list.should == ['long']
+      end
+
+      it "parses the list of arguments" do
+        @parsed_cmd.argument_list.should == ['foo/bar']
+      end
+    end
+
+    context "one long and one short w/arguments" do
+      before(:each) do
+        @opts = ['--long=foo', '-a=bar']
+        @parsed_cmd = @parser.parse("#{@cmd} #{@opts.join(' ')}")
+      end
+
+      it "parses the list of options" do
+        @parsed_cmd.option_list.should == ['long', 'a']
+      end
+
+      it "parses the list of arguments" do
+        @parsed_cmd.argument_list.should == ['foo', 'bar']
+      end
+    end
+  end
+
+  context "with just arguments" do
+    before(:each) do
+      @cmd = 'cp'
+      @args = ['foo']
+    end
+
+    context "one argument" do
+      before(:each) do
+        @parsed_cmd = @parser.parse("#{@cmd} #{@args.join(' ')}")
+      end
+
+      it "parses the list of arguments" do
+        @parsed_cmd.argument_list.should == @args
+      end
+    end
+
+    context "two arguments" do
+      before(:each) do
+        @args << 'bar'
+        @parsed_cmd = @parser.parse("#{@cmd} #{@args.join(' ')}")
+      end
+
+      it "parses the list of arguments" do
+        @parsed_cmd.argument_list.should == @args
+      end
+    end
+  end
+
+  context "with arguments and options" do
+    before(:each) do
+      @cmd = 'cp'
+      @opts = ['r']
+      @args = ['foo', 'bar']
+    end
+
+    context "1 option followed by 2 arguments" do
+      before(:each) do
+        @parsed_cmd = @parser.parse("#{@cmd} -#{@opts} #{@args.join(' ')}")
+      end
+
+      it "parses the option" do
+        @parsed_cmd.option_list.should == @opts
+      end
+
+      it "parses the list of arguments" do
+        @parsed_cmd.argument_list.should == @args
+      end
+    end
+
+    context "2 arguments followed by 1 option" do
+      before(:each) do
+        @parsed_cmd = @parser.parse("#{@cmd} -#{@opts} #{@args.join(' ')}")
+      end
+
+      it "parses the option" do
+        @parsed_cmd.option_list.should == @opts
+      end
+
+      it "parses the list of arguments" do
+        @parsed_cmd.argument_list.should == @args
+      end
+    end
+
+    context "1 argument, 1 option, 1 argument" do
+      before(:each) do
+        @cmd << ' foo -r bar'
+        @parsed_cmd = @parser.parse(@cmd)
+      end
+
+      it "parses the option" do
+        @parsed_cmd.option_list.should == @opts
+      end
+
+      it "parses the list of arguments" do
+        @parsed_cmd.argument_list.should == @args
+      end
+    end
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe SSH::Allow::Command do
+
+  context "for a simple command" do
+    before(:each) do
+      @cmd_text = 'git help'
+      @command = SSH::Allow::Command.new(@cmd_text)
+    end
+
+    it "returns the correct name" do
+      @command.name.should == 'git'
+    end
+
+    it "returns the array of arguments" do
+      @command.arguments.should == ['help']
+    end
+
+    it "returns an empty array for options" do
+      @command.options.should == []
+    end
+  end
+
+  context "for a complex command" do
+    before(:each) do
+      @cmd_text = %(git log --since="6 months ago" Gemfile)
+      @command = SSH::Allow::Command.new(@cmd_text)
+    end
+
+    it "returns the array of arguments" do
+      @command.arguments.should == ['log', '"6 months ago"', 'Gemfile']
+    end
+
+    it "returns the array of options" do
+      @command.options.should == ['since']
+    end
+  end
+
+  describe "#allowed?" do
+    context "with 1 'allow' rule, each, for cp and mv commands" do
+      before(:each) do
+        @cp = mock(:cp_rule)
+        @mv = mock(:mv_rule)
+        @cp.should_receive(:match?).once.and_return([false, false])
+        @rules = [@cp, @mv]
+        cmd_text = 'mv /foo/bar /baz/bar'
+        @command = SSH::Allow::Command.new(cmd_text)
+      end
+
+      context "when the mv command matches" do
+        before(:each) do
+          @mv.should_receive(:match?).once.and_return([true, true])
+        end
+
+        it "returns true" do
+          @command.should be_allowed(@rules)
+        end
+      end
+
+      context "when the mv command doesn't match" do
+        before(:each) do
+          @mv.should_receive(:match?).once.and_return([false, false])
+        end
+
+        it "returns false" do
+          @command.should_not be_allowed(@rules)
+        end
+      end
+    end
+  end
+
+end

data/spec/rule_set_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe SSH::Allow::RuleSet do
+  before(:each) do
+    @rule_set = SSH::Allow::RuleSet.new
+  end
+
+  context "#new" do
+    it "has an empty rules array" do
+      @rule_set.rules.should be_empty
+    end
+  end
+
+  context "with a valid rule" do
+    before(:each) do
+      @rule = mock(:rule)
+      @rule_set.should_receive(:get_rule).once.and_return(@rule)
+    end
+
+    context "#allow" do
+      before(:each) do
+        @rule_set.allow(:rule)
+      end
+
+      it "adds the rule" do
+        @rule_set.rules.should == [@rule]
+      end
+    end
+
+    context "#allow!" do
+      it "does not raise an error" do
+        lambda { @rule_set.allow!(:rule) }.should_not raise_error
+      end
+    end
+  end
+
+  context "with an invalid rule" do
+    before(:each) do
+      @rule_set.should_receive(:get_rule).once.and_return(false)
+    end
+
+    context "#allow" do
+      before(:each) do
+        @allow = @rule_set.allow(:rule)
+      end
+
+      it "returns false" do
+        @allow.should == false
+      end
+
+      it "does not add the rule" do
+        @rule_set.rules.should be_empty
+      end
+    end
+
+    context "#allow!" do
+      it "raises an error" do
+        lambda { @rule_set.allow!(:rule) }.should raise_error(/Invalid rule: "rule"/)
+      end
+    end
+  end
+
+  context "with a config file with 2 valid rules" do
+    before(:each) do
+      @rule1 = mock(:foo)
+      @rule2 = mock(:bar)
+      @rule_set.should_receive(:get_rule).twice.and_return(@rule1, @rule2)
+      @rule_set.should_receive(:read_rules).once.and_return(sample_rules)
+    end
+
+    context "#read" do
+      before(:each) do
+        @rule_set.read('/my/fake/rules')
+      end
+
+      it "adds 2 rules" do
+        @rule_set.rules.should == [@rule1, @rule2]
+      end
+    end
+  end
+
+  context "with a config file with 1 valid and 1 invalid rule" do
+    before(:each) do
+      @rule1 = mock(:foo)
+      @rule_set.should_receive(:get_rule).twice.and_return(@rule1, false)
+      @rule_set.should_receive(:read_rules).once.and_return(sample_rules)
+    end
+
+    context "#read" do
+      it "raises an error on the second rule" do
+        lambda { @rule_set.read('/my/fake/rules') }.should raise_error(/Invalid rule: "bar"/)
+      end
+    end
+  end
+end

data/spec/rule_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe SSH::Allow::Rule do
+
+  context "creating an Allow rule, with a single command" do
+    before(:each) do
+      @cmd = "ls"
+    end
+
+    context "when specifying no options or arguments" do
+      before(:each) do
+        @rule = SSH::Allow::Rule.allow(@cmd)
+      end
+
+      it "returns [:none] for options" do
+        @rule.options.should == [:none]
+      end
+
+      it "match_command? matches 'ls'" do
+        @rule.should be_match_command(@cmd)
+      end
+
+      it "match_command? doesn't match 'ln'" do
+        @rule.should_not be_match_command('ln')
+      end
+
+      it "match_options? matches no options" do
+        @rule.should be_match_options([])
+      end
+
+      it "match_options? doesn't match a passed in option" do
+        @rule.should_not be_match_options(['foo'])
+      end
+
+      it "match_arguments? matches no arguments" do
+        @rule.should be_match_arguments([])
+      end
+
+      it "match_arguments? doesn't match a passed in argument" do
+        @rule.should_not be_match_arguments(['foo'])
+      end
+    end
+
+    context "when specifying :any for options and arguments " do
+      before(:each) do
+        @rule = SSH::Allow::Rule.allow(@cmd)
+        @rule.opts(:any)
+        @rule.args(:any)
+      end
+
+      it "match_options? matches no options" do
+        @rule.should be_match_options([])
+      end
+
+      it "match_options? matches any number of options" do
+        @rule.should be_match_options(['foo', 'bar', 'baz'])
+      end
+
+      it "match_arguments? matches no arguments" do
+        @rule.should be_match_arguments([])
+      end
+
+      it "match_arguments? matches any number of arguments" do
+        @rule.should be_match_arguments(['foo', 'bar', :baz])
+      end
+    end
+
+    context "when specifying strings for options and arguments, via a block" do
+      before(:each) do
+        @rule = SSH::Allow::Rule.allow(@cmd) do
+          opts '-ld'
+          args '^\/foo\/bar\/.*'
+        end
+      end
+
+      it "returns \"ld\" for the rule options" do
+        @rule.options.should == ['ld']
+      end
+
+      it "returns the correct pattern for the argument" do
+        @rule.arguments[0].should == Regexp.new('^\/foo\/bar\/.*')
+      end
+
+      it "match_options? matches the correct options" do
+        @rule.should be_match_options(['ld'])
+      end
+
+      it "match_options? doesn't match more than one option" do
+        @rule.should_not be_match_options(['ld', 'foo'])
+      end
+
+      it "match_arguments? matches an argument that starts with '/foo/bar/'" do
+        @rule.should be_match_arguments(['/foo/bar/*'])
+      end
+
+      it "match_arguments? doesn't match an argument that starts with '/foo/baz/'" do
+        @rule.should_not be_match_arguments(['/foo/baz/*'])
+      end
+
+      it "match_arguments? doesn't match more than one argument" do
+        @rule.should_not be_match_arguments(['/foo/bar/*', '/foo/baz/*'])
+      end
+    end
+
+    context "when sending an invalid block" do
+      before(:each) do
+        @rule = SSH::Allow::Rule.allow(@cmd) do
+          opts "-ld"
+          foo "bar"
+        end
+      end
+
+      it "returns false" do
+        @rule.should be(false)
+      end
+    end
+  end
+
+  context "creating a Deny rule" do
+    context "with a single command string" do
+      before(:each) do
+        @cmd = "ls"
+        @rule = SSH::Allow::Rule.deny(@cmd)
+      end
+
+      it "returns a Deny rule" do
+        @rule.should be_instance_of(SSH::Allow::Rule::Deny)
+      end
+    end
+  end
+end
+
+describe SSH::Allow::Rule::Allow do
+  context "A Command for 'ls -ld /foo/bar/*'" do
+    before(:each) do
+      @cmd = mock(:command)
+      @cmd.should_receive(:name).once.and_return('ls')
+      @cmd.should_receive(:options).once.and_return(['ld'])
+      @cmd.should_receive(:arguments).once.and_return(['/foo/bar/*'])
+    end
+
+    context "matched against an 'ls' rule with no options or arguments" do
+      before(:each) do
+        @rule = SSH::Allow::Rule.allow('ls')
+        @match, @allow = @rule.match?(@cmd)
+      end
+
+      it "is not a match" do
+        @match.should_not be(true)
+      end
+
+      it "would not be allowed" do
+        @allow.should_not be(true)
+      end
+    end
+
+    context "matched against an 'ls' rule with matching options and arguments" do
+      before(:each) do
+        @rule = SSH::Allow::Rule.allow('ls') do
+          opts '-ld'
+          args '^\/foo\/bar\/.*'
+        end
+        @match, @allow = @rule.match?(@cmd)
+      end
+
+      it "is a match" do
+        @match.should be(true)
+      end
+
+      it "would be allowed" do
+        @allow.should be(true)
+      end
+    end
+  end
+end
+
+describe SSH::Allow::Rule::Deny do
+  context "A Command for 'mv /foo/bar/file.txt /foo/baz/'" do
+    before(:each) do
+      @cmd = mock(:command)
+      @cmd.should_receive(:name).once.and_return('mv')
+      @cmd.should_receive(:options).once.and_return([])
+      @cmd.should_receive(:arguments).once.and_return(['/foo/bar/file.txt', '/foo/baz/'])
+    end
+
+    context "matched against an 'mv' rule with no options or arguments" do
+      before(:each) do
+        @rule = SSH::Allow::Rule.deny('mv')
+        @match, @allow = @rule.match?(@cmd)
+      end
+
+      it "is not a match" do
+        @match.should_not == true
+      end
+
+      it "would be allowed" do
+        @allow.should == true
+      end
+    end
+
+    context "matched against an 'mv' rule with matching options and arguments" do
+      before(:each) do
+        @rule = SSH::Allow::Rule.deny('mv') do
+          args '^\/foo\/bar\/.*'
+          args '^\/foo\/baz\/.*'
+        end
+        @match, @allow = @rule.match?(@cmd)
+      end
+
+      it "is a match" do
+        @match.should == true
+      end
+
+      it "would not be allowed" do
+        @allow.should_not == true
+      end
+    end
+  end
+end