jwt_test.go 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312
  1. package otjwt
  2. import (
  3. "crypto/rand"
  4. "crypto/rsa"
  5. "crypto/x509"
  6. "encoding/pem"
  7. "io"
  8. "net/http"
  9. "net/http/httptest"
  10. "os"
  11. "testing"
  12. "time"
  13. "github.com/OliveTin/OliveTin/internal/auth/authpublic"
  14. config "github.com/OliveTin/OliveTin/internal/config"
  15. "github.com/golang-jwt/jwt/v5"
  16. "github.com/stretchr/testify/assert"
  17. "github.com/stretchr/testify/require"
  18. )
  19. func generateRSAKeyPair(t *testing.T) (*rsa.PrivateKey, []byte) {
  20. t.Helper()
  21. privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
  22. if err != nil {
  23. t.Fatalf("failed to generate RSA key: %v", err)
  24. }
  25. pubKey := &privateKey.PublicKey
  26. pkixPubKey, err := x509.MarshalPKIXPublicKey(pubKey)
  27. if err != nil {
  28. t.Fatalf("failed to marshal public key: %v", err)
  29. }
  30. pubPem := pem.EncodeToMemory(
  31. &pem.Block{
  32. Type: "PUBLIC KEY",
  33. Bytes: pkixPubKey,
  34. },
  35. )
  36. return privateKey, pubPem
  37. }
  38. func createKeys(t *testing.T) (*rsa.PrivateKey, string) {
  39. t.Helper()
  40. tmpFile, err := os.CreateTemp(os.TempDir(), "olivetin-jwt-")
  41. if err != nil {
  42. t.Fatalf("failed to create temp file: %v", err)
  43. }
  44. defer func() { _ = tmpFile.Close() }()
  45. t.Logf("Created File: %s", tmpFile.Name())
  46. privateKey, pubPem := generateRSAKeyPair(t)
  47. if err := os.WriteFile(tmpFile.Name(), pubPem, 0644); err != nil {
  48. t.Fatalf("error when dumping pubKey: %s \n", err)
  49. }
  50. return privateKey, tmpFile.Name()
  51. }
  52. func newMux() *http.ServeMux {
  53. mux := http.NewServeMux()
  54. return mux
  55. }
  56. func createJWTTokenWithExpirationAndAudience(t *testing.T, privateKey *rsa.PrivateKey, expire int64, audience string) string {
  57. t.Helper()
  58. token := jwt.New(jwt.SigningMethodRS256)
  59. claims := token.Claims.(jwt.MapClaims)
  60. claims["nbf"] = time.Now().Unix() - 1000
  61. claims["exp"] = time.Now().Unix() + expire
  62. claims["sub"] = "test"
  63. claims["olivetinGroup"] = "test"
  64. if audience != "" {
  65. claims["aud"] = audience
  66. }
  67. tokenStr, err := token.SignedString(privateKey)
  68. if err != nil {
  69. t.Fatalf("failed to sign JWT token: %v", err)
  70. }
  71. return tokenStr
  72. }
  73. func setupJWTTestHandler(t *testing.T, cfg *config.Config) http.Handler {
  74. t.Helper()
  75. mux := newMux()
  76. mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  77. context := &authpublic.AuthCheckingContext{
  78. Request: r,
  79. Config: cfg,
  80. }
  81. user := CheckUserFromJwtHeader(context)
  82. if user == nil {
  83. w.WriteHeader(http.StatusForbidden)
  84. return
  85. }
  86. assert.Equal(t, "test", user.Username)
  87. assert.Equal(t, "test", user.UsergroupLine)
  88. })
  89. return mux
  90. }
  91. func verifyJWTResponse(t *testing.T, res *http.Response, expectCode int) {
  92. t.Helper()
  93. defer func() { _ = res.Body.Close() }()
  94. assert.Equal(t, expectCode, res.StatusCode)
  95. body, err := io.ReadAll(res.Body)
  96. require.NoError(t, err, "reading JWT response body")
  97. t.Logf("Response body: %s", string(body))
  98. }
  99. func testJwkValidation(t *testing.T, expire int64, expectCode int) {
  100. t.Helper()
  101. testJwkValidationWithAudience(t, expire, expectCode, "", "")
  102. }
  103. func testJwkValidationWithAudience(t *testing.T, expire int64, expectCode int, configAudience, tokenAudience string) {
  104. t.Helper()
  105. privateKey, publicKeyPath := createKeys(t)
  106. defer func() { _ = os.Remove(publicKeyPath) }()
  107. cfg := config.DefaultConfig()
  108. cfg.AuthJwtPubKeyPath = publicKeyPath
  109. cfg.AuthJwtClaimUsername = "sub"
  110. cfg.AuthJwtClaimUserGroup = "olivetinGroup"
  111. cfg.AuthJwtHeader = "Authorization"
  112. cfg.AuthJwtAud = configAudience
  113. tokenStr := createJWTTokenWithExpirationAndAudience(t, privateKey, expire, tokenAudience)
  114. handler := setupJWTTestHandler(t, cfg)
  115. srv := httptest.NewServer(handler)
  116. defer srv.Close()
  117. res := makeJWTRequest(t, srv, tokenStr) //nolint:bodyclose // closed by verifyJWTResponse
  118. verifyJWTResponse(t, res, expectCode)
  119. }
  120. func TestJWTSignatureVerificationSucceeds(t *testing.T) {
  121. testJwkValidation(t, 1000, http.StatusOK)
  122. }
  123. func TestJWTSignatureVerificationFails(t *testing.T) {
  124. testJwkValidation(t, -500, http.StatusForbidden)
  125. }
  126. func TestJWTAudienceValidationRejectsWrongAudience(t *testing.T) {
  127. testJwkValidationWithAudience(t, 1000, http.StatusForbidden, "expected-audience", "wrong-audience")
  128. }
  129. func TestJWTAudienceValidationAcceptsCorrectAudience(t *testing.T) {
  130. testJwkValidationWithAudience(t, 1000, http.StatusOK, "expected-audience", "expected-audience")
  131. }
  132. func createJWTTokenWithGroups(t *testing.T, privateKey *rsa.PrivateKey, groups any) string {
  133. t.Helper()
  134. token := jwt.New(jwt.SigningMethodRS256)
  135. claims := token.Claims.(jwt.MapClaims)
  136. claims["nbf"] = time.Now().Unix() - 1000
  137. claims["exp"] = time.Now().Unix() + 2000
  138. claims["sub"] = "test"
  139. claims["olivetinGroup"] = groups
  140. tokenStr, err := token.SignedString(privateKey)
  141. if err != nil {
  142. t.Fatalf("failed to sign JWT token: %v", err)
  143. }
  144. return tokenStr
  145. }
  146. func makeJWTRequest(t *testing.T, srv *httptest.Server, tokenStr string) *http.Response {
  147. t.Helper()
  148. req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, srv.URL, nil)
  149. if err != nil {
  150. t.Fatalf("failed to create request: %v", err)
  151. }
  152. req.Header.Set("Authorization", "Bearer "+tokenStr)
  153. res, err := http.DefaultClient.Do(req)
  154. if err != nil {
  155. t.Fatalf("Client err: %+v", err)
  156. }
  157. return res
  158. }
  159. func TestJWTHeaderSkipsNonStringGroupArrayElements(t *testing.T) {
  160. privateKey, publicKeyPath := createKeys(t)
  161. defer func() { _ = os.Remove(publicKeyPath) }()
  162. cfg := config.DefaultConfig()
  163. cfg.AuthJwtPubKeyPath = publicKeyPath
  164. cfg.AuthJwtClaimUsername = "sub"
  165. cfg.AuthJwtClaimUserGroup = "olivetinGroup"
  166. cfg.AuthJwtHeader = "Authorization"
  167. tokenStr := createJWTTokenWithGroups(t, privateKey, []any{"admins", 42, "ops"})
  168. mux := newMux()
  169. mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  170. context := &authpublic.AuthCheckingContext{
  171. Request: r,
  172. Config: cfg,
  173. }
  174. user := CheckUserFromJwtHeader(context)
  175. if user == nil {
  176. w.WriteHeader(http.StatusForbidden)
  177. return
  178. }
  179. assert.Equal(t, "test", user.Username)
  180. assert.Equal(t, "admins ops", user.UsergroupLine)
  181. })
  182. srv := httptest.NewServer(mux)
  183. defer srv.Close()
  184. res := makeJWTRequest(t, srv, tokenStr) //nolint:bodyclose // closed by verifyJWTResponse
  185. verifyJWTResponse(t, res, http.StatusOK)
  186. }
  187. func TestJWTHeaderWithCustomGroupSeparator(t *testing.T) {
  188. privateKey, publicKeyPath := createKeys(t)
  189. defer func() { _ = os.Remove(publicKeyPath) }()
  190. cfg := config.DefaultConfig()
  191. cfg.AuthJwtPubKeyPath = publicKeyPath
  192. cfg.AuthJwtClaimUsername = "sub"
  193. cfg.AuthJwtClaimUserGroup = "olivetinGroup"
  194. cfg.AuthJwtHeader = "Authorization"
  195. cfg.AuthHttpHeaderUserGroupSep = ","
  196. tokenStr := createJWTTokenWithGroups(t, privateKey, []string{"test", "test2"})
  197. mux := newMux()
  198. mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  199. context := &authpublic.AuthCheckingContext{
  200. Request: r,
  201. Config: cfg,
  202. }
  203. user := CheckUserFromJwtHeader(context)
  204. if user == nil {
  205. w.WriteHeader(http.StatusForbidden)
  206. return
  207. }
  208. assert.Equal(t, "test", user.Username)
  209. assert.Equal(t, "test,test2", user.UsergroupLine)
  210. })
  211. srv := httptest.NewServer(mux)
  212. defer srv.Close()
  213. res := makeJWTRequest(t, srv, tokenStr) //nolint:bodyclose // closed by verifyJWTResponse
  214. verifyJWTResponse(t, res, http.StatusOK)
  215. }
  216. func TestJWTHeader(t *testing.T) {
  217. privateKey, publicKeyPath := createKeys(t)
  218. defer func() { _ = os.Remove(publicKeyPath) }()
  219. cfg := config.DefaultConfig()
  220. cfg.AuthJwtPubKeyPath = publicKeyPath
  221. cfg.AuthJwtClaimUsername = "sub"
  222. cfg.AuthJwtClaimUserGroup = "olivetinGroup"
  223. cfg.AuthJwtHeader = "Authorization"
  224. tokenStr := createJWTTokenWithGroups(t, privateKey, []string{"test", "test2"})
  225. mux := newMux()
  226. mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  227. context := &authpublic.AuthCheckingContext{
  228. Request: r,
  229. Config: cfg,
  230. }
  231. user := CheckUserFromJwtHeader(context)
  232. if user == nil {
  233. w.WriteHeader(http.StatusForbidden)
  234. return
  235. }
  236. assert.Equal(t, "test", user.Username)
  237. assert.Equal(t, "test test2", user.UsergroupLine)
  238. })
  239. srv := httptest.NewServer(mux)
  240. defer srv.Close()
  241. res := makeJWTRequest(t, srv, tokenStr) //nolint:bodyclose // closed by verifyJWTResponse
  242. verifyJWTResponse(t, res, http.StatusOK)
  243. }