493 lines
14 KiB
Go
493 lines
14 KiB
Go
package auth
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/url"
|
|
"strings"
|
|
|
|
authsvc "server/services/auth"
|
|
|
|
"server/models"
|
|
"server/pkg/jwtutil"
|
|
|
|
beego "github.com/beego/beego/v2/server/web"
|
|
"github.com/beego/beego/v2/server/web/context"
|
|
)
|
|
|
|
type AuthLoginController struct {
|
|
beego.Controller
|
|
}
|
|
|
|
func (c *AuthLoginController) serveJSON(data map[string]interface{}) {
|
|
c.Data["json"] = data
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *AuthLoginController) LoginPage() {
|
|
clientID := strings.TrimSpace(c.GetString("client_id"))
|
|
redirect := c.GetString("redirect")
|
|
step := c.GetString("step")
|
|
errMsg := c.GetString("error")
|
|
|
|
// 已登录且已选企业:直接放行,无需再输密码。
|
|
// 即使 redirect 丢失也要放行到业务站首页,否则会一直停留在登录页,
|
|
// 表现为「登录后还是跳回登录界面」。
|
|
sid := strings.TrimSpace(c.Ctx.GetCookie(sessionCookieName))
|
|
if sid != "" && step != "tenant" {
|
|
if session, err := authsvc.GetSession(sid); err == nil {
|
|
if session.Tid == authsvc.PendingTenantID {
|
|
target := "/auth/login?step=tenant&client_id=" + url.QueryEscape(clientID) +
|
|
"&redirect=" + url.QueryEscape(redirect)
|
|
c.Redirect(target, 302)
|
|
return
|
|
}
|
|
if back := safeBackURL(clientID, redirect); back != "" {
|
|
c.Redirect(back, 302)
|
|
return
|
|
}
|
|
} else {
|
|
clearSessionCookieForCtx(c.Ctx)
|
|
sid = ""
|
|
}
|
|
}
|
|
|
|
tenants := make([]authsvc.TenantOption, 0)
|
|
if sid != "" {
|
|
if session, err := authsvc.GetSession(sid); err == nil {
|
|
list, _ := authsvc.ListTenantOptions(session.IdentityID)
|
|
tenants = list
|
|
if len(tenants) == 1 && step == "tenant" {
|
|
if _, _, err := authsvc.ChooseTenant(sid, tenants[0].Tid, clientID); err == nil {
|
|
if back := safeBackURL(clientID, redirect); back != "" {
|
|
c.Redirect(back, 302)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
} else if step == "tenant" {
|
|
clearSessionCookieForCtx(c.Ctx)
|
|
c.Redirect("/auth/login?client_id="+url.QueryEscape(clientID), 302)
|
|
return
|
|
}
|
|
}
|
|
|
|
c.Data["ClientID"] = clientID
|
|
c.Data["Redirect"] = redirect
|
|
c.Data["Step"] = step
|
|
c.Data["Error"] = errMsg
|
|
c.Data["Tenants"] = tenants
|
|
c.Data["Notice"] = c.GetString("notice")
|
|
c.Data["WarnMsg"] = c.GetString("warn")
|
|
|
|
brand := models.GetPlatformSiteTagMap()
|
|
loginTitle := strings.TrimSpace(brand["login_title"])
|
|
if loginTitle == "" {
|
|
loginTitle = "一次登录,全平台通行"
|
|
}
|
|
loginSubtitle := strings.TrimSpace(brand["login_subtitle"])
|
|
if loginSubtitle == "" {
|
|
loginSubtitle = "基于 OIDC / OAuth 2.0 的统一身份底座,为所有接入应用提供安全、一致的登录体验。"
|
|
}
|
|
c.Data["LoginTitle"] = loginTitle
|
|
c.Data["LoginSubtitle"] = loginSubtitle
|
|
c.Data["LoginLogo"] = strings.TrimSpace(brand["login_logo"])
|
|
c.Data["LoginBg"] = strings.TrimSpace(brand["login_bg"])
|
|
|
|
loginEnabled := func(tag string) bool {
|
|
return strings.TrimSpace(brand[tag]) != "0"
|
|
}
|
|
pwdOn, smsOn, qrOn := loginEnabled("login_pwd_enabled"), loginEnabled("login_sms_enabled"), loginEnabled("login_qr_enabled")
|
|
c.Data["LoginPwdOn"] = pwdOn
|
|
c.Data["LoginSmsOn"] = smsOn
|
|
c.Data["LoginQrOn"] = qrOn
|
|
c.Data["LoginDisabled"] = !(pwdOn || smsOn || qrOn)
|
|
defaultTab := "account"
|
|
if !pwdOn {
|
|
if smsOn {
|
|
defaultTab = "sms"
|
|
} else {
|
|
defaultTab = "qr"
|
|
}
|
|
}
|
|
c.Data["LoginDefaultTab"] = defaultTab
|
|
methodCount := 0
|
|
for _, on := range []bool{pwdOn, smsOn, qrOn} {
|
|
if on {
|
|
methodCount++
|
|
}
|
|
}
|
|
c.Data["LoginShowTabs"] = methodCount > 1
|
|
|
|
c.TplName = "auth/login.tpl"
|
|
}
|
|
|
|
func (c *AuthLoginController) LoginSubmit() {
|
|
var req struct {
|
|
Account string `json:"account"`
|
|
Password string `json:"password"`
|
|
ClientID string `json:"client_id"`
|
|
Redirect string `json:"redirect"`
|
|
DeviceID string `json:"device_id"`
|
|
CaptchaID string `json:"captcha_id"`
|
|
LotNumber string `json:"lot_number"`
|
|
PassToken string `json:"pass_token"`
|
|
GenTime string `json:"gen_time"`
|
|
CaptchaOutput string `json:"captcha_output"`
|
|
}
|
|
|
|
body := c.Ctx.Input.RequestBody
|
|
if len(body) == 0 {
|
|
var err error
|
|
body, err = io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil || len(body) == 0 {
|
|
c.serveJSON(map[string]interface{}{"code": 400, "msg": "参数错误"})
|
|
return
|
|
}
|
|
}
|
|
if err := json.Unmarshal(body, &req); err != nil {
|
|
c.serveJSON(map[string]interface{}{"code": 400, "msg": "参数错误"})
|
|
return
|
|
}
|
|
if strings.TrimSpace(req.Account) == "" || req.Password == "" {
|
|
c.serveJSON(map[string]interface{}{"code": 400, "msg": "请输入账号和密码"})
|
|
return
|
|
}
|
|
|
|
loginTags := models.GetPlatformSiteTagMap()
|
|
pwdOff := strings.TrimSpace(loginTags["login_pwd_enabled"]) == "0"
|
|
allOff := pwdOff &&
|
|
strings.TrimSpace(loginTags["login_sms_enabled"]) == "0" &&
|
|
strings.TrimSpace(loginTags["login_qr_enabled"]) == "0"
|
|
if allOff {
|
|
c.serveJSON(map[string]interface{}{"code": 403, "msg": "登录功能已关闭,请联系管理员"})
|
|
return
|
|
}
|
|
if pwdOff {
|
|
c.serveJSON(map[string]interface{}{"code": 403, "msg": "账号密码登录已关闭,请使用其他登录方式"})
|
|
return
|
|
}
|
|
|
|
if strings.TrimSpace(req.ClientID) != "yz-miniapp" {
|
|
if err := authsvc.VerifyLoginCaptcha(0, authsvc.CaptchaResult{
|
|
CaptchaID: req.CaptchaID,
|
|
LotNumber: req.LotNumber,
|
|
PassToken: req.PassToken,
|
|
GenTime: req.GenTime,
|
|
CaptchaOutput: req.CaptchaOutput,
|
|
}); err != nil {
|
|
c.serveJSON(map[string]interface{}{"code": 400, "msg": err.Error()})
|
|
return
|
|
}
|
|
}
|
|
|
|
clientIP := c.Ctx.Input.IP()
|
|
userAgent := c.Ctx.Request.UserAgent()
|
|
|
|
result, err := authsvc.PasswordLogin(req.Account, req.Password, req.ClientID, clientIP, userAgent)
|
|
if err != nil {
|
|
c.serveJSON(map[string]interface{}{"code": 401, "msg": err.Error()})
|
|
return
|
|
}
|
|
|
|
setSessionCookieForCtx(c.Ctx, result.Tokens.Sid)
|
|
|
|
if result.NeedChooseTenant {
|
|
c.serveJSON(map[string]interface{}{
|
|
"code": 200,
|
|
"msg": "请选择要进入的企业",
|
|
"need_choose_tenant": true,
|
|
"tenants": result.Tenants,
|
|
"tokens": result.Tokens,
|
|
"sid": result.Tokens.Sid,
|
|
})
|
|
return
|
|
}
|
|
|
|
back := safeBackURL(req.ClientID, req.Redirect)
|
|
c.serveJSON(map[string]interface{}{
|
|
"code": 200,
|
|
"msg": "登录成功",
|
|
"redirect": back,
|
|
"tokens": result.Tokens,
|
|
"tenants": result.Tenants,
|
|
})
|
|
}
|
|
|
|
func (c *AuthLoginController) Tenants() {
|
|
claims := claimsFromHeaderLogin(c)
|
|
if claims == nil {
|
|
c.Ctx.Output.SetStatus(401)
|
|
c.serveJSON(map[string]interface{}{"code": 401, "msg": "未登录"})
|
|
return
|
|
}
|
|
list, err := authsvc.ListTenantOptions(uint64(claims.UserID))
|
|
if err != nil {
|
|
c.serveJSON(map[string]interface{}{"code": 500, "msg": "查询失败"})
|
|
return
|
|
}
|
|
c.serveJSON(map[string]interface{}{"code": 200, "data": list})
|
|
}
|
|
|
|
func (c *AuthLoginController) SwitchTenant() {
|
|
var req struct {
|
|
Tid uint64 `json:"tid"`
|
|
ClientID string `json:"client_id"`
|
|
Redirect string `json:"redirect"`
|
|
Sid string `json:"sid"`
|
|
}
|
|
body := c.Ctx.Input.RequestBody
|
|
if len(body) == 0 {
|
|
body, _ = io.ReadAll(c.Ctx.Request.Body)
|
|
}
|
|
_ = json.Unmarshal(body, &req)
|
|
|
|
sid := strings.TrimSpace(c.Ctx.GetCookie(sessionCookieName))
|
|
if sid == "" {
|
|
if claims := claimsFromHeaderLogin(c); claims != nil {
|
|
sid = claims.Sid
|
|
}
|
|
}
|
|
if sid == "" {
|
|
sid = strings.TrimSpace(req.Sid)
|
|
}
|
|
if sid == "" || req.Tid == 0 {
|
|
c.serveJSON(map[string]interface{}{"code": 400, "msg": "参数错误"})
|
|
return
|
|
}
|
|
|
|
tokens, profile, err := authsvc.ChooseTenant(sid, req.Tid, req.ClientID)
|
|
if err != nil {
|
|
c.serveJSON(map[string]interface{}{"code": 403, "msg": err.Error()})
|
|
return
|
|
}
|
|
setSessionCookieForCtx(c.Ctx, tokens.Sid)
|
|
c.serveJSON(map[string]interface{}{
|
|
"code": 200,
|
|
"msg": "切换成功",
|
|
"redirect": safeBackURL(req.ClientID, req.Redirect),
|
|
"data": map[string]interface{}{"tokens": tokens, "identity": profile},
|
|
})
|
|
}
|
|
|
|
func (c *AuthLoginController) LogoutPage() {
|
|
sid := strings.TrimSpace(c.Ctx.GetCookie(sessionCookieName))
|
|
access := bearerTokenLogin(c)
|
|
if sid != "" {
|
|
_ = authsvc.RevokeSession(sid, models.RevokeReasonLogout)
|
|
}
|
|
if access != "" {
|
|
_ = authsvc.Logout(access, "")
|
|
}
|
|
clearSessionCookieForCtx(c.Ctx)
|
|
|
|
back := strings.TrimSpace(c.GetString("post_logout_redirect_uri"))
|
|
cid := strings.TrimSpace(c.GetString("client_id"))
|
|
if back != "" && cid != "" {
|
|
if client, err := findClient(cid); err == nil && allowLogoutRedirect(client, back) {
|
|
c.Redirect(back, 302)
|
|
return
|
|
}
|
|
target := "/auth/login?error=" + url.QueryEscape("登出回跳地址未登记,已返回登录页")
|
|
if cid != "" {
|
|
target += "&client_id=" + url.QueryEscape(cid)
|
|
}
|
|
c.Redirect(target, 302)
|
|
return
|
|
}
|
|
target := "/auth/login"
|
|
if cid != "" {
|
|
target += "?client_id=" + url.QueryEscape(cid)
|
|
}
|
|
c.Redirect(target, 302)
|
|
}
|
|
|
|
func (c *AuthLoginController) Sessions() {
|
|
claims := claimsFromHeaderLogin(c)
|
|
if claims == nil {
|
|
c.Ctx.Output.SetStatus(401)
|
|
c.serveJSON(map[string]interface{}{"code": 401, "msg": "未登录"})
|
|
return
|
|
}
|
|
list, err := authsvc.ListActiveSessions(uint64(claims.UserID))
|
|
if err != nil {
|
|
c.serveJSON(map[string]interface{}{"code": 500, "msg": "查询失败"})
|
|
return
|
|
}
|
|
c.serveJSON(map[string]interface{}{"code": 200, "data": list})
|
|
}
|
|
|
|
func (c *AuthLoginController) KickSession() {
|
|
var req struct {
|
|
Sid string `json:"sid"`
|
|
}
|
|
body := c.Ctx.Input.RequestBody
|
|
if len(body) == 0 {
|
|
body, _ = io.ReadAll(c.Ctx.Request.Body)
|
|
}
|
|
_ = json.Unmarshal(body, &req)
|
|
|
|
claims := claimsFromHeaderLogin(c)
|
|
if claims == nil {
|
|
c.Ctx.Output.SetStatus(401)
|
|
c.serveJSON(map[string]interface{}{"code": 401, "msg": "未登录"})
|
|
return
|
|
}
|
|
if req.Sid == "" {
|
|
c.serveJSON(map[string]interface{}{"code": 400, "msg": "参数错误"})
|
|
return
|
|
}
|
|
owned := false
|
|
if list, err := authsvc.ListActiveSessions(uint64(claims.UserID)); err == nil {
|
|
for _, s := range list {
|
|
if s.Sid == req.Sid {
|
|
owned = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if !owned {
|
|
c.serveJSON(map[string]interface{}{"code": 403, "msg": "无权操作"})
|
|
return
|
|
}
|
|
if err := authsvc.RevokeSession(req.Sid, models.RevokeReasonAdmin); err != nil {
|
|
c.serveJSON(map[string]interface{}{"code": 500, "msg": "操作失败"})
|
|
return
|
|
}
|
|
c.serveJSON(map[string]interface{}{"code": 200, "msg": "已下线"})
|
|
}
|
|
|
|
func (c *AuthLoginController) LogoutAction() {
|
|
sid := strings.TrimSpace(c.Ctx.GetCookie(sessionCookieName))
|
|
access := ""
|
|
if claims := claimsFromHeaderLogin(c); claims != nil {
|
|
if sid == "" {
|
|
sid = claims.Sid
|
|
}
|
|
access = bearerTokenLogin(c)
|
|
}
|
|
_ = authsvc.Logout(access, "")
|
|
if sid != "" {
|
|
_ = authsvc.RevokeSession(sid, models.RevokeReasonLogout)
|
|
}
|
|
clearSessionCookieForCtx(c.Ctx)
|
|
c.serveJSON(map[string]interface{}{"code": 200, "msg": "已登出"})
|
|
}
|
|
|
|
func (c *AuthLoginController) ClearSiteData() {
|
|
if sid := strings.TrimSpace(c.Ctx.GetCookie(sessionCookieName)); sid != "" {
|
|
_ = authsvc.RevokeSession(sid, models.RevokeReasonLogout)
|
|
}
|
|
clearSessionCookieForCtx(c.Ctx)
|
|
c.Ctx.Output.Header("Clear-Site-Data", `"cache", "cookies", "storage"`)
|
|
c.Ctx.Output.Header("Cache-Control", "no-store")
|
|
c.serveJSON(map[string]interface{}{"code": 200, "msg": "已清除"})
|
|
}
|
|
|
|
func (c *AuthLoginController) VerifyConfig() {
|
|
tid, _ := c.GetInt64("tid", 0)
|
|
sessionCfg := authsvc.GetTenantSessionPolicy(uint64(tid))
|
|
verify := authsvc.GetLoginVerifyConfig(uint64(tid))
|
|
|
|
openVerify := 0
|
|
if verify.OpenVerify {
|
|
openVerify = 1
|
|
}
|
|
c.serveJSON(map[string]interface{}{
|
|
"code": 200,
|
|
"data": map[string]interface{}{
|
|
"openVerify": openVerify,
|
|
"verifyType": verify.VerifyType,
|
|
"needGeetest": verify.NeedGeetest(),
|
|
"geetestVersion": verify.GeetestVersion,
|
|
"captchaId": verify.CaptchaID,
|
|
"sessionTTL": sessionCfg.SessionTTL,
|
|
"maxSession": sessionCfg.MaxSession,
|
|
"mfaRequired": 0,
|
|
},
|
|
})
|
|
}
|
|
|
|
func safeBackURL(clientID, redirect string) string {
|
|
if back := decodeRedirect(redirect); back != "" {
|
|
return back
|
|
}
|
|
client, err := findClient(strings.TrimSpace(clientID))
|
|
if err != nil || client.RedirectURIs == nil {
|
|
return ""
|
|
}
|
|
var list []string
|
|
if err := json.Unmarshal([]byte(*client.RedirectURIs), &list); err != nil {
|
|
return ""
|
|
}
|
|
for _, item := range list {
|
|
u, err := url.Parse(strings.TrimSpace(item))
|
|
if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") {
|
|
continue
|
|
}
|
|
return u.Scheme + "://" + u.Host + "/"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func decodeRedirect(encoded string) string {
|
|
if encoded == "" {
|
|
return ""
|
|
}
|
|
raw, err := base64.RawURLEncoding.DecodeString(encoded)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
back := string(raw)
|
|
if !strings.HasPrefix(back, "/auth/") && !strings.HasPrefix(back, "http") {
|
|
return ""
|
|
}
|
|
return back
|
|
}
|
|
|
|
func claimsFromHeaderLogin(c *AuthLoginController) *jwtutil.Claims {
|
|
token := bearerTokenLogin(c)
|
|
if token == "" {
|
|
return nil
|
|
}
|
|
claims, err := jwtutil.ParseToken(token)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return claims
|
|
}
|
|
|
|
func bearerTokenLogin(c *AuthLoginController) string {
|
|
header := c.Ctx.Request.Header.Get("Authorization")
|
|
if header == "" {
|
|
return ""
|
|
}
|
|
parts := strings.SplitN(header, " ", 2)
|
|
if len(parts) != 2 || parts[0] != "Bearer" {
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(parts[1])
|
|
}
|
|
|
|
func setSessionCookieForCtx(ctx *context.Context, sid string) {
|
|
flag := cookieSecureFlag(ctx)
|
|
ctx.Output.Header("Set-Cookie",
|
|
fmt.Sprintf("%s=%s; Path=/; Max-Age=%d; HttpOnly%s; SameSite=Lax",
|
|
sessionCookieName, sid, sessionCookieTTL, flag))
|
|
}
|
|
|
|
func clearSessionCookieForCtx(ctx *context.Context) {
|
|
flag := cookieSecureFlag(ctx)
|
|
ctx.Output.Header("Set-Cookie",
|
|
fmt.Sprintf("%s=; Path=/; Max-Age=0; HttpOnly%s; SameSite=Lax", sessionCookieName, flag))
|
|
}
|
|
|
|
func cookieSecureFlag(ctx *context.Context) string {
|
|
if ctx.Request.TLS != nil || strings.EqualFold(ctx.Request.Header.Get("X-Forwarded-Proto"), "https") {
|
|
return "; Secure"
|
|
}
|
|
return ""
|
|
}
|