restapi_auth_oauth2.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643
  1. package otoauth2
  2. import (
  3. "context"
  4. "crypto/rand"
  5. "crypto/tls"
  6. "crypto/x509"
  7. "encoding/base64"
  8. "encoding/json"
  9. "fmt"
  10. "io"
  11. "net/http"
  12. "os"
  13. "strings"
  14. "sync"
  15. "time"
  16. authTypes "github.com/OliveTin/OliveTin/internal/auth/authpublic"
  17. config "github.com/OliveTin/OliveTin/internal/config"
  18. log "github.com/sirupsen/logrus"
  19. "golang.org/x/oauth2"
  20. )
  21. type OAuth2Handler struct {
  22. cfg *config.Config
  23. pendingStates map[string]*oauth2PendingState
  24. sessions map[string]*oauth2Session
  25. registeredProviders map[string]*oauth2.Config
  26. mu sync.RWMutex
  27. }
  28. func NewOAuth2Handler(cfg *config.Config) *OAuth2Handler {
  29. h := &OAuth2Handler{
  30. cfg: cfg,
  31. }
  32. h.pendingStates = make(map[string]*oauth2PendingState)
  33. h.sessions = make(map[string]*oauth2Session)
  34. h.registeredProviders = make(map[string]*oauth2.Config)
  35. for providerName, providerConfig := range cfg.AuthOAuth2Providers {
  36. completeProviderConfig(providerName, providerConfig)
  37. newConfig := &oauth2.Config{
  38. ClientID: providerConfig.ClientID,
  39. ClientSecret: providerConfig.ClientSecret,
  40. Scopes: providerConfig.Scopes,
  41. Endpoint: oauth2.Endpoint{
  42. AuthURL: providerConfig.AuthUrl,
  43. TokenURL: providerConfig.TokenUrl,
  44. },
  45. RedirectURL: cfg.AuthOAuth2RedirectURL,
  46. }
  47. h.registeredProviders[providerName] = newConfig
  48. log.Debugf("Dumping newly registered provider: %v = %+v", providerName, providerConfig)
  49. }
  50. return h
  51. }
  52. type oauth2PendingState struct {
  53. createdAt time.Time
  54. providerConfig *oauth2.Config
  55. providerName string
  56. }
  57. type oauth2Session struct {
  58. createdAt time.Time
  59. Username string
  60. Usergroup string
  61. providerName string
  62. }
  63. const (
  64. oauthStateCookieName = "olivetin-oauth-state"
  65. oauthSessionCookieName = "olivetin-sid-oauth"
  66. oauthStateMaxAge = 900 // seconds; CSRF pending window
  67. oauthSessionMaxAge = 900 // seconds; authenticated session lifetime
  68. oauthStateMaxEntries = 10000
  69. oauthSessionMaxEntries = 10000
  70. )
  71. func assignIfEmpty(target *string, value string) {
  72. if *target == "" {
  73. *target = value
  74. }
  75. }
  76. func completeProviderConfig(providerName string, providerConfig *config.OAuth2Provider) {
  77. dbConfig, ok := oauth2ProviderDatabase[providerName]
  78. if ok {
  79. assignIfEmpty(&providerConfig.Name, dbConfig.Name)
  80. assignIfEmpty(&providerConfig.Title, dbConfig.Title)
  81. assignIfEmpty(&providerConfig.WhoamiUrl, dbConfig.WhoamiUrl)
  82. assignIfEmpty(&providerConfig.TokenUrl, dbConfig.TokenUrl)
  83. assignIfEmpty(&providerConfig.AuthUrl, dbConfig.AuthUrl)
  84. assignIfEmpty(&providerConfig.Icon, dbConfig.Icon)
  85. assignIfEmpty(&providerConfig.UsernameField, dbConfig.UsernameField)
  86. if providerConfig.Scopes == nil {
  87. providerConfig.Scopes = dbConfig.Scopes
  88. }
  89. } else {
  90. log.Warnf("Provider not found in database: %v", providerName)
  91. }
  92. }
  93. func (h *OAuth2Handler) getOAuth2Config(providerName string) (*oauth2.Config, error) {
  94. config, ok := h.registeredProviders[providerName]
  95. if !ok {
  96. return nil, fmt.Errorf("provider not found in config: %v", providerName)
  97. }
  98. return config, nil
  99. }
  100. func randString(nByte int) (string, error) {
  101. b := make([]byte, nByte)
  102. if _, err := io.ReadFull(rand.Reader, b); err != nil {
  103. return "", err
  104. }
  105. return base64.URLEncoding.EncodeToString(b), nil
  106. }
  107. func (h *OAuth2Handler) cookieSecure(r *http.Request) bool {
  108. useTLS := r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https"
  109. return useTLS || h.cfg.Security.ForceSecureCookies
  110. }
  111. func (h *OAuth2Handler) setOAuthCookie(w http.ResponseWriter, r *http.Request, name, value string, maxAge int) {
  112. cookie := &http.Cookie{
  113. Name: name,
  114. Value: value,
  115. MaxAge: maxAge,
  116. Secure: h.cookieSecure(r),
  117. HttpOnly: true,
  118. Path: "/",
  119. SameSite: http.SameSiteLaxMode,
  120. }
  121. http.SetCookie(w, cookie)
  122. }
  123. func (h *OAuth2Handler) clearOAuthCookie(w http.ResponseWriter, r *http.Request, name string) {
  124. h.setOAuthCookie(w, r, name, "", -1)
  125. }
  126. func (h *OAuth2Handler) deletePendingStateLocked(state string) {
  127. delete(h.pendingStates, state)
  128. }
  129. func (h *OAuth2Handler) sweepExpiredOAuthEntriesLocked(now time.Time) {
  130. h.sweepExpiredPendingStatesLocked(now)
  131. h.sweepExpiredSessionsLocked(now)
  132. }
  133. func (h *OAuth2Handler) sweepExpiredPendingStatesLocked(now time.Time) {
  134. pendingCutoff := now.Add(-oauthStateMaxAge * time.Second)
  135. for state, entry := range h.pendingStates {
  136. if entry.createdAt.Before(pendingCutoff) {
  137. delete(h.pendingStates, state)
  138. }
  139. }
  140. }
  141. func (h *OAuth2Handler) sweepExpiredSessionsLocked(now time.Time) {
  142. sessionCutoff := now.Add(-oauthSessionMaxAge * time.Second)
  143. for sid, entry := range h.sessions {
  144. if entry.createdAt.Before(sessionCutoff) {
  145. delete(h.sessions, sid)
  146. }
  147. }
  148. }
  149. func (h *OAuth2Handler) HandleOAuthLogin(w http.ResponseWriter, r *http.Request) {
  150. state, err := randString(16)
  151. if err != nil {
  152. http.Error(w, err.Error(), http.StatusInternalServerError)
  153. return
  154. }
  155. providerName := r.URL.Query().Get("provider")
  156. provider, err := h.getOAuth2Config(providerName)
  157. if err != nil {
  158. log.Errorf("Failed to get provider config: %v %v", providerName, err)
  159. http.Error(w, err.Error(), http.StatusBadRequest)
  160. return
  161. }
  162. h.mu.Lock()
  163. h.sweepExpiredOAuthEntriesLocked(time.Now())
  164. if len(h.pendingStates) >= oauthStateMaxEntries {
  165. h.mu.Unlock()
  166. http.Error(w, "OAuth login temporarily unavailable", http.StatusServiceUnavailable)
  167. return
  168. }
  169. h.pendingStates[state] = &oauth2PendingState{
  170. providerConfig: provider,
  171. providerName: providerName,
  172. createdAt: time.Now(),
  173. }
  174. h.mu.Unlock()
  175. // CSRF double-submit cookie only — never reuse this value as the session ID.
  176. h.setOAuthCookie(w, r, oauthStateCookieName, state, oauthStateMaxAge)
  177. log.Infof("OAuth2 login redirect for provider %v", providerName)
  178. http.Redirect(w, r, provider.AuthCodeURL(state), http.StatusFound)
  179. }
  180. func (h *OAuth2Handler) validateStateMatch(queryState, cookieState string) bool {
  181. return queryState != "" && queryState == cookieState
  182. }
  183. func pendingStateExpired(pending *oauth2PendingState, now time.Time) bool {
  184. return pending.createdAt.Before(now.Add(-oauthStateMaxAge * time.Second))
  185. }
  186. func sessionExpired(session *oauth2Session, now time.Time) bool {
  187. return session.createdAt.Before(now.Add(-oauthSessionMaxAge * time.Second))
  188. }
  189. func (h *OAuth2Handler) consumePendingOAuthState(w http.ResponseWriter, r *http.Request) (*oauth2PendingState, string, bool) {
  190. cookie, err := r.Cookie(oauthStateCookieName)
  191. if err != nil {
  192. log.Errorf("Failed to get OAuth state cookie: %v", err)
  193. http.Error(w, "State not found", http.StatusBadRequest)
  194. return nil, "", false
  195. }
  196. state := cookie.Value
  197. queryState := r.URL.Query().Get("state")
  198. if !h.validateStateMatch(queryState, state) {
  199. // Keep the cookie's pending state: an unrelated callback (different or
  200. // missing query state) must not invalidate an in-flight login.
  201. log.Errorf("OAuth2 state mismatch between query and cookie")
  202. http.Error(w, "State mismatch", http.StatusBadRequest)
  203. return nil, state, false
  204. }
  205. return h.loadValidPendingOAuthState(w, state)
  206. }
  207. func (h *OAuth2Handler) loadValidPendingOAuthState(w http.ResponseWriter, state string) (*oauth2PendingState, string, bool) {
  208. h.mu.RLock()
  209. pending, ok := h.pendingStates[state]
  210. expired := ok && pendingStateExpired(pending, time.Now())
  211. h.mu.RUnlock()
  212. if !ok {
  213. log.Errorf("OAuth2 pending state not found on server")
  214. http.Error(w, "State not found in server", http.StatusBadRequest)
  215. return nil, state, false
  216. }
  217. if expired {
  218. h.mu.Lock()
  219. h.deletePendingStateLocked(state)
  220. h.mu.Unlock()
  221. log.Errorf("OAuth2 pending state expired")
  222. http.Error(w, "State expired", http.StatusBadRequest)
  223. return nil, state, false
  224. }
  225. return pending, state, true
  226. }
  227. type HttpClientSettings struct {
  228. Transport *http.Transport
  229. Timeout time.Duration
  230. }
  231. func getOAuth2HttpClient(providerConfig *config.OAuth2Provider) *HttpClientSettings {
  232. config := &HttpClientSettings{
  233. Transport: &http.Transport{
  234. TLSClientConfig: &tls.Config{InsecureSkipVerify: providerConfig.InsecureSkipVerify},
  235. },
  236. Timeout: time.Duration(min(3, providerConfig.CallbackTimeout)) * time.Second,
  237. }
  238. if providerConfig.CertBundlePath != "" {
  239. config.Transport.TLSClientConfig.RootCAs = getOAuthCertBundle(providerConfig)
  240. }
  241. return config
  242. }
  243. func getOAuthCertBundle(providerConfig *config.OAuth2Provider) *x509.CertPool {
  244. caCert, err := os.ReadFile(providerConfig.CertBundlePath)
  245. if err != nil {
  246. log.Errorf("OAuth2 Cert Bundle - failed to read file: %v", err)
  247. return nil
  248. }
  249. caCertPool := x509.NewCertPool()
  250. if ok := caCertPool.AppendCertsFromPEM(caCert); !ok {
  251. log.Errorf("OAuth2 Cert Bundle - failed to append certificates from PEM")
  252. }
  253. return caCertPool
  254. }
  255. func (h *OAuth2Handler) exchangeOAuthCode(ctx context.Context, providerConfig *oauth2.Config, code string, clientSettings *HttpClientSettings) (*oauth2.Token, error) {
  256. exchangeClient := &http.Client{
  257. Transport: clientSettings.Transport,
  258. Timeout: clientSettings.Timeout,
  259. }
  260. ctx = context.WithValue(ctx, oauth2.HTTPClient, exchangeClient)
  261. return providerConfig.Exchange(ctx, code)
  262. }
  263. func (h *OAuth2Handler) createUserInfoClient(ctx context.Context, providerConfig *oauth2.Config, tok *oauth2.Token, clientSettings *HttpClientSettings) *http.Client {
  264. return &http.Client{
  265. Transport: &oauth2.Transport{
  266. Source: providerConfig.TokenSource(ctx, tok),
  267. Base: clientSettings.Transport,
  268. },
  269. Timeout: clientSettings.Timeout,
  270. }
  271. }
  272. func (h *OAuth2Handler) computeUsergroup(userinfo *UserInfo, providerConfig *config.OAuth2Provider) string {
  273. usergroup := userinfo.Usergroup
  274. if providerConfig != nil && providerConfig.AddToUsergroup != "" {
  275. if usergroup != "" {
  276. sep := h.cfg.AuthHttpHeaderUserGroupSep
  277. if sep == "" {
  278. sep = " "
  279. }
  280. usergroup = usergroup + sep + providerConfig.AddToUsergroup
  281. } else {
  282. usergroup = providerConfig.AddToUsergroup
  283. }
  284. }
  285. return usergroup
  286. }
  287. func (h *OAuth2Handler) takeValidPendingStateLocked(state string, now time.Time) (*oauth2PendingState, error) {
  288. pendingEntry, ok := h.pendingStates[state]
  289. if !ok {
  290. return nil, fmt.Errorf("pending OAuth state no longer exists")
  291. }
  292. if pendingStateExpired(pendingEntry, now) {
  293. h.deletePendingStateLocked(state)
  294. return nil, fmt.Errorf("pending OAuth state expired")
  295. }
  296. h.deletePendingStateLocked(state)
  297. return pendingEntry, nil
  298. }
  299. func (h *OAuth2Handler) issueOAuthSession(state, username, usergroup string) (string, error) {
  300. sessionID, err := randString(16)
  301. if err != nil {
  302. return "", err
  303. }
  304. h.mu.Lock()
  305. defer h.mu.Unlock()
  306. h.sweepExpiredOAuthEntriesLocked(time.Now())
  307. if len(h.sessions) >= oauthSessionMaxEntries {
  308. return "", fmt.Errorf("OAuth session capacity exceeded")
  309. }
  310. pendingEntry, err := h.takeValidPendingStateLocked(state, time.Now())
  311. if err != nil {
  312. return "", err
  313. }
  314. h.sessions[sessionID] = &oauth2Session{
  315. createdAt: time.Now(),
  316. Username: username,
  317. Usergroup: usergroup,
  318. providerName: pendingEntry.providerName,
  319. }
  320. return sessionID, nil
  321. }
  322. func (h *OAuth2Handler) HandleOAuthCallback(w http.ResponseWriter, r *http.Request) {
  323. log.Infof("OAuth2 Callback received")
  324. pending, state, ok := h.consumePendingOAuthState(w, r)
  325. if !ok {
  326. return
  327. }
  328. code := r.FormValue("code")
  329. log.Debug("OAuth2 token exchange starting")
  330. providerConfig := h.cfg.AuthOAuth2Providers[pending.providerName]
  331. clientSettings := getOAuth2HttpClient(providerConfig)
  332. ctx := context.Background()
  333. tok, err := h.exchangeOAuthCode(ctx, pending.providerConfig, code, clientSettings)
  334. if err != nil {
  335. log.Errorf("Failed to exchange code: %v", err)
  336. h.mu.Lock()
  337. h.deletePendingStateLocked(state)
  338. h.mu.Unlock()
  339. http.Error(w, "Failed to exchange code", http.StatusBadRequest)
  340. return
  341. }
  342. userInfoClient := h.createUserInfoClient(ctx, pending.providerConfig, tok, clientSettings)
  343. userinfo := getUserInfo(h.cfg, userInfoClient, providerConfig)
  344. if userinfo.Username == "" {
  345. h.mu.Lock()
  346. h.deletePendingStateLocked(state)
  347. h.mu.Unlock()
  348. log.Errorf("OAuth2 user info returned empty username")
  349. http.Error(w, "Failed to get user info", http.StatusBadRequest)
  350. return
  351. }
  352. usergroup := h.computeUsergroup(userinfo, providerConfig)
  353. sessionID, err := h.issueOAuthSession(state, userinfo.Username, usergroup)
  354. if err != nil {
  355. log.Errorf("Failed to issue OAuth session: %v", err)
  356. http.Error(w, "Failed to create session", http.StatusInternalServerError)
  357. return
  358. }
  359. h.clearOAuthCookie(w, r, oauthStateCookieName)
  360. h.setOAuthCookie(w, r, oauthSessionCookieName, sessionID, oauthSessionMaxAge)
  361. http.Redirect(w, r, "/", http.StatusFound)
  362. }
  363. type UserInfo struct {
  364. Username string
  365. Usergroup string
  366. }
  367. //gocyclo:ignore
  368. func getUserInfo(cfg *config.Config, client *http.Client, provider *config.OAuth2Provider) *UserInfo {
  369. ret := &UserInfo{}
  370. ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
  371. defer cancel()
  372. req, err := http.NewRequestWithContext(ctx, http.MethodGet, provider.WhoamiUrl, nil)
  373. if err != nil {
  374. log.Error("Could not construct user data request", err)
  375. return ret
  376. }
  377. res, err := client.Do(req)
  378. if err != nil {
  379. log.Errorf("Failed to get user data: %v", err)
  380. return ret
  381. }
  382. defer func() { _ = res.Body.Close() }()
  383. if res.StatusCode != http.StatusOK {
  384. log.Errorf("Failed to get user data: %v", res.StatusCode)
  385. return ret
  386. }
  387. contents, err := io.ReadAll(res.Body)
  388. if err != nil {
  389. log.Errorf("Failed to read user data: %v", err)
  390. return ret
  391. }
  392. var userData map[string]any
  393. if cfg.InsecureAllowDumpOAuth2UserData {
  394. log.Debugf("OAuth2 User Data: %v+", string(contents))
  395. }
  396. err = json.Unmarshal(contents, &userData)
  397. if err != nil {
  398. log.Errorf("Failed to unmarshal user data: %v", err)
  399. return ret
  400. }
  401. ret.Username = getDataField(userData, provider.UsernameField)
  402. ret.Usergroup = getGroupField(userData, provider.UserGroupField, cfg.AuthHttpHeaderUserGroupSep)
  403. return ret
  404. }
  405. func lookupRawField(data map[string]any, field string) (any, bool) {
  406. if field == "" {
  407. return nil, false
  408. }
  409. val, ok := data[field]
  410. if !ok {
  411. log.Errorf("Failed to get field from user data: %v / %v", data, field)
  412. return nil, false
  413. }
  414. return val, true
  415. }
  416. func getDataField(data map[string]any, field string) string {
  417. val, ok := lookupRawField(data, field)
  418. if !ok {
  419. return ""
  420. }
  421. stringVal, ok := val.(string)
  422. if !ok {
  423. log.Errorf("Field %v is not a string: %v", field, val)
  424. return ""
  425. }
  426. return stringVal
  427. }
  428. // getGroupField reads a userinfo field that may be either a single string
  429. // group name, or a JSON array of group names (e.g. an OIDC "groups" claim).
  430. // Array elements that aren't strings are skipped and logged, rather than
  431. // discarding the whole claim.
  432. func getGroupField(data map[string]any, field string, sep string) string {
  433. val, found := lookupRawField(data, field)
  434. if !found {
  435. return ""
  436. }
  437. if stringVal, isString := val.(string); isString {
  438. return stringVal
  439. }
  440. arrayVal, isArray := val.([]any)
  441. if !isArray {
  442. log.Errorf("Field %v is not a string or array: %v", field, val)
  443. return ""
  444. }
  445. return joinGroupArray(arrayVal, field, sep)
  446. }
  447. // joinGroupArray joins the string elements of a group claim array using sep,
  448. // defaulting to a space. Non-string elements are skipped and logged, rather
  449. // than discarding the whole claim.
  450. func joinGroupArray(arrayVal []any, field string, sep string) string {
  451. groups := make([]string, 0, len(arrayVal))
  452. for _, v := range arrayVal {
  453. strVal, isString := v.(string)
  454. if !isString {
  455. log.Warnf("Skipping non-string group entry in field %v: %v", field, v)
  456. continue
  457. }
  458. groups = append(groups, strVal)
  459. }
  460. if sep == "" {
  461. sep = " "
  462. }
  463. return strings.Join(groups, sep)
  464. }
  465. func (h *OAuth2Handler) lookupOAuth2UserBySession(sessionID string) (*authTypes.AuthenticatedUser, bool) {
  466. h.mu.RLock()
  467. session, found := h.sessions[sessionID]
  468. if !found || session.Username == "" {
  469. h.mu.RUnlock()
  470. return nil, false
  471. }
  472. if sessionExpired(session, time.Now()) {
  473. h.mu.RUnlock()
  474. h.deleteSessionIfExpired(sessionID)
  475. return nil, false
  476. }
  477. user := &authTypes.AuthenticatedUser{
  478. Username: session.Username,
  479. UsergroupLine: session.Usergroup,
  480. Provider: "oauth2",
  481. SID: sessionID,
  482. }
  483. h.mu.RUnlock()
  484. return user, true
  485. }
  486. func (h *OAuth2Handler) deleteSessionIfExpired(sessionID string) {
  487. h.mu.Lock()
  488. defer h.mu.Unlock()
  489. session, found := h.sessions[sessionID]
  490. if found && sessionExpired(session, time.Now()) {
  491. delete(h.sessions, sessionID)
  492. }
  493. }
  494. func (h *OAuth2Handler) RevokeSession(sid string) {
  495. h.mu.Lock()
  496. defer h.mu.Unlock()
  497. delete(h.sessions, sid)
  498. }
  499. func (h *OAuth2Handler) CheckUserFromOAuth2Cookie(context *authTypes.AuthCheckingContext) *authTypes.AuthenticatedUser {
  500. cookie, err := context.Request.Cookie(oauthSessionCookieName)
  501. if err != nil || cookie.Value == "" {
  502. return nil
  503. }
  504. user, found := h.lookupOAuth2UserBySession(cookie.Value)
  505. if !found {
  506. log.WithFields(log.Fields{
  507. "provider": "oauth2",
  508. }).Warnf("Stale OAuth2 session")
  509. return nil
  510. }
  511. return user
  512. }