v1
This commit is contained in:
commit
8d4915543e
132 files changed
+20628
No files matched your search
@@ -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, " ")
|
||||
}
|
||||
Reference in new issue
Block a user