more confusing than it seems

Perhaps overkill, but I liked the collection method in this way.

public class RequestBuilder
{
    List<RequesItemClass> items = new List<RequesItemClass>();
    public void AddParam(string name, string value)
    {
        items.Add(new RequesItemClass { name = name, value = value });
    }
    public override string ToString()
    {
        return string.Join("&", items.Select(a => a.name + "=" + a.value));
    }
}

public class RequesItemClass
{
    public string name;
    public string value;
}

async Task<string> UrlBuild(string redirectUri)
{
    using var client = new HttpClient();

    var timestamp = DateTime.UtcNow.ToString("yyyy.MM.dd HH:mm:ss +0000");
    var state = Guid.NewGuid().ToString("D");

    var msg = $"{esiaSettings.Value.ClientId}{esiaSettings.Value.Scope}{timestamp}{state}{redirectUri}";

    var clientSecret = await GetClientSecret(msg);

    var builder = new RequestBuilder();
    builder.AddParam("client_secret", clientSecret);
    builder.AddParam("client_id", esiaSettings.Value.ClientId);
    builder.AddParam("scope", esiaSettings.Value.Scope);
    builder.AddParam("timestamp", timestamp);
    builder.AddParam("state", state);
    builder.AddParam("redirect_uri", redirectUri);
    builder.AddParam("client_certificate_hash", esiaSettings.Value.ClientCertificateHash);
    builder.AddParam("response_type", "code");
    builder.AddParam("access_type", "online");

    //Вот тут самый важный момент на который было потрачено множество времени. Просто заменяем символы на безопасные
    var url = esiaSettings.Value.EsiaAuthUrl + "?" + builder.ToString().Replace("+", "%2B")
        .Replace(":", "%3A")
        .Replace(" ", "+");

    return url;
}

public async Task<EsiaAuthToken> GetToken(string authorizationCode, string redirectUrl)
{
    var timestamp = DateTime.UtcNow.ToString("yyyy.MM.dd HH:mm:ss +0000");
    var state = Guid.NewGuid().ToString("D");

    var msg =
        $"{esiaSettings.Value.ClientId}{esiaSettings.Value.Scope}{timestamp}{state}{redirectUrl}{authorizationCode}";

    var clientSecret = await GetClientSecret(msg);

    var requestParams = new List<KeyValuePair<string, string>>
    {
        new KeyValuePair<string, string>("client_id", esiaSettings.Value.ClientId),
        new KeyValuePair<string, string>("code", authorizationCode), //Здесь мы передаём полученный код
        new KeyValuePair<string, string>("grant_type", "authorization_code"),  //Просто указываем тип
        new KeyValuePair<string, string>("state", state),
        new KeyValuePair<string, string>("scope", esiaSettings.Value.Scope),
        new KeyValuePair<string, string>("timestamp", timestamp),
        new KeyValuePair<string, string>("token_type", "Bearer"),  //Какой токен мы хотим получить
        new KeyValuePair<string, string>("client_secret", clientSecret),
        new KeyValuePair<string, string>("redirect_uri", redirectUrl),
        new KeyValuePair<string, string>("client_certificate_hash", esiaSettings.Value.ClientCertificateHash)
    };

    using var client = new HttpClient();
    using var response = await client.PostAsync(esiaSettings.Value.EsiaTokenUrl,
        new FormUrlEncodedContent(requestParams));
    response.EnsureSuccessStatusCode();
    var tokenResponse = await response.Content.ReadAsStringAsync();

    var token = JsonConvert.DeserializeObject<EsiaAuthToken>(tokenResponse);

    if (!await ValidatingAccessToken(token))
    {
        throw new Exception("Ошибка проверки маркера индентификации");
    }

    return token;
}

Everything is simple here, we generate again client_secret specify the remaining parameters and send a request to the ESIA to receive a token. Test Uri https://esia-portal1.test.gosuslugi.ru/aas/oauth2/v3/te

public class EsiaAuthToken
{
    /// <summary>
    /// Токен доступа
    /// </summary>
    [JsonProperty("access_token")]
    public string AccessToken { get; set; }

    /// <summary>
    /// Идентификатор запроса
    /// </summary>
    public string State { get; set; }

    string[] parts => AccessToken.Split('.');

    /// <summary>
    /// Хранилище данных в токене
    /// </summary>
    public EsiaAuthTokenPayload Payload
    {
        get
        {
            if (string.IsNullOrEmpty(AccessToken))
            {
                return null;
            }

            if (parts.Length < 2)
            {
                throw new Exception($"При расшифровке токена доступа произошла ошибка. Токен: {AccessToken}");
            }

            var payload = Encoding.UTF8.GetString(Base64UrlEncoder.DecodeBytes(parts[1]));
            return JsonConvert.DeserializeObject<EsiaAuthTokenPayload>(payload);
        }
    }

    /// <summary>
    /// Сообщение для проверки подписи
    /// </summary>
    [Newtonsoft.Json.JsonIgnore]
    public string Message
    {
        get
        {
            if (string.IsNullOrEmpty(AccessToken))
            {
                return null;
            }

            if (parts.Length < 2)
            {
                throw new Exception($"При расшифровке токена доступа произошла ошибка. Токен: {AccessToken}");
            }

            return parts[0] + "." + parts[1];
        }
    }

    /// <summary>
    /// Сигнатура подписи
    /// </summary>
    [Newtonsoft.Json.JsonIgnore]
    public string Signature
    {
        get
        {
            if (string.IsNullOrEmpty(AccessToken))
            {
                return null;
            }

            if (parts.Length < 2)
            {
                throw new Exception($"При расшифровке токена доступа произошла ошибка. Токен: {AccessToken}");
            }

            return parts[2];
        }
    }

    public class EsiaAuthTokenPayload
    {
        [JsonConstructor]
        public EsiaAuthTokenPayload(string tokenId, string userId, string nbf, string exp, string iat, string iss,
            string client_id)
        {
            TokenId = tokenId;
            UserId = userId;
            BeginDate = EsiaHelper.DateFromUnixSeconds(double.Parse(nbf));
            ExpireDate = EsiaHelper.DateFromUnixSeconds(double.Parse(exp));
            CreateDate = EsiaHelper.DateFromUnixSeconds(double.Parse(iat));
            Iss = iss;
            ClientId = client_id;
        }

        /// <summary>
        /// Идентификатор токена
        /// </summary>
        [JsonProperty("urn:esia:sid")]
        public string TokenId { get; private set; }

        /// <summary>
        /// Идентификатор пользователя
        /// </summary>
        [JsonProperty("urn:esia:sbj_id")]
        public string UserId { get; private set; }

        /// <summary>
        /// Время начала действия токена
        /// </summary>
        [JsonPropertyName("nbf")]
        public DateTime BeginDate { get; private set; }

        /// <summary>
        /// Время окончания действия токена
        /// </summary>
        [JsonPropertyName("exp")]
        public DateTime ExpireDate { get; private set; }

        /// <summary>
        /// Время выпуска токена
        /// </summary>
        [JsonPropertyName("iat")]
        public DateTime CreateDate { get; private set; }

        /// <summary>
        /// Организация, выпустившая маркер
        /// </summary>
        [JsonPropertyName("iss")]
        public string Iss { get; private set; }

        /// <summary>
        /// Адресат маркера
        /// </summary>
        [JsonPropertyName("client_id")]
        public string ClientId { get; private set; }
    }
  }

  public static class EsiaHelper
  {
      public static DateTime DateFromUnixSeconds(double seconds)
      {
          var date = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);

          return date.AddSeconds(seconds).ToLocalTime();
      }
  }

[HttpPost]
public bool Verify(VerifyMessage message)
{
    try
    {
        return VerifyRawSignString(message.Message, message.Signature);
    }
    catch (Exception ex)
    {
        return false;
    }
}

public class VerifyMessage
{
    public string Signature { get; set; }
    public string Message { get; set; }
}

/// <summary>
/// Проверка подписи JWT в формате HEADER.PAYLOAD.SIGNATURE.
/// </summary>
/// <param name="message">HEADER.PAYLOAD в формате Base64url</param>
/// <param name="signature">SIGNATURE в формате Base64url</param>
bool VerifyRawSignString(string message, string signature)
{
    var signerCert = GetEsiaSignerCert();

    var messageBytes = Encoding.UTF8.GetBytes(message);
    var signatureBytes = Base64UrlEncoder.DecodeBytes(signature);
    //Переварачиваем байты, так как используется RAW подпись
    Array.Reverse(signatureBytes, 0, signatureBytes.Length);

    using (var GostHash = new Gost3411_2012_256CryptoServiceProvider())
    {
        var csp = (Gost3410_2012_256CryptoServiceProvider) signerCert.PublicKey.Key;
        //Используем публичный ключ сертификата для проверки  
        return csp.VerifyData(messageBytes, GostHash, signatureBytes);
    }
}

X509Certificate2 GetEsiaSignerCert()
{
    var store = new X509Store(StoreName.AddressBook, StoreLocation.CurrentUser);
    store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadOnly);
    var certificates = store.Certificates.Find(X509FindType.FindBySerialNumber, EsiaCertSerialNumber, false);

    var certificate = certificates[0];

    return certificate;
}

Here we use the constants introduced earlier. And We get a certificate from trusted certificates.

public async Task<bool> ValidatingAccessToken(EsiaAuthToken token)
{
    if (token.Payload.ExpireDate <= DateTime.Now ||
        token.Payload.BeginDate >= DateTime.Now ||
        token.Payload.CreateDate >= DateTime.Now ||
        token.Payload.ExpireDate <= token.Payload.BeginDate ||
        token.Payload.CreateDate > token.Payload.BeginDate ||
        token.Payload.CreateDate > token.Payload.ExpireDate ||
        token.Payload.Iss != esiaSettings.Value.ISS ||
        token.Payload.ClientId != esiaSettings.Value.ClientId)
    {
        return false;
    }

    var client = new HttpClient();

    var requestParams = new List<KeyValuePair<string, string>>
    {
        new KeyValuePair<string, string>("signature", token.Signature),
        new KeyValuePair<string, string>("message", token.Message)
    };

    var response = await client.PostAsync($"{cryptoProSettings.Value.BaseUrl}/Verify",
        new FormUrlEncodedContent(requestParams));

    response.EnsureSuccessStatusCode();
    var resultResponse = await response.Content.ReadAsStringAsync();

    var result = JsonConvert.DeserializeObject<bool>(resultResponse);

    return result;
}

We use this code in our main service.
We check the fields of the token for relevance so that it cannot be faked. And then we check the signature of the token, as indicated in the guidelines.