git/list[1] front-page[2] threads[3] people[4] search[5] about
 

Re: [PATCH 14/16] promisor-remote: trust known remotes matching acceptFromServerUrl

From
Christian Couder <christian.couder@gmail.com>
Date
Mar 27, 2026, 12:17 UTC
Message-ID
<CAP8UFD2vAK_khTkJMP4QBfhYA5iYVW5sfB3i-vnzhf71BvwQ=w@mail.gmail.com>
In-Reply-To
<xmqqzf3y4bsg.fsf@gitster.g>
On Mon, Mar 23, 2026 at 7:54 PM Junio C Hamano <gitster@pobox.com> wrote:
Show 24 quoted lines
>
> Christian Couder <christian.couder@gmail.com> 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".
Show 5 quoted lines
> > +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.

[...]
Show 28 quoted lines
> >> +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.
Show 14 quoted lines
> 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.
Previous: Junio C HamanoNext: Junio C Hamano
Message 37 of 47 in “Auto-configure advertised remotes via URL whitelist”
  1. 00/16 Auto-configure advertised remotes via URL whitelistChristian Couder, Mar 23, 2026
  2. 01/16 promisor-remote: try accepted remotes before others in get_direct()Christian Couder, Mar 23, 2026
  3. Patrick SteinhardtMar 26, 2026
  4. Christian CouderApr 2, 2026
  5. 02/16 urlmatch: change 'allow_globs' arg to boolChristian Couder, Mar 23, 2026
  6. 03/16 urlmatch: add url_is_valid_pattern() helperChristian Couder, Mar 23, 2026
  7. Patrick SteinhardtMar 26, 2026
  8. Christian CouderApr 27, 2026
  9. 04/16 promisor-remote: clarify that a remote is ignoredChristian Couder, Mar 23, 2026
  10. Patrick SteinhardtMar 26, 2026
  11. Christian CouderApr 2, 2026
  12. 05/16 promisor-remote: refactor has_control_char()Christian Couder, Mar 23, 2026
  13. 06/16 promisor-remote: refactor accept_from_server()Christian Couder, Mar 23, 2026
  14. 07/16 promisor-remote: keep accepted promisor_info structs aliveChristian Couder, Mar 23, 2026
  15. Patrick SteinhardtMar 26, 2026
  16. 08/16 promisor-remote: remove the 'accepted' strvecChristian Couder, Mar 23, 2026
  17. Patrick SteinhardtMar 26, 2026
  18. Christian CouderApr 2, 2026
  19. 09/16 promisor-remote: add 'local_name' to 'struct promisor_info'Christian Couder, Mar 23, 2026
  20. Patrick SteinhardtMar 26, 2026
  21. Christian CouderApr 27, 2026
  22. 10/16 promisor-remote: pass config entry to all_fields_match() directlyChristian Couder, Mar 23, 2026
  23. Patrick SteinhardtMar 26, 2026
  24. Christian CouderApr 2, 2026
  25. 12/16 t5710: use proper file:// URIs for absolute pathsChristian Couder, Mar 23, 2026
  26. Patrick SteinhardtMar 26, 2026
  27. Christian CouderApr 2, 2026
  28. 13/16 promisor-remote: introduce promisor.acceptFromServerUrlChristian Couder, Mar 23, 2026
  29. Patrick SteinhardtMar 26, 2026
  30. Christian CouderApr 27, 2026
  31. 11/16 promisor-remote: refactor should_accept_remote() control flowChristian Couder, Mar 23, 2026
  32. Patrick SteinhardtMar 26, 2026
  33. Christian CouderApr 2, 2026
  34. 14/16 promisor-remote: trust known remotes matching acceptFromServerUrlChristian Couder, Mar 23, 2026
  35. Junio C HamanoMar 23, 2026
  36. Junio C HamanoMar 23, 2026
  37. Christian CouderMar 27, 2026
  38. Junio C HamanoMar 31, 2026
  39. Christian CouderApr 1, 2026
  40. Patrick SteinhardtMar 26, 2026
  41. Christian CouderApr 27, 2026
  42. 16/16 doc: promisor: improve acceptFromServer entryChristian Couder, Mar 23, 2026
  43. 15/16 promisor-remote: auto-configure unknown remotesChristian Couder, Mar 23, 2026
  44. Patrick SteinhardtMar 26, 2026
  45. Christian CouderApr 27, 2026
  46. Patrick SteinhardtMar 26, 2026
  47. Christian CouderApr 2, 2026

Read the whole thread, see it on lore, or plain text.

$ cat FOOTERMessages come from the public archive at lore.kernel.org/git, fetched every hour. The front page is chosen and written each morning by an AI editor and can be wrong; the threads themselves are the record. About and API. For agents: an MCP server at https://gitlist.dev/mcp, and any thread, story or person page as Markdown by adding .md to its URL (or sending Accept: text/markdown). Details in /llms.txt.