/* zx8 (ps) - Stream Cipher Algorithm/Source Code */ /* Copyright (c) 2012, Karl-Uwe Frank All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #** zx8 (ps) algorithm developed by Karl-Uwe Frank */ /* ------------------------------------------------------------------ zx8 (ps) Test vectors ------------------------------------------------------------------ Key: Password Key (Hex): 50617373776F7264 Keystream: 8A1A89B3221AC4AB9AAB Plaintext: Plaintext Ciphertext: DA76E8DA4C6EA1D3EEA1 -------------------------------------------------------------------- Key: SecretKey Key (Hex): 5365637265744B6579 Keystream: 983283BFE117A0B211E5B433FD0799DCBB43 Plaintext: Secure my Secrets Ciphertext: CB57E0CA937280DF68C5E7569E75FCA8C849 -------------------------------------------------------------------- Key: HQQMG005 Key (Hex): 4851514D47303035 Keystream: 9094D05D6D1F67EAE75C6A6FD59D35 Plaintext: Attack at dawn Ciphertext: D1E0A43C0E74478B937C0E0EA2F33F ------------------------------------------------------------------- Key: HQQMG007 Key (Hex): 4851514D47303037 Keystream: 295C7428FC2C329C627ADD05043F76AC Plaintext: Victory is near Ciphertext: 7F35175C935E4BBC0B09FD6B615E04A6 ------------------------------------------------------------------- Example: echo "Secure my Secrets" | java -Xms32m -Xmx32m zx8_stdio 5365637265744B6579 > ciphertext.out java -Xms32m -Xmx32m zx8_stdio 5365637265744B6579 < ciphertext.out ------------------------------------------------------------------- */ import java.io.Console; import java.io.IOException; import java.util.Arrays; //----------------------------------------- // // Compile Instruction // // rm -f zx8_stdio.class && javac zx8_stdio.java // public class zx8_stdio { //----------------------------------------- // // Global Varaiable Definition // private static byte[] KeyHash; // Secret State Arrays // private static int z[] = new int[256]; private static int x[] = new int[256]; // Global Carry on Array Indices // private static int a = 0; private static int b = 0; //----------------------------------------- // Main // public static void main (String args[]) throws IOException { try { if (args.length < 1) { ShowUsage("zx8_stdio"); System.exit(0); } long startTime = System.currentTimeMillis(); //----------------------------------------- // Rebuild KeyWord[] from KeyHash // KeyHash = hexStr2byteArr(args[0]); //----------------------------------------- // Initialisation of zx8 (ps) // // perform the Key Schedule Algorithm KSA(KeyHash); //----------------------------------------- // // Encrypt/Decrypt Binary File (unbuffered Read/Write) // byte[] inByte = new byte[1]; byte[] outByte = new byte[1]; int inB, outB; while ((System.in.read(inByte) != -1)) { inB = (int)inByte[0]; outB = (inB ^ PRGA()) & 0xff; outByte[0] = (byte)outB; System.out.write(outByte[0]); } float elapsedTimeSec = (System.currentTimeMillis() - startTime)/1000F; System.err.printf("\nElapsed: "); System.err.print(elapsedTimeSec); System.err.printf(" Seconds\n"); System.in.close(); System.out.close(); System.exit(0); } catch (Exception e) { System.err.println("Error: " + e); } finally { System.exit(0); } } //----------------------------------------- // public static void ShowUsage(String ThisName) { System.err.printf("\nUsage : java %s Key(in Hex) out\n", ThisName); System.err.printf("\nExample: java %s 7d0ef66789aca2cfa6c76db7560554 CipherFile\n", ThisName); System.err.printf("\n java %s $(echo -en 'egN99T8eK6peC2UC' | md5) < Plainfile > CipherFile\n", ThisName); System.err.printf("\n cat CipherFile | java %s 7d0ef66789aca2cfa6c76db7560554 > Plainfile\n\n", ThisName); } //----------------------------------------- // // Convert String in Hex Notation to byte Array // private static byte[] hexStr2byteArr(String hexStr) { int ArrLen = hexStr.length()/2; byte[] byteArr = new byte[ArrLen]; for (int i=0; i= 60-Bit of Entropy. int i, n, j, k, t; // Prefill the Arrays for (i=0; i<256; i++) { z[i] = i; x[i] = i; } a=0; b=0; j=0; k=0; n=0; t=0; for (i=0; i<256; i++) { k = (i % KeyWord.length); for (n=0; n<128; n++) t = PRGA() & 0xff; j = (t + j + z[i] + KeyWord[k]) & 0xff; swap(z, i, j); // z[i] <==> z[j] for (n=0; n<128; n++) t = PRGA() & 0xff; j = (t + j + x[i] + z[x[j]]) & 0xff; swap(x, i, j); // x[i] <==> x[j] } // Reset the Array Indices Start Point a=0; b=0; } //----------------------------------------- // // Pseudo Random Generation Algorithm (ps) // public static int PRGA() { int n1, n2, y, m; // Calculate distant Array Element Indices n1 = (z[a] + x[a]) & 0xff; n2 = (z[b] + x[b]) & 0xff; // First Swap randomly selected Array Element swap(z, a, n1); // z[a] <==> z[n1] swap(x, a, n2); // x[a] <==> x[n2] // Update the global Carry on Array Indices a = (a + b + (n1^n2)) & 0xff; b = (b + 1) & 0xff; // Second Swap sequentially cycle over every Array Element swap(z, b, n1); // z[b] <==> z[n1] swap(x, b, n2); // x[b] <==> x[n2] // Calculate the internal State Selector Value y = (z[n1] ^ x[n2]) & 0xff; // Calculate the internal State Protection Value m = (n1 + n2) & 0xff; // Never reveal internal State Values directly return (z[x[y]] ^ m) & 0xff; } }