Posso realizar uma pesquisa DNS (nome do host para endereço IP) usando Javascript do lado do cliente?

Eu gostaria de usar Javascript do lado do cliente para realizar uma pesquisa DNS (nome do host para endereço IP), visto do computador do cliente. Isso é possível?

Não há noção de hosts ou endereços IP na biblioteca padrão javascript. Portanto, você terá que acessar algum serviço externo para pesquisar nomes de host para você.

Eu recomendo hospedar um cgi-bin que procura o endereço IP de um nome de host e acessa-o via javascript.

Edit : Esta questão me deu uma coceira, então eu coloquei um serviço da web JSONP no Google App Engine que retorna o endereço IP do cliente. 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>

Oba, não são necessários proxies de servidor.

JS puro não pode. Se você tiver um script de servidor no mesmo domínio que o imprime, poderá enviar um XMLHttpRequest para lê-lo.

Muito tarde, mas acho que muitas pessoas ainda vão pousar aqui através do "Google Airlines". Uma abordagem moderada é usar WebRTC que não requer suporte de servidor.

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

O próximo código é copiar e colar de 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.";
}   

A versão JSONP hospedada funciona perfeitamente, mas parece que gasta seus recursos durante a noite na maioria dos dias (horário do leste), então tive que criar minha própria versão.

Foi assim que fiz isso com o PHP:

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

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

Então, o Javascript é exatamente o mesmo de antes, mas não uma matriz:

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

Simples assim!

Observação lateral: certifique-se de limpar seu $ _GET se estiver usando em qualquer ambiente voltado para o público!

Sei que essa pergunta foi feita há muito tempo, mas decidi oferecer uma resposta mais recente.

DNS sobre HTTPS (DoH)

Você pode enviar consultas DNS por HTTPS para resolvedores de DNS que o suportam. O padrão para DOH é descrito no RFC 8484 .

Isso é semelhante ao que todas as outras respostas sugerem, apenas que DoH é na verdade o protocolo DNS sobre HTTPS. É também um padrão "proposto" da Internet e está se tornando bastante popular. Por exemplo, alguns dos principais navegadores o suportam ou têm planos de suportá-lo (Chrome, Edge, Firefox), e a Microsoft está em processo de integrá-lo em seu sistema operacional.

Um dos objetivos do DoH é:

permitindo que aplicativos da web acessem informações de DNS por meio de APIs de navegador existentes de maneira segura e consistente com o Cross Origin Resource Sharing (CORS)

Existe uma ferramenta de código aberto feita especialmente para fazer pesquisas de DNS em aplicativos da web chamada dohjs . Ele faz consultas em formato de fio DNS sobre HTTPS (DoH), conforme descrito em RFC 8484 . Ele suporta os métodos GET e POST.

Divulgação completa: eu contribuo com dohjs.

DNS sobre APIs JSON HTTPS

Se você não quiser se preocupar com o formato de cabo do DNS, o Google e o Cloudflare oferecem APIs JSON para DNS sobre HTTPS.

• Endpoint do Google: https://dns.google/resolve ?
• Documentos da API JSON do Google: https://developers.google.com/speed/public-dns/docs/doh/json
• Endpoint da Cloudflare: https://cloudflare-dns.com/dns-query ?
• Documentos da API JSON da Cloudflare: https://developers.cloudflare.com/1.1.1.1/dns-over-https/json-format/

Exemplo de código Javascript para pesquisar example.com com a API JSON DOH do Google:

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

Exemplos do RFC para DOH GET e POST com wireformat

Aqui estão os exemplos que o RFC fornece para GET e POST (consulte https://tools.ietf.org/html/rfc8484#section-4.1.1 ):

Exemplo GET:

O primeiro exemplo de solicitação usa GET para solicitar "www.example.com".

: método = GET
: esquema = https
: autoridade = dnsserver.example.net
: caminho = / dns-query? dns = AAABAAABAAAAAAAAA3d3dwdleGFtcGxlA2NvbQAAAQAB
aceitar = aplicativo / dns-mensagem

Exemplo de POST:

A mesma consulta DNS para "www.example.com", usando o método POST seria:

: método = POST
: esquema = https
: autoridade = dnsserver.example.net
: caminho = / dns-query
aceitar = application / dns-message
content-type = application / dns-message
content-length = 33

<33 bytes representados pela seguinte codificação hexadecimal> 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

Outros lugares para enviar consultas DOH

Você pode encontrar uma lista de alguns resolvedores de DNS públicos compatíveis com DNS sobre HTTPS em alguns lugares:

• DNSCrypt tem uma longa lista de resolvedores públicos de DoH e DNSCrypt em seu Github e uma bela versão interativa da lista em https://dnscrypt.info/public-servers/
• Wikipedia - comparação de servidores de nomes recursivos públicos
• Lista na wiki do Curl
• (curta) lista em dnsprivacy.org

Dos recursos acima, eu diria que a lista no wiki do Curl e a lista DNSCrypt são provavelmente as mais completas e atualizadas com mais frequência. A página do Curl também inclui uma lista de ferramentas de código aberto para DoH (servidores, proxies, bibliotecas de cliente, etc).

Sei que essa é uma questão antiga, mas minha solução pode ajudar outras pessoas.

Acho que os serviços JSON (P) que tornam isso fácil não duram para sempre, mas o JavaScript a seguir funciona bem para mim no momento em que escrevo.

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

O código acima escreve o IP do meu servidor na página em que está localizado, mas o script pode ser modificado para encontrar qualquer IP alterando 'zero.eu.org' para outro nome de domínio. Isso pode ser visto em ação na minha página: http://meon.zero.eu.org/

Existe um serviço de terceiros que fornece uma API REST compatível com CORS para realizar pesquisas de DNS a partir do navegador - https://exana.io/tools/dns/

Como muitas pessoas disseram, você precisa usar um serviço externo e ligar para ele. E isso só lhe dará a resolução DNS da perspectiva do servidor.

Se isso for bom o suficiente e você precisar apenas da resolução DNS, poderá usar o seguinte contêiner do Docker:

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

Endpoints:

[GET] /ipv6/[domain]: Execute uma resolução DNS para determinado domínio e retorne os endereços IPv6 associados.

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

[GET] /ipv4/[domain]: Execute uma resolução DNS para determinado domínio e retorne os endereços IPv4 associados.

 {
     "addresses": [
         "139.180.232.162"
     ]
 }

Minha recomendação é que você configure seu servidor web para reverter o proxy para o contêiner em um ponto de extremidade específico em seu servidor servindo seu Javascript e chamá-lo usando suas funções Ajax Javascript padrão.

Isso exigiria quebrar a sandbox do navegador. Tente deixar seu servidor fazer a pesquisa e solicitar isso do lado do cliente via XmlHttp.

Existe uma biblioteca javascript DNS-JS.com que faz exatamente isso.

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

O Firefox tem uma API integrada para isso desde a v60, para WebExtensions:

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

certeza de que você pode fazer isso sem usar qualquer adição, apenas javascript puro, usando este método de dns, browser.dns.resolve("example.com"); mas é compatível apenas com FIREFOX 60, você pode ver mais informações no MDN https://developer.mozilla.org/en-US/docs / Mozilla / Add-ons / WebExtensions / API / dns / resolve

Não acho que isso seja permitido pela maioria dos navegadores por razões de segurança, em um contexto JavaScript puro, como a pergunta pede.

Talvez eu tenha perdido o ponto, mas em resposta ao cara da MARINHA, aqui está como o navegador pode informar o endereço IP do 'solicitante' (embora talvez apenas o provedor de serviços).

Coloque uma tag de script na página a ser renderizada pelo cliente que chama (tem src apontando para) outro servidor que não está carregado balanceado (eu percebo que isso significa que você precisa de acesso a um segundo servidor, mas a hospedagem é barata hoje em dia e você pode configurar isso de forma fácil e barata).

Este é o tipo de código que precisa ser adicionado à página do cliente:

No outro servidor "someServerIown" você precisa ter a página ASP, ASPX ou PHP que;

----- contém o código do servidor como este:

"<% Response.Write (" var clientipaddress = '"& Request.ServerVariables (" REMOTE_ADDR ") &"'; ")%>" (sem as aspas dbl externas :-))

---- e grava este código de volta na tag de script:

   var clientipaddress = '178.32.21.45';

Isso cria efetivamente uma variável Javascript que você pode acessar com Javascript na página, nada menos.

Felizmente, você acessa essa var e grava o valor em um controle de formulário pronto para ser enviado de volta.

Quando o usuário postar ou receber a próxima solicitação, seu Javascript e / ou formulário enviará o valor da variável que "otherServerIown" preencheu para você, de volta ao servidor em que você gostaria.

É assim que consigo contornar o balanceador de carga burro que temos, que mascara o endereço IP do cliente e o faz parecer o do balanceador de carga ... burro ... burro burro burro!

Não dei a solução exata porque a situação de cada pessoa é um pouco diferente. O conceito é sólido, no entanto. Além disso, observe que se você estiver fazendo isso em uma página HTTPS, seu "otherServerIOwn" também deve ser entregue naquela forma segura, caso contrário, o Cliente será alertado sobre conteúdo misto. E se você tiver https, certifique-se de que TODOS os seus certificados são válidos, caso contrário, o cliente também receberá um aviso.

Espero que ajude alguém! Desculpe, demorou um ano para responder / contribuir. :-)

Minha versão é assim:

php no meu servidor:

<?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 na página:

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

}).done( function( json ) {

    self.ip = json;

});

Funciona em vários domínios. Ele poderia usar uma verificação de status. Trabalhando nisso.

Se o cliente tiver Java instalado, você pode fazer algo assim:

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

Fora isso, você provavelmente terá que usar um script do lado do servidor.