Merry Christmas! #11
LCC
http://www.youtube.com/watch?v=fussEgy_j5M
Rather than link to my original post "Merry Christmas 2", here is the
precise same text. This specification provided a technique for
generating tables of random number seeds from an agreed upon master
password string, using a shared implementation of the specified
algorithm. Since implementations will probably differ from one
programmer to another, it cannot be assumed that a password string
will always generate the same tables of random number seeds...
I hereby declare that this specification is not copyrighted or
patented. As a product of my imagination, I offer it free of charge as
a "public domain" entity, to be redistributed freely. So copy this
post to your websites anytime you please. Develop front end processes
for password usage from it if you so desire, because there are no
license fees involved.
This is a specification for converting an ASCII password string into
a larger byte string which can be used to initialize an array of
random number seeds. A neural net is the basis for the concepts given.
A "node" is the data processing and state vector component of the
system. A "nexus" is the derived set of links for each node. For each
node there are up to 26 active links in its nexus. The network
occupies a three dimensional cube with sides of length six. In the two
dimensional example given, node 01 is the network input node and node
18 is the network output node. Node 01 links to nodes 02, 03, and 04.
Node 05 links to nodes 02, 03, 04, 06, 07, 10, 11, and 12 etc.
++++++++++++++++++ 01 ++++++++++++++++++
++++++++++++++ 04 = 02 = 03 +
+++++++++++++
++++++++++ 09 = 06 = 05 = 07 = 08 ++++++++++
+++++++++
+ 14 = 11 = 10 = 12 = 13 ++++++++++
++++++++++++++ 17 = 15 = 16 ++++++
++++++++
++++++++++++++++++ 18 ++++++++++++++++++
The password string is a series of byte values which are used to
initialize the net. Each byte is converted to a set of coordinates
within the net for placement of the next node. This is done by taking
the remainder after division (by six) of the byte value for the "x"
coordinate (value 0-5). Then division of the byte value by thirty six
is used to obtain the "y" coordinate (value 0-5) from the remainder.
The "z" coordinate is the value obtained from division by thirty six
of the byte value. Once all nodes have been selected from the seeding
password string, the nodes are linked as an initial nexus network to
their nearest neighbors in the x,y, and z coordinates. The 64 bit
state vector of each used node is initialized (going from 0,0,0
towards 5,5,5) to the eight bytes of the password string beginning at
the first byte and wrapping around (when necessary) from the last back
to the first. So as an example, if the password string is 11
characters, the first node found gets the bytes 0-7 in its state
vector, the fifth node found gets bytes 4-10 then 0... Once all
initialization nodes have the state vector initialized, the password
string is submitted to the net eight bytes at a time at the node
closest to 0,0,0 (wrapping around when necessary). Each of the nodes'
inputs 64 bits are xored with the node's state vector to produce a new
state vector, and the node's output value is the bitwise "not" of the
final result after all inputs are processed. Inputs come from the
closest neighbors in x,y,z coordinates which have a lower coordinate
value, while outputs are clocked to the closest neighbors in x,y,z
coordinates which have a higher coordinate value. So information
propagates from 0,0,0 towards 5,5,5.
The neural net nexus is rewired to have new nodes based upon the final
output node's value. As the net evolves, the input and output nodes
are revised to pick the closest nodes to 0,0,0 and 5,5,5. For each
clock cycle the eight byte output node result is converted byte by
byte into eight new nodes' x,y,z coordinates as specified above (/6
then /36). If the net already contains a node at the specified
coordinates, no action is taken. Otherwise the new node gets its state
vector initialized to the current value of the output node shifted
circularly right by a distance depending upon which byte is currently
being processed. The nexus of the new node is connected up to nearest
neighbors and those neighbors are revised to access the new node in
addition to the existing links. When TBD cycles pass without a new
node being added, this phase of filling in the network ends. Then the
latest output node is connected to the input, and each clock cycle of
the net produces a 64 bit number to be used as a random number seed.
Alternatively, a second (larger) neural net can be built from the
outputs of the current net, relatively disengaging dependency upon the
original password string to form a new neural net for use in
generating random number seeds.
-----------------------------------------------------------
Merry Christmas 11 specification
Table - 1 Bit transpositions
From the first random number seed, generate a 256x256x256 array of
unduplicated 24 bit values. An easy way to do that is a diminishing
size single dimensional vector. Initialize the vector with each value
equal to its own 24 bit index. The index of the selected value to be
obtained from the vector is the current pseudo random number generated
from the seed modulo the number of entries remaining in the vector. As
each value is pulled from the vector, the current size of the
remaining vector is decremented by one, then the contents of the
vector at that index are used to overwrite the vector at the same
index as the value just now pulled from the vector. As values are
pulled from the vector, it evolves from an ordered sequence into
something more closely resembling randomness, so that it does not even
resemble a copy of the 24 bit stream generated by the first random
number seed.
Each 24 bit value in the table specifies 4 pairs of 3 bits each. Each
pair gives the two indexes for bits to be swapped. The current value
of the output byte is processed in the specified SEQUENCE of swaps. As
an example (3,4)->(2,7)->(4,2)->(5,7) is NOT the same as (2,7)->(4,2)-
>(5,7)->(3,4)
A bit might be swapped with itself four times, which will occur 8/16
million times, not a problem..
Table - 2 - Preceding 3 bytes for initializing each code block
From the second random number seed, generate a 256x256x256 array of
unduplicated 24 bit values. Same technique as for table 1…
Table - 3 Bit shuffle mappings
From the third random number seed, generate another 256x256x256 array
of 24 bit values using the diminishing table technique specified for
table 1. In this case however, the vector is initialized with 416.1
copies of the 8 factorial=40320 possible mappings of an 8 bit input
into an 8 bit output.
Each 24 bit value gives 8 values of 3 bits - the output bits for bits
0 through 7, with no duplicate mappings in the set of 40320.
Table - 4 - Indexes to bit mappings table
From the fourth random number seed, generate a 256x256x256 array of
unduplicated 24 bit values. Same technique as for table 1…
Now we are ready to get rolling.
a) Using the fifth random number seed, generate a pseudo random number
sequence. The 24 LSB of the current value in the random sequence is
used to index table 4.
b) The 24 bit value looked up in table 4 is used to index table 3.
c) Using the value from table 3 do a bit shuffle of the current
message byte.
d) Use the preceding three UNCODED bytes of the current message block
to generate an index to table 1, taking values from table 2 if the
current position is at the start of a block, the index to table 2
being the table 4 value, or something more complicated…
e) Use the 24 bit value looked up in table 1 to transpose bits of the
current output byte, beginning with the value from step c, in the
specified sequence. This is a second bit reorganization, which some
might consider redundant. Note however that an entirely different
random number seed was used to generate tables 1 and 3. It might seem
a bit Baroque, but I consider this level of indirection to be the
redeeming virtue of this specification…
f) Generate the message output stream as a set of code blocks of
variable size, with the size of the code blocks being determined in
whatever manner you please, for example derived from the random number
sequence generated by the sixth random number seed.
g) If you want to get Baroque, you could put a clear text time stamp
at the start of each output message giving a time at which the coded
message was generated. Using the time stamp, you could have modified
the original shared password depending upon time of encryption so that
the pair of you are not always using the same data tables to encrypt/
decrypt your messages.
-----------------------------------------------------------
So here you are as the recipient with a file which you know how to
divide into code blocks, using the same technique as step f. You have
used your shared password string (perhaps modified using the step g
agreed upon technique) to generate the same tables as the sender of
the coded file. You have generated the same sequence of pseudo random
numbers using the fifth random number seed. For each coded byte you do
the following :
a) Using the current value in the pseudo random number sequence,
lookup a value from table 4, and from table 2 if at the start of a
code block.
b) If at the start of a code block, generate an index to table 1 using
the table 2 value, otherwise use the preceding three bytes of the
DECODED message to index table 1.
c) Use the value from table 1 to perform four transpositions of bits
(of the current encoded byte within a block) in the opposite sequence
from the one used to encode the byte to produce an untransposed
encoded byte. If the originator used a big-endian sequence, then you
use little-endian, and vice-versa.
d) Use the value from table 3 indexed by table 4 to perform the
inverse shuffle of the untransposed encoded byte, so that you have the
decoded original message byte at the current position in the message
block.
e) Keep track of the three DECODED bytes preceding the current byte in
the message block, so that you have the proper indexes to table 1.
No one has ever contacted me or sent money as compensation for
previous specifications, so I won't bother to ask…
Lonnie Courtney Clay
LCC
think that they would have to do bit operations at run time in order
to implement this specification. What I suggest is that you should
generate data tables which provide the output byte for a given input
byte. These transformation tables are NOT random in any way
whatsoever, so the data arrays could be hard-coded at compile time.
You write a program to generate the tables, then use its output in the
compilation process…
In the case of a bit shuffle, you generate a 40320x256 entry array of
byte size giving the output byte for each possible combination of
shuffle and input byte.
In the case of bit transpositions, you generate an 8x8x256 entry array
of byte size giving the output byte for each possible combination of
transposition and input byte.
bit shuffle arrays :
out = t(shuffle,in) the value of tin(shuffle,out) is generated at the
same time as you setup t(shuffle,in) where tin(shuffle,out) = in
==> in = tin(shuffle,out)
Same deal for the transpose arrays :
out = b(b1,b2,in) the value of bin(b1,b2,out) is generated at the same
time as you setup b(b1,b2,in) where bin(b1,b2,out) = in
==> in = bin(b1,b2,out)
Lonnie Courtney Clay
LCC
Upon further consideration, it might be helpful to specify how to
obtain the values of the 40320x256 entry arrays. I whipped this up in
a 10 hour session. I have not written any code in ANY language since
1992, so this is pseudo code, needing corrections perhaps. But any
competent programmer /mathematician should be able to figure it out…
byte table0(8),table1(8),table2(8),table3(8),table4(8),table5(8);
unsigned index0,index1,index2,index3,index4,index5,index6;
unsigned i,j,k,l,m,n,p,q,r,x,b0,b1,b2,b3,b4,b5,b6,b7;
unsigned i0,i1,i2,i3,i4,i5,i6,i7,y,z,z1,z2;
BOOLEAN x_flag(9);
byte shuffle(40320)(8),inverse_shuffle(40320)(8);
byte lookup(40320)(256), inverse_lookup(40320)(256);
x_flag(8) = TRUE;/* saves some code on infinite do loop control */
for(i=0; i<8; i++;)
{
for(r=0; r<8; r++;)
{
x_flag[r] = FALSE;
};
index0 =i*5040;
table0[0] = i;
x_flag[table0[0]] = TRUE;
q = 0;
for(r=1; r<8; r++;)
{
do
{
if(x_flag[q])
{
q++;
}
else
{
break;
};
};
table0[r]= q;
q++;
};
for(j=1; j<8; j++;)
{
index1 =(j-1)*720 + index0;
table1[1] = table0[j];
x_flag[table1[1]] = TRUE;
q = 0;
for(r=2; r<8; r++;)
{
do
{
if(x_flag[q])
{
q++;
}
else
{
break;
};
};
table1[r]= table0[q];
q++;
};
for(k=2; k<8; k++;)
{
index2 = (k-2)*120 + index1;
table2[2] = table1[k];
x_flag[table2[2]] = TRUE;
q = 0;
for(r=3; r<8; r++;)
{
do
{
if(x_flag[q])
{
q++;
}
else
{
break;
};
};
table2[r]= table1[q];
q++;
};
for(l=3; l<8; l++;)
{
index3 =(l-3)*24 + index2;
table3[3] = table2[l];
x_flag[table3[3]] = TRUE;
q = 0;
for(r=4; r<8; r++;)
{
do
{
if(x_flag[q])
{
q++;
}
else
{
break;
};
};
table3[r]= table2[q];
q++;
};
for(m=4; m<8; m++;)
{
index4 = (m-4)*6 + index3;
table4[4] = table3[m];
x_flag[table4[4]] = TRUE;
q = 0;
for(r=5; r<8; r++;)
{
do
{
if(x_flag[q])
{
q++;
}
else
{
break;
};
};
table4[r]= table3[q];
q++;
};
for(n=5; n<8; n++;)
{
index5 = (n-5)*2 + index4;
index6 = index5 +1;
table5[5] = table4[n];
x_flag[table5[5]] = TRUE;
q = 0;
for(r=6; r<8; r++;)
{
do
{
if(x_flag[q])
{
q++;
}
else
{
break;
};
};
table5[r]= table4[q];
q++;
};
/* Let's do it! - the bit map is specified by
table0[0], table1[1], table2[2], table3[3], table4[4],table5[5]
with two combinations of table5[6],table5[7] and table5[7],table5[6]
*/
b0 = table0[0];
b1 = table1[1];
b2 = table2[2];
b3 = table3[3];
b4 = table4[4];
b5 = table5[5];
b6 = table5[6];
b7 = table5[7];
shuffle[index6][0]=shuffle[index5][0]=b0;
shuffle[index6][1]=shuffle[index5][1]=b1;
shuffle[index6][2]=shuffle[index5][2]=b2;
shuffle[index6][3]=shuffle[index5][3]=b3;
shuffle[index6][4]=shuffle[index5][4]=b4;
shuffle[index6][5]=shuffle[index5][5]=b5;
shuffle[index6][7]=shuffle[index5][6]=b6;
shuffle[index6][6]=shuffle[index5][7]=b7;
inverse_shuffle[index6][b0]=inverse_shuffle[index5][b0]=0;
inverse_shuffle[index6][b1]=inverse_shuffle[index5][b1]=1;
inverse_shuffle[index6][b2]=inverse_shuffle[index5][b2]=2;
inverse_shuffle[index6][b3]=inverse_shuffle[index5][b3]=3;
inverse_shuffle[index6][b4]=inverse_shuffle[index5][b4]=4;
inverse_shuffle[index6][b5]=inverse_shuffle[index5][b5]=5;
inverse_shuffle[index6][b7]=inverse_shuffle[index5][b6]=6;
inverse_shuffle[index6][b6]=inverse_shuffle[index5][b7]=7;
y = 0;
for (i0=0; i0<2; i0++;)
{
for (i1=0; i1<2; i1++;)
{
for (i2=0; i2<2; i2++;)
{
for (i3=0; i3<2; i3++;)
{
for (i4=0; i4<2; i4++;)
{
for (i5=0; i5<2; i5++;)
{
for (i6=0; i6<2; i6++;)
{
for (i7=0; i7<2; i7++;)
{
z = i0 <<b0 + i1 <<b1 + i2 << b2 + i3 << b3 + i4 << b4 + i5 << b5;
z1 = z + i6<< b6 + i7 << b7;
z2 = z + i6<< b7 + i7 << b6;
lookup[index5][y]= z1;
lookup[index6][y]= z2;
inverse_lookup[index5][z1] = y;
inverse_lookup[index6][z2] = y;
y++;
};/* i7 */
};/* i6 */
};/* i5 */
};/* i4 */
};/* i3 */
};/* i2 */
};/* i1 */
};/* i0 */
/* IT is DONE! */
x_flag[table5[5]] = FALSE;
};/* end table5 */
x_flag[table4[4]] = FALSE;
};/* end table4 */
x_flag[table3[3]] = FALSE;
};/* end table3 */
x_flag[table2[2]] = FALSE;
};/* end table2 */
x_flag[table1[1]] = FALSE;
};/* end table1 */
};/* end table0 */
0,1,2,3,4,5,6,7 entry 0
0,1,2,3,4,5,7,6
0,1,2,3,4,6,5,7
0,1,2,3,4,6,7,5
0,1,2,3,4,7,5,6
0,1,2,3,4,7,6,5
0,1,2,3,5,4,6,7 entry 6
0,1,2,3,5,4,7,6
0,1,2,3,5,6,4,7
0,1,2,3,5,6,7,4
0,1,2,3,5,7,4,6
0,1,2,3,5,7,6,4
=====>
0,1,2,3,7,6,5,4 entry 23
=====>
0,1,2,7,6,5,4,3 entry 119
=====>
0,1,7,6,5,4,3,2 entry 719
=====>
0,7,6,5,4,3,2,1 entry 5039
1,0,2,3,4,5,6,7 entry 5040
2,0,1,3,4,5,6,7 entry 10080
3,0,1,2,4,5,6,7 entry 15120
4,0,1,2,3,5,6,7 entry 20160
5,0,1,2,3,4,6,7 entry 25200
6,0,1,2,3,4,5,7 entry 30240
7,0,1,2,3,4,5,6 entry 35280
7,6,5,4,3,2,1,0 entry 40319
Lonnie Courtney Clay