13870686685

Committed 15 Mar 2025 07:17AM UTC coverage: 11.936% (-5.5%) from 17.445%

Build # 13870686685

Build Type

push

github

Committed by

nixpig

Commit Message

chore: start wiring up cli

Run Details

0 of 461 new or added lines in 7 files covered. (0.0%)

4 existing lines in 2 files now uncovered.

127 of 1064 relevant lines covered (11.94%)

0.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/pkg/ssh/client.go

package ssh

import (
        "fmt"
        "io"
        "net"
        "os"

        "github.com/skeema/knownhosts"
        gossh "golang.org/x/crypto/ssh"
        "golang.org/x/crypto/ssh/agent"
)

const Client = "SSH-2.0-Syringe"

type SSHClient struct {
        client *gossh.Client
}

func (s *SSHClient) Close() error {
        if err := s.client.Close(); err != nil {
                return err
        }

        return nil
}

func (s *SSHClient) Run(cmd string, out io.Writer) error {
        session, err := s.client.NewSession()
        if err != nil {
                return fmt.Errorf("new session: %w", err)
        }

        defer session.Close()

        output, err := session.CombinedOutput(cmd)
        if err != nil {
                if _, err := out.Write(output); err != nil {
                        return fmt.Errorf("write to output: %w", err)
                }
                return fmt.Errorf("combined output: %w", err)
        }

        if _, err := out.Write(output); err != nil {
                return fmt.Errorf("last write: %w", err)
        }

        return nil
}

func NewSSHClient(
        host string,
        port int,
        username string,
        authMethod gossh.AuthMethod,
        knownHosts string,
) (*SSHClient, error) {
        sshConfig := &gossh.ClientConfig{
                User:          username,
                ClientVersion: Client,
                Auth:          []gossh.AuthMethod{authMethod},

                HostKeyCallback: gossh.HostKeyCallback(
                        func(hostname string, remote net.Addr, key gossh.PublicKey) error {
                                kh, err := knownhosts.New(knownHosts)
                                if err != nil {
                                        return fmt.Errorf("failed to open knownhosts file: %w", err)
                                }

                                err = kh(fmt.Sprintf("%s:%d", host, port), remote, key)

                                if knownhosts.IsHostKeyChanged(err) {
                                        return fmt.Errorf("remote host identification has changed which may indicate a MITM attack: %w", err)
                                }

                                if knownhosts.IsHostUnknown(err) {
                                        khHandle, err := os.OpenFile(knownHosts, os.O_APPEND|os.O_WRONLY, 0600)
                                        if err != nil {
                                                return fmt.Errorf("failed to open known hosts file for writing: %w", err)
                                        }

                                        defer khHandle.Close()

                                        if err := knownhosts.WriteKnownHost(khHandle, hostname, remote, key); err != nil {
                                                return fmt.Errorf("failed to write to known hosts: %w", err)
                                        }
                                }

                                return nil
                        },
                ),
        }

        conn, err := gossh.Dial("tcp", fmt.Sprintf("%s:%d", host, port), sshConfig)
        if err != nil {
                return nil, fmt.Errorf("dial ssh: %w", err)
        }

        return &SSHClient{
                conn,
        }, nil
}

func NewSSHAgentClient(sshAuthSock string) (agent.ExtendedAgent, error) {
        sshAgent, err := net.Dial("unix", sshAuthSock)
        if err != nil {
                return nil, fmt.Errorf("dial agent auth sock: %w", err)
        }

        sshAgentClient := agent.NewClient(sshAgent)

        return sshAgentClient, nil
}

1	package ssh
2
3	import (
4	"fmt"
5	"io"
6	"net"
7	"os"
8
9	"github.com/skeema/knownhosts"
10	gossh "golang.org/x/crypto/ssh"
11	"golang.org/x/crypto/ssh/agent"
12	)
13
14	const Client = "SSH-2.0-Syringe"
15
16	type SSHClient struct {
17	client *gossh.Client
18	}
19
NEW 20	func (s *SSHClient) Close() error {	×
NEW 21	if err := s.client.Close(); err != nil {	×
NEW 22	return err	×
NEW 23	}	×
24
NEW 25	return nil	×
26	}
27
NEW 28	func (s *SSHClient) Run(cmd string, out io.Writer) error {	×
NEW 29	session, err := s.client.NewSession()	×
NEW 30	if err != nil {	×
NEW 31	return fmt.Errorf("new session: %w", err)	×
NEW 32	}	×
33
NEW 34	defer session.Close()	×
NEW 35		×
NEW 36	output, err := session.CombinedOutput(cmd)	×
NEW 37	if err != nil {	×
NEW 38	if _, err := out.Write(output); err != nil {	×
NEW 39	return fmt.Errorf("write to output: %w", err)	×
NEW 40	}	×
NEW 41	return fmt.Errorf("combined output: %w", err)	×
42	}
43
NEW 44	if _, err := out.Write(output); err != nil {	×
NEW 45	return fmt.Errorf("last write: %w", err)	×
NEW 46	}	×
47
NEW 48	return nil	×
49	}
50
51	func NewSSHClient(
52	host string,
53	port int,
54	username string,
55	authMethod gossh.AuthMethod,
56	knownHosts string,
NEW 57	) (*SSHClient, error) {	×
NEW 58	sshConfig := &gossh.ClientConfig{	×
NEW 59	User: username,	×
NEW 60	ClientVersion: Client,	×
NEW 61	Auth: []gossh.AuthMethod{authMethod},	×
NEW 62		×
NEW 63	HostKeyCallback: gossh.HostKeyCallback(	×
NEW 64	func(hostname string, remote net.Addr, key gossh.PublicKey) error {	×
NEW 65	kh, err := knownhosts.New(knownHosts)	×
NEW 66	if err != nil {	×
NEW 67	return fmt.Errorf("failed to open knownhosts file: %w", err)	×
NEW 68	}	×
69
NEW 70	err = kh(fmt.Sprintf("%s:%d", host, port), remote, key)	×
NEW 71		×
NEW 72	if knownhosts.IsHostKeyChanged(err) {	×
NEW 73	return fmt.Errorf("remote host identification has changed which may indicate a MITM attack: %w", err)	×
NEW 74	}	×
75
NEW 76	if knownhosts.IsHostUnknown(err) {	×
NEW 77	khHandle, err := os.OpenFile(knownHosts, os.O_APPEND\|os.O_WRONLY, 0600)	×
NEW 78	if err != nil {	×
NEW 79	return fmt.Errorf("failed to open known hosts file for writing: %w", err)	×
NEW 80	}	×
81
NEW 82	defer khHandle.Close()	×
NEW 83		×
NEW 84	if err := knownhosts.WriteKnownHost(khHandle, hostname, remote, key); err != nil {	×
NEW 85	return fmt.Errorf("failed to write to known hosts: %w", err)	×
NEW 86	}	×
87	}
88
NEW 89	return nil	×
90	},
91	),
92	}
93
NEW 94	conn, err := gossh.Dial("tcp", fmt.Sprintf("%s:%d", host, port), sshConfig)	×
NEW 95	if err != nil {	×
NEW 96	return nil, fmt.Errorf("dial ssh: %w", err)	×
NEW 97	}	×
98
NEW 99	return &SSHClient{	×
NEW 100	conn,	×
NEW 101	}, nil	×
102	}
103
NEW 104	func NewSSHAgentClient(sshAuthSock string) (agent.ExtendedAgent, error) {	×
NEW 105	sshAgent, err := net.Dial("unix", sshAuthSock)	×
NEW 106	if err != nil {	×
NEW 107	return nil, fmt.Errorf("dial agent auth sock: %w", err)	×
NEW 108	}	×
109
NEW 110	sshAgentClient := agent.NewClient(sshAgent)	×
NEW 111		×
NEW 112	return sshAgentClient, nil	×
113	}

nixpig / syringe.sh / 13870686685

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous