Skip to content

Instantly share code, notes, and snippets.

Show Gist options
  • Select an option

  • Save halter73/aca998c8855b4260b7ae2e705d85ec98 to your computer and use it in GitHub Desktop.

Select an option

Save halter73/aca998c8855b4260b7ae2e705d85ec98 to your computer and use it in GitHub Desktop.
Copilot Chat Conversation Export: Parsing WWW-Authenticate parameters in .NET 10

@halter73

Is there an API available in .NET 10 to securely parse the parameters in a WWW-Authenticate response header which properly handles quotes?

Copilot

No—.NET 10 doesn’t provide a dedicated, public API specifically for parsing the parameter list of a WWW-Authenticate response header (e.g., handling realm="a, b" and other quoted-string edge cases) into a key/value map for you.

What you can use in .NET 10 are the existing header/authentication types, but they don’t directly solve “parse all challenges and their quoted parameters” in a single call:

  • System.Net.Http.Headers.AuthenticationHeaderValue / AuthenticationHeaderValue.TryParse(...) — parses a single auth header value, but parameter parsing is limited and it doesn’t conveniently handle multiple challenges in one WWW-Authenticate header value.
  • System.Net.Http.Headers.AuthenticationHeaderValue.TryParseList(...) — can split multiple challenges, but you still typically need your own robust parameter parsing if you need strict RFC behavior around quoted strings/escapes.

If you share an example header value you’re receiving (especially one that breaks naïve Split(',') parsing), I can provide a small, correct parser for WWW-Authenticate challenges that properly handles quoted strings and escape sequences, or point you at the best-fit built-in types for your specific scheme (Basic/Bearer/Digest/Negotiate).

@halter73

I'm currently using an implementation like this:

    private static string? ParseWwwAuthenticateParameters(string parameters, string parameterName)
    {
        if (parameters.IndexOf(parameterName, StringComparison.OrdinalIgnoreCase) == -1)
        {
            return null;
        }

        foreach (var part in parameters.Split(','))
        {
            var trimmedPart = part.AsSpan().Trim();
            int equalsIndex = trimmedPart.IndexOf('=');

            if (equalsIndex <= 0)
            {
                continue;
            }

            var key = trimmedPart[..equalsIndex].Trim();

            if (key.Equals(parameterName, StringComparison.OrdinalIgnoreCase))
            {
                var value = trimmedPart[(equalsIndex + 1)..].Trim();
                if (value.Length > 0 && value[0] == '"' && value[^1] == '"')
                {
                    value = value[1..^1];
                }

                return value.ToString();
            }
        }

        return null;
    }

Can you fix it so that handles commas inside quoted parameters efficiently, and doesn't throw an ArgumentOutOfRangeException given something like param=",?

Copilot

Here’s a fast, allocation-light fix that:

  • does not Split(',') (so commas inside quotes are OK)
  • handles \" escapes inside quoted-string
  • never slices past the end (so param=", won’t throw)
  • returns the first matching parameter value (like your current code)
private static string? ParseWwwAuthenticateParameters(string parameters, string parameterName)
{
    if (string.IsNullOrEmpty(parameters) || string.IsNullOrEmpty(parameterName))
        return null;

    ReadOnlySpan<char> s = parameters.AsSpan();
    ReadOnlySpan<char> target = parameterName.AsSpan();

    int i = 0;
    while (i < s.Length)
    {
        // Skip whitespace and commas
        while (i < s.Length && (s[i] == ',' || char.IsWhiteSpace(s[i])))
            i++;

        if (i >= s.Length)
            break;

        // Parse key = token up to '=' or delimiter
        int keyStart = i;
        while (i < s.Length && s[i] != '=' && s[i] != ',')
            i++;

        // If no '=', this "part" is malformed; skip to next comma (respecting quotes just in case)
        if (i >= s.Length || s[i] != '=')
        {
            SkipToNextCommaRespectingQuotes(s, ref i);
            continue;
        }

        int keyEnd = i; // exclusive
        i++; // skip '='

        ReadOnlySpan<char> key = s.Slice(keyStart, keyEnd - keyStart).Trim();

        // Parse value: quoted-string or token, ending at next comma (outside quotes) or end
        ReadOnlySpan<char> valueSpan;
        bool wasQuoted = false;

        // Skip leading whitespace before value
        while (i < s.Length && char.IsWhiteSpace(s[i]))
            i++;

        if (i < s.Length && s[i] == '"')
        {
            wasQuoted = true;
            i++; // skip opening quote
            int valueStart = i;

            bool escaped = false;
            while (i < s.Length)
            {
                char c = s[i];
                if (escaped)
                {
                    escaped = false;
                    i++;
                    continue;
                }

                if (c == '\\')
                {
                    escaped = true;
                    i++;
                    continue;
                }

                if (c == '"')
                {
                    // closing quote found
                    break;
                }

                i++;
            }

            // value is everything up to the closing quote (or end if malformed / unterminated)
            int valueEnd = i; // exclusive
            valueSpan = s.Slice(valueStart, valueEnd - valueStart);

            // If we stopped on a closing quote, consume it; otherwise unterminated quote -> consume to end
            if (i < s.Length && s[i] == '"')
                i++;

            // After quoted value, consume optional whitespace, then skip until next comma (outside quotes)
            while (i < s.Length && char.IsWhiteSpace(s[i]))
                i++;

            // If there's junk before the comma, skip it (some servers add it)
            SkipToNextCommaRespectingQuotes(s, ref i);
        }
        else
        {
            int valueStart = i;
            // read until comma or end
            while (i < s.Length && s[i] != ',')
                i++;

            int valueEnd = i;
            valueSpan = s.Slice(valueStart, valueEnd - valueStart).Trim();
            // i is at comma or end; the loop top will skip commas/space
        }

        if (key.Equals(target, StringComparison.OrdinalIgnoreCase))
        {
            if (!wasQuoted)
                return valueSpan.ToString();

            // Unescape quoted-string only if necessary (keeps it efficient)
            if (valueSpan.IndexOf('\\') < 0)
                return valueSpan.ToString();

            return UnescapeQuotedString(valueSpan);
        }

        // If we're on a comma, next loop iteration will skip it
    }

    return null;

    static void SkipToNextCommaRespectingQuotes(ReadOnlySpan<char> s, ref int i)
    {
        bool inQuotes = false;
        bool escaped = false;

        while (i < s.Length)
        {
            char c = s[i];

            if (escaped)
            {
                escaped = false;
                i++;
                continue;
            }

            if (c == '\\' && inQuotes)
            {
                escaped = true;
                i++;
                continue;
            }

            if (c == '"')
            {
                inQuotes = !inQuotes;
                i++;
                continue;
            }

            if (c == ',' && !inQuotes)
            {
                // stop at comma (do not consume; caller will skip it)
                return;
            }

            i++;
        }
    }

    static string UnescapeQuotedString(ReadOnlySpan<char> value)
    {
        // RFC-ish unescape: \" and \\ (and allow escaping any char after '\')
        var sb = new System.Text.StringBuilder(value.Length);
        for (int j = 0; j < value.Length; j++)
        {
            char c = value[j];
            if (c == '\\' && j + 1 < value.Length)
            {
                sb.Append(value[j + 1]);
                j++;
            }
            else
            {
                sb.Append(c);
            }
        }
        return sb.ToString();
    }
}

Behaviors / examples

  • realm="a,b", error="invalid_token" → realm returns a,b (comma preserved)
  • param="," → returns , (no exception)
  • param="\,", other=x → returns , (unescaped)
  • malformed unterminated: param="abc, other=x → param returns abc, other=x up to end (no exception)

If you want to parse all params into a dictionary (and/or support multiple challenges in a single header), tell me the exact header shape you’re receiving and I’ll adapt this into a proper IReadOnlyDictionary<string,string> / multi-challenge parser.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment