Errors

Author: jaksi

conn.go

@@ -2,19 +2,36 @@ package sshutils
 
 import (
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"net"
 	"strconv"
 
 	"golang.org/x/crypto/ssh"
 )
 
-var (
-	ErrEstablishSSH = errors.New("failed to establish SSH connection")
-	ErrSendRequest  = errors.New("failed to send request")
-	ErrChannelOpen  = errors.New("failed to open channel")
-)
+type EstablishError struct {
+	err error
+}
+
+func (e EstablishError) Error() string {
+	return fmt.Sprintf("failed to establish SSH connection: %v", e.err)
+}
+
+type SendRequestError struct {
+	err error
+}
+
+func (e SendRequestError) Error() string {
+	return fmt.Sprintf("failed to send request: %v", e.err)
+}
+
+type ChannelOpenError struct {
+	err error
+}
+
+func (e ChannelOpenError) Error() string {
+	return fmt.Sprintf("failed to open channel: %v", e.err)
+}
 
 type Listener struct {
 	net.Listener
@@ -29,7 +46,7 @@ func (listener *Listener) Accept() (*Conn, error) {
 	sshConn, sshNewChannels, sshRequests, err := ssh.NewServerConn(conn, &listener.config)
 	if err != nil {
 		conn.Close()
-		return nil, fmt.Errorf("%w: %v", ErrEstablishSSH, err)
+		return nil, EstablishError{err}
 	}
 	return handleConn(sshConn, sshNewChannels, sshRequests), nil
 }
@@ -52,7 +69,7 @@ type Conn struct {
 func (conn *Conn) RawChannel(name string, payload []byte) (*Channel, error) {
 	sshChannel, sshRequests, err := conn.Conn.OpenChannel(name, payload)
 	if err != nil {
-		return nil, fmt.Errorf("%w: %v", ErrChannelOpen, err)
+		return nil, ChannelOpenError{err}
 	}
 	return handleChannel(sshChannel, sshRequests, conn, name), nil
 }
@@ -68,7 +85,7 @@ func (conn *Conn) Channel(name string, payload Payload) (*Channel, error) {
 func (conn *Conn) RawRequest(name string, wantReply bool, payload []byte) (bool, []byte, error) {
 	accepted, reply, err := conn.SendRequest(name, wantReply, payload)
 	if err != nil {
-		return false, nil, fmt.Errorf("%w: %v", ErrSendRequest, err)
+		return false, nil, SendRequestError{err}
 	}
 	return accepted, reply, nil
 }
@@ -93,7 +110,7 @@ func Dial(address string, config *ssh.ClientConfig) (*Conn, error) {
 	sshConn, sshNewChannels, sshRequests, err := ssh.NewClientConn(conn, address, config)
 	if err != nil {
 		conn.Close()
-		return nil, fmt.Errorf("%w: %v", ErrEstablishSSH, err)
+		return nil, EstablishError{err}
 	}
 	return handleConn(sshConn, sshNewChannels, sshRequests), nil
 }
@@ -138,7 +155,7 @@ type NewChannel struct {
 func (newChannel *NewChannel) AcceptChannel() (*Channel, error) {
 	sshChannel, sshRequests, err := newChannel.Accept()
 	if err != nil {
-		return nil, fmt.Errorf("%w: %v", ErrChannelOpen, err)
+		return nil, ChannelOpenError{err}
 	}
 	return handleChannel(sshChannel, sshRequests, newChannel.conn, newChannel.ChannelType()), nil
 }
@@ -178,7 +195,7 @@ func (channel *Channel) ConnMetadata() ssh.ConnMetadata {
 func (channel *Channel) RawRequest(name string, wantReply bool, payload []byte) (bool, error) {
 	accepted, err := channel.SendRequest(name, wantReply, payload)
 	if err != nil {
-		return false, fmt.Errorf("%w: %v", ErrSendRequest, err)
+		return false, SendRequestError{err}
 	}
 	return accepted, nil
 }

host_keys.go

@@ -7,7 +7,6 @@ import (
 	"crypto/rsa"
 	"crypto/x509"
 	"encoding/pem"
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -20,11 +19,29 @@ const (
 	hostKeyFilePerms = 0o600
 )
 
-var (
-	ErrInvalidKey         = errors.New("invalid key")
-	ErrInvalidKeyFile     = errors.New("invalid key file")
-	ErrUnsupportedKeyType = errors.New("unsupported key type")
-)
+type InvalidKeyError struct {
+	err error
+}
+
+func (e InvalidKeyError) Error() string {
+	return fmt.Sprintf("invalid key: %v", e.err)
+}
+
+type InvalidKeyFileError struct {
+	err error
+}
+
+func (e InvalidKeyFileError) Error() string {
+	return fmt.Sprintf("invalid key file: %v", e.err)
+}
+
+type UnsupportedKeyTypeError struct {
+	t KeyType
+}
+
+func (e UnsupportedKeyTypeError) Error() string {
+	return fmt.Sprintf("unsupported key type: %v", e.t)
+}
 
 type KeyType int
 
@@ -59,7 +76,7 @@ func (key *HostKey) String() string {
 func hostKeyFromKey(key interface{}) (*HostKey, error) {
 	signer, err := ssh.NewSignerFromKey(key)
 	if err != nil {
-		return nil, fmt.Errorf("%w: %v", ErrInvalidKey, err)
+		return nil, InvalidKeyError{err}
 	}
 	return &HostKey{
 		Signer: signer,
@@ -78,42 +95,42 @@ func GenerateHostKey(rand io.Reader, t KeyType) (*HostKey, error) {
 	case Ed25519:
 		_, key, err = ed25519.GenerateKey(rand)
 	default:
-		return nil, fmt.Errorf("%w: %v", ErrUnsupportedKeyType, t)
+		return nil, UnsupportedKeyTypeError{t}
 	}
 	if err != nil {
-		return nil, fmt.Errorf("%w: %v", ErrInvalidKey, err)
+		return nil, InvalidKeyError{err}
 	}
 	return hostKeyFromKey(key)
 }
 
 func LoadHostKey(fileName string) (*HostKey, error) {
 	keyBytes, err := os.ReadFile(fileName)
 	if err != nil {
-		return nil, fmt.Errorf("%w: %v", ErrInvalidKeyFile, err)
+		return nil, InvalidKeyFileError{err}
 	}
 	key, err := ssh.ParseRawPrivateKey(keyBytes)
 	if err != nil {
-		return nil, fmt.Errorf("%w: %v", ErrInvalidKeyFile, err)
+		return nil, InvalidKeyFileError{err}
 	}
 	return hostKeyFromKey(key)
 }
 
 func (key *HostKey) Save(fileName string) error {
 	file, err := os.OpenFile(fileName, os.O_WRONLY|os.O_CREATE|os.O_EXCL, hostKeyFilePerms) //nolint:nosnakecase
 	if err != nil {
-		return fmt.Errorf("%w: %v", ErrInvalidKeyFile, err)
+		return InvalidKeyFileError{err}
 	}
 	defer file.Close()
 	keyBytes, err := x509.MarshalPKCS8PrivateKey(key.key)
 	if err != nil {
-		return fmt.Errorf("%w: %v", ErrInvalidKey, err)
+		return InvalidKeyError{err}
 	}
 	if _, err = file.Write(pem.EncodeToMemory(&pem.Block{
 		Type:    "PRIVATE KEY",
 		Headers: nil,
 		Bytes:   keyBytes,
 	})); err != nil {
-		return fmt.Errorf("%w: %v", ErrInvalidKeyFile, err)
+		return InvalidKeyFileError{err}
 	}
 	return nil
 }