hybertone - Forma correcta de obtener las direcciones IP del cliente de http.Request

goip sms server

Question

¿Cuál es la forma correcta de obtener todas las direcciones IP del cliente de http.Request ? En PHP hay muchas variables que debo verificar. ¿Es lo mismo en Go?

Uno que encontré es:

req.RemoteAddr

¿Y la solicitud distingue entre mayúsculas y minúsculas? por ejemplo, x-forwarded-for es lo mismo que X-Forwarded-For y X-FORWARDED-FOR ? (de req.Header.Get("X-FORWARDED-FOR") )

Answer 1

En PHP hay muchas variables que debo verificar. ¿Es lo mismo en Go?

Esto no tiene nada que ver con Go (o PHP para el caso). Solo depende de lo que envíe el cliente, el proxy, el equilibrador de carga o el servidor. Obtenga el que necesita según su entorno.

http.Request.RemoteAddr contiene la dirección IP remota. Puede o no ser su cliente real.

¿Y la solicitud distingue entre mayúsculas y minúsculas? por ejemplo, x-reenviado-para es lo mismo que X-reenviado-por y X-FORWARDED-FOR? (de req.Header.Get ("X-FORWARDED-FOR"))

No, ¿por qué no lo intentas tú mismo? http://play.golang.org/p/YMf_UBvDsH

Answer 2

Aquí un ejemplo completamente funcional

package main
import (
// Standard library packages
"fmt"
"strconv"
"log"
"net"
"net/http"
// Third party packages
"github.com/julienschmidt/httprouter"
"github.com/skratchdot/open-golang/open"
)
// https://blog.golang.org/context/userip/userip.go
func getIP(w http.ResponseWriter, req *http.Request, _ httprouter.Params){
fmt.Fprintf(w, "<h1>static file server</h1><p><a href=''./static''>folder</p></a>")
ip, port, err := net.SplitHostPort(req.RemoteAddr)
if err != nil {
//return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
fmt.Fprintf(w, "userip: %q is not IP:port", req.RemoteAddr)
}
userIP := net.ParseIP(ip)
if userIP == nil {
//return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
fmt.Fprintf(w, "userip: %q is not IP:port", req.RemoteAddr)
return
}
// This will only be defined when site is accessed via non-anonymous proxy
// and takes precedence over RemoteAddr
// Header.Get is case-insensitive
forward := req.Header.Get("X-Forwarded-For")
fmt.Fprintf(w, "<p>IP: %s</p>", ip)
fmt.Fprintf(w, "<p>Port: %s</p>", port)
fmt.Fprintf(w, "<p>Forwarded for: %s</p>", forward)
}
func main() {
myport := strconv.Itoa(10002);
// Instantiate a new router
r := httprouter.New()
r.GET("/ip", getIP)
// Add a handler on /test
r.GET("/test", func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
// Simply write some test data for now
fmt.Fprint(w, "Welcome!/n")
})
l, err := net.Listen("tcp", "localhost:" + myport)
if err != nil {
log.Fatal(err)
}
// The browser can connect now because the listening socket is open.
//err = open.Start("http://localhost:"+ myport + "/test")
err = open.Start("http://localhost:"+ myport + "/ip")
if err != nil {
log.Println(err)
}
// Start the blocking server loop.
log.Fatal(http.Serve(l, r))
}

Answer 3

Así es como llego a la IP

func ReadUserIP(r *http.Request) string {
IPAddress := r.Header.Get("X-Real-Ip")
if IPAddress == "" {
IPAddress = r.Header.Get("X-Forwarded-For")
}
if IPAddress == "" {
IPAddress = r.RemoteAddr
}
return IPAddress
}

• X-Real-Ip: obtiene la primera IP verdadera (si las solicitudes se encuentran detrás de múltiples fuentes NAT / balanceador de carga)

• X-Fordered-For: si por alguna razón X-Real-Ip está en blanco y no devuelve la respuesta, obtenga de X-Fordered-For

• Dirección remota: último recurso (por lo general, no será confiable, ya que esta podría ser la última IP o si es una solicitud http desnuda al servidor, es decir, sin equilibrador de carga)

Answer 4

Mirando http.Request puede encontrar las siguientes variables miembro:

// HTTP defines that header names are case-insensitive.
// The request parser implements this by canonicalizing the
// name, making the first character and any characters
// following a hyphen uppercase and the rest lowercase.
//
// For client requests certain headers are automatically
// added and may override values in Header.
//
// See the documentation for the Request.Write method.
Header Header
// RemoteAddr allows HTTP servers and other software to record
// the network address that sent the request, usually for
// logging. This field is not filled in by ReadRequest and
// has no defined format. The HTTP server in this package
// sets RemoteAddr to an "IP:port" address before invoking a
// handler.
// This field is ignored by the HTTP client.
RemoteAddr string

Puede usar RemoteAddr para obtener la dirección IP y el puerto del cliente remoto (el formato es "IP: puerto"), que es la dirección del solicitante original o el último proxy (por ejemplo, un equilibrador de carga que vive frente a su servidor) .

Esto es todo lo que tienes seguro.

Luego puede investigar los encabezados, que no distinguen entre mayúsculas y minúsculas (según la documentación anterior), lo que significa que todos sus ejemplos funcionarán y producirán el mismo resultado:

req.Header.Get("X-Forwarded-For") // capitalisation
req.Header.Get("x-forwarded-for") // doesn''t
req.Header.Get("X-FORWARDED-FOR") // matter

Esto se debe a que internamente http.Header.Get normalizará la clave por usted. (Si desea acceder al mapa de encabezado directamente, y no a través de Get , primero http.CanonicalHeaderKey usar http.CanonicalHeaderKey ).

Finalmente, "X-Forwarded-For" es probablemente el campo que desea examinar para obtener más información sobre la IP del cliente. Sin embargo, esto depende en gran medida del software HTTP utilizado en el lado remoto, ya que el cliente puede poner cualquier cosa allí si lo desea. Además, tenga en cuenta que el formato esperado de este campo es la lista de direcciones IP separadas por comas y espacios. Deberá analizarlo un poco para obtener una sola IP de su elección (probablemente la primera de la lista), por ejemplo:

// Assuming format is as expected
ips := strings.Split("10.0.0.1, 10.0.0.2, 10.0.0.3", ", ")
for _, ip := range ips {
fmt.Println(ip)
}

Producirá:

10.0.0.1
10.0.0.2
10.0.0.3