ShuttlePads Cryptology - Comprehension.

ShuttlePads Cryptology - Comprehension.

[Austin Obyrne]

Comp.Lang.Ada readers please understand why this seemingly intrusive topic in cryptography is being posted here.

Synopsis.

(with sci crypt readers in mind)

This post has a lot of subject matter in it that may be of interest also to Comp.Lang.Ada readers so I am cross-posting this article from Sci Crypt news group to that group also for that reason. May I explain to those readers over there that I am making a claim that cryptology belongs in computer science and not in mathematics as has quite wrongly and for a long time being held to be the case by the cryptology establishment. 

The ground work to date in my researches is programmed in Ada-95.

I am saying that it was a huge misadventure to go down the road of mathematics as the platform for cryptography for so long for the obvious reason that cryptographers and enemy cryptanalysts supped from the same bowl so to speak when they both used the same number system in mathematics i.e. the arbitrary number system of number theory to perform encryptions of so-called secure information.  The advent of computers intensified the error way back in the seventies.  It is very understandable why it happened but it was a mistake none the less that needs to be rectified now.

Alice and Eve are the participants of the mutual and hugely transparent number system that has been used in cryptography for ages past - 'Alice' is the industry standard pseudonym in this article for the sending cryptographer and Eve is the adversary who is always going to try and steal the secured information by decrypting Alice's ciphertext.  

Up to now Eve has had a huge advantage in that she always knows what number system Alice is using and can make some very telling assumptions because of that - Alice on the other hand must try and camouflage her encryption transformations so well that Eve does not succeed in this - but that is an impossible task for Alice - it's a bit like a tragedy in the Greek Classics by analogy and it is all brought about by using the same numbers system.

It is difficult to understand how this has gone on for so long  unnoticed i.e. cryptographers using a number system that is notoriously good at what is was intended to do first day but totally unsuited to cryptography because of the indelible foot prints it leaves in the ciphertext.  It should have been stopped long ago but instead has gone on as the longest-running mistake in mathematics.  My conjecture is that cryptographers of the day (in the seventies) were so beguiled by the huge new computing power that they thought they could apply it to enhance their existing ciphers unbreakably without realising that they were basically going down a wrong road with already defunct cryptography.

Having made this damning indictment of the status quo it behoves me to demonstrate  something better so here goes.  

I have invented cryptography that I am calling "ShuttlePads".  The salient thing about this cryptography is that it is best effected in practice as a computer program and in general, cryptanalysis by any methodical means (apart from brute force) is impossible.

I have written a cipher program in Ada-95 that delivers on this claim.


Comment,

Cryptography in mathematics using the raw traditional number system that may be modelled as an arbitrary straight line that may have any direction and any unitary periodicity is like trying to hide behind the curtains in an empty room so transparent is it to cryptanalysis.  It is incredible that it has gone on for so long unnoticed.

ShuttlePads.

A 'Pad' by definition here is a scrambled permutation of the 95 code-point set of ASCII i.e. the set of positive integers 32 to 126 inclusive.  The possibility space of all such permutations is 95!(factorial) or 10 ^148 in number - a colossal number of pads.

A pad is indeed an ordinary computer array having the usual set of contiguous cells that have addresses that are called 'indexes' and a set of elements that populate the cells.  The cells may be called for use in any order by the indexes for whatever purpose that may arise.  Only the set of elements ( column on RHS in the Ada package model below) are scrambled - the LHS column of integers are left as standard i.e. in the unaltered ASCII order.

A 'shuttle' per se  is a unique subset of this pad (to be described here).  

Each plaintext character for encryption in this crypto scheme has associated with it a unique subset of the ASCII numbers that is called a 'shuttle'.  A shuttle is so called because of the continuous reciprocating path of the numbers by the cipher program i.e. from the entry point at Alice's end to the  terminating point at Bob's end, back and forth rather like a single line railway system.

Encryption

Alice encrypts by forward-indexing the shuttle from the entry point at "EntryNum" ( a variable name) which is the codepoint of the plaintext for immediate encryption in hand until after an agreed number of iterations (*ANY* positive integer agreed with  Bob may be used) it leaves the shuttle at a number called "ExitNum".  This exit number becomes the code point of the ciphertext and is realised as the ASCII character it represents for public transporting to Bob as ciphertext.

Decryption.

Bob goes back along the shuttle by entering at the codepoint value of the ciphertext to be decrypted and reverse-indexes it back all the way along the same line for the agreed number of iterations until Alice's original entry point is reached.  The exit number is then the same as the entry number i.e. the same point at which Alice came in and is the code point value of the plaintext (as message-text now) having been inductively pinpointed by symmetric decryption.

In practice the entities do not do any computations that might seem to be suggested here by this description - the cipher algorithm and the computer science does it all.  The entities just thoughtlessly submit plaintext or ciphertext items  as the case may be for processing by the cipher computer program either as prepared read-in batch files or interactive emails in real-time.

There is no need for them to do anything but the more discerning reader will want to know what happens under the bonnet (hood) inside the computer at runtime just the same.

Lemma.

*The Ada programming language has a data structure package called "The Case Statement" and this is used throughout this cryptology.  The Case Statement package is used here as the demonstration model.


A sample Pad_165 is used as the discussion model.

Let the reader please note well that the entities do not go into any of modular arithmetic described next when they use the cipher.  This bit of theory is being expounded here only to show the algebraic analysis of the encryption for readers who are interested and the total impossibility at the same time of any methodical cryptanalysis by adversaries.


Example:

Let the plaintext be the capital letter 'P' say which has the code-point value in ASCII of 80


The Ada "Case Statement" Package being used as the discussion model:-

WITH Ada.Text_IO;
PACKAGE BODY Pad_165 IS
------------------------------------------------------------------------
--| Contains the body of the function "Get_Num" that is provided
--| by the package called "Pad_165".
--| Copyright © 2015 Austin O' Byrne
--| Last Modified January 2015
-------------------------------------------------------------------------
  FUNCTION GetNum (NumIn: Integer) RETURN Integer IS
    CharOut: Integer;

  BEGIN
    CASE NumIn IS
      WHEN 032 => CharOut:= 117;
      WHEN 033 => CharOut:= 121;
      WHEN 034 => CharOut:= 108;
      WHEN 035 => CharOut:=  45;
      WHEN 036 => CharOut:=  41;
      WHEN 037 => CharOut:=  35;
      WHEN 038 => CharOut:=  82;
      WHEN 039 => CharOut:=  62;
      WHEN 040 => CharOut:= 100;
      WHEN 041 => CharOut:=  37;
      WHEN 042 => CharOut:=  44;
      WHEN 043 => CharOut:=  72;
      WHEN 044 => CharOut:= 113;
      WHEN 045 => CharOut:=  61;
      WHEN 046 => CharOut:= 110;                  
      WHEN 047 => CharOut:=  68;
      WHEN 048 => CharOut:=  99;
      WHEN 049 => CharOut:=  97;
      WHEN 050 => CharOut:=  33;
      WHEN 051 => CharOut:=  74;
      WHEN 052 => CharOut:= 119;
      WHEN 053 => CharOut:=  40;
      WHEN 054 => CharOut:= 120;
      WHEN 055 => CharOut:=  64;
      WHEN 056 => CharOut:=  67;
      WHEN 057 => CharOut:= 109;
      WHEN 058 => CharOut:=  69;
      WHEN 059 => CharOut:= 106;
      WHEN 060 => CharOut:= 102;
      WHEN 061 => CharOut:= 114;
      WHEN 062 => CharOut:=  59;
      WHEN 063 => CharOut:=  92;
      WHEN 064 => CharOut:=  70;
      WHEN 065 => CharOut:=  94;
      WHEN 066 => CharOut:=  89;
      WHEN 067 => CharOut:= 103;
      WHEN 068 => CharOut:=  34;
      WHEN 069 => CharOut:= 123;
      WHEN 070 => CharOut:= 107;
      WHEN 071 => CharOut:= 104;
      WHEN 072 => CharOut:=  86;
      WHEN 073 => CharOut:=  32;
      WHEN 074 => CharOut:=  60;
      WHEN 075 => CharOut:=  43;
      WHEN 076 => CharOut:=  93;
      WHEN 077 => CharOut:=  78;
      WHEN 078 => CharOut:=  79;
      WHEN 079 => CharOut:=  125;
      WHEN 080 => CharOut:=  54;
      WHEN 081 => CharOut:=  47;
      WHEN 082 => CharOut:= 111;
      WHEN 083 => CharOut:=  80;
      WHEN 084 => CharOut:=  66;
      WHEN 085 => CharOut:= 116;
      WHEN 086 => CharOut:= 105;
      WHEN 087 => CharOut:= 112;
      WHEN 088 => CharOut:=  90;
      WHEN 089 => CharOut:=  77;
      WHEN 090 => CharOut:=  65;
      WHEN 091 => CharOut:=  38;
      WHEN 092 => CharOut:=  42;
      WHEN 093 => CharOut:=  98;
      WHEN 094 => CharOut:=  76;
      WHEN 095 => CharOut:=  85;
      WHEN 096 => CharOut:=  36;
      WHEN 097 => CharOut:=  46;
      WHEN 098 => CharOut:=  87;
      WHEN 099 => CharOut:=  48;
      WHEN 100 => CharOut:=  57;
      WHEN 101 => CharOut:=  71;
      WHEN 102 => CharOut:= 101;
      WHEN 103 => CharOut:= 118;
      WHEN 104 => CharOut:=  55;
      WHEN 105 => CharOut:=  81;
      WHEN 106 => CharOut:=  95;
      WHEN 107 => CharOut:=  96;
      WHEN 108 => CharOut:= 115
      WHEN 109 => CharOut:= 122;
      WHEN 110 => CharOut:=  49;
      WHEN 111 => CharOut:=  56;
      WHEN 112 => CharOut:= 124;
      WHEN 113 => CharOut:=  53;
      WHEN 114 => CharOut:=  84;
      WHEN 115 => CharOut:=  91;
      WHEN 116 => CharOut:= 126;
      WHEN 117 => CharOut:=  63;
      WHEN 118 => CharOut:=  75;
      WHEN 119 => CharOut:=  58;
      WHEN 120 => CharOut:=  50;
      WHEN 121 => CharOut:=  73;
      WHEN 122 => CharOut:=  39;
      WHEN 123 => CharOut:=  51;
      WHEN 124 => CharOut:=  83;
      WHEN 125 => CharOut:=  88;
      WHEN 126 => CharOut:=  52;

    WHEN OTHERS =>
        Ada.Text_IO. Put (Item => "Forget this one - out of bounds ");
    END CASE;
    RETURN CharOut;

  END GetNum;

END Pad_165;

                      ----------------------------                                                    Discussion.
                                                      
About the shuttle demonstrated later (Please see the Index-A) - it has 70 elements and that is for the seed element 80 only on the LHS of this particular pad.  The shuttle is complete when the seed element has migrated to the RHS , denoted here by '83 Indexes 80' from having started at the line at '80 Indexes 54'.

A similar shuttle can be demonstrated by readers for every one of the remaining 94 elements in Pad_165.

Pads are constructed initially by manual configuring - scrambling by hand. A run-time scrambling process can be parameterised for the computer to do interim programmed scrambling at each session if that is required ( every session might be a bit too much but it is there for periodic use if the user decides to use it).

The effect of this interim computer-driven scrambling is profound - the smallest change completely changes the entire shuttle..

*Warning - an accidentally repeated number during the manual construction of a pad can have very unwelcome effects for the  knock-on reason of a propagated error .

Comment.

The reader who has any design instinct will clearly realise the enormous possibilities of contrived entanglement that this has piece of computer science has for cryptography.  

(That potential has been realised in an up-and-running cipher program to hand that is written in Ada-95 - the cipher name is simply "ShuttlePads" )

The applications to cryptography to date =>

Comment.

The ciphertext item for a particular plaintext is always within the associated shuttle i.e. it cannot be outside of the shuttle.- another stumbling block to cryptanalysis.

Only one circuit of the shuttle has been demonstrated here but  a user my go on and on with many more repeats of the same shuttle (for whatever design reason that may exist apart from the obvious one of extra 'entanglement' ) in each encryption of a plaintext character.  These repeats may be implemented by the users applying extra 'iterations' that may be encapsulated in the program source code at the touch of a key.

Comment.

Let the number of iterations be any positive integer, N.
Let 'n' be the number of elements in a particular shuttle.

Then, the position of the ciphertext code point in the shuttle is (N mod (n)) counting from the start of the shuttle for whatever use that information may be (can't see any at the moment - just comment from an algebraic overview).

Cryptanalysis.

A cryptanalyst would need to know,
1) The Pad(s) being used by Alice.
2) Details of the shuttle elements.
3) The number of iterations (N) being deployed by Alice.

Since 2) requires knowledge of the plaintext there would be no need to  proceed any further if that was the case.

Comments.

Dry-run testing by the reader of other plaintext items in this pad should show similar results.

Comment.

*What is known to an adversary about the algorithm,

It uses the ASCII code point set.
The cipher text string may be scrambled after creation.

What is not provided because of being key information,

1)The number of Pads being used in any cipher by the entities.
2)The number of iterations being used by the entities during encryptions.
3) Details of any Pads.
4) Details of any scrambling parameters of arrays of data.

Comment.

(The Ada package used here is adapted from some other use in previous private work hence the anachronism 'Charout' as a variable name in the table).

Tests and challenges.

These, when they occur in any post from me, are not some kind of benign table game with rules of fair play.  They are meant to simulate a serious breach of security in that a batch of ciphertext has been aggressively purloined by an enemy who is trying very hard to decrypt it.  There are no clues for the asking like "How many pads are being used" or "How many iterations per pad". Alice's mobile number?


---------------------------------------------------------------

Index - A - The Shuttle.
(the plaintext being encrypted is capital 'P' that has code point 80 in ASCII

Then,
Shuttle <= 80

80  Indexes 54
54  Indexes 120
120 Indexes 50
50  Indexes 33
33 Indexes 121
121 Indexes 73
73 indexes  32
32 Indexes 117
117 Indexes 63
63 Indexes 92
92 Indexes 42
42 Indexes 44
44 Indexes 113
113 Indexes 53
53 Indexes 40
40 Indexes 100
100 Indexes 57
57 Indexes 109
109 Indexes 122
122 Indexes 39
39 Indexes 62
62 Indexes 59
59 Indexes 106
106 Indexes 95
95 Indexes 85
85 Indexes 116
116 Indexes 126
126 Indexes 52
52 Indexes 119
119 Indexes 58
58 Indexes 69
69 Indexes 123
123 Indexes 51
51 Indexes 74
74 Indexes 60 
60 Indexes 102
102 Indexes 101
101 Indexes 71
71 Indexes 104
104 Indexes 55
55 Indexes 64
64 Indexes 70
70 Indexes 107
107 Indexes 96
96 Indexes 36
36 Indexes 41
41 Indexes 37
37 Indexes 35
35 Indexes 45
45 Indexes 61 
61 Indexes 114
114 Indexes 84
84 Indexes 66
66 Indexes 89
89 Indexes 77
77 Indexes 78
78 Indexes 79
79 Indexes 125
125 Indexes 88
88 Indexes 90
90 Indexes 65
65 Indexes 94
94 Indexes 76
76 Indexes 93
93 Indexes 98
98 Indexes 87
87 Indexes 112
112 Indexes 124
124 Indexes 83
83 Indexes 80.
--------------------
Thats's it - the shuttle is complete - it has 70 elements.

adacrypt