HttpListener Acceso Denegado

Question

Estoy escribiendo un servidor HTTP en C#.

Cuando trato de ejecutar la función HttpListener.Start() me sale un HttpListenerException diciendo

"Acceso denegado".

Cuando ejecuto la aplicación en modo de administrador en Windows 7, funciona bien.

¿Puedo hacer que funcione sin el modo de administración? Si es así, ¿cómo? Si no, ¿cómo puedo hacer que la aplicación cambie al modo de administración después de comenzar a ejecutar?

using System; 
using System.Net; 

namespace ConsoleApplication1 
{ 
    class Program 
    { 
     private HttpListener httpListener = null; 

     static void Main(string[] args) 
     { 
      Program p = new Program(); 
      p.Server(); 
     } 

     public void Server() 
     { 
      this.httpListener = new HttpListener(); 

      if (httpListener.IsListening) 
       throw new InvalidOperationException("Server is currently running."); 

      httpListener.Prefixes.Clear(); 
      httpListener.Prefixes.Add("http://*:4444/"); 

      try 
      { 
       httpListener.Start(); //Throws Exception 
      } 
      catch (HttpListenerException ex) 
      { 
       if (ex.Message.Contains("Access is denied")) 
       { 
        return; 
       } 
       else 
       { 
        throw; 
       } 
      } 
     } 
    } 
} 

Answer 1

Sí, puede ejecutar HttpListener en modo no administrador. Todo lo que necesita hacer es otorgar permisos a la URL en particular. p.ej.

netsh http add urlacl url=http://+:80/MyUri user=DOMAIN\user 

La documentación es here.

Answer 2

¿Puedo hacer que se ejecute sin el modo de administrador? Si es así, ¿cómo? Si no, ¿cómo puedo hacer que la aplicación cambie al modo de administración después de comenzar a correr?

No puede, tiene que comenzar con privilegios elevados. Puede reiniciarlo con el runas verbo, que le pedirá al usuario cambiar al modo de administrador

static void RestartAsAdmin() 
{ 
    var startInfo = new ProcessStartInfo("yourApp.exe") { Verb = "runas" }; 
    Process.Start(startInfo); 
    Environment.Exit(0); 
} 

---

EDIT: En realidad, eso no es cierto; HttpListener puede ejecutarse sin privilegios elevados, pero debe otorgar permiso para la URL en la que desea escuchar. Ver Darrel Miller's answer para más detalles.

Answer 3

Si usa http://localhost:80/ como prefijo, puede escuchar las solicitudes http sin necesidad de privilegios administrativos.

Answer 4

La sintaxis estaba mal para mí, debe incluir las comillas:

netsh http add urlacl url="http://+:4200/" user=everyone 

de lo contrario me recibieron "el parámetro es incorrecto"

Answer 5

Puede iniciar la aplicación como administrador si se agrega Manifiesto de aplicación a tu proyecto.

Solo agregue un nuevo elemento a su proyecto y seleccione "Archivo de manifiesto de aplicación". Cambiar el elemento <requestedExecutionLevel> a:

<requestedExecutionLevel level="requireAdministrator" uiAccess="false" /> 

Answer 6

En caso de que quiera utilizar la bandera "user = Todos" tiene que ajustar a su idioma del sistema. En Inglés que es como se menciona:

netsh http add urlacl url=http://+:80/ user=Everyone 

en alemán sería:

netsh http add urlacl url=http://+:80/ user=Jeder 

Answer 7

también hice frente de problema.Si similares que ya han reservado url entonces usted tiene que eliminar primero la url para funcionar en En modo no administrador, fallará con el error Acceso denegado.

netsh http delete urlacl url=http://+:80 

Answer 8

Por defecto, Windows define el siguiente prefijo que está disponible para todos: http://+:80/Temporary_Listen_Addresses/

para que pueda registrar su HttpListener a través de:

Prefixes.Add("http://+:80/Temporary_Listen_Addresses/" + Guid.NewGuid().ToString("D") + "/";

Esto a veces causa problemas con el software, tales como Skype, que tratará de utilizar el puerto 80 por defecto.

Answer 9

httpListener.Prefixes.Add("http://*:4444/"); 

utiliza "*" para que ejecute siguiente cmd como administrador

netsh http add urlacl url=http://*:4444/ user=username 

inútil +, debe utilizar *, * porque especializas: 4444 ~.

https://msdn.microsoft.com/en-us/library/system.net.httplistener.aspx

Answer 10

Como una alternativa que no requiere elevación o netsh también se podría utilizar TcpListener por ejemplo.

El siguiente es un extracto modificado de esta muestra: https://github.com/googlesamples/oauth-apps-for-windows/tree/master/OAuthDesktopApp

// Generates state and PKCE values. 
string state = randomDataBase64url(32); 
string code_verifier = randomDataBase64url(32); 
string code_challenge = base64urlencodeNoPadding(sha256(code_verifier)); 
const string code_challenge_method = "S256"; 

// Creates a redirect URI using an available port on the loopback address. 
var listener = new TcpListener(IPAddress.Loopback, 0); 
listener.Start(); 
string redirectURI = string.Format("http://{0}:{1}/", IPAddress.Loopback, ((IPEndPoint)listener.LocalEndpoint).Port); 
output("redirect URI: " + redirectURI); 

// Creates the OAuth 2.0 authorization request. 
string authorizationRequest = string.Format("{0}?response_type=code&scope=openid%20profile&redirect_uri={1}&client_id={2}&state={3}&code_challenge={4}&code_challenge_method={5}", 
    authorizationEndpoint, 
    System.Uri.EscapeDataString(redirectURI), 
    clientID, 
    state, 
    code_challenge, 
    code_challenge_method); 

// Opens request in the browser. 
System.Diagnostics.Process.Start(authorizationRequest); 

// Waits for the OAuth authorization response. 
var client = await listener.AcceptTcpClientAsync(); 

// Read response. 
var response = ReadString(client); 

// Brings this app back to the foreground. 
this.Activate(); 

// Sends an HTTP response to the browser. 
WriteStringAsync(client, "<html><head><meta http-equiv='refresh' content='10;url=https://google.com'></head><body>Please close this window and return to the app.</body></html>").ContinueWith(t => 
{ 
    client.Dispose(); 
    listener.Stop(); 

    Console.WriteLine("HTTP server stopped."); 
}); 

// TODO: Check the response here to get the authorization code and verify the code challenge 

de lectura y escritura métodos ser:

private string ReadString(TcpClient client) 
{ 
    var readBuffer = new byte[client.ReceiveBufferSize]; 
    string fullServerReply = null; 

    using (var inStream = new MemoryStream()) 
    { 
     var stream = client.GetStream(); 

     while (stream.DataAvailable) 
     { 
      var numberOfBytesRead = stream.Read(readBuffer, 0, readBuffer.Length); 
      if (numberOfBytesRead <= 0) 
       break; 

      inStream.Write(readBuffer, 0, numberOfBytesRead); 
     } 

     fullServerReply = Encoding.UTF8.GetString(inStream.ToArray()); 
    } 

    return fullServerReply; 
} 

private Task WriteStringAsync(TcpClient client, string str) 
{ 
    return Task.Run(() => 
    { 
     using (var writer = new StreamWriter(client.GetStream(), new UTF8Encoding(false))) 
     { 
      writer.Write("HTTP/1.0 200 OK"); 
      writer.Write(Environment.NewLine); 
      writer.Write("Content-Type: text/html; charset=UTF-8"); 
      writer.Write(Environment.NewLine); 
      writer.Write("Content-Length: " + str.Length); 
      writer.Write(Environment.NewLine); 
      writer.Write(Environment.NewLine); 
      writer.Write(str); 
     } 
    }); 
}