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 @@ -60,14 +60,30 @@ 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 @@ -191,24 +191,52 @@ 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 @@ -5,7 +5,8 @@ import ( "errors" "fmt" "net/http" - "regexp" + "strconv" + "strings" "time" "github.com/oauth2-proxy/oauth2-proxy/v7/pkg/apis/options" @@ -71,30 +72,47 @@ 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_ - 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 { @@ -121,8 +139,21 @@ 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 }