restapi_auth_oauth2_test.go 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399
  1. package otoauth2
  2. import (
  3. "net/http"
  4. "net/http/httptest"
  5. "net/url"
  6. "strconv"
  7. "testing"
  8. "time"
  9. authTypes "github.com/OliveTin/OliveTin/internal/auth/authpublic"
  10. config "github.com/OliveTin/OliveTin/internal/config"
  11. "github.com/stretchr/testify/assert"
  12. "github.com/stretchr/testify/require"
  13. "golang.org/x/oauth2"
  14. )
  15. func TestSweepExpiredOAuthEntriesLocked(t *testing.T) {
  16. h := &OAuth2Handler{
  17. pendingStates: make(map[string]*oauth2PendingState),
  18. sessions: make(map[string]*oauth2Session),
  19. }
  20. h.pendingStates["fresh"] = &oauth2PendingState{
  21. providerName: "test",
  22. createdAt: time.Now(),
  23. }
  24. h.pendingStates["stale"] = &oauth2PendingState{
  25. providerName: "test",
  26. createdAt: time.Now().Add(-2 * oauthStateMaxAge * time.Second),
  27. }
  28. h.sessions["fresh-session"] = &oauth2Session{
  29. Username: "alice",
  30. createdAt: time.Now(),
  31. }
  32. h.sessions["stale-session"] = &oauth2Session{
  33. Username: "bob",
  34. createdAt: time.Now().Add(-2 * oauthSessionMaxAge * time.Second),
  35. }
  36. h.sweepExpiredOAuthEntriesLocked(time.Now())
  37. _, freshPending := h.pendingStates["fresh"]
  38. _, stalePending := h.pendingStates["stale"]
  39. _, freshSession := h.sessions["fresh-session"]
  40. _, staleSession := h.sessions["stale-session"]
  41. assert.True(t, freshPending)
  42. assert.False(t, stalePending)
  43. assert.True(t, freshSession)
  44. assert.False(t, staleSession)
  45. }
  46. func TestGetGroupFieldString(t *testing.T) {
  47. data := map[string]any{"olivetin_group": "admins"}
  48. assert.Equal(t, "admins", getGroupField(data, "olivetin_group", ""))
  49. }
  50. func TestGetGroupFieldMissing(t *testing.T) {
  51. data := map[string]any{}
  52. assert.Empty(t, getGroupField(data, "olivetin_group", ""))
  53. }
  54. func TestGetGroupFieldEmptyFieldName(t *testing.T) {
  55. data := map[string]any{"olivetin_group": "admins"}
  56. assert.Empty(t, getGroupField(data, "", ""))
  57. }
  58. func TestGetGroupFieldArrayDefaultSeparator(t *testing.T) {
  59. data := map[string]any{"groups": []any{"admins", "ops"}}
  60. assert.Equal(t, "admins ops", getGroupField(data, "groups", ""))
  61. }
  62. func TestGetGroupFieldArrayCustomSeparator(t *testing.T) {
  63. data := map[string]any{"groups": []any{"admins", "ops"}}
  64. assert.Equal(t, "admins,ops", getGroupField(data, "groups", ","))
  65. }
  66. func TestGetGroupFieldArraySkipsNonStringElements(t *testing.T) {
  67. data := map[string]any{"groups": []any{"admins", float64(5), "ops"}}
  68. assert.Equal(t, "admins ops", getGroupField(data, "groups", ""))
  69. }
  70. func TestGetGroupFieldArrayAllNonStringElements(t *testing.T) {
  71. data := map[string]any{"groups": []any{float64(1), true}}
  72. assert.Empty(t, getGroupField(data, "groups", ""))
  73. }
  74. func TestGetGroupFieldNotStringOrArray(t *testing.T) {
  75. data := map[string]any{"groups": map[string]any{"nested": "value"}}
  76. assert.Empty(t, getGroupField(data, "groups", ""))
  77. }
  78. func TestGetUserInfoWithArrayGroupsClaim(t *testing.T) {
  79. srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  80. w.Header().Set("Content-Type", "application/json")
  81. _, _ = w.Write([]byte(`{"preferred_username":"john","groups":["admins","ops"]}`))
  82. }))
  83. defer srv.Close()
  84. cfg := config.DefaultConfig()
  85. cfg.AuthHttpHeaderUserGroupSep = ","
  86. provider := &config.OAuth2Provider{
  87. WhoamiUrl: srv.URL,
  88. UsernameField: "preferred_username",
  89. UserGroupField: "groups",
  90. }
  91. userinfo := getUserInfo(cfg, srv.Client(), provider)
  92. assert.Equal(t, "john", userinfo.Username)
  93. assert.Equal(t, "admins,ops", userinfo.Usergroup)
  94. }
  95. func TestComputeUsergroupUsesConfiguredSeparatorWithAddToUsergroup(t *testing.T) {
  96. cfg := config.DefaultConfig()
  97. cfg.AuthHttpHeaderUserGroupSep = ","
  98. h := &OAuth2Handler{cfg: cfg}
  99. userinfo := &UserInfo{Usergroup: "admins,ops"}
  100. providerConfig := &config.OAuth2Provider{AddToUsergroup: "github"}
  101. assert.Equal(t, "admins,ops,github", h.computeUsergroup(userinfo, providerConfig))
  102. }
  103. func TestComputeUsergroupDefaultSeparatorWithAddToUsergroup(t *testing.T) {
  104. cfg := config.DefaultConfig()
  105. h := &OAuth2Handler{cfg: cfg}
  106. userinfo := &UserInfo{Usergroup: "admins"}
  107. providerConfig := &config.OAuth2Provider{AddToUsergroup: "github"}
  108. assert.Equal(t, "admins github", h.computeUsergroup(userinfo, providerConfig))
  109. }
  110. func TestHandleOAuthLoginRejectsWhenStateMapFull(t *testing.T) {
  111. cfg := config.DefaultConfig()
  112. cfg.AuthOAuth2Providers = map[string]*config.OAuth2Provider{
  113. "test": {
  114. Name: "test",
  115. ClientID: "id",
  116. ClientSecret: "secret",
  117. AuthUrl: "https://example.com/auth",
  118. TokenUrl: "https://example.com/token",
  119. },
  120. }
  121. h := NewOAuth2Handler(cfg)
  122. h.pendingStates = make(map[string]*oauth2PendingState, oauthStateMaxEntries)
  123. for i := range oauthStateMaxEntries {
  124. h.pendingStates[strconv.Itoa(i)] = &oauth2PendingState{
  125. providerConfig: &oauth2.Config{},
  126. providerName: "test",
  127. createdAt: time.Now(),
  128. }
  129. }
  130. req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/oauth/login?provider=test", nil)
  131. rec := httptest.NewRecorder()
  132. h.HandleOAuthLogin(rec, req)
  133. assert.Equal(t, http.StatusServiceUnavailable, rec.Code)
  134. assert.Len(t, h.pendingStates, oauthStateMaxEntries)
  135. }
  136. func TestHandleOAuthLoginUsesSeparateStateCookie(t *testing.T) {
  137. cfg := config.DefaultConfig()
  138. cfg.AuthOAuth2Providers = map[string]*config.OAuth2Provider{
  139. "test": {
  140. Name: "test",
  141. ClientID: "id",
  142. ClientSecret: "secret",
  143. AuthUrl: "https://example.com/auth",
  144. TokenUrl: "https://example.com/token",
  145. },
  146. }
  147. h := NewOAuth2Handler(cfg)
  148. req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/oauth/login?provider=test", nil)
  149. rec := httptest.NewRecorder()
  150. h.HandleOAuthLogin(rec, req)
  151. assert.Equal(t, http.StatusFound, rec.Code)
  152. cookies := rec.Result().Cookies()
  153. var stateCookie, sessionCookie *http.Cookie
  154. for _, cookie := range cookies {
  155. switch cookie.Name {
  156. case oauthStateCookieName:
  157. stateCookie = cookie
  158. case oauthSessionCookieName:
  159. sessionCookie = cookie
  160. }
  161. }
  162. requireCookie := func(cookie *http.Cookie, name string) string {
  163. t.Helper()
  164. assert.NotNil(t, cookie, "expected %s cookie", name)
  165. assert.NotEmpty(t, cookie.Value)
  166. return cookie.Value
  167. }
  168. stateValue := requireCookie(stateCookie, oauthStateCookieName)
  169. assert.Nil(t, sessionCookie, "login must not set the session cookie yet")
  170. location, err := url.Parse(rec.Header().Get("Location"))
  171. require.NoError(t, err)
  172. assert.Equal(t, stateValue, location.Query().Get("state"))
  173. assert.Contains(t, h.pendingStates, stateValue)
  174. assert.Empty(t, h.sessions)
  175. }
  176. func TestIssueOAuthSessionRotatesAwayFromCSRFState(t *testing.T) {
  177. h := &OAuth2Handler{
  178. pendingStates: make(map[string]*oauth2PendingState),
  179. sessions: make(map[string]*oauth2Session),
  180. }
  181. state := "csrf-state-value"
  182. h.pendingStates[state] = &oauth2PendingState{
  183. providerName: "test",
  184. createdAt: time.Now(),
  185. }
  186. sessionID, err := h.issueOAuthSession(state, "alice", "admins")
  187. require.NoError(t, err)
  188. assert.NotEmpty(t, sessionID)
  189. assert.NotEqual(t, state, sessionID)
  190. assert.NotContains(t, h.pendingStates, state)
  191. assert.Contains(t, h.sessions, sessionID)
  192. user, found := h.lookupOAuth2UserBySession(sessionID)
  193. assert.True(t, found)
  194. assert.Equal(t, "alice", user.Username)
  195. assert.Equal(t, sessionID, user.SID)
  196. _, foundAsState := h.lookupOAuth2UserBySession(state)
  197. assert.False(t, foundAsState, "CSRF state must not authenticate as a session")
  198. }
  199. func TestCheckUserFromOAuth2CookieUsesSessionCookieOnly(t *testing.T) {
  200. cfg := config.DefaultConfig()
  201. h := NewOAuth2Handler(cfg)
  202. h.sessions["session-id"] = &oauth2Session{
  203. Username: "alice",
  204. Usergroup: "admins",
  205. createdAt: time.Now(),
  206. }
  207. h.pendingStates["csrf-state"] = &oauth2PendingState{
  208. providerName: "test",
  209. createdAt: time.Now(),
  210. }
  211. reqWithSession := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", nil)
  212. reqWithSession.AddCookie(&http.Cookie{Name: oauthSessionCookieName, Value: "session-id"})
  213. user := h.CheckUserFromOAuth2Cookie(&authTypes.AuthCheckingContext{Request: reqWithSession})
  214. assert.NotNil(t, user)
  215. assert.Equal(t, "alice", user.Username)
  216. reqWithState := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", nil)
  217. reqWithState.AddCookie(&http.Cookie{Name: oauthSessionCookieName, Value: "csrf-state"})
  218. assert.Nil(t, h.CheckUserFromOAuth2Cookie(&authTypes.AuthCheckingContext{Request: reqWithState}))
  219. reqLegacyStateCookie := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", nil)
  220. reqLegacyStateCookie.AddCookie(&http.Cookie{Name: oauthStateCookieName, Value: "csrf-state"})
  221. assert.Nil(t, h.CheckUserFromOAuth2Cookie(&authTypes.AuthCheckingContext{Request: reqLegacyStateCookie}))
  222. }
  223. func TestIssueOAuthSessionRejectsMissingPendingState(t *testing.T) {
  224. h := &OAuth2Handler{
  225. pendingStates: make(map[string]*oauth2PendingState),
  226. sessions: make(map[string]*oauth2Session),
  227. }
  228. sessionID, err := h.issueOAuthSession("already-consumed", "alice", "admins")
  229. require.Error(t, err)
  230. assert.Empty(t, sessionID)
  231. assert.Empty(t, h.sessions)
  232. }
  233. func TestIssueOAuthSessionRejectsExpiredPendingState(t *testing.T) {
  234. h := &OAuth2Handler{
  235. pendingStates: make(map[string]*oauth2PendingState),
  236. sessions: make(map[string]*oauth2Session),
  237. }
  238. state := "expired-state"
  239. pending := &oauth2PendingState{
  240. providerName: "test",
  241. createdAt: time.Now().Add(-2 * oauthStateMaxAge * time.Second),
  242. }
  243. h.pendingStates[state] = pending
  244. sessionID, err := h.issueOAuthSession(state, "alice", "admins")
  245. require.Error(t, err)
  246. assert.Empty(t, sessionID)
  247. assert.NotContains(t, h.pendingStates, state)
  248. assert.Empty(t, h.sessions)
  249. }
  250. func TestLookupOAuth2UserBySessionRejectsExpiredSession(t *testing.T) {
  251. h := &OAuth2Handler{
  252. pendingStates: make(map[string]*oauth2PendingState),
  253. sessions: make(map[string]*oauth2Session),
  254. }
  255. h.sessions["stale"] = &oauth2Session{
  256. Username: "alice",
  257. createdAt: time.Now().Add(-2 * oauthSessionMaxAge * time.Second),
  258. }
  259. user, found := h.lookupOAuth2UserBySession("stale")
  260. assert.False(t, found)
  261. assert.Nil(t, user)
  262. assert.NotContains(t, h.sessions, "stale")
  263. }
  264. func TestLoadValidPendingOAuthStateRejectsExpired(t *testing.T) {
  265. h := &OAuth2Handler{
  266. pendingStates: make(map[string]*oauth2PendingState),
  267. sessions: make(map[string]*oauth2Session),
  268. }
  269. state := "expired-pending"
  270. h.pendingStates[state] = &oauth2PendingState{
  271. providerName: "test",
  272. createdAt: time.Now().Add(-2 * oauthStateMaxAge * time.Second),
  273. }
  274. rec := httptest.NewRecorder()
  275. pending, gotState, ok := h.loadValidPendingOAuthState(rec, state)
  276. assert.False(t, ok)
  277. assert.Nil(t, pending)
  278. assert.Equal(t, state, gotState)
  279. assert.Equal(t, http.StatusBadRequest, rec.Code)
  280. assert.NotContains(t, h.pendingStates, state)
  281. }
  282. func TestConsumePendingOAuthStateMismatchKeepsPending(t *testing.T) {
  283. h := &OAuth2Handler{
  284. pendingStates: make(map[string]*oauth2PendingState),
  285. sessions: make(map[string]*oauth2Session),
  286. }
  287. state := "valid-pending"
  288. h.pendingStates[state] = &oauth2PendingState{
  289. providerName: "test",
  290. createdAt: time.Now(),
  291. }
  292. req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/oauth/callback?state=other-state", nil)
  293. req.AddCookie(&http.Cookie{Name: oauthStateCookieName, Value: state})
  294. rec := httptest.NewRecorder()
  295. pending, gotState, ok := h.consumePendingOAuthState(rec, req)
  296. assert.False(t, ok)
  297. assert.Nil(t, pending)
  298. assert.Equal(t, state, gotState)
  299. assert.Equal(t, http.StatusBadRequest, rec.Code)
  300. assert.Contains(t, h.pendingStates, state)
  301. }
  302. func TestIssueOAuthSessionRejectsWhenSessionCapacityExceeded(t *testing.T) {
  303. h := &OAuth2Handler{
  304. pendingStates: make(map[string]*oauth2PendingState),
  305. sessions: make(map[string]*oauth2Session, oauthSessionMaxEntries),
  306. }
  307. for i := range oauthSessionMaxEntries {
  308. h.sessions[strconv.Itoa(i)] = &oauth2Session{
  309. Username: "user",
  310. createdAt: time.Now(),
  311. }
  312. }
  313. state := "pending"
  314. h.pendingStates[state] = &oauth2PendingState{
  315. providerName: "test",
  316. createdAt: time.Now(),
  317. }
  318. sessionID, err := h.issueOAuthSession(state, "alice", "admins")
  319. require.Error(t, err)
  320. assert.Empty(t, sessionID)
  321. assert.Contains(t, h.pendingStates, state)
  322. assert.Len(t, h.sessions, oauthSessionMaxEntries)
  323. }