BlueGit

timfa bluegit

CI_JOB_TOKEN: leestoegang tot de eigen repo via git en API; origin naar de echte URL

timfa Tim Falken · pushed by timfa

Authored 2026-10-25 · 3 weeks ago

Hash
b55ff49c5c0936fc67dbc5175cd880ed2b414542
Parent
ce180674
Pipeline
Passed
9 files changed +234 −3
docs/runner.en.md +4 −0
@@ -108,6 +108,10 @@ Site administrators get the same screen for the runner inside BlueGit at
108 108 jobs that are actually *running*, so a paused built-in runner does not block
109 109 an update; queued jobs start after resuming.
110 110
111 ## Git and API from a job (`CI_JOB_TOKEN`)
112
113 A job can reach its own repo without its own login, also when the repo is private. `origin` points to `CI_PROJECT_URL.git`, and the runner sets `http.<project url>.extraHeader` (`Authorization: Bearer $CI_JOB_TOKEN`) through `GIT_CONFIG_*` environment variables, only for this project's URL. No file is written, so it works in any image (including `bluegit/base`) with git ≥ 2.31. `git ls-remote origin`, `git fetch` and `git clone` work, as do `GET` API routes for the own repo with the job token (read-only). Pushing, other repos and any use after the job ends are refused.
114
111 115 ## Security and isolation
112 116
113 117 - Every job runs in its own Docker container with the checkout on `/workspace`; services get a network per job. Per-job limits are set in the web interface.
@@ -108,6 +108,10 @@ Site administrators get the same screen for the runner inside BlueGit at
108jobs that are actually *running*, so a paused built-in runner does not block
108jobs that are actually *running*, so a paused built-in runner does not block
109an update; queued jobs start after resuming.
109an update; queued jobs start after resuming.
110
110
111## Git and API from a job (`CI_JOB_TOKEN`)
112
113A job can reach its own repo without its own login, also when the repo is private. `origin` points to `CI_PROJECT_URL.git`, and the runner sets `http.<project url>.extraHeader` (`Authorization: Bearer $CI_JOB_TOKEN`) through `GIT_CONFIG_*` environment variables, only for this project's URL. No file is written, so it works in any image (including `bluegit/base`) with git ≥ 2.31. `git ls-remote origin`, `git fetch` and `git clone` work, as do `GET` API routes for the own repo with the job token (read-only). Pushing, other repos and any use after the job ends are refused.
114
111## Security and isolation
115## Security and isolation
112
116
113- Every job runs in its own Docker container with the checkout on `/workspace`; services get a network per job. Per-job limits are set in the web interface.
117- Every job runs in its own Docker container with the checkout on `/workspace`; services get a network per job. Per-job limits are set in the web interface.
docs/runner.md +16 −1
@@ -104,7 +104,8 @@ mislukken met `runner_system_failure` (retry-regels gelden).
104 104 eigenaar mag lezen; een groepsrunner alleen uit repo's van die groep.
105 105 Toestemming van een maintainer telt alleen zolang die maintainer is.
106 106 Het runner-token mag alleen de repo clonen van een job die die runner op
107 dat moment draait. De rechten van `CI_JOB_TOKEN` zijn ongewijzigd.
107 dat moment draait. `CI_JOB_TOKEN` geeft alleen leestoegang tot de eigen
108 repo (zie hieronder).
108 109
109 110 ## Wat gebeurt er per job
110 111
@@ -122,6 +123,20 @@ runnermachine in `work_dir/cache`.
122 123 De job-UI en de API (`runner` in job-JSON: `{id, name, kind}`) tonen
123 124 welke runner een job draaide.
124 125
126 ## Git en API vanuit een job (`CI_JOB_TOKEN`)
127
128 Een job kan zonder eigen inlog bij de eigen repo, ook als die privé is:
129
130 - `origin` in `/workspace` wijst naar `CI_PROJECT_URL.git` (ook bij de ingebouwde runner).
131 - De runner zet via `GIT_CONFIG_COUNT`/`GIT_CONFIG_KEY_n`/`GIT_CONFIG_VALUE_n` een `http.<projecturl>.extraHeader` met `Authorization: Bearer $CI_JOB_TOKEN`, alleen voor de URL van dit project. Er komt geen bestand in de container, dus het werkt in elk image (ook `bluegit/base`) zolang git ≥ 2.31 is.
132 - `git ls-remote origin`, `git fetch`, `git clone $CI_PROJECT_URL.git` werken dus gewoon (scripts zoals `next-version.sh` hoeven niets te veranderen).
133 - De API: `GET`-routes onder `/api/v1/…/{owner}/{repo}` van de eigen repo met `Authorization: Bearer $CI_JOB_TOKEN` (of `PRIVATE-TOKEN`). Leesrechten, zoals een lid met de rol *readonly*.
134 - Niet: pushen, schrijven via de API (behalve releases publiceren, zoals voorheen), andere repo's, of iets na het einde van de job: het token vervalt dan.
135
136 Pipelines hebben zo dezelfde bescherming als de repo: wie de repo niet
137 mag lezen, ziet ook de pipelines niet, en het job-token komt niet verder
138 dan de eigen repo.
139
125 140 ## Beheer via de API (en voor agents)
126 141
127 142 Zelfde regels als de UI: account-endpoints alleen voor de eigenaar zelf,
@@ -104,7 +104,8 @@ mislukken met `runner_system_failure` (retry-regels gelden).
104eigenaar mag lezen; een groepsrunner alleen uit repo's van die groep.
104eigenaar mag lezen; een groepsrunner alleen uit repo's van die groep.
105Toestemming van een maintainer telt alleen zolang die maintainer is.
105Toestemming van een maintainer telt alleen zolang die maintainer is.
106Het runner-token mag alleen de repo clonen van een job die die runner op
106Het runner-token mag alleen de repo clonen van een job die die runner op
107dat moment draait. De rechten van `CI_JOB_TOKEN` zijn ongewijzigd.
107dat moment draait. `CI_JOB_TOKEN` geeft alleen leestoegang tot de eigen
108repo (zie hieronder).
108
109
109## Wat gebeurt er per job
110## Wat gebeurt er per job
110
111
@@ -122,6 +123,20 @@ runnermachine in `work_dir/cache`.
122De job-UI en de API (`runner` in job-JSON: `{id, name, kind}`) tonen
123De job-UI en de API (`runner` in job-JSON: `{id, name, kind}`) tonen
123welke runner een job draaide.
124welke runner een job draaide.
124
125
126## Git en API vanuit een job (`CI_JOB_TOKEN`)
127
128Een job kan zonder eigen inlog bij de eigen repo, ook als die privé is:
129
130- `origin` in `/workspace` wijst naar `CI_PROJECT_URL.git` (ook bij de ingebouwde runner).
131- De runner zet via `GIT_CONFIG_COUNT`/`GIT_CONFIG_KEY_n`/`GIT_CONFIG_VALUE_n` een `http.<projecturl>.extraHeader` met `Authorization: Bearer $CI_JOB_TOKEN`, alleen voor de URL van dit project. Er komt geen bestand in de container, dus het werkt in elk image (ook `bluegit/base`) zolang git ≥ 2.31 is.
132- `git ls-remote origin`, `git fetch`, `git clone $CI_PROJECT_URL.git` werken dus gewoon (scripts zoals `next-version.sh` hoeven niets te veranderen).
133- De API: `GET`-routes onder `/api/v1/…/{owner}/{repo}` van de eigen repo met `Authorization: Bearer $CI_JOB_TOKEN` (of `PRIVATE-TOKEN`). Leesrechten, zoals een lid met de rol *readonly*.
134- Niet: pushen, schrijven via de API (behalve releases publiceren, zoals voorheen), andere repo's, of iets na het einde van de job: het token vervalt dan.
135
136Pipelines hebben zo dezelfde bescherming als de repo: wie de repo niet
137mag lezen, ziet ook de pipelines niet, en het job-token komt niet verder
138dan de eigen repo.
139
125## Beheer via de API (en voor agents)
140## Beheer via de API (en voor agents)
126
141
127Zelfde regels als de UI: account-endpoints alleen voor de eigenaar zelf,
142Zelfde regels als de UI: account-endpoints alleen voor de eigenaar zelf,
internal/runner/job_git_auth_test.go added +22 −0
@@ -0,0 +1,22 @@
1 package runner
2
3 import "testing"
4
5 func TestJobGitAuthScopedToProject(t *testing.T) {
6 env := map[string]string{"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_KEY_0": "safe.directory", "GIT_CONFIG_VALUE_0": "*"}
7 JobGitAuth(env, "https://git.example/tim/app", "bgj_x")
8 if env["GIT_CONFIG_COUNT"] != "3" || env["GIT_CONFIG_KEY_0"] != "safe.directory" {
9 t.Fatalf("count/keep: %v", env)
10 }
11 if env["GIT_CONFIG_KEY_1"] != "http.https://git.example/tim/app.extraHeader" || env["GIT_CONFIG_KEY_2"] != "http.https://git.example/tim/app.git.extraHeader" {
12 t.Fatalf("keys: %v", env)
13 }
14 if env["GIT_CONFIG_VALUE_1"] != "Authorization: Bearer bgj_x" {
15 t.Fatalf("value: %v", env)
16 }
17 none := map[string]string{}
18 JobGitAuth(none, "", "bgj_x")
19 if len(none) != 0 {
20 t.Fatal("no URL: no config")
21 }
22 }
@@ -0,0 +1,22 @@
1package runner
2
3import "testing"
4
5func TestJobGitAuthScopedToProject(t *testing.T) {
6 env := map[string]string{"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_KEY_0": "safe.directory", "GIT_CONFIG_VALUE_0": "*"}
7 JobGitAuth(env, "https://git.example/tim/app", "bgj_x")
8 if env["GIT_CONFIG_COUNT"] != "3" || env["GIT_CONFIG_KEY_0"] != "safe.directory" {
9 t.Fatalf("count/keep: %v", env)
10 }
11 if env["GIT_CONFIG_KEY_1"] != "http.https://git.example/tim/app.extraHeader" || env["GIT_CONFIG_KEY_2"] != "http.https://git.example/tim/app.git.extraHeader" {
12 t.Fatalf("keys: %v", env)
13 }
14 if env["GIT_CONFIG_VALUE_1"] != "Authorization: Bearer bgj_x" {
15 t.Fatalf("value: %v", env)
16 }
17 none := map[string]string{}
18 JobGitAuth(none, "", "bgj_x")
19 if len(none) != 0 {
20 t.Fatal("no URL: no config")
21 }
22}
internal/runner/runner.go +26 −0
@@ -416,6 +416,11 @@ func (r *Runner) runOne(ctx context.Context, p store.Pipeline, job store.Job) ([
416 416 sink.closeSection()
417 417 return nil, fmt.Errorf("clone: %w", err)
418 418 }
419 // origin wijst naar de echte repo-URL, niet naar het pad van de bare repo
420 // op de host. In de container kan de job zo met CI_JOB_TOKEN fetchen.
421 if r.BaseURL != "" {
422 _, _ = execOut(ctx, r.GitBin, "-C", work, "remote", "set-url", "origin", strings.TrimRight(r.BaseURL, "/")+"/"+repo.FullPath()+".git")
423 }
419 424 if _, err := execOut(ctx, r.GitBin, "-C", work, "checkout", "--detach", p.CommitSHA); err != nil {
420 425 sink.closeSection()
421 426 return nil, fmt.Errorf("checkout %s: %w", p.CommitSHA, err)
@@ -883,10 +888,31 @@ func (r *Runner) environment(ctx context.Context, repo store.Repo, p store.Pipel
883 888 // Na de jobvariabelen, zodat een eigen GIT_CONFIG_COUNT blijft staan
884 889 // en safe.directory er alsnog bij komt.
885 890 markWorkspaceSafe(env)
891 JobGitAuth(env, base+"/"+repo.FullPath(), token)
886 892 mask = append(mask, token)
887 893 return env, mask, nil
888 894 }
889 895
896 // JobGitAuth geeft git in de job leestoegang tot de eigen repo met het
897 // job-token. De header geldt alleen voor de URL van dit project (met en
898 // zonder .git) en het token vervalt als de job stopt. Via GIT_CONFIG_* werkt
899 // het in elk image, zonder bestanden in de container.
900 func JobGitAuth(env map[string]string, projectURL, token string) {
901 if projectURL == "" || token == "" || !strings.Contains(projectURL, "://") {
902 return
903 }
904 n := 0
905 if v, err := strconv.Atoi(strings.TrimSpace(env["GIT_CONFIG_COUNT"])); err == nil && v > 0 {
906 n = v
907 }
908 for _, u := range []string{projectURL, projectURL + ".git"} {
909 env[fmt.Sprintf("GIT_CONFIG_KEY_%d", n)] = "http." + u + ".extraHeader"
910 env[fmt.Sprintf("GIT_CONFIG_VALUE_%d", n)] = "Authorization: Bearer " + token
911 n++
912 }
913 env["GIT_CONFIG_COUNT"] = strconv.Itoa(n)
914 }
915
890 916 // markWorkspaceSafe zet safe.directory voor elke job.
891 917 // De checkout is van de host-uid; de container-user is dat niet.
892 918 // Git 2.35+ weigert die repo anders. Een job die safe.directory al op
@@ -416,6 +416,11 @@ func (r *Runner) runOne(ctx context.Context, p store.Pipeline, job store.Job) ([
416 sink.closeSection()
416 sink.closeSection()
417 return nil, fmt.Errorf("clone: %w", err)
417 return nil, fmt.Errorf("clone: %w", err)
418 }
418 }
419 // origin wijst naar de echte repo-URL, niet naar het pad van de bare repo
420 // op de host. In de container kan de job zo met CI_JOB_TOKEN fetchen.
421 if r.BaseURL != "" {
422 _, _ = execOut(ctx, r.GitBin, "-C", work, "remote", "set-url", "origin", strings.TrimRight(r.BaseURL, "/")+"/"+repo.FullPath()+".git")
423 }
419 if _, err := execOut(ctx, r.GitBin, "-C", work, "checkout", "--detach", p.CommitSHA); err != nil {
424 if _, err := execOut(ctx, r.GitBin, "-C", work, "checkout", "--detach", p.CommitSHA); err != nil {
420 sink.closeSection()
425 sink.closeSection()
421 return nil, fmt.Errorf("checkout %s: %w", p.CommitSHA, err)
426 return nil, fmt.Errorf("checkout %s: %w", p.CommitSHA, err)
@@ -883,10 +888,31 @@ func (r *Runner) environment(ctx context.Context, repo store.Repo, p store.Pipel
883 // Na de jobvariabelen, zodat een eigen GIT_CONFIG_COUNT blijft staan
888 // Na de jobvariabelen, zodat een eigen GIT_CONFIG_COUNT blijft staan
884 // en safe.directory er alsnog bij komt.
889 // en safe.directory er alsnog bij komt.
885 markWorkspaceSafe(env)
890 markWorkspaceSafe(env)
891 JobGitAuth(env, base+"/"+repo.FullPath(), token)
886 mask = append(mask, token)
892 mask = append(mask, token)
887 return env, mask, nil
893 return env, mask, nil
888}
894}
889
895
896// JobGitAuth geeft git in de job leestoegang tot de eigen repo met het
897// job-token. De header geldt alleen voor de URL van dit project (met en
898// zonder .git) en het token vervalt als de job stopt. Via GIT_CONFIG_* werkt
899// het in elk image, zonder bestanden in de container.
900func JobGitAuth(env map[string]string, projectURL, token string) {
901 if projectURL == "" || token == "" || !strings.Contains(projectURL, "://") {
902 return
903 }
904 n := 0
905 if v, err := strconv.Atoi(strings.TrimSpace(env["GIT_CONFIG_COUNT"])); err == nil && v > 0 {
906 n = v
907 }
908 for _, u := range []string{projectURL, projectURL + ".git"} {
909 env[fmt.Sprintf("GIT_CONFIG_KEY_%d", n)] = "http." + u + ".extraHeader"
910 env[fmt.Sprintf("GIT_CONFIG_VALUE_%d", n)] = "Authorization: Bearer " + token
911 n++
912 }
913 env["GIT_CONFIG_COUNT"] = strconv.Itoa(n)
914}
915
890// markWorkspaceSafe zet safe.directory voor elke job.
916// markWorkspaceSafe zet safe.directory voor elke job.
891// De checkout is van de host-uid; de container-user is dat niet.
917// De checkout is van de host-uid; de container-user is dat niet.
892// Git 2.35+ weigert die repo anders. Een job die safe.directory al op
918// Git 2.35+ weigert die repo anders. Een job die safe.directory al op
internal/server/api.go +9 −1
@@ -126,7 +126,15 @@ func (s *Server) authorizeRepoRead(w http.ResponseWriter, r *http.Request, repo
126 126 http.Error(w, s.tr(r, "err.tokenAbsent"), http.StatusUnauthorized)
127 127 return false
128 128 }
129 if strings.HasPrefix(token, "bgj_") || !strings.HasPrefix(token, "bg_") {
129 if strings.HasPrefix(token, "bgj_") {
130 job, err := s.Store.JobByToken(r.Context(), token)
131 if err == nil && job.Status == "running" && job.RepoID == repo.ID {
132 return true
133 }
134 http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
135 return false
136 }
137 if !strings.HasPrefix(token, "bg_") {
130 138 http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
131 139 return false
132 140 }
@@ -126,7 +126,15 @@ func (s *Server) authorizeRepoRead(w http.ResponseWriter, r *http.Request, repo
126 http.Error(w, s.tr(r, "err.tokenAbsent"), http.StatusUnauthorized)
126 http.Error(w, s.tr(r, "err.tokenAbsent"), http.StatusUnauthorized)
127 return false
127 return false
128 }
128 }
129 if strings.HasPrefix(token, "bgj_") || !strings.HasPrefix(token, "bg_") {
129 if strings.HasPrefix(token, "bgj_") {
130 job, err := s.Store.JobByToken(r.Context(), token)
131 if err == nil && job.Status == "running" && job.RepoID == repo.ID {
132 return true
133 }
134 http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
135 return false
136 }
137 if !strings.HasPrefix(token, "bg_") {
130 http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
138 http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
131 return false
139 return false
132 }
140 }
internal/server/api_collab.go +3 −0
@@ -196,6 +196,9 @@ func (s *Server) apiRepo(w http.ResponseWriter, r *http.Request, min access.Role
196 196 s.writeAPIErr(w, r, fail(500, err))
197 197 return store.Repo{}, "", false
198 198 }
199 if jr := jobRole(r, repo.ID); jr != access.RoleNone && !role.CanRead() {
200 role = jr
201 }
199 202 readable := role.CanRead() || repo.Visibility == "public"
200 203 if !readable {
201 204 s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
@@ -196,6 +196,9 @@ func (s *Server) apiRepo(w http.ResponseWriter, r *http.Request, min access.Role
196 s.writeAPIErr(w, r, fail(500, err))
196 s.writeAPIErr(w, r, fail(500, err))
197 return store.Repo{}, "", false
197 return store.Repo{}, "", false
198 }
198 }
199 if jr := jobRole(r, repo.ID); jr != access.RoleNone && !role.CanRead() {
200 role = jr
201 }
199 readable := role.CanRead() || repo.Visibility == "public"
202 readable := role.CanRead() || repo.Visibility == "public"
200 if !readable {
203 if !readable {
201 s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
204 s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
internal/server/api_http.go +42 −0
@@ -21,6 +21,8 @@ type apiActor struct {
21 21 User store.User
22 22 Scopes access.Scopes
23 23 Via string
24 // JobRepo is de repo van een lopende job (Via "job"); alleen die mag hij lezen.
25 JobRepo int64
24 26 }
25 27
26 28 type apiAuth int
@@ -92,6 +94,10 @@ func (s *Server) serveAPI(w http.ResponseWriter, r *http.Request, rt apiRoute) {
92 94 return
93 95 }
94 96 }
97 if tok := tokenFrom(r); strings.HasPrefix(tok, "bgj_") {
98 s.serveJobAPI(w, r, rt, tok)
99 return
100 }
95 101 actor, ok := r.Context().Value(actorKey{}).(apiActor)
96 102 if !ok {
97 103 tok := tokenFrom(r)
@@ -356,3 +362,39 @@ func apiIndex() []byte {
356 362 })
357 363 return raw
358 364 }
365
366 // serveJobAPI laat een job-token alleen GET-routes van de eigen repo lezen,
367 // met de rechten van een leesrol. Al het andere is 401.
368 func (s *Server) serveJobAPI(w http.ResponseWriter, r *http.Request, rt apiRoute, tok string) {
369 deny := func() { s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.jobToken"))) }
370 if r.Method != http.MethodGet || !strings.Contains(rt.Path, "{owner}/{repo}") {
371 deny()
372 return
373 }
374 job, err := s.Store.JobByToken(r.Context(), tok)
375 if err != nil || job.Status != "running" {
376 deny()
377 return
378 }
379 repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
380 if err != nil || repo.ID != job.RepoID {
381 deny()
382 return
383 }
384 actor := apiActor{Scopes: access.StoredScopes(access.ScopeReadAPI + "," + access.ScopeReadRepo), Via: "job", JobRepo: job.RepoID}
385 if !actor.Scopes.Allows(rt.Class) {
386 s.writeAPIErr(w, r, fail(http.StatusForbidden, i18n.E("err.apiScope")))
387 return
388 }
389 ctx := context.WithValue(r.Context(), ctxKey{}, principal{OK: false})
390 ctx = context.WithValue(ctx, actorKey{}, actor)
391 rt.Handler(s, w, r.WithContext(ctx))
392 }
393
394 // jobRole geeft een leesrol als de API-aanroep van een job voor de eigen repo is.
395 func jobRole(r *http.Request, repoID int64) access.Role {
396 if a, ok := r.Context().Value(actorKey{}).(apiActor); ok && a.Via == "job" && a.JobRepo == repoID {
397 return access.RoleReadonly
398 }
399 return access.RoleNone
400 }
@@ -21,6 +21,8 @@ type apiActor struct {
21 User store.User
21 User store.User
22 Scopes access.Scopes
22 Scopes access.Scopes
23 Via string
23 Via string
24 // JobRepo is de repo van een lopende job (Via "job"); alleen die mag hij lezen.
25 JobRepo int64
24}
26}
25
27
26type apiAuth int
28type apiAuth int
@@ -92,6 +94,10 @@ func (s *Server) serveAPI(w http.ResponseWriter, r *http.Request, rt apiRoute) {
92 return
94 return
93 }
95 }
94 }
96 }
97 if tok := tokenFrom(r); strings.HasPrefix(tok, "bgj_") {
98 s.serveJobAPI(w, r, rt, tok)
99 return
100 }
95 actor, ok := r.Context().Value(actorKey{}).(apiActor)
101 actor, ok := r.Context().Value(actorKey{}).(apiActor)
96 if !ok {
102 if !ok {
97 tok := tokenFrom(r)
103 tok := tokenFrom(r)
@@ -356,3 +362,39 @@ func apiIndex() []byte {
356 })
362 })
357 return raw
363 return raw
358}
364}
365
366// serveJobAPI laat een job-token alleen GET-routes van de eigen repo lezen,
367// met de rechten van een leesrol. Al het andere is 401.
368func (s *Server) serveJobAPI(w http.ResponseWriter, r *http.Request, rt apiRoute, tok string) {
369 deny := func() { s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.jobToken"))) }
370 if r.Method != http.MethodGet || !strings.Contains(rt.Path, "{owner}/{repo}") {
371 deny()
372 return
373 }
374 job, err := s.Store.JobByToken(r.Context(), tok)
375 if err != nil || job.Status != "running" {
376 deny()
377 return
378 }
379 repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
380 if err != nil || repo.ID != job.RepoID {
381 deny()
382 return
383 }
384 actor := apiActor{Scopes: access.StoredScopes(access.ScopeReadAPI + "," + access.ScopeReadRepo), Via: "job", JobRepo: job.RepoID}
385 if !actor.Scopes.Allows(rt.Class) {
386 s.writeAPIErr(w, r, fail(http.StatusForbidden, i18n.E("err.apiScope")))
387 return
388 }
389 ctx := context.WithValue(r.Context(), ctxKey{}, principal{OK: false})
390 ctx = context.WithValue(ctx, actorKey{}, actor)
391 rt.Handler(s, w, r.WithContext(ctx))
392}
393
394// jobRole geeft een leesrol als de API-aanroep van een job voor de eigen repo is.
395func jobRole(r *http.Request, repoID int64) access.Role {
396 if a, ok := r.Context().Value(actorKey{}).(apiActor); ok && a.Via == "job" && a.JobRepo == repoID {
397 return access.RoleReadonly
398 }
399 return access.RoleNone
400}
internal/server/git_http.go +12 −1
@@ -28,7 +28,7 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {
28 28 }
29 29 service := r.URL.Query().Get("service")
30 30 write := service == "git-receive-pack" || strings.HasSuffix(r.URL.Path, "/git-receive-pack")
31 if !write && s.runnerMayClone(r, repo.ID) {
31 if !write && (s.runnerMayClone(r, repo.ID) || s.jobMayRead(r, repo.ID)) {
32 32 rest := strings.TrimPrefix(r.URL.Path, "/"+owner+"/"+repoSeg)
33 33 if err := gitrepo.ServeSmartHTTP(w, r, s.Git, gitrepo.ProjectRoot(s.StoragePath()), gitrepo.PathInfo(owner, repoSeg, rest), nil); err != nil && s.Log != nil {
34 34 s.Log.Error("git http", "err", err, "path", r.URL.Path)
@@ -124,6 +124,17 @@ func (s *Server) runnerMayClone(r *http.Request, repoID int64) bool {
124 124 return err == nil && s.Store.RunnerRunsRepo(r.Context(), rn.ID, repoID)
125 125 }
126 126
127 // jobMayRead: een lopende job (bgj_-token, als Bearer of als wachtwoord) mag
128 // alleen de eigen repo lezen. Schrijven of andere repo's lezen kan niet.
129 func (s *Server) jobMayRead(r *http.Request, repoID int64) bool {
130 tok := tokenFrom(r)
131 if !strings.HasPrefix(tok, "bgj_") {
132 return false
133 }
134 job, err := s.Store.JobByToken(r.Context(), tok)
135 return err == nil && job.Status == "running" && job.RepoID == repoID
136 }
137
127 138 func (s *Server) askAuth(w http.ResponseWriter) {
128 139 w.Header().Set("WWW-Authenticate", `Basic realm="BlueGit"`)
129 140 http.Error(w, "aanmelden met een toegangstoken als wachtwoord", http.StatusUnauthorized)
@@ -28,7 +28,7 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {
28 }
28 }
29 service := r.URL.Query().Get("service")
29 service := r.URL.Query().Get("service")
30 write := service == "git-receive-pack" || strings.HasSuffix(r.URL.Path, "/git-receive-pack")
30 write := service == "git-receive-pack" || strings.HasSuffix(r.URL.Path, "/git-receive-pack")
31 if !write && s.runnerMayClone(r, repo.ID) {
31 if !write && (s.runnerMayClone(r, repo.ID) || s.jobMayRead(r, repo.ID)) {
32 rest := strings.TrimPrefix(r.URL.Path, "/"+owner+"/"+repoSeg)
32 rest := strings.TrimPrefix(r.URL.Path, "/"+owner+"/"+repoSeg)
33 if err := gitrepo.ServeSmartHTTP(w, r, s.Git, gitrepo.ProjectRoot(s.StoragePath()), gitrepo.PathInfo(owner, repoSeg, rest), nil); err != nil && s.Log != nil {
33 if err := gitrepo.ServeSmartHTTP(w, r, s.Git, gitrepo.ProjectRoot(s.StoragePath()), gitrepo.PathInfo(owner, repoSeg, rest), nil); err != nil && s.Log != nil {
34 s.Log.Error("git http", "err", err, "path", r.URL.Path)
34 s.Log.Error("git http", "err", err, "path", r.URL.Path)
@@ -124,6 +124,17 @@ func (s *Server) runnerMayClone(r *http.Request, repoID int64) bool {
124 return err == nil && s.Store.RunnerRunsRepo(r.Context(), rn.ID, repoID)
124 return err == nil && s.Store.RunnerRunsRepo(r.Context(), rn.ID, repoID)
125}
125}
126
126
127// jobMayRead: een lopende job (bgj_-token, als Bearer of als wachtwoord) mag
128// alleen de eigen repo lezen. Schrijven of andere repo's lezen kan niet.
129func (s *Server) jobMayRead(r *http.Request, repoID int64) bool {
130 tok := tokenFrom(r)
131 if !strings.HasPrefix(tok, "bgj_") {
132 return false
133 }
134 job, err := s.Store.JobByToken(r.Context(), tok)
135 return err == nil && job.Status == "running" && job.RepoID == repoID
136}
137
127func (s *Server) askAuth(w http.ResponseWriter) {
138func (s *Server) askAuth(w http.ResponseWriter) {
128 w.Header().Set("WWW-Authenticate", `Basic realm="BlueGit"`)
139 w.Header().Set("WWW-Authenticate", `Basic realm="BlueGit"`)
129 http.Error(w, "aanmelden met een toegangstoken als wachtwoord", http.StatusUnauthorized)
140 http.Error(w, "aanmelden met een toegangstoken als wachtwoord", http.StatusUnauthorized)
internal/server/job_git_access_test.go added +100 −0
@@ -0,0 +1,100 @@
1 package server
2
3 import (
4 "context"
5 "net/http"
6 "os"
7 "os/exec"
8 "path/filepath"
9 "strings"
10 "testing"
11
12 "gitlab.com/Timfa/bluegit/internal/gitrepo"
13 "gitlab.com/Timfa/bluegit/internal/runner"
14 )
15
16 // Een lopende job leest de eigen privérepo met CI_JOB_TOKEN (git en API),
17 // maar geen andere repo, niet schrijven, en niet meer na afloop.
18 func TestJobTokenReadsOwnRepo(t *testing.T) {
19 e := newCIEnv(t)
20 ctx := context.Background()
21 st, base := e.st, e.ts.URL
22 other, err := st.CreateRepo(ctx, "user", e.user.ID, "other", "", "master", "private")
23 if err != nil {
24 t.Fatal(err)
25 }
26 if err := gitrepo.Init("git", gitrepo.Dir(e.srv.StoragePath(), other.OwnerPath, other.Name), "master", "/bin/true"); err != nil {
27 t.Fatal(err)
28 }
29 pid := e.pipeline()
30 jobs, _ := st.JobsByPipeline(ctx, pid)
31 tok, err := st.CreateJobToken(ctx, jobs[0].ID)
32 if err != nil {
33 t.Fatal(err)
34 }
35 if _, err := st.MarkJobRunning(ctx, jobs[0].ID); err != nil {
36 t.Fatal(err)
37 }
38 own := base + "/tim/app"
39 // Precies de config die de runner de job meegeeft (GIT_CONFIG_*).
40 env := map[string]string{}
41 runner.JobGitAuth(env, own, tok)
42 git := func(args ...string) (string, error) {
43 cmd := exec.Command("git", args...)
44 cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_ASKPASS=/bin/false")
45 for k, v := range env {
46 cmd.Env = append(cmd.Env, k+"="+v)
47 }
48 out, err := cmd.CombinedOutput()
49 return string(out), err
50 }
51 for _, u := range []string{own + ".git"} {
52 if out, err := git("ls-remote", u); err != nil || !strings.Contains(out, e.sha) {
53 t.Fatalf("ls-remote %s: %v %s", u, err, out)
54 }
55 }
56 dir := filepath.Join(t.TempDir(), "c")
57 if out, err := git("clone", "-q", own+".git", dir); err != nil {
58 t.Fatalf("clone: %v %s", err, out)
59 }
60 if out, err := git("-C", dir, "fetch", "-q", "origin"); err != nil {
61 t.Fatalf("fetch: %v %s", err, out)
62 }
63 if out, err := git("-C", dir, "push", "-q", "origin", "HEAD:refs/heads/x"); err == nil {
64 t.Fatalf("push with job token must fail: %s", out)
65 }
66 // De header geldt alleen voor de eigen URL; met het token expliciet
67 // erbij kan een andere repo ook niet.
68 if out, err := git("-c", "http.extraHeader=Authorization: Bearer "+tok, "ls-remote", base+"/tim/other.git"); err == nil {
69 t.Fatalf("other repo readable: %s", out)
70 }
71 api := func(path string) int {
72 req, _ := http.NewRequest("GET", base+"/api/v1"+path, nil)
73 req.Header.Set("Authorization", "Bearer "+tok)
74 resp, err := http.DefaultClient.Do(req)
75 if err != nil {
76 t.Fatal(err)
77 }
78 resp.Body.Close()
79 return resp.StatusCode
80 }
81 if c := api("/projects/tim/app"); c != 200 {
82 t.Fatalf("api own: %d", c)
83 }
84 if c := api("/projects/tim/other"); c == 200 {
85 t.Fatalf("api other: %d", c)
86 }
87 if c := api("/user"); c == 200 {
88 t.Fatalf("api user: %d", c)
89 }
90 // Na afloop vervalt alles.
91 if err := st.FinishJob(ctx, jobs[0].ID, "success", ""); err != nil {
92 t.Fatal(err)
93 }
94 if out, err := git("ls-remote", own+".git"); err == nil {
95 t.Fatalf("ls-remote after job: %s", out)
96 }
97 if c := api("/projects/tim/app"); c == 200 {
98 t.Fatalf("api after job: %d", c)
99 }
100 }
@@ -0,0 +1,100 @@
1package server
2
3import (
4 "context"
5 "net/http"
6 "os"
7 "os/exec"
8 "path/filepath"
9 "strings"
10 "testing"
11
12 "gitlab.com/Timfa/bluegit/internal/gitrepo"
13 "gitlab.com/Timfa/bluegit/internal/runner"
14)
15
16// Een lopende job leest de eigen privérepo met CI_JOB_TOKEN (git en API),
17// maar geen andere repo, niet schrijven, en niet meer na afloop.
18func TestJobTokenReadsOwnRepo(t *testing.T) {
19 e := newCIEnv(t)
20 ctx := context.Background()
21 st, base := e.st, e.ts.URL
22 other, err := st.CreateRepo(ctx, "user", e.user.ID, "other", "", "master", "private")
23 if err != nil {
24 t.Fatal(err)
25 }
26 if err := gitrepo.Init("git", gitrepo.Dir(e.srv.StoragePath(), other.OwnerPath, other.Name), "master", "/bin/true"); err != nil {
27 t.Fatal(err)
28 }
29 pid := e.pipeline()
30 jobs, _ := st.JobsByPipeline(ctx, pid)
31 tok, err := st.CreateJobToken(ctx, jobs[0].ID)
32 if err != nil {
33 t.Fatal(err)
34 }
35 if _, err := st.MarkJobRunning(ctx, jobs[0].ID); err != nil {
36 t.Fatal(err)
37 }
38 own := base + "/tim/app"
39 // Precies de config die de runner de job meegeeft (GIT_CONFIG_*).
40 env := map[string]string{}
41 runner.JobGitAuth(env, own, tok)
42 git := func(args ...string) (string, error) {
43 cmd := exec.Command("git", args...)
44 cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0", "GIT_ASKPASS=/bin/false")
45 for k, v := range env {
46 cmd.Env = append(cmd.Env, k+"="+v)
47 }
48 out, err := cmd.CombinedOutput()
49 return string(out), err
50 }
51 for _, u := range []string{own + ".git"} {
52 if out, err := git("ls-remote", u); err != nil || !strings.Contains(out, e.sha) {
53 t.Fatalf("ls-remote %s: %v %s", u, err, out)
54 }
55 }
56 dir := filepath.Join(t.TempDir(), "c")
57 if out, err := git("clone", "-q", own+".git", dir); err != nil {
58 t.Fatalf("clone: %v %s", err, out)
59 }
60 if out, err := git("-C", dir, "fetch", "-q", "origin"); err != nil {
61 t.Fatalf("fetch: %v %s", err, out)
62 }
63 if out, err := git("-C", dir, "push", "-q", "origin", "HEAD:refs/heads/x"); err == nil {
64 t.Fatalf("push with job token must fail: %s", out)
65 }
66 // De header geldt alleen voor de eigen URL; met het token expliciet
67 // erbij kan een andere repo ook niet.
68 if out, err := git("-c", "http.extraHeader=Authorization: Bearer "+tok, "ls-remote", base+"/tim/other.git"); err == nil {
69 t.Fatalf("other repo readable: %s", out)
70 }
71 api := func(path string) int {
72 req, _ := http.NewRequest("GET", base+"/api/v1"+path, nil)
73 req.Header.Set("Authorization", "Bearer "+tok)
74 resp, err := http.DefaultClient.Do(req)
75 if err != nil {
76 t.Fatal(err)
77 }
78 resp.Body.Close()
79 return resp.StatusCode
80 }
81 if c := api("/projects/tim/app"); c != 200 {
82 t.Fatalf("api own: %d", c)
83 }
84 if c := api("/projects/tim/other"); c == 200 {
85 t.Fatalf("api other: %d", c)
86 }
87 if c := api("/user"); c == 200 {
88 t.Fatalf("api user: %d", c)
89 }
90 // Na afloop vervalt alles.
91 if err := st.FinishJob(ctx, jobs[0].ID, "success", ""); err != nil {
92 t.Fatal(err)
93 }
94 if out, err := git("ls-remote", own+".git"); err == nil {
95 t.Fatalf("ls-remote after job: %s", out)
96 }
97 if c := api("/projects/tim/app"); c == 200 {
98 t.Fatalf("api after job: %d", c)
99 }
100}