Scalar Cryptography. Copyright 2009 Austin O Byrne.

Worked Example Scalable Key Cryptography:

Introduction. This is a bare bones, highly contrived and studiously configured presentation of cryptography being modelled in modular arithmetic. It is intended for the understanding of the design cryptographer reader who has the mathematical wherewithal to understand the connections within the mathematical design model in modular arithmetic being used by me and the way in which the residue classes of prescribed moduli therein translate as fallout random keys that are collated as sets of encryption keying-data in the cryptography that then uses them for the construction of ciphers. The mathematics of this cryptography is my private invention. The scheme uses Mutual Database Technology (appendix A) in an excursion that use modular arithmetic as the encryption environment. The core, obfuscating algorithm only, is discussed here. Lets say I want to set up an encryption scheme that will enable any message length from 1 to 14250 characters long (as an arbitrary figure), to be encrypted. I will need key-sets of that same length also. There are two random key-sets available i.e. the keypad formed from multiples of the ASCII printable subset (elements 32 to 126 incl.,) and the set of moduli being called the Ns. The set of Ns as moduli. The minimum value that X may take to produce a key-set of 14250 Ns = 14250 + 63 = 14313, therefore in the formula that follows X is initialised at 14313. Then, Nis a positive integer, belonging in the range (X +127) to 2(X+32) i.e. 14440 to 28690. Checking this, 28690 14440 = 14250 => the key-set of Ns is 14250 (correct) 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, counting the characters in the external file 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 make the two equal in length). This composite keypad is random by the same definition of having equal probability of the elements, hence the use of round multiples of a basic module of the 95 printable characters of ASCII that is itself scientifically random per se.

Scalar Cryptography. Copyright 2009 Austin O Byrne. 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 for the instantaneous use, the arrays are volatile and will empty themselves again at the end of the program run. The arrays are scrambled and sliced according to scrambling parameters that Alice alone decides. Bob follows her instructions by applying the scrambling instructions to the arrays of his database so as to stay in synchronism with Alices database. X as a key. In theory X is a key also in being a random variable from a large possibility space of random Xs but no great value of crypto-strength is ascribed to it by me because of it being a constant but it does count however at the same time as a useful stumbling block of some degree to an adversary. Note: This version of the cipher plans a broad usable scope of message lengths ahead of expected requirements, this is a general modus operandi that permits many varying message lengths by the same program sourcecode. It could also be arranged that each message length is calculated at run time and dedicated keys only of the bare keylength are used. That ploy is available for a special application if that is required. How the cipher works. Encryption. [(X + Key) + (X + Plaintext)] (Mod N) = a residue >=0 Ciphertext = residue N (ciphertext is always a negative integer) Decryption. Plaintext (as messagetext) = Ciphertext +2N Key 2X = the denary representation of the messagetext in ASCII. Note: 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 from Bobs database so to evaluate the denary value in ASCII of the Plaintext as message text. These, being random keys, cause total uncertainty to any illegal cryptanalyst (see appendix - B). Recapping. X = 14313. There are 95^2 or 9025 combinations of Key and Plaintext. N = 14250. 2

Scalar Cryptography. Copyright 2009 Austin O Byrne. In passing, the key space is 9025 x 14250 = 128606250 (no additional crypto strength significance is given to this statistic there are that many possible test examples however for testing if needed) The Worked Example. Any combination of Key, Plaintext and N in their prescribed ranges can be encrypted with theoretically unbreakable strength by means of this cipher. Let us say that I want to encrypt the letter capital P that has denary representation of 80 in my plaintext domain that consists of the ASCII printable subset (elements 32 to 126 incl.) Let us say also that the key that was randomly called by the program to do this is the character @ which has denary representation 64 in ASCII also and is the Key that will be paired with P in the forthcoming encryption process (the random Key could be any one of the 95 possibilities that have equal probability). The modulus N that was called from the array of Ns may be anywhere between 14440 and 28690 (see previous work), lets say it is 19653 (it could be any number in the range this is no more than a wild guess). 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. There are 128606250 possibilities of non-repeating combinations of Key, Plaintext and N that may be used in any test case, the implications to powerful cryptography are clearly evident. This is a very efficient cipher and much more so than the companion vector ciphers on (http://www.adacrypt.com ) that are also on the table. The vector ciphers are very mathematically elegant although I must admit the ciphertext expansion of vector cryptography type is pretty great. Even so, I take the view that unbreakable security of information at any cost should be the aim that cost should not be important at national level anyway and is not a damning criticism of vector cryptography. 3

Scalar Cryptography. Copyright 2009 Austin O Byrne.

In practice the ciphertext in the example above is always negative so I can 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 single download complete with compiler and PDF from my website http://www.scalarcryptography.co.uk . The encryption/decryption rate of the ciphers is very high on my very ordinary home computer it should be very much quicker in a large commercial mini computer I think. A salient feature of this cipher design is that it encrypts both by reading in plaintext files character by character from any external batch file and also by reading in directly from the keyboard in real time (impromptu emails). The operator is a nonspecialist office worker who does not need to have any knowledge of cryptography whatever. No specialist user-assistance such as on-site cryptographers or specially trained personnel is required. The software could possibly become little more than an adjunct to word processing eventually so simple and robust is the scheme. Any data type is manageable as an external file for encryption. This cryptography is independent of the deleterious effect of increasing brute force capability through increasing computer power for all time and indeed contrary to this is enhanced by the upgraded computing power that any such advances may bring. The cipher has a theoretical message length capability of 2147483584 characters half a million pages of plaintext that is for 32 bit arithmetic computers. Model and Theory. This is a piece of niche number theory that enables a set of random keys as the modulus N in a modular arithmetic model to be generated for use as keys in encryption work. That set of moduli satisfies the mandatory requirement in cryptography for one random key-set to be provided in a cipher that claims theoretically unbreakable cryptographic strength but the option is there also in this case for a second random key-set to be generated if the user wants that as extra backup security. The entire encryption environment is provided by the modular settings of the residue classes that are associated with the set of configured Ns. The Vigenere square being used as the basic model of the eponymous cipher is defined by its mathematical equation in this context.

Scalar Cryptography. Copyright 2009 Austin O Byrne. Although the basic cipher type that ensues emanates from the historic Vigenere Cipher the connection quickly becomes tenuous as the newly adapted cipher type being called Scalable Key Cryptography is developed along separate lines. Take, (Key + Plaintext) (Mod 27) = Ciphertext as the equation of the original Vigenere square when that square is populated by the 26 characters of the English alphabet, I deliberately chose Mod 27 for my purposes of demonstration here. Suppose now I say that, Plaintext = Ciphertext Key This is a deliberately nave demonstration that acknowledges that there are cases when Key is larger than the Ciphertext and, Ciphertext Key < 0 (this example is being used deliberately to make the point here.) In order to redress this imbalance I next add one multiple of the modulus 27 to the ciphertext and repeat the demonstration and this time, Ciphertext + N (the modulus) Key >0 and is now in order for finding the correct plaintext due to having been incremented by 1 value of N. The upshot now is that there is a measurable range of moduli somewhere between 1 and 27 that will always a give a residue that in turn gives me a negative result that requires the addition of one multiple of the current modulus to the residue so as to put things right in the general equation, Plaintext = Ciphertext Key. I am going to make this anomaly the basis of my algorithm in the design of a new cipher that uses modular arithmetic. I am interested only in those cases where the right-hand side of this equation is deliberately negative. That requires that, (Key + Plaintext) (Mod N) = a residue >= 0 when N divides once and only once. Finding the set of Ns that will do this by operating on every possible combination of (Key + Plaintext) is my next problem.

Upgrading the previous model. 5

Scalar Cryptography. Copyright 2009 Austin O Byrne. If I extend the original Vigenere model that used the 26 letters of the English language only and apply it to a modern information system that now uses ASCII instead then this is what evolves in the application of my theory to the equation of the square, 1) I populate the Vigenere square with the 95 printable subset of ASCII. 2) I next determine the method of finding a sequence that gives me the range of moduli that divides every combination of. (Key +Plaintext) (Mod N) = a residue >= 0 this residue will always give a negative result if the equation, Plaintext = Ciphertext Key, is tested. An abiding condition of my algorithm is that N divides once and only once when producing the residue. Furthermore, In my new model, I increment both the Key and the Plaintext by a value X so that my new equation is, [(X + Key) + (X + Plaintext)] (Mod N) = a residue >= 0 The variables Key and Plaintext are drawn from the printable subset of ASCII characters i.e. elements numbered 32 to 126 incl. The range of N has to be established next. Incrementing with X is necessary to give a large range of Ns It happens then that X and N are related as follows, Whatever the required maximum message length is to be then, X = messagelength + 63. X is initialised at that value in the formula that follows. The sequence of Ns is then, All the positive integers in the range => (X +127) to 2(X+32). Encryption. [(X +Key) + (X + Plaintext)] (Mod N) = a residue >= 0 Ciphertext = residue N. Decryption. Plaintext (as messagetext) = Ciphertext +2N Key 2X This gives the denary value of the messagetext in the ASCII subset of printable characters. 6

Scalar Cryptography. Copyright 2009 Austin O Byrne.

Remember the important caveat, the modulus N divides once and only once every time. Design details. In theory at least the maximum message length is restricted only by the maximum positive integer that the computer can store i.e., If X is initialised at 2147483647 (max positive integer) then the maximum messagelength is 2147483647 63 = 21474836584. My claim for establishing the sequence of Ns is validated by a computer program that tests every possible combination of Key, Plaintext and Modulus N in any proposed range of N. Proof by any other method is not to hand yet. The computer program in question is named, Make_Moduli_Program_Mark_0 and is to be seen and used by readers in a free download from my website that is called, http://www.scalarcryptography.co.uk The five cipher versions that are to hand are written in the Ada-95 computer programming language, they have a high encryption/decryption rate. Appendix - A. Mutual Database Technology. Alice creates her encryption program to perfection complete with all arrays of data that she normally needs. She immediately creates a decryption program that decrypts her previous encryption work to perfection using the same arrays. She can now decrypt her own encryptions but so also can anyone else to whom she sends a copy of her database. That person is Bob. This requires a one-off secure delivery of her copy database by whatever means is appropriate to the security level, it may even require a delivery by a trusted live courier in extreme cases. No other exchange of keying material is ever again needed in the life of the secure loop. As long as the entities keep their databases secure then they can enjoy theoretically unbreakable security of information forevermore. Alice exchanges scrambling parameters that keep the shared databases in synchronism with Bob every so often. These scrambling parameters may go as unsecured data along with the ciphertext. The ciphertext is useless to anybody who intercepts it in transit because it merely indexes the elements of the arrays in the databases of the entities and without access to the databases it is totally worthless to any adversary. There is nothing embedded within the ciphertext (as is the case with modern encapsulation cryptography) that a cryptanalyst can discover by mathematical means. 7

Scalar Cryptography. Copyright 2009 Austin O Byrne. The ciphertext is a string of integers that have mathematically dysfunctional periodicity it has no regular scale and the space between the integers is continually varying this pre-empts all inductive methodology by a cryptanalyst hence the name Scalable Key Cryptography. Enjoy, - Austin OByrne pseudonym adacrypt. Appendix B. A Handbook of Applied Cryptography by A.Menezes, Paul Van Oorschot, S Vanstone is a highly respected information reference and I quote them as follows. The context is in relation to the generally unusable One-Time-Pad cipher but is applicable also to all scalar ciphers which includes this cipher type being called Scalable Key Cryptography here by me. Extract. Quote: the One-Time Pad can be shown to be theoretically unbreakable. That is, if a cryptanalyst has a cipher text string encrypted using a random key string that has been used only once, the cryptanalyst can do no better than guess at the plaintext being any binary string of length t i.e. (t-bit binary strings are equally likely as plaintext). It has been proven that to realize an unbreakable system requires a random key of the same length as the message. Unquote Not well, this is not a one-Time pad cipher type. NB. used only once means within that message on that occasion. It does not mean ever before or ever again as one handbook wrongly implies. Comment. One, or two random keys are optional in the cryptography being described and the key lengths are studiously made equal to the message length every time so as to satisfy this important caveat. Finally, these ciphers are simple, transparent and robust. They can claim theoretically unbreakable cryptographic strength. They are written in the Ada-95 programming language, they have a high encryption /decryption rate and are very efficient in terms of ciphertext expanded volume. They are intended to be used by non-specialist office staff who need only a minimal in what anybody could call special training. Comment. I am not bound to using the standard denary values of the printable subset of ASCII, I can revalue these at will but there is little profit in doing this since I already have theoretically unbreakable crypto strength and it becomes a case of gilding the lily to try to add more unnecessary complexity. If I did decide to revalue the ASCII printable subset however, then its a whole new ball game of finding the new 8

Scalar Cryptography. Copyright 2009 Austin O Byrne. parameters that need to be calculated for finding the range of Ns as moduli / keys. The latter is done just as before and is not difficult. -----------------------------------------

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

`` `!` `` `#` `$` `%` `&` `` `(` `)` `*` `+` `,` `-` `.` `/` `0` `1` `2` `3` `4` `5` `6` `7` `8` `9` `:` `;` `<` `=` `>` `?` `@` `A` `B` `C` `D` `E` `F` `G` `H` `I` `J` `K` `L` `M` `N` `O`

W R I T A B L E

A S C I I
S U B S E T

80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

`P` `Q` `R` `S` `T` `U` `V` `W` `X` `Y` `Z` `[` `\` `]` `^` `_` ``` `a` `b` `c` `d` `e` `f` `g` `h` `i` `j` `k` `l` `m` `n` `o` `p` `q` `r` `s` `t` `u` `v` `w` `x` `y` `z` `{` `|` `}` `~` DEL