Datasets:
Tasks:
Text Generation
Formats:
parquet
Sub-tasks:
language-modeling
Languages:
English
Size:
< 1K
License:
| diff --git a/pkg/cookies/cookies.go b/pkg/cookies/cookies.go | |
| index be5ee451..5427b20d 100644 | |
| --- a/pkg/cookies/cookies.go | |
| +++ b/pkg/cookies/cookies.go | |
| func MakeCookieFromOptions(req *http.Request, opts *CookieOptions) *http.Cookie | |
| // by checking the X-Fowarded-Host and host header of an an http request | |
| func GetCookieDomain(req *http.Request, cookieDomains []string) string { | |
| host := requestutil.GetRequestHost(req) | |
| + if h, _, err := net.SplitHostPort(host); err == nil { | |
| + host = h | |
| + } | |
| for _, domain := range cookieDomains { | |
| - if strings.HasSuffix(host, domain) { | |
| + if hostInDomain(host, domain) { | |
| return domain | |
| } | |
| } | |
| return "" | |
| } | |
| +// hostInDomain reports whether host sits inside the cookie domain. Membership | |
| +// is decided on whole DNS labels: sharing a character suffix with the domain | |
| +// is not the same as being part of it. | |
| +func hostInDomain(host, domain string) bool { | |
| + if host == "" || domain == "" { | |
| + return false | |
| + } | |
| + if strings.HasPrefix(domain, ".") { | |
| + return strings.HasSuffix(host, domain) | |
| + } | |
| + return host == domain || strings.HasSuffix(host, "."+domain) | |
| +} | |
| + | |
| // ParseSameSite a valid http.SameSite value from a user supplied string for use of making cookies. | |
| func ParseSameSite(v string) http.SameSite { | |
| switch v { | |
| diff --git a/pkg/cookies/csrf.go b/pkg/cookies/csrf.go | |
| index 2614f378..ddd09737 100644 | |
| --- a/pkg/cookies/csrf.go | |
| +++ b/pkg/cookies/csrf.go | |
| func ClearExtraCsrfCookies(opts *options.Cookie, rw http.ResponseWriter, req *ht | |
| } | |
| decodedCookies := []*csrf{} | |
| + undecodableCookies := []*http.Cookie{} | |
| for _, cookie := range existingCsrfCookies { | |
| decodedCookie, err := decodeCSRFCookie(cookie, opts) | |
| if err != nil { | |
| + undecodableCookies = append(undecodableCookies, cookie) | |
| continue | |
| } | |
| decodedCookies = append(decodedCookies, decodedCookie) | |
| } | |
| - // delete the X oldest cookies | |
| + // delete the X oldest cookies, counting every CSRF cookie the request | |
| + // carries. Cookies that no longer decode can never be used again, so they | |
| + // go first. | |
| slices.SortStableFunc(decodedCookies, func(a, b *csrf) int { | |
| return a.clock().Compare(b.clock()) | |
| }) | |
| - for i := 0; i < len(decodedCookies)-opts.CSRFPerRequestLimit; i++ { | |
| + excess := len(existingCsrfCookies) - opts.CSRFPerRequestLimit | |
| + for _, cookie := range undecodableCookies { | |
| + if excess <= 0 { | |
| + break | |
| + } | |
| + clearCsrfCookieByName(opts, rw, req, cookie.Name) | |
| + excess-- | |
| + } | |
| + for i := 0; i < len(decodedCookies) && excess > 0; i++ { | |
| decodedCookies[i].ClearCookie(rw, req) | |
| + excess-- | |
| } | |
| } | |
| +// clearCsrfCookieByName removes a CSRF cookie the proxy could not decode, and | |
| +// so has no csrf value to rebuild the name from. | |
| +func clearCsrfCookieByName(opts *options.Cookie, rw http.ResponseWriter, req *http.Request, name string) { | |
| + http.SetCookie(rw, MakeCookieFromOptions(req, &CookieOptions{ | |
| + Name: name, | |
| + Value: "", | |
| + Domains: opts.Domains, | |
| + Expiration: time.Hour * -1, | |
| + SameSite: getCSRFSameSite(opts), | |
| + Path: opts.Path, | |
| + HTTPOnly: opts.HTTPOnly, | |
| + Secure: opts.Secure, | |
| + })) | |
| +} | |
| + | |
| // ClearCookie removes the CSRF cookie | |
| func (c *csrf) ClearCookie(rw http.ResponseWriter, req *http.Request) { | |
| csrfCookieOptions := &CookieOptions{ | |
| diff --git a/pkg/sessions/cookie/session_store.go b/pkg/sessions/cookie/session_store.go | |
| index a4da3734..3e44a99a 100644 | |
| --- a/pkg/sessions/cookie/session_store.go | |
| +++ b/pkg/sessions/cookie/session_store.go | |
| import ( | |
| "errors" | |
| "fmt" | |
| "net/http" | |
| - "regexp" | |
| + "strconv" | |
| + "strings" | |
| "time" | |
| "github.com/oauth2-proxy/oauth2-proxy/v7/pkg/apis/options" | |
| func (s *SessionStore) Load(req *http.Request) (*sessions.SessionState, error) { | |
| // Clear clears any saved session information by writing a cookie to | |
| // clear the session | |
| func (s *SessionStore) Clear(rw http.ResponseWriter, req *http.Request) error { | |
| - // matches CookieName, CookieName_<number> | |
| - var cookieNameRegex = regexp.MustCompile(fmt.Sprintf("^%s(_\\d+)?$", s.Cookie.Name)) | |
| - | |
| for _, c := range req.Cookies() { | |
| - if cookieNameRegex.MatchString(c.Name) { | |
| - sessionCookieOptions := &pkgcookies.CookieOptions{ | |
| - Name: c.Name, | |
| - Value: "", | |
| - Domains: s.Cookie.Domains, | |
| - Expiration: time.Hour * -1, | |
| - SameSite: s.Cookie.SameSite, | |
| - Path: s.Cookie.Path, | |
| - HTTPOnly: s.Cookie.HTTPOnly, | |
| - Secure: s.Cookie.Secure, | |
| - } | |
| - clearCookie := pkgcookies.MakeCookieFromOptions(req, sessionCookieOptions) | |
| - | |
| - http.SetCookie(rw, clearCookie) | |
| + if s.ownsCookieName(c.Name) { | |
| + http.SetCookie(rw, s.expireCookie(req, c.Name)) | |
| } | |
| } | |
| return nil | |
| } | |
| +// ownsCookieName reports whether name is one of the names this store writes | |
| +// the session under: the configured name, or one of the chunk names produced | |
| +// by splitCookieName for it. | |
| +func (s *SessionStore) ownsCookieName(name string) bool { | |
| + if name == s.Cookie.Name { | |
| + return true | |
| + } | |
| + i := strings.LastIndex(name, "_") | |
| + if i < 0 { | |
| + return false | |
| + } | |
| + count, err := strconv.Atoi(name[i+1:]) | |
| + if err != nil || count < 0 { | |
| + return false | |
| + } | |
| + return splitCookieName(s.Cookie.Name, count) == name | |
| +} | |
| + | |
| +// expireCookie builds a cookie that asks the client to drop name. | |
| +func (s *SessionStore) expireCookie(req *http.Request, name string) *http.Cookie { | |
| + return pkgcookies.MakeCookieFromOptions(req, &pkgcookies.CookieOptions{ | |
| + Name: name, | |
| + Value: "", | |
| + Domains: s.Cookie.Domains, | |
| + Expiration: time.Hour * -1, | |
| + SameSite: s.Cookie.SameSite, | |
| + Path: s.Cookie.Path, | |
| + HTTPOnly: s.Cookie.HTTPOnly, | |
| + Secure: s.Cookie.Secure, | |
| + }) | |
| +} | |
| + | |
| // VerifyConnection always return no-error, as there's no connection | |
| // in this store | |
| func (s *SessionStore) VerifyConnection(_ context.Context) error { | |
| func (s *SessionStore) setSessionCookie(rw http.ResponseWriter, req *http.Reques | |
| if err != nil { | |
| return err | |
| } | |
| + written := make(map[string]struct{}, len(cookies)) | |
| for _, c := range cookies { | |
| http.SetCookie(rw, c) | |
| + written[c.Name] = struct{}{} | |
| + } | |
| + // A session that needs a different number of cookies than the one already | |
| + // on the client leaves names behind. Those are still sent back on the next | |
| + // request and would be joined into the value, so expire them here. | |
| + for _, c := range req.Cookies() { | |
| + if _, rewritten := written[c.Name]; rewritten { | |
| + continue | |
| + } | |
| + if s.ownsCookieName(c.Name) { | |
| + http.SetCookie(rw, s.expireCookie(req, c.Name)) | |
| + } | |
| } | |
| return nil | |
| } | |