v1
Test / test (push) Successful in 3m36s
Release / release (push) Successful in 7m31s

This commit is contained in:
Sebastian Unterschütz committed 2026-11-17 19:00:44 +01:00
commit 8d4915543e
132 files changed
+20628

No files matched your search

+155
View File
@@ -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, ""
}
+46
View File
@@ -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)
}
})
}
}
+199
View File
@@ -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")
}
}
+162
View File
@@ -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")
}
+180
View File
@@ -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)
}
}
+22
View File
@@ -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())
}
+296
View File
@@ -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, " ")
}
+144
View File
@@ -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)
}
}
}