social media network

English

_ga_CEP9QLJYWD

_gcl_au

csrftoken

The domain name 'pinp.disqus.com' uses the commercial generic top-level domain (.com); it also runs on subdomain 'pinp'. The second-level label 'disqus' is 6 characters long containing two vowels alongside four consonants. Splitting it apart reveals 4 words: d, is, qu, s. Median word length comes out to 1.5 characters. No strong language cues emerged from the frequency lists.

csrfmiddlewaretoken

username

password

html/55/ef/55ef40dd-01fb-4531-81a4-597916a09df1.html.gz

script-src 'none'; form-action 'none'; frame-src 'none'; report-uri https://csp.withgoogle.com/csp/scaffolding/ascnsrsggc:112:0

c849cdeb7d018cb881cb0d8317158780cf57522b098a4dd6e1698b39db2a42d9

b1388948feedf6e1e425c3dbcae50348d07c400ca3c00ddc2f50fcde374ba11e

5649807295e7ae6c56c55cf90f0ef2f7e6f50228b168b00c7902aaa6a6dd66d7

a921868893c5619a021cf80397548d8e4410c55408436fb760ef3fa251ace0cd

0ce1a2c09ca86a263ec13575dca5a867858827803edb2947725cd685f2055805

334555c22851b3a4f2e0dc7be3038ad664270da2594615d6288484976f88f978

8b7fcc8b3a84c01020b7d121fbe127b51572fc951b1b171c8fb4d06224859959

95b67acb7136cbdd79cbf7ab72d53b49e64d818cf9b7d8865c76606e3797742c

765a079971e8fd6e057b5d63a41d9e7d02e0ea490c2a5c36b8bb3afd82b7a9d8

9a9b19e93f5b2ff859bffad2d1fe88cb8e18371159dc11a7902769b50b926559

83d26f56685f68a19281f4c8ed8a60e8af4eb2915a3763d36394d4a0c433ad81

41d7f2f555a81e83b22768a96c0c465893c928c7ecf8543ea1cfc542fff43570

2a9663df41b6530d92055ac09e35295a2f3a38962ec8ae5ef539ecaaecf40e6e

f5627ea74eac809576ae16667ed7522b8dff46df48c38d9452dbe2eb208d2eef

Versions of jquery prior to 1.9.0 are vulnerable to Cross-Site Scripting. The load method fails to recognize and remove "<script>" HTML tags that contain a whitespace character, i.e: "</script >", which results in the enclosed script logic to be executed. This allows attackers to execute arbitrary JavaScript in a victim's browser.


## Recommendation

Upgrade to version 1.9.0 or later.

jQuery 1.x and 2.x are End-of-Life and no longer receiving security updates

jQuery before 3.4.0, as used in Drupal, Backdrop CMS, and other products, mishandles jQuery.extend(true, {}, ...) because of Object.prototype pollution

passing HTML containing <option> elements from untrusted sources - even after sanitizing it - to one of jQuery's DOM manipulation methods (i.e. .html(), .append(), and others) may execute untrusted code.

Regex in its jQuery.htmlPrefilter sometimes may introduce XSS

19d5335c3c1708ca603def5a46b6efc7c88fa7a37539f4aca3c5f7249532a413

fd272a2b28c77e6c6d4521ae06ccfba9ee96ec48fefb4ceab15f0ab25a8dec5e

1e5a442f8454245a9ec92f4fd0c6bf851a011bea07f982160dc0c36846dabdd7

9aa6b840d441302d3518aa13857c608e2ccc7cb488040126fba1c8d15f1008b1

557fbc5cbc2876cf63b4f48343a09070cbe0db483f13a759477d36a747bf1daf

18c9db1b52459f530986198aab0fb36b72faebf4d84c09b5a1896419906775c9

c2230239c7907e3c9f6f6417f903fbd5734f84c555943bbcc3abd974985108fc

72ae2ac8bc5832c67b7215f8070fd6d5b896ce64259d0892d11fb3692b6c8a7e

5c7c99c3b9470e7849d9383b4e711be6578d33b7271b4c7206b355be974f5352

55fb00b2f28ef206f983a65a05e54da4b823fcf21ed816b82cded5349963e1f8

1713cc28a121a2f6f897067b0b1f54b4bebe1847122e305fa4557d9f1d3c81b4

67e2afec0165e2b716875617145b6d9ade4a5a1f28760228fb9ceeacc9c25348

02487ac34920f7a8b237909f0c330d783bceab5503ae091c276e7c021e8d48a2

d53a29bf760442e1b5581dcd18abb3db747dae7a4a82ed63869b2b9a364be4f3

75e384ab2e4b5997cd1d5ebcf49204acab1c6119bd6d170c1c07962e79c1dad5

b19ad603876f56c229845ae4e7d26932063c5cc4343ad9cd2460c8e74d5a1384

Disqus, disqus.com, comments, blog, blogs, discussion

keywords

google

Disqus is a global comment system that improves discussion on websites and connects conversations across the web.

description

viewport

apple-mobile-web-app-capable

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

html/55/ef/55ef40dd-01fb-4531-81a4-597916a09df1_nodriver.html.gz

Log In | Disqus

GoDaddy.com, LLC

DISQUS.COM

Abuse

Google LLC

GOOGLE


//
// shared/foundation.js
//
// This file contains the absolute minimum code necessary in order
// to create a new application in the DISQUS namespace.
//
// You should load this file *before* anything that modifies the DISQUS global.
//

/*jshint browser:true, undef:true, strict:true, expr:true, white:true */
/*global DISQUS:true */

var DISQUS = (function (window, undefined) {
    "use strict";

    var DISQUS = window.DISQUS || {};

    // Exception thrown from DISQUS.assert method on failure
    DISQUS.AssertionError = function (message) {
        this.message = message;
    };

    DISQUS.AssertionError.prototype.toString = function () {
        return 'Assertion Error: ' + (this.message || '[no message]');
    };


    // Raises a DISQUS.AssertionError if value is falsy
    DISQUS.assert = function (value, message, soft) {
        if (value)
            return;

        if (soft)
            window.console && window.console.log("DISQUS assertion failed: " + message);
        else
            throw new DISQUS.AssertionError(message);
    };


    // Functions to clean attached modules (used by define and cleanup)
    var cleanFuncs = [];

    // Attaches a new public interface (module) to the DISQUS namespace.
    // For example, if DISQUS object is { 'a': { 'b': {} } }:
    //
    //   DISQUS.define('a.b.c', function () { return { 'd': 'hello' }; }); will transform it into
    //     -> { 'a': { 'b': { 'c': { 'd' : hello' }}}}
    //
    //   and DISQUS.define('a', function () { return { 'x': 'world' }; }); will transform it into
    //     -> { 'a': { 'b': {}}, 'x': 'world' }
    //
    // Attach modules to DISQUS using only this function.

    DISQUS.define = function (name, fn) {
        /*jshint loopfunc:true */
        if (typeof name === 'function') {
            fn = name;
            name = '';
        }

        var parts = name.split('.');
        var part  = parts.shift();
        var cur   = DISQUS;

        var exports = (fn || function () { return {}; }).call({
            overwrites: function (obj) {
                obj.__overwrites__ = true;
                return obj;
            }
        }, window);

        while (part) {
            cur = (cur[part] ? cur[part] : cur[part] = {});
            part = parts.shift();
        }

        for (var key in exports) {
            if (!exports.hasOwnProperty(key))
                continue;

            /*jshint eqnull:true */
            if (!exports.__overwrites__ && cur[key] !== null) {
                DISQUS.assert(!cur.hasOwnProperty(key),
                              'Unsafe attempt to redefine existing module: ' + key,
                              true /* soft assertion */);
            }

            cur[key] = exports[key];
            cleanFuncs.push(function (cur, key) {
                return function () { delete cur[key]; };
            }(cur, key));
        }
        return cur;
    };


    // Alias for DISQUS.define for the sake of semantics.
    // You should use it when you need to get a reference to another
    // DISQUS module before that module is defined:
    //
    //   var collections = DISQUS.use('lounge.collections');
    //
    // DISQUS.use is a single argument function because we don't
    // want to encourage people to use it instead of DISQUS.define.

    DISQUS.use = function (name) {
        return DISQUS.define(name);
    };

    DISQUS.cleanup = function () {
        for (var i = 0; i < cleanFuncs.length; i++) {
            cleanFuncs[i]();
        }
    };

    return DISQUS;
})(window);

/*jshint expr:true, undef:true, strict:true, white:true, browser:true */
/*global DISQUS:false*/
//
// shared/corefuncs.js
//

DISQUS.define(function (window, undefined) {
    "use strict";

    var DISQUS     = window.DISQUS;
    var document   = window.document;
    var head       = document.getElementsByTagName('head')[0] ||
                     document.body;
    var jobs       = { running: false, timer: null, queue: [] };
    var uid        = 0;

    // Taken from _.uniqueId
    DISQUS.getUid = function (prefix) {
        var id = ++uid + '';
        return prefix ? prefix + id : id;
    };

    /* Defers func() execution until cond() is true */
    DISQUS.defer = function (cond, func) {
        function beat() {
            /*jshint boss:true */
            var queue = jobs.queue;

            if (queue.length === 0) {
                jobs.running = false;
                clearInterval(jobs.timer);
            }

            for (var i = 0, pair; pair = queue[i]; i++) {
                if (pair[0]()) {
                    queue.splice(i--, 1);
                    pair[1]();
                }
            }
        }

        jobs.queue.push([cond, func]);
        beat();

        if (!jobs.running) {
            jobs.running = true;
            jobs.timer = setInterval(beat, 100);
        }
    };

    DISQUS.isOwn = function (obj, key) {
        // The object.hasOwnProperty method fails when the
        // property under consideration is named 'hasOwnProperty'.
        return Object.prototype.hasOwnProperty.call(obj, key);
    };

    DISQUS.isString = function (str) {
        return Object.prototype.toString.call(str) === "[object String]";
    };

    /*
     * Iterates over an object or a collection and calls a callback
     * function with each item as a parameter.
     */
    DISQUS.each = function (collection, callback) {
        var length = collection.length,
            forEach = Array.prototype.forEach;

        if (!isNaN(length)) {
            // Treat collection as an array
            if (forEach) {
                forEach.call(collection, callback);
            } else {
                for (var i = 0; i < length; i++) {
                    callback(collection[i], i, collection);
                }
            }
        } else {
            // Treat collection as an object
            for (var key in collection) {
                if (DISQUS.isOwn(collection, key)) {
                    callback(collection[key], key, collection);
                }
            }
        }
    };

    // Borrowed from underscore
    DISQUS.extend = function (obj) {
        DISQUS.each(Array.prototype.slice.call(arguments, 1), function (source) {
            for (var prop in source) {
                obj[prop] = source[prop];
            }
        });
        return obj;
    };

    DISQUS.serializeArgs = function (params) {
        var pcs = [];
        DISQUS.each(params, function (val, key) {
            if (val !== undefined) {
                pcs.push(key + (val !== null ? '=' + encodeURIComponent(val) : ''));
            }
        });
        return pcs.join('&');
    };

    DISQUS.serialize = function (url, params, nocache) {
        if (params) {
            url += (~url.indexOf('?') ?
                        (url.charAt(url.length - 1) == '&' ? '': '&') : '?');
            url += DISQUS.serializeArgs(params);
        }

        if (nocache) {
            var ncp = {};
            ncp[(new Date()).getTime()] = null;
            return DISQUS.serialize(url, ncp);
        }

        var len = url.length;
        return (url.charAt(len - 1) == "&" ? url.slice(0, len - 1) : url);
    };

    var TIMEOUT_DURATION = 2e4; // 20 seconds
    var addEvent, removeEvent;

    // select the correct event listener function. all of our supported
    // browsers will use one of these
    if ('addEventListener' in window) {
        addEvent = function (node, event, handler) {
            node.addEventListener(event, handler, false);
        };
        removeEvent = function (node, event, handler) {
            node.removeEventListener(event, handler, false);
        };
    }
    else {
        addEvent = function (node, event, handler) {
            node.attachEvent('on' + event, handler);
        };
        removeEvent = function (node, event, handler) {
            node.detachEvent('on' + event, handler);
        };
    }

    DISQUS.require = function (url, params, nocache, success, failure) {
        var script = document.createElement('script');
        var evName = script.addEventListener ? 'load' : 'readystatechange';
        var timeout = null;

        script.src = DISQUS.serialize(url, params, nocache);
        script.async = true;
        script.charset = 'UTF-8';

        function handler(ev) {
            ev = ev || window.event;
            if (!ev.target) {
                ev.target = ev.srcElement;
            }

            if (ev.type != 'load' && !/^(complete|loaded)$/.test(ev.target.readyState)) {
                return; // Not ready yet
            }

            if (success) {
                success();
            }

            if (timeout) {
                clearTimeout(timeout);
            }

            removeEvent(ev.target, evName, handler);
        }

        if (success || failure) {
            addEvent(script, evName, handler);
        }

        if (failure) {
            timeout = setTimeout(function () {
                failure();
            }, TIMEOUT_DURATION);
        }

        head.appendChild(script);
        return DISQUS;
    };

    DISQUS.requireStylesheet = function (url, params, nocache) {
        var link = document.createElement('link');
        link.rel = 'stylesheet';
        link.type = 'text/css';
        link.href = DISQUS.serialize(url, params, nocache);
        head.appendChild(link);
        return DISQUS;
    };

    DISQUS.requireSet = function (urls, nocache, callback) {
        var remaining = urls.length;
        DISQUS.each(urls, function (url) {
            DISQUS.require(url, {}, nocache, function () {
                if (--remaining === 0) { callback(); }
            });
        });
    };

    DISQUS.injectCss = function (css) {
        var style = document.createElement('style');
        style.setAttribute('type', 'text/css');

        // Make inline CSS more readable by splitting each rule onto a separate line
        css = css.replace(/\}/g, "}\n");

        if (window.location.href.match(/^https/))
            css = css.replace(/http:\/\//g, 'https://');

        if (style.styleSheet) { // Internet Explorer only
            style.styleSheet.cssText = css;
        } else {
            style.appendChild(document.createTextNode(css));
        }

        head.appendChild(style);
    };

    DISQUS.isString = function (val) {
        return Object.prototype.toString.call(val) === '[object String]';
    };
});

/*jshint boss:true*/
/*global DISQUS */
DISQUS.define('Events', function (window, undefined) {
    "use strict";

    // Returns a function that will be executed at most one time, no matter how
    // often you call it. Useful for lazy initialization.
    var once = function (func) {
        var ran = false, memo;
        return function () {
            if (ran) return memo;
            ran = true;
            memo = func.apply(this, arguments);
            func = null;
            return memo;
        };
    };
    var has = DISQUS.isOwn;
    var keys = Object.keys || function (obj) {
        if (obj !== Object(obj)) throw new TypeError('Invalid object');
        var keys = [];
        for (var key in obj) if (has(obj, key)) keys[keys.length] = key;
        return keys;
    };
    var slice = [].slice;

    // Backbone.Events
    // ---------------

    // A module that can be mixed in to *any object* in order to provide it with
    // custom events. You may bind with `on` or remove with `off` callback
    // functions to an event; `trigger`-ing an event fires all callbacks in
    // succession.
    //
    // var object = {};
    // _.extend(object, Backbone.Events);
    // object.on('expand', function(){ alert('expanded'); });
    // object.trigger('expand');
    //
    var Events = {

        // Bind an event to a `callback` function. Passing `"all"` will bind
        // the callback to all events fired.
        on: function (name, callback, context) {
            if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
            this._events = this._events || {};
            var events = this._events[name] || (this._events[name] = []);
            events.push({callback: callback, context: context, ctx: context || this});
            return this;
        },

        // Bind an event to only be triggered a single time. After the first time
        // the callback is invoked, it will be removed.
        once: function (name, callback, context) {
            if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
            var self = this;
            var onced = once(function () {
                self.off(name, onced);
                callback.apply(this, arguments);
            });
            onced._callback = callback;
            return this.on(name, onced, context);
        },

        // Remove one or many callbacks. If `context` is null, removes all
        // callbacks with that function. If `callback` is null, removes all
        // callbacks for the event. If `name` is null, removes all bound
        // callbacks for all events.
        off: function (name, callback, context) {
            var retain, ev, events, names, i, l, j, k;
            if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
            if (!name && !callback && !context) {
                this._events = {};
                return this;
            }

            names = name ? [name] : keys(this._events);
            for (i = 0, l = names.length; i < l; i++) {
                name = names[i];
                if (events = this._events[name]) {
                    this._events[name] = retain = [];
                    if (callback || context) {
                        for (j = 0, k = events.length; j < k; j++) {
                            ev = events[j];
                            if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
                                (context && context !== ev.context)) {
                                retain.push(ev);
                            }
                        }
                    }
                    if (!retain.length) delete this._events[name];
                }
            }

            return this;
        },

        // Trigger one or many events, firing all bound callbacks. Callbacks are
        // passed the same arguments as `trigger` is, apart from the event name
        // (unless you're listening on `"all"`, which will cause your callback to
        // receive the true name of the event as the first argument).
        trigger: function (name) {
            if (!this._events) return this;
            var args = slice.call(arguments, 1);
            if (!eventsApi(this, 'trigger', name, args)) return this;
            var events = this._events[name];
            var allEvents = this._events.all;
            if (events) triggerEvents(events, args);
            if (allEvents) triggerEvents(allEvents, arguments);
            return this;
        },

        // Tell this object to stop listening to either specific events ... or
        // to every object it's currently listening to.
        stopListening: function (obj, name, callback) {
            var listeners = this._listeners;
            if (!listeners) return this;
            var deleteListener = !name && !callback;
            if (typeof name === 'object') callback = this;
            if (obj) (listeners = {})[obj._listenerId] = obj;
            for (var id in listeners) {
                listeners[id].off(name, callback, this);
                if (deleteListener) delete this._listeners[id];
            }
            return this;
        }

    };

    // Regular expression used to split event strings.
    var eventSplitter = /\s+/;

    // Implement fancy features of the Events API such as multiple event
    // names `"change blur"` and jQuery-style event maps `{change: action}`
    // in terms of the existing API.
    var eventsApi = function (obj, action, name, rest) {
        if (!name) return true;

        // Handle event maps.
        if (typeof name === 'object') {
            for (var key in name) {
                obj[action].apply(obj, [key, name[key]].concat(rest));
            }
            return false;
        }

        // Handle space separated event names.
        if (eventSplitter.test(name)) {
            var names = name.split(eventSplitter);
            for (var i = 0, l = names.length; i < l; i++) {
                obj[action].apply(obj, [names[i]].concat(rest));
            }
            return false;
        }

        return true;
    };

    // A difficult-to-believe, but optimized internal dispatch function for
    // triggering events. Tries to keep the usual cases speedy (most internal
    // Backbone events have 3 arguments).
    var triggerEvents = function (events, args) {
        var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
        switch (args.length) {
        case 0:
            while (++i < l) {
                (ev = events[i]).callback.call(ev.ctx);
            }
            return;
        case 1:
            while (++i < l) {
                (ev = events[i]).callback.call(ev.ctx, a1);
            }
            return;
        case 2:
            while (++i < l) {
                (ev = events[i]).callback.call(ev.ctx, a1, a2);
            }
            return;
        case 3:
            while (++i < l) {
                (ev = events[i]).callback.call(ev.ctx, a1, a2, a3);
            }
            return;
        default:
            while (++i < l) {
                (ev = events[i]).callback.apply(ev.ctx, args);
            }
        }
    };

    var listenMethods = {listenTo: 'on', listenToOnce: 'once'};

    // Inversion-of-control versions of `on` and `once`. Tell *this* object to
    // listen to an event in another object ... keeping track of what it's
    // listening to.
    DISQUS.each(listenMethods, function (implementation, method) {
        Events[method] = function (obj, name, callback) {
            var listeners = this._listeners || (this._listeners = {});
            var id = obj._listenerId || (obj._listenerId = DISQUS.getUid('l'));
            listeners[id] = obj;
            if (typeof name === 'object') callback = this;
            obj[implementation](name, callback, this);
            return this;
        };
    });

    // Aliases for backwards compatibility.
    Events.bind = Events.on;
    Events.unbind = Events.off;

    return Events;
});
 // used for /follow/ /login/ /signup/ social oauth dialogs
// faking the bus
DISQUS.use('Bus');
_.extend(DISQUS.Bus, DISQUS.Events);



    if (window.AB_TESTS === undefined) {
        var AB_TESTS = {};
    }



    // Global tests
    $(document).ready(function() {
        $('a[rel*=facebox]').facebox();
    });




<% var has_custom_avatar = data.avatar_url && data.avatar_url.indexOf('noavatar') < 0; %>
<% var has_custom_username = data.username && data.username.indexOf('disqus_') < 0; %>
<% if (data.username) { %>
    <% if (data.has_forums) { %>
        <li class="admin<% if (has_custom_avatar || !has_custom_username) { %> avatar-menu-admin<% } %>" data-analytics="header admin"><a href="<%= data.urlMap.admin %>"><strong>Admin</strong></a></li>
    <% } %>
    <li class="user-dropdown dropdown-toggle<% if (has_custom_avatar || !has_custom_username) { %> avatar-menu<% } else { %> username-menu<% } %>" data-analytics="header username dropdown" data-floater-marker="<% if (has_custom_avatar || !has_custom_username) { %>square<% } %>">
        <a href="<%= data.urlMap.home %>/<%= data.username %>/">
            <% if (has_custom_avatar) { %>
                <img src="<%= data.avatar_url %>" class="avatar">
            <% } else if (has_custom_username) { %>
                <%= data.username %>
            <% } else { %>
                <img src="<%= data.avatar_url %>" class="avatar">
            <% } %>
            <span class="caret"></span>
        </a>
        <ul class="clearfix dropdown">
            <li data-analytics="header view profile"><a href="<%= data.urlMap.home %>/<%= data.username %>/">View Profile</a></li>
            <li class="js-edit-profile" data-analytics="header edit profile"><a href="<%= data.urlMap.home_settings_profile %>">Edit Profile</a></li>
            <li class="logout" data-analytics="header logout"><a href="<%= data.urlMap.logout %>">Logout</a></li>
        </ul>
    </li>
<% } else { %>
    <li class="link-login" data-analytics="header login"><a href="<%= data.urlMap.login %>?next=<%= encodeURIComponent(document.location.href) %>">Log in</a></li>
<% } %>





            // Global tests
            $(document).ready(function() {
                $('a[rel*=facebox]').facebox();
            });
        

(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
        j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
        'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
        })(window,document,'script','dataLayer','GTM-MRHN8JCT');


    var jesterObj = {
        product: 'dotcom',
        zone: 'login',
    };
    
    
    window.DISQUS.jester.pv(jesterObj);



DISQUS.define('web.urls', function () {
    return {
        twitter: 'https://disqus.com/_ax/twitter/begin/?ctkn=kOXzvP1J7DkzC4vH3RH8liueTDiVeeis&amp;',
        google: 'https://disqus.com/_ax/google/begin/?ctkn=kOXzvP1J7DkzC4vH3RH8liueTDiVeeis&amp;',
        facebook: 'https://disqus.com/_ax/facebook/begin/?ctkn=kOXzvP1J7DkzC4vH3RH8liueTDiVeeis&amp;',
        microsoft: 'https://disqus.com/_ax/microsoft/begin/?ctkn=kOXzvP1J7DkzC4vH3RH8liueTDiVeeis&amp;',
        apple: 'https://disqus.com/_ax/apple/begin/?ctkn=kOXzvP1J7DkzC4vH3RH8liueTDiVeeis&amp;',
        dashboard: 'http://disqus.com/dashboard/'
    }
});

$(document).ready(function () {
    $("form").submit(function () {
        $(this).find('.button.submit')
               .attr('disabled', 'disabled')
               .addClass('submitted');
        $(this).find('#password-input')
               .attr('readonly', 'readonly');
        $(this).find('#username-input')
               .attr('readonly', 'readonly');
    });
});



        
        data-profile-username="${username}" data-profile-hash="${emailHash}" href="/${username}"
        
    


  DISQUS.ui.config({
    disqusUrl: 'https://disqus.com',
    mediaUrl: '//a.disquscdn.com/1763052994/'
  });


Requests	IP Address	Location	AS Autonomous System
7	146.75.120.134	Frankfurt am Main, Hesse, Germany	AS54113FASTLY
4	146.75.122.49	Frankfurt am Main, Hesse, Germany	AS54113FASTLY
4	157.240.0.6	Frankfurt am Main, Hesse, Germany	AS32934FACEBOOK
4	216.58.212.132	United States	AS15169GOOGLE
4	3.171.214.73	Germany	Unknown
4	151.101.128.134	United States	AS54113FASTLY
4	142.250.184.227	Germany	Unknown
4	142.250.185.168	United States	AS15169GOOGLE
35	8	-	-

Security Scan Report: pinp.disqus.com

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies8

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History