Thanks for the replies, folks!

Now I may be mistaken in what I'm about to write,

but I'm not sure that you've sufficiently digested

the descriptions in the source code of the program.

Here's a page where I spelled out more details of

what the program does, to prepare itself to do

encryption, than in my original post above:

http://www.halfbakery.com/idea/Primary_20Cryption#1099120544

But here I'll try to present the process as it

scrambles a single byte of data:

Imagine an Array of a (approximately at least) a

thousand division "scratchpads". Each scratchpad

has a "random"ly chosen prime divisor (ultimately

depending on the Key File), and a "random"ly chosen

dividend. The longer the Key File, the bigger this

Array, up to 65536 scratchpads. Four of the

scratchpads have special Control functionality.

Before scrambling our byte, we fetch 2 bits (via

division) from one Control scratchpad, to decide

"how many times will we do everything else". Values

0, 1, 2, 3 are converted into values 1, 2, 3, 2.

So, the Main Event will always be done once, often

twice, and sometimes thrice.

Within the Main Event, a second Control scratchpad

gives us 2 more bits, which determine "how many

specific scramblings will be done to the byte".

Values 0, 1, 2, or 3 will cause 2, 3, 4, or 5

scramble operations.

For each scramble operation, the third Control

scratchpad is tapped to provide 16 bits, which

are used as an Index into the main Array of

scratchpads. The program knows exactly how

many elements (N) of the Array are actually being

used, so the Modulus N of that 16-bit number

becomes the actual Index value. The Array

scratchpad at that Index location is tapped

(performs division) for 8 bits of scramble-data.

With respect to each particular current scramble-

operation, a fourth Control scratchpad is tapped

for 3 bits of data. One of eight different

operations will be done to our data-byte:

rotation, addition, subtraction, or exclusive-OR

-- or those same operations in conjuction with NOT.

So, here is a possible sequence in more detail:

First Control data: 2 Main Events

First Main Event:

Second Control data: 3 scramble operations

Frist scrambling:

Third Control data: access Array[529]

Fourth Control data: Add the 8 bits

Second scrambling:

Third Control data: access Array[933]

Fourth Control data: XOR the 8 bits

Third scrambling:

Third Control data: access Array[149]

Fourth Control data: Subtract, then NOT

Second Main Event:

Second Control data: 4 scramble operations

First scrambling:

Third Control data: access Array[58]

Fourth Control data: XOR, then NOT

Second scrambling:

Third Control data: access Array[863]

Fourth Control data: XOR the 8 bits

Third scrambling:

Third Control data: access Array[276]

Fourth Control data: Rotate*, then NOT

Fourth scrambling:

Third Control data: access Array[537]

Fourth Control data: Add the 8 bits

*Rotations are limited. The scramble-data

will cause the data-byte to be circularly

shifted only 1-to-7 bit-positions.

We now save the scrambled byte, and fetch the

next piece of data for equivalent processing.

As you can see, while every Scratchpad

is indeed used for straightforward

division to yield some bits, only a

few bits are used at a time from any one

Scratchpad. If we have several thousand

bytes to process, then probably almost

every scratchpad in the Array will have

contributed to the overall scrambling,

by the time it's all done (and it DOES

go pretty quickly!).

I think, however, that what I have just

described is far more complicated than

can be handled by the cryptanalysis

methods so far mentioned in this Thread.

I could be wrong, of course. Let me know!

Thanks!