HttpWebRequest utilizzando l'autenticazione di base

Sto cercando di passare attraverso una richiesta di autenticazione che imita la "richiesta di autorizzazione di base" che siamo abituati a vedere quando si configura IIS per questo comportamento.

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

Questo server è in esecuzione su UNIX e Java come application server.

Questo è il codice che uso per connettermi a questo server:

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();

(L'ho copiato da un altro post su questo sito). Ma ricevo questa risposta dal server:

La connessione sottostante è stata chiusa: si è verificato un errore imprevisto durante l'invio.

Penso di aver provato ogni possibile compito che la mia conoscenza di C # deve offrirmi, ma niente ...

Puoi anche aggiungere tu stesso l'intestazione dell'autorizzazione.

Basta fare il nome "Autorizzazione" e il valore "Base 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);

modificare

Commutazione della codifica da UTF-8 a ISO 8859-1 per Quale codifica dovrei usare per l'autenticazione di base HTTP? e il commento di Jeroen.

Finalmente ho capito!

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;

e questo è 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;
}

SÌÌ!

Se è possibile utilizzare la WebClientclasse, l'utilizzo dell'autenticazione di base diventa semplice:

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");

Prova questo:

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; 

Per coloro che utilizzano RestSharp , potrebbe non funzionare quando si utilizza SimpleAuthenticator (probabilmente a causa del mancato utilizzo di ISO-8859-1 dietro la scena). Sono riuscito a farlo inviando esplicitamente le intestazioni di autenticazione di 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;

Il codice seguente risolverà la risposta json se sono stati implementati l'autenticazione di base e il proxy. Anche IIS 7.5 Hosting Problm verrà risolto.

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;
}

Le specifiche possono essere lette come "ISO-8859-1" o "non definito". La tua scelta. È noto che molti server utilizzano ISO-8859-1 (piaccia o no) e falliranno quando invii qualcos'altro.

Per ulteriori informazioni e una proposta per risolvere la situazione, vedere http://greenbytes.de/tech/webdav/draft-reschke-basicauth-enc-latest.html

La seguente costruzione non funzionava correttamente per me:

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

Ho usato CredentialCacheinvece:

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

Tuttavia, se desideri aggiungere più credenziali di autenticazione di base (ad esempio se è presente il reindirizzamento di cui sei a conoscenza) puoi utilizzare la seguente funzione che ho creato:

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);
    }
}

Spero che possa aiutare qualcuno in futuro.

Per prima cosa, per me ServicePointManager.SecurityProtocol = SecurityProtocolType. Tls12 ha funzionato invece di Ssl3.

In secondo luogo, ho dovuto inviare la richiesta Auth di base insieme ad alcuni dati (codificati in forma di modulo). Ecco il campione completo che ha funzionato perfettamente per me, dopo aver provato molte soluzioni.

Dichiarazione di non responsabilità: il codice seguente è una combinazione di soluzioni trovate su questo collegamento e alcuni altri collegamenti stackoverflow, grazie per le informazioni utili.

        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();