Hallo,
so sry für Doppel Post, aber ich nehm mir das Recht mal raus *h3h3*.
So was mir auffiel:
Warum ist der perKey ein int-Array, wo aber nur byte-Werte verwendet werden?
Warum implementierst du dies über Byte-Arrays und verwendest keine 32-Bit Wörter (integer)?
Speed-Tipp: Modulo-Operationen (%) sind extrem langsam, anstatt %8 lieber &7 verwenden, steiger die Performance enorm.
Dann anstatt zu Teilen und zu multipilizieren evt. die Bits schieben, also anstatt x/8 lieber x>>3
Negative Bytes: Bytes bei denen man das Vorzeichen beachtet, wie es bei dir der Fall ist, sind sehr sehr komisch.
Da in C# das Byte _vorzeichenlos_ ist, habe ich große Probleme deinen Code nach C# zu übersetzen.
Normale Algorithmen verwenden kein Vorzeichen.
Vorallem bei einem Byte mit einem Vorzeichen gibts keinen Wert '128' sondern nur -128.
Da ich die Substitutions-Methode etwas modifizieren musste, wären Testvektoren sinnvoll.
Vorrunde: Dieses erhöht nicht die Sicherheit, da diese nicht Schlüsselabhänig ist. Ist ähnlich wie bei der Premutation von DES, die aber nur diente, um die Input-Bits zu "laden".
Schlussrunde: "// Schlussrunde, ganz wichtig

"
Ist der perKey Schlüssel-Abhänig? Da ich nix zum Key-Setup gefunden habe, kann ich dazu nix sagen, ich denke aber mal dass nur xorKey0-3 den Schlüssel darstellt.
Wenn dieser nicht Key-Abhänig ist, bringt die Schlussrunde genauso wenig wie die Vorrunde, da ich den perKey kenne, kann ich die Schlussrunde ganz einfach wieder "abziehen" vom Ciphertext.
Lücke!
Wenn die XOR-Keys nur 0x00 sind (ohne perKey oder Boxen zu ändern), dann ist der Chiffer-Text ohne die Schlussrunde wie folgt:
a = 11 11 11 11 ...
b = 4c 4c 4c 4c ...
c = 71 71 71 71 ...
d = 44 44 44 44 ...
Selbst wenn die Schlussrunde Schlüsselabhänig sein sollte, dann ist dieses Ergebnis extrem verdächtig und soetwas darf eigentlich bei keinem guten Algorithmus auftreten.
Wie du siehst, ist dein Algorithmus mit sehr sehr hoher Wahrscheinlichkeit unsicher.
Denn wenn der Key (die XOR-Keys) alle die gleiche Value haben sowie das Input das gleiche Value hat (alles 00-Bytes), so sind die Variablen a,b,c,d in den Runden immer gleich, also a besteht z.B. nur aus 0x5a-Bytes, b nur aus 0x66 Bytes usw.
Da dein Key-Setup so konfuse ist, und der Abend zuende geht, beendige ich den Abend vorerst mit '
Algorithmus gebrochen', da dies so merkwürdig ist, dass es höchst wahrscheinlich eine Lücke darstellt.
Erklräung der Lücke
Dein Algorithmus
zu geradlinig!. Die einzelnen Blöche a,b,c,d beeinflussen sich nicht gegenseitig, also hast du effektiv keine 256-Bit-Blöcke, sondern in Wirklichkeit nur 64-Bit Blöcke.
Des Weiteren verwendest du nur 1 Byte-Schift (bzw. 8 insgesamt), und dies nur innerhalb des Blockes.
Wenn einer der 64-Bit-Blöcke "homogen" ist, also nur aus 1 Byte besteht (z.B. AB AB AB...), so bringt der Byte-Schift nicht viel, ist dann noch der XOR-Key homogen, geht die Sicherheit komplett überboard.
Wenn du schon 256-Bit-Blöcke verwendest, dann sollte eine Veränderung in einem Block auch alle anderen Blöcke beeinflussen. Standard-Mittel hierfür ein ein Feistel-Netz.
Bsp:
Du Verschlüsselst du Eingabe: AA 00 00 00 ....
Die Blöcke a,b,c,d nach den 32 Runden weisen aber nur eine Veränderung jeweils in ihrem ersten Byte auf, wenn überhaupt:
Meine Ausgabe:
a = 2c 11 11 11 ...
b = 60 4c 4c 4c ...
c = 71 71 71 71 ... (Keine Veränderung!)
d = 6a 44 44 44 ...
Und diese minimale Veränderung entstand nur Aufgrund der Vorrunde, die die Blöcke aber nur minimal in Abhänigkeit setzt.
Was schön wäre, ein verständliches Key-Setup zu schreiben, also in den Algorithmus Kobalt....java eine Methode SetupKey zu integrieren, der man einfach den 256-Bit Key übergibt, und diesen die Arrays entsprechend modifiziert.
Des Weiteren fiel mir noch in expand auf:
SBox0=expand(SBox0,xorKey);
//Methode expand (byte [] Box,byte [] xorKey)
Box
=Box[xorKey];
Die SBox hat 128-Einträge, ein Byte kann bekanntlich 256-Werte annehmen.
Da das byte unter Java ja scheinbar vorzeichenhaft ist, gibts auch negative Werte, aber welchen Wert liefert Box[-15] zurück??
Fazit
Dein Algorithmus ist deutlich zu geradlinig. Kleinste Veränderungen in der Eingabe müssen zu einem deutlich anderem Ciphertext führen.
Die Blöcke müssen sich untereinander stark beeinflussen. Verändert sich nur ein einziges Bit im ersten Block, muss dieses alle anderen Bits beeinflussen.
Im jetzigen Zustand ist dein Algorithmus sehr unsicher.
Verbesserungsmöglichkeiten:
- Verständliches Keysetup 
- Feistel-Netzwerk
- Mit 32-Bit-Wörtern arbeiten (aufgrund der Performance)
- Bit-Rotationen verwenden
- Oder doch gleich einen sicheren Algorithmus benutzen (Blowfish, Twofish, AES, Serpent, die Liste ist lang...) verwenden