v1
This commit is contained in:
commit
8d4915543e
132 files changed
+20628
No files matched your search
@@ -0,0 +1,155 @@
|
||||
package ssh
|
||||
|
||||
import "strings"
|
||||
|
||||
// flagsWithArg lists all SSH flags that consume the following argument.
|
||||
var flagsWithArg = map[byte]bool{
|
||||
'B': true, 'P': true, 'b': true, 'c': true, 'D': true, 'E': true, 'e': true,
|
||||
'F': true, 'I': true, 'i': true, 'J': true, 'L': true,
|
||||
'l': true, 'm': true, 'o': true, 'O': true, 'p': true,
|
||||
'Q': true, 'R': true, 'S': true, 'w': true, 'W': true,
|
||||
}
|
||||
|
||||
// ParsedArgs holds the result of parsing SSH arguments.
|
||||
type ParsedArgs struct {
|
||||
Host string // hostname without the user@ prefix or :path
|
||||
User string // empty if not specified
|
||||
Path string // sftp only: the remote path after host:
|
||||
DestIdx int // index in Args where [user@]host sits
|
||||
Args []string
|
||||
}
|
||||
|
||||
// Parse scans SSH arguments and extracts the destination ([user@]host).
|
||||
// Returns nil if no destination is found.
|
||||
func Parse(args []string) *ParsedArgs { return SSH.Parse(args) }
|
||||
|
||||
// Parse extracts the destination: [user@]host, or [user@]host[:path] for sftp.
|
||||
func (c Client) Parse(args []string) *ParsedArgs {
|
||||
i := 0
|
||||
for i < len(args) {
|
||||
arg := args[i]
|
||||
|
||||
// "--" ends option processing
|
||||
if arg == "--" {
|
||||
i++
|
||||
break
|
||||
}
|
||||
|
||||
if strings.HasPrefix(arg, "-") && len(arg) > 1 {
|
||||
// OpenSSH accepts clusters such as -vp 2222 and -vladmin.
|
||||
if c.takesSeparateValue(arg) {
|
||||
i++
|
||||
}
|
||||
i++
|
||||
continue
|
||||
}
|
||||
|
||||
// first non-flag argument is the destination
|
||||
return c.parsed(args, i)
|
||||
}
|
||||
|
||||
// handle arguments after "--"
|
||||
if i < len(args) {
|
||||
return c.parsed(args, i)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c Client) parsed(args []string, i int) *ParsedArgs {
|
||||
dest, path := args[i], ""
|
||||
if c.paths {
|
||||
if d, p, remote := c.splitRemote(dest); remote {
|
||||
dest, path = d, p
|
||||
}
|
||||
}
|
||||
host, user := splitUserHost(dest)
|
||||
return &ParsedArgs{Host: host, User: user, Path: path, DestIdx: i, Args: args}
|
||||
}
|
||||
|
||||
// ReplaceHost returns a copy of args with the destination replaced by newHost,
|
||||
// preserving any user@ prefix.
|
||||
func ReplaceHost(args []string, destIdx int, newHost string) []string {
|
||||
return SSH.replaceHost(args, []int{destIdx}, newHost)
|
||||
}
|
||||
|
||||
// replaceHost keeps user@ and, for sftp and scp, :path. Those clients read
|
||||
// host:path, so an IPv6 address must be bracketed.
|
||||
func (c Client) replaceHost(args []string, dests []int, newHost string) []string {
|
||||
result := make([]string, len(args))
|
||||
copy(result, args)
|
||||
if c.paths && strings.Contains(newHost, ":") {
|
||||
newHost = "[" + newHost + "]"
|
||||
}
|
||||
for _, destIdx := range dests {
|
||||
original := args[destIdx]
|
||||
prefix, suffix := "", ""
|
||||
if at := strings.Index(original, "@"); at != -1 {
|
||||
prefix, original = original[:at+1], original[at+1:]
|
||||
}
|
||||
if c.paths {
|
||||
if _, path, remote := c.splitRemote(original); remote {
|
||||
suffix = ":" + path
|
||||
}
|
||||
}
|
||||
result[destIdx] = prefix + newHost + suffix
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// HasPortFlag reports whether a port was explicitly supplied.
|
||||
func HasPortFlag(args []string) bool { return SSH.HasPortFlag(args) }
|
||||
|
||||
// HasUserFlag reports whether a login user was explicitly supplied.
|
||||
func HasUserFlag(args []string) bool { return SSH.HasUserFlag(args) }
|
||||
|
||||
// HasPortFlag reports whether a port was explicitly supplied.
|
||||
func (c Client) HasPortFlag(args []string) bool { return c.hasOption(args, c.port, "Port") }
|
||||
|
||||
// HasUserFlag reports whether a login user was explicitly supplied.
|
||||
func (c Client) HasUserFlag(args []string) bool { return c.hasOption(args, c.user, "User") }
|
||||
|
||||
func hasOption(args []string, wanted byte, keyword string) bool {
|
||||
return SSH.hasOption(args, wanted, keyword)
|
||||
}
|
||||
|
||||
func (c Client) hasOption(args []string, wanted byte, keyword string) bool {
|
||||
for i := 0; i < len(args); i++ {
|
||||
arg := args[i]
|
||||
if arg == "--" || len(arg) < 2 || arg[0] != '-' {
|
||||
break
|
||||
}
|
||||
for j := 1; j < len(arg); j++ {
|
||||
flag := arg[j]
|
||||
if !c.withArg[flag] {
|
||||
continue
|
||||
}
|
||||
value := arg[j+1:]
|
||||
if value == "" {
|
||||
i++
|
||||
if i >= len(args) {
|
||||
return false
|
||||
}
|
||||
value = args[i]
|
||||
}
|
||||
if wanted != 0 && flag == wanted {
|
||||
return true
|
||||
}
|
||||
if flag == 'o' {
|
||||
fields := strings.FieldsFunc(value, func(r rune) bool { return r == '=' || r == ' ' || r == '\t' })
|
||||
if len(fields) >= 2 && strings.EqualFold(fields[0], keyword) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func splitUserHost(dest string) (host, user string) {
|
||||
if at := strings.Index(dest, "@"); at != -1 {
|
||||
return dest[at+1:], dest[:at]
|
||||
}
|
||||
return dest, ""
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
package ssh
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestParseOptionClusters(t *testing.T) {
|
||||
for _, args := range [][]string{
|
||||
{"-vp", "2222", "server"},
|
||||
{"-vp2222", "server"},
|
||||
{"-vAl", "admin", "server"},
|
||||
{"-vladmin", "server"},
|
||||
{"-B", "eth0", "server"},
|
||||
{"-P", "production", "server"},
|
||||
} {
|
||||
t.Run(args[0], func(t *testing.T) {
|
||||
assertParsed(t, Parse(args), "server", "", len(args)-1)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestExplicitSSHOptions(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
args []string
|
||||
user, port bool
|
||||
}{
|
||||
{"cluster port separated", []string{"-vp", "2222", "server"}, false, true},
|
||||
{"cluster user attached", []string{"-vladmin", "server"}, true, false},
|
||||
{"o separated", []string{"-o", "User=admin", "-o", "Port=2222", "server"}, true, true},
|
||||
{"o attached and case insensitive", []string{"-ouSeR=admin", "-oport=2222", "server"}, true, true},
|
||||
{"o whitespace", []string{"-o", " User = admin", "-o", "Port\t2222", "server"}, true, true},
|
||||
{"cluster o", []string{"-voUser=admin", "server"}, true, false},
|
||||
{"option value looks like flag", []string{"-i", "-lroot", "-F", "-p2222", "server"}, false, false},
|
||||
{"remote flags", []string{"server", "-p2222", "-o", "User=admin"}, false, false},
|
||||
{"after double dash", []string{"--", "-lroot", "-p2222"}, false, false},
|
||||
{"missing value", []string{"-vp"}, false, false},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
if got := HasUserFlag(tc.args); got != tc.user {
|
||||
t.Errorf("HasUserFlag(%v) = %v, want %v", tc.args, got, tc.user)
|
||||
}
|
||||
if got := HasPortFlag(tc.args); got != tc.port {
|
||||
t.Errorf("HasPortFlag(%v) = %v, want %v", tc.args, got, tc.port)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,199 @@
|
||||
package ssh
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestParse_BareHostname(t *testing.T) {
|
||||
got := Parse([]string{"myhost"})
|
||||
assertParsed(t, got, "myhost", "", 0)
|
||||
}
|
||||
|
||||
func TestParse_UserAtHost(t *testing.T) {
|
||||
got := Parse([]string{"admin@myhost"})
|
||||
assertParsed(t, got, "myhost", "admin", 0)
|
||||
}
|
||||
|
||||
func TestParse_PortFlag_Separated(t *testing.T) {
|
||||
got := Parse([]string{"-p", "2222", "myhost"})
|
||||
assertParsed(t, got, "myhost", "", 2)
|
||||
}
|
||||
|
||||
func TestParse_PortFlag_Attached(t *testing.T) {
|
||||
got := Parse([]string{"-p2222", "myhost"})
|
||||
assertParsed(t, got, "myhost", "", 1)
|
||||
}
|
||||
|
||||
func TestParse_IdentityFlag(t *testing.T) {
|
||||
got := Parse([]string{"-i", "/path/to/key", "user@myhost", "ls"})
|
||||
assertParsed(t, got, "myhost", "user", 2)
|
||||
}
|
||||
|
||||
func TestParse_VerboseFlag(t *testing.T) {
|
||||
got := Parse([]string{"-v", "myhost"})
|
||||
assertParsed(t, got, "myhost", "", 1)
|
||||
}
|
||||
|
||||
func TestParse_OptionFlag(t *testing.T) {
|
||||
got := Parse([]string{"-o", "StrictHostKeyChecking=no", "myhost"})
|
||||
assertParsed(t, got, "myhost", "", 2)
|
||||
}
|
||||
|
||||
func TestParse_JumpHost(t *testing.T) {
|
||||
got := Parse([]string{"-J", "jumphost", "-p", "22", "target"})
|
||||
assertParsed(t, got, "target", "", 4)
|
||||
}
|
||||
|
||||
func TestParse_MultipleFlags(t *testing.T) {
|
||||
got := Parse([]string{"-v", "-p", "22", "-i", "key", "root@host", "uptime"})
|
||||
assertParsed(t, got, "host", "root", 5)
|
||||
}
|
||||
|
||||
func TestParse_DoubleDash(t *testing.T) {
|
||||
got := Parse([]string{"--", "myhost"})
|
||||
assertParsed(t, got, "myhost", "", 1)
|
||||
}
|
||||
|
||||
func TestParse_DoubleDash_WithFlags(t *testing.T) {
|
||||
// flags after -- should be treated as destination
|
||||
got := Parse([]string{"-v", "--", "-not-a-flag"})
|
||||
assertParsed(t, got, "-not-a-flag", "", 2)
|
||||
}
|
||||
|
||||
func TestParse_NoDestination(t *testing.T) {
|
||||
got := Parse([]string{"-v", "-p", "2222"})
|
||||
if got != nil {
|
||||
t.Errorf("expected nil for args without destination, got %+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParse_EmptyArgs(t *testing.T) {
|
||||
got := Parse([]string{})
|
||||
if got != nil {
|
||||
t.Error("empty args should return nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParse_OnlyDoubleDash(t *testing.T) {
|
||||
got := Parse([]string{"--"})
|
||||
if got != nil {
|
||||
t.Error("only -- with no destination should return nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReplaceHost_PlainHost(t *testing.T) {
|
||||
args := []string{"myhost"}
|
||||
result := ReplaceHost(args, 0, "10.0.0.1")
|
||||
if result[0] != "10.0.0.1" {
|
||||
t.Errorf("got %q, want %q", result[0], "10.0.0.1")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReplaceHost_PreservesUserPrefix(t *testing.T) {
|
||||
args := []string{"-p", "22", "admin@myhost", "ls"}
|
||||
result := ReplaceHost(args, 2, "10.0.0.1")
|
||||
if result[2] != "admin@10.0.0.1" {
|
||||
t.Errorf("got %q, want %q", result[2], "admin@10.0.0.1")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReplaceHost_DoesNotMutateOriginal(t *testing.T) {
|
||||
args := []string{"myhost"}
|
||||
_ = ReplaceHost(args, 0, "10.0.0.1")
|
||||
if args[0] != "myhost" {
|
||||
t.Error("ReplaceHost must not mutate the original slice")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReplaceHost_OtherArgsUnchanged(t *testing.T) {
|
||||
args := []string{"-p", "22", "myhost"}
|
||||
result := ReplaceHost(args, 2, "10.0.0.1")
|
||||
if result[0] != "-p" || result[1] != "22" {
|
||||
t.Errorf("other args should be unchanged: %v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasUserFlag_FlagSeparated(t *testing.T) {
|
||||
if !HasUserFlag([]string{"-l", "admin", "host"}) {
|
||||
t.Error("should detect -l <user>")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasUserFlag_FlagAttached(t *testing.T) {
|
||||
if !HasUserFlag([]string{"-ladmin", "host"}) {
|
||||
t.Error("should detect -l<user> (attached form)")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasUserFlag_NotPresent(t *testing.T) {
|
||||
if HasUserFlag([]string{"-p", "22", "host"}) {
|
||||
t.Error("should not detect user flag when absent")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasUserFlag_EmptyArgs(t *testing.T) {
|
||||
if HasUserFlag([]string{}) {
|
||||
t.Error("empty args should return false")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasUserFlag_LFlagAtEnd(t *testing.T) {
|
||||
// -l at the very end with no value — should not panic
|
||||
if HasUserFlag([]string{"-l"}) {
|
||||
t.Error("-l with no value should return false")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasPortFlag_FlagSeparated(t *testing.T) {
|
||||
if !HasPortFlag([]string{"-p", "2222", "host"}) {
|
||||
t.Error("should detect -p <port>")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasPortFlag_FlagAttached(t *testing.T) {
|
||||
if !HasPortFlag([]string{"-p2222", "host"}) {
|
||||
t.Error("should detect -p<port> (attached form)")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasPortFlag_NotPresent(t *testing.T) {
|
||||
if HasPortFlag([]string{"-l", "admin", "host"}) {
|
||||
t.Error("should not detect port flag when absent")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasPortFlag_EmptyArgs(t *testing.T) {
|
||||
if HasPortFlag([]string{}) {
|
||||
t.Error("empty args should return false")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasPortFlag_PAtEnd(t *testing.T) {
|
||||
// -p at the very end with no value — should return false
|
||||
if HasPortFlag([]string{"-p"}) {
|
||||
t.Error("-p with no value should return false")
|
||||
}
|
||||
}
|
||||
|
||||
func assertParsed(t *testing.T, got *ParsedArgs, host, user string, destIdx int) {
|
||||
t.Helper()
|
||||
if got == nil {
|
||||
t.Fatal("Parse returned nil")
|
||||
}
|
||||
if got.Host != host {
|
||||
t.Errorf("host: got %q, want %q", got.Host, host)
|
||||
}
|
||||
if got.User != user {
|
||||
t.Errorf("user: got %q, want %q", got.User, user)
|
||||
}
|
||||
if got.DestIdx != destIdx {
|
||||
t.Errorf("destIdx: got %d, want %d", got.DestIdx, destIdx)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRemoteCommandFlagsDoNotOverrideDefaults(t *testing.T) {
|
||||
args := []string{"web01", "command", "-p", "1234", "-lroot"}
|
||||
if HasPortFlag(args) || HasUserFlag(args) {
|
||||
t.Fatal("remote command interpreted as SSH options")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,162 @@
|
||||
package ssh
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Client describes one OpenSSH program netssh can run. The programs share
|
||||
// ssh's connection options but differ in flags and destination syntax.
|
||||
type Client struct {
|
||||
Name string // binary name: ssh, sftp, or scp
|
||||
withArg map[byte]bool // short flags that consume a value
|
||||
port byte // flag for the port: -p (ssh) or -P (sftp, scp)
|
||||
user byte // flag for the login user; 0 when only user@ or -o User work
|
||||
paths bool // destinations are host[:path]
|
||||
// instances are the configured NetBox instance names; "inst/host:path"
|
||||
// is remote only for these, so local paths like "dir/file:x" stay local.
|
||||
instances map[string]bool
|
||||
}
|
||||
|
||||
// WithInstances returns c aware of the NetBox instance prefixes in host:path.
|
||||
func (c Client) WithInstances(names []string) Client {
|
||||
c.instances = make(map[string]bool, len(names))
|
||||
for _, name := range names {
|
||||
c.instances[strings.ToLower(name)] = true
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
var (
|
||||
// SSH is the default client; its flag table is flagsWithArg.
|
||||
SSH = Client{Name: "ssh", withArg: flagsWithArg, port: 'p', user: 'l'}
|
||||
// SFTP follows sftp(1): -l is a bandwidth limit, -P the port.
|
||||
SFTP = Client{Name: "sftp", withArg: flagSet("BbcDFiJloPRSsX"), port: 'P', paths: true}
|
||||
// SCP follows scp(1); unlike sftp, -B and -R take no value.
|
||||
SCP = Client{Name: "scp", withArg: flagSet("cDFiJloPSX"), port: 'P', paths: true}
|
||||
)
|
||||
|
||||
func flagSet(flags string) map[byte]bool {
|
||||
set := make(map[byte]bool, len(flags))
|
||||
for i := 0; i < len(flags); i++ {
|
||||
set[flags[i]] = true
|
||||
}
|
||||
return set
|
||||
}
|
||||
|
||||
// PortArgs returns the arguments that set port for this client.
|
||||
func (c Client) PortArgs(port string) []string { return []string{"-" + string(c.port), port} }
|
||||
|
||||
// UserArgs returns the arguments that set the login user for this client.
|
||||
func (c Client) UserArgs(user string) []string {
|
||||
if c.user == 0 {
|
||||
return []string{"-o", "User=" + user}
|
||||
}
|
||||
return []string{"-" + string(c.user), user}
|
||||
}
|
||||
|
||||
// Operand is a remote scp argument such as user@host:/path.
|
||||
type Operand struct {
|
||||
Idx int
|
||||
User string
|
||||
Host string
|
||||
Path string
|
||||
}
|
||||
|
||||
// Operands returns the remote operands of scp arguments. All remote operands
|
||||
// must name the same host, because one set of options applies per call.
|
||||
func (c Client) Operands(args []string) ([]Operand, error) {
|
||||
start := c.optionsEnd(args)
|
||||
var out []Operand
|
||||
for i := start; i < len(args); i++ {
|
||||
arg := args[i]
|
||||
if strings.HasPrefix(arg, "scp://") || strings.HasPrefix(arg, "sftp://") {
|
||||
return nil, fmt.Errorf("%q: use host:path instead of a URI", arg)
|
||||
}
|
||||
dest, path, remote := c.splitRemote(arg)
|
||||
if !remote {
|
||||
continue
|
||||
}
|
||||
host, user := splitUserHost(dest)
|
||||
if host == "" {
|
||||
continue
|
||||
}
|
||||
if len(out) > 0 && !strings.EqualFold(out[0].Host, host) {
|
||||
return nil, fmt.Errorf("scp between two remote hosts (%s, %s) is not supported; copy in two steps", out[0].Host, host)
|
||||
}
|
||||
out = append(out, Operand{Idx: i, User: user, Host: host, Path: path})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// optionsEnd returns the index of the first operand; scp, like ssh, stops
|
||||
// option parsing at the first non-option or after "--".
|
||||
func (c Client) optionsEnd(args []string) int {
|
||||
end := c.insertionPoint(args)
|
||||
if end < len(args) && args[end] == "--" {
|
||||
end++
|
||||
}
|
||||
return end
|
||||
}
|
||||
|
||||
// insertionPoint is where added options still count as options: before the
|
||||
// first operand or before "--".
|
||||
func (c Client) insertionPoint(args []string) int {
|
||||
for i := 0; i < len(args); i++ {
|
||||
arg := args[i]
|
||||
if arg == "--" {
|
||||
return i
|
||||
}
|
||||
if !strings.HasPrefix(arg, "-") || len(arg) < 2 {
|
||||
return i
|
||||
}
|
||||
if c.takesSeparateValue(arg) {
|
||||
i++
|
||||
}
|
||||
}
|
||||
return len(args)
|
||||
}
|
||||
|
||||
// splitRemote is splitHostPath with netssh's [user@]instance/host:path form.
|
||||
func (c Client) splitRemote(arg string) (dest, path string, remote bool) {
|
||||
if head, rest, ok := strings.Cut(arg, "/"); ok {
|
||||
instance := head[strings.LastIndex(head, "@")+1:]
|
||||
if c.instances[strings.ToLower(instance)] {
|
||||
if d, p, r := splitHostPath(rest); r {
|
||||
return head + "/" + d, p, true
|
||||
}
|
||||
}
|
||||
}
|
||||
return splitHostPath(arg)
|
||||
}
|
||||
|
||||
// splitHostPath mirrors scp's colon(): an argument is remote when a ':' comes
|
||||
// before any '/'. A leading "[" starts a bracketed IPv6 address.
|
||||
func splitHostPath(arg string) (dest, path string, remote bool) {
|
||||
if strings.HasPrefix(arg, "/") || strings.HasPrefix(arg, ".") {
|
||||
return "", "", false
|
||||
}
|
||||
inBracket := false
|
||||
for i := 0; i < len(arg); i++ {
|
||||
switch arg[i] {
|
||||
case '[':
|
||||
inBracket = true
|
||||
case ']':
|
||||
inBracket = false
|
||||
case '/':
|
||||
if !inBracket {
|
||||
return "", "", false
|
||||
}
|
||||
case ':':
|
||||
if !inBracket {
|
||||
return arg[:i], arg[i+1:], true
|
||||
}
|
||||
}
|
||||
}
|
||||
return "", "", false
|
||||
}
|
||||
|
||||
// HasForwardFlag reports whether -L, -R, or -D (or the -o equivalents) was given.
|
||||
func (c Client) HasForwardFlag(args []string) bool {
|
||||
return c.hasOption(args, 'L', "LocalForward") || c.hasOption(args, 'R', "RemoteForward") || c.hasOption(args, 'D', "DynamicForward")
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
package ssh
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
|
||||
)
|
||||
|
||||
func TestSFTPParse(t *testing.T) {
|
||||
// -l is a bandwidth limit and -s takes a value for sftp, unlike ssh.
|
||||
parsed := SFTP.Parse([]string{"-l", "100", "-s", "sub", "-P", "2222", "ops@web01:/var/log"})
|
||||
if parsed == nil || parsed.Host != "web01" || parsed.User != "ops" || parsed.Path != "/var/log" || parsed.DestIdx != 6 {
|
||||
t.Fatalf("got %+v", parsed)
|
||||
}
|
||||
if p := SFTP.Parse([]string{"prod/web01"}); p == nil || p.Host != "prod/web01" || p.Path != "" {
|
||||
t.Fatalf("instance-qualified host: %+v", p)
|
||||
}
|
||||
if !SFTP.HasPortFlag([]string{"-P", "2222", "web"}) || SFTP.HasPortFlag([]string{"-p", "web"}) {
|
||||
t.Fatal("sftp port flag is -P")
|
||||
}
|
||||
if SFTP.HasUserFlag([]string{"-l", "100", "web"}) || !SFTP.HasUserFlag([]string{"-o", "User=ops", "web"}) {
|
||||
t.Fatal("sftp has no -l user flag")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSCPOperands(t *testing.T) {
|
||||
ops, err := SCP.Operands([]string{"-X", "nrequests=8", "-r", "./local:dir", "/abs/file", "ops@web01:/tmp/", "web01:b"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
want := []Operand{{Idx: 5, User: "ops", Host: "web01", Path: "/tmp/"}, {Idx: 6, Host: "web01", Path: "b"}}
|
||||
if !reflect.DeepEqual(ops, want) {
|
||||
t.Fatalf("got %+v", ops)
|
||||
}
|
||||
if ops, _ := SCP.Operands([]string{"a.txt", "b.txt"}); len(ops) != 0 {
|
||||
t.Fatalf("local copy has remote operands: %+v", ops)
|
||||
}
|
||||
if _, err := SCP.Operands([]string{"web01:a", "db01:b"}); err == nil {
|
||||
t.Fatal("two remote hosts accepted")
|
||||
}
|
||||
if _, err := SCP.Operands([]string{"scp://web01/a", "."}); err == nil {
|
||||
t.Fatal("URI accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSFTPApply(t *testing.T) {
|
||||
args := []string{"-P", "2222", "ops@web01:/var/log"}
|
||||
opts := config.SSHOptions{ProxyJump: "jh", ExtraArgs: []string{"-A"}, Forwards: map[string]config.Forward{"web": {Local: "1:a:2"}}}
|
||||
got := SFTP.Apply(args, []int{2}, Host{Name: "web01", IP: "192.0.2.10"}, opts, WrapperFlags{ForwardArgs: []string{"-L", "1:a:2"}}).Args
|
||||
want := []string{"-P", "2222", "-J", "jh", "ops@192.0.2.10:/var/log"}
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("got %v, want %v (extra_args and forwards are ssh only)", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSCPApplyReplacesEveryOperandAndBracketsIPv6(t *testing.T) {
|
||||
args := []string{"a.txt", "web01:/tmp/", "ops@web01:b"}
|
||||
got := SCP.Apply(args, []int{1, 2}, Host{Name: "web01", IP: "2001:db8::1"}, config.SSHOptions{HostKeyChecking: "accept-new"}, WrapperFlags{}).Args
|
||||
want := []string{"-o", "StrictHostKeyChecking=accept-new", "a.txt", "[2001:db8::1]:/tmp/", "ops@[2001:db8::1]:b"}
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("got %v", got)
|
||||
}
|
||||
// sftp needs brackets even without a path; ssh never does.
|
||||
if got := SFTP.Apply([]string{"web01"}, []int{0}, Host{Name: "web01", IP: "2001:db8::1"}, config.SSHOptions{}, WrapperFlags{}).Args; got[0] != "[2001:db8::1]" {
|
||||
t.Fatalf("sftp: %v", got)
|
||||
}
|
||||
if got := apply([]string{"web01"}, config.SSHOptions{}, WrapperFlags{}); got.Args[0] != "192.0.2.10" {
|
||||
t.Fatalf("ssh: %v", got.Args)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSFTPTargetName(t *testing.T) {
|
||||
got := SFTP.Apply([]string{"web01:/srv"}, []int{0}, Host{Name: "web01.example.com", IP: "192.0.2.10"}, config.SSHOptions{Target: "name"}, WrapperFlags{}).Args
|
||||
want := []string{"-o", "HostName=192.0.2.10", "-o", "HostKeyAlias=web01.example.com", "web01.example.com:/srv"}
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("got %v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientUserAndPortArgs(t *testing.T) {
|
||||
if got := SSH.UserArgs("ops"); !reflect.DeepEqual(got, []string{"-l", "ops"}) {
|
||||
t.Fatal(got)
|
||||
}
|
||||
if got := SCP.UserArgs("ops"); !reflect.DeepEqual(got, []string{"-o", "User=ops"}) {
|
||||
t.Fatal(got)
|
||||
}
|
||||
if got := SFTP.PortArgs("2222"); !reflect.DeepEqual(got, []string{"-P", "2222"}) {
|
||||
t.Fatal(got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClientExtractWrapperFlags(t *testing.T) {
|
||||
// For scp, -X takes a value; for ssh it does not.
|
||||
flags, rest, err := SCP.ExtractWrapperFlags([]string{"-X", "--dry-run", "--dry-run", "a", "web:b"})
|
||||
if err != nil || !flags.DryRun || !reflect.DeepEqual(rest, []string{"-X", "--dry-run", "a", "web:b"}) {
|
||||
t.Fatalf("got %+v %v %v", flags, rest, err)
|
||||
}
|
||||
flags, rest, err = ExtractWrapperFlags([]string{"--forward", "web", "--forward=8080:localhost:80", "-v", "web01"})
|
||||
if err != nil || !reflect.DeepEqual(flags.Forwards, []string{"web", "8080:localhost:80"}) || !reflect.DeepEqual(rest, []string{"-v", "web01"}) {
|
||||
t.Fatalf("got %+v %v %v", flags, rest, err)
|
||||
}
|
||||
for _, args := range [][]string{{"--forward"}, {"--forward", "-L", "web"}} {
|
||||
if _, _, err := ExtractWrapperFlags(args); err == nil {
|
||||
t.Errorf("%v accepted", args)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestForwardArgs(t *testing.T) {
|
||||
available := map[string]config.Forward{"web": {Local: "8080:localhost:80"}, "socks": {Dynamic: "1080"}, "back": {Remote: "9000:localhost:9000"}}
|
||||
got, err := ForwardArgs([]string{"WEB", "socks", "back", "5432:db:5432", "127.0.0.1:3000:localhost:3000"}, available)
|
||||
want := []string{"-L", "8080:localhost:80", "-D", "1080", "-R", "9000:localhost:9000", "-L", "5432:db:5432", "-L", "127.0.0.1:3000:localhost:3000"}
|
||||
if err != nil || !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("got %v %v", got, err)
|
||||
}
|
||||
if _, err := ForwardArgs([]string{"db"}, available); err == nil || !strings.Contains(err.Error(), "back, socks, web") {
|
||||
t.Fatalf("unknown name: %v", err)
|
||||
}
|
||||
if _, err := ForwardArgs([]string{"db"}, nil); err == nil || !strings.Contains(err.Error(), "no forwards are configured") {
|
||||
t.Fatalf("no forwards: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyForwardsAndTunnel(t *testing.T) {
|
||||
flags := WrapperFlags{ForwardArgs: []string{"-L", "8080:localhost:80"}}
|
||||
if got := apply([]string{"web"}, config.SSHOptions{}, flags).Args; !reflect.DeepEqual(got, []string{"-L", "8080:localhost:80", "192.0.2.10"}) {
|
||||
t.Fatalf("forward: %v", got)
|
||||
}
|
||||
flags.Tunnel = true
|
||||
result := apply([]string{"web"}, config.SSHOptions{}, flags)
|
||||
want := []string{"-L", "8080:localhost:80", "-o", "ExitOnForwardFailure=yes", "-N", "192.0.2.10"}
|
||||
if !reflect.DeepEqual(result.Args, want) || !strings.Contains(result.Notice, "forwarding -L 8080:localhost:80 via web.example.com") {
|
||||
t.Fatalf("tunnel: %v %q", result.Args, result.Notice)
|
||||
}
|
||||
// The user's own ExitOnForwardFailure wins.
|
||||
if got := apply([]string{"-o", "ExitOnForwardFailure=no", "web"}, config.SSHOptions{}, flags).Args; strings.Contains(strings.Join(got, " "), "=yes") {
|
||||
t.Fatalf("overrode user option: %v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasForwardFlag(t *testing.T) {
|
||||
for args, want := range map[string]bool{"-L 1:a:2 web": true, "-vD1080 web": true, "-o RemoteForward=1_a_2 web": true, "-l ops web": false, "web -L 1:a:2": false} {
|
||||
if got := SSH.HasForwardFlag(strings.Fields(args)); got != want {
|
||||
t.Errorf("%q: got %v", args, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyInsertsOptionsBeforeDoubleDash(t *testing.T) {
|
||||
got := Apply([]string{"-v", "--", "web"}, 2, Host{Name: "web", IP: "192.0.2.10"}, config.SSHOptions{ProxyJump: "jh"}, WrapperFlags{}).Args
|
||||
if want := []string{"-v", "-J", "jh", "--", "192.0.2.10"}; !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("got %v, want %v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
// Instance-qualified hosts contain "/" before the ":" of host:path; only
|
||||
// configured instances make such an argument remote.
|
||||
func TestInstanceQualifiedHostPath(t *testing.T) {
|
||||
scp := SCP.WithInstances([]string{"prod"})
|
||||
ops, err := scp.Operands([]string{"a.txt", "ops@prod/web01:/tmp/", "dir/file:x"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if want := []Operand{{Idx: 1, User: "ops", Host: "prod/web01", Path: "/tmp/"}}; !reflect.DeepEqual(ops, want) {
|
||||
t.Fatalf("got %+v", ops)
|
||||
}
|
||||
got := scp.Apply([]string{"a.txt", "ops@prod/web01:/tmp/"}, []int{1}, Host{Name: "web01", IP: "192.0.2.1"}, config.SSHOptions{}, WrapperFlags{}).Args
|
||||
if want := []string{"a.txt", "ops@192.0.2.1:/tmp/"}; !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("apply: %v", got)
|
||||
}
|
||||
sftp := SFTP.WithInstances([]string{"prod"})
|
||||
if p := sftp.Parse([]string{"prod/web01:/var/log"}); p == nil || p.Host != "prod/web01" || p.Path != "/var/log" {
|
||||
t.Fatalf("sftp: %+v", p)
|
||||
}
|
||||
if ops, _ := SCP.Operands([]string{"prod/web01:/tmp/", "."}); len(ops) != 0 {
|
||||
t.Fatalf("unknown instance must stay local: %+v", ops)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package ssh
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"syscall"
|
||||
)
|
||||
|
||||
// Exec replaces the current process with the native ssh client via syscall.Exec.
|
||||
// All existing SSH configs, keys, and agent forwarding remain intact.
|
||||
func Exec(args []string) error { return SSH.Exec(args) }
|
||||
|
||||
// Exec replaces the current process with the client's binary.
|
||||
func (c Client) Exec(args []string) error {
|
||||
path, err := exec.LookPath(c.Name)
|
||||
if err != nil {
|
||||
return fmt.Errorf("%s not found in PATH: %w", c.Name, err)
|
||||
}
|
||||
argv := append([]string{c.Name}, args...)
|
||||
return syscall.Exec(path, argv, os.Environ())
|
||||
}
|
||||
@@ -0,0 +1,296 @@
|
||||
package ssh
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/netip"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
|
||||
)
|
||||
|
||||
// WrapperFlags are netssh's own long options. OpenSSH has no long options,
|
||||
// so these never collide with flags meant for ssh.
|
||||
type WrapperFlags struct {
|
||||
DryRun bool
|
||||
Jump string // --jump HOST overrides the configured jump host
|
||||
NoJump bool // --no-jump disables any jump host, including ~/.ssh/config
|
||||
Forwards []string // --forward NAME|SPEC, repeatable (ssh only)
|
||||
// ForwardArgs are Forwards resolved by ForwardArgs; Apply inserts them.
|
||||
ForwardArgs []string
|
||||
// Tunnel runs ssh without a remote command (-N), for netssh tunnel.
|
||||
Tunnel bool
|
||||
}
|
||||
|
||||
// ExtractWrapperFlags removes netssh's long options that appear before the
|
||||
// destination. Anything after the destination belongs to the remote command.
|
||||
func ExtractWrapperFlags(args []string) (WrapperFlags, []string, error) {
|
||||
return SSH.ExtractWrapperFlags(args)
|
||||
}
|
||||
|
||||
// ExtractWrapperFlags removes netssh's long options before the destination.
|
||||
func (c Client) ExtractWrapperFlags(args []string) (WrapperFlags, []string, error) {
|
||||
var flags WrapperFlags
|
||||
out := make([]string, 0, len(args))
|
||||
for i := 0; i < len(args); i++ {
|
||||
arg := args[i]
|
||||
switch {
|
||||
case arg == "--dry-run":
|
||||
flags.DryRun = true
|
||||
case arg == "--no-jump":
|
||||
flags.NoJump = true
|
||||
case arg == "--jump":
|
||||
if i+1 >= len(args) {
|
||||
return flags, nil, fmt.Errorf("--jump requires a host")
|
||||
}
|
||||
i++
|
||||
flags.Jump = args[i]
|
||||
case strings.HasPrefix(arg, "--jump="):
|
||||
flags.Jump = strings.TrimPrefix(arg, "--jump=")
|
||||
case arg == "--forward":
|
||||
if i+1 >= len(args) {
|
||||
return flags, nil, fmt.Errorf("--forward requires a name or spec")
|
||||
}
|
||||
i++
|
||||
flags.Forwards = append(flags.Forwards, args[i])
|
||||
case strings.HasPrefix(arg, "--forward="):
|
||||
flags.Forwards = append(flags.Forwards, strings.TrimPrefix(arg, "--forward="))
|
||||
case arg == "--" || !strings.HasPrefix(arg, "-") || len(arg) < 2:
|
||||
// Destination or end of options: keep the rest unchanged.
|
||||
return flags, append(out, args[i:]...), validateJump(flags)
|
||||
case strings.HasPrefix(arg, "--"):
|
||||
return flags, nil, fmt.Errorf("unknown option %s", arg)
|
||||
default:
|
||||
out = append(out, arg)
|
||||
// Keep the value of an ssh option such as -l USER together with it.
|
||||
if c.takesSeparateValue(arg) && i+1 < len(args) {
|
||||
i++
|
||||
out = append(out, args[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
return flags, out, validateJump(flags)
|
||||
}
|
||||
|
||||
func validateJump(flags WrapperFlags) error {
|
||||
if flags.Jump == "" && flags.NoJump {
|
||||
return nil
|
||||
}
|
||||
if flags.Jump != "" && flags.NoJump {
|
||||
return fmt.Errorf("--jump and --no-jump are mutually exclusive")
|
||||
}
|
||||
if strings.HasPrefix(flags.Jump, "-") {
|
||||
return fmt.Errorf("--jump: invalid host %q", flags.Jump)
|
||||
}
|
||||
for _, forward := range flags.Forwards {
|
||||
if forward == "" || strings.HasPrefix(forward, "-") || strings.ContainsAny(forward, " \t\n") {
|
||||
return fmt.Errorf("--forward: invalid value %q", forward)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
var adHocForward = regexp.MustCompile(`^([^\s:]+:)?[0-9]+(:[^\s]+:[0-9]+)?$`)
|
||||
|
||||
// ForwardArgs resolves forward names against the configured forwards. A value
|
||||
// that is no configured name but looks like a port or [bind:]port:host:port
|
||||
// is used as a local forward (-L).
|
||||
func ForwardArgs(names []string, available map[string]config.Forward) ([]string, error) {
|
||||
var out []string
|
||||
for _, name := range names {
|
||||
if forward, ok := available[strings.ToLower(name)]; ok {
|
||||
out = append(out, forward.Flag()...)
|
||||
continue
|
||||
}
|
||||
if strings.Contains(name, ":") && adHocForward.MatchString(name) {
|
||||
out = append(out, "-L", name)
|
||||
continue
|
||||
}
|
||||
known := make([]string, 0, len(available))
|
||||
for key := range available {
|
||||
known = append(known, key)
|
||||
}
|
||||
sort.Strings(known)
|
||||
if len(known) == 0 {
|
||||
return nil, fmt.Errorf("unknown forward %q; no forwards are configured for this host (ssh.forwards), or pass a spec such as 8080:localhost:80", name)
|
||||
}
|
||||
return nil, fmt.Errorf("unknown forward %q; available: %s", name, strings.Join(known, ", "))
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// takesSeparateValue reports whether a short option cluster ends with a flag
|
||||
// whose value is the next argument (e.g. "-l" or "-vp").
|
||||
func (c Client) takesSeparateValue(arg string) bool {
|
||||
for j := 1; j < len(arg); j++ {
|
||||
if c.withArg[arg[j]] {
|
||||
return j == len(arg)-1
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Host is a resolved NetBox host.
|
||||
type Host struct {
|
||||
Name string // NetBox name without the instance prefix
|
||||
IP string
|
||||
}
|
||||
|
||||
// Result is the final ssh argument list and an optional notice for stderr.
|
||||
type Result struct {
|
||||
Args []string
|
||||
Notice string
|
||||
}
|
||||
|
||||
var destinationName = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]*$`)
|
||||
|
||||
// ValidAddress reports whether addr is an IP address or a hostname. Addresses
|
||||
// come from NetBox and the cache file; one such as "-oProxyCommand=…" would be
|
||||
// read by ssh as an option and run a command.
|
||||
func ValidAddress(addr string) bool {
|
||||
if _, err := netip.ParseAddr(addr); err == nil {
|
||||
return !strings.ContainsAny(addr, " \t\r\n")
|
||||
}
|
||||
return destinationName.MatchString(addr)
|
||||
}
|
||||
|
||||
var plainHostname = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9._-]*[A-Za-z0-9])?$`)
|
||||
|
||||
// Apply replaces the destination at destIdx and inserts the configured -o
|
||||
// options directly before it. Explicit options given by the user come first,
|
||||
// and ssh uses the first -o value it obtains, so the user's choice wins.
|
||||
func Apply(args []string, destIdx int, host Host, opts config.SSHOptions, flags WrapperFlags) Result {
|
||||
return SSH.Apply(args, []int{destIdx}, host, opts, flags)
|
||||
}
|
||||
|
||||
// Apply replaces the host in every destination (several only for scp) and
|
||||
// inserts the configured options before the first one. extra_args and
|
||||
// forwards are ssh flags and apply to ssh only.
|
||||
func (c Client) Apply(args []string, dests []int, host Host, opts config.SSHOptions, flags WrapperFlags) Result {
|
||||
destIdx := dests[0]
|
||||
var inserted []string
|
||||
add := func(keyword, value string) {
|
||||
if !c.hasOption(args[:destIdx], 0, keyword) {
|
||||
inserted = append(inserted, "-o", keyword+"="+value)
|
||||
}
|
||||
}
|
||||
|
||||
dest := host.IP
|
||||
if opts.Target == "name" || opts.Target == "hostname" {
|
||||
if plainHostname.MatchString(host.Name) {
|
||||
dest = host.Name
|
||||
if opts.Target == "name" {
|
||||
add("HostName", host.IP)
|
||||
add("HostKeyAlias", host.Name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
userJump := c.hasOption(args[:destIdx], 'J', "ProxyJump") || c.hasOption(args[:destIdx], 0, "ProxyCommand")
|
||||
switch {
|
||||
case userJump:
|
||||
case flags.NoJump:
|
||||
inserted = append(inserted, "-o", "ProxyJump=none")
|
||||
case flags.Jump != "":
|
||||
inserted = append(inserted, "-J", flags.Jump)
|
||||
case opts.ProxyJump != "" && opts.ProxyJump != "none":
|
||||
inserted = append(inserted, "-J", opts.ProxyJump)
|
||||
}
|
||||
|
||||
var notice string
|
||||
switch opts.HostKeyChecking {
|
||||
case "strict":
|
||||
add("StrictHostKeyChecking", "yes")
|
||||
case "accept-new":
|
||||
add("StrictHostKeyChecking", "accept-new")
|
||||
case "off":
|
||||
if !hasOption(args[:destIdx], 0, "StrictHostKeyChecking") {
|
||||
add("StrictHostKeyChecking", "no")
|
||||
add("UserKnownHostsFile", "/dev/null")
|
||||
add("LogLevel", "ERROR")
|
||||
notice = "host key checking is disabled for this connection (ssh.host_key_checking: off)"
|
||||
}
|
||||
}
|
||||
|
||||
if opts.AddressFamily != "" && !c.hasBoolFlag(args[:destIdx], '4') && !c.hasBoolFlag(args[:destIdx], '6') {
|
||||
add("AddressFamily", opts.AddressFamily)
|
||||
}
|
||||
|
||||
keys := make([]string, 0, len(opts.Options))
|
||||
for key := range opts.Options {
|
||||
keys = append(keys, key)
|
||||
}
|
||||
sort.Strings(keys)
|
||||
for _, key := range keys {
|
||||
add(key, opts.Options[key])
|
||||
}
|
||||
|
||||
var extra []string
|
||||
if c.Name == SSH.Name {
|
||||
extra = opts.ExtraArgs
|
||||
inserted = append(inserted, flags.ForwardArgs...)
|
||||
if flags.Tunnel {
|
||||
add("ExitOnForwardFailure", "yes")
|
||||
inserted = append(inserted, "-N")
|
||||
forwards := strings.Join(flags.ForwardArgs, " ")
|
||||
if forwards == "" {
|
||||
forwards = "the given ports"
|
||||
}
|
||||
tunnel := fmt.Sprintf("forwarding %s via %s, press Ctrl+C to stop", forwards, host.Name)
|
||||
if notice == "" {
|
||||
notice = tunnel
|
||||
} else {
|
||||
notice += "\nnetssh: " + tunnel
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Extra arguments go first: short flags such as -4 or -A take the last
|
||||
// value given, so the user's own flags later on the line still win.
|
||||
// Options go before the first operand: scp stops reading options there,
|
||||
// and after "--" they would be taken as the destination.
|
||||
at := c.insertionPoint(args)
|
||||
replaced := c.replaceHost(args, dests, dest)
|
||||
out := make([]string, 0, len(extra)+len(replaced)+len(inserted))
|
||||
out = append(out, extra...)
|
||||
out = append(out, replaced[:at]...)
|
||||
out = append(out, inserted...)
|
||||
out = append(out, replaced[at:]...)
|
||||
return Result{Args: out, Notice: notice}
|
||||
}
|
||||
|
||||
// hasBoolFlag reports whether a flag without a value, such as -4, was given.
|
||||
func (c Client) hasBoolFlag(args []string, wanted byte) bool {
|
||||
for i := 0; i < len(args); i++ {
|
||||
arg := args[i]
|
||||
if arg == "--" || len(arg) < 2 || arg[0] != '-' {
|
||||
break
|
||||
}
|
||||
for j := 1; j < len(arg); j++ {
|
||||
if arg[j] == wanted {
|
||||
return true
|
||||
}
|
||||
if c.withArg[arg[j]] {
|
||||
if j == len(arg)-1 {
|
||||
i++
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Quote renders an argument list as a copy-pasteable POSIX shell command.
|
||||
func Quote(argv []string) string {
|
||||
quoted := make([]string, len(argv))
|
||||
for i, arg := range argv {
|
||||
if arg != "" && strings.Trim(arg, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@%+=:,./_-") == "" {
|
||||
quoted[i] = arg
|
||||
continue
|
||||
}
|
||||
quoted[i] = "'" + strings.ReplaceAll(arg, "'", `'\''`) + "'"
|
||||
}
|
||||
return strings.Join(quoted, " ")
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
package ssh
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config"
|
||||
)
|
||||
|
||||
func TestExtractWrapperFlags(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
args []string
|
||||
flags WrapperFlags
|
||||
rest []string
|
||||
}{
|
||||
{[]string{"--dry-run", "web"}, WrapperFlags{DryRun: true}, []string{"web"}},
|
||||
{[]string{"-l", "--dry-run", "--jump", "jh", "web"}, WrapperFlags{Jump: "jh"}, []string{"-l", "--dry-run", "web"}},
|
||||
{[]string{"--jump=jh", "-vp", "22", "web", "--dry-run"}, WrapperFlags{Jump: "jh"}, []string{"-vp", "22", "web", "--dry-run"}},
|
||||
{[]string{"--no-jump", "--", "web"}, WrapperFlags{NoJump: true}, []string{"--", "web"}},
|
||||
} {
|
||||
flags, rest, err := ExtractWrapperFlags(tc.args)
|
||||
if err != nil || !reflect.DeepEqual(flags, tc.flags) || !reflect.DeepEqual(rest, tc.rest) {
|
||||
t.Errorf("%v: got %+v %v %v", tc.args, flags, rest, err)
|
||||
}
|
||||
}
|
||||
for _, args := range [][]string{{"--jump"}, {"--jump", "-x", "web"}, {"--jump=a", "--no-jump", "web"}, {"--version-typo", "web"}} {
|
||||
if _, _, err := ExtractWrapperFlags(args); err == nil {
|
||||
t.Errorf("%v accepted", args)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func apply(args []string, opts config.SSHOptions, flags WrapperFlags) Result {
|
||||
return Apply(args, len(args)-1, Host{Name: "web.example.com", IP: "192.0.2.10"}, opts, flags)
|
||||
}
|
||||
|
||||
func TestApplyDefaultConnectsToIP(t *testing.T) {
|
||||
got := apply([]string{"-l", "root", "web"}, config.SSHOptions{}, WrapperFlags{})
|
||||
if want := []string{"-l", "root", "192.0.2.10"}; !reflect.DeepEqual(got.Args, want) {
|
||||
t.Fatalf("got %v", got.Args)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyTargetName(t *testing.T) {
|
||||
got := apply([]string{"admin@web"}, config.SSHOptions{Target: "name"}, WrapperFlags{})
|
||||
want := []string{"-o", "HostName=192.0.2.10", "-o", "HostKeyAlias=web.example.com", "admin@web.example.com"}
|
||||
if !reflect.DeepEqual(got.Args, want) {
|
||||
t.Fatalf("got %v", got.Args)
|
||||
}
|
||||
got = apply([]string{"web"}, config.SSHOptions{Target: "hostname"}, WrapperFlags{})
|
||||
if want := []string{"web.example.com"}; !reflect.DeepEqual(got.Args, want) {
|
||||
t.Fatalf("got %v", got.Args)
|
||||
}
|
||||
// Names that are not plain hostnames fall back to the IP address.
|
||||
got = Apply([]string{"x"}, 0, Host{Name: "rack 1 switch", IP: "192.0.2.1"}, config.SSHOptions{Target: "name"}, WrapperFlags{})
|
||||
if want := []string{"192.0.2.1"}; !reflect.DeepEqual(got.Args, want) {
|
||||
t.Fatalf("got %v", got.Args)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyJumpPrecedence(t *testing.T) {
|
||||
opts := config.SSHOptions{ProxyJump: "jh.example.com"}
|
||||
for _, tc := range []struct {
|
||||
args []string
|
||||
flags WrapperFlags
|
||||
want string
|
||||
}{
|
||||
{[]string{"web"}, WrapperFlags{}, "-J jh.example.com 192.0.2.10"},
|
||||
{[]string{"web"}, WrapperFlags{Jump: "other"}, "-J other 192.0.2.10"},
|
||||
{[]string{"web"}, WrapperFlags{NoJump: true}, "-o ProxyJump=none 192.0.2.10"},
|
||||
{[]string{"-J", "mine", "web"}, WrapperFlags{}, "-J mine 192.0.2.10"},
|
||||
{[]string{"-oProxyCommand=nc %h %p", "web"}, WrapperFlags{}, "-oProxyCommand=nc %h %p 192.0.2.10"},
|
||||
} {
|
||||
if got := strings.Join(apply(tc.args, opts, tc.flags).Args, " "); got != tc.want {
|
||||
t.Errorf("%v %+v: got %q, want %q", tc.args, tc.flags, got, tc.want)
|
||||
}
|
||||
}
|
||||
if got := apply([]string{"web"}, config.SSHOptions{ProxyJump: "none"}, WrapperFlags{}); len(got.Args) != 1 {
|
||||
t.Fatalf("proxy_jump none still jumps: %v", got.Args)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyHostKeyChecking(t *testing.T) {
|
||||
got := apply([]string{"web"}, config.SSHOptions{HostKeyChecking: "off"}, WrapperFlags{})
|
||||
want := "-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR 192.0.2.10"
|
||||
if strings.Join(got.Args, " ") != want || got.Notice == "" {
|
||||
t.Fatalf("got %v, notice %q", got.Args, got.Notice)
|
||||
}
|
||||
// An explicit user choice disables the whole "off" bundle.
|
||||
got = apply([]string{"-o", "StrictHostKeyChecking=yes", "web"}, config.SSHOptions{HostKeyChecking: "off"}, WrapperFlags{})
|
||||
if strings.Join(got.Args, " ") != "-o StrictHostKeyChecking=yes 192.0.2.10" || got.Notice != "" {
|
||||
t.Fatalf("user choice overridden: %v", got.Args)
|
||||
}
|
||||
got = apply([]string{"web"}, config.SSHOptions{HostKeyChecking: "accept-new"}, WrapperFlags{})
|
||||
if strings.Join(got.Args, " ") != "-o StrictHostKeyChecking=accept-new 192.0.2.10" {
|
||||
t.Fatalf("got %v", got.Args)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyOptionsAndExtraArgs(t *testing.T) {
|
||||
opts := config.SSHOptions{
|
||||
AddressFamily: "inet",
|
||||
ExtraArgs: []string{"-A"},
|
||||
Options: map[string]string{"serveraliveinterval": "60", "user": "ignored"},
|
||||
}
|
||||
got := apply([]string{"-o", "User=me", "web"}, opts, WrapperFlags{})
|
||||
want := "-A -o User=me -o AddressFamily=inet -o serveraliveinterval=60 192.0.2.10"
|
||||
if strings.Join(got.Args, " ") != want {
|
||||
t.Fatalf("got %q", strings.Join(got.Args, " "))
|
||||
}
|
||||
got = apply([]string{"-v6", "web"}, config.SSHOptions{AddressFamily: "inet"}, WrapperFlags{})
|
||||
if strings.Join(got.Args, " ") != "-v6 192.0.2.10" {
|
||||
t.Fatalf("address family overrides -6: %v", got.Args)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyKeepsRemoteCommand(t *testing.T) {
|
||||
got := Apply([]string{"web", "uptime", "-o", "x"}, 0, Host{Name: "web", IP: "192.0.2.1"}, config.SSHOptions{ProxyJump: "jh"}, WrapperFlags{})
|
||||
if want := []string{"-J", "jh", "192.0.2.1", "uptime", "-o", "x"}; !reflect.DeepEqual(got.Args, want) {
|
||||
t.Fatalf("got %v", got.Args)
|
||||
}
|
||||
}
|
||||
|
||||
func TestQuote(t *testing.T) {
|
||||
got := Quote([]string{"ssh", "-o", "ProxyCommand=nc %h %p", "it's", "", "a@b:22"})
|
||||
if want := `ssh -o 'ProxyCommand=nc %h %p' 'it'\''s' '' a@b:22`; got != want {
|
||||
t.Fatalf("got %s", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidAddress(t *testing.T) {
|
||||
for _, addr := range []string{"10.0.0.1", "fd00:30::60", "fe80::1%eth0", "web01", "web01.example.com", "db_1.lan"} {
|
||||
if !ValidAddress(addr) {
|
||||
t.Errorf("ValidAddress(%q) = false, want true", addr)
|
||||
}
|
||||
}
|
||||
// ssh would read the first as an option and run the command.
|
||||
for _, addr := range []string{"-oProxyCommand=touch /tmp/pwned", "-J", "", "a b", "host;id", "user@host", "host/path", "fe80::1%eth0 x", "$(id)"} {
|
||||
if ValidAddress(addr) {
|
||||
t.Errorf("ValidAddress(%q) = true, want false", addr)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user