javascript diffie hellman - schwache random zahl

b4ck

b4ck

0
Hi,

ich arbeite gerade an einer Security-Aufgabe bei der ein "diffie hellman" key exchange über ajax stattfindet und ich mitgeschnifften Traffic entschlüsseln soll.
Laut Aufgabenstellung gibt es eine Schwachstelle bei der Zufallszahlen generierung:

Code: 
	function getRandom( min, max ) {
		if( min > max ) {
			return( -1 );
		}
		if( min == max ) {
			return( min );
		}
	 
		var randomFloat = Math.random() * ( max-min+1 );
	 
	    return( min + parseInt( randomFloat ) );
	}


        // generate random r
	randomValue = new Clipperz.ByteArray();
	for (i=0; i<16 ; i++) {
	    randomValue.appendByte(getRandom(0, 255));
	}

ich seh mir den Code seit Stunden an und seh hier keine Schwachstelle die mich den Randomwert einschränken oder vorhersehen lässt.

javascripts math.random erstelle eine random float zahl zwischen 0-1. Mit dem Code ist die range der erstelleten random-werte doch viel zu hoch um sie vorher zu sehen oder übersehe ich da etwas?
 
Zuletzt bearbeitet:
Wenn es um Zufallszahlen geht, sollte man zu erst immer den Seed für den PRNG angucken, laut [0] ist das für Math.random() die aktuelle Zeit, wenn diese im Protokoll also irgendwo mitgeschickt wird, oder du den Zeitpunkt, wann die Zufallszahl erzeugt wurde einigermaßen genau bestimmen (einschränken) kannst, solltest du in der Lage sein über Bruteforce die Zufallszahlen zu ermitteln.

[0] random - https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Math/random
 
leider habe ich keine Möglichkeit den Zeitpunkt der Übertragung zu bestimmen.
Im mit gesnifften Request finde ich leider nichts.
 
Ich hab jetzt auf die schnelle auch nichts entdeckt.
Aber wie ist die Aufgabe denn genau zu lösen? Wenn du den Übertragungszeitpunkt kennst und weißt, dass die Zahl unmittelbar davor erstellt wurde, kannst du doch zur Not einfach ein hinreichend großen Zahlenwert an Zeiten nehmen und damit Bruteforcen.
Wenn der Randomwert tatsächlich erzeugt wird und dann direkt gesendet wird, reicht es sicherlich vom mitgesnifften Zeitpunkt bis zu 1000 ms runterzugehen. Und 1000 Passwörter zu Bruteforcen geht wirklich schnell.
 
das problem ist das ich nicht weis ober mitgesniffte traffic von vor 2 wochen 3 wochen gestern oder 6 monaten ist.
 
OK, wenn du weder den Zeitpunkt des Empfangs (sniffen) kennst, noch den Zeitpunkt des Versendens kannst du den Ansatz in die Tonne treten.

Hmm getRandom(min , max) wird immer mit (0, 255) aufgerufen, damit ist min > max nie erfüllt und auch nicht min == max.
Die beiden Zeilen bedeuten
Code: 
		var randomFloat = Math.random() * ( max-min+1 );
	 
	    return( min + parseInt( randomFloat ) );
bedeuten dann immer wegen 255-0+1
Code: 
		var randomFloat = Math.random() * ( 256 );
	 
	    return( parseInt( randomFloat ) );

Ich kann ehrlich gesagt nur noch ins blaue Raten, weil ich von JS auch nicht viel Ahnung habe, daher kann es kompletter Schwachsinn:
Hat dieses ByteArray vielleicht eine Standardbelegung, sodass man es leeren muss oder noch trivialer, funktioniert die appendByte Funktion/Methode überhaupt?
 
jop das ganze funktioniert und soweit ich das sehe werden auch "echte" random wert erzeugt werden. iwie muss es möglich sein die random werte soweit einzuschränken das bruteforcing sinn macht nur WIE?!?^^
 
Also soweit ich das sehen konnte, entspricht der Code den Empfehlungen, um gleichverteilt Zufallszahlen zu erhalten. Einziger Unterschied ist, dass immer Math.floor() verwendet wird, parseInt() tut letztendlich aber exakt das Gleiche.

Gibt es vielleicht sonst noch irgendwelche Hinweise, die uns weiterhelfen könnten? Evtl ein spezielles Thema/Angriff, was vor der Aufgabenstellung besprochen wurde?

Vielleicht könnte auch so ein Mitschitt hilfreich sein.
 
Der Klassiker ist eigentlich, dass Math.random() ein double aus einer Gleichverteilung zieht, aber ein int, generiert durch parseInt(Math.random() * n), keiner Gleichverteilung folgt, falls die Anzahl der Möglichkeiten von Math.random() kein Vielfaches von n ist.

Man muss aber schon recht oft würfeln, bis man den Effekt beobachtet :)
 
Man muss aber schon recht oft würfeln, bis man den Effekt beobachtet
Zum Vergrößern anklicken....
Wenn man das als Stichwort nimmt:
Code: 
JS console
x = [];
while (x.length < 10000) { x.push(parseInt(Math.random()*(256)));}
document.write(x)
=> copy to textfile (damit man es in "richtigen" Scriptsprachen bearbeiten kann :) )
Python Konsole:
Code: 
with open('rand.txt','r') as f:
    nums = [int(elem) for elem in f.read().split(',')]

from collections import Counter

for byte, count in Counter(nums).most_common():
    print("Byte: %d, freq: %d " % (byte, count))

Code: 
Byte: 85, freq: 56
Byte: 69, freq: 54
Byte: 10, freq: 53
Byte: 43, freq: 53
Byte: 62, freq: 53
Byte: 176, freq: 53
Byte: 2, freq: 52
Byte: 28, freq: 52
Byte: 109, freq: 52
Byte: 180, freq: 52
Byte: 207, freq: 52
Byte: 253, freq: 52
Byte: 14, freq: 51
Byte: 112, freq: 51
Byte: 139, freq: 51
Byte: 194, freq: 51
Byte: 5, freq: 50
Byte: 70, freq: 50
Byte: 116, freq: 50
Byte: 230, freq: 49
Byte: 47, freq: 48
Byte: 106, freq: 48
Byte: 118, freq: 48
Byte: 201, freq: 48
Byte: 248, freq: 48
Byte: 252, freq: 48
Byte: 65, freq: 47
Byte: 181, freq: 47
Byte: 212, freq: 47
Byte: 217, freq: 47
Byte: 31, freq: 46
Byte: 55, freq: 46
Byte: 127, freq: 46
Byte: 145, freq: 46
Byte: 149, freq: 46
Byte: 191, freq: 46
Byte: 195, freq: 46
Byte: 213, freq: 46
Byte: 40, freq: 45
Byte: 50, freq: 45
Byte: 57, freq: 45
Byte: 58, freq: 45
Byte: 136, freq: 45
Byte: 153, freq: 45
Byte: 200, freq: 45
Byte: 227, freq: 45
Byte: 228, freq: 45
Byte: 3, freq: 44
Byte: 9, freq: 44
Byte: 13, freq: 44
Byte: 21, freq: 44
Byte: 27, freq: 44
Byte: 33, freq: 44
Byte: 48, freq: 44
Byte: 61, freq: 44
Byte: 74, freq: 44
Byte: 105, freq: 44
Byte: 108, freq: 44
Byte: 146, freq: 44
Byte: 152, freq: 44
Byte: 164, freq: 44
Byte: 25, freq: 43
Byte: 29, freq: 43
Byte: 36, freq: 43
Byte: 44, freq: 43
Byte: 94, freq: 43
Byte: 189, freq: 43
Byte: 196, freq: 43
Byte: 198, freq: 43
Byte: 202, freq: 43
Byte: 203, freq: 43
Byte: 204, freq: 43
Byte: 209, freq: 43
Byte: 215, freq: 43
Byte: 239, freq: 43
Byte: 35, freq: 42
Byte: 82, freq: 42
Byte: 86, freq: 42
Byte: 96, freq: 42
Byte: 131, freq: 42
Byte: 165, freq: 42
Byte: 237, freq: 42
Byte: 255, freq: 42
Byte: 11, freq: 41
Byte: 15, freq: 41
Byte: 16, freq: 41
Byte: 26, freq: 41
Byte: 95, freq: 41
Byte: 119, freq: 41
Byte: 141, freq: 41
Byte: 147, freq: 41
Byte: 148, freq: 41
Byte: 155, freq: 41
Byte: 168, freq: 41
Byte: 197, freq: 41
Byte: 223, freq: 41
Byte: 244, freq: 41
Byte: 22, freq: 40
Byte: 42, freq: 40
Byte: 52, freq: 40
Byte: 89, freq: 40
Byte: 93, freq: 40
Byte: 97, freq: 40
Byte: 128, freq: 40
Byte: 129, freq: 40
Byte: 142, freq: 40
Byte: 159, freq: 40
Byte: 172, freq: 40
Byte: 179, freq: 40
Byte: 184, freq: 40
Byte: 210, freq: 40
Byte: 211, freq: 40
Byte: 220, freq: 40
Byte: 225, freq: 40
Byte: 233, freq: 40
Byte: 233, freq: 40
Byte: 243, freq: 40
Byte: 254, freq: 40
Byte: 18, freq: 39
Byte: 34, freq: 39
Byte: 54, freq: 39
Byte: 84, freq: 39
Byte: 90, freq: 39
Byte: 113, freq: 39
Byte: 150, freq: 39
Byte: 151, freq: 39
Byte: 158, freq: 39
Byte: 161, freq: 39
Byte: 178, freq: 39
Byte: 190, freq: 39
Byte: 224, freq: 39
Byte: 236, freq: 39
Byte: 240, freq: 39
Byte: 247, freq: 39
Byte: 30, freq: 38
Byte: 41, freq: 38
Byte: 64, freq: 38
Byte: 73, freq: 38
Byte: 132, freq: 38
Byte: 134, freq: 38
Byte: 137, freq: 38
Byte: 163, freq: 38
Byte: 170, freq: 38
Byte: 199, freq: 38
Byte: 216, freq: 38
Byte: 232, freq: 38
Byte: 1, freq: 37
Byte: 8, freq: 37
Byte: 12, freq: 37
Byte: 24, freq: 37
Byte: 60, freq: 37
Byte: 67, freq: 37
Byte: 77, freq: 37
Byte: 88, freq: 37
Byte: 99, freq: 37
Byte: 101, freq: 37
Byte: 104, freq: 37
Byte: 117, freq: 37
Byte: 121, freq: 37
Byte: 123, freq: 37
Byte: 125, freq: 37
Byte: 130, freq: 37
Byte: 138, freq: 37
Byte: 143, freq: 37
Byte: 144, freq: 37
Byte: 160, freq: 37
Byte: 173, freq: 37
Byte: 206, freq: 37
Byte: 235, freq: 37
Byte: 23, freq: 36
Byte: 32, freq: 36
Byte: 38, freq: 36
Byte: 45, freq: 36
Byte: 76, freq: 36
Byte: 81, freq: 36
Byte: 103, freq: 36
Byte: 115, freq: 36
Byte: 156, freq: 36
Byte: 166, freq: 36
Byte: 182, freq: 36
Byte: 188, freq: 36
Byte: 193, freq: 36
Byte: 249, freq: 36
Byte: 17, freq: 35
Byte: 100, freq: 35
Byte: 122, freq: 35
Byte: 135, freq: 35
Byte: 205, freq: 35
Byte: 218, freq: 35
Byte: 221, freq: 35
Byte: 226, freq: 35
Byte: 229, freq: 35
Byte: 231, freq: 35
Byte: 0, freq: 34
Byte: 39, freq: 34
Byte: 49, freq: 34
Byte: 56, freq: 34
Byte: 68, freq: 34
Byte: 71, freq: 34
Byte: 75, freq: 34
Byte: 79, freq: 34
Byte: 80, freq: 34
Byte: 87, freq: 34
Byte: 92, freq: 34
Byte: 111, freq: 34
Byte: 133, freq: 34
Byte: 154, freq: 34
Byte: 171, freq: 34
Byte: 174, freq: 34
Byte: 175, freq: 34
Byte: 251, freq: 34
Byte: 4, freq: 33
Byte: 51, freq: 33
Byte: 59, freq: 33
Byte: 107, freq: 33
Byte: 126, freq: 33
Byte: 140, freq: 33
Byte: 185, freq: 33
Byte: 192, freq: 33
Byte: 208, freq: 33
Byte: 214, freq: 33
Byte: 7, freq: 32
Byte: 114, freq: 32
Byte: 162, freq: 32
Byte: 167, freq: 32
Byte: 78, freq: 31
Byte: 102, freq: 31
Byte: 110, freq: 31
Byte: 186, freq: 31
Byte: 187, freq: 31
Byte: 234, freq: 31
Byte: 238, freq: 31
Byte: 241, freq: 31
Byte: 246, freq: 31
Byte: 19, freq: 30
Byte: 20, freq: 30
Byte: 91, freq: 30
Byte: 157, freq: 30
Byte: 242, freq: 30
Byte: 250, freq: 30
Byte: 63, freq: 29
Byte: 72, freq: 29
Byte: 124, freq: 29
Byte: 219, freq: 29
Byte: 6, freq: 28
Byte: 46, freq: 28
Byte: 53, freq: 28
Byte: 66, freq: 28
Byte: 83, freq: 28
Byte: 120, freq: 28
Byte: 169, freq: 28
Byte: 177, freq: 28
Byte: 222, freq: 28
Byte: 245, freq: 27
Byte: 98, freq: 26
Byte: 183, freq: 26
Byte: 37, freq: 25
 
Ich glaube, du misst da eigentlich etwas anderes. Kurzer Vergleich:

python -c "from random import *; print(','.join(map(lambda x: str(randint(0, 256)), range(1,10000))))"
Code: 
Byte: 149, freq: 57 
Byte: 153, freq: 57 
Byte: 124, freq: 55 
Byte: 166, freq: 54 
Byte: 11, freq: 53 
Byte: 113, freq: 53 
Byte: 144, freq: 52 
Byte: 98, freq: 51 
Byte: 189, freq: 51 
Byte: 231, freq: 51 
Byte: 41, freq: 50 
Byte: 61, freq: 50 
Byte: 101, freq: 50 
Byte: 139, freq: 50 
Byte: 93, freq: 49 
Byte: 108, freq: 49 
Byte: 110, freq: 49 
Byte: 237, freq: 49 
Byte: 247, freq: 49 
Byte: 251, freq: 49 
Byte: 77, freq: 48 
Byte: 186, freq: 48 
Byte: 206, freq: 48 
Byte: 235, freq: 48 
Byte: 255, freq: 48 
Byte: 17, freq: 47 
Byte: 40, freq: 47 
Byte: 79, freq: 47 
Byte: 150, freq: 47 
Byte: 233, freq: 47 
Byte: 109, freq: 46 
Byte: 114, freq: 46 
Byte: 123, freq: 46 
Byte: 147, freq: 46 
Byte: 151, freq: 46 
Byte: 170, freq: 46 
Byte: 177, freq: 46 
Byte: 209, freq: 46 
Byte: 210, freq: 46 
Byte: 245, freq: 46 
Byte: 256, freq: 46 
Byte: 29, freq: 45 
Byte: 36, freq: 45 
Byte: 37, freq: 45 
Byte: 50, freq: 45 
Byte: 55, freq: 45 
Byte: 117, freq: 45 
Byte: 134, freq: 45 
Byte: 167, freq: 45 
Byte: 176, freq: 45 
Byte: 184, freq: 45 
Byte: 207, freq: 45 
Byte: 224, freq: 45 
Byte: 1, freq: 44 
Byte: 4, freq: 44 
Byte: 26, freq: 44 
Byte: 72, freq: 44 
Byte: 75, freq: 44 
Byte: 140, freq: 44 
Byte: 148, freq: 44 
Byte: 198, freq: 44 
Byte: 228, freq: 44 
Byte: 56, freq: 43 
Byte: 59, freq: 43 
Byte: 64, freq: 43 
Byte: 100, freq: 43 
Byte: 156, freq: 43 
Byte: 160, freq: 43 
Byte: 181, freq: 43 
Byte: 182, freq: 43 
Byte: 222, freq: 43 
Byte: 252, freq: 43 
Byte: 12, freq: 42 
Byte: 32, freq: 42 
Byte: 42, freq: 42 
Byte: 47, freq: 42 
Byte: 54, freq: 42 
Byte: 69, freq: 42 
Byte: 99, freq: 42 
Byte: 116, freq: 42 
Byte: 141, freq: 42 
Byte: 161, freq: 42 
Byte: 172, freq: 42 
Byte: 185, freq: 42 
Byte: 188, freq: 42 
Byte: 192, freq: 42 
Byte: 203, freq: 42 
Byte: 0, freq: 41 
Byte: 28, freq: 41 
Byte: 45, freq: 41 
Byte: 83, freq: 41 
Byte: 89, freq: 41 
Byte: 90, freq: 41 
Byte: 112, freq: 41 
Byte: 125, freq: 41 
Byte: 129, freq: 41 
Byte: 131, freq: 41 
Byte: 164, freq: 41 
Byte: 199, freq: 41 
Byte: 218, freq: 41 
Byte: 239, freq: 41 
Byte: 25, freq: 40 
Byte: 38, freq: 40 
Byte: 49, freq: 40 
Byte: 53, freq: 40 
Byte: 62, freq: 40 
Byte: 66, freq: 40 
Byte: 68, freq: 40 
Byte: 76, freq: 40 
Byte: 105, freq: 40 
Byte: 118, freq: 40 
Byte: 121, freq: 40 
Byte: 126, freq: 40 
Byte: 142, freq: 40 
Byte: 154, freq: 40 
Byte: 168, freq: 40 
Byte: 179, freq: 40 
Byte: 195, freq: 40 
Byte: 201, freq: 40 
Byte: 234, freq: 40 
Byte: 7, freq: 39 
Byte: 18, freq: 39 
Byte: 20, freq: 39 
Byte: 58, freq: 39 
Byte: 71, freq: 39 
Byte: 73, freq: 39 
Byte: 87, freq: 39 
Byte: 158, freq: 39 
Byte: 162, freq: 39 
Byte: 174, freq: 39 
Byte: 178, freq: 39 
Byte: 180, freq: 39 
Byte: 197, freq: 39 
Byte: 208, freq: 39 
Byte: 214, freq: 39 
Byte: 226, freq: 39 
Byte: 246, freq: 39 
Byte: 3, freq: 38 
Byte: 9, freq: 38 
Byte: 15, freq: 38 
Byte: 24, freq: 38 
Byte: 33, freq: 38 
Byte: 46, freq: 38 
Byte: 119, freq: 38 
Byte: 133, freq: 38 
Byte: 135, freq: 38 
Byte: 163, freq: 38 
Byte: 171, freq: 38 
Byte: 193, freq: 38 
Byte: 204, freq: 38 
Byte: 216, freq: 38 
Byte: 229, freq: 38 
Byte: 249, freq: 38 
Byte: 250, freq: 38 
Byte: 253, freq: 38 
Byte: 39, freq: 37 
Byte: 51, freq: 37 
Byte: 52, freq: 37 
Byte: 82, freq: 37 
Byte: 155, freq: 37 
Byte: 173, freq: 37 
Byte: 187, freq: 37 
Byte: 236, freq: 37 
Byte: 241, freq: 37 
Byte: 244, freq: 37 
Byte: 5, freq: 36 
Byte: 6, freq: 36 
Byte: 8, freq: 36 
Byte: 14, freq: 36 
Byte: 16, freq: 36 
Byte: 21, freq: 36 
Byte: 63, freq: 36 
Byte: 80, freq: 36 
Byte: 95, freq: 36 
Byte: 138, freq: 36 
Byte: 159, freq: 36 
Byte: 202, freq: 36 
Byte: 27, freq: 35 
Byte: 44, freq: 35 
Byte: 92, freq: 35 
Byte: 97, freq: 35 
Byte: 115, freq: 35 
Byte: 127, freq: 35 
Byte: 146, freq: 35 
Byte: 165, freq: 35 
Byte: 194, freq: 35 
Byte: 220, freq: 35 
Byte: 230, freq: 35 
Byte: 31, freq: 34 
Byte: 60, freq: 34 
Byte: 67, freq: 34 
Byte: 70, freq: 34 
Byte: 88, freq: 34 
Byte: 94, freq: 34 
Byte: 104, freq: 34 
Byte: 132, freq: 34 
Byte: 137, freq: 34 
Byte: 145, freq: 34 
Byte: 183, freq: 34 
Byte: 191, freq: 34 
Byte: 243, freq: 34 
Byte: 35, freq: 33 
Byte: 48, freq: 33 
Byte: 78, freq: 33 
Byte: 81, freq: 33 
Byte: 86, freq: 33 
Byte: 136, freq: 33 
Byte: 143, freq: 33 
Byte: 152, freq: 33 
Byte: 175, freq: 33 
Byte: 200, freq: 33 
Byte: 205, freq: 33 
Byte: 217, freq: 33 
Byte: 227, freq: 33 
Byte: 238, freq: 33 
Byte: 10, freq: 32 
Byte: 13, freq: 32 
Byte: 22, freq: 32 
Byte: 30, freq: 32 
Byte: 43, freq: 32 
Byte: 84, freq: 32 
Byte: 85, freq: 32 
Byte: 106, freq: 32 
Byte: 215, freq: 32 
Byte: 221, freq: 32 
Byte: 232, freq: 32 
Byte: 19, freq: 31 
Byte: 34, freq: 31 
Byte: 122, freq: 31 
Byte: 223, freq: 31 
Byte: 23, freq: 30 
Byte: 65, freq: 30 
Byte: 74, freq: 30 
Byte: 120, freq: 30 
Byte: 242, freq: 30 
Byte: 91, freq: 29 
Byte: 96, freq: 29 
Byte: 128, freq: 29 
Byte: 130, freq: 29 
Byte: 190, freq: 29 
Byte: 211, freq: 29 
Byte: 213, freq: 29 
Byte: 248, freq: 29 
Byte: 103, freq: 28 
Byte: 111, freq: 28 
Byte: 225, freq: 28 
Byte: 254, freq: 28 
Byte: 2, freq: 27 
Byte: 107, freq: 27 
Byte: 196, freq: 27 
Byte: 102, freq: 25 
Byte: 157, freq: 25 
Byte: 212, freq: 25 
Byte: 240, freq: 25 
Byte: 57, freq: 24 
Byte: 219, freq: 24 
Byte: 169, freq: 23
python -c "from random import *; print(','.join(map(lambda x: str(int(random()*256)), range(1,10000))))"
Code: 
Byte: 193, freq: 61 
Byte: 64, freq: 56 
Byte: 220, freq: 52 
Byte: 40, freq: 51 
Byte: 159, freq: 51 
Byte: 186, freq: 51 
Byte: 24, freq: 50 
Byte: 50, freq: 50 
Byte: 77, freq: 50 
Byte: 151, freq: 50 
Byte: 185, freq: 50 
Byte: 236, freq: 50 
Byte: 255, freq: 50 
Byte: 80, freq: 49 
Byte: 88, freq: 49 
Byte: 131, freq: 49 
Byte: 143, freq: 49 
Byte: 149, freq: 49 
Byte: 231, freq: 49 
Byte: 12, freq: 48 
Byte: 16, freq: 48 
Byte: 28, freq: 48 
Byte: 60, freq: 48 
Byte: 65, freq: 48 
Byte: 75, freq: 48 
Byte: 189, freq: 48 
Byte: 3, freq: 47 
Byte: 7, freq: 47 
Byte: 47, freq: 47 
Byte: 122, freq: 47 
Byte: 124, freq: 47 
Byte: 142, freq: 47 
Byte: 168, freq: 47 
Byte: 211, freq: 47 
Byte: 221, freq: 47 
Byte: 26, freq: 46 
Byte: 36, freq: 46 
Byte: 76, freq: 46 
Byte: 141, freq: 46 
Byte: 163, freq: 46 
Byte: 166, freq: 46 
Byte: 172, freq: 46 
Byte: 234, freq: 46 
Byte: 250, freq: 46 
Byte: 6, freq: 45 
Byte: 17, freq: 45 
Byte: 84, freq: 45 
Byte: 112, freq: 45 
Byte: 113, freq: 45 
Byte: 164, freq: 45 
Byte: 176, freq: 45 
Byte: 1, freq: 44 
Byte: 22, freq: 44 
Byte: 25, freq: 44 
Byte: 48, freq: 44 
Byte: 71, freq: 44 
Byte: 81, freq: 44 
Byte: 85, freq: 44 
Byte: 103, freq: 44 
Byte: 119, freq: 44 
Byte: 121, freq: 44 
Byte: 54, freq: 43 
Byte: 61, freq: 43 
Byte: 82, freq: 43 
Byte: 98, freq: 43 
Byte: 127, freq: 43 
Byte: 130, freq: 43 
Byte: 152, freq: 43 
Byte: 153, freq: 43 
Byte: 194, freq: 43 
Byte: 202, freq: 43 
Byte: 210, freq: 43 
Byte: 241, freq: 43 
Byte: 31, freq: 42 
Byte: 34, freq: 42 
Byte: 63, freq: 42 
Byte: 73, freq: 42 
Byte: 93, freq: 42 
Byte: 123, freq: 42 
Byte: 125, freq: 42 
Byte: 150, freq: 42 
Byte: 155, freq: 42 
Byte: 181, freq: 42 
Byte: 223, freq: 42 
Byte: 232, freq: 42 
Byte: 240, freq: 42 
Byte: 0, freq: 41 
Byte: 9, freq: 41 
Byte: 45, freq: 41 
Byte: 51, freq: 41 
Byte: 69, freq: 41 
Byte: 110, freq: 41 
Byte: 120, freq: 41 
Byte: 138, freq: 41 
Byte: 144, freq: 41 
Byte: 156, freq: 41 
Byte: 157, freq: 41 
Byte: 170, freq: 41 
Byte: 171, freq: 41 
Byte: 212, freq: 41 
Byte: 217, freq: 41 
Byte: 219, freq: 41 
Byte: 222, freq: 41 
Byte: 27, freq: 40 
Byte: 55, freq: 40 
Byte: 57, freq: 40 
Byte: 68, freq: 40 
Byte: 86, freq: 40 
Byte: 104, freq: 40 
Byte: 128, freq: 40 
Byte: 160, freq: 40 
Byte: 179, freq: 40 
Byte: 182, freq: 40 
Byte: 197, freq: 40 
Byte: 224, freq: 40 
Byte: 230, freq: 40 
Byte: 233, freq: 40 
Byte: 235, freq: 40 
Byte: 251, freq: 40 
Byte: 5, freq: 39 
Byte: 14, freq: 39 
Byte: 30, freq: 39 
Byte: 42, freq: 39 
Byte: 52, freq: 39 
Byte: 72, freq: 39 
Byte: 96, freq: 39 
Byte: 97, freq: 39 
Byte: 99, freq: 39 
Byte: 108, freq: 39 
Byte: 109, freq: 39 
Byte: 145, freq: 39 
Byte: 146, freq: 39 
Byte: 167, freq: 39 
Byte: 183, freq: 39 
Byte: 192, freq: 39 
Byte: 209, freq: 39 
Byte: 215, freq: 39 
Byte: 226, freq: 39 
Byte: 244, freq: 39 
Byte: 247, freq: 39 
Byte: 249, freq: 39 
Byte: 13, freq: 38 
Byte: 19, freq: 38 
Byte: 87, freq: 38 
Byte: 118, freq: 38 
Byte: 165, freq: 38 
Byte: 174, freq: 38 
Byte: 180, freq: 38 
Byte: 196, freq: 38 
Byte: 205, freq: 38 
Byte: 208, freq: 38 
Byte: 242, freq: 38 
Byte: 23, freq: 37 
Byte: 37, freq: 37 
Byte: 91, freq: 37 
Byte: 114, freq: 37 
Byte: 133, freq: 37 
Byte: 134, freq: 37 
Byte: 154, freq: 37 
Byte: 177, freq: 37 
Byte: 184, freq: 37 
Byte: 199, freq: 37 
Byte: 204, freq: 37 
Byte: 227, freq: 37 
Byte: 246, freq: 37 
Byte: 248, freq: 37 
Byte: 254, freq: 37 
Byte: 2, freq: 36 
Byte: 11, freq: 36 
Byte: 18, freq: 36 
Byte: 32, freq: 36 
Byte: 79, freq: 36 
Byte: 94, freq: 36 
Byte: 137, freq: 36 
Byte: 173, freq: 36 
Byte: 175, freq: 36 
Byte: 218, freq: 36 
Byte: 229, freq: 36 
Byte: 238, freq: 36 
Byte: 8, freq: 35 
Byte: 39, freq: 35 
Byte: 49, freq: 35 
Byte: 66, freq: 35 
Byte: 70, freq: 35 
Byte: 95, freq: 35 
Byte: 100, freq: 35 
Byte: 139, freq: 35 
Byte: 158, freq: 35 
Byte: 195, freq: 35 
Byte: 198, freq: 35 
Byte: 200, freq: 35 
Byte: 4, freq: 34 
Byte: 15, freq: 34 
Byte: 20, freq: 34 
Byte: 38, freq: 34 
Byte: 43, freq: 34 
Byte: 59, freq: 34 
Byte: 92, freq: 34 
Byte: 116, freq: 34 
Byte: 136, freq: 34 
Byte: 178, freq: 34 
Byte: 191, freq: 34 
Byte: 206, freq: 34 
Byte: 207, freq: 34 
Byte: 214, freq: 34 
Byte: 216, freq: 34 
Byte: 245, freq: 34 
Byte: 10, freq: 33 
Byte: 29, freq: 33 
Byte: 53, freq: 33 
Byte: 62, freq: 33 
Byte: 78, freq: 33 
Byte: 107, freq: 33 
Byte: 111, freq: 33 
Byte: 132, freq: 33 
Byte: 148, freq: 33 
Byte: 188, freq: 33 
Byte: 201, freq: 33 
Byte: 21, freq: 32 
Byte: 44, freq: 32 
Byte: 46, freq: 32 
Byte: 89, freq: 32 
Byte: 90, freq: 32 
Byte: 126, freq: 32 
Byte: 161, freq: 32 
Byte: 190, freq: 32 
Byte: 237, freq: 32 
Byte: 56, freq: 31 
Byte: 67, freq: 31 
Byte: 102, freq: 31 
Byte: 115, freq: 31 
Byte: 140, freq: 31 
Byte: 162, freq: 31 
Byte: 243, freq: 31 
Byte: 35, freq: 30 
Byte: 41, freq: 30 
Byte: 74, freq: 30 
Byte: 117, freq: 30 
Byte: 253, freq: 30 
Byte: 101, freq: 29 
Byte: 135, freq: 29 
Byte: 187, freq: 29 
Byte: 228, freq: 29 
Byte: 58, freq: 28 
Byte: 83, freq: 28 
Byte: 105, freq: 28 
Byte: 225, freq: 28 
Byte: 203, freq: 27 
Byte: 213, freq: 27 
Byte: 33, freq: 26 
Byte: 129, freq: 26 
Byte: 169, freq: 26 
Byte: 239, freq: 26 
Byte: 252, freq: 26 
Byte: 106, freq: 25 
Byte: 147, freq: 24
 
um mal eine idee in den raum zu werfen:

die zufallszahlen sollen wohl die schwachstelle sein... fein ... schauen wir mal was da so rumgeistert ... die getRandom() sieht halbwegs sicher aus (mit der ausnahme, das sie keinen CPRNG verwendet ...)


wir haben eine ausgabe des PRNG als klartext: ctr=5356575355555749

was wohl hier erzeugt wird...

Code: 
        // generate random r
        randomValue = new Clipperz.ByteArray();
        iv = new Clipperz.ByteArray();
        ctr = "";
        c = (128/8)
        for (i=0; i<c ; i++) {
                randomValue.appendByte(getRandom(0, 255));
                iv.appendByte(getRandom(0, 255));
        }
        for (i = 0; i < 8; i++) {
                ctr += getRandom(48, 57)        
        }
die stellen 0 - 15 des zufalls zahlenstroms kennen wir nicht ... 16 - 23 sind bekannt

ferner ist bekannt, dass der JS PRNG typischerweise über die systemzeit geseeded wird

da die jeweilige implemntation browserspezifisch ist, und unser mitschnitt keinen user-agent nennt, kann man nun das raten anfangen ...

wenn ich auf diese datenbasis einen angriff aufstellen wollte, würde ich nun sowas probieren (in ermangelung praktikabler statistischer angriffe auf die zufalls zahlen reihe selbst oder den verwendeten PRNG):
Code: 
        found=false;
        seed=Date(); // JS kennt keine seeds ... :(
        while(true)
        {
            found=true;
            ctr = new Array(53,56,57,53,55,55,57,49);
            c = (128/8);
            for (i=0; i<c ; i++) {
                    getRandom(0, 255);
                    getRandom(0, 255);
            }
            for (i = 0; i < 8; i++) {
                if(ctr[i]!=getRandom(0,255)){
                    found=false;
                    break;
                }
            }
            if(found)
            {
                echo seed;
                break;
            }
            seed--;
        }
wobei man sich natürlich im klaren sein muss, dass dieser code so nicht funktioniert ... aber ich denke der ansatz sollte klar sein ... raten welcher PRNG verwendet wurde ... diesen systematisch seeden, und den ausgabestrom mit dem vergleichen, was wir kennen ... haben wir eine übereinstimmung, können wir mal testen ob der verwendete seed zu einem passenden schlüssel führt ...
 
@GrafZahl danke für deine Idee.
Das ganze bedarf dann noch etwas Tüftelei da ich in javascript das Datum nicht setzten kann d.h die Systemzeit zurücksetzten muss und das ganze noch für die gängigen Browser machen muss.

Weiters bleibt die Frage wie effizient das Script läuft, da ich den Zeitpunkt nur raten kann d.h für 30Tag wärend das: 30 * 24 * 60 * 60 * 1000 also ~2,5mrd Möglichkeiten. für 1 Monat.

Aber vll. geht sichs ja aus mal schauen :D
 
31,2 Bit ist mit sicherheit klein genug für einen bruteforce versuch ... ist halt die frage wie lange man zeit hat, und was für maschinen das testen sollen ... auf ner uni würde ich mal fragen wann nachts der pc pool nicht gebraucht wird ... wenns nen realer fall wäre, wären ein paar ec2 instanzen sicherlich auch bezahlbar ...
 
ja rechnerpower is NP, das größte problem das ich aktuell sehe ist, das ich keine möglichkeit hab den seed zu steuern ich kann die systemzeit setzen aber ich kann den seed nicht inkremetieren d.h ich müsste die javascript math.random() funktion in C oder ähnlichem nachbauen um die bruteforce attacke zu starten :/
 
du kannst dir auch den FF source holen, und in der JS implementation nachsehen wie der PRNG funktioniert ... das ganze auszubauen und seed fähig zu machen sollte kein mammut projekt sein ...
 
arrgghh *a wild problem appeared*

"53,56,57,53" sind alles ints Math.random() returned eigentlich floats die dann in der getRandom() funktion einfach abgeschnitten werden d.h ich weis ja garnicht welche genaue float-random zahl verwendet wurde :/
 
Beachte, was du als Sequenz betrachtest ... die Ausgabe von Math.random() oder die Ausgabe von getRandom() ...

Letzteres reicht für diese Betrachtung. Der entstehende Fehler führt allenfalls zu false positives ... diese sind allerdings unwahrscheinlich, da ansonsten bei unterschiedlichem seed sehr ähnliche sequenzen entstehen müssten ... sicherlich möglich, aber die Verteilung der Zahlen sprich dagegen, dass das zu einem großen Problem wird ... wir reden hier immerhin von 8 fest positionierten Werten der Sequenz die so ähnlich sein müssen, das sie beim abrunden auf die gleiche Integer Sequenz abgebildet würden ...
 
so nach einigen Tagen herumprobieren kann ich sagen ich komm nicht weiter.
Das Problem liegt vorallem daran das ich nicht weis welcher Browser geschweigedenn Version benutzt wird. Die einzelnen Browser/Versionen generieren den Randomwert/Seeds auf unterschiedliche weisen das scheint für mich also ein dead-end.
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben