From: adacrypt on
On Jul 19, 10:07 pm, Mok-Kong Shen <mok-kong.s...(a)t-online.de> wrote:
> adacrypt wrote:
> > I made a mess of my post here - I'll continue,
>
> I posted my previous post before reading this one of yours. So I'll
> also add my comments below.
>
> >>> (3) X, chosen above satisfying the criterion, is fixed, i.e. constant
> >>> for 'all' messages to be sent in future.
>
> > Yes.
> > I explained that there are two options here, you can compute X as a
> > large constant value that has 'scope' - i.e use the same large X that
> > will cover a large range of message lengths within its compass or you
> > can compute a shorter X dedicated to just the one message in hand -
> > there might be management reasons for this sometime - any way its
> > there as an option.  I like the large scope X modus operandi - note
> > that X can be as large as 2147483647 - 63  i.e. the largest positive
> > integer that the computer (30 bit) can accomodate as the initialised X
> > - a miilion pages of text ?
>
> So for messages of length in the range [1,14250], as we have assumed
> from the very beginning, from which more precisely specified range
> do you randomly pick X?
>
> (The questions in my previous post concerning X remain valid.)
>
>
>
>
>
> >> Does "set of N's" imply that there are a number of different values
> >> of N that will be used (the range of N has been given above)? How
> >> many N's will be needed for a message of, say, 10000 characters?
> >> How are they chosen? The partners have certainly to agree on their
> >> values. How is that done?
>
> > 10000 - 63  I have explained this already. Why 63 - that's another
> > story.
>
> > How they are chosen is that they 'happen' as a result of the algorithm
> > that creates them - this is a very difficult thing to grasp - it is
> > related to the Vigenere square dynamics - I have to keep on refreshing
> > my own understanding of it quite often even though I invented it.
> > Once it is understood it can be forgotten.  I am suggesting that the
> > algorithm could be used on its merits without explanation - simply as
> > the rule of a certain sequence that yields a desired result - finish -
> > but if you were to teach this stuff you would prefer to expound
> > properly.
>
> > The partners don't agree on anything - Alice is the instigator of a
> > loop - she calls the shots all the time - she decides on the
> > scrambling parameters that Bob must use to stay in sync - Bob does
> > what he is told like a good obedient fella.
>
> > It all starts with the desired message capacity as explained - that's
> > enough for now - hope this helps - cheers - adacrypt
>
> I don't want at the present stage of attempting to understand your
> algorithm as such to question the "rationale" of your design. So
> for a message of length 10000 there are 10000 - 63 N's. These make
> up S2. Different messages of length 10000 have different sets
> of 10000 - 63 N's. Right? How are they chosen for a specific
> message of length 10000? How many N's are the for a message
> of length, say, 20? (20 - 63 would be negative!)
>
> Thanks.
>
> M. K. Shen- Hide quoted text -
>
> - Show quoted text -

Hi again,

>‘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?


Yes.
S2 is used fro any message that is from 1 to 14250 characters (in this
case) long - any message within the 'scope' of the set of N's is ok.

No different different messages use the same S2 albeit a different
subset of the same S2 - that subset depends on the slice parameter in
vogue that is set by Alice - i.e. the point at which the program
starts reading the array of N's - the reading process wraps back to
the beginning but the array is read only once in entirety.

No. There is no raw secret SR2 - S2 is created as described only - it
is validated by testing every possible combination of key, Plaintext
and N in a special computer program - I have given a link already to
this - once the computer program is run the understanding becomes very
clear and in future you can write down the bounds of N by inspection
as I have done in the worked example - talk again - adacrypt
From: adacrypt on
On Jul 19, 9:46 pm, Mok-Kong Shen <mok-kong.s...(a)t-online.de> wrote:
> adacrypt wrote:
> > Mok-Kong Shen wrote:
>
> [snip]
>
> 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?
>
> Thanks.
>
> 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
From: adacrypt on
On Jul 19, 6:48 pm, Mok-Kong Shen <mok-kong.s...(a)t-online.de> wrote:
> adacrypt wrote:
> > Hi,Worked Example - Using my methods:
> > Let’s say I want to set up a crypto scheme that will enable any
> > message length from one to 14250 characters long (as an arbitrary
> > figure), to be encrypted.
> > I will need two key sets of that same length also.
> > There are two random key sets required i.e. the keypad formed from
> > multiples of the ASCII subset and the set of moduli being called ‘N’s
>
> > Then minimum value that X may take = 14250 + 63 = 14313 in the formula
> > that follows.
> > i.e. X is initialised at 14313.
>
> > The set of N’s as moduli.
> > ‘N’ belongs in the range  (X +127) to 2(X+32) i.e. 14440 to 28690..
> > Checking, 28690 – 14440 = 14250 =>  the keyset of N’s is 14250 (ok)
>
> [snip]
>
> Sorry that I am not smart enough and have to capture your stuff step by
> step. So I'll in this post first try to understand only the first part
> of your post as above.
>
> Are the following points correct?
>
> (1) The partners have agreed on two secret character strings (let's
> name them S1 and S2) each of length 14250.
>
> (2) One may repeatedly use S1 and S2, e.g. one could use them to send
> 10000 messages of 10000 characters.
>
> (3) X, chosen above satisfying the criterion, is fixed, i.e. constant
> for 'all' messages to be sent in future.
>
> Questions:
>
> Does "set of N's" imply that there are a number of different values
> of N that will be used (the range of N has been given above)? How
> many N's will be needed for a message of, say, 10000 characters?
> How are they chosen? The partners have certainly to agree on their
> values. How is that done?
>
> After learning your explanations I'll proceed to pose questions on the
> part of your post that I have snipped for the present.
>
> Thanks.
>
> M. K. Shen
>
>
>
>
>
> > The set of keys being called ‘Key’.
> > This key set is created ad hoc at runtime by the computer reading in
> > the message for encryption and then calculating the number of
> > multiples of the 95 elements of the ASCII printable subset that will
> > be needed to provide an adequate key-length (this may require some
> > padding of the message to bring the two to be equal in length.
>
> > Both of these key sets are read into the empty, waiting to be filled,
> > arrays of the program software.  At runtime the program will call the
> > elements of each key array in sequential order as required, the arrays
> > are volatile and will empty themselves at the end of the program run.
> > The arrays are scrambled and sliced according to parameters that Alice
> > alone decides.  Bob follows her instructions to stay in sync.
>
> > X as a key.
> > In theory X is a key also but no great reliance of crypto strength is
> > ascribed to it by me because of it being a constant but it does count
> > as a stumbling block to some degree to an adversary.
>
> > Note:
> >   This version of the cipher plans ahead as a general modus operandi
> > that permits many message lengths.  It could also be arranged that
> > each message length is calculated at run time and dedicated keys of
> > the bare key-length are used - this as an added foil to
> > cryptanalysis.
>
> > How the cipher works.
>
> > Encryption.
> > [(X +Key) + (X + Plaintext)] (Mod N) = a residue>=0
> > Ciphertext = residue - N
>
> > Decryption.
> > Plaintext (as messagetext) = Ciphertext +2N – Key – 2X = denary
> > representation in ASCII.
>
> > The decryption algorithm is an equation in four unknowns i.e. the
> > Plaintext, the Key, the modulus ‘N’ and X.  Key, N, and X must be
> > supplied so as to evaluate the denary value in ASCII of the Plaintext
> > as messagetext.
>
> > Recapping.
>
> >   X = 14313.
> >   There are 95^2 or 9025 combinations of Key and Plaintext.
> > N = 14250.
> > In passing, the key space is 9025 x 14250 = 128606250 (no significance
> > to this statistic)
>
> > The Worked Example.
> >   Lets say that I want to encrypt the letter capital P which has denary
> > representation of 80 in my plaintext domain of the ASCII printable
> > subset.
>
> > Lets say also that the key that was called by the program is the
> > character @ which has denary representation 64 in ASCII also.
>
> >   The modulus N that was called from the array of N’s is somewhere
> > between 14440 and 28690 (previous work), lets say it is 19653 (a pure
> > guess is ok).
>
> > Then,
> > Encryption.
> >   [(14313 + 64) + (14313 +80)] (Mod 19653) = 9117
> > Ciphertext = -10536
>
> > Decryption.
> >   Plaintext = -10536 + 2 x 19653 – 64 – 2 x 14313 = 80 (as the denary
> > representation)
>
> > The denary representation 80 translates back as capital ‘P’ in ASCII
> > as you would expect.
> > The reader is asked to test as many variations of this encryption
> > example as you wish and let me know if you find anything wrong with
> > it.
>
> > This is a very efficient cipher and much more so than the vector
> > ciphers that are also on the table. The vector ciphers are very
> > elegant although I must admit the ciphertext expansion is pretty
> > great.  I take the view that it is unbreakable security of information
> > at any cost – the cost is not important at national level anyway.
>
> > In practice the ciphertext is always negative so I just treat it as a
> > positive integer while it is in electronic email transit and multiply
> > it by (–1) on arrival.
>
> > There are five versions of this cipher up and running – they are
> > available as a download complete with compiler and PDF from my website
> >http://www.scalarcryptography.co.uk The cipher encryption/decrytpion
> > rate is very high on my home computer – should be very fast in a
> > larger commercial mini computer I think
> > . – cheers - adacrypt- Hide quoted text -
>
> - Show quoted text -- Hide quoted text -
>
> - Show quoted text -
Hi,
Correction.
>Does "set of N's" imply that there are a number of different values
>of N that will be used (the range of N has been given above)? How
>many N's will be needed for a message of, say, 10000 characters?
>How are they chosen? The partners have certainly to agree on their
>values. How is that done?


That will be 10000 N's (not 10000 - 63 as perviously sated)
From: adacrypt on
On Jul 20, 8:25 am, adacrypt <austin.oby...(a)hotmail.com> wrote:
> On Jul 19, 9:46 pm, Mok-Kong Shen <mok-kong.s...(a)t-online.de> wrote:
>
>
>
>
>
> > adacrypt wrote:
> > > Mok-Kong Shen wrote:
>
> > [snip]
>
> > 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?
>
> > Thanks.
>
> > 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- Hide quoted text -
>
> - Show quoted text -

Hi,

>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) -

On reflection SR2 notation is quite appropriate - the base set is a
part of the database that of course is secret amd must be studiosly
kept secret by Alice and Bob - adacrypt
From: Mok-Kong Shen on
adacrypt wrote:
[2 posts combined]

> Yes - S1 is not a fixed string but is contrived (engineered) to be the
> same length as the messagelength.
> If it happens that the message for encryption is already a round
> multiple of 95 then this is good luck and no 'engineering' is
> necessary.
> There is no engineering as such to be done - this in retrospect was an
> unfortunate choice of words by me to cover the act of counting and
> then computing 'm' the multiplier of 95 - the characters are simply
> counted as they are read in from an external file or from the keyboard
> - in passing this latter is done by the keyboard operator who does not
> need to know anything about cryptography (any cryptography).
>
> No there is no raw secret material SR1 whatever - there is only the
> perfectly open set of printable ASCII only that is available to
> everyone - S1 is created as described - talk again - adacrypt

> Hi again,

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

> S2 is used fro any message that is from 1 to 14250 characters (in this
> case) long - any message within the 'scope' of the set of N's is ok.

> No different different messages use the same S2 albeit a different
> subset of the same S2 - that subset depends on the slice parameter in
> vogue that is set by Alice - i.e. the point at which the program
> starts reading the array of N's - the reading process wraps back to
> the beginning but the array is read only once in entirety.

> No. There is no raw secret SR2 - S2 is created as described only - it
> is validated by testing every possible combination of key, Plaintext
> and N in a special computer program - I have given a link already to
> this - once the computer program is run the understanding becomes very
> clear and in future you can write down the bounds of N by inspection
> as I have done in the worked example - talk again - adacrypt

There have been lots of stuffs that you didn't tell clearly in previous
posts IMHO. But doesn't matter. Since I have already spent quite some
time on this, I'll keep on till the end. Now please examine/correct
the following. (I assume you have no objection that I name your
"perfectly open stuff" SR1).

(1) Message length: L characters in a 95 subset of ASCII, L=0 mod 95,
L<=14250.

(2) Partners agree to employ a publically available character sequence
SR1 of length 14250.

(3) S1: a character sequence of lengeh L that is either directly taken
from SR1 or is a modified version of a part of SR1.

(4) S2: an integer sequence in [14440, 28690] of length L.

Now please concretely explain the following for a given message of length L:

(1) If L<14250, which part of SR1 will be taken for processing? Under
which condition is it not modified? If it needs to be modified, how?

(2) How does one compute the integer sequence S2?

Thanks,

M. K. Shen