Javascript webrtc (STUN) ipv6

Question

When trying to find out my public IP address using a public STUN server, it works for IPv4 but not for IPv6, regardless of the STUN server I use.

I only get stuff like "59aeb370-1d93-44ee-a526-27d639256cf4.local" under candidate.address. Is there any way to get the public IPv6 via javascript using STUN?

The code I use is:

(don't mind the IPv4 regex; the entire 'candidate' is console logged anyway)

var ip_dups = {};

function getRTCPeerConnection () {
    var iframe, content_window, rtc_peer_con = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection || window.msRTCPeerConnection;
    return rtc_peer_con || (iframe = document.createElement("iframe"), iframe.style.display = "none", document.body.appendChild(iframe), content_window = iframe.contentWindow, rtc_peer_con = content_window.RTCPeerConnection || content_window.mozRTCPeerConnection || content_window.webkitRTCPeerConnection || content_window.msRTCPeerConnection), rtc_peer_con
};

var n = getRTCPeerConnection();
servers = {
    iceServers: [{
        urls: "stun:stun.l.google.com:19302"
    }]
};  
mediaConstraints = {
    optional: [{
        RTCPChannel: true
    }]
};
        
pc = new n(servers, mediaConstraints);

function handleCandidate(candidate){
    console.log(candidate);
    //match just the IP address
    var ip_regex = /([0-9]{1,3}(\.[0-9]{1,3}){3}|[a-f0-9]{1,4}(:[a-f0-9]{1,4}){7})/
    var ip_addr = ip_regex.exec(candidate)[1];
    if(ip_dups[ip_addr] === undefined) {
        console.log(ip_addr);
        ip_dups[ip_addr] = true;
    }
    pc.close()
}

pc.onicecandidate = function(ice){
    //skip non-candidate events
    console.log(ice)
    if(ice.candidate) {
        handleCandidate(ice.candidate.candidate);
    }
};

pc.createDataChannel("");

void pc.createOffer(function(e) {
    console.log(e)
    console.log(e.sdp)
    pc.setLocalDescription(e, function() {}, function() {})
}, function() {})

EDIT:

seems like in some cases I do get my IPv6 in the response when running the code inside the consoles of some web pages.

But then when accessing the same page from chrome incognito for example, it doesn't work, so it's not because of the domain or anything like that.

No permissions are involved too.

So what the hell is going on? What's the logic behind it? Is there anything can do so my webpage will always cause its visitors to receive their IPv6 addresses?

Answer 1

To quote a great article about your issue:

Ignoring that fact, Google has been running mDNS as an experiment for a few Chrome releases already. As an experiment, two things were decided:

• It runs almost “randomly” on Chrome browsers of users without any real control of the user or the service that this is happening (not something automated and obvious at least)
• It was added only when local IP addresses had to be shared and no permission for the camera or microphone were asked for (receive only scenarios)

Basically, Chrome has been rolling out mDNS IP obfuscation. This means that if your script does not call getUserMedia, the candidate line will be obfuscated. Please read the entire article here

OLD ANSWER:

Due to security concerns originating with the Chrome team, IP addresses are now obfuscated (hidden, definition). If you look at the date on the post you commented (in 2018, three years ago), you can see how outdated this question and solution is.

However, you can use a UDP transport which will reliably return a user's IPv4 address. Consider the following snippet:

iceServers: [{
    urls: "stun:stun.l.google.com:19302?transport=udp"
}]

That being said, you can also reliably get a user's IP address with a 3rd part API like Abstract (see the full list of 3rd party IP lookups here). Alternatively, you can use Node.js to do the same thing. Here are some relevant code samples and articles:

How to Get User’s IP Details in ExpressJS - Article

geoip-lite - Node.js module

Simple ip detection in Node.js:

const express = require('express');
const app = express();
const router = express.Router();

router.get('/someroute', (req,res) => {
  const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
  console.log(ip); // ip address of the user
});

app.use('/', router);
app.listen(5000);

(found here)

References:

Wikipedia:

The basic protocol operates essentially as follows: The client, typically operating inside a private network, sends a binding request to a STUN server on the public Internet. The STUN server responds with a success response that contains the IP address and port number of the client, as observed from the server's perspective. The result is obfuscated through exclusive or (XOR) mapping to avoid translation of the packet content by application layer gateways (ALGs) that perform deep packet inspection in an attempt to perform alternate NAT traversal methods.

RFC 5389:

The XOR-MAPPED-ADDRESS attribute is identical to the MAPPED-ADDRESS attribute, except that the reflexive transport address is obfuscated through the XOR function.

Here is the final code:

var ip_dups = {};

function getRTCPeerConnection () {
    var iframe, content_window, rtc_peer_con = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection || window.msRTCPeerConnection;
    return rtc_peer_con || (iframe = document.createElement("iframe"), iframe.style.display = "none", document.body.appendChild(iframe), content_window = iframe.contentWindow, rtc_peer_con = content_window.RTCPeerConnection || content_window.mozRTCPeerConnection || content_window.webkitRTCPeerConnection || content_window.msRTCPeerConnection), rtc_peer_con
};

var n = getRTCPeerConnection();
servers = {
    iceServers: [{
        urls: "stun:stun.l.google.com:19302?transport=udp"
    }]
};  
mediaConstraints = {
    optional: [{
        RTCPChannel: true
    }]
};
        
pc = new n(servers, mediaConstraints);

function handleCandidate(candidate){
    console.log(candidate);
    //match just the IP address
    var ip_regex = /([0-9]{1,3}(\.[0-9]{1,3}){3}|[a-f0-9]{1,4}(:[a-f0-9]{1,4}){7})/
    var ip_addr = ip_regex.exec(candidate)[1];
    if(ip_dups[ip_addr] === undefined) {
        console.log(ip_addr);
        ip_dups[ip_addr] = true;
    }
    pc.close()
}

pc.onicecandidate = function(ice){
    //skip non-candidate events
    console.log(ice)
    if(ice.candidate) {
        handleCandidate(ice.candidate.candidate);
    }
};
// now you have to create a data channel with a name
pc.createDataChannel("fake_data_channel");

void pc.createOffer(function(e) {
    console.log(e)
    console.log(e.sdp)
    pc.setLocalDescription(e, function() {}, function() {})
}, function() {})