HASH

Die Klasse in Python 3

Perfektionierter RC4 von Ron Rivest mit N = 256 Spielkarten

Letzte Änderungen

Der Parameter a nimmt alle Werte von null bis 62 an, nicht 128 wie in Spritz oder 240 oder auch 241 wie zuvor. Vor der Ausgabe wird die Funktion Shuffle dreimal aufgerufen. Damit ist die Hashfunktion jetzt hundert Prozent sicher, wahrhaft sicher für die Ewigkeit. Die Funktion Shuffle wird in der Funktion Squeeze jetzt immer, für jeden Wert des Parameters a, aufgerufen.

Zufallszahlen

Kurz gefasst

N Karten mischen, im Kreis, einem Ziffernblatt mit zwei Zeigern, anordnen.

Folgendes wird so oft wiederholt wie Zufallswerte benötigt werden.

Ein Zeiger wird immer um eins weitergedreht, der zweite Zeigen um den Wert,
auf den der erste Zeiger zeigt. Der zweite Zeiger wird dann auf die Position gedreht,
auf die er zeigt. Die Karten, auf die beide Zeiger zeigen, werden vertauscht. Sie
weren so ständig weiter gemischt.
Der Wert, auf den der zweite Zeiger zeigt, ist der deterministisch berechnete Zufallswert.
Eine abweichende, ungerade Schrittweite w = 3, 5, 7, … ist ebenso gut.

Aufbauend auf dieser Idee, können wir auch eine einfache Hashfunktion konstruieren. Dies ist viel einfacher
und mindestens ebenso sicher wie SHA-2. Auch wenn SHA-2 wahrscheinlich sicher ist.

Spritz/RC4 ist noch besser entsprechend dem Motto:

Beautiful is better than ugly
Simple is better than complex
Complex is better than complicated
Readability counts

Sensation

- vermeintlich sicherer NIST-Standard SHA-1 nach über 20 Jahren geknackt.

Eine Hashfunktion, die tatsächlich die Berechnung von Kollisionen praktisch zu 100 Prozent ausschließt.

SPRITZ-HASH ohne CRUSH

Quellcode in Python

Eine Abweichung vom gewünschten s-Wert sei ein FEHLER.

Die linke Seite, der Wert "a = 0, 1, ... 62", beim Vertauschen wird 
erst nach dem Aufruf von SHUFFLE erneut durchlaufen. Sie wandert
immer weiter nach rechts.

Die rechte Seite "240, 241, ... 255" liegt rechts davon. 
Somit können FEHLER nicht korrigiert werden.

Ein FEHLER an der Stelle a 
bleibt bis zum Aufruf von 
SHUFFLE bestehen.

Kollisionen vor dem Aufruf von SHUFFLE können nicht
konstruiert werden. Durch Variation der Eingabe-Nibbles 
erhalten wir zwei hoch (63 mal 4) also 2^252 verschiedene
Permutationen s[]. Eine riesige Zahl, doch noch viel 
größer ist die Zahl möglicher Permutationen,
 nämlich 256-Fakultät, etwa 2^1684.

Die Chance eine Kollision mit einer zufälligen
Permutation erreichen zu können, ist daher praktisch 
gleich null.

Durch Variaton der 63 Nibbles (4 Byte-Blöcke) werden
nur 2^252 von 2^1684 möglichen Vertauschungen erreicht.

Es ist sogar noch schwieriger, weil auch j und w überein-
stimmen müssen, also tatsächlich praktisch 
unmöglich.

-----------------------------------------------------------------------

PYTHON - SKCRIPT (NO IMPORT with Python 2 and Python 3!)
output:
SPRITZ:  7c23cff4f519dc984877fa7a6655cf1797a0f6e59082911e835bcdc9c75513

----------------------------------------------------------------------

def update():
    global a,i,j,w,s
    i = (i + w) % 256
    j = s[(j + s[i]) % 256]
    s[i], s[j] = s[j], s[i]

def output():
    global a,i,j,w,s
    update()
    return s[j]

def shuffle():
    global a,i,j,w,s
    for v in range(256):
        update()    
    w = (w + 2) % 256
    a = 0

def absorb_nibble(x):
    global a,i,j,w,s
    if a == 63:
        shuffle()
    s[a], s[240 + x] = s[240 + x], s[a]
    a = a + 1

def absorb_byte(b):
    absorb_nibble(b % 16)
    absorb_nibble(b >> 4)

def squeeze(out, outlen):
    global a,i,j,w,s
    shuffle()
    shuffle()
    shuffle()
    for v in range(outlen):
        out.append(output())

msg = "Some text ..."

s = []   
a = i = j = 0
w = 1
for v in range(256):
   s.append(v)

for c in msg:
  absorb_byte(ord(c))

def num2hextxt(x):
  res = ''
  h__ = ['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f']
  while x > 0:
    res = h__[x % 16] + res
    x >>= 4
  return res

out = []
squeeze(out, 32)
otx = ''
for n in out:
  otx += num2hextxt(n)
    
print ("SPRITZ: ", otx)

--------------------------------------------------------------------
J A V A S C R I P T
<script>
var a = 0, i = 0, j = 0, w = 1, s = [256], out = [32];

function update()
{
    i = (i + w) % 256
    j = s[(j + s[i]) % 256]
    tmp = s[i]
    s[i] = s[j]
    s[j] = tmp
}

function shuffle()
{
    for (v = 0; v < 256; v++) 
        update()
    w = (w + 2) % 256
    a = 0
}

function absorb_nibble(x)
{
    shuffle()
    shuffle()
    shuffle()
    tmp = s[a]
    s[a] = s[240 + x]
    s[240 + x] = tmp
    a = a + 1
}

function absorb_byte(b)
{
    absorb_nibble(b % 16)
    absorb_nibble(Math.floor(b / 16))
}

function output()
{
    update()
    return s[j]
}

function squeeze(out, outlen)
{
    shuffle()
    for (v = 0; v < outlen; v++) 
        out[v] = output()
}

function MD(txt){
  for (v = 0; v < 256; v++) 
      s[v] = v;
  a = i = j = 0
  w = 1
  for ( ii = 0; ii < txt.length; ii++ )
    absorb_byte(txt.charCodeAt(ii))
  squeeze(out, 32)
  return out
}
function h(x){
  return MD(x)
}

</script>

Beliebigen Text eingeben und SPRITZ-HASH berechnen!
Message Digest (unverändert)