Eu sei que a reação inicial a esta pergunta é "não" e "não pode ser feito" e "você não deveria precisar, você está fazendo algo errado". O que estou tentando fazer é obter o endereço IP da LAN dos usuários e exibi-lo na página da web. Por quê? Porque é disso que se trata a página em que estou trabalhando, mostrando o máximo de informações possível sobre você, o visitante: http://www.whatsmyip.org/more-info-about-you/

Portanto, não estou FAZENDO nada com o IP, a não ser mostrá-lo ao usuário para fins informativos. Eu costumava fazer isso usando um pequeno miniaplicativo Java. Funcionou muito bem. Mas hoje em dia, o navegador faz com que você concorde e confie tantas vezes, para executar até mesmo o menor miniaplicativo Java, que prefiro não executar nenhum.

Então, por um tempo, acabei de me livrar desse recurso, mas gostaria que ele voltasse, se possível. Era algo que eu, como consultor de informática, usaria de vez em quando. É mais rápido ir a este site para ver em qual intervalo de IP uma rede está sendo executada, do que ir em Preferências do Sistema, Rede e, em seguida, qualquer interface que esteja ativa.

Portanto, espero que haja alguma maneira de fazer isso apenas em javascript? Talvez algum novo objeto que você possa acessar, semelhante ao modo como o javascript pode perguntar ao navegador onde está a localização geográfica na Terra. Talvez haja algo semelhante para informações de rede do cliente? Se não, talvez haja alguma outra maneira inteiramente de fazer isso? As únicas maneiras que consigo pensar são em um miniaplicativo java ou um objeto flash. Prefiro não fazer nada disso.

Acontece que a recente extensão WebRTC do HTML5 permite que o javascript consulte o endereço IP do cliente local. Uma prova de conceito está disponível aqui: http://net.ipcalf.com

Esse recurso é aparentemente por design e não é um bug. No entanto, devido à sua natureza controversa, eu seria cauteloso ao confiar nesse comportamento. No entanto, acho que ele atende de forma perfeita e apropriada ao objetivo pretendido (revelar ao usuário o que o navegador está vazando).

Atualizar

Esta solução não funcionaria mais porque os navegadores estão corrigindo o vazamento do webrtc: para mais informações sobre isso, leia esta outra pergunta: RTCIceCandidate não retorna mais o IP

Além da resposta de uma revista, este código funciona em navegadores que suportam WebRTC (Chrome e Firefox). Ouvi dizer que há um movimento em andamento para implementar um recurso que faz os sites solicitarem o IP (como no caso de geo-localização ou mídia do usuário), embora ainda não tenha sido implementado em nenhum desses navegadores.

Aqui está uma versão modificada do código-fonte , reduziu as linhas, não fazendo nenhuma solicitação de atordoamento, pois você deseja apenas o IP local, não o IP público:

window.RTCPeerConnection = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection;//compatibility for Firefox and chrome
var pc = new RTCPeerConnection({iceServers:[]}), noop = function(){};      
pc.createDataChannel('');//create a bogus data channel
pc.createOffer(pc.setLocalDescription.bind(pc), noop);// create offer and set local description
pc.onicecandidate = function(ice)
{
 if (ice && ice.candidate && ice.candidate.candidate)
 {
  var myIP = /([0-9]{1,3}(\.[0-9]{1,3}){3}|[a-f0-9]{1,4}(:[a-f0-9]{1,4}){7})/.exec(ice.candidate.candidate)[1];
  console.log('my IP: ', myIP);   
  pc.onicecandidate = noop;
 }
};

Estamos criando uma conexão de par fictícia para o par remoto entrar em contato conosco. Geralmente trocamos candidatos de gelo uns com os outros e, lendo os candidatos de gelo, podemos dizer o ip do usuário.

Você pode encontrar uma demonstração em -> Demonstração

A API WebRTC pode ser usada para recuperar o IP local do cliente.

No entanto, o navegador pode não suportá-lo ou o cliente pode tê-lo desativado por motivos de segurança. Em qualquer caso, não se deve confiar neste "hack" a longo prazo, pois é provável que seja corrigido no futuro (veja a resposta de Cullen Fluffy Jennings).

O código ECMAScript 6 abaixo demonstra como fazer isso.

/* ES6 */
const findLocalIp = (logInfo = true) => new Promise( (resolve, reject) => {
    window.RTCPeerConnection = window.RTCPeerConnection 
                            || window.mozRTCPeerConnection 
                            || window.webkitRTCPeerConnection;

    if ( typeof window.RTCPeerConnection == 'undefined' )
        return reject('WebRTC not supported by browser');

    let pc = new RTCPeerConnection();
    let ips = [];

    pc.createDataChannel("");
    pc.createOffer()
     .then(offer => pc.setLocalDescription(offer))
     .catch(err => reject(err));
    pc.onicecandidate = event => {
        if ( !event || !event.candidate ) {
            // All ICE candidates have been sent.
            if ( ips.length == 0 )
                return reject('WebRTC disabled or restricted by browser');

            return resolve(ips);
        }

        let parts = event.candidate.candidate.split(' ');
        let [base,componentId,protocol,priority,ip,port,,type,...attr] = parts;
        let component = ['rtp', 'rtpc'];

        if ( ! ips.some(e => e == ip) )
            ips.push(ip);

        if ( ! logInfo )
            return;

        console.log(" candidate: " + base.split(':')[1]);
        console.log(" component: " + component[componentId - 1]);
        console.log("  protocol: " + protocol);
        console.log("  priority: " + priority);
        console.log("        ip: " + ip);
        console.log("      port: " + port);
        console.log("      type: " + type);

        if ( attr.length ) {
            console.log("attributes: ");
            for(let i = 0; i < attr.length; i += 2)
                console.log("> " + attr[i] + ": " + attr[i+1]);
        }

        console.log();
    };
} );

Observe que escrevo return resolve(..)ou return reject(..)como um atalho. Ambas as funções não retornam nada.

Então você pode ter algo assim:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Local IP</title>
</head>
<body>
    <h1>My local IP is</h1>
    <p id="ip">Loading..</p>
    <script src="ip.js"></script>
    <script>
    let p = document.getElementById('ip');
    findLocalIp().then(
        ips => {
            let s = '';
            ips.forEach( ip => s += ip + '<br>' );
            p.innerHTML = s;
        },
        err => p.innerHTML = err
    );
    </script>
</body>
</html>

Limpei a postagem do mido e depois limpei a função que eles encontraram. Isso irá retornar falseou um array. Ao testar, lembre-se de que você precisa recolher o array no console do desenvolvedor da web, caso contrário, seu comportamento padrão não intuitivo pode enganá-lo ao pensar que ele está retornando um vazio array.

function ip_local()
{
 var ip = false;
 window.RTCPeerConnection = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection || false;

 if (window.RTCPeerConnection)
 {
  ip = [];
  var pc = new RTCPeerConnection({iceServers:[]}), noop = function(){};
  pc.createDataChannel('');
  pc.createOffer(pc.setLocalDescription.bind(pc), noop);

  pc.onicecandidate = function(event)
  {
   if (event && event.candidate && event.candidate.candidate)
   {
    var s = event.candidate.candidate.split('\n');
    ip.push(s[0].split(' ')[4]);
   }
  }
 }

 return ip;
}

Além disso, lembre-se, pessoal, de que isso não é algo novo como o CSS, border-radiusembora seja um daqueles bits que não é totalmente suportado pelo IE11 e anteriores. Sempre use a detecção de objetos, teste em navegadores razoavelmente mais antigos (por exemplo, Firefox 4, IE9, Opera 12.1) e certifique-se de que seus scripts mais recentes não estão quebrando seus bits de código mais recentes. Além disso, sempre detecte o código compatível com os padrões primeiro, portanto, se houver algo com, digamos, um prefixo CSS, detecte o código padrão não prefixado primeiro e, em seguida, retroceda, pois a longo prazo o suporte será padronizado para o resto de sua existência.

Chrome 76+

No ano passado, usei a resposta do Linblow (19 de outubro de 2018) para descobrir com sucesso meu IP local via javascript. No entanto, as atualizações recentes do Chrome (76?) Conquistaram esse método para que agora ele retorne um IP ofuscado, como:1f4712db-ea17-4bcf-a596-105139dfd8bf.local

Se você tiver controle total sobre seu navegador, poderá desfazer esse comportamento desativando-o nos sinalizadores do Chrome, digitando o seguinte na barra de endereço:

chrome://flags

e DESATIVANDO a bandeira Anonymize local IPs exposed by WebRTC

No meu caso, exijo o IP de um script TamperMonkey para determinar minha localização atual e fazer coisas diferentes com base na minha localização. Também tenho controle total sobre as configurações do meu próprio navegador (sem políticas corporativas, etc.). Então, para mim, mudar a chrome://flagsconfiguração resolve.

Fontes:

https://groups.google.com/forum/#!topic/discuss-webrtc/6stQXi72BEU

https://codelabs.developers.google.com/codelabs/webrtc-web/index.html

Você pode encontrar mais informações sobre quais limitações os navegadores provavelmente irão adicionar para mitigar isso e o que a IETF está fazendo sobre isso, bem como por que isso é necessário no IETF SPEC no tratamento de IP

Um RTCPeerConnectionpode ser usado. Em navegadores como o Chrome, onde uma getUserMediapermissão é necessária , podemos apenas detectar os dispositivos de entrada disponíveis e solicitá-los.

const internalIp = async () => {
    if (!RTCPeerConnection) {
        throw new Error("Not supported.")
    }

    const peerConnection = new RTCPeerConnection({ iceServers: [] })

    peerConnection.createDataChannel('')
    peerConnection.createOffer(peerConnection.setLocalDescription.bind(peerConnection), () => { })

    peerConnection.addEventListener("icecandidateerror", (event) => {
        throw new Error(event.errorText)
    })

    return new Promise(async resolve => {
        peerConnection.addEventListener("icecandidate", async ({candidate}) => {
            peerConnection.close()

            if (candidate && candidate.candidate) {
                const result = candidate.candidate.split(" ")[4]
                if (result.endsWith(".local")) {
                    const inputDevices = await navigator.mediaDevices.enumerateDevices()
                    const inputDeviceTypes = inputDevices.map(({ kind }) => kind)

                    const constraints = {}

                    if (inputDeviceTypes.includes("audioinput")) {
                        constraints.audio = true
                    } else if (inputDeviceTypes.includes("videoinput")) {
                        constraints.video = true
                    } else {
                        throw new Error("An audio or video input device is required!")
                    }

                    const mediaStream = await navigator.mediaDevices.getUserMedia(constraints)
                    mediaStream.getTracks().forEach(track => track.stop())
                    resolve(internalIp())
                }
                resolve(result)
            }
        })
    })
}