SBox8 - Stream Cipher Algorithm

=========================================================================

This is a proposal for a finite internal state CSPRNG that is based
entirely on 8 bit arithmetic and permutation shuffle.

The algorithm consist of three different functions

1) PIA, the permutation initialisation algorithm

2) KSA, the key schedule algorithm

3) PRGA, the pseudo-random generation algorithm

The initialisation of this CSPRNG is somewhat different to other
permutation based CSPRNG, because it does not use a sequentially
initialised permutation from the start.

In contrast the permutation array of SBox8 is first initialised passing
a 32bit seed to the permutation initialisation algorithm (PIA). This
function will generate a pre-shuffled pseudo-random permutation.

In a second step the key byte are now injected into the pre-shuffled
permutation array, using the key schedule algorithm (KSA). The key byte
used are independent from the seed byte.

The output of the keystream encrypting all zero is indistinguishable
from randomness for up to 2**39bit (64 GB). Recently tested using the
bookstack test [1] which reveals the massive bias of RC4 and ZK-Crypt.

Furthermore this algorithm also pass all statistical tests for
randomness without failure and can be considered as unbiased. The
formulae below passes Qualcomms's bias test, John Walker's ENT, Maurer's
Universal test for random bits, show a well uniform distribution
regarding Winston Rayburn's bit analysis and pass all tests off Pierre
L'Ecuyer test suite TestU01, which are SmallCrush, Crush and BigCrush.



This is the algorithm of SBox8


<?//========================================================================

//
// All arithmetic is performed modulo 256.
//
#define swap(X,Y) { uint8_t T = X; X = Y; Y = T; }

static uint8_t  a, b, c, d, j;
static uint8_t  SBox[256];

//-----------------------------------------
// PIA = Permutation Initialisation Algorithm
//
void SBox8_PIA(uint32_t seed) {

  if (seed == 0) {
    a = 14;
    b = 59;
    c = 23;
    d = 77; 
  } else {  
    a = ( seed        & 0xff);
    b = ((seed >>  8) & 0xff);
    c = ((seed >> 16) & 0xff);
    d = ((seed >> 24) & 0xff);
  }

  // Shifting to the next odd Value of each Variable
  // in Order to generate an alternating Permutation
  uint8_t t = ((b ^ c) + d);
  t |= 1;

  // Initialise the alternating Permutation
  // into the internal State Array
  for (int i=0; i<256; i++) {
    a += t;
    SBox[i] = a;
  }

  // a,b and c are not explicitly set to zero
  // but keep on carrying over their values
}

//-----------------------------------------
// KSA = Key Schedule Algorithm
//
void SBox8_KSA(uint8_t key[], uint8_t keyLen) {

  // Shuffle the Key into the Permutation
  // of the internal State Array
  for (int i=0; i<256; i++) {
    d  = i % keyLen;
    
    a += SBox[b];
    b += SBox[a];
    c  = a + b + i + key[d];
    
    swap(SBox[c], SBox[i]);   
  }
  
  // a,b and c are not explicitly set to zero
  // but keep on carrying over their values
  j=0;
}

//-----------------------------------------
// PRGA = Pseudo-Random Generation Algorithm
//
uint8_t SBox8_PRGA() {
  a += SBox[b];
  b += SBox[a];
  c  = a + b + j + SBox[j];
  
  swap(SBox[c], SBox[j]);   

  d  = SBox[(SBox[c] + SBox[d]) &0xff];
  
  j++;

  return ((a + b) ^ (c + d));
}

//========================================================================?>

For convenience some test results. The source code for verifying as well
as the used test seeds and keys including all results in detail can be
found over here

http://www.freecx.co.uk/crypto/SBox8/Bookstack_tests_results/


# Comparing SBox8 against RC4

Table 1:
--------
Number of files generated by SBox8 and recognized as non-random (from 100)
Test run with the book stack parameter  "-w 16 -u 16 -q"

 SBox8
+--------------------------------------------------------------------------+
|Length(bit)|2**31 |2**32 |2**33 |2**34 |2**35 |2**36 |2**37 |2**38 |2**39 |
+--------------------------------------------------------------------------+
|Non-random |    5 |    4 |    2 |    3 |    6 |    8 |    7 |    7 |    4 |
+--------------------------------------------------------------------------+


Table 2: 
--------
Number of files generated by RC4 and recognized as non-random (from 100)
Test run with the book stack parameter  "-w 16 -u 16 -q"

 RC4
+--------------------------------------------------------------------------+
|Length(bit)|2**31 |2**32 |2**33 |2**34 |2**35 |2**36 |2**37 |2**38 |2**39 |
+--------------------------------------------------------------------------+
|Non-random |    4 |    6 |   10 |   23 |   44 |   70 |   98 |   99 |  100 |
+--------------------------------------------------------------------------+




# Comparing SBox8 against ZK-Crypt

Table 3: 
--------
Number of files generated by SBox8 and recognized as non-random (from 100)
Test run with the book stack parameter  "-w 32 -u 65536 -q"

 SBox8
+-------------------------------------------------------------------+
|Length(bit)|2**24 |2**26 |2**28 |2**30 |2**31 |2**32 |2**33 |2**34 |
+-------------------------------------------------------------------+
|Non-random |    2 |    4 |    4 |    3 |    3 |    2 |    3 |    4 |
+-------------------------------------------------------------------+



Table 4:
--------
Number of files generated by ZK-Crypt and recognized as non-random (from 100)
This test had used the book stack parameter  "-w 32 -u 65536 -q" 
Parameters and results of ZK-Crypt as described in [3]

 ZK-Crypt
+-------------------------------------------------------------------+
|Length(bit)|2**24 |2**26 |2**28 |2**30 |2**31 |2**32 |2**33 |2**34 |
+-------------------------------------------------------------------+
|Non-random |   25 |   51 |   97 |  100 |  n/t |  n/t |  n/t |  n/t |
+-------------------------------------------------------------------+
 [ n/t = not tested ]

^ Top