Ho un'applicazione Web (ospitata in IIS) che parla con un servizio Windows. Il servizio Windows utilizza l'API Web ASP.Net MVC (self-hosted) e pertanto può essere comunicato tramite http tramite JSON. L'applicazione Web è configurata per eseguire la rappresentazione, con l'idea che l'utente che effettua la richiesta all'applicazione Web dovrebbe essere l'utente che l'applicazione Web utilizza per effettuare la richiesta al servizio. La struttura si presenta così:

_{(L'utente evidenziato in rosso è l'utente a cui si fa riferimento negli esempi seguenti.)}

L'applicazione Web invia richieste al servizio Windows utilizzando un HttpClient:

var httpClient = new HttpClient(new HttpClientHandler() 
                      {
                          UseDefaultCredentials = true
                      });
httpClient.GetStringAsync("http://localhost/some/endpoint/");

Questo invia la richiesta al servizio Windows, ma non trasferisce correttamente le credenziali (il servizio riporta l'utente come IIS APPPOOL\ASP.NET 4.0). Non è quello che voglio succedere .

Se cambio invece il codice sopra per utilizzare un WebClient, le credenziali dell'utente vengono passate correttamente:

WebClient c = new WebClient
                   {
                       UseDefaultCredentials = true
                   };
c.DownloadStringAsync(new Uri("http://localhost/some/endpoint/"));

Con il codice sopra riportato, il servizio segnala l'utente come l'utente che ha effettuato la richiesta all'applicazione Web.

Cosa sto facendo di sbagliato HttpClientnell'implementazione che sta causando il mancato passaggio corretto delle credenziali (o è un bug con HttpClient)?

_{Il motivo per cui voglio usare HttpClientè che ha un'API asincrona che funziona bene con Tasks, mentre l' WebClientAPI asyc deve essere gestita con eventi.}

Avevo anche questo stesso problema. Ho sviluppato una soluzione sincrona grazie alla ricerca condotta da @tpeczek nel seguente articolo SO: Impossibile eseguire l'autenticazione al servizio Api Web ASP.NET con HttpClient

La mia soluzione usa a WebClient, che come hai notato correttamente passa le credenziali senza problemi. Il motivo HttpClientnon funziona perché la sicurezza di Windows disabilita la possibilità di creare nuovi thread con un account rappresentato (vedere l'articolo SO sopra.) HttpClientCrea nuovi thread tramite Task Factory causando così l'errore. WebClientd'altra parte, viene eseguito in modo sincrono sullo stesso thread ignorando così la regola e inoltrandone le credenziali.

Sebbene il codice funzioni, il rovescio della medaglia è che non funzionerà in modo asincrono.

var wi = (System.Security.Principal.WindowsIdentity)HttpContext.Current.User.Identity;

var wic = wi.Impersonate();
try
{
    var data = JsonConvert.SerializeObject(new
    {
        Property1 = 1,
        Property2 = "blah"
    });

    using (var client = new WebClient { UseDefaultCredentials = true })
    {
        client.Headers.Add(HttpRequestHeader.ContentType, "application/json; charset=utf-8");
        client.UploadData("http://url/api/controller", "POST", Encoding.UTF8.GetBytes(data));
    }
}
catch (Exception exc)
{
    // handle exception
}
finally
{
    wic.Undo();
}

Nota: richiede il pacchetto NuGet: Newtonsoft.Json, che è lo stesso serializzatore JSON utilizzato da WebAPI.

È possibile configurare HttpClientper passare automaticamente le credenziali in questo modo:

var myClient = new HttpClient(new HttpClientHandler() { UseDefaultCredentials = true });

Quello che stai cercando di fare è convincere NTLM a inoltrare l'identità al server successivo, cosa che non può fare: può solo fare la rappresentazione che ti dà solo accesso alle risorse locali. Non ti permetterà di attraversare un confine macchina. L'autenticazione Kerberos supporta la delega (ciò di cui hai bisogno) utilizzando i ticket e il ticket può essere inoltrato quando tutti i server e le applicazioni della catena sono configurati correttamente e Kerberos è impostato correttamente sul dominio. Quindi, in breve, è necessario passare dall'utilizzo di NTLM a Kerberos.

Per ulteriori informazioni sulle opzioni di autenticazione di Windows disponibili e su come funzionano, iniziare da: http://msdn.microsoft.com/en-us/library/ff647076.aspx

OK, quindi grazie a tutti i collaboratori sopra. Sto usando .NET 4.6 e abbiamo avuto anche lo stesso problema. Ho impiegato del tempo per il debug System.Net.Http, in particolare il HttpClientHandler, e ho trovato quanto segue:

    if (ExecutionContext.IsFlowSuppressed())
    {
      IWebProxy webProxy = (IWebProxy) null;
      if (this.useProxy)
        webProxy = this.proxy ?? WebRequest.DefaultWebProxy;
      if (this.UseDefaultCredentials || this.Credentials != null || webProxy != null && webProxy.Credentials != null)
        this.SafeCaptureIdenity(state);
    }

Quindi, dopo aver valutato che ExecutionContext.IsFlowSuppressed()potrebbe essere stato il colpevole, ho concluso il nostro codice di rappresentazione come segue:

using (((WindowsIdentity)ExecutionContext.Current.Identity).Impersonate())
using (System.Threading.ExecutionContext.SuppressFlow())
{
    // HttpClient code goes here!
}

Il codice all'interno di SafeCaptureIdenity(non il mio errore di ortografia), afferra WindowsIdentity.Current()quale è la nostra identità impersonata. Questo è stato raccolto perché ora stiamo sopprimendo il flusso. A causa dell'utilizzo / eliminazione, questo viene ripristinato dopo l'invocazione.

Ora sembra funzionare per noi, accidenti!

In .NET Core, sono riuscito a ottenere un System.Net.Http.HttpClientcon UseDefaultCredentials = trueper passare le credenziali di Windows dell'utente autenticato a un servizio back-end utilizzando WindowsIdentity.RunImpersonated.

HttpClient client = new HttpClient(new HttpClientHandler { UseDefaultCredentials = true } );
HttpResponseMessage response = null;

if (identity is WindowsIdentity windowsIdentity)
{
    await WindowsIdentity.RunImpersonated(windowsIdentity.AccessToken, async () =>
    {
        var request = new HttpRequestMessage(HttpMethod.Get, url)
        response = await client.SendAsync(request);
    });
}

Ha funzionato per me dopo aver impostato un utente con accesso a Internet nel servizio Windows.

Nel mio codice:

HttpClientHandler handler = new HttpClientHandler();
handler.Proxy = System.Net.WebRequest.DefaultWebProxy;
handler.Proxy.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
.....
HttpClient httpClient = new HttpClient(handler)
.... 

Ok, ho preso il codice Joshoun e l'ho reso generico. Non sono sicuro se dovrei implementare il modello singleton sulla classe SynchronousPost. Forse qualcuno più competente può aiutare.

Implementazione

FileCategory x = new FileCategory { CategoryName = "Some Bs"};
SynchronousPost<FileCategory>test= new SynchronousPost<FileCategory>();
test.PostEntity(x, "/api/ApiFileCategories"); 

Classe generica qui. Puoi passare qualsiasi tipo

 public class SynchronousPost<T>where T :class
    {
        public SynchronousPost()
        {
            Client = new WebClient { UseDefaultCredentials = true };
        }

        public void PostEntity(T PostThis,string ApiControllerName)//The ApiController name should be "/api/MyName/"
        {
            //this just determines the root url. 
            Client.BaseAddress = string.Format(
         (
            System.Web.HttpContext.Current.Request.Url.Port != 80) ? "{0}://{1}:{2}" : "{0}://{1}",
            System.Web.HttpContext.Current.Request.Url.Scheme,
            System.Web.HttpContext.Current.Request.Url.Host,
            System.Web.HttpContext.Current.Request.Url.Port
           );
            Client.Headers.Add(HttpRequestHeader.ContentType, "application/json;charset=utf-8");
            Client.UploadData(
                                 ApiControllerName, "Post", 
                                 Encoding.UTF8.GetBytes
                                 (
                                    JsonConvert.SerializeObject(PostThis)
                                 )
                             );  
        }
        private WebClient Client  { get; set; }
    }

Le mie lezioni di Api sono così, se sei curioso

public class ApiFileCategoriesController : ApiBaseController
{
    public ApiFileCategoriesController(IMshIntranetUnitOfWork unitOfWork)
    {
        UnitOfWork = unitOfWork;
    }

    public IEnumerable<FileCategory> GetFiles()
    {
        return UnitOfWork.FileCategories.GetAll().OrderBy(x=>x.CategoryName);
    }
    public FileCategory GetFile(int id)
    {
        return UnitOfWork.FileCategories.GetById(id);
    }
    //Post api/ApileFileCategories

    public HttpResponseMessage Post(FileCategory fileCategory)
    {
        UnitOfWork.FileCategories.Add(fileCategory);
        UnitOfWork.Commit(); 
        return new HttpResponseMessage();
    }
}

Sto usando ninject e il modello di pronti contro termine con l'unità di lavoro. Comunque, la classe generica sopra aiuta davvero.