Re: Is there a Mathematician Cryptographr in the House.

On Jul 19, 9:46 pm, Mok-Kong Shen <mok-kong.s...@xxxxxxxxxxx> wrote:
adacrypt wrote:
Mok-Kong Shen wrote:


Sorry that at least one more iteration step is needed and I have to
ask a bunch of dumb questions.

Likewise I had better proceed carefully lest there be any damning
misundesrtanding that could scupper the good work - I will take each
point it one at a time'

1) The partners have agreed on two secret character strings (let's
name them S1 and S2) each of length 14250.

Yes but this needs explaining. S1 is made up of characters per se and
comprises a multiple ('m' say) of the basic set of the 95 printable
characters of ASCII - it is engineered by first reading in the
plaintext file for encryption  and counting the number of characters
in it - this number is then used to determine 'm' explicitly as the
number of round modules of keys from ASCII that will be needed to
encrypt the file of plaintext when they are combined into one set - it
is unlikely that the message length is an exact multiple of the 95
element set so in order to satisfy the caveat that message length and
key length are equal the message is made up by padding with repeats of
some character (like this<<<<)  until they are both the same length.

So S1 is not a fixed (i.e. same for all messages) string but is
dependent in some way on the particular message to be processed? Say,
the particular (padded if needed) message has a length L that is a
multiple of 95. How does one do the "engineering" you mentioned? Is it
correct that there is some "raw" secret material SR1 of length 14250
that is fixed and one derives from SR1 a message specific S1 for use?
If yes, how is S1 obtained from SR1?

S2 is a set of positive integers but within the stipulated range (X
+127) and 2(X +32) - this set is a fixed length and the elements
being consecutive positive integers are non-repeating) - happily,
subsets of this random set (i.e. in lengths required by shorter
messages) are also random themselves and only part of the set can
safely be used as the random set that is equal to the messagelength.
You wrote:

   ‘N’ belongs in the range  (X +127) to 2(X+32) i.e. 14440 to 28690.

So S2 consists of N's? Right? Is S2 (for use for a particular message)
of length L or of length 14250? Is it correct that different messages
use different S2? Is S2 for use for a particular message derived
from a "raw" secret material SR2 of length 14250 which is fixed? How
does one derive that?

You will appreciate my great care in preserving randomness.

Important:  Both sets S1 and S2 are each simply one permutation that
is possible in the enormous permutation space that is available for
both of them.  For instance inthe case of S1 the permutation space of
m modules of 95 is 95! ^m (95 factorial to the power of m) which is an
out-of-this-world large number.

In the case of S2 the permutation space is 14250! (14250 factorial) an
even larger number.

It seems that some permutation processing is involved in what I mention
as "derivations" above. Could you tell concretely the algorithm of
permutation that is used, i.e., given L, how does one exactly obtain S1
and S2 from SR1 and SR2?

Important: The two sets S1 and S2 are scrambled by a special computer
procedure that requires some understanding by programmers - elements
are swopped around positionally - also the arrays are sliced i.e. the
starting point at which the computer starts reading the keys from
either array is changed each time.  All of this is to keep on
reinforcing the randomness and to guard against transparency of keying
data in the mutual databases.  Alice decides how the arrays will be
shuffled and sliced and directs Bob to do the same thing exactly - it
works a treat.

This doesn't further help much my understanding. I understand that a
secret (kind of key-dependent) permutation does some desired
scrambling. As said above, I like to know how you concretely do the
permutations in obtaining S1 and S2 from SR1 and SR2.

I strongly suggest that you mull over this for some time before going
any further - I am here any time you are ready to move on but give
this some thought - This is a very difficult piece of the algoritm.

That's why I have to ask the many questions above.

(2) One may repeatedly use S1 and S2, e.g. one could use them to send
10000 messages of 10000 characters.
  Yes but remember to scramble and slice regulary so as to keep a high
level of entanglement that underwrites the randomnes of the key sets.

If my view above of "dynamically" deriving S1 and S2 from SR1 and SR2 is
right, then I have understood this.

(3) X, chosen above satisfying the criterion, is fixed, i.e. constant
for 'all' messages to be sent in future.

I explained that there are two options here, you can X as a constant

So either

(a) X is a constant (agreed upon at the same time as SR1 and SR2) for
     all messages, or

(b) X is different for different messages but its value doesn't vary
     throught one and the same message (i.e. a constant for each
     particular message).

Is that right? How is X chosen by the partners in case (b)? Presumably
using (a) is much weaker than (b). Is (a) permissible at all or do
you consider it to be nonetheless quire safe because of the other
operations present, in particular the permutations mentioned above?


M. K. Shen- Hide quoted text -

- Show quoted text -

Hi once more,

It seems that some permutation processing is involved in what I mention
as "derivations" above. Could you tell concretely the algorithm of
permutation that is used, i.e., given L, how does one exactly obtain S1
and S2 from SR1 and SR2?

Yes, the permutation processing as such is no more than a scrambling
operation that throws up a fresh permutation.

Yes I can tell you the algorithm explicitly if you insist but it is
more a program procedure in my software that is best understood by
reading it there.

Explanation of scrambling.
There are two variables called "Step" and "Repeat" - when the
procedure runs at main program boot-up time it loads the set of data
(whichever it might be) from the storage as packages into the
erstwhile empty arrays - as it does this it reverses the position of
element numbered "Step" (Step a positive integer) to position of
element number 1, element Step -1 goes to position 2. Step - 2 goes to
positiion 3 and so on to end of "Step". "Repeat" is another positive
integer. Repeat repeats the action described for Step.

- Step x Repeat must not exceed the total number of elements in an
array being scarambled. - Step x Repeat may be applied to any subset
of the total array length however.

When the database is first created by Alice and she sends a copy to
Bob it contains a package containing one ( a base set) permutation of
the set of data - its is this that is scrambled periodically (as often
as she wishes by Alice) to get fresh working permutations for her
daily needs. She can also (if needs be) change the static base set if
she wishes by arrangement with Bob at any time ( that would be a
special case).

This latter base set might correspond to what you are calling SR2 (I
dont think you should continue thinking along those lines however -
stay in sync with me for now anyway - forget SR2 and SR1 for now) -

Have to leave the rest till later - adacrypt