Re: Ada Connections to this Crypto.

[Austin Obyrne <austin.obyrne@hotmail.com>]

On Monday, December 15, 2014 7:06:56 PM UTC, Mark Carroll wrote:
> Austin Obyrne <austin.obyrne@hotmail.com> writes:
> 
> > The bottom line has to be "Where are the ciphers that all these clever readers have written? - there blowing in their own wind can be the only answer - there's pedantry, politics and petulance, vicious personal attacks but no ciphers"
> >  A bit like the golfer who has a lovely set of clubs, polishes the bag , cleans and polishes his shoes, buys some snazzy outfits with a white cap, knows the rules of the game inside out panders to club politics with lots of 'me too' stuff but never hits a ball.
> 
> Not really. I would have loved to developed worthwhile ciphers. In some
> of my master's program work I developed software for generating and
> assessing block ciphers; only last year I worked on an idea for
> automating differential cryptanalysis to assist in my ideas for creating
> ciphers. (It failed miserably.) I am /not/ offering cipher designs
> because I have read enough and learned enough and tried enough to have
> found that I am simply not good enough at it: that other people in the
> field are far more skilled than I am, and that I still don't understand
> the theory well enough to devise ciphers and provide credible assurance
> of their security.
> 
> I'm not like a golfer who panders to club politics, I'm like a golfer
> who likes the game but after a lot of trying and even two rounds of
> classes still can't even hit the ball reliably and realizes that his
> efforts are best applied elsewhere. I wouldn't have responded to you at
> all had you not been persistently filling an Ada group -- something I
> /am/ interested in reading about -- with your peculiar assertions and
> misapprehensions, which I've made a good-faith constructive effort to
> help you move past.
> 
> -- Mark


Further to my earlier post - herewith a cipher that was prompted by a chance remark in a popular hand book - it took me three years before I was satisfied with the mathematics - the cipher algorithm harks back to the famous Vigenere Cipher of some 500 years ago - a more expanded description with copious explanatory pdf diagrams is available on http;//www.adacryptpages.com

adacrypt
Scalable Key Cipher. 

Copyright © 2009 Austin O'Byrne.
Last modified october 2013.

The encryption model is, 

[(Plaintext + X) + (Key +X)] mod N = residue >= 0
(N divides at least once but must divide once)
=> [ (Plaintext + X) + (Key +X)]  = N + residue mod N  >= 0

All of these variables are keys in his cipher => they must be validated therefore for a particular scope according to a table of values.

The elements of the table are positive integers. The bounds of this table of values are also tertiary key material - the bounds are arbitrarily set by the entities exchanging two suitable positive integers.  Suitable meaning positive integers that have a differential in excess of say of 100.  The entities may also stipulate a message length scope.

Key-making process.

The keys are named:

Plaintext (a numerical variable name)
Key (a numerical value)
X ( a constant value key)
N ( a modulus - a variable integer value)
Residue (instantaneous fall-out residue mod N)
n = an arbitrary scalar multiplier

The Table (bounds  700 ... 850).

PlainText     Key
---------------------------------
  700         700
  701         701
  ___         ___
  ___         ___ 
  849         849
  850         850 
----------------------------------- 

The table comprises two identical sets of positive integer elements in the range 700 to 850 (in this demonstration) those numbers being the nominated bounds of 700 and 850. Every element in the RH column is paired with every element in the LH column

'Plaintext' is drawn from Alice's encryption alphabet which is a subset of the table.
'Key' is drawn from the entire table at any moment. 

Nomenclature:

Largest valued element is called HI_NUM.
MAX_NUM = HI_NUM + 1
Lowest valued element is called LOWEST_NUM 
N =  is the instantaneous value of the modulus N
M = the scope of all anticipated message lengths => max-message-length.
n = an arbitrary scalar multiplier  

To enable N to divide every possible pairing of the elements they must each be incremented by an amount X so the table becomes,

Plaintext + X    Key + X 
--------------------------
  700 + X        700  +  X
  701 + X        701 + X
  _______        _______
  _______        _______ 
  849  + X       849 + X
  850  + X       850 + X
--------------------------


To find X :- One pass of the encryption loop by the loop counter N will lead to X.
Consider N as the counter of the eventual encryption loop being constrained to just one pass here.

For N in (X + MAX_NUM) ... 2 (X + LOWEST_NUM) Loop -- one only N
=> 2X + 2.LOWEST_NUM - (X + MAX_NUM) = 0 (0 => 1 incl.)
X + 2 .LOWEST_NUM - MAX_NUM = 0
X = MAX_NUM - 2.LOWEST_NUM 
=> X = 851 - 2x700
= 851 -1400 = - 549

This is the 'identity' X (a coined name) for this particular table (<= N = 1) 

To Find the bounds of 'N'.
X is incremented by the max message-length.
Let M = 50000 be the max-message-length
Then,
the loop  program array bounds emanate from N in the counter,

For N in (X + 50000 + Max_NUM) ... 2 (LOWEST_NUM + X + M) Loop

checking,

2 (LOWEST_NUM + X + M) - (X + 50000 + Max_NUM) = 50000 ?
2(700 - 549 +50000) - (-549 +50000 + 851)
1400 - 1098 +100000 + 549 -50000 -851 = 50000 (this is correct obviously)

Encryption:
Ciphertext = residue + n. N

Decryption:
Plaintext = Ciphertext - (n-1) . N - Key - 2X

The ciphertext is contrived to be a large integer of about 6 to 8 digits - may be positive or negative but is entirely so in a given case.

Cryptanalysis:

The ciphertext is secured by the impossibility of an adversary being able to correctly partition the integer into the subsets (residue + N) and (n-1.N).  The partitioning function can only be enabled by the intervention of the entities who must supply the keys  that enable this to be done.

adacrypt