This cipher is unpatented and free to use in your own programs. (the cipher, not the actual code from StealthMail)

Designed and published in 1996, the LeapFrog cipher design is for implementations that require a cipher which does not use any shifts/rotates. The user-entered key is expanded into S-boxes using a non-linear method somewhat similar to the stream cipher RC4. The diffusion is provided by compound lookups into the S-boxes. The cipher is implemented with a Feistel-like structure. Three bytes on the left are mixed through the S-box function and combined with a target byte on the right using the Xor operator. This is used for each of the four target bytes on the right. Using asymmetry in the function, groups of two and three are selected to provide maximal diffusion. Also, each byte on the left is added to its opposite on the right. Thus, the round function consists of four parallel functions which look like the parity function in MD5, but using the noted lookups, and also the add operations. Note that the Xor/Add combination create a Feistel cipher that is NOT self-inverse with an odd number of rounds. Also, the cipher uses distinct S-boxes for each half of the Feistel network, and halves are not actually swapped. How the LeapFrog2 cipher differs from the LeapFrog cipher: 1) Instead of simple whitening Xors LeapFrog2 uses pseudo-random round keys like Blowfish, etc. 2) The structural symmetry is broken up by using a different ordering in rounds 0-3 and rounds 4-7. (the hash function MD5 uses something similar) This is commentary regarding the LeapFrog2 cipher. The origin of the cipher is of a graphical nature. Consider a Blowfish-like function where four 8x32 lookups are Xored together. Ignore the fact that Blowfish also employs a 32-bit add. In that case, rather than Xoring the four 32-bit values together, you could (using groups of four bytes) Xor four bytes together, and Xor them with the other half. (using 16-bytes per round) You could think of it like Blowfish structured "backwards". You could then build a cipher to have more non-linearity than a Blowfish design. The LeapFrog design builds on this idea using compound (chained) substitutions. This function is similar to the key-expansion function in Twofish. (Although it is used for an entirely different purpose.) The LeapFrog design may look somewhat similar to a Skipjack-like or RC2-like design, except that LeapFrog uses S-boxes, not pure math, as the diffusion element. Also, LeapFrog uses a balanced Feistel network, not an unbalanced one like those ciphers or MacGuffin. LeapFrog diffusion is complete at 3 rounds like Blowfish. Note that the LeapFrog design blurs the destinction between nonlinear substitution and diffusion. To diffuse a block, why would you restrict the design to use only 2-in/2-out diffusion blocks. Why not make it cubic, or use even more dimensions? As stated, LeapFrog accomplishes this using compound or "chained" S-boxes. Unlike the original work of Ritter, the S-box diffusion in LeapFrog is all non-linear. Using the Feistel design, LeapFrog decryption does not need to employ inverse S-boxes. Also, some key-independent diffusion is provided by the add operation across the block halves. The add operation also has the effect of making a Feistel cipher not self-inverse with an odd number of rounds. Key-expansion: You could view the key-expansion code in LeapFrog as combining elements from ones employed in RC4 and Diamond2. The key entropy is mainly expressed in the S-boxes, not the subkeys. Although in LeapFrog2, the "subkeys" are non-cyclical like the ones employed in Blowfish. It should be noted that this analysis is entirely retrospective. I did not know of most of these cipher designs when I designed LeapFrog. I am not providing any differential or linear analysis here, you can do that for yourself. You might trust your own abilities more than my own. This is a TYPO-CORRECTED pseudo-code example showing the LeapFrog2 block-cipher. It uses a 64-bit block and a variable-bit key. T1, T2, T3, T4 are signed integers p1....p8 are signed integers Subroutine LeapFrogEncrypt For BlockNumber = 1 To Blocks * read plaintext block into p1....p8 * LeapFrogRounds are 8 For x = 0 To (LeapFrogRounds / 2) - 1 * create the T variables T1 = A1(p1 Xor SK(x, 0)) T2 = A2(p2 Xor SK(x, 1)) T3 = A3(p3 Xor SK(x, 2)) T4 = A4(p4 Xor SK(x, 3)) * T variable order "A" p5 = p5 Xor A1(A1(T2 Xor T3) Xor T4) p6 = p6 Xor A2(A2(T1 Xor T4) Xor T3) p7 = p7 Xor A3(A3(T4 Xor T2) Xor T1) p8 = p8 Xor A4(A4(T3 Xor T1) Xor T2) p5 = (p5 + T1) And HFF p6 = (p6 + T2) And HFF p7 = (p7 + T3) And HFF p8 = (p8 + T4) And HFF * do other half without swapping T1 = A5(p5 Xor SK(x, 4)) T2 = A6(p6 Xor SK(x, 5)) T3 = A7(p7 Xor SK(x, 6)) T4 = A8(p8 Xor SK(x, 7)) p1 = p1 Xor A5(A5(T2 Xor T3) Xor T4) p2 = p2 Xor A6(A6(T1 Xor T4) Xor T3) p3 = p3 Xor A7(A7(T4 Xor T2) Xor T1) p4 = p4 Xor A8(A8(T3 Xor T1) Xor T2) p1 = (p1 + T1) And HFF p2 = (p2 + T2) And HFF p3 = (p3 + T3) And HFF p4 = (p4 + T4) And HFF Next For x = (LeapFrogRounds / 2) To (LeapFrogRounds - 1) * create the T variables T1 = A1(p1 Xor SK(x, 0)) T2 = A2(p2 Xor SK(x, 1)) T3 = A3(p3 Xor SK(x, 2)) T4 = A4(p4 Xor SK(x, 3)) * T variable order "B" p5 = p5 Xor A1(A1(T2 Xor T3) Xor T4) p6 = p6 Xor A2(A2(T3 Xor T4) Xor T1) p7 = p7 Xor A3(A3(T4 Xor T1) Xor T2) p8 = p8 Xor A4(A4(T1 Xor T2) Xor T3) p5 = (p5 + T1) And HFF p6 = (p6 + T2) And HFF p7 = (p7 + T3) And HFF p8 = (p8 + T4) And HFF * do other half without swapping T1 = A5(p5 Xor SK(x, 4)) T2 = A6(p6 Xor SK(x, 5)) T3 = A7(p7 Xor SK(x, 6)) T4 = A8(p8 Xor SK(x, 7)) p1 = p1 Xor A5(A5(T2 Xor T3) Xor T4) p2 = p2 Xor A6(A6(T3 Xor T4) Xor T1) p3 = p3 Xor A7(A7(T4 Xor T1) Xor T2) p4 = p4 Xor A8(A8(T1 Xor T2) Xor T3) p1 = (p1 + T1) And HFF p2 = (p2 + T2) And HFF p3 = (p3 + T3) And HFF p4 = (p4 + T4) And HFF Next * whiten data p1 = p1 Xor SK(LeapFrogRounds, 0) p2 = p2 Xor SK(LeapFrogRounds, 1) p3 = p3 Xor SK(LeapFrogRounds, 2) p4 = p4 Xor SK(LeapFrogRounds, 3) p5 = p5 Xor SK(LeapFrogRounds, 4) p6 = p6 Xor SK(LeapFrogRounds, 5) p7 = p7 Xor SK(LeapFrogRounds, 6) p8 = p8 Xor SK(LeapFrogRounds, 7) * write ciphertext block from p1....p8 Next End Subroutine LeapFrogEncrypt Subroutine LeapFrogDecrypt For BlockNumber = 1 To Blocks * read ciphertext block into p1....p8 * unwhiten data p1 = p1 Xor SK(LeapFrogRounds, 0) p2 = p2 Xor SK(LeapFrogRounds, 1) p3 = p3 Xor SK(LeapFrogRounds, 2) p4 = p4 Xor SK(LeapFrogRounds, 3) p5 = p5 Xor SK(LeapFrogRounds, 4) p6 = p6 Xor SK(LeapFrogRounds, 5) p7 = p7 Xor SK(LeapFrogRounds, 6) p8 = p8 Xor SK(LeapFrogRounds, 7) For y = 0 To (LeapFrogRounds / 2) - 1 * invert subkeys x = (LeapFrogRounds - 1) - y * create the T variables T1 = A5(p5 Xor SK(x, 4)) T2 = A6(p6 Xor SK(x, 5)) T3 = A7(p7 Xor SK(x, 6)) T4 = A8(p8 Xor SK(x, 7)) * T variable order "B" p1 = (p1 - T1) And HFF p2 = (p2 - T2) And HFF p3 = (p3 - T3) And HFF p4 = (p4 - T4) And HFF p1 = p1 Xor A5(A5(T2 Xor T3) Xor T4) p2 = p2 Xor A6(A6(T3 Xor T4) Xor T1) p3 = p3 Xor A7(A7(T4 Xor T1) Xor T2) p4 = p4 Xor A8(A8(T1 Xor T2) Xor T3) * do other half without swapping T1 = A1(p1 Xor SK(x, 0)) T2 = A2(p2 Xor SK(x, 1)) T3 = A3(p3 Xor SK(x, 2)) T4 = A4(p4 Xor SK(x, 3)) p5 = (p5 - T1) And HFF p6 = (p6 - T2) And HFF p7 = (p7 - T3) And HFF p8 = (p8 - T4) And HFF p5 = p5 Xor A1(A1(T2 Xor T3) Xor T4) p6 = p6 Xor A2(A2(T3 Xor T4) Xor T1) p7 = p7 Xor A3(A3(T4 Xor T1) Xor T2) p8 = p8 Xor A4(A4(T1 Xor T2) Xor T3) Next For y = (LeapFrogRounds / 2) To (LeapFrogRounds - 1) * invert subkeys x = (LeapFrogRounds - 1) - y * create the T variables T1 = A5(p5 Xor SK(x, 4)) T2 = A6(p6 Xor SK(x, 5)) T3 = A7(p7 Xor SK(x, 6)) T4 = A8(p8 Xor SK(x, 7)) * T variable order "A" p1 = (p1 - T1) And HFF p2 = (p2 - T2) And HFF p3 = (p3 - T3) And HFF p4 = (p4 - T4) And HFF p1 = p1 Xor A5(A5(T2 Xor T3) Xor T4) p2 = p2 Xor A6(A6(T1 Xor T4) Xor T3) p3 = p3 Xor A7(A7(T4 Xor T2) Xor T1) p4 = p4 Xor A8(A8(T3 Xor T1) Xor T2) * do other half without swapping T1 = A1(p1 Xor SK(x, 0)) T2 = A2(p2 Xor SK(x, 1)) T3 = A3(p3 Xor SK(x, 2)) T4 = A4(p4 Xor SK(x, 3)) p5 = (p5 - T1) And HFF p6 = (p6 - T2) And HFF p7 = (p7 - T3) And HFF p8 = (p8 - T4) And HFF p5 = p5 Xor A1(A1(T2 Xor T3) Xor T4) p6 = p6 Xor A2(A2(T1 Xor T4) Xor T3) p7 = p7 Xor A3(A3(T4 Xor T2) Xor T1) p8 = p8 Xor A4(A4(T3 Xor T1) Xor T2) Next * write plaintext block from p1....p8 Next End Subroutine LeapFrogDecrypt Subroutine LeapFrogExpandKey * replicate key into array y = 0 For x = 0 To 255 LongKey(x) = k(y) y = (y + 1) Mod RealKeyLen Next * initialize expanded key arrays For i = 0 To 255 A1(i) = i, A5(i) = i A2(i) = i, A6(i) = i A3(i) = i, A7(i) = i A4(i) = i, A8(i) = i Next j = 0 * randomize array For i = 0 To 255 j = (j + A1(i) + LongKey(i)) And HFF Exchange A1(i), A1(j) Next For i = 0 To 255 j = (j + A1(i)) And HFF, Exchange A1(i), A1(j) Next * randomize the other arrays For i = 0 To 255 j = (j + A1(A2(i)) + A1(LongKey(i))) And HFF Exchange A2(i), A2(j) Next For i = 0 To 255 j = (j + A2(A3(i)) + A2(LongKey(i))) And HFF Exchange A3(i), A3(j) Next For i = 0 To 255 j = (j + A3(A4(i)) + A3(LongKey(i))) And HFF Exchange A4(i), A4(j) Next For i = 0 To 255 j = (j + A4(A5(i)) + A4(LongKey(i))) And HFF Exchange A5(i), A5(j) Next For i = 0 To 255 j = (j + A5(A6(i)) + A5(LongKey(i))) And HFF Exchange A6(i), A6(j) Next For i = 0 To 255 j = (j + A6(A7(i)) + A6(LongKey(i))) And HFF Exchange A7(i), A7(j) Next For i = 0 To 255 j = (j + A7(A8(i)) + A7(LongKey(i))) And HFF Exchange A8(i), A8(j) Next * store zeros to SK array * make subkeys from S-boxes For i = 0 To 63 SK(0, 0) = (SK(0, 0) + A1(i)) And HFF SK(0, 1) = (SK(0, 1) + A2(i)) And HFF SK(0, 2) = (SK(0, 2) + A3(i)) And HFF SK(0, 3) = (SK(0, 3) + A4(i)) And HFF SK(0, 4) = (SK(0, 4) + A5(i)) And HFF SK(0, 5) = (SK(0, 5) + A6(i)) And HFF SK(0, 6) = (SK(0, 6) + A7(i)) And HFF SK(0, 7) = (SK(0, 7) + A8(i)) And HFF Next For i = 0 To LeapFrogRounds - 1 SK(i + 1, 0) = (SK(i, 0) + A1(64 + i)) And HFF SK(i + 1, 1) = (SK(i, 1) + A2(64 + i)) And HFF SK(i + 1, 2) = (SK(i, 2) + A3(64 + i)) And HFF SK(i + 1, 3) = (SK(i, 3) + A4(64 + i)) And HFF SK(i + 1, 4) = (SK(i, 4) + A5(64 + i)) And HFF SK(i + 1, 5) = (SK(i, 5) + A6(64 + i)) And HFF SK(i + 1, 6) = (SK(i, 6) + A7(64 + i)) And HFF SK(i + 1, 7) = (SK(i, 7) + A8(64 + i)) And HFF Next For i = 0 To LeapFrogRounds SK(i, 0) = A5(SK(i, 0)) SK(i, 1) = A6(SK(i, 1)) SK(i, 2) = A7(SK(i, 2)) SK(i, 3) = A8(SK(i, 3)) Next For i = 0 To LeapFrogRounds SK(i, 4) = A1(SK(i, 4)) SK(i, 5) = A2(SK(i, 5)) SK(i, 6) = A3(SK(i, 6)) SK(i, 7) = A4(SK(i, 7)) Next End Sub LeapFrogExpand