@k03mad/dns-leak 2.0.2 → 3.0.1

package/README.md

@@ -1,14 +1,18 @@
 # DNS leak test
 
-Based on:\
-— [ipleak.net](https://ipleak.net) ([API](https://airvpn.org/forums/topic/14737-api))\
-— [ipwhois.io](https://ipwhois.io) ([API](https://ipwhois.io/documentation))
+Using API/tools:\
+— [ipleak.net](https://airvpn.org/forums/topic/14737-api)\
+— [ipwhois.io](https://ipwhois.io/documentation)\
+— [cloudping.cloud](https://www.cloudping.cloud/cdn)\
+— [nextdns.io](https://test.nextdns.io/)
 
 ## Global
 
 ```bash
 npm i @k03mad/dns-leak -g
+```
 
+```bash
 dns-leak
 ```
 
@@ -19,21 +23,7 @@ npm i @k03mad/dns-leak
 ```
 
 ```js
-import {IPLeak, IPWhois} from '@k03mad/dns-leak';
-
-// default params (details at the ./app/api folder)
-const LeakApi = new IPLeak();
-const WhoisApi = new IPWhois();
-
-// get current external ip info
-await WhoisApi.getIpInfo();
-await LeakApi.getIpInfo();
-// get other ip info
-await WhoisApi.getIpInfo({ip: '8.8.8.8'});
-await LeakApi.getIpInfo({ip: '8.8.8.8'});
-
-// dns leak check with one request (one request — fewer dns ips)
-await LeakApi.getDnsInfoOnce();
-// dns leak check with multi requests
-await LeakApi.getDnsInfoMulti();
+import {CloudPing, IPLeak, IPWhois, NextDNS} from '@k03mad/dns-leak';
 ```
+
+Details at [./app/api](/app/api) folder

package/app/api/CloudPing.js

@@ -0,0 +1,66 @@
+import {request} from '@k03mad/request';
+
+/** */
+export default class CloudPing {
+
+    /**
+     * @param {object} [opts]
+     * @param {number} [opts.requestsRps] parallel requests rps
+     */
+    constructor({
+        requestsRps = 2,
+    } = {}) {
+        this._requestsRps = requestsRps;
+    }
+
+    /** */
+    get _endpoints() {
+        return {
+
+            /** */
+            edge: () => 'https://edge.feitsui.com/',
+
+            /** */
+            locations: () => 'https://www.cloudping.cloud/cloudfront-edge-locations.json',
+        };
+    }
+
+    /**
+     * @returns {Promise<string>}
+     */
+    async getCurrentIataCode() {
+        const testEndpoint = this._endpoints.edge();
+
+        const {headers} = await request(testEndpoint, {}, {
+            rps: this._requestsRps,
+        });
+
+        return headers['x-amz-cf-pop'];
+    }
+
+    /**
+     * @returns {Promise<object>}
+     */
+    async getAllLocations() {
+        const locationsEndpoint = this._endpoints.locations();
+
+        const {body} = await request(locationsEndpoint, {}, {
+            rps: this._requestsRps,
+        });
+
+        return body.nodes;
+    }
+
+    /**
+     * @returns {Promise<object>}
+     */
+    async getCurrentLocation() {
+        const [iata, locations] = await Promise.all([
+            this.getCurrentIataCode(),
+            this.getAllLocations(),
+        ]);
+
+        return {...locations[iata.replace(/\d.+/, '')], iata};
+    }
+
+}

package/app/api/IPLeak.js

@@ -11,29 +11,26 @@ export default class IPLeak {
     /**
      * @param {object} [opts]
      * @param {number} [opts.dnsRequestsCount] dns leak multi requests count with one session
-     * @param {number} [opts.dnsRequestsRps] dns leak requests rps
      * @param {number} [opts.dnsRequestsWaitBeforeLastMs] dns leak multi requests wait before the last request (with all ips gathered)
      * @param {number} [opts.dnsSessionStringLength] dns leak session string length, only works with 40 characters for now
      * @param {number} [opts.dnsUniqStringLength] dns leak unique string length for subdomain
      * @param {number} [opts.ipRequestsCacheExpireMs] ip info requests cache ttl ms for same ip
-     * @param {number} [opts.ipRequestsRps] ip info requests rps
+     * @param {number} [opts.requestsRps] parallel requests rps
      */
     constructor({
         dnsRequestsCount = 30,
-        dnsRequestsRps = 2,
         dnsRequestsWaitBeforeLastMs = 2000,
         dnsSessionStringLength = 40,
         dnsUniqStringLength = 20,
         ipRequestsCacheExpireMs = 3_600_000,
-        ipRequestsRps = 2,
+        requestsRps = 2,
     } = {}) {
         this._dnsRequestsCount = dnsRequestsCount;
-        this._dnsRequestsRps = dnsRequestsRps;
         this._dnsRequestsWaitBeforeLastMs = dnsRequestsWaitBeforeLastMs;
         this._dnsSessionStringLength = dnsSessionStringLength;
         this._dnsUniqStringLength = dnsUniqStringLength;
         this._ipRequestsCacheExpireMs = ipRequestsCacheExpireMs;
-        this._ipRequestsRps = ipRequestsRps;
+        this._requestsRps = requestsRps;
     }
 
     /** */
@@ -71,7 +68,7 @@ export default class IPLeak {
 
         const {body} = await requestCache(ipEndpoint, {}, {
             expire: this._ipRequestsCacheExpireMs,
-            rps: this._ipRequestsRps,
+            rps: this._requestsRps,
         });
 
         return body;
@@ -86,7 +83,11 @@ export default class IPLeak {
     async getDnsInfoOnce({session = this._dnsSessionString, uniqString = this._dnsUniqString} = {}) {
         const dnsEndpoint = this._endpoints.dns(session, uniqString);
 
-        const {body} = await request(dnsEndpoint, {}, {queueBy: session, rps: this._dnsRequestsRps});
+        const {body} = await request(dnsEndpoint, {}, {
+            queueBy: session,
+            rps: this._requestsRps,
+        });
+
         return body;
     }
 
@@ -97,7 +98,7 @@ export default class IPLeak {
      * @returns {Promise<object>}
      */
     async getDnsInfoMulti({isSpinnerEnabled, session = this._dnsSessionString} = {}) {
-        const spinnerName = 'dnsReq';
+        const spinnerName = 'DNS info';
         const arrayFromLen = Array.from({length: this._dnsRequestsCount - 1});
 
         spinner.start(spinnerName, isSpinnerEnabled);
@@ -107,7 +108,6 @@ export default class IPLeak {
             spinner.count(spinnerName, this._dnsRequestsCount);
         }));
 
-        spinner.text(spinnerName, 'Wait for last request');
         await sleep(this._dnsRequestsWaitBeforeLastMs);
         const info = await this.getDnsInfoOnce({session});
 

package/app/api/IPWhois.js

@@ -6,14 +6,14 @@ export default class IPWhois {
     /**
      * @param {object} [opts]
      * @param {number} [opts.ipRequestsCacheExpireMs] ip info requests cache ttl ms for same ip
-     * @param {number} [opts.ipRequestsRps] ip info requests rps
+     * @param {number} [opts.requestsRps] parallel requests rps
      */
     constructor({
         ipRequestsCacheExpireMs = 3_600_000,
-        ipRequestsRps = 2,
+        requestsRps = 2,
     } = {}) {
         this._ipRequestsCacheExpireMs = ipRequestsCacheExpireMs;
-        this._ipRequestsRps = ipRequestsRps;
+        this._requestsRps = requestsRps;
     }
 
     /** */
@@ -35,7 +35,7 @@ export default class IPWhois {
 
         const {body} = await requestCache(ipEndpoint, {}, {
             expire: this._ipRequestsCacheExpireMs,
-            rps: this._ipRequestsRps,
+            rps: this._requestsRps,
         });
 
         return body;

package/app/api/NextDNS.js

@@ -0,0 +1,38 @@
+import {request} from '@k03mad/request';
+
+/** */
+export default class NextDNS {
+
+    /**
+     * @param {object} [opts]
+     * @param {number} [opts.requestsRps] parallel requests rps
+     */
+    constructor({
+        requestsRps = 2,
+    } = {}) {
+        this._requestsRps = requestsRps;
+    }
+
+    /** */
+    get _endpoints() {
+        return {
+
+            /** */
+            test: () => 'https://test.nextdns.io/',
+        };
+    }
+
+    /**
+     * @returns {Promise<object>}
+     */
+    async getTest() {
+        const testEndpoint = this._endpoints.test();
+
+        const {body} = await request(testEndpoint, {}, {
+            rps: this._requestsRps,
+        });
+
+        return body;
+    }
+
+}

package/app/api/_index.js

@@ -0,0 +1,4 @@
+export {default as CloudPing} from './CloudPing.js';
+export {default as IPLeak} from './IPLeak.js';
+export {default as IPWhois} from './IPWhois.js';
+export {default as NextDNS} from './NextDNS.js';

package/app/helpers/spinner.js

@@ -1,6 +1,6 @@
 import ora from 'ora';
 
-import {bar} from './text.js';
+import {bar, info} from './text.js';
 
 export const spinner = {};
 
@@ -26,7 +26,7 @@ export const start = (name, active) => {
  * @param {string} msg
  */
 export const text = (name, msg) => {
-    spinner[name].instance.text = bar(msg);
+    spinner[name].instance.text = `${info(name)} ${bar(msg)}`;
 };
 
 /**

package/app/helpers/text.js

@@ -1,17 +1,34 @@
 import chalk from 'chalk';
+import clm from 'country-locale-map';
 
-const {bgBlackBright, blue, gray, green, yellow} = chalk;
+const {blue, gray, green, magenta, yellow} = chalk;
+const SEPARATOR = ' :: ';
 
 /**
  * @param {string} msg
  */
-export const header = msg => bgBlackBright.magenta.bold(` ${msg}`.padEnd(15, ' '));
+export const header = msg => magenta.bold.bgBlackBright(` ${msg}`.padEnd(25, ' '));
 
 /**
  * @param {string} msg
  */
 export const bar = msg => yellow(msg);
 
+/**
+ * @param {string} msg
+ */
+export const info = msg => gray(msg);
+
+/**
+ * @param {string} msg
+ */
+export const org = msg => green(msg);
+
+/**
+ * @param {string} msg
+ */
+export const address = msg => blue(msg);
+
 /**
  * @param {object} [ipInfo]
  * @param {object} [ipInfo.connection]
@@ -32,23 +49,23 @@ export const formatIpInfo = ({
     let output = '';
 
     if (ip) {
-        output += `${blue(ip)}\n`;
+        output += `${address(ip)}\n`;
     }
 
     if (connection?.org) {
-        output += `${green(connection.org)} `;
+        output += `${org(connection.org)} `;
     }
 
     if (connection?.isp && !connection?.org?.includes(connection?.isp)) {
         if (connection?.org) {
-            output += green('/ ');
+            output += org('/ ');
         }
 
-        output += `${green(connection.isp)} `;
+        output += `${org(connection.isp)} `;
     }
 
     if (connection?.domain) {
-        output += gray(`(${connection.domain})`);
+        output += info(`(${connection.domain})`);
     }
 
     output += '\n';
@@ -63,7 +80,37 @@ export const formatIpInfo = ({
             region,
             city,
         ]),
-    ].filter(Boolean).join(' :: ');
+    ].filter(Boolean).join(SEPARATOR);
+
+    return output;
+};
+
+/**
+ * @param {object} [opts]
+ * @param {string} [opts.iata]
+ * @param {string} [opts.city]
+ * @param {string} [opts.country]
+ */
+export const formatLocationInfo = ({city, country, iata}) => {
+    let output = '';
+
+    if (iata) {
+        output += `${org(iata)}\n`;
+    }
+
+    if (country) {
+        const {emoji} = clm.getCountryByName(country);
+
+        if (emoji) {
+            output += `${emoji}  `;
+        }
+
+        output += country;
+    }
+
+    if (city) {
+        output += SEPARATOR + city;
+    }
 
     return output;
 };

package/app/run.js

@@ -1,37 +1,61 @@
 #!/usr/bin/env node
-import {IPLeak, IPWhois} from './api/index.js';
+import {CloudPing, IPLeak, IPWhois, NextDNS} from './api/_index.js';
 import {log} from './helpers/log.js';
 import * as spinner from './helpers/spinner.js';
-import {formatIpInfo, header} from './helpers/text.js';
+import {formatIpInfo, formatLocationInfo, header} from './helpers/text.js';
 
 const LeakApi = new IPLeak();
+const NextApi = new NextDNS();
 const WhoisApi = new IPWhois();
+const CloudPingApi = new CloudPing();
 
-const currentIpInfo = await WhoisApi.getIpInfo();
+const [leak, next, whois, location] = await Promise.all([
+    LeakApi.getDnsInfoMulti({isSpinnerEnabled: true}),
+    NextApi.getTest(),
+    WhoisApi.getIpInfo(),
+    CloudPingApi.getCurrentLocation(),
+]);
+
+const spinnerName = 'IP info';
+spinner.start(spinnerName, true);
+
+const dnsIps = [...new Set([...Object.keys(leak.ip), next.resolver])];
+
+const dnsData = await Promise.all(dnsIps.map(async ip => {
+    const data = await WhoisApi.getIpInfo({ip});
+    spinner.count(spinnerName, dnsIps.length);
+    return data;
+}));
+
+spinner.stop(spinnerName);
 
 log(
     '',
     header('IP'),
     '',
-    formatIpInfo(currentIpInfo),
+    formatIpInfo(whois),
     '',
     header('DNS'),
     '',
+    ...dnsData
+        .sort((a, b) => a?.ip?.localeCompare(b?.ip))
+        .flatMap(data => [formatIpInfo(data), '']),
 );
 
-const dnsInfo = await LeakApi.getDnsInfoMulti({isSpinnerEnabled: true});
-const dnsIps = [...new Set(Object.keys(dnsInfo.ip))];
+if (next.ecs) {
+    const data = await WhoisApi.getIpInfo({ip: next.ecs.replace(/\/.+/, '')});
+    data.ip += ` (${next.ecs})`;
 
-spinner.start(currentIpInfo.ip, true);
+    log(
+        header('DNS ECS'),
+        '',
+        formatIpInfo(data),
+        '',
+    );
+}
 
-const dnsData = await Promise.all(dnsIps.map(async ip => {
-    const data = await WhoisApi.getIpInfo({ip});
-    spinner.count(currentIpInfo.ip, dnsIps.length);
-    return data;
-}));
-
-spinner.stop(currentIpInfo.ip);
-
-dnsData
-    .sort((a, b) => a?.ip?.localeCompare(b?.ip))
-    .forEach(data => log(formatIpInfo(data), ''));
+log(
+    header('CLOUDFRONT CDN'),
+    '',
+    formatLocationInfo(location),
+);

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@k03mad/dns-leak",
-  "version": "2.0.2",
+  "version": "3.0.1",
   "description": "DNS leak test",
   "maintainers": [
     "Kirill Molchanov <k03.mad@gmail.com"
   ],
-  "main": "app/api/index.js",
+  "main": "app/api/_index.js",
   "bin": "app/run.js",
   "repository": "k03mad/dns-leak",
   "license": "MIT",
@@ -16,6 +16,7 @@
   "dependencies": {
     "@k03mad/request": "3.2.0",
     "chalk": "5.3.0",
+    "country-locale-map": "1.8.15",
     "nanoid": "5.0.2",
     "nanoid-dictionary": "5.0.0-beta.1",
     "ora": "7.0.1"

package/app/api/index.js

@@ -1,2 +0,0 @@
-export {default as IPLeak} from './IPLeak.js';
-export {default as IPWhois} from './IPWhois.js';