[Update] 修改一些字段

pkg/auth/server.go

 package auth
 
 import (
-	gossh "golang.org/x/crypto/ssh"
+	"strings"
 
 	"github.com/gliderlabs/ssh"
+	gossh "golang.org/x/crypto/ssh"
+
+	"cocogo/pkg/cctx"
+	"cocogo/pkg/common"
+	"cocogo/pkg/logger"
+	"cocogo/pkg/service"
 )
 
+func checkAuth(ctx ssh.Context, password, publicKey string) (ok bool) {
+	username := ctx.User()
+	remoteAddr := strings.Split(ctx.RemoteAddr().String(), ":")[0]
+	user := service.Authenticate(username, password, publicKey, remoteAddr, "T")
+	authMethod := "publickey"
+	action := "Accepted"
+	if password != "" {
+		authMethod = "password"
+	}
+	if user == nil {
+		action = "Failed"
+		ok = false
+	} else {
+		ctx.SetValue(cctx.ContextKeyUser, user)
+	}
+	logger.Infof("%s %s for %s from %s", action, authMethod, username, remoteAddr)
+	return false
+}
+
 func CheckUserPassword(ctx ssh.Context, password string) bool {
-	return true
+	ok := checkAuth(ctx, password, "")
+	return ok
 }
 
 func CheckUserPublicKey(ctx ssh.Context, key ssh.PublicKey) bool {
-	//username := ctx.User()
-	//b := key.Marshal()
-	//publicKeyBase64 := common.Base64Encode(string(b))
-	//remoteAddr := ctx.RemoteAddr().String()
-	//authUser, err := service.CheckAuth(username, "", publicKeyBase64, remoteAddr, "T")
-	//if err != nil {
-	//	return false
-	//}
-	//ctx.SetValue("LoginUser", authUser)
-	return true
+	b := key.Marshal()
+	publicKey := common.Base64Encode(string(b))
+	return checkAuth(ctx, "", publicKey)
 }
 
 func CheckMFA(ctx ssh.Context, challenger gossh.KeyboardInteractiveChallenge) bool {
-	return true
+	return false
 }

pkg/cctx/context.go

+package cctx
+
+import (
+	"context"
+	"github.com/gliderlabs/ssh"
+
+	"cocogo/pkg/sdk"
+)
+
+type contextKey struct {
+	name string
+}
+
+var (
+	ContextKeyUser       = &contextKey{"User"}
+	ContextKeyAsset      = &contextKey{"asset"}
+	ContextKeySystemUser = &contextKey{"systemUser"}
+	ContextKeySSHSession = &contextKey{"sshSession"}
+	ContextKeyRemoteAddr = &contextKey{"remoteAddr"}
+	ContextKeyLocalAddr  = &contextKey{"localAddr"}
+	ContextKeySSHCtx     = &contextKey{"sshCtx"}
+)
+
+type Context interface {
+	context.Context
+	User() *sdk.User
+	Asset() *sdk.Asset
+	SystemUser() *sdk.SystemUser
+	SSHSession() *ssh.Session
+	SSHCtx() *ssh.Context
+	SetValue(key, value interface{})
+}
+
+type CocoContext struct {
+	context.Context
+}
+
+func (ctx *CocoContext) User() *sdk.User {
+	return ctx.Value(ContextKeyUser).(*sdk.User)
+}
+
+func (ctx *CocoContext) Asset() *sdk.Asset {
+	return ctx.Value(ContextKeyAsset).(*sdk.Asset)
+}
+
+func (ctx *CocoContext) SystemUser() *sdk.SystemUser {
+	return ctx.Value(ContextKeySystemUser).(*sdk.SystemUser)
+}
+
+func (ctx *CocoContext) SSHSession() *ssh.Session {
+	return ctx.Value(ContextKeySSHSession).(*ssh.Session)
+}
+
+func (ctx *CocoContext) SSHCtx() *ssh.Context {
+	return ctx.Value(ContextKeySSHCtx).(*ssh.Context)
+}
+
+func (ctx *CocoContext) SetValue(key, value interface{}) {
+	ctx.Context = context.WithValue(ctx.Context, key, value)
+}
+
+func applySessionMetadata(ctx *CocoContext, sess ssh.Session) {
+	ctx.SetValue(ContextKeySSHSession, &sess)
+	ctx.SetValue(ContextKeySSHCtx, sess.Context())
+	//ctx.SetValue(ContextKeyUser, &sdk.User{Username: sess.User()})
+	ctx.SetValue(ContextKeyLocalAddr, sess.LocalAddr())
+}
+
+func NewContext(sess ssh.Session) (*CocoContext, context.CancelFunc) {
+	sshCtx, cancel := context.WithCancel(sess.Context())
+	ctx := &CocoContext{sshCtx}
+	applySessionMetadata(ctx, sess)
+	return ctx, cancel
+}

pkg/context/context.go

-package context
-
-import (
-	"context"
-	"github.com/gliderlabs/ssh"
-
-	"cocogo/pkg/model"
-)
-
-type UserContext struct {
-	context.Context
-
-	SessionCtx ssh.Context
-	User       model.User
-	Asset      sdk.Asset
-	SystemUser model.SystemUser
-}

pkg/logger/logger.go

@@ -29,18 +29,34 @@ func Debug(args ...interface{}) {
 	logger.Debug(args...)
 }
 
+func Debugf(format string, args ...interface{}) {
+	logger.Debugf(format, args...)
+}
+
 func Info(args ...interface{}) {
 	logger.Info(args...)
 }
 
+func Infof(format string, args ...interface{}) {
+	logger.Infof(format, args...)
+}
+
 func Warn(args ...interface{}) {
 	logger.Warn(args...)
 }
 
+func Warnf(format string, args ...interface{}) {
+	logger.Warnf(format, args...)
+}
+
 func Error(args ...interface{}) {
 	logger.Error(args...)
 }
 
+func Errorf(format string, args ...interface{}) {
+	logger.Errorf(format, args...)
+}
+
 func Panic(args ...interface{}) {
 	logrus.Panic(args...)
 }

pkg/sdk/users.go

@@ -57,14 +57,14 @@ func CheckAuth(username, password, publicKey, remoteAddr, loginType string) (use
 //	return result.User, nil
 //}
 //
-//func (s *Service) CheckSSHPassword(ctx ssh.Value, password string) bool {
+//func (s *Service) CheckSSHPassword(cctx ssh.Value, password string) bool {
 //
-//	username := ctx.User()
-//	remoteAddr := ctx.RemoteAddr().String()
+//	username := cctx.User()
+//	remoteAddr := cctx.RemoteAddr().String()
 //	authUser, err := s.CheckAuth(username, password, "", remoteAddr, "T")
 //	if err != nil {
 //		return false
 //	}
-//	ctx.SetValue("LoginUser", authUser)
+//	cctx.SetValue("LoginUser", authUser)
 //	return true
 //}

pkg/sdk/users_model.go

@@ -20,8 +20,8 @@ package sdk
 
 type User struct {
 	Id       string `json:"id"`
+	Username string `json:"username"`
 	Name     string `json:"name"`
-	UserName string `json:"username"`
 	Email    string `json:"email"`
 
 	Role     string `json:"role"`

pkg/service/users.go

@@ -2,10 +2,14 @@ package service
 
 import "cocogo/pkg/sdk"
 
-func Authenticate(username, password, public_key, remote_addr, login_type string) {
-	return
+func Authenticate(username, password, publicKey, remoteAddr, loginType string) *sdk.User {
+	return &sdk.User{Id: "1111111111", Username: "admin", Name: "广宏伟"}
 }
 
 func GetUserProfile(userId string) (user sdk.User) {
 	return
 }
+
+func LoadUserByUsername(user *sdk.User) {
+
+}

pkg/sshd/handler/session.go

 package handler
 
 import (
+	"context"
 	//"context"
 	//"strconv"
-
-	"cocogo/pkg/model"
-	"cocogo/pkg/proxy"
-	"cocogo/pkg/sdk"
-	"cocogo/pkg/service"
-	"cocogo/pkg/userhome"
-	"context"
 	"fmt"
-	"github.com/olekukonko/tablewriter"
-	"github.com/xlab/treeprint"
-
 	//"encoding/json"
 	//"fmt"
 	"io"
 	"strconv"
 	"strings"
-
 	//"strings"
-
 	//"strconv"
-	//"strings"
 	"sync"
 	//"time"
 
@@ -31,19 +19,46 @@ import (
 	//"github.com/olekukonko/tablewriter"
 	//"github.com/satori/go.uuid"
 	//"github.com/xlab/treeprint"
+	"github.com/olekukonko/tablewriter"
+	"github.com/xlab/treeprint"
 	"golang.org/x/crypto/ssh/terminal"
 
+	"cocogo/pkg/cctx"
 	"cocogo/pkg/logger"
+	"cocogo/pkg/model"
+	"cocogo/pkg/proxy"
+	"cocogo/pkg/sdk"
+	"cocogo/pkg/service"
+	"cocogo/pkg/userhome"
 	//"cocogo/pkg/proxy"
-	//"cocogo/pkg/service"
 	//"cocogo/pkg/transport"
 	//"cocogo/pkg/userhome"
 )
 
+func SessionHandler(sess ssh.Session) {
+	_, _, ptyOk := sess.Pty()
+	if ptyOk {
+		ctx, cancel := cctx.NewContext(sess)
+		handler := &InteractiveHandler{
+			sess: sess,
+			user: ctx.User(),
+			term: terminal.NewTerminal(sess, "Opt> "),
+		}
+		logger.Infof("New connection from: %s %s", sess.User(), sess.RemoteAddr().String())
+		handler.Dispatch(ctx)
+		cancel()
+	} else {
+		_, err := io.WriteString(sess, "No PTY requested.\n")
+		if err != nil {
+			return
+		}
+	}
+}
+
 type InteractiveHandler struct {
 	sess         ssh.Session
 	term         *terminal.Terminal
-	user         sdk.User
+	user         *sdk.User
 	assets       model.AssetList
 	searchResult model.AssetList
 	nodes        model.NodeList
@@ -69,7 +84,7 @@ func (i *InteractiveHandler) watchWinSizeChange(winCh <-chan ssh.Window) {
 	for {
 		select {
 		case <-ctx.Done():
-			logger.Info("ctx done")
+			logger.Info("Ctx done")
 			return
 		case win, ok := <-winCh:
 			if !ok {
@@ -81,7 +96,7 @@ func (i *InteractiveHandler) watchWinSizeChange(winCh <-chan ssh.Window) {
 	}
 }
 
-func (i *InteractiveHandler) Dispatch() {
+func (i *InteractiveHandler) Dispatch(ctx cctx.Context) {
 	i.preDispatch()
 	_, winCh, _ := i.sess.Pty()
 	for {
@@ -416,21 +431,3 @@ func ConstructAssetNodeTree(assetNodes []sdk.Node) treeprint.Tree {
 	}
 	return tree
 }
-
-func SessionHandler(sess ssh.Session) {
-	_, _, ptyOk := sess.Pty()
-	if ptyOk {
-		handler := &InteractiveHandler{
-			sess: sess,
-			term: terminal.NewTerminal(sess, "Opt> "),
-		}
-
-		logger.Info("Accept one session")
-		handler.Dispatch()
-	} else {
-		_, err := io.WriteString(sess, "No PTY requested.\n")
-		if err != nil {
-			return
-		}
-	}
-}

pkg/userhome/userhome.go

@@ -64,7 +64,7 @@ func (r *userSessionHome) AddConnection(c Conn) {
 
 		select {
 		case <-ctx.Done():
-			log.Info(" user conn ctx done")
+			log.Info(" user conn cctx done")
 			return
 		default:
 			copyBuf := make([]byte, nr)