Merry Christmas 12
LCC
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 12 specification
1) This specification could use a hypercube of 64**4 as an example,
but generally speaking any B**N hypercube of sufficient size will do.
The coded value is a hypercube coordinate combined with an index to a
table at the coordinates. In order to attain maximum security, the
table should be of variable size, ranging from s-low to s-high. The
table contents at each coordinate are either the value of the uncoded
data, or the coordinates combined with index of another location in
the hypercube.
For this specification, the uncoded values are the set of 4-byte codes
obtained using the original "Merry Christmas" post provided in 2007,
which is much too lengthy to repeat here, so I will give a link to
sci.crypt July 23, 2007:
2) The total number of possible coded values is at least s-low*(B**N),
at most s-high*(B**N). The values for s-low and s-high should be
selected so that s-average*(B**N) is greater than the total number of
entries in the dictionary by a factor of at least two. I recommend
that s_average should NOT be simply half of s-low plus s-high. A good
choice for distribution would be obtained by constructing a constant
table whose contents are a Gaussian distribution ranging from s-low to
s-high, perhaps with s-low at the mean, and s-high occurring at 3
standard deviations above the mean. In such a table there would be
many entries at the start with value of s-low, and only one or two at
the end of value s-high.
3) Using the first random number seed, assign a table size between s-
low and s-high to all of the hypercube's nodes. You could do that by
taking each random number modulo the size of the Gaussian constant
table to lookup a table size for a node.
4) Step sequentially through the DICTIONARY using the current random
number to select the hypercube node and next unused table index to be
allocated for that uncoded value from the dictionary. (As each unused
index is used up, increment the index at the hypercube node table to
ensure that table overflow does not occur. If a table at the selected
coordinates is full, just discard the current random number and pull
another.) Initialize the head of a linked list for each dictionary
entry with the primary coded value (the hypercube node coordinates and
table index). The linked list heads are located in a table whose size
is the same as the number of entries in the dictionary.
5) Once all values in the dictionary have at least one coded
translation, then using the current random number, step sequentially
through the HYPERCUBE. At each hypercube coordinate, until the table
is filled, pull random numbers. For each random number, check whether
there is a matching uncoded 4 byte dictionary value. If so, then place
the hypercube coordinates (and table entry assigned) in the linked
list for the dictionary value as an alternative translation, and
continue onwards filling up the table at the current hypercube
coordinates. If the random number was NOT a valid dictionary code,
then translate it into the coordinates of an indirect reference
hypercube node (coordinates plus table index). If there is a
dictionary value in the table at the translated location, then place
the random number into the linked list for THAT dictionary value. If
there is a table entry pointing to another node, then keep looking
through the nodes until a valid dictionary value is found, then place
the random number into the linked list for THAT dictionary value. If
the random number resulted in a node coordinate and table index which
were not valid due to the table either not being filled in up to that
point or the index being greater than the table size, then discard the
current random number and pull another.
6) At this point you would have a variable number of table entries for
each node in the hypercube (giving either translations in the
dictionary table, or indirect references within the hypercube), and a
variable number of possible hypercube codes for each dictionary
(uncoded) value. For a given dictionary and password input to the
Merry Christmas 2 specified random number seed generator, the result
is deterministic.
7) Using the second random number seed and the stream of dictionary
codes in the message, construct an output stream. For a given
dictionary code, the coded output is determined by the random number
modulo the number of alternative translations in the linked list for
that dictionary code. To save execution time, you could reconstruct
the linked lists as a table of tables, rather than stepping though the
lists.
8) For decoding, translate the coded value into hypercube node
coordinates plus table index. If the value from the table is not a
valid dictionary code, then search through the indirect references
until a valid code is located…
9) At first glance, this might look like a simple translation process.
But each dictionary entry should have several different possible coded
values. Also there is no reason why the coordinates of a node and the
table entry should be simply concatenated to form a code value. For
example, the bits of those two components could be mixed together in
some way to form the coded value, costing greater execution time but
resulting in greater security…
Lonnie Courtney Clay