Est-il possible d'empêcher le remplacement / l'écrasement des fonctions / variables dans l'instance singleton?

Considérer cette pseudo-code:

(function(window){
   var options = { /*where everything goes */ };

   var instance = (function(options){
       for (var i in options){
       if (options.hasOwnProperty(i)){
         this[i] = options[i];
       }
     }
   })(options);

   instance.callbacks = function(cb){
     //...
   }

   instance.is_allowed = function()
    //... checks, return boolean
   }

   window.instance = instance;
})(this);

Si jamais quelqu'un voulait manipuler ce code (un utilisateur malveillant par exemple), il serait de réécrire le is_allowed fonction avec les siens, par exemple, à l'aide de la barre d'adresse (il n'a pas firebug, qui sait).

javascript:(function(){ window.instance.is_allowed = function(){ return true; } })();

C'est un naïf exemple, mais c'est le point, rien en Javascript peut être écrasé.

Je sais que dans l'es5, nous avons l'Objet.defineProperty de sorte que vous pouvez définir:

//being explicit
Object.defineProperty(instance, "is_allowed", {
  enumerable: false,
  configurable: false,
  writable: false,
  value: function(){
    //do checks
  }    
});

En fait, ce qui est MIEUX dans ce sens est l'utilisation de Object.freeze(instance) ou Object.seal(instance) au lieu de Object.definePropertydepuis le plus tard peut être appelé à nouveau avec writable: false (bête hein?)

Est-il possible qu'il travail dans les vieux navigateurs (à savoir IE6-8) sans trop de tracas? Si c'est impossible, alors je vais simplement hausser les épaules et de passer.

source d'informationauteur pocesar | 2013-02-03

3

Si jamais quelqu'un voulait manipuler ce code (un utilisateur malveillant pour
exemple), il serait de réécrire le is_allowed fonction avec son propre

Il pourrait réécrire l'ensemble de votre code javascript ou même pas de l'utilisation d'un navigateur, mais de simuler un "navigateur" demande à votre serveur.

Est-il possible qu'il travail dans les vieux navigateurs (à savoir IE6-8) sans
trop de tracas?

Pas. Tout ce que vous exposer à l'échelle mondiale peuvent être modifiés par l'utilisateur, c'est à l'navigateurs restreindre la javascript: comportement pour éviter aux utilisateurs d'être dupe pour accéder à la pré-conçu des liens. Firefox ont récemment fait une sorte de changement de l'URL javascript protocole.

Comme l'a dit cet article: http://survey-remover.com/blog/javascript-protocol-dangers/

De Chrome v13, Firefox v6 et IE 9, le navigateur, les développeurs ont pris connaissance des dangers de la "javascript:" protocole et ont par la suite refusé de code ... Dans le cas de Chrome et IE, le "javascript:" sous-chaîne est supprimée lorsque le code est collé, alors que Firefox n'est plus exécute le script dans le champ d'application de la page active.

Donc...

Si c'est impossible, alors je vais simplement hausser les épaules et de passer.

Vous devriez.
1

Proposition

Je ne vais pas dire que je suis un expert sur ces choses. Mais en supposant que vous pouvez envelopper votre code complètement et utiliser les événements pour déclencher problème, vous pouvez utiliser une structure comme ceci:
```
Closed = function(args) { return (function() {
  "use strict";

  var secret, init, get_secret, use_secret;

  init = function(something){
    secret = something;
  };

  get_secret = function() {
    return secret;
  };

  use_secret = function () {
    console.log(secret);
  };

  /* Run constructor */
  init(args);

  /* Publish API */
  return { use_secret:use_secret };

}())};
```
D'établir obj = Closed("Anything"); vous pouvez toujours avoir un utilisateur malveillant d'écraser le use_secret() méthode, car elle est exposée, mais le get_secret() méthode, et les autres internes, sont protégés.

Si votre méthode init déclare un certain nombre de liaisons d'événements de l'application, vous pouvez garder votre état privé de cette façon. Les événements seront capables de déclencher des méthodes internes car ils sont liés à partir de l'intérieur de la chambre de fermeture, mais le code externe ne les voyons pas.

Réserves

Alors que cela pourrait résoudre votre problème, je ne suis pas sûr à 100% il ne, il ne faut pas faire confiance de toute façon. Tout utilisateur qui veut pénétrer votre application peut aussi longtemps que la sécurité est sur le côté client. Il n'y a rien pour les empêcher de l'artisanat de leur propre objet de remplacer le vôtre après le fait, de toute façon, ES5 ou pas ES5.

Pour tout ce qui doit réellement être sûr que vous aurez à revalider sur le côté serveur. Ne faites jamais confiance à côté client code pour vous protéger, la demande pourrait même ne pas venir à partir de la page vous avez servi ...

Que si is_allowed serait entièrement locale?

(function(window){
   var options = {}, is_allowed;

   var instance = (function(options){
     for (var i in options) {
     if (options.hasOwnProperty(i)) {
        this[i] = options[i];
       }
     }
     return this;
   })(options);

   instance.callbacks = function(cb){
       /* ... */
   };

   function check_allowed(){
     /* check and let this function set [is_allowed] */
   };

  window.instance = check_allowed()
                     ? instance
                     : { callbacks: function(){(alert('not allowed'));}  };

} (this) );

jsBin maquette

BTW: dans votre code, window.instance serait undefined.

Vous devez vous connecter pour publier un commentaire.

Proposition

Réserves