Posso eseguire una ricerca DNS (dal nome host all'indirizzo IP) utilizzando Javascript lato client?

Vorrei utilizzare Javascript lato client per eseguire una ricerca DNS (dal nome host all'indirizzo IP) come visto dal computer del client. È possibile?

Non c'è la nozione di host o indirizzi IP nella libreria standard javascript. Quindi dovrai accedere a un servizio esterno per cercare i nomi host per te.

Consiglio di ospitare un cgi-bin che cerca l'indirizzo ip di un nome host e accedervi tramite javascript.

Modifica : questa domanda mi ha dato prurito, quindi ho creato un servizio web JSONP su Google App Engine che restituisce l'indirizzo IP del client. Utilizzo:

<script type="application/javascript">
function getip(json){
  alert(json.ip); // alerts the ip address
}
</script>

<script type="application/javascript" src="http://jsonip.appspot.com/?callback=getip"> </script>

Sì, non sono necessari proxy server.

Pure JS non può. Se hai uno script del server nello stesso dominio che lo stampa, puoi inviare un XMLHttpRequest per leggerlo.

Molto tardi, ma immagino che molte persone atterreranno ancora qui tramite "Google Airlines". Un approccio moderno consiste nell'utilizzare WebRTC che non richiede il supporto del server.

https://hacking.ventures/local-ip-discovery-with-html5-webrtc-security-and-privacy-risk/

Il codice successivo è un copia e incolla da http://net.ipcalf.com/

// NOTE: window.RTCPeerConnection is "not a constructor" in FF22/23
var RTCPeerConnection = /*window.RTCPeerConnection ||*/ window.webkitRTCPeerConnection || window.mozRTCPeerConnection;

if (RTCPeerConnection) (function () {
    var rtc = new RTCPeerConnection({iceServers:[]});
    if (window.mozRTCPeerConnection) {      // FF needs a channel/stream to proceed
        rtc.createDataChannel('', {reliable:false});
    };  

    rtc.onicecandidate = function (evt) {
        if (evt.candidate) grepSDP(evt.candidate.candidate);
    };  
    rtc.createOffer(function (offerDesc) {
        grepSDP(offerDesc.sdp);
        rtc.setLocalDescription(offerDesc);
    }, function (e) { console.warn("offer failed", e); }); 


    var addrs = Object.create(null);
    addrs["0.0.0.0"] = false;
    function updateDisplay(newAddr) {
        if (newAddr in addrs) return;
        else addrs[newAddr] = true;
        var displayAddrs = Object.keys(addrs).filter(function (k) { return addrs[k]; }); 
        document.getElementById('list').textContent = displayAddrs.join(" or perhaps ") || "n/a";
    }   

    function grepSDP(sdp) {
        var hosts = []; 
        sdp.split('\r\n').forEach(function (line) { // c.f. http://tools.ietf.org/html/rfc4566#page-39
            if (~line.indexOf("a=candidate")) {     // http://tools.ietf.org/html/rfc4566#section-5.13
                var parts = line.split(' '),        // http://tools.ietf.org/html/rfc5245#section-15.1
                    addr = parts[4],
                    type = parts[7];
                if (type === 'host') updateDisplay(addr);
            } else if (~line.indexOf("c=")) {       // http://tools.ietf.org/html/rfc4566#section-5.7
                var parts = line.split(' '), 
                    addr = parts[2];
                updateDisplay(addr);
            }   
        }); 
    }   
})(); else {
    document.getElementById('list').innerHTML = "<code>ifconfig | grep inet | grep -v inet6 | cut -d\" \" -f2 | tail -n1</code>";
    document.getElementById('list').nextSibling.textContent = "In Chrome and Firefox your IP should display automatically, by the power of WebRTCskull.";
}   

La versione JSONP ospitata funziona a meraviglia, ma sembra che durante la notte la maggior parte dei giorni (Eastern Time) vada oltre le sue risorse, quindi ho dovuto creare la mia versione.

Ecco come l'ho realizzato con PHP:

<?php
header('content-type: application/json; charset=utf-8');

$data = json_encode($_SERVER['REMOTE_ADDR']);
echo $_GET['callback'] . '(' . $data . ');';
?>

Quindi il Javascript è esattamente lo stesso di prima, ma non un array:

<script type="application/javascript">
function getip(ip){
    alert('IP Address: ' + ip);
}
</script>

<script type="application/javascript" src="http://www.anotherdomain.com/file.php?callback=getip"> </script>

Semplice come quella!

Nota a margine: assicurati di pulire il tuo $ _GET se lo usi in qualsiasi ambiente pubblico!

So che questa domanda è stata posta molto tempo fa, ma ho pensato di offrire una risposta più recente.

DNS su HTTPS (DoH)

È possibile inviare query DNS tramite HTTPS ai risolutori DNS che lo supportano. Lo standard per DOH è descritto in RFC 8484 .

Questa è una cosa simile a ciò che suggeriscono tutte le altre risposte, solo che DoH è effettivamente il protocollo DNS su HTTPS. È anche uno standard Internet "proposto" e sta diventando molto popolare. Ad esempio, alcuni dei principali browser lo supportano o hanno in programma di supportarlo (Chrome, Edge, Firefox) e Microsoft sta per integrarlo nel proprio sistema operativo.

Uno degli scopi di DoH è:

consentendo alle applicazioni Web di accedere alle informazioni DNS tramite le API del browser esistenti in modo sicuro coerente con Cross Origin Resource Sharing (CORS)

C'è uno strumento open source creato appositamente per eseguire ricerche DNS da applicazioni web chiamato dohjs . Lo fa DNS su HTTPS query (DoH) wireformat come descritto nella RFC 8484 . Supporta i metodi GET e POST.

Divulgazione completa: sono un collaboratore di dohjs.

API JSON DNS su HTTPS

Se non vuoi perdere tempo con il wireformat DNS, sia Google che Cloudflare offrono API JSON per DNS su HTTPS.

• Endpoint di Google: https://dns.google/resolve ?
• Documenti dell'API JSON di Google: https://developers.google.com/speed/public-dns/docs/doh/json
• Endpoint di Cloudflare: https://cloudflare-dns.com/dns-query ?
• Documenti dell'API JSON di Cloudflare: https://developers.cloudflare.com/1.1.1.1/dns-over-https/json-format/

Esempio di codice Javascript per cercare example.com con l'API JSON DOH di Google:

var response = await fetch('https://dns.google/resolve?name=example.com');
var json = await response.json();
console.log(json);

Esempi dalla RFC per DOH GET e POST con wireformat

Di seguito sono riportati gli esempi forniti da RFC sia per GET che per POST (vedere https://tools.ietf.org/html/rfc8484#section-4.1.1 ):

OTTIENI un esempio:

La prima richiesta di esempio utilizza GET per richiedere "www.example.com".

: method = GET
: scheme = https
: authority = dnsserver.example.net
: path = / dns-query? dns = AAABAAABAAAAAAAAA3d3dwdleGFtcGxlA2NvbQAAAQAB
accept = application / dns-message

Esempio POST:

La stessa query DNS per "www.example.com", utilizzando il metodo POST, sarebbe:

: method = POST
: scheme = https
: authority = dnsserver.example.net
: path = / dns-query
accept = application / dns-message
content-type = application / dns-message
content-length = 33

<33 byte rappresentati dalla seguente codifica esadecimale> 00 00 01 00 00 01 00 00 00 00 00 00 03 77 77 77 07 65 78 61 6d 70 6c 65 03 63 6f 6d 00 00 01 00 01

Altri posti per inviare query DOH

Puoi trovare un elenco di alcuni resolver DNS pubblici che supportano DNS su HTTPS in un paio di posti:

• DNSCrypt ha un lungo elenco di resolver DoH e DNSCrypt pubblici sul loro Github e una bella versione interattiva dell'elenco su https://dnscrypt.info/public-servers/
• Wikipedia: confronto di server dei nomi ricorsivi pubblici
• Elenco sul wiki di Curl
• (breve) elenco su dnsprivacy.org

Delle risorse di cui sopra, direi che l'elenco sul wiki di Curl e l'elenco DNSCrypt sono probabilmente i più completi e quelli più aggiornati. La pagina di Curl include anche un elenco di strumenti open source per DoH (server, proxy, librerie client, ecc.).

Sono consapevole che questa è una vecchia domanda, ma la mia soluzione potrebbe aiutare gli altri.

Trovo che i servizi JSON (P) che lo rendono facile non durano per sempre, ma il seguente JavaScript funziona bene per me al momento della scrittura.

<script type="text/javascript">function z (x){ document.getElementById('y').innerHTML=x.query }</script>
<script type='text/javascript' src='http://ip-api.com/json/zero.eu.org?callback=z'></script>

Quanto sopra scrive l'IP del mio server sulla pagina in cui si trova, ma lo script può essere modificato per trovare qualsiasi IP cambiando 'zero.eu.org' con un altro nome di dominio. Questo può essere visto in azione sulla mia pagina all'indirizzo: http://meon.zero.eu.org/

Esiste un servizio di terze parti che fornisce un'API REST compatibile con CORS per eseguire ricerche DNS dal browser: https://exana.io/tools/dns/

Come molte persone hanno detto, è necessario utilizzare un servizio esterno e chiamarlo. E questo ti darà solo la risoluzione DNS dal punto di vista del server.

Se è abbastanza buono e se hai solo bisogno della risoluzione DNS, puoi utilizzare il seguente contenitore Docker:

https://github.com/kuralabs/docker-webaiodns

Endpoint:

[GET] /ipv6/[domain]: Esegue una risoluzione DNS per un determinato dominio e restituisce gli indirizzi IPv6 associati.

 {
     "addresses": [
         "2a01:91ff::f03c:7e01:51bd:fe1f"
     ]
 }

[GET] /ipv4/[domain]: Esegue una risoluzione DNS per un determinato dominio e restituisce gli indirizzi IPv4 associati.

 {
     "addresses": [
         "139.180.232.162"
     ]
 }

La mia raccomandazione è di configurare il server Web per eseguire il proxy inverso al contenitore su un particolare endpoint nel server che serve il tuo Javascript e di chiamarlo utilizzando le tue funzioni Ajax Javascript standard.

In questo modo è necessario interrompere la sandbox del browser. Prova a lasciare che il tuo server esegua la ricerca e richiedilo dal lato client tramite XmlHttp.

C'è una libreria javascript DNS-JS.com che fa proprio questo.

DNS.Query("dns-js.com",
    DNS.QueryType.A,
    function(data) {
        console.log(data);
});

Firefox ha un'API integrata per questo dalla v60, per WebExtensions:

https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/dns/resolve

certo che puoi farlo senza usare alcuna aggiunta, solo puro javascript, usando questo metodo di dns browser.dns.resolve("example.com"); ma è compatibile solo con FIREFOX 60 puoi vedere maggiori informazioni su MDN https://developer.mozilla.org/en-US/docs / Mozilla / Add-ons / WebExtensions / API / dns /ublesho

Non penso che ciò sia consentito dalla maggior parte dei browser per motivi di sicurezza, in un contesto JavaScript puro come la domanda chiede.

Forse ho perso il punto, ma in risposta al ragazzo della NAVY ecco come il browser può dirti l'indirizzo IP del "richiedente" (anche se forse solo il loro fornitore di servizi).

Posiziona un tag script nella pagina che deve essere renderizzato dal client che chiama (ha src che punta) un altro server che non è caricato bilanciato (mi rendo conto che questo significa che devi accedere a un secondo server ma l'hosting è economico in questi giorni e puoi configurarlo in modo semplice ed economico).

Questo è il tipo di codice che deve essere aggiunto alla pagina del cliente:

Sull'altro server "someServerIown" devi avere la pagina ASP, ASPX o PHP che;

----- contiene il codice del server come questo:

"<% Response.Write (" var clientipaddress = '"& Request.ServerVariables (" REMOTE_ADDR ") &"'; ")%>" (senza virgolette dbl esterne :-))

---- e riscrive questo codice nel tag dello script:

   var clientipaddress = '178.32.21.45';

Questo crea efficacemente una variabile Javascript a cui puoi accedere con Javascript sulla pagina non meno.

Si spera che tu acceda a questa var e scriva il valore in un controllo del modulo pronto per essere rispedito.

Quando l'utente invia o riceve la richiesta successiva, il tuo Javascript e / o modulo invia il valore della variabile che "otherServerIown" ha compilato per te, di nuovo al server su cui vorresti che fosse.

È così che aggiro il dumb load balancer che abbiamo che maschera l'indirizzo IP del client e lo fa apparire come quello del load balancer .... dumb ... dumb dumb dumb!

Non ho dato la soluzione esatta perché la situazione di ognuno è leggermente diversa. Il concetto è comunque valido. Inoltre, tieni presente che se lo stai facendo su una pagina HTTPS, anche il tuo "altroServerIOwn" deve fornire in quella forma sicura, altrimenti il ​​Cliente viene avvisato del contenuto misto. E se hai https, assicurati che TUTTI i tuoi certificati siano validi altrimenti anche il client riceve un avviso.

Spero che aiuti qualcuno! Spiacenti, ci è voluto un anno per rispondere / contribuire. :-)

La mia versione è così:

php sul mio server:

<?php
    header('content-type: application/json; charset=utf-8');

    $data = json_encode($_SERVER['REMOTE_ADDR']);


    $callback = filter_input(INPUT_GET, 
                 'callback',
                 FILTER_SANITIZE_STRING, 
                 FILTER_FLAG_ENCODE_HIGH|FILTER_FLAG_ENCODE_LOW);
    echo $callback . '(' . $data . ');';
?>

jQuery nella pagina:

var self = this;
$.ajax({
    url: this.url + "getip.php",
    data: null,
    type: 'GET',
    crossDomain: true,
    dataType: 'jsonp'

}).done( function( json ) {

    self.ip = json;

});

Funziona su più domini. Potrebbe utilizzare un controllo dello stato. Ci sto lavorando.

Se il client ha Java installato, potresti fare qualcosa del genere:

ipAddress = java.net.InetAddress.getLocalHost().getHostAddress();

Oltre a questo, probabilmente dovrai usare uno script lato server.