HttpWebRequest utilisant l'authentification de base

J'essaie de passer par une demande d'authentification qui imite la "demande d'authentification de base" que nous avons l'habitude de voir lors de la configuration d'IIS pour ce comportement.

L'URL est: https://telematicoprova.agenziadogane.it/TelematicoServiziDiUtilitaWeb/ServiziDiUtilitaAutServlet?UC=22&SC=1&ST=2
(avertissement: https!)

Ce serveur fonctionne sous UNIX et Java en tant que serveur d'applications.

Voici le code que j'utilise pour me connecter à ce serveur:

CookieContainer myContainer = new CookieContainer();
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://telematicoprova.agenziadogane.it/TelematicoServiziDiUtilitaWeb/ServiziDiUtilitaAutServlet?UC=22&SC=1&ST=2");
request.Credentials = new NetworkCredential(xxx,xxx);
request.CookieContainer = myContainer;
request.PreAuthenticate = true;
HttpWebResponse response = (HttpWebResponse)request.GetResponse();

(J'ai copié ceci à partir d'un autre article sur ce site). Mais je reçois cette réponse du serveur:

La connexion sous-jacente a été fermée: une erreur inattendue s'est produite lors d'un envoi.

Je pense que j'ai essayé toutes les tâches possibles que mes connaissances sur C # ont à m'offrir, mais rien ...

Vous pouvez également simplement ajouter vous-même l'en-tête d'autorisation.

Créez simplement le nom "Authorization" et la valeur "Basic BASE64 ({USERNAME: PASSWORD})"

String username = "abc";
String password = "123";
String encoded = System.Convert.ToBase64String(System.Text.Encoding.GetEncoding("ISO-8859-1").GetBytes(username + ":" + password));
httpWebRequest.Headers.Add("Authorization", "Basic " + encoded);

Éditer

Passage du codage UTF-8 à ISO 8859-1 par Quel codage dois-je utiliser pour l'authentification de base HTTP? et le commentaire de Jeroen.

J'ai enfin compris!

string url = @"https://telematicoprova.agenziadogane.it/TelematicoServiziDiUtilitaWeb/ServiziDiUtilitaAutServlet?UC=22&SC=1&ST=2";
WebRequest request = WebRequest.Create(url);
request.Credentials = GetCredential();
request.PreAuthenticate = true;

et c'est GetCredential()

private CredentialCache GetCredential()
{
    string url = @"https://telematicoprova.agenziadogane.it/TelematicoServiziDiUtilitaWeb/ServiziDiUtilitaAutServlet?UC=22&SC=1&ST=2";
    ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3;
    CredentialCache credentialCache = new CredentialCache();
    credentialCache.Add(new System.Uri(url), "Basic", new NetworkCredential(ConfigurationManager.AppSettings["ead_username"], ConfigurationManager.AppSettings["ead_password"]));
    return credentialCache;
}

YAY!

Si vous pouvez utiliser la WebClientclasse, l'utilisation de l'authentification de base devient simple:

var client = new WebClient {Credentials = new NetworkCredential("user_name", "password")};
var response = client.DownloadString("https://telematicoprova.agenziadogane.it/TelematicoServiziDiUtilitaWeb/ServiziDiUtilitaAutServlet?UC=22&SC=1&ST=2");

Essaye ça:

System.Net.CredentialCache credentialCache = new System.Net.CredentialCache(); 
credentialCache.Add(
    new System.Uri("http://www.yoururl.com/"),
    "Basic", 
    new System.Net.NetworkCredential("username", "password")
);

...
...

httpWebRequest.Credentials = credentialCache; 

Pour ceux qui utilisent RestSharp , il peut échouer lors de l'utilisation de SimpleAuthenticator (probablement en raison de ne pas utiliser ISO-8859-1 en arrière-plan). J'ai réussi à le faire en envoyant explicitement des en-têtes d'authentification de base:

string username = "...";
string password = "...";

public IRestResponse GetResponse(string url, Method method = Method.GET)
{
    string encoded = Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes($"{username}:{password}"));
    var client = new RestClient(url);
    var request = new RestRequest(method );
    request.AddHeader("Authorization", $"Basic {encoded}");
    IRestResponse response = client.Execute(request);
    return response;
}

var response = GetResponse(url);
txtResult.Text = response.Content;

Le code suivant résoudra la réponse json si l'authentification de base et le proxy sont implémentés.Le problème d'hébergement IIS 7.5 sera également résolu.

public string HttpGetByWebRequ(string uri, string username, string password)
{
//For Basic Authentication
    string authInfo = username + ":" + password;
    authInfo = Convert.ToBase64String(Encoding.Default.GetBytes(authInfo));

//For Proxy
    WebProxy proxy = new WebProxy("http://10.127.0.1:8080", true);

    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
    request.Method = "GET";
    request.Accept = "application/json; charset=utf-8";
    request.Proxy = proxy;

    request.Headers["Authorization"] = "Basic " + authInfo;

    var response = (HttpWebResponse)request.GetResponse();

    string strResponse = "";
    using (var sr = new StreamReader(response.GetResponseStream()))
    {
        strResponse= sr.ReadToEnd();

    }

    return strResponse;
}

La spécification peut être lue comme «ISO-8859-1» ou «indéfini». Votre choix. On sait que de nombreux serveurs utilisent ISO-8859-1 (que vous le vouliez ou non) et échoueront lorsque vous enverrez autre chose.

Pour plus d'informations et une proposition pour corriger la situation, voir http://greenbytes.de/tech/webdav/draft-reschke-basicauth-enc-latest.html

La construction suivante ne fonctionnait pas correctement pour moi:

request.Credentials = new NetworkCredential("user", "pass");

J'ai utilisé à la CredentialCacheplace:

CredentialCache credentialCache = new CredentialCache
{
    {
        new Uri($"http://{request.Host}/"), "Basic",
        new NetworkCredential("user", "pass")
    }
};
request.Credentials = credentialCache;

Cependant, si vous souhaitez ajouter plusieurs informations d'authentification de base (par exemple, s'il existe une redirection dont vous avez connaissance), vous pouvez utiliser la fonction suivante que j'ai créée:

private void SetNetworkCredential(Uri uriPrefix, string authType, NetworkCredential credential)
{
    if (request.Credentials == null)
    {
        request.Credentials = new CredentialCache();
    }

    if (request.Credentials.GetCredential(uriPrefix, authType) == null)
    {
        (request.Credentials as CredentialCache).Add(uriPrefix, authType, credential);
    }
}

J'espère que cela aidera quelqu'un à l'avenir.

Tout d'abord, pour moi ServicePointManager.SecurityProtocol = SecurityProtocolType. Tls12 a fonctionné au lieu de Ssl3.

Deuxièmement, j'ai dû envoyer la demande d'authentification de base avec quelques données (form-urlencoded). Voici l'exemple complet qui a parfaitement fonctionné pour moi, après avoir essayé de nombreuses solutions.

Avertissement: Le code ci-dessous est un mélange de solutions trouvées sur ce lien et d'autres liens stackoverflow, merci pour les informations utiles.

        ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
        String username = "user_name";
        String password = "password";
        String encoded = System.Convert.ToBase64String(System.Text.Encoding.GetEncoding("ISO-8859-1").GetBytes(username + ":" + password));

        //Form Data
        var formData = "var1=val1&var2=val2";
        var encodedFormData = Encoding.ASCII.GetBytes(formData);

        HttpWebRequest request = (HttpWebRequest)WebRequest.Create("THE_URL");
        request.ContentType = "application/x-www-form-urlencoded";
        request.Method = "POST";
        request.ContentLength = encodedFormData.Length;
        request.Headers.Add("Authorization", "Basic " + encoded);
        request.PreAuthenticate = true;

        using (var stream = request.GetRequestStream())
        {
            stream.Write(encodedFormData, 0, encodedFormData.Length);
        }

        HttpWebResponse response = (HttpWebResponse)request.GetResponse();
        var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();