384 lines
9.7 KiB
Go
384 lines
9.7 KiB
Go
package idp
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
|
|
"server/models"
|
|
)
|
|
|
|
type UserInfo struct {
|
|
OpenID string
|
|
UnionID string
|
|
Nickname string
|
|
Avatar string
|
|
Raw string
|
|
}
|
|
|
|
type Config struct {
|
|
Provider string
|
|
AuthURL string
|
|
TokenURL string
|
|
UserinfoURL string
|
|
Scopes []string
|
|
AppID string
|
|
AppSecret string
|
|
ProxyURL string
|
|
|
|
UseAppIDStyle bool
|
|
UserinfoStyle string
|
|
|
|
OpenIDField string
|
|
UnionIDField string
|
|
NicknameField string
|
|
AvatarField string
|
|
}
|
|
|
|
var presets = map[string]Config{
|
|
models.IdPWechat: {
|
|
Provider: models.IdPWechat,
|
|
AuthURL: "https://open.weixin.qq.com/connect/oauth2/authorize",
|
|
TokenURL: "https://api.weixin.qq.com/sns/oauth2/access_token",
|
|
UserinfoURL: "https://api.weixin.qq.com/sns/userinfo",
|
|
Scopes: []string{"snsapi_userinfo"},
|
|
UseAppIDStyle: true,
|
|
UserinfoStyle: "query",
|
|
OpenIDField: "openid",
|
|
UnionIDField: "unionid",
|
|
NicknameField: "nickname",
|
|
AvatarField: "headimgurl",
|
|
},
|
|
models.IdPQQ: {
|
|
Provider: models.IdPQQ,
|
|
AuthURL: "https://graph.qq.com/oauth2.0/authorize",
|
|
TokenURL: "https://graph.qq.com/oauth2.0/token",
|
|
UserinfoURL: "https://graph.qq.com/user/get_user_info",
|
|
Scopes: []string{"get_user_info"},
|
|
UseAppIDStyle: true,
|
|
UserinfoStyle: "query",
|
|
OpenIDField: "openid",
|
|
NicknameField: "nickname",
|
|
AvatarField: "figureurl_qq_2",
|
|
},
|
|
models.IdPGitHub: {
|
|
Provider: models.IdPGitHub,
|
|
AuthURL: "https://github.com/login/oauth/authorize",
|
|
TokenURL: "https://github.com/login/oauth/access_token",
|
|
UserinfoURL: "https://api.github.com/user",
|
|
Scopes: []string{"read:user"},
|
|
UserinfoStyle: "bearer",
|
|
OpenIDField: "id",
|
|
NicknameField: "login",
|
|
AvatarField: "avatar_url",
|
|
},
|
|
models.IdPGoogle: {
|
|
Provider: models.IdPGoogle,
|
|
AuthURL: "https://accounts.google.com/o/oauth2/v2/auth",
|
|
TokenURL: "https://oauth2.googleapis.com/token",
|
|
UserinfoURL: "https://openidconnect.googleapis.com/v1/userinfo",
|
|
Scopes: []string{"openid", "profile"},
|
|
UserinfoStyle: "bearer",
|
|
OpenIDField: "sub",
|
|
NicknameField: "name",
|
|
AvatarField: "picture",
|
|
},
|
|
models.IdPDingTalk: {
|
|
Provider: models.IdPDingTalk,
|
|
AuthURL: "https://login.dingtalk.com/oauth2/auth",
|
|
TokenURL: "https://api.dingtalk.com/v1.0/oauth2/userAccessToken",
|
|
UserinfoURL: "https://api.dingtalk.com/v1.0/contact/users/me",
|
|
Scopes: []string{"openid", "profile"},
|
|
UserinfoStyle: "bearer",
|
|
OpenIDField: "unionId",
|
|
UnionIDField: "unionId",
|
|
NicknameField: "nick",
|
|
AvatarField: "avatarUrl",
|
|
},
|
|
models.IdPFeishu: {
|
|
Provider: models.IdPFeishu,
|
|
AuthURL: "https://open.feishu.cn/open-apis/authen/v1/authorize",
|
|
TokenURL: "https://open.feishu.cn/open-apis/authen/v2/oauth/token",
|
|
UserinfoURL: "https://open.feishu.cn/open-apis/authen/v1/user_info",
|
|
Scopes: []string{"contact:user.base:readonly"},
|
|
UserinfoStyle: "bearer",
|
|
OpenIDField: "open_id",
|
|
UnionIDField: "union_id",
|
|
NicknameField: "name",
|
|
AvatarField: "avatar_url",
|
|
},
|
|
}
|
|
|
|
func Supported() []string {
|
|
return []string{
|
|
models.IdPWechat, models.IdPDingTalk, models.IdPFeishu,
|
|
models.IdPQQ, models.IdPGitHub, models.IdPGoogle,
|
|
}
|
|
}
|
|
|
|
func IsSupported(provider string) bool {
|
|
_, ok := presets[provider]
|
|
return ok
|
|
}
|
|
|
|
func LoadConfig(provider string, tid uint64) (Config, bool) {
|
|
base, ok := presets[provider]
|
|
if !ok {
|
|
return Config{}, false
|
|
}
|
|
|
|
var row models.AuthTenantIdp
|
|
qs := models.Orm.QueryTable(new(models.AuthTenantIdp)).
|
|
Filter("provider", provider).
|
|
Filter("status", 1)
|
|
|
|
if tid > 0 {
|
|
if err := qs.Filter("tid", tid).One(&row); err == nil {
|
|
return applyDBConfig(base, &row), true
|
|
}
|
|
}
|
|
if err := qs.Filter("tid", 0).One(&row); err == nil {
|
|
return applyDBConfig(base, &row), true
|
|
}
|
|
return base, false
|
|
}
|
|
|
|
func applyDBConfig(base Config, row *models.AuthTenantIdp) Config {
|
|
if row.AppID != nil && strings.TrimSpace(*row.AppID) != "" {
|
|
base.AppID = strings.TrimSpace(*row.AppID)
|
|
}
|
|
if row.AppSecret != nil && strings.TrimSpace(*row.AppSecret) != "" {
|
|
base.AppSecret = strings.TrimSpace(*row.AppSecret)
|
|
}
|
|
if row.ProxyURL != nil && strings.TrimSpace(*row.ProxyURL) != "" {
|
|
base.ProxyURL = strings.TrimSpace(*row.ProxyURL)
|
|
}
|
|
if row.AuthURL != nil && strings.TrimSpace(*row.AuthURL) != "" {
|
|
base.AuthURL = strings.TrimSpace(*row.AuthURL)
|
|
}
|
|
if row.TokenURL != nil && strings.TrimSpace(*row.TokenURL) != "" {
|
|
base.TokenURL = strings.TrimSpace(*row.TokenURL)
|
|
}
|
|
if row.UserinfoURL != nil && strings.TrimSpace(*row.UserinfoURL) != "" {
|
|
base.UserinfoURL = strings.TrimSpace(*row.UserinfoURL)
|
|
}
|
|
if row.Scopes != nil && strings.TrimSpace(*row.Scopes) != "" {
|
|
base.Scopes = splitList(*row.Scopes)
|
|
}
|
|
return base
|
|
}
|
|
|
|
func splitList(s string) []string {
|
|
parts := strings.Split(s, ",")
|
|
out := make([]string, 0, len(parts))
|
|
for _, p := range parts {
|
|
if v := strings.TrimSpace(p); v != "" {
|
|
out = append(out, v)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func BuildAuthURL(cfg Config, redirectURI, state string) string {
|
|
v := url.Values{}
|
|
if cfg.UseAppIDStyle {
|
|
v.Set("appid", cfg.AppID)
|
|
} else {
|
|
v.Set("client_id", cfg.AppID)
|
|
}
|
|
v.Set("redirect_uri", redirectURI)
|
|
v.Set("response_type", "code")
|
|
v.Set("scope", strings.Join(cfg.Scopes, ","))
|
|
v.Set("state", state)
|
|
|
|
addr := cfg.AuthURL + "?" + v.Encode()
|
|
if cfg.Provider == models.IdPWechat {
|
|
return addr + "#wechat_redirect"
|
|
}
|
|
return addr
|
|
}
|
|
|
|
func Exchange(cfg Config, code string) (*UserInfo, error) {
|
|
if cfg.AppID == "" || cfg.AppSecret == "" {
|
|
return nil, errors.New("该登录方式尚未配置,请联系管理员")
|
|
}
|
|
|
|
v := url.Values{}
|
|
if cfg.UseAppIDStyle {
|
|
v.Set("appid", cfg.AppID)
|
|
v.Set("secret", cfg.AppSecret)
|
|
} else {
|
|
v.Set("client_id", cfg.AppID)
|
|
v.Set("client_secret", cfg.AppSecret)
|
|
}
|
|
v.Set("code", code)
|
|
v.Set("grant_type", "authorization_code")
|
|
|
|
tokenBody, err := post(cfg, cfg.TokenURL, v, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tokenMap := parseMap(tokenBody)
|
|
accessToken := firstStr(tokenMap, "access_token")
|
|
if accessToken == "" {
|
|
return nil, fmt.Errorf("换取令牌失败: %s", truncate(tokenBody, 200))
|
|
}
|
|
openID := firstStr(tokenMap, "openid", "unionId", "open_id", "sub", "id")
|
|
|
|
var infoMap map[string]interface{}
|
|
if cfg.UserinfoStyle == "query" {
|
|
q := url.Values{}
|
|
q.Set("access_token", accessToken)
|
|
if openID != "" {
|
|
q.Set("openid", openID)
|
|
}
|
|
if cfg.Provider == models.IdPQQ {
|
|
q.Set("oauth_consumer_key", cfg.AppID)
|
|
}
|
|
body, err := get(cfg, cfg.UserinfoURL+"?"+q.Encode(), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
infoMap = parseMap(body)
|
|
} else {
|
|
body, err := get(cfg, cfg.UserinfoURL, map[string]string{
|
|
"Authorization": "Bearer " + accessToken,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
infoMap = parseMap(body)
|
|
if d, ok := infoMap["data"].(map[string]interface{}); ok {
|
|
infoMap = d
|
|
}
|
|
}
|
|
|
|
info := &UserInfo{Raw: truncate(mustJSON(infoMap), 2000)}
|
|
info.OpenID = strField(infoMap, cfg.OpenIDField)
|
|
if cfg.UnionIDField != "" {
|
|
info.UnionID = strField(infoMap, cfg.UnionIDField)
|
|
}
|
|
info.Nickname = strField(infoMap, cfg.NicknameField)
|
|
info.Avatar = strField(infoMap, cfg.AvatarField)
|
|
|
|
if info.OpenID == "" && openID != "" {
|
|
info.OpenID = openID
|
|
}
|
|
if info.OpenID == "" {
|
|
return nil, errors.New("未能获取第三方账号标识")
|
|
}
|
|
if info.UnionID == "" {
|
|
info.UnionID = info.OpenID
|
|
}
|
|
return info, nil
|
|
}
|
|
|
|
func client(cfg Config) *http.Client {
|
|
c := &http.Client{Timeout: 15 * time.Second}
|
|
if cfg.ProxyURL != "" {
|
|
if u, err := url.Parse(cfg.ProxyURL); err == nil {
|
|
c.Transport = &http.Transport{Proxy: http.ProxyURL(u)}
|
|
}
|
|
}
|
|
return c
|
|
}
|
|
|
|
func post(cfg Config, target string, form url.Values, headers map[string]string) (string, error) {
|
|
req, err := http.NewRequest("POST", target, strings.NewReader(form.Encode()))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
if cfg.Provider == models.IdPGitHub {
|
|
req.Header.Set("Accept", "application/json")
|
|
}
|
|
for k, v := range headers {
|
|
req.Header.Set(k, v)
|
|
}
|
|
resp, err := client(cfg).Do(req)
|
|
if err != nil {
|
|
return "", fmt.Errorf("请求第三方失败: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
body, _ := io.ReadAll(resp.Body)
|
|
if resp.StatusCode >= 300 {
|
|
return "", fmt.Errorf("第三方返回异常(%d): %s", resp.StatusCode, truncate(string(body), 200))
|
|
}
|
|
return string(body), nil
|
|
}
|
|
|
|
func get(cfg Config, target string, headers map[string]string) (string, error) {
|
|
req, err := http.NewRequest("GET", target, nil)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
for k, v := range headers {
|
|
req.Header.Set(k, v)
|
|
}
|
|
resp, err := client(cfg).Do(req)
|
|
if err != nil {
|
|
return "", fmt.Errorf("请求第三方失败: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
body, _ := io.ReadAll(resp.Body)
|
|
if resp.StatusCode >= 300 {
|
|
return "", fmt.Errorf("第三方返回异常(%d): %s", resp.StatusCode, truncate(string(body), 200))
|
|
}
|
|
return string(body), nil
|
|
}
|
|
|
|
func parseMap(body string) map[string]interface{} {
|
|
out := map[string]interface{}{}
|
|
if err := json.Unmarshal([]byte(body), &out); err == nil {
|
|
return out
|
|
}
|
|
if values, err := url.ParseQuery(body); err == nil {
|
|
for k, v := range values {
|
|
if len(v) > 0 {
|
|
out[k] = v[0]
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func firstStr(m map[string]interface{}, keys ...string) string {
|
|
for _, k := range keys {
|
|
if v, ok := m[k]; ok {
|
|
switch t := v.(type) {
|
|
case string:
|
|
if t != "" {
|
|
return t
|
|
}
|
|
case float64:
|
|
return fmt.Sprintf("%.0f", t)
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func strField(m map[string]interface{}, field string) string {
|
|
if field == "" {
|
|
return ""
|
|
}
|
|
return firstStr(m, field)
|
|
}
|
|
|
|
func mustJSON(m map[string]interface{}) string {
|
|
b, _ := json.Marshal(m)
|
|
return string(b)
|
|
}
|
|
|
|
func truncate(s string, n int) string {
|
|
if len(s) <= n {
|
|
return s
|
|
}
|
|
return s[:n]
|
|
}
|