Bring the sftp server code into the package itself

sftp/errors.go

@@ -0,0 +1,19 @@
+package sftp
+
+type fxerr uint32
+
+const (
+	// Extends the default SFTP server to return a quota exceeded error to the client.
+	//
+	// @see https://tools.ietf.org/id/draft-ietf-secsh-filexfer-13.txt
+	ErrSshQuotaExceeded = fxerr(15)
+)
+
+func (e fxerr) Error() string {
+	switch e {
+	case ErrSshQuotaExceeded:
+		return "Quota Exceeded"
+	default:
+		return "Failure"
+	}
+}

sftp/handler.go

@@ -0,0 +1,380 @@
+package sftp
+
+import (
+	"github.com/apex/log"
+	"github.com/patrickmn/go-cache"
+	"github.com/pkg/errors"
+	"github.com/pkg/sftp"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+type FileSystem struct {
+	UUID        string
+	Permissions []string
+	ReadOnly    bool
+	User        SftpUser
+	Cache       *cache.Cache
+
+	PathValidator func(fs FileSystem, p string) (string, error)
+	HasDiskSpace  func(fs FileSystem) bool
+
+	logger *log.Entry
+	lock   sync.Mutex
+}
+
+func (fs FileSystem) buildPath(p string) (string, error) {
+	return fs.PathValidator(fs, p)
+}
+
+const (
+	PermissionFileRead        = "file.read"
+	PermissionFileReadContent = "file.read-content"
+	PermissionFileCreate      = "file.create"
+	PermissionFileUpdate      = "file.update"
+	PermissionFileDelete      = "file.delete"
+)
+
+// Fileread creates a reader for a file on the system and returns the reader back.
+func (fs FileSystem) Fileread(request *sftp.Request) (io.ReaderAt, error) {
+	// Check first if the user can actually open and view a file. This permission is named
+	// really poorly, but it is checking if they can read. There is an addition permission,
+	// "save-files" which determines if they can write that file.
+	if !fs.can(PermissionFileReadContent) {
+		return nil, sftp.ErrSshFxPermissionDenied
+	}
+
+	p, err := fs.buildPath(request.Filepath)
+	if err != nil {
+		return nil, sftp.ErrSshFxNoSuchFile
+	}
+
+	fs.lock.Lock()
+	defer fs.lock.Unlock()
+
+	if _, err := os.Stat(p); os.IsNotExist(err) {
+		return nil, sftp.ErrSshFxNoSuchFile
+	} else if err != nil {
+		fs.logger.WithField("error", errors.WithStack(err)).Error("error while processing file stat")
+
+		return nil, sftp.ErrSshFxFailure
+	}
+
+	file, err := os.Open(p)
+	if err != nil {
+		fs.logger.WithField("source", p).WithField("error", errors.WithStack(err)).Error("could not open file for reading")
+		return nil, sftp.ErrSshFxFailure
+	}
+
+	return file, nil
+}
+
+// Filewrite handles the write actions for a file on the system.
+func (fs FileSystem) Filewrite(request *sftp.Request) (io.WriterAt, error) {
+	if fs.ReadOnly {
+		return nil, sftp.ErrSshFxOpUnsupported
+	}
+
+	p, err := fs.buildPath(request.Filepath)
+	if err != nil {
+		return nil, sftp.ErrSshFxNoSuchFile
+	}
+
+	var l = fs.logger.WithField("source", p)
+
+	// If the user doesn't have enough space left on the server it should respond with an
+	// error since we won't be letting them write this file to the disk.
+	if !fs.HasDiskSpace(fs) {
+		return nil, ErrSshQuotaExceeded
+	}
+
+	fs.lock.Lock()
+	defer fs.lock.Unlock()
+
+	stat, statErr := os.Stat(p)
+	// If the file doesn't exist we need to create it, as well as the directory pathway
+	// leading up to where that file will be created.
+	if os.IsNotExist(statErr) {
+		// This is a different pathway than just editing an existing file. If it doesn't exist already
+		// we need to determine if this user has permission to create files.
+		if !fs.can(PermissionFileCreate) {
+			return nil, sftp.ErrSshFxPermissionDenied
+		}
+
+		// Create all of the directories leading up to the location where this file is being created.
+		if err := os.MkdirAll(filepath.Dir(p), 0755); err != nil {
+			l.WithFields(log.Fields{
+				"path": filepath.Dir(p),
+				"error": errors.WithStack(err),
+			}).Error("error making path for file")
+
+			return nil, sftp.ErrSshFxFailure
+		}
+
+		file, err := os.Create(p)
+		if err != nil {
+			l.WithField("error", errors.WithStack(err)).Error("failed to create file")
+
+			return nil, sftp.ErrSshFxFailure
+		}
+
+		// Not failing here is intentional. We still made the file, it is just owned incorrectly
+		// and will likely cause some issues.
+		if err := os.Chown(p, fs.User.Uid, fs.User.Gid); err != nil {
+			l.WithField("error", errors.WithStack(err)).Warn("failed to set permissions on file")
+		}
+
+		return file, nil
+	}
+
+	// If the stat error isn't about the file not existing, there is some other issue
+	// at play and we need to go ahead and bail out of the process.
+	if statErr != nil {
+		l.WithField("error", errors.WithStack(statErr)).Error("encountered error performing file stat")
+
+		return nil, sftp.ErrSshFxFailure
+	}
+
+	// If we've made it here it means the file already exists and we don't need to do anything
+	// fancy to handle it. Just pass over the request flags so the system knows what the end
+	// goal with the file is going to be.
+	//
+	// But first, check that the user has permission to save modified files.
+	if !fs.can(PermissionFileUpdate) {
+		return nil, sftp.ErrSshFxPermissionDenied
+	}
+
+	// Not sure this would ever happen, but lets not find out.
+	if stat.IsDir() {
+		return nil, sftp.ErrSshFxOpUnsupported
+	}
+
+	file, err := os.Create(p)
+	if err != nil {
+		// Prevent errors if the file is deleted between the stat and this call.
+		if os.IsNotExist(err) {
+			return nil, sftp.ErrSSHFxNoSuchFile
+		}
+
+		l.WithField("flags", request.Flags).WithField("error", errors.WithStack(err)).Error("failed to open existing file on system")
+		return nil, sftp.ErrSshFxFailure
+	}
+
+	// Not failing here is intentional. We still made the file, it is just owned incorrectly
+	// and will likely cause some issues.
+	if err := os.Chown(p, fs.User.Uid, fs.User.Gid); err != nil {
+		l.WithField("error", errors.WithStack(err)).Warn("error chowning file")
+	}
+
+	return file, nil
+}
+
+// Filecmd hander for basic SFTP system calls related to files, but not anything to do with reading
+// or writing to those files.
+func (fs FileSystem) Filecmd(request *sftp.Request) error {
+	if fs.ReadOnly {
+		return sftp.ErrSshFxOpUnsupported
+	}
+
+	p, err := fs.buildPath(request.Filepath)
+	if err != nil {
+		return sftp.ErrSshFxNoSuchFile
+	}
+
+	var l = fs.logger.WithField("source", p)
+
+	var target string
+	// If a target is provided in this request validate that it is going to the correct
+	// location for the server. If it is not, return an operation unsupported error. This
+	// is maybe not the best error response, but its not wrong either.
+	if request.Target != "" {
+		target, err = fs.buildPath(request.Target)
+		if err != nil {
+			return sftp.ErrSshFxOpUnsupported
+		}
+	}
+
+	switch request.Method {
+	case "Setstat":
+		if !fs.can(PermissionFileUpdate) {
+			return sftp.ErrSshFxPermissionDenied
+		}
+
+		var mode os.FileMode = 0644
+		// If the client passed a valid file permission use that, otherwise use the
+		// default of 0644 set above.
+		if request.Attributes().FileMode().Perm() != 0000 {
+			mode = request.Attributes().FileMode().Perm()
+		}
+
+		// Force directories to be 0755
+		if request.Attributes().FileMode().IsDir() {
+			mode = 0755
+		}
+
+		if err := os.Chmod(p, mode); err != nil {
+			if os.IsNotExist(err) {
+				return sftp.ErrSSHFxNoSuchFile
+			}
+
+			l.WithField("error", errors.WithStack(err)).Error("failed to perform setstat on item")
+			return sftp.ErrSSHFxFailure
+		}
+		return nil
+	case "Rename":
+		if !fs.can(PermissionFileUpdate) {
+			return sftp.ErrSSHFxPermissionDenied
+		}
+
+		if err := os.Rename(p, target); err != nil {
+			if os.IsNotExist(err) {
+				return sftp.ErrSSHFxNoSuchFile
+			}
+
+			l.WithField("target", target).WithField("error", errors.WithStack(err)).Error("failed to rename file")
+
+			return sftp.ErrSshFxFailure
+		}
+
+		break
+	case "Rmdir":
+		if !fs.can(PermissionFileDelete) {
+			return sftp.ErrSshFxPermissionDenied
+		}
+
+		if err := os.RemoveAll(p); err != nil {
+			l.WithField("error", errors.WithStack(err)).Error("failed to remove directory")
+
+			return sftp.ErrSshFxFailure
+		}
+
+		return sftp.ErrSshFxOk
+	case "Mkdir":
+		if !fs.can(PermissionFileCreate) {
+			return sftp.ErrSshFxPermissionDenied
+		}
+
+		if err := os.MkdirAll(p, 0755); err != nil {
+			l.WithField("error", errors.WithStack(err)).Error("failed to create directory")
+
+			return sftp.ErrSshFxFailure
+		}
+
+		break
+	case "Symlink":
+		if !fs.can(PermissionFileCreate) {
+			return sftp.ErrSshFxPermissionDenied
+		}
+
+		if err := os.Symlink(p, target); err != nil {
+			l.WithField("target", target).WithField("error", errors.WithStack(err)).Error("failed to create symlink")
+
+			return sftp.ErrSshFxFailure
+		}
+
+		break
+	case "Remove":
+		if !fs.can(PermissionFileDelete) {
+			return sftp.ErrSshFxPermissionDenied
+		}
+
+		if err := os.Remove(p); err != nil {
+			if os.IsNotExist(err) {
+				return sftp.ErrSSHFxNoSuchFile
+			}
+
+			l.WithField("error", errors.WithStack(err)).Error("failed to remove a file")
+
+			return sftp.ErrSshFxFailure
+		}
+
+		return sftp.ErrSshFxOk
+	default:
+		return sftp.ErrSshFxOpUnsupported
+	}
+
+	var fileLocation = p
+	if target != "" {
+		fileLocation = target
+	}
+
+	// Not failing here is intentional. We still made the file, it is just owned incorrectly
+	// and will likely cause some issues. There is no logical check for if the file was removed
+	// because both of those cases (Rmdir, Remove) have an explicit return rather than break.
+	if err := os.Chown(fileLocation, fs.User.Uid, fs.User.Gid); err != nil {
+		l.WithField("error", errors.WithStack(err)).Warn("error chowning file")
+	}
+
+	return sftp.ErrSshFxOk
+}
+
+// Filelist is the handler for SFTP filesystem list calls. This will handle calls to list the contents of
+// a directory as well as perform file/folder stat calls.
+func (fs FileSystem) Filelist(request *sftp.Request) (sftp.ListerAt, error) {
+	p, err := fs.buildPath(request.Filepath)
+	if err != nil {
+		return nil, sftp.ErrSshFxNoSuchFile
+	}
+
+	switch request.Method {
+	case "List":
+		if !fs.can(PermissionFileRead) {
+			return nil, sftp.ErrSshFxPermissionDenied
+		}
+
+		files, err := ioutil.ReadDir(p)
+		if err != nil {
+			fs.logger.WithField("error", errors.WithStack(err)).Error("error while listing directory")
+
+			return nil, sftp.ErrSshFxFailure
+		}
+
+		return ListerAt(files), nil
+	case "Stat":
+		if !fs.can(PermissionFileRead) {
+			return nil, sftp.ErrSshFxPermissionDenied
+		}
+
+		s, err := os.Stat(p)
+		if os.IsNotExist(err) {
+			return nil, sftp.ErrSshFxNoSuchFile
+		} else if err != nil {
+			fs.logger.WithField("source", p).WithField("error", errors.WithStack(err)).Error("error performing stat on file")
+
+			return nil, sftp.ErrSshFxFailure
+		}
+
+		return ListerAt([]os.FileInfo{s}), nil
+	default:
+		// Before adding readlink support we need to evaluate any potential security risks
+		// as a result of navigating around to a location that is outside the home directory
+		// for the logged in user. I don't forsee it being much of a problem, but I do want to
+		// check it out before slapping some code here. Until then, we'll just return an
+		// unsupported response code.
+		return nil, sftp.ErrSshFxOpUnsupported
+	}
+}
+
+// Determines if a user has permission to perform a specific action on the SFTP server. These
+// permissions are defined and returned by the Panel API.
+func (fs FileSystem) can(permission string) bool {
+	// Server owners and super admins have their permissions returned as '[*]' via the Panel
+	// API, so for the sake of speed do an initial check for that before iterating over the
+	// entire array of permissions.
+	if len(fs.Permissions) == 1 && fs.Permissions[0] == "*" {
+		return true
+	}
+
+	// Not the owner or an admin, loop over the permissions that were returned to determine
+	// if they have the passed permission.
+	for _, p := range fs.Permissions {
+		if p == permission {
+			return true
+		}
+	}
+
+	return false
+}

sftp/lister.go

@@ -0,0 +1,22 @@
+package sftp
+
+import (
+	"io"
+	"os"
+)
+
+type ListerAt []os.FileInfo
+
+// Returns the number of entries copied and an io.EOF error if we made it to the end of the file list.
+// Take a look at the pkg/sftp godoc for more information about how this function should work.
+func (l ListerAt) ListAt(f []os.FileInfo, offset int64) (int, error) {
+	if offset >= int64(len(l)) {
+		return 0, io.EOF
+	}
+
+	if n := copy(f, l[offset:]); n < len(f) {
+		return n, io.EOF
+	} else {
+		return n, nil
+	}
+}

sftp/server.go

@@ -1,118 +1,238 @@
 package sftp
 
 import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+	"fmt"
 	"github.com/apex/log"
-	"github.com/pkg/errors"
-	"github.com/pterodactyl/sftp-server"
+	"github.com/patrickmn/go-cache"
+	"github.com/pkg/sftp"
 	"github.com/pterodactyl/wings/api"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/server"
-	"go.uber.org/zap"
-	"regexp"
+	"golang.org/x/crypto/ssh"
+	"io"
+	"io/ioutil"
+	"net"
+	"os"
+	"path"
+	"strings"
+	"time"
 )
 
-func Initialize(config *config.Configuration) error {
-	c := &sftp_server.Server{
-		User: sftp_server.SftpUser{
-			Uid: config.System.User.Uid,
-			Gid: config.System.User.Gid,
-		},
-		Settings: sftp_server.Settings{
-			BasePath:         config.System.Data,
-			ReadOnly:         config.System.Sftp.ReadOnly,
-			BindAddress:      config.System.Sftp.Address,
-			BindPort:         config.System.Sftp.Port,
-		},
-		CredentialValidator: validateCredentials,
-		PathValidator: validatePath,
-		DiskSpaceValidator: validateDiskSpace,
-	}
+type Settings struct {
+	BasePath    string
+	ReadOnly    bool
+	BindPort    int
+	BindAddress string
+}
 
-	if err := sftp_server.New(c); err != nil {
-		return err
-	}
+type SftpUser struct {
+	Uid int
+	Gid int
+}
 
-	c.ConfigureLogger(func() *zap.SugaredLogger {
-		return zap.S().Named("sftp")
-	})
+type Server struct {
+	cache *cache.Cache
 
-	// Initialize the SFTP server in a background thread since this is
-	// a long running operation.
-	go func(instance *sftp_server.Server) {
-		if err := c.Initialize(); err != nil {
-			log.WithField("subsystem", "sftp").WithField("error", errors.WithStack(err)).Error("failed to initialize SFTP subsystem")
-		}
-	}(c)
+	Settings Settings
+	User     SftpUser
+
+	PathValidator      func(fs FileSystem, p string) (string, error)
+	DiskSpaceValidator func(fs FileSystem) bool
+
+	// Validator function that is called when a user connects to the server. This should
+	// check against whatever system is desired to confirm if the given username and password
+	// combination is valid. If so, should return an authentication response.
+	CredentialValidator func(r api.SftpAuthRequest) (*api.SftpAuthResponse, error)
+}
+
+// Create a new server configuration instance.
+func New(c *Server) error {
+	c.cache = cache.New(5*time.Minute, 10*time.Minute)
 
 	return nil
 }
 
-func validatePath(fs sftp_server.FileSystem, p string) (string, error) {
-	s := server.GetServers().Find(func(server *server.Server) bool {
-		return server.Id() == fs.UUID
-	})
+// Initialize the SFTP server and add a persistent listener to handle inbound SFTP connections.
+func (c *Server) Initialize() error {
+	serverConfig := &ssh.ServerConfig{
+		NoClientAuth: false,
+		MaxAuthTries: 6,
+		PasswordCallback: func(conn ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) {
+			resp, err := c.CredentialValidator(api.SftpAuthRequest{
+				User:          conn.User(),
+				Pass:          string(pass),
+				IP:            conn.RemoteAddr().String(),
+				SessionID:     conn.SessionID(),
+				ClientVersion: conn.ClientVersion(),
+			})
 
-	if s == nil {
-		return "", errors.New("no server found with that UUID")
+			if err != nil {
+				return nil, err
+			}
+
+			sshPerm := &ssh.Permissions{
+				Extensions: map[string]string{
+					"uuid":        resp.Server,
+					"user":        conn.User(),
+					"permissions": strings.Join(resp.Permissions, ","),
+				},
+			}
+
+			return sshPerm, nil
+		},
 	}
 
-	return s.Filesystem.SafePath(p)
-}
-
-func validateDiskSpace(fs sftp_server.FileSystem) bool {
-	s := server.GetServers().Find(func(server *server.Server) bool {
-		return server.Id() == fs.UUID
-	})
-
-	if s == nil {
-		return false
+	if _, err := os.Stat(path.Join(c.Settings.BasePath, ".sftp/id_rsa")); os.IsNotExist(err) {
+		if err := c.generatePrivateKey(); err != nil {
+			return err
+		}
+	} else if err != nil {
+		return err
 	}
 
-	return s.Filesystem.HasSpaceAvailable()
-}
-
-var validUsernameRegexp = regexp.MustCompile(`^(?i)(.+)\.([a-z0-9]{8})$`)
-
-// Validates a set of credentials for a SFTP login aganist Pterodactyl Panel and returns
-// the server's UUID if the credentials were valid.
-func validateCredentials(c sftp_server.AuthenticationRequest) (*sftp_server.AuthenticationResponse, error) {
-	log.WithFields(log.Fields{"subsystem": "sftp", "username": c.User}).Debug("validating credentials for SFTP connection")
-
-	f := log.Fields{
-		"subsystem": "sftp",
-		"username":  c.User,
-		"ip":        c.IP,
-	}
-
-	// If the username doesn't meet the expected format that the Panel would even recognize just go ahead
-	// and bail out of the process here to avoid accidentially brute forcing the panel if a bot decides
-	// to connect to spam username attempts.
-	if !validUsernameRegexp.MatchString(c.User) {
-		log.WithFields(f).Warn("failed to validate user credentials (invalid format)")
-
-		return nil, new(sftp_server.InvalidCredentialsError)
-	}
-
-	resp, err := api.NewRequester().ValidateSftpCredentials(c)
+	privateBytes, err := ioutil.ReadFile(path.Join(c.Settings.BasePath, ".sftp/id_rsa"))
 	if err != nil {
-		if sftp_server.IsInvalidCredentialsError(err) {
-			log.WithFields(f).Warn("failed to validate user credentials (invalid username or password)")
-		} else {
-			log.WithFields(f).Error("encountered an error while trying to validate user credentials")
+		return err
+	}
+
+	private, err := ssh.ParsePrivateKey(privateBytes)
+	if err != nil {
+		return err
+	}
+
+	// Add our private key to the server configuration.
+	serverConfig.AddHostKey(private)
+
+	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", c.Settings.BindAddress, c.Settings.BindPort))
+	if err != nil {
+		return err
+	}
+
+	log.WithField("host", c.Settings.BindAddress).WithField("port", c.Settings.BindPort).Info("sftp subsystem listening for connections")
+
+	for {
+		conn, _ := listener.Accept()
+		if conn != nil {
+			go c.AcceptInboundConnection(conn, serverConfig)
+		}
+	}
+}
+
+// Handles an inbound connection to the instance and determines if we should serve the request
+// or not.
+func (c Server) AcceptInboundConnection(conn net.Conn, config *ssh.ServerConfig) {
+	defer conn.Close()
+
+	// Before beginning a handshake must be performed on the incoming net.Conn
+	sconn, chans, reqs, err := ssh.NewServerConn(conn, config)
+	if err != nil {
+		return
+	}
+	defer sconn.Close()
+
+	go ssh.DiscardRequests(reqs)
+
+	for newChannel := range chans {
+		// If its not a session channel we just move on because its not something we
+		// know how to handle at this point.
+		if newChannel.ChannelType() != "session" {
+			newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
+			continue
 		}
 
-		return resp, err
+		channel, requests, err := newChannel.Accept()
+		if err != nil {
+			continue
+		}
+
+		// Channels have a type that is dependent on the protocol. For SFTP this is "subsystem"
+		// with a payload that (should) be "sftp". Discard anything else we receive ("pty", "shell", etc)
+		go func(in <-chan *ssh.Request) {
+			for req := range in {
+				ok := false
+
+				switch req.Type {
+				case "subsystem":
+					if string(req.Payload[4:]) == "sftp" {
+						ok = true
+					}
+				}
+
+				req.Reply(ok, nil)
+			}
+		}(requests)
+
+		// Configure the user's home folder for the rest of the request cycle.
+		if sconn.Permissions.Extensions["uuid"] == "" {
+			continue
+		}
+
+		// Create a new handler for the currently logged in user's server.
+		fs := c.createHandler(sconn)
+
+		// Create the server instance for the channel using the filesystem we created above.
+		server := sftp.NewRequestServer(channel, fs)
+
+		if err := server.Serve(); err == io.EOF {
+			server.Close()
+		}
 	}
-
-	s := server.GetServers().Find(func(server *server.Server) bool {
-		return server.Id() == resp.Server
-	})
-
-	if s == nil {
-		return resp, errors.New("no matching server with UUID found")
-	}
-
-	s.Log().WithFields(f).Debug("credentials successfully validated and matched user to server instance")
-
-	return resp, err
+}
+
+// Creates a new SFTP handler for a given server. The directory argument should
+// be the base directory for a server. All actions done on the server will be
+// relative to that directory, and the user will not be able to escape out of it.
+func (c Server) createHandler(sc *ssh.ServerConn) sftp.Handlers {
+	p := FileSystem{
+		UUID:          sc.Permissions.Extensions["uuid"],
+		Permissions:   strings.Split(sc.Permissions.Extensions["permissions"], ","),
+		ReadOnly:      c.Settings.ReadOnly,
+		Cache:         c.cache,
+		User:          c.User,
+		HasDiskSpace:  c.DiskSpaceValidator,
+		PathValidator: c.PathValidator,
+		logger: log.WithFields(log.Fields{
+			"subsystem": "sftp",
+			"username":  sc.User(),
+			"ip":        sc.RemoteAddr(),
+		}),
+	}
+
+	return sftp.Handlers{
+		FileGet:  p,
+		FilePut:  p,
+		FileCmd:  p,
+		FileList: p,
+	}
+}
+
+// Generates a private key that will be used by the SFTP server.
+func (c Server) generatePrivateKey() error {
+	key, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll(path.Join(c.Settings.BasePath, ".sftp"), 0755); err != nil {
+		return err
+	}
+
+	o, err := os.OpenFile(path.Join(c.Settings.BasePath, ".sftp/id_rsa"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+	if err != nil {
+		return err
+	}
+	defer o.Close()
+
+	pkey := &pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(key),
+	}
+
+	if err := pem.Encode(o, pkey); err != nil {
+		return err
+	}
+
+	return nil
 }

sftp/sftp.go

@@ -0,0 +1,97 @@
+package sftp
+
+import (
+	"github.com/apex/log"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/wings/api"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/server"
+)
+
+var noMatchingServerError = errors.New("no matching server with that UUID was found")
+
+func Initialize(config config.SystemConfiguration) error {
+	s := &Server{
+		User: SftpUser{
+			Uid: config.User.Uid,
+			Gid: config.User.Gid,
+		},
+		Settings: Settings{
+			BasePath:    config.Data,
+			ReadOnly:    config.Sftp.ReadOnly,
+			BindAddress: config.Sftp.Address,
+			BindPort:    config.Sftp.Port,
+		},
+		CredentialValidator: validateCredentials,
+		PathValidator:       validatePath,
+		DiskSpaceValidator:  validateDiskSpace,
+	}
+
+	if err := New(s); err != nil {
+		return errors.WithStack(err)
+	}
+
+	// Initialize the SFTP server in a background thread since this is
+	// a long running operation.
+	go func(s *Server) {
+		if err := s.Initialize(); err != nil {
+			log.WithField("subsystem", "sftp").WithField("error", errors.WithStack(err)).Error("failed to initialize SFTP subsystem")
+		}
+	}(s)
+
+	return nil
+}
+
+func validatePath(fs FileSystem, p string) (string, error) {
+	s := server.GetServers().Find(func(server *server.Server) bool {
+		return server.Id() == fs.UUID
+	})
+
+	if s == nil {
+		return "", noMatchingServerError
+	}
+
+	return s.Filesystem.SafePath(p)
+}
+
+func validateDiskSpace(fs FileSystem) bool {
+	s := server.GetServers().Find(func(server *server.Server) bool {
+		return server.Id() == fs.UUID
+	})
+
+	if s == nil {
+		return false
+	}
+
+	return s.Filesystem.HasSpaceAvailable()
+}
+
+// Validates a set of credentials for a SFTP login aganist Pterodactyl Panel and returns
+// the server's UUID if the credentials were valid.
+func validateCredentials(c api.SftpAuthRequest) (*api.SftpAuthResponse, error) {
+	f := log.Fields{"subsystem": "sftp", "username": c.User, "ip": c.IP}
+
+	log.WithFields(f).Debug("validating credentials for SFTP connection")
+	resp, err := api.NewRequester().ValidateSftpCredentials(c)
+	if err != nil {
+		if api.IsInvalidCredentialsError(err) {
+			log.WithFields(f).Warn("failed to validate user credentials (invalid username or password)")
+		} else {
+			log.WithFields(f).Error("encountered an error while trying to validate user credentials")
+		}
+
+		return resp, err
+	}
+
+	s := server.GetServers().Find(func(server *server.Server) bool {
+		return server.Id() == resp.Server
+	})
+
+	if s == nil {
+		return resp, noMatchingServerError
+	}
+
+	s.Log().WithFields(f).Debug("credentials successfully validated and matched user to server instance")
+
+	return resp, err
+}