Könnte es sein, dass die vermeintlichen Sternenexplosionen in Wahrheit optische
 Täuschungen sind?
 	
Ich sage, eine Supernova ist tatsächlich nur eine optische Täuschung,
hervorgerufen durch eine 
Gravitationslinse. Liegen zwei Sterne und ein Beobachter exakt auf einer Geraden, wird also ein
Stern durch einen anderen Stern vermeindlich verdeckt, passiert tatsächlich etwas ganz anderes.
	 
 		  	
Die Lichtstrahlen werden von der Masse des Sterns in der Mitte abgelenkt. Die Ablenkung ist proportional
dem Kehrwert des Abstands x in dem die Strahlen die Gravitationslinse passieren. Mehr brauchen wir nicht
wissen, um es zu verstehen. 

Die Ablenkung nimmt also mit der Entfernung zum Stern ab und ist am Rand des Sterns maximal. Die Ablenkung nimmt
mit der Masse des ablenkenden Sterns zu und liegt in der Größenordnung einer Bogensekunde. Für alle 
Sterne mit Ausnahme der Sonne wird der Stern in Wahrheit nicht verdeckt. Nur die Sonne hat einem scheinbaren Radius
von über tausend Bogensekunden. Bei allen anderen Sternen ist die Ablenkung durch die Masse groß genug,
um das Licht um den vermeintlich verdeckenden Stern herumzuführen. Der punkförmige Stern weitet sich damit 
zu einem Kreis auf. Dies ist jedoch nur  mit einem modernen, hochauflösenden Teleskop erkennbar. Die Gravitationslinse
ist aber dennoch relativ einfach von der Erde aus zu beobachten, durch eine scheinbare Aufhellung des vermeintlich verdeckten
Sterns. Der quasi punktförmige Stern weitet sich zu einem Kreis mit einem Radius von mehreren Millionen Kilometern und 
erscheint dadurch wesentlich heller.


Eine Erscheinung, die im Prinzip wie Mond- und Sonnenfinsternis oder ein Planetentransit vor der Sonne, relativ
einfach, rein geometrisch verstanden werden kann.



Impressum



Symmetrische Kryptographie (Spritz)

Es ist durchaus fraglich, ob wir tiefgehende Kenntnisse der Zahlentheorie und riesige Primzahlen überhaupt 
brauchen, denn nur bei asymmetrischen Verfahren ist dies erforderlich. 


Bei symmetrischen Verfahren ist des Rechnen mit riesigen Zahlen mit hunderten Stellen nicht erforderlich. Wir
könnem damit alles mit der Programmiersprache-C leicht erledigen, die überall verfügbar ist und 
auch besonders schnell.

Der bekannte Professor Rivest (siehe RSA) hat auch auf diesem Gebiet eine Lösung für alles. 


Spritz - a spongy RC4-like stream cipher and hash function

 


KISS - keep it simple, stupid


Blockweise die Reihenfolge der Bytes umkehren

Wir erreichen eine nahezu perfekte Verschlüsselung, die es erlaubt
den Schlüssel wiederzuverwenden, durch eine sogenannte 
selbstsynchronisierte Stromchiffre, Umkehrung
der Reihenfolge der Bytes und erneute Anwendung der Stromchiffre.

Ein solches Verfahren ist besser als eine Blockchiffre wie AES und noch dazu
deutlich schneller. Jede, wirklich jede Änderung, auch im letzten Bit,
führt zu einer komplett veränderten Chiffre. Die Wiederverwendung
des Schlüssels ist an der Chiffre nicht zu erkennen. Die Chiffre ist
von reinen Zufallsbits nicht zu unterscheiden. Selbst ein Quantencomputer
kann die Chiffre niemals knacken.







 AES 
ist einfach nur sinnlos kompliziert, mit Kanonen auf Spatzen geschossen. 


Wir können alle symmetrischen Verfahren der Kryptographie mit dem
von Ron Rivest vorgeschlagenen Verfahren SPRITZ abdecken. An der Sicherheit
gibt es keine berechtigten Zweifel.


Spätestens der zweite Verschlüsselungsschritt ist ein echtes One-Time-Pad,
also unknackbar.
 
knoppix@Microknoppix:~$ gcc r.c -o R
knoppix@Microknoppix:~$ gcc e.c -o e
knoppix@Microknoppix:~$ gcc d.c -o d
knoppix@Microknoppix:~$ cat e.c | ./e | ./R | ./e > x
9ba737b83db7b4dc
f19831653bcebf22
knoppix@Microknoppix:~$ cat x | ./d | ./R | ./d > e.copy
f19831653bcebf22
9ba737b83db7b4dc
knoppix@Microknoppix:~$ diff e.copy e.c
knoppix@Microknoppix:~$ ls -l x 
-rw-r--r-- 1 knoppix knoppix 7550 Mai 10 07:47 x
knoppix@Microknoppix:~$ gzip x
gzip: x.gz already exists; do you wish to overwrite (y or n)? y
knoppix@Microknoppix:~$ ls -l x.gz 
-rw-r--r-- 1 knoppix knoppix 7575 Mai 10 07:47 x.gz

 Mit eingefrorenen Startwerten 

Der skurrile KEY SCHEDULE ist nicht erforderlich. Der Anfangszustand
state kann schlicht in initialize_state(&state) festgelegt werden.


  



Digitale Signatur

Basierend auf kollisionsresistentem Hashwert.

 Beispiel in Python 3 

text = """
Test
Test
Test
"""

import hashlib, sys

def mac(txt):
    return hashlib.sha256(('XXX secret' + txt + 'some other secret text').encode()).hexdigest()    

if len(sys.argv) > 1:
   text = sys.argv[1]

print( mac(text) )    
 






Wird der Message Authentication Code (MAC) amtlich verwahrt, inklusive dem Schlüsselwert, 
ist der MAC nicht abzuleugnen. Dies gilt jedenfalls bei einem kollisionsresistenten Wert, bei
dem es praktisch unmöglich ist, zwei unterschiedliche Nachrichten mit identischem MAC
zu finden. Der MAC ist dann eine echte digitale Signatur. Der Public Key und riesige Primzahlen 
werden dann nicht gebraucht.


  
 Verification 



 Update 

 Rabin-Signatur 

'''
  Rabin Signature Algorithm
  Copyright (c) 2021 Franz Scheerer, all rights reserved 
'''  

import hashlib

def gcd(a,b):
    while b > 0:
        a,b = b, a % b 
    return a 

# The minimum size of the primes is 500 bits 
min = 1 << 500

# The product of the smallest odd primes
m = 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23 * 29

#
# Find smallest prime greater or equal p with 500 bits
#
def nextPrime(p):
  while p < min:
    p = 47 * p + 11
  while p % 4 != 3:
      p = p + 1
  while True:
    while gcd(p, m) != 1:
      p = p + 4 
    if (pow(17,p-1,p) != 1):
      p = p + 4 
      continue
    return p

def hvar(x, r):
  num = 0
  for rr in range(r):
      bs = hashlib.md5((x+str(num)).encode()).digest()
      for b in bs:
         num = (num<<8) + b
  return num     

def root(m: str, p, q):
    """Rabin signature algorithm."""
    n = p * q
    while True:
        x = hvar(m, 8)
        sig = pow(p, q - 2, q) * p * pow(x, (q + 1) // 4, q)
        sig = (pow(q, p - 2, p) * q * pow(x, (p + 1) // 4, p) + sig) % (n)
        if (sig * sig) % (n) == x:
            break
        m = m + 'X'
    return [sig, m]

#Calculate the private key
p = nextPrime(hvar('one prime', 5))    
q = nextPrime(hvar('one other prime', 5))

#Calculate the public key
n = p * q

#Calculate the signature
sig = root('Rabin signature algorithm.', p, q)
print("sig = ", sig)

#Verification

assert ( (sig[0] * sig[0]) % (n) == hvar(sig[1], 8) )

print()
print("The signature was verified.")




Alle Probleme sind gelöst
Die gesamte Kryptographie lässt sich mit wenigen Zeilen Pythoncode 
bewältigen.





Javascript 

Hash mit Javascript