From: Christian Couder Date: Fri, 27 Mar 2026 12:17:59 GMT Subject: Re: [PATCH 14/16] promisor-remote: trust known remotes matching acceptFromServerUrl Message-ID: In-Reply-To: On Mon, Mar 23, 2026 at 7:54 PM Junio C Hamano wrote: > > Christian Couder writes: > > > diff --git a/Documentation/config/promisor.adoc b/Documentation/config/promisor.adoc > > index b0fa43b839..6f5442cd65 100644 > > --- a/Documentation/config/promisor.adoc > > +++ b/Documentation/config/promisor.adoc > > @@ -51,6 +51,52 @@ promisor.acceptFromServer:: > > to "fetch" and "clone" requests from the client. Name and URL > > comparisons are case sensitive. See linkgit:gitprotocol-v2[5]. > > > > +promisor.acceptFromServerUrl:: > > + A glob pattern to specify which URLs advertised by a server > > + are considered trusted by the client. This option acts as an > > + additive security whitelist that works in conjunction with > > + `promisor.acceptFromServer`. > > Between the first sentence and the second one, I think there needs > to be an explanation on what "trusted" means in this context. Is it > trusted so that the URL can feed random configuration variable=value > pairs for the client to blindly apply? Or is it trusted to do very > limited things that other remotes can do, and if so what are these > limited things? Without knowing that, the end-users cannot assess > the security implications of setting this option. Yeah, in the current version, the following is used, which is more explicit: A glob pattern to specify which server-advertised URLs a client is allowed to act on. When a URL matches, the client will accept the advertised remote as a promisor remote and may automatically accept field updates (such as authentication tokens) from the server, even if `promisor.acceptFromServer` is set to `none` (the default). > I am guessing that the client would behave as if the existing > promisor.acceptFromServer configuration variable were set to "all" > when talking with a remote whose URL matches one of the patterns > listed? Yes, that's the idea. > By the way, some people may suggest "white" -> "allow". Right, I have changed all the "whitelist" instances with "allowlist". > > +1. Start with a secure protocol scheme, like `https://` or `ssh://`. > > Is there a practical reason why people would want to use schemes > other than the above two? This sounds like something a small amount > of code can easily enforce. The main issue is that some remote helper schemes might be secure, while it might be difficult to maintain a hardcoded allowlist of them. (Different implementations might exist out there with the same scheme name but different security properties.) Also file:// and http:// for example might be OK in some corporate setups. We could add yet another config variable (or env variable) for an allowlist of schemes (on top of `https://` and `ssh://` which would be the only ones accepted by default), but maybe we can do that in a future patch series. [...] > >> +3. Don't use globs (`*`) in the domain name. For example > >> + `https://cdn.example.com/*` is much safer than > >> + `https://*.example.com/*`, because the latter matches > >> + `https://evil-hacker.net/fake.example.com/repo`. > > > > Is there a practical use case where allowing '*' to match anything > > that contains a slash '/' is useful? > > > >> +4. Make sure to have a `/` at the end of the domain name (or the end > >> + of specific directories). For example `https://cdn.example.com/*` > >> + is much safer than `https://cdn.example.com*`, because the latter > >> + matches `https://cdn.example.com.hacker.net/repo`. > > > > Ditto. The above two points sound like excuses to keep sloppy > > asterisk matching logic. Yes, retroactively tightening rules always > > have risk to break existing deployments, but if existing code paths > > of urlmatch do not have any good reason to allow '*' to match a > > string that contains a slash '/', perhaps there is no fallout. > > I probably should caution the readers not to take the above too > literally. Forbidding an asterisk '*' glob not to match '/' > anywhere in urlmatch will obviusly break existing deployments that > does this > > [http "https://example.com/*"] > var = val > > and expects it to catch any URL pointing into the site. Yeah, the main reason for allowing an asterisk '*' glob to match '/' is to allow something like: git config set --global promisor.acceptFromServerUrl "https://my-org.com/*" to be all what is needed for most internal work in many random orgs. > But I still do think the matcher should be more intelligent than the > current implementation to avoid pitfalls like #3 and #4 above. > > Perhaps if an additional rule says that '*' after the scheme:// part > before the first '/' in the pattern, e.g., > > https://*.example.com/ > https://*.example.com > https://example.com* > > unlike '*' that appear anywhere else, never matches a substring that > contains a slash '/' in it, it would cover plausible mistakes that > the above #3 and #4 are trying to catch, without hurting any real > world use case? I agree that it is better security wise, so I have implemented it in the current version. Now the scheme and port parts must match exactly while * match any sequence of characters within the host and path parts but cannot cross part boundaries. It's not a panacea though. Users still have to be very careful. The current documentation looks like this: -------------------- promisor.acceptFromServerUrl:: A glob pattern to specify which server-advertised URLs a client is allowed to act on. When a URL matches, the client will accept the advertised remote as a promisor remote and may automatically accept field updates (such as authentication tokens) from the server, even if `promisor.acceptFromServer` is set to `none` (the default). + This option can appear multiple times in config files. An advertised URL will be accepted if it matches _ANY_ glob pattern specified by this option in _ANY_ config file read by Git. + Be _VERY_ careful with these patterns: `*` matches any sequence of characters within the 'host' and 'path' parts of a URL (but cannot cross part boundaries). An overly broad pattern is a major security risk, as a matching URL allows a server to update fields (such as authentication tokens) on known remotes without further confirmation. To minimize security risks, follow these guidelines: + 1. Start with a secure protocol scheme, like `https://` or `ssh://`. + 2. Only allow domain names or paths where you control and trust _ALL_ the content. Be especially careful with shared hosting platforms like `github.com` or `gitlab.com`. A broad pattern like `https://gitlab.com/*` is dangerous because it trusts every repository on the entire platform. Always restrict such patterns to your specific organization or namespace (e.g., `https://gitlab.com/your-org/*`). + 3. Never use globs at the end of domain names. For example, `https://cdn.your-org.com/*` might be safe, but `https://cdn.your-org.com*/*` is a major security risk because the latter matches `https://cdn.your-org.com.hacker.net/repo`. + 4. Be careful using globs at the beginning of domain names. While the code ensures a `*` in the host cannot cross into the path, a pattern like `https://*.example.com/*` will still match any subdomain. This is extremely dangerous on shared hosting platforms (e.g., `https://*.github.io/*` trusts every user's site on the entire platform). + Before matching, both the advertised URL and the pattern are normalized: the scheme and host are lowercased, percent-encoded characters are decoded where possible, and path segments like `..` are resolved. The port must also match exactly (e.g., `https://example.com:8080/*` will not match a URL advertised on port 9999). + For the security implications of accepting a promisor remote, see the documentation of `promisor.acceptFromServer`. For details on the protocol, see linkgit:gitprotocol-v2[5]. -------------------- I will work on the suggestions Patrick made before sending the v2 (which I may split into 2 patch series as Patrick suggested). Thanks.