Comment Facebook désactiver le navigateur intégré d'Outils de développement?

Je trouve le Facebook de la console de buster script à l'aide de Chrome developer tools. Voici le script avec des changements mineurs pour des raisons de lisibilité. J'ai supprimé les bits que je ne pouvais pas comprendre:

Object.defineProperty(window, "console", {
    value: console,
    writable: false,
    configurable: false
});

var i = 0;
function showWarningAndThrow() {
    if (!i) {
        setTimeout(function () {
            console.log("%cWarning message", "font: 2em sans-serif; color: yellow; background-color: red;");
        }, 1);
        i = 1;
    }
    throw "Console is disabled";
}

var l, n = {
        set: function (o) {
            l = o;
        },
        get: function () {
            showWarningAndThrow();
            return l;
        }
    };
Object.defineProperty(console, "_commandLineAPI", n);
Object.defineProperty(console, "__commandLineAPI", n);

Avec cela, la console automatique échoue silencieusement tandis que les états tapé dans la console d'échec de l'exécution (à l'exception sera connecté).

Références:

• Objet.defineProperty
• Objet.getOwnPropertyDescriptor
• Chrome de la console.la fonction log (pour des conseils sur la mise en forme de la sortie)

En plus de redéfinir console._commandLineAPI,
il ya d'autres façons de percer dans InjectedScriptHost sur les navigateurs WebKit, afin de prévenir ou de modifier l'évaluation d'expressions conclu par le développeur de la console.

Edit:

Chrome a fixé ce, dans un communiqué. - qui doit avoir eu lieu avant février 2015, que j'ai créé l'essentiel à l'époque

Voici donc une autre possibilité. Cette fois, nous avons crochet, un niveau au-dessus, directement dans InjectedScript plutôt que InjectedScriptHost contrairement à la version précédente.

Qui est une sorte de gentil, comme vous pouvez directement monkey patch InjectedScript._evaluateAndWrap au lieu d'avoir à compter sur InjectedScriptHost.evaluate comme qui vous donne un contrôle plus fin sur ce qui doit arriver.

Un autre très intéressant, c'est que l'on peut intercepter le résultat interne lorsqu'une expression est évaluée et retour que à l'utilisateur au lieu d'un comportement normal.

Voici le code qui fait exactement cela, retourner le résultat interne lorsque l'utilisateur évalue quelque chose dans la console.

var is;
Object.defineProperty(Object.prototype,"_lastResult",{
   get:function(){
       return this._lR;
   },
   set:function(v){
       if (typeof this._commandLineAPIImpl=="object") is=this;
       this._lR=v;
   }
});
setTimeout(function(){
   var ev=is._evaluateAndWrap;
   is._evaluateAndWrap=function(){
       var res=ev.apply(is,arguments);
       console.log();
       if (arguments[2]==="completion") {
           //This is the path you end up when a user types in the console and autocompletion get's evaluated

           //Chrome expects a wrapped result to be returned from evaluateAndWrap.
           //You can use `ev` to generate an object yourself.
           //In case of the autocompletion chrome exptects an wrapped object with the properties that can be autocompleted. e.g.;
           //{iGetAutoCompleted: true}
           //You would then go and return that object wrapped, like
           //return ev.call (is, '', '({test:true})', 'completion', true, false, true);
           //Would make `test` pop up for every autocompletion.
           //Note that syntax as well as every Object.prototype property get's added to that list later,
           //so you won't be able to exclude things like `while` from the autocompletion list,
           //unless you wou'd find a way to rewrite the getCompletions function.
           //
           return res; //Return the autocompletion result. If you want to break that, return nothing or an empty object
       } else {
           //This is the path where you end up when a user actually presses enter to evaluate an expression.
           //In order to return anything as normal evaluation output, you have to return a wrapped object.

           //In this case, we want to return the generated remote object. 
           //Since this is already a wrapped object it would be converted if we directly return it. Hence,
           //`return result` would actually replicate the very normal behaviour as the result is converted.
           //to output what's actually in the remote object, we have to stringify it and `evaluateAndWrap` that object again.`
           //This is quite interesting;
           return ev.call (is, null, '(' + JSON.stringify (res) + ')', "console", true, false, true)
       }
   };
},0);

C'est un peu verbeux, mais j'ai pensé que j'ai mis quelques commentaires dans il

Donc, normalement, si un utilisateur, par exemple, évalue [1,2,3,4] que vous attendez la sortie suivante:

Après monkeypatching InjectedScript._evaluateAndWrap l'évaluation de la même expression, donne le résultat suivant:

Comme vous le voyez la petite flèche vers la gauche, indiquant la sortie, il est toujours là, mais cette fois nous obtenons un objet. Lorsque le résultat de l'expression, le tableau [1,2,3,4] est représentée comme un objet avec toutes ses propriétés décrites.

Je vous recommande d'essayer de l'évaluer et d'expression, y compris ceux qui génèrent des erreurs. C'est assez intéressant.

En outre, prendre un coup d'oeil à la is - InjectedScriptHost - objet. Il fournit des méthodes pour jouer avec et d'obtenir un peu d'un aperçu de l'intérieur de l'inspecteur.

Bien sûr, vous pouvez intercepter toutes les données et retourner le résultat original de l'utilisateur.

Il suffit de remplacer l'instruction de retour dans la trajectoire par une console.log (res) à la suite d'une return res. Ensuite, vous finirais par le suivant.

Fin de l'Edit

---

C'est la version précédente qui a été fixé par Google. Donc pas possible de plus.

l'Une d'elle est d'accrochage dans Function.prototype.call

Chrome évalue l'expression par calling sa fonction eval avec InjectedScriptHost comme thisArg

var result = evalFunction.call(object, expression);

Compte tenu de cela, vous pouvez écouter de la thisArg de call être evaluate et d'obtenir une référence vers le premier argument (InjectedScriptHost)

if (window.URL) {
    var ish, _call = Function.prototype.call;
    Function.prototype.call = function () { //Could be wrapped in a setter for _commandLineAPI, to redefine only when the user started typing.
        if (arguments.length > 0 && this.name === "evaluate" && arguments [0].constructor.name === "InjectedScriptHost") { //If thisArg is the evaluate function and the arg0 is the ISH
            ish = arguments[0];
            ish.evaluate = function (e) { //Redefine the evaluation behaviour
                throw new Error ('Rejected evaluation of: \n\'' + e.split ('\n').slice(1,-1).join ("\n") + '\'');
            };
            Function.prototype.call = _call; //Reset the Function.prototype.call
            return _call.apply(this, arguments);  
        }
    };
}

Vous pourriez par exemple jeter une erreur, que l'évaluation a été rejetée.

_{Voici un exemple où l'expression est passée à un CoffeeScript compilateur avant de passer à l' evaluate de la fonction.}

C'est en fait possible étant donné que Facebook a été en mesure de le faire.
Eh bien, pas le développeur web outils mais l'exécution de Javascript dans la console.

Voir ceci: Comment Facebook désactiver le navigateur intégré d'Outils de développement?

- Ce vraiment l'habitude de faire beaucoup, bien que depuis il y a d'autres façons de contourner ce type de sécurité côté client.

Quand vous dites que c'est côté client, il se passe en dehors du contrôle du serveur, donc il n'y a pas beaucoup que vous pouvez faire à ce sujet. Si vous vous demandez pourquoi Facebook n'est toujours présent, ce n'est pas vraiment pour la sécurité, mais pour protéger les utilisateurs normaux qui ne savent pas javascript d'exécuter du code (qu'ils ne savent pas lire) dans la console. C'est courant pour les sites qui promettent d'auto-liker service, ou autres Facebook fonctionnalité robots après vous faites ce qu'ils vous demandent de faire, où dans la plupart des cas, ils vous donnent une capture de javascript à exécuter dans la console.

Si vous n'avez pas autant d'utilisateurs que Facebook, alors je ne pense pas qu'il soit besoin de faire ce que Facebook est en train de faire.

Même si vous avez désactivé Javascript dans la console, en cours d'exécution javascript via la barre d'adresse est toujours possible.

et si le navigateur désactive javascript dans la barre d'adresse, (Lorsque vous collez le code dans la barre d'adresse de Google Chrome, il supprime le membre de phrase 'javascript:') coller du code javascript dans l'un des liens sur inspecter l'élément est encore possible.

Inspecter le point d'ancrage:

Coller le code dans href:

Ligne de fond est la validation côté serveur et de sécurité devrait être le premier, puis le faire côté client après.

Chrome beaucoup changé depuis le temps de facebook pourrait désactiver la console...

Comme par Mars 2017, cela ne fonctionne pas plus.

Meilleur que vous pouvez faire est de désactiver certaines fonctions de la console, par exemple:

if(!window.console) window.console = {};
var methods = ["log", "debug", "warn", "info", "dir", "dirxml", "trace", "profile"];
for(var i=0;i<methods.length;i++){
    console[methods[i]] = function(){};
}

une solution simple!

setInterval(()=>console.clear(),1500);

Ce n'est pas une mesure de sécurité pour les faibles code pour être laissé sans surveillance. Toujours obtenir une solution permanente à la faiblesse de code et la sécurisation de vos sites web correctement avant la mise en œuvre de cette stratégie

Le meilleur outil de loin à ma connaissance serait pour ajouter plusieurs fichiers javascript qui change simplement de l'intégrité de la page retour à la normale par rafraîchissante ou remplacer le contenu. La désactivation de ce développeur de l'outil ne serait pas la meilleure idée, depuis le contournement est toujours en question étant donné que le code est la partie du navigateur et non sur un serveur de rendu, donc il pourrait être fissuré.

Si vous avez js file one la vérification de <element> des modifications sur les éléments importants et js file two et js file three vérifier que ce fichier existe, par période, vous aurez le plein de l'intégrité de restauration sur la page de la période.

Permet de prendre un exemple de l'4 fichiers et de vous montrer ce que je veux dire.

index.html

   <!DOCTYPE html>
   <html>
   <head id="mainhead">
   <script src="ks.js" id="ksjs"></script>
   <script src="mainfile.js" id="mainjs"></script>
   <link rel="stylesheet" href="style.css" id="style">
   <meta id="meta1" name="description" content="Proper mitigation against script kiddies via Javascript" >
   </head>
   <body>
   <h1 id="heading" name="dontdel" value="2">Delete this from console and it will refresh. If you change the name attribute in this it will also refresh. This is mitigating an attack on attribute change via console to exploit vulnerabilities. You can even try and change the value attribute from 2 to anything you like. If This script says it is 2 it should be 2 or it will refresh. </h1>
   <h3>Deleting this wont refresh the page due to it having no integrity check on it</h3>

   <p>You can also add this type of error checking on meta tags and add one script out of the head tag to check for changes in the head tag. You can add many js files to ensure an attacker cannot delete all in the second it takes to refresh. Be creative and make this your own as your website needs it. 
   </p>

   <p>This is not the end of it since we can still enter any tag to load anything from everywhere (Dependent on headers etc) but we want to prevent the important ones like an override in meta tags that load headers. The console is designed to edit html but that could add potential html that is dangerous. You should not be able to enter any meta tags into this document unless it is as specified by the ks.js file as permissable. <br>This is not only possible with meta tags but you can do this for important tags like input and script. This is not a replacement for headers!!! Add your headers aswell and protect them with this method.</p>
   </body>
   <script src="ps.js" id="psjs"></script>
   </html>

mainfile.js

   setInterval(function() {
   //check for existence of other scripts. This part will go in all other files to check for this file aswell. 
   var ksExists = document.getElementById("ksjs"); 
   if(ksExists) {
   }else{ location.reload();};

   var psExists = document.getElementById("psjs");
   if(psExists) {
   }else{ location.reload();};

   var styleExists = document.getElementById("style");
   if(styleExists) {
   }else{ location.reload();};


   }, 1 * 1000); //1 * 1000 milsec

ps.js

   /*This script checks if mainjs exists as an element. If main js is not existent as an id in the html file reload!You can add this to all js files to ensure that your page integrity is perfect every second. If the page integrity is bad it reloads the page automatically and the process is restarted. This will blind an attacker as he has one second to disable every javascript file in your system which is impossible.

   */

   setInterval(function() {
   //check for existence of other scripts. This part will go in all other files to check for this file aswell. 
   var mainExists = document.getElementById("mainjs"); 
   if(mainExists) {
   }else{ location.reload();};

   //check that heading with id exists and name tag is dontdel.
   var headingExists = document.getElementById("heading"); 
   if(headingExists) {
   }else{ location.reload();};
   var integrityHeading = headingExists.getAttribute('name');
   if(integrityHeading == 'dontdel') {
   }else{ location.reload();};
   var integrity2Heading = headingExists.getAttribute('value');
   if(integrity2Heading == '2') {
   }else{ location.reload();};
   //check that all meta tags stay there
   var meta1Exists = document.getElementById("meta1"); 
   if(meta1Exists) {
   }else{ location.reload();};

   var headExists = document.getElementById("mainhead"); 
   if(headExists) {
   }else{ location.reload();};

   }, 1 * 1000); //1 * 1000 milsec

ks.js

   /*This script checks if mainjs exists as an element. If main js is not existent as an id in the html file reload! You can add this to all js files to ensure that your page integrity is perfect every second. If the page integrity is bad it reloads the page automatically and the process is restarted. This will blind an attacker as he has one second to disable every javascript file in your system which is impossible.

   */

   setInterval(function() {
   //check for existence of other scripts. This part will go in all other files to check for this file aswell. 
   var mainExists = document.getElementById("mainjs"); 
   if(mainExists) {
   }else{ location.reload();};
   //Check meta tag 1 for content changes. meta1 will always be 0. This you do for each meta on the page to ensure content credibility. No one will change a meta and get away with it. Addition of a meta in spot 10, say a meta after the id="meta10" should also be covered as below.
   var x = document.getElementsByTagName("meta")[0];
   var p = x.getAttribute("name");
   var s = x.getAttribute("content");
   if (p != 'description') {
   location.reload();
   }
   if ( s != 'Proper mitigation against script kiddies via Javascript') {
   location.reload();
   }
   //This will prevent a meta tag after this meta tag @ id="meta1". This prevents new meta tags from being added to your pages. This can be used for scripts or any tag you feel is needed to do integrity check on like inputs and scripts. (Yet again. It is not a replacement for headers to be added. Add your headers aswell!)
   var lastMeta = document.getElementsByTagName("meta")[1];
   if (lastMeta) {
   location.reload();
   }
   }, 1 * 1000); //1 * 1000 milsec

style.css

Maintenant, c'est juste pour montrer qu'il fonctionne sur tous les fichiers et les tags aswell

   #heading {
   background-color:red;
   }

Si vous mettez tous ces fichiers ensemble et construire l'exemple, vous verrez que la fonction de cette mesure. Cela permettra d'éviter certains imprévus injections doivent la mettre en œuvre correctement sur tous les éléments importants dans votre fichier d'index en particulier lorsque l'on travaille avec PHP.

Pourquoi j'ai choisi de le recharger au lieu de revenir à la normale de la valeur de l'attribut est le fait que certains attaquants pourraient avoir une autre partie du site est déjà configuré et prêt, et il diminue code montant. Le rechargement de retirer toutes les attaquant est un travail difficile, et il va probablement aller jouer quelque part plus facile.

Une autre remarque: Cela pourrait devenir beaucoup de code afin de le garder propre et assurez-vous d'ajouter des définitions où ils appartiennent à faire des modifications facile à l'avenir. Également définir le nombre de secondes de votre choix quantité 1 seconde d'intervalle sur les pages de grande taille pourraient avoir des effets dévastateurs sur les anciens ordinateurs de vos visiteurs pourraient être à l'aide de