social media network

English

_ga_CEP9QLJYWD

csrftoken

_gcl_au

The domain 'simply-recipes.disqus.com' uses the commercial generic top-level domain (.com) with subdomain 'simply-recipes'. The registrable portion 'disqus' spans 6 characters with two vowels and 4 consonants. Word splitting yields 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/a2/86/a286a9e4-263f-4284-9762-0feb9b9d629f.html.gz

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

a921868893c5619a021cf80397548d8e4410c55408436fb760ef3fa251ace0cd

b1388948feedf6e1e425c3dbcae50348d07c400ca3c00ddc2f50fcde374ba11e

c849cdeb7d018cb881cb0d8317158780cf57522b098a4dd6e1698b39db2a42d9

5649807295e7ae6c56c55cf90f0ef2f7e6f50228b168b00c7902aaa6a6dd66d7

334555c22851b3a4f2e0dc7be3038ad664270da2594615d6288484976f88f978

0ce1a2c09ca86a263ec13575dca5a867858827803edb2947725cd685f2055805

33cf7bbfefefe7d99930e0ef87025fa0d0d4532efc72cfefb516841b13e83601

586244f36f9f417567608421b44c9aaa155b8285c16e2c6a3ddbea8d6094230f

f5627ea74eac809576ae16667ed7522b8dff46df48c38d9452dbe2eb208d2eef

49f031613f8548e7ae85e383bc4b44da335014a88f66d3e48d085ce5cdf870cf

c6b19d6d54e189fe9166e8024c3e1c7fee679ee4396bd3873642309e00d7d8de

9735c405b4fdfabefa5d616b00add100686078d2a32073ba5b13a2a73b757e4f

c6351095fa6c3ae8444eac9a74fbf3cb92ba6ae3469480eb867b1fb2235cf6d5

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

bb1501e6b71fbceb01ba4cf53792c8d4a0a33c20014595c2fb496199d76c1a9c

fd272a2b28c77e6c6d4521ae06ccfba9ee96ec48fefb4ceab15f0ab25a8dec5e

1e5a442f8454245a9ec92f4fd0c6bf851a011bea07f982160dc0c36846dabdd7

9aa6b840d441302d3518aa13857c608e2ccc7cb488040126fba1c8d15f1008b1

557fbc5cbc2876cf63b4f48343a09070cbe0db483f13a759477d36a747bf1daf

18c9db1b52459f530986198aab0fb36b72faebf4d84c09b5a1896419906775c9

c2230239c7907e3c9f6f6417f903fbd5734f84c555943bbcc3abd974985108fc

55fb00b2f28ef206f983a65a05e54da4b823fcf21ed816b82cded5349963e1f8

1713cc28a121a2f6f897067b0b1f54b4bebe1847122e305fa4557d9f1d3c81b4

3e98f48819dcdd472393c6f285780994b912c4715ecb661de36dda2a1583b7d9

02487ac34920f7a8b237909f0c330d783bceab5503ae091c276e7c021e8d48a2

d53a29bf760442e1b5581dcd18abb3db747dae7a4a82ed63869b2b9a364be4f3

75e384ab2e4b5997cd1d5ebcf49204acab1c6119bd6d170c1c07962e79c1dad5

bff3aaddd8ba89437bdb5dfc35582a1f5c3adc13d1594561aa01cf3d9afe8782

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

GoDaddy.com, LLC

DISQUS.COM

ORG-FI26-RIPE

Fastly, Inc.

ORG-NCC1-RIPE

FASTLY


//
// 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=43wP0CRvGkCCT8f9bvkLVuwICY4xCGwv&amp;',
        google: 'https://disqus.com/_ax/google/begin/?ctkn=43wP0CRvGkCCT8f9bvkLVuwICY4xCGwv&amp;',
        facebook: 'https://disqus.com/_ax/facebook/begin/?ctkn=43wP0CRvGkCCT8f9bvkLVuwICY4xCGwv&amp;',
        microsoft: 'https://disqus.com/_ax/microsoft/begin/?ctkn=43wP0CRvGkCCT8f9bvkLVuwICY4xCGwv&amp;',
        apple: 'https://disqus.com/_ax/apple/begin/?ctkn=43wP0CRvGkCCT8f9bvkLVuwICY4xCGwv&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/1781125780/'
  });


Requests	IP Address	Location	AS Autonomous System
9	146.75.122.49	Frankfurt am Main, Hesse, Germany	AS54113Fastly, Inc.
8	146.75.120.134	Frankfurt am Main, Hesse, Germany	AS54113Fastly, Inc.
8	143.204.181.74	United States	AS16509Amazon.com, Inc.
8	151.101.0.134	United States	AS54113Fastly, Inc.
33	4	-	-

Security Scan Report: simply-recipes.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 Technologies6

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