È possibile eseguire una ricerca DNS (nome host in un indirizzo IP utilizzando Javascript lato client?

Question

Vorrei utilizzare Javascript lato client per eseguire una ricerca DNS (nome host in un indirizzo IP, come si è visto dal computer client.È possibile?

Answer 1

Non esiste alcuna nozione di host o indirizzi IP nella libreria standard javascript. Quindi dovrai accedere ad alcuni servizi esterni per cercare i nomi host per te.

Raccomando di ospitare un cgi-bin che cerca l'indirizzo IP di un nome host e accede a questo tramite javascript.

Answer 2

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

<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.

---

JS puro non può. Se disponi di uno script server nello stesso dominio che lo stampa, puoi inviare un XMLHttpRequest per leggerlo.

Answer 3

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

https://hacking.ventures/local-ip- discovery-con-html5-WebRTC-sicurezza-e-privacy-rischio /

Il prossimo codice è una copia & amp; 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.";
}   

Answer 4

La versione JSONP ospitata funziona come un incantesimo, ma sembra che vada oltre le sue risorse durante la notte quasi tutti i giorni (Eastern Time), 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 quello!

Nota a margine: assicurati di pulire $ _GET se lo stai utilizzando in qualsiasi ambiente pubblico!

Answer 5

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

Trovo che i servizi JSON (P) che rendono questo facile non durino 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/

Answer 6

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/

Answer 7

Come molte persone hanno detto che è 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 di una risoluzione DNS puoi usare il seguente contenitore Docker:

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

Endpoints:

[GET] /ipv6/[domain]:  Eseguire una risoluzione DNS per un determinato dominio e restituire l'IPv6 associato  indirizzi.

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

[GET] /ipv4/[domain]:  Eseguire una risoluzione DNS per un determinato dominio e restituire l'IPv4 associato  indirizzi.

 {
     "addresses": [
         "139.180.232.162"
     ]
 }

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

Answer 8

Ciò richiederebbe di interrompere la sandbox del browser. Prova a consentire al tuo server di effettuare la ricerca e di richiederlo dal lato client tramite XmlHttp.

Answer 9

sicuro che puoi farlo senza usare alcuna aggiunta, solo javascript puro, 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/resolve

Answer 10

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

Answer 11

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

https: // developer .mozilla.org / it-iT / docs / Mozilla / Add-ons / WebExtensions / API / dns / risolvere

Answer 12

Forse mi sono perso il punto, ma in risposta ad un NAVY ragazzo qui è come il browser può dire il 'richiedente' indirizzo IP (anche se magari solo con il loro fornitore del servizio).

Inserire un tag script nella pagina per essere resi dal cliente che chiama (ha src punta a) di un altro server che non viene caricato equilibrato (mi rendo conto che questo significa che avete bisogno di accedere ad un 2 ° server di hosting è a buon mercato in questi giorni e si può impostare facilmente e a basso costo).

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

Sull'altro server "someServerIown" avete bisogno dell'ASP, ASPX, PHP o pagina;

----- server contiene un codice come questo:

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

---- e scrive questo codice tag script:

   var clientipaddress = '178.32.21.45';

In pratica, si crea una variabile Javascript che è possibile accedere con il codice Javascript della pagina non meno.

Si spera, si accede a questa var e scrivere il valore di una forma di controllo pronto per il rientro.

Quando l'utente invia o riceve alla successiva richiesta di Javascript e/o del modulo invia il valore della variabile che il "otherServerIown" ha riempito per voi, al server come su.

Questo è come sono arrivato intorno al muto di bilanciamento del carico che abbiamo, che maschera l'indirizzo IP del client e lo fa apparire come quella del sistema di bilanciamento del Carico ....muto ...muto muto muto!

Non ho dato la soluzione esatta, poiché ogni situazione è un po ' diverso.Il concetto è chiaro, tuttavia.Si noti, inoltre, se si sta facendo questo su una pagina web HTTPS tuo "otherServerIOwn" deve anche consegnare in che modulo sicuro altrimenti Cliente viene avvisato di contenuto misto.E se avete https quindi assicurarsi che TUTTI i certificati sono validi, altrimenti il client riceve un messaggio di avviso.

Speranza che aiuta qualcuno!Scusate, c'è voluto un anno per rispondere/contribuire.:-)

Answer 13

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 sulla 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.

Answer 14

Se sul client è installato Java, è possibile fare qualcosa del genere:

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

A parte questo, probabilmente dovrai usare uno script lato server.