Token sicher zwischen Funktionen übergeben

Question

Ich suche nach einem Weg, dass ein Stück Code (A) eine Art Token generieren kann, und dann an ein anderes Stück Code (B) so weitergeben, dass ein 3. Stück Code ist nicht in der Lage, es abzufangen (E).

Für die Zwecke dieser Frage wird vorausgesetzt, dass A das Token sicher generieren kann.

Wenn B eine Funktion F zu A verfügbar macht, die als eines der Argumente ein Objekt akzeptiert, das das Token enthält, dann kann A dieses Token direkt übergeben.

Aber E kann dieses Token finden, indem es zum Beispiel console.log überschreibt und den Stapel untersucht.

var x = console.log 
console.log = function Eve() 
{ 
    x.apply(this, arguments); 
    console.info(Thing.caller.arguments); 
} 

(unter der Annahme, dass F console.log natürlich ruft, aber in Wirklichkeit gibt es viele solche Funktionen, die auf diese Weise überschrieben werden könnte)

Ich glaube, ich habe eine Milderung gegen diese

, die die löschen ist sichere Token vom übergebenen Objekt, bevor potenziell kompromittierte Funktionen aufgerufen werden. d.h.

var y = function Y(Secure) 
{ 
    var Thing = Secure.Arg; 
    delete Secure.Arg; 
    console.log('SomeMessage', arguments) ; 
} 
y({Arg:'SomeArg'}) 

(FF in zumindest) die Manipulation des Objekts Argument sein Wert auch auf dem Stapel verändert, so dass die arguments Objekt auf dem Stapel nun ein leeres Objekt enthält. Gibt es andere Möglichkeiten, dass E Zugriff auf die übergebenen Daten erhält? Wenn ja, können diese Methoden gemildert werden oder sollte ich andere Optionen mit besserer Sicherheit untersuchen?

EDIT für Clarity: Es wird angenommen, dass E durch Mittel außerhalb der Kontrolle von A oder B - z.B. Greasemonkey Benutzerscript

Answer 1

können Sie einen Lauf einmal Getter und Verschluss verwenden, um private Daten vom Stapel zu halten:

function A(secret){ 
    return function(){ 
     var s=secret; 
     secret=null; 
     return s; 
    }; 
} 

function B(fn){ 
    var v=fn(); 
    console.log(fn); 
    alert("In B(): " + v); 
} 

var x=A(123); //give secret number to A, getting back a function 
alert(x); // no secret here 

B(x); // extract the secret by executing a one-time getter 
alert(x); // no secret here 

alert(x()); // still no secret, it's used-up 

seit JS referenzbasierte Sicherheit verwendet, das Entfernen der Schiedsrichter Sicherheit bietet.

Beachten Sie auch, dass Sie Breakpoints setzen können, um Argumente Werte zu erhalten, aber Sie können try/catch, console.log() oder einen anderen User-Land-Trick nicht verwenden, um die 123 zwischen A und B wiederherzustellen Code oben.

Sie müssen die Funktion ausführen, um den Wert abzurufen, und die Ausführung der Funktion zerstört den Wert.

Das Problem mit Objekteigenschaften, wie der OP-Code verwendet, ist, dass der geheime Wert auf dem Objekt sichtbar ist, wenn eine Ausnahme auftritt, während eine Schließung ihr Geheimnis behalten würde.

Answer 2

Es ist bereits ein Nachteil, wenn Sie eine Bibliothek eines Drittanbieters verwenden, die Ihren eigenen Code für schlechte Zwecke überschreiben könnte. Also ist die beste Lösung, eine andere vertrauenswürdige zu verwenden.

Wenn Sie noch interessiert sind, in den Token aus diesen Bibliotheken zu schützen, können Sie unwritable Funktionen mit Object.defineProperty definieren.

var obj = {}; 
Object.defineProperty(obj,'unwritableMethod',{ 
    value: function(token){ 
     //do stuff with this token 
    }, 
    writable: false 
}); 
var x = obj.unwritableMethod; 
var maliciousMethod = function Eve() 
{ 
    x.apply(this, arguments); 
    console.info(Thing.caller.arguments); 
}; 
// This will be silently ignored. 
obj.unwritableMethod = maliciousMethod; 
//you can test the result with this 
console.log(obj.unwritableMethod === maliciousMethod); //false