Alice and Bob are fed up about having to deal with single bits all the time when wanting to exchange secret messages. Because one single bit could be enough to give away their secrets. Cryptographers have actually been using only whole characters for their encryption for centuries. This should really also still be possible today, especially when using modern technology. They will remember the old method according to which partners select a specific book and then compile the secret text by pointing to individual passages (e.g., a = page 27, line 12, letter 9 / b = page 19, line 4, letter 21 ... or in a simpler way by number code: 27,12,09 / 19,04,21 / 14,23,13 / ...). Of course, an attacker is only able to decipher the message if he also possess the agreed book (key).
Some comparable solution should be possibly achievable if
1. both partners - sender and addressee - generate an identical
cryptographic mechanism which, as to its function, corresponds with
the book. This could be a multidimensional array (matrix) in which
all plain letters are stored at secret but well defined positions,
2. the position (x, y, z) of a plain letter is searched for in the
array, assigned to a separate order system (transfer alphabet) as
indicator ("pointer") and is then sent to the addressee, and
3. the addressee will look for the received pointer in the transfer
alphabet, will find the position (x, y, z) in his identical array
(matrix) by reversing the order system and will thus be able to
decipher the plain letter.
B. Basic principle of the method
Plaintexts (bytes) are to be encrypted so that a plaintext alphabet, on the one hand, as well as a ciphertext alphabet, on the other, must exist. The following data as a simple example:
Plaintext alphabet (64 characters):
abcdefghijklmnopqrstuvwxyz 01234
56789/ABCDEFGHIJKLMNOPQRSTUVWXYZ
The plaintext alphabet with 64 characters [#1] will be stored in a two-dimensional matrix 8x8 (array)
and subjected to a thorough mixing (permutation) in every encryption cycle:
0 1 2 3 4 5 6 7
0 m 7 b G 4 h L j
1 x E l 0 B q k 1
2 d A 6 R i z I c
3 K o N 5 w O r M
4 W 2 / u 9 f a Q
5 v P F 3 y V p
6 T 8 t U H n Y J
7 g C Z D s X e S
The ciphertext alphabet (transfer characters) with 32 characters, independent of the plaintext alphabet,
consists of completely different characters:
@ # / &
The characters are stored in a vector (array) and also thoroughly mixed (permutation) for every
encryption cycle:
Ciphertext alphabet (32 characters):
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
# /
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
@ &
The following transfer text will result for the plaintext "Kryptographie":
K r y p t o g r a p h i e
30 36 55 57 62 31 70 36 46 57 05 24 76
Because the plaintext alphabet comprises 64 (8x8) characters the characters are changed from numbersystem
on base 8 to binary values (6-bit sequences):
base 8: 30 36 55 57 62 31 70 6-bit sequ: 011000 011110 101101 101111 110010 011001 111000 base 8: 36 46 57 05 24 76 6-bit sequ: 011110 100110 101111 000101 010100 111110A bit conversion separates the 6 bit sequences into 5 bit sequences, which get as index values the correspondent characters from the Ciphertext alphabet.
5-bit sequ: 01100 00111 10101 10110 11111 10010 01100 11110 index values: 12 7 21 22 31 18 12 30 5-bit sequ: 00011 11010 01101 01111 00010 10101 00111 index values: 3 26 13 15 2 21 7The characters found by this procedure are then used as transfer text:
ciphertext: # #
12 7 21 22 31 18 12 30 3 26 13 15 2 21 7
At the addressee the method creates identical plaintext and ciphertext alphabets. The indices of
the received transfer characters in the ciphertext array lead to the plaintext
characters in the permuted plaintext alphabet. The remaining task is how to find a
mechanism, which will result in an identical course at sender and at addressee, as well.
If you want to test the conversion from 6 bit to 5 bit sequences or from
7 bit to 6 bit sequences you may download two small selfextracting DEMO-programs
"R6Cipher.exe and "R7Cipher.exe"
Your system files will not be involved.
C. CypherMatrix as cryptographic Basic Function
In consideration of all this, an encryption method was developed which the author called: CypherMatrix®. Beyond of encryptions CypherMatrix turns out to be a universal Basic Function which may be used in most areas of cryptographic techniques.
A secret start sequence (pass phrase) as joint key at sender and addressee and a collision-free
one-way function generate an identical cryptographic mechanism at both sites.
Inputs are all bit series (especially 8-bit bytes like 256 characters of extended ASCII-set) and output
are ciphers from independent alphabets of 128 characters. The procedure applies byte techniques only, single
mathematics and modulo calculation, as well as converting of number systems (base 2 up to base 128).
You may get a short impression by the following graph in an attended Pdf-file:
The cryptographic generator - CypherMatrix - starts with an easy to remember start sequence of optimal 42 bytes (pass phrase). This master key controls the whole procedure from beginning to end. Some examples:
Blue heaven over Minnesota all the day long [43 bytes]
Le petit prince sourit avec mélancolie [38 bytes]
7 kangaroos jumping along the Times Square [42 bytes]
Woody woodpecker diving in the Murray Mouth [42 bytes]
The flying Dutchman was never in New Zealand [44 bytes]
Pass phrases have to be easy to remember and it's not necessary to write them down.
Because of their length they will not be object of lexical attacks. An attacker will
have no success when trying to analyse parts of a key separate or in segments because
key sequences can be found - if really - only in an unique process in total.
Changing of a single bit only ends in quite different results and blocks the function.
Start sequence 1: Blue flamingos flying to Northern Sutherland
d = 0110 0100
Hash value base 62: h8IfWro90
Hash value base 16: 21757DEB2C2AAE
Start sequence 2: Blue flamingos flying to Northern Sutherlane
e = 0110 0101
Hash value base 62: gbPZDI4Sc
Hash value base 16: 210C2721F72746
(Hash values are calculated with program "CMXhash.exe")
With the start sequence sender and addressee initialize a collision-free one-way-hash function [#2]. From 256 elements of the extended ASCII-character set the function generates a permuted array of 16x16 characters (CypherMatrix) and serveral control parameters. This function is the specific cryptographic "hard problem" [#3] of the method. There exists no inverse function which could be used to reconstruct the initial start sequence. Those unable to reconstruct the Matrix themselves will have no access to the identification factors and cannot decipher the encrypted text.
The following scheme illustrates the functional connections:
The "generator" may be used independent (e.g. hash value calculation and random bytes generation) or in connection with a coding device (encryption programs). The process repeats in utmost short cycles. In order to control the different enryption steps in each round a permuted CypherMatrix and the parameters variante, alpha, beta, gamma, delta and theta are generated to control different encryption steps. To achieve this the program extracts in each round the following byte sequences:
1. An independent cipher-alphabet with 128 characters (array 0...127),
2. a block key with alternatively 35, 42, 49, 56, 63 or 70 characters
(length must be divisible by 7),
3. a matrix key with 42 characters as start sequence to initialize
the next round and
4. alternative all elements of the CypherMatrix in total as a
"byte stream" to be stored in files of unlimited length.
Addressee generates by the same start sequence an identical CypherMatrix,
equal control parameters and identical cipher-alphabets. Start sequence is the only
input which controls the whole procedure, at sender and at recipient, as well.
2. Collision free one-way-hash functions
A procedure cycle works in four steps:
1. Extrapolating input sequence to a position weighted
interim result (Hk) based on a hash constant (Ck) in order
to avoid collisions,
2. expanding input sequence by multiplying each character value to
a unique hash function series of about 160 to 2400 digits (expansion),
3. contracting hash series by MODULO 256 to an array BASIC-VARIATION
of 256 characters (contraction) and
4. threefold permutation of the BASIC-VARIATION to generate a matrix
of 16x16 elements as final result.
This procedure repeats itself in plaintext intervals of alternatively 7 to 70 bytes
(multiple of 7) especially 63 bytes. At a definite position - defined by control parameter gamma -
the procedure extracts a digital sequence of 42 bytes as "Matrix key", which will
be returned to the start position of the next round ("loop").
A start sequence of length (n) comprises a series of definite signs (bytes):
sequence = a1 a2 a3 ... ai ... anFor the following explanations we choose the start sequence:
Horse racing on the banks of San Bernardino
To assign the start sequence univalent with a value (Hk) each character (ai) is denoted with an index value. Numbers of extended ASCII character set (zero - 255) serve as indexes. Expressed in bits the input sequence forms a digital series of "0" and "1". Devided into 8-bit sequences (binary numbers 0 to 255) the values can be expressed in decimal numbers and can be converted into other - especially higher - number system bases.
Following abbreviations mean:
n = length of start sequence
ai = character of start sequence (extended
ASCII-character set with 256 elements)
pi = position in start sequence
Hk = position-weighted hash value
First assignment by addition:
Hk = a1 + a2 + a3 +... ai +... an
(Single values for "ai" are increased by (+1) because otherwise ASCII-zero
would not be considered)
n
Hk = 
(ai + 1)
i = 1
Hk = 4007
But the thus calculated value is far away to serve as hash value. In order to obtain a unmistakable association of all bytes
some more features have to be added
As to common knowledge that every fact is exactly determined by coordinates for subject, location and time (cartesian coordinate system [#22]), we have to consider an additional attribut for the location. While the subject (byte ai) is marked by ASCII-indexes and time may be neglect (ti = 1) we state position (pi) inside the sequence to be the location of the concerned character ai.
Each sequence character (ai) is position weighted by multiplying its value with its location (pi)
n
Hk = (ai + 1) * pi * ti
i = 1
ti = 1
But collisions are not yet excluded. A collision occurs when despite of changing characters inside the
start sequence an equal hash value results. Thus, an additional factor must be provided which
comprises all cases resulting in collisions.
For a hash value the following features are absolutely necessary [#5]:
a) The hash function must be collision resistent and
b) has to be a one-way function.
Development of Hash Constant Ck is explained detalied in the pdf-file:
Determinants leading to collision free
Constant Ck depends on length of the hash sequence and an individually fixed user code. The constant is calculated as follows:
n = Length of start sequence
Ck = [(n - (n/(n-1))) / (n/(n-1) - 1)] + Code
Ck = n * (n - 2) + Code
n = sqrt(Ck + 1 - Code) + 1
The following graph demonstrates the interdependence between possible collisions and constant value Ck:
Code is a personally chosen parameter between 1 and 99 by which the constant
and the function in total will be individualized to the user. In an alternative solution
the factor Code can be multiplied instead of being added.
The procedure now calculates a position weighted partial hash value Hk which excludes collisions:
n
Hk = (ai + 1) * (Ck + pi)
i = 1
Hk = 7158981
n = length of start sequence
ai = element of the start sequence (extended
ASCII-character set with 256 elements)
pi = position in the start sequence
Ck = hash constant
Hk = position-weighted hash value
The calculated value Hk does exclude collisions but on the other hand
is still to narrow to establish a secure and unchallengeable hash result. To obtain more security an
expansion function is introduced which widens the determining factors to a
voluminous scale without loosing the quality of beeing collision free.
b) Expanding to hash-function-series
Expansion function gets the task to widen the really short start sequences (42 bytes)
to possibly utmost variables (160 to 2400 digits, signs) by way of a hash-function-series.
This function converts the values of the start sequences (ai) into digits of
higher number systems. Converting factor may be determined individually from base 36 up to
base 96. In our example we choose number system on base 83. In other applications
may be used base 77 alternatively.
The procedure generates the hash-function-series and a partial hash value Hp according to following pseudo-code:
FOR i = 1 TO n
si = (( ai + 1) * pi * Hk ) + (pi + c)
CALL DezNachSystem (83, si, digit)
Reihe = Reihe + digit
Hp = Hp + si
NEXT i
n = length of start sequence
pi = position in the start sequence
ai = element of the start sequence (extended
ASCII-character set with 256 elements)
si = single result of expansion calculation
c = user code
Hk = position-weighted hash value
Hp = partial hash value
expansion base: 83
contracting base: 84
digit: number in number system on base 83
Reihe: hash-function-series
Chosen number system on base 83 comprises the following digits:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg
hijklmnopqrstuvwxyz&#@{|
(determined by the Author, not standardized)
The assignment "Reihe = Reihe + digit" expands characters of the start sequence to as most as possible digital elements: "expansion effect". The function "DezNachSystem (,,)" converts decimal numbers up to digits in number system on base 83
The selected start sequence (43 bytes) results in the following Data:
hash constant (Ck: 1763 + 1 = 1764
position weighted value (Hk): 7158981
partial hash value (Hp): 636211483478
total hash value (Hk+Hp): 636218642459
Control parameters derived from destination Data show as follows:
Variante: (Hk MOD 11)+1 = 6 begin of contraction (84->dec) Alpha : (Hk+Hp MOD 255)+1 = 120 begin ciphertext alphabet Beta : (Hk MOD 169)+1 = 142 offset block key Gamma : ((Hp+Code) MOD 196)+1 = 104 offset matrix key Delta : ((Hk+Hp) MOD 155)+Code = 150 begin of dynamic bit series Theta : (Hk MOD 32)+1 = 6 dynamic number seriesIn defining the offsets of Gamma and Delta the chosen personal code is included. Thus, inspite of equal start sequences up to 99 different processes are possible. Because since 2nd round start sequences (matrix keys) are generated anew in each round there will be different control parameters in each cycle, as well.
Single digits of hash-function-series are calculated as follows:
char ai+1 pi (ai+1)*pi Hk (ai+1)*pi*Hk si base 83
digit
. ... .. .... ....... ........... .......... ......
o 112 14 1568 7158981 11225282208 11225282223 2hEB
n 111 15 1665 7158981 11919703365 11919703381 32DXp9
33 16 528 7158981 3779941968 3779941985 r&Xw
t 117 17 1989 7158981 14239213209 14239213227 3p30I
h 105 18 1890 7158981 13530474090 13530474109 3a8eXT
e 102 19 1938 7158981 13874105178 13874105198 3hSch
33 20 660 7158981 4724927460 4724927481 1GkagA
b 99 21 2079 7158981 14883521499 14883521521 3@oSX
a 98 22 2156 7158981 15434763036 15434763059 3I{x
n 111 23 2553 7158981 18276878493 18276878517 4r9edq
k 108 24 2592 7158981 18556078752 18556078777 4w|@F
s 116 25 2900 7158981 20761044900 20761044926 5Mc4cX
. ... .. .... ....... ........... ........... ......
sum = 636211483478 1gvEQA
Expanding variables to "Hash-function-series" 1gvfB0{GXkncq3hoJ|bJaV{dT2sC1cZ6h1ZL771q#RB1mlL2IFUFT2ML
YQg@xJmB2hEB32DXp9r&Xw3p30I3a8eXT3hSch1GkagA3@oSX3I{x4r9edq4w|
@F5Mc4cX1kZdDL5fDm3i5K3yY1zT{{4mBQG5hMwj6bRb71{Mu7K4BqWFX6ehvI7
hgPLp7ciA{6#&C8Cj7SZMKT7mfa08dKhe8&e58
(2) Sensitivity of start sequence
Changing of only one bit in the start sequence while all other data remain unchanged demonstrates the high sensitivity of the method:
Changed start sequence: Horse racing on the banks of San Bernardinn
o = 01101111
n = 01101110
hash constant (Ck: 1763 + 1 = 1764
control sum (Hk): 7157174
partial hash value (Hp): 635743138713
total hash value (Hk+Hp): 635750295887
Variante (Hk MOD 11)+1: 3 begin of contraction (84->dec)
Alpha (Hk+Hp MOD 255)+1: 63 begin ciphertext alphabet
Beta (Hk MOD 169)+1: 25 offset block key
Gamma ((Hp+Code) MOD 196)+1: 83 offset matrix key
Delta ((Hp+Hk) MOD 155)+Code: 28 begin of dynamic bit series
Theta (Hk MOD 32)+1: 23 dynamic number series
Expanding variables to "Hash function series" 1WnAB0&yX@zq2a9H{hs@HITXxd1cXS1ZJeak1qye51Jh2IBf2MH
cG@v4S2c6328BLq6l3oxgF3a2gs03hMSFn1GiTWH3@iM1Q3C7cL4r1Y44w
n0i5MSL1kW#8t5f41@5Jo81zQ4m3TGz5hDL|6bu8&G1{JJai4BjFs6eWYbb7
hTIRR7cVCw6#p5SS8CVsah7SMfjE7Y#c8d6Gtv8tot3
A comparison with the parameters of the unchanged start sequence shows the differing control Data.
No value at all corresponds with the foregoing positions. By the way this example demonstrates that the
start sequence has to be searched for in a unique process in total, if at all.
Expansion constitutes the first one-way-function of the procedure.
There is no way back to the start sequence.
c) Contracting to BASIC-VARIATION
In order to reduce the variables of the function to decimal data - beginning at variante - three each digits of the hash function series are converted to decimal numbers 0 to 255 by MODULO 256 (without repetition) and stored in an array (16x16) with 256 elements: BASIC VARIATION. To achieve the reverse convertion the hash function series is assumed to be digits in number system to base 84 (expansion base 83+1). Compared with number system on base 83 in number system base 84 there is one more digit, but this remains unimportant for the contracting procedure. Contraction process is the second one-way function. The function is irreversible and the way back to the hash function series is not possible. The contraction process can be performed alternatively with varied MODULO factors (2 up to 256, especially 8,16,24,32 and 64).
In single steps the procedure works as follows:
FOR k=1 TO 256
digit = MID$(Reihe, k, 3) three digit number base 84
CALL SystemNachDez (84, digit, decimal) reconversion
element = (decimal MOD 256) limitation on 0 to 255
variation(k)=element BASIC-VARIATION: 256 elements
IF k>1 THEN
n = 0
DO
INCR n
IF variation(n) = element THEN
INCR element
variation(k) = element
n = 0
END IF
LOOP UNTIL n = k-1
END IF
NEXT k
By this we get the following abridged derivation: fB0{GXkncq3hoJ|bJaV{dT2sC1cZ6h1ZL771q#RB1mlL2IFUFT2ML.....
3 digits decimal modulo 256 element
base 84
... ...... ... ...
2sC 18660 228 228
sC1 382033 81 81
C1c 84794 58 58
1cZ 10283 43 + 1 44
cZ 271142 38 38
Z6 253182 254 + 1 255
6h 522691 195 195
6h1 45949 125 + 1 126
h1Z 303527 167 167
1ZL 10017 33 33
... ...... ... ...
In the first round the following array Variation(k) is derivated with 256 elements BASIC-VARIATION (256 elements)
Distribution of the elements
183 204 129 221 148 113 021 018 217 026 060 115 103 254 171 161
166 222 087 048 205 125 035 206 043 121 188 242 094 228 081 058
044 038 255 195 126 167 033 229 023 083 061 120 223 007 088 027
201 128 202 056 143 130 086 138 024 042 089 233 246 014 109 102
019 210 168 219 111 156 123 158 030 067 203 131 243 127 046 101
133 090 085 244 049 020 073 238 155 207 112 172 194 050 196 160
136 008 193 114 025 119 232 134 099 208 029 212 000 062 218 022
235 220 226 173 224 034 151 216 178 245 185 116 240 181 174 236
091 132 004 209 154 200 106 092 145 045 047 225 214 227 053 028
211 135 137 074 057 157 082 139 031 040 037 122 100 124 140 051
189 197 177 039 054 104 230 192 011 182 213 041 165 079 002 175
231 052 107 110 199 234 179 093 032 149 059 001 215 237 141 159
016 096 239 013 075 176 180 241 055 198 117 152 063 017 247 064
147 036 150 248 095 118 249 250 076 015 144 009 065 162 163 251
252 253 164 066 068 084 003 069 005 006 105 142 153 010 072 012
097 070 184 169 098 108 071 077 146 078 080 170 186 187 190 191
Distribution of elements in the array depends on length of start sequences.
In case of lengths less than 36 bytes the order of numbers in the matrix may
be insufficient mixed. That might possibly harm the intenseness of permutation.
c) Threefold permutation to CypherMatrix
By the start sequence of the first round, respectively by the Matrix key beginning at second and further rounds, and two one-way-functions (expansion and contraction) the procedure creates an array with 16x16 elements variation(k), which is named as: BASIC-VARIATION.
f: Start-Sequence ---> BASIC-VARIATIONBASIC-VARIATION is a definite and irreversible mapping of the start sequence or of the respective matrix key.
Elements in the CypherMatrix are all characters of extended ASCII-character set (ASCII-00 to ASCII-255). Thus all numbers of BASIC-VARIATION can be related to values of ASCII-characters. In each round the procedure generates the CypherMatrix from all characters of array variation(k) in three loops (permutations):
k = Alpha Initialisation
FOR i = 1 TO 16
FOR j = 1 TO 16
Matrix$(1,i,j) = CHR$(Variation(k)) BASIC-VARIATION
INCR k 256 elements
IF k > 256 THEN k = 1
NEXT j
NEXT i
CypherSet$ = "" CypherMatrix in
FOR s = 1 TO 3 three loops
FOR i = 1 TO 16 (permutation)
FOR j = 1 TO 16
a = i - j
IF a <= 0 THEN a = 16 + a
SELECT CASE s
CASE 1
Matrix$(2,a,j) = Matrix$(1,i,j)
CASE 2
Matrix$(3,a,j) = Matrix$(2,i,j)
CASE 3
Char$ = Matrix$(3,i,j)
CypherSet$ = CypherSet$ +Char$ SERIES03.RND
END SELECT
NEXT j
NEXT i
NEXT s
In three loops a total permutation of all characters is performed :
CypherMatrix derived from BASIC-VARIATION (256 elements)
CypherMatrix (16x16)
1 8B 20 0F 50 F2 F6 32 AE 33 10 FD 81 C3 6F 77 6A 16
17 C0 37 06 3C 78 F3 3E 35 AF 93 46 57 38 31 22 52 32
33 5D 4C 4E BC E9 C2 B5 8C 9F FC CC FF DB 19 C8 E6 48
49 F1 05 1A 3D 83 00 E3 02 40 61 DE CA F4 E0 9D B3 64
65 FA 92 79 59 AC F0 7C 8D FB B7 26 A8 72 9A 68 B4 80
81 45 D9 53 CB D4 D6 4F F7 0C A6 80 55 AD 39 EA F9 96
97 4D 2B 2A 70 74 64 ED A3 BF 2C D2 C1 D1 36 B0 03 112
113 12 17 43 1D E1 A5 11 48 A1 C9 5A E2 4A C7 76 47 128
129 CE 18 CF B9 7A D7 A2 BE 3A 13 08 04 27 4B 54 15 144
145 E5 1E D0 2F 29 3F 0A AB 1B 85 DC 89 6E 5F 6C 23 160
161 8A 9B F5 25 01 41 BB 51 66 88 84 B1 0D 44 71 21 176
177 9E 63 2D D5 98 99 FE 58 65 EB 87 6B F8 62 7D 56 192
193 EE B2 28 3B 09 BA E4 6D A0 5B C5 EF 42 94 A7 7B 208
209 86 91 B6 75 8E 67 07 2E 16 D3 34 96 A9 CD 82 49 224
225 D8 1F 95 90 AA 5E 0E C4 EC BD 60 A4 DD 7E 9C E8 240
241 5C 0B C6 69 73 DF 7F DA 1C E7 24 B8 30 8F 14 97 256
Blue signed characters show the ciphertext alphabet extracted from the CypherMatrix beginning at parameter alpha (position 120).
Each element has the same probabiliy to be transfered to any position of the matrix. Due to extracting the matrix key from the last CypherMatrix to be the start sequence in the next cycle all permutations take effect directly at the next round, and by this for all further rounds, as well. According to the fact that all characters are passed on with the same probability very strong random effects are working to distribute the characters in the CypherMatrix. The course of all rounds and with that the distribution of characters in each round is determined all alone by the start sequence of the first round. This feature is used by the method to generate unlimited number series which can be changed into bit and byte series. Compared with encryption procedures block keys and XOR-techniques are not necessary here. All elements of a CypherMatrix are aggregated in a string CypherSet$ and stored in the file SERIES03.RND to result in a unlimited file of byte series.
A new CypherMatrix is created in each round. Due to the principles of probability
a repetition of the same distribution of matrix elements will occur once in 256!
(faculty) = 8E+506 cases. That should be sufficient for random performing.
In each cycle the control parameters (Alpha, Beta, Gamma, Delta and Theta) bring about the necessary partial sequences for performing procedure steps out of the CypherMatrix at different offsets. In random and hash calculations only gamma and delta are necessary, for encryptions in addition alpha and beta are needed as well. Delta and theta are necessary in byte series, only.
Fixing the partial amount "alphabet" (128 characters) is achieved by the parameter Alpha as follows:
Extracting the ciphertext alphabet (128 characters)
n = Alpha - 1
FOR i = 1 TO 128
INCR n
IF n > 256 THEN n = 1
Zeichen$ = MID$(CypherSet$,n,1) [Cypher-string]
SELECT CASE ASC(Zeichen$)
CASE <32 [without control characters]
DECR i
CASE 34,44,219,xxx [masking out of characters]
DECR i
CASE ELSE [ciphertext array]
ChiffreArray$(i) = Zeichen$
END SELECT
NEXT i
Certain characters (control characters ASCII-00 to ASCII-31, ASCII-34,44 and others) are
excluded because in some situations they do still their original tasks (e.g. ASCII-26)
and will disturb the proper performance.
Ciphertext alphabet (array 128 characters)
offset: Alpha = 120
Index 1 - 16: H Z J v G z
Index 17 - 32: : ' K T / ) ? n _ l #
Index 33 - 48: % A Q f D q ! c -
Index 49 - 64: X e k b } V ( ;
Index 65 - 80: m [ B { u
Index 81 - 96: g . 4 I ^
Index 97 - 112: ` ~ \ i s $ 0
Index 113 - 128: P 2 3 o w j
Ciphertext alphabet: hexadecimal
48 A1 C9 5A E2 4A C7 76 47 CE CF B9 7A D7 A2 BE
3A 27 4B 54 E5 D0 2F 29 3F AB 85 89 6E 5F 6C 23
8A 9B F5 25 41 BB 51 66 88 84 44 71 21 9E 63 2D
D5 98 99 FE 58 65 EB 87 6B F8 62 7D 56 EE 28 3B
BA E4 6D A0 5B C5 EF 42 94 A7 7B 86 91 B6 75 8E
67 2E D3 34 96 A9 CD 82 49 D8 95 90 AA 5E C4 EC
BD 60 A4 7E 9C E8 5C C6 69 73 7F DA E7 24 B8 30
8F 97 8B 50 F2 F6 32 AE 33 FD 81 C3 6F 77 6A C0
The ciphertext alphabet is implemented in all encryptions with CypherMatrix as cryptographic generator.
In the first procedure cycle the method takes from the CypherMatrix at parameter Gamma the following character sequence (42 bytes):
Matrix key (at offset: Gamma = 104 --> 42 bytes)
,6C HZJvGϹzע:'KT
A3 BF 2C D2 C1 D1 36 B0 03 12 17 43 1D E1 A5 11 48 A1 C9 5A E2
4A C7 76 47 CE 18 CF B9 7A D7 A2 BE 3A 13 08 04 27 4B 54 15 E5
The matrix key has to be led back to cycle's beginning in order to initialize the next run.
The series of matrix keys controls the identical course of the complete procedure at sender and
recipient, as well.
For XOR-concatenations with alternatively 7 to 70 bytes length (especially 63 bytes) the parameter Beta fixes the position in the CypherMatrix from where a sequence in length of the block key is to be extracted for concatenation with plaintext blocks of equal length.
In the first round the function generates the following block key:
Block key (at offset: Beta = 142 --> 63 bytes)
KT /)? ܉n_l#%AQf.Dq!c-Xekb}V(; m[
4B 54 15 E5 1E D0 2F 29 3F 0A AB 1B 85 DC 89 6E 5F 6C 23 8A 9B
F5 25 01 41 BB 51 66 88 84 B1 2E 44 71 21 9E 63 2D D5 98 99 FE
58 65 EB 87 6B F8 62 7D 56 EE B2 28 3B 09 BA E4 6D A0 5B C5 EF
Length of plaintext blocks - and by this length of block keys, as well - may be fixed
alternatively with 35, 42, 49, 56, 63 or 70 bytes (multiple of 7) for each session.
Block keys are necessary in encryption procedures with XOR-concatenations only.
Start Sequence as a master key constructs and controls the whole procedure. In order to combine additional applications with the Data Generator some Key Parameters are necessary. Following screen shot shows the parameters available:
To perform cryptographic applications the following key parameters are used:
Length of >Matrix Keys< : 36-64 bytes
Length of >Hash Sequences< : 32-96 bytes
Length of Block Keys : 35-96 bytes
Number System for Data output : 36-82 basis digits
Number System for Expansion function : 35-96 basis digits
individual User code : 1-99 numbers
In applications predefined key parameters are shown in last column of the screen shot.
In each case necessary parameters are mentioned in connection with explanation of the following
applications.
D. Applications based on the procedure
Contrary to actually most used bit techniques the CypherMatrix method works exclusive with bytes. In order to solve cryptographic tasks in particular are developed:
Generating of unlimited dynamic number series (DNG),
dynamic calculation of serial and final hash values,
simple digital signature and - of course -
all modes of encryption with xor-concatenation,
bit-conversion and further numerous operations.
CypherMatrix Generator is the Core of the application in each case.
The most important of them are described in the following.
1. Dynamic Number Generator (DNG)
Procedure's feature to generate unlimited character series by the respective CypherMatrix can be used as a dynamic Number Generator (DNG). Parameters to control the procedure are variante, gamma, delta and theta. Alpha and beta are not needed. As key parameters are necessary:
Length of >Matrix Keys< : 36-64 bytes
Number system for Expansion function : 35-96 basis digits
individual User code : 1-99 number
a) Unlimited Bit and Byte Series
The byte stream generated by the procedure may be transformed alternatively into 16-, 32-, 64- or other bit series of any length:
Generating series by threefold permutation is controled in three modes:
1. Current BASIC-VARIATION is used to perform the respective
permutations (continuous) or
2. MODULO-calculation to generate the BASIC-VARIATION is initiated
by varying parameter (theta), which will be created in each
cycle anew (alternating).
3. A third mode creates unlimited number series (DNG).
FOR k=1 TO 256
digit = MID$(Reihe, k, 3) three digit number base 84
CALL SystemNachDez (84, digit, decimal) reconverasion
element = (decimal MOD 256) limitation on 0 bis 255
variation(k)=element BASIC-VARIATION: 256 elements
IF k>1 THEN
n = 0
DO
INCR n
IF variation(n) = element THEN
INCR element
variation(k) = element
n = 0
END IF
LOOP UNTIL n = k-1
END IF
index = variation(k) - theta
IF index<0 THEN index = 256 + index
variation(k) = index
NEXT k
Parameter theta is calculated by (Hk MOD 32)+1 in each cycle, anew.
In each round all 256 elements of the respective CypherMatrix are stored correspondingly their distribution in succesive lines (byte series). Length of these series depends on inserted number of rounds. As "random number series" they are suitable for many-sided cryptographical tasks (e.g. as key files for "one-time-pad" and "multi-time-pad" encryptions).
The program Generate.exe with the "start sequence"
and 20.000 cycles generate the following file: SERIES03.RND:
Characters in the file SERIES03.RND
File contains in total 5120000 characters,
of these are 256 different characters;
on the average 20000 positions per character
'q B`C rf]恂S# 3,W|śo*J79 &pz@EXH
\ߩ[bkv:
+{lYw)8c0i!AgMUR_jG -y
=(uPt/}ѧ52eL
ZπQd% a $N
20000 z 20000 20000 m 20000
20000 20000 U 20000 4 20000
20000 @ 20000 20000 V 20000
20000 20000 R 20000 20000
' 20000 20000 20000 O 20000
20000 20000 20000 T 20000
q 20000 E 20000 20000 20000
20000 20000 20000 . 20000
20000 X 20000 20000 F 20000
20000 20000 20000 20000
20000 H 20000 20000 ~ 20000
20000 20000 _ 20000 I 20000
B 20000 20000 20000 20000
` 20000 20000 20000 20000
C 20000 \ 20000 20000 20000
20000 20000 20000 ? 20000
r 20000 20000 20000 " 20000
20000 20000 20000 D 20000
f 20000 20000 20000 20000
] 20000 20000 j 20000 K 20000
20000 [ 20000 G 20000 20000
20000 b 20000 20000 h 20000
20000 k 20000 20000 ^ 20000
20000 v 20000 - 20000 s 20000
S 20000 20000 20000 ->0 20000
20000 : 20000 y 20000 20000
20000 ->10 20000 20000 20000
# 20000 20000 20000 20000
20000 20000 20000 20000
->13 20000 20000 20000 ; 20000
3 20000 + 20000 20000 1 20000
20000 20000 = 20000 n 20000
20000 20000 20000 6 20000
, 20000 20000 ( 20000 20000
20000 20000 u 20000 20000
20000 { 20000 20000 20000
W 20000 20000 20000 20000
| 20000 20000 P 20000 20000
20000 l 20000 20000 > 20000
20000 20000 t 20000 20000
20000 Y 20000 / 20000 20000
20000 w 20000 } 20000 20000
20000 20000 20000 20000
20000 20000 20000 20000
20000 20000 20000 Z 20000
o 20000 ) 20000 20000 20000
20000 8 20000 20000 20000
* 20000 20000 20000 20000
20000 c 20000 20000 Q 20000
20000 20000 20000 20000
20000 0 20000 5 20000 20000
20000 20000 20000 20000
J 20000 i 20000 20000 d 20000
20000 ! 20000 ->255 20000 % 20000
7 20000 20000 20000 -> 26 20000
20000 20000 20000 a 20000
9 20000 20000 2 20000 20000
20000 20000 20000 20000
->32 20000 A 20000 e 20000 20000
& 20000 20000 L 20000 20000
p 20000 g 20000 20000 $ 20000
20000 20000 20000 N 20000
20000 M 20000 < 20000 ->9 20000
20000 20000 x 20000 20000
In total: 5120000 characters
average value: 20000
standard deviation: 0
random factor [1.0]: 1
optimal result: factor < 2.0
-----------------------------------------------------------------------
The test program FIPS PUB 140-1 of U.S.NIST
confirm the following results:
Monobit Test
Zeros = 10001 and Ones = 9999
9.654 < 9999 < 10.346
The Test is passed
Runs Test
2509: "0" length 1 2484: "1" length 1
1234: "0" length 2 1277: "1" length 2
640: "0" length 3 606: "1" length 3
300: "0" length 4 319: "1" length 4
145: "0" length 5 156: "1" length 5
161: "0" length 6 156: "1" length 6
The well known test program "ENT.EXE"
(available on demand) states on byte level the following result:
Entropy = 8.000000 bits per byte Optimum compression would reduce the size of this 5120000 byte file by 0 percent Chi square distribution for 5120000 samples is 0.00, and randomly would exeed this value 99.99 percent of the times Arithmetic mean value of data bytes is 127.5000 (127.5 = random) Monte Carlo value for Pi is 3.144568416 (error 0.09 percent) Serial correlation coefficient is -0.007182 (totally uncorrelated = 0.0).
Obviously these tests demonstrate that the procedure meets the requirements of random generation of bytes. By changing of only one bit in the start sequence there is no corresponding byte left at the same positions in both generated files. If, for instance, in the above mentioned start sequence the last bit at the end is changed from "1 to "0" completely different files will appear:
Sven Hedin is sailing around the Northpole
Sven Hedin is sailing around the Northpold
e = 0110 0101
d = 0110 0100
The random files generated with both the foregoing start sequences are marked by quite different
hash values:
SERIES03.RND Base 62: qq0Pjg9Ny9
Base 16: 9ED32B019D575E5
Base 10: 715283647750829541
SERIES04.RND Base 62: qpiZRTfk1h
Base 16: 9EDF9898CF0ED09
Base 10: 715220810015501577
You may download both the random files ZIP File (10,24 MB): FILESRND.ZIP
and test them by yourself. In addition the accessory program Generate.exe
is at your's disposal per download. Your system files will not be affected.
If the contraction process is calculated by MODULO 8 (alternativ by MODULO 16, 32, 64 or others) instead of MODULO 256 (as at contraction to BASIC VARIATION) unlimited number series will be generated. For example to perform the operation "Bit exchange BE" combined with other encryption steps.
Basic numbers to achieve the MODULO calculation can be extracted from the CypherMatrix or from the BASIC VARIATION as well. Begin of extraction is fixed by parameter delta.
Data for a 24-bit series - based on delta = 150 - create at begin the following 7 lines:
19 15 16 10 3 13 18 14 7 4 1 17 5 6 8 9 20 2 11 12 24 21 22 23
5 6 7 19 20 1 3 14 22 8 11 9 10 12 13 15 2 16 17 23 18 21 24 4
24 8 3 16 10 4 15 20 9 11 1 17 5 22 18 19 21 2 6 23 7 12 13 14
12 13 22 18 19 23 14 1 15 16 24 5 4 2 6 17 21 11 3 7 8 9 10 20
16 11 8 17 10 13 6 3 12 5 19 14 22 15 7 18 9 20 21 23 2 1 24 4
15 19 1 7 9 2 3 24 18 4 5 20 17 6 14 22 8 23 10 11 21 12 13 16
23 2 22 4 3 7 18 14 24 5 10 19 8 15 11 1 21 6 12 9 13 16 17 20
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
By means of the same technique basic series for 16-, 32-, 64- or other bit series
may be generated. For instance: In customary S-Boxes as dynamic 64-bit series or
in German Lotto-Zahlen (6 aus 49 + Zusatzzahl). You may download the program
LottoTip.exe and try the game once by yourself.
Your system files will not be involved.
The following description concerns an application as dynamic hash function for identification of digital series. Long digital strings (files) are devided into plaintext blocks (e.g. 64 bytes), which in each cycle are going in sucession to be sequentially position weighted, multiplied by the hash constant Ck, expanded to hash-function-series, again contracted to BASIC-VARIATION and finaly subjected to a threefold permutation (steps 1 to 3 of section C above). The result - last CypherMatrix with 256 elements - represents the Hash Value (H). An identical hash value will occur first in 256! (faculty) = 8E+506 cases.
Compared with customary hash functions the procedure has some advantages:
1. There is no compression function necessary,
2. No even block-length messages (no padding),
3. The function uses no bit techniques, bytes only and sole mathematics,
4. Function results allow for all mathematical operations (e.g. adding,
subtracting, multiplying, dividing and modulo calculating) and
5. Function results are much shorter than fixed length of 128 bit
rsp. 160 bit (SHA, MD5, RIPE-MD).
Two techniques of hash processing are possible:
a) Serial calculation of partial hash values from the CypherMatrix in
each round and accumulate to a hash value (serial mode: CMhash.exe) and
b) final calculation of the hash value from the last CypherMatrix
beyond all foregoing cycles passed (final mode: CMXhash.exe).
As key parameters are embedded:
Length of >Matrix Key< : 36-64 bytes
Length of >Hash Sequences< : 32-96 bytes
Number system for Data output : 36-82 basis digits
Number system for Expansion function : 35-96 basis digits
individal User code : 1-99 numbers
Connections are shown by the following schemes:
Development and working features of "CypherMatrix Hash Function" are detailed demonstrated in the following Pdf-files:
If the hash function is applied to both the message to be signed and the identification data (ID) of the signatory (including personal photo and signature) an extended digital signature" can be created.
Following key parameters serve to perform the application:
Length of >Matrix Key< : 36-64 bytes
Length of >Hash Sequences< : 32-96 bytes
Number system for Data output : 36-82 basis digits
Number system for Expansion function : 35-96 basis digits
individual User code : 1-99 numbers
(Note: name and data are free devised)
Name, location: Geoffrey Durbridge, Chicago
Birthday, location: 14.07.1954/Stratford-upon-Avon
pers. passphrase: Blue flamingos flying to Northern Sutherland
passport number: 890-abc-1234567
hash value pers. Data (base 62): YOYPAnbP8
passport photo (passfoto.jpg): + XgPGAxL1k
digital Sign (mysign.jpg): + XVVkCZ5tm
------------
ID-Data (base 62): = 1daTPYK2Ke
Because of security reasons an interim hash function is interpolated calculating a definite User code:
ID-Data hash User-Code
base 62 1daTPYK2Ke ---> YoXuUvgO7e
base 16 4ECD51CD806BA8 ---> 68A62761356923A
decimal 22180799407221672 ---> 471297370283741754
If the hash value of User-Code will be added to the hash value of any file we get a
simple signature of the document [#18] (here named >telecode<):
base 62 base 16 decimal
sender's User-Code YoXuUvgO7e 68A62761356923A 471297370283741754
+ file CANNERY.TXT + XHHnm47UC + 19D07B3CCCA9EC 7266102137367020
+ data-check *) + 1U5Z6 + 1DD7EB7 + 21947572
------------ ----------------- ---------------------
teleCode ZLpCIjEbAw 6A432F1517220DA 478563472443056346
*) In order to avoid finding sender's User-Code there is a data-check included in addition of the hash values.
Its amount results from the hashed file only, but isn't known by the parties concerned.
The simple signature >teleCode< is a determined information about content and sender in comprehended form. If the >teleCode< is transferd together with the respective file
a) the recipient is able to calculate the hash value of the file and
b) the recipient may verify "senders User-Code" from the difference
between hash value and the received "teleCode".
If sender's User-Code is stored in an internet database ("Signatur-Portal") the recipient
may test the integrity of the message and the identity of the sender by a checkback
to the internet database. In addition the recipient can download on his computer even the pass photo and the
personal sign of the sender and verify it by himself. Details you will find in the article:
4. Performance of digital encryption
The real encryption - the way from plaintext character to ciphertext character and back again - has not yet been covered at all. All processes explained so far, only serve the setup and parallel execution of the CypherMatrix (cryptographical mechanism) at sender and recipient. Encryption and decryption as symetric procedures are performed by separate operations.
Encryption procedures need following key parameters:
Length of >Matrix Key< : 36-64 Bytes
Length of Block Key : 35-96 Bytes
Number system for Expansion function : 35-96 Grundziffern
individal User code : 1-99 Zahl
CypherMatrix procedure achieves encryptions by combining of suitable operations: XOR concatenation, substitution "dyn24", bit conversion and bit exchange and further operations to be demonstated in details:
XOR concatenation is a standard operation. As there is yet no real protection with the simple XOR concatenation [#6] the method performs further a substitution "dyn24" as additional encryption step. Further solutions are "bit conversion BC: C1,2,3,4" and bit exchange BE" (denominated by the author).
With this operations the following combinations may be created:
Further combinations are possible, especially in the triple and fourfold area and by further operations still to be found. There is no end of researching.
Plaintext P on principle covers every byte (8 bits), that are all 256 ASCII-characters, but all pixels and other binary stored Data too. Limited ranges as at procedures "R6Cipher" and "R7Cipher" (see part B) are left out. By each combination an own cipher is build up not to be compared with others. Combinations with bit conversion, C2 cannot be cracked because Congruence of Length is nonexistent. No ciphertext character can be associated to a definite plaintext character. All other combinations may be target of known attacks, in the same way as current procedures do.
Best qualified for encryption purposes are the double combination: P - X - C2 (CYPHER22), P - Y - C2 (CYPHER24) and the threefold combination P - X - Y - C2 (CYPHER31) and P - Y - X - C2 (CYPHER33).
The encryption - for exanple CYPHER22 - is performed in three functions:
1. Partial dynamic "one-time-pad":
Plaintext --> block key --> XOR-concatenation,
2. Bit conversion:
8-bit XOR-concatenation --> 7-bit index values (0...127) and
3. Allocation of the ciphertext:
7-bit index values --> ciphertext array (0...127) --> ciphertext.
The following scheme shows the connections:
The plaintext and the corresponding block key extracted from the CypherMatrix are of equal length (here chosen with 63 bytes). Both, plaintext and block key are XOR-concatenated. In principle, that means a partial dynamic "one-time-pad" even for each cycle. The block key will not be repeated because a different key is generated in ech round.
The following encryption is performed by the program CypherXT.exe. We choose words from John Steinbeck (file: CANNERY.TXT) as an accompaning example:
The WORD is a symbol and a delight which sucks up men and scenes, threes, plants, factories, and Pekinese. Then the Thing becomes the Word and back to Thing again, but warped and woven into a fantastic pattern. The word sucks up Cannery Row, digests it and spews it out, and the Row has taken the shimmer of the green world and the sky-reflecting seas.
Plaintext (63 bytes)
The WORD is a symbol and a delight which sucks up men and scene
54 68 65 20 57 4F 52 44 20 69 73 20 61 20 73 79 6D 62 6F 6C 20
61 6E 64 20 61 20 64 65 6C 69 67 68 74 20 77 68 69 63 68 20 73
75 63 6B 73 20 75 70 20 6D 65 6E 20 61 6E 64 20 73 63 65 6E 65
Block key (at offset: Beta = 160 --> 63 bytes)
..!.?Eۤ...R^.x.B0.fZp ց(9LD
BB EF FF 8F FE 90 16 B1 0C C2 21 9E E6 9A 2E 3F 45 DB A4 F4 BC
D4 D8 CD 12 92 99 1F E8 A8 06 52 5E 0E 78 82 14 E0 CF 42 30 3C
66 5A A0 70 D2 0A D6 81 85 8D A6 28 39 C1 BA AD 98 4C F6 B5 44
XOR-concatenation (63 bytes)
D,R]F(˘2{o56zX|*.O.9..Xލ/!
EF 87 9A AF A9 DF 44 F5 2C AB 52 BE 87 BA 5D 46 28 B9 CB 98 9C
B5 B6 A9 32 F3 B9 7B 8D C4 6F 35 36 7A 58 F5 7C 89 AC 2A 10 4F
13 39 CB 03 F2 7F A6 A1 E8 E8 C8 08 58 AF DE 8D EB 2F 93 DB 21
c) Substitution "dyn24"
A substitution "dyn24" (author's designation) can be a preliminary coding step (CYPHER23) or a follow up step (CYPHER21) to the XOR-concatenation. In the following description the substitution is used in exchange of a XOR-concatenation (CYPHER12).
The procedure generates two matrices with four dimensions (2x2x2x2 characters) from the BASIC-VARIATION of 16 elements by cyclical permutations: Matrix A and Matrix B. In each matrix all hexadecimal digits (0 - F) are stored in well mixed manner. Digits are permutated in each round of e.g. 63 plaintext bytes difference and "Matrix A" and "Matrix B" are generated anew.
BASIC-VARIATION (16 elements)
Matrix A: 0 2 12 15 4 11 13 14 1 3 5 6 7 8 9 10
Matrix B: 10 0 12 1 5 4 15 6 14 7 3 8 9 11 2 13
Substitution >dyn24<
(2 matrices with 4 dimensions each)
Matrix A
0 C 4 D 1 5 7 9
2 F B E 3 6 8 A
Matrix B
A C 5 F E 3 9 2
0 1 4 6 7 8 B D
To implement a partial substitution the procedure takes the 8-bit sequence of a
plaintext character in hexadecimal notation (two-figure: 00 to FF), search for the left
figure in Matrix A and for the right figure in Matrix B and combines the four
found indices (0000 to 1111) to an eight-figure binary digit. This binary digits
represent the original plaintext or XOR-red characters. A substitution of the plaintext
Blue flamingos works as follows:
Plain- 1. Matrix 2. Matrix binary- subst-
text hex digit A digit B digit hex char
B 42 4 0100 2 1110 01001110 4E N
l 6C 6 1011 C 0010 10110010 B2
u 75 7 1100 5 1010 11001010 CA
e 65 6 1011 5 1010 10111010 BA
20 2 0001 0 0001 00010001 11 P
f 66 6 1011 6 0111 10110111 B7
l 6C 6 1011 C 0010 10110010 B2
a 61 6 1011 1 0011 10110011 B3
m 6D 6 1011 D 1111 10111111 BF
i 69 6 1011 9 1100 10111100 BC
n 6E 6 1011 E 1000 10111000 B8
g 67 6 1011 7 1001 10111001 B9
o 6F 6 1011 F 0110 10110110 B6
s 73 7 1100 3 1010 11001010 CA
Binary series: 01001110 10110010 11001010 10111010 00010001 10110111 10110010
10110011 10111111 10111100 10111000 10111001 10110110 11001010
Operating with the expanded ASCII-character set we get the substituted sequence:
NʺP. Next the substituted sequences can be concatenated
with the respective block key (CYPHER23) or can be subjected to a bit conversion
(CYPHER24). With the program "Cypher24.exe"
You may test the dynamic substitution once by yourself. Your system files will remain unaffected.
Note: Because the indices (-1) of a four dimensional matrix in binary number system supposedly are not present in every case, they are shown here in addition:
Dim. 1 Dim. 2 Dim. 3 Dim. 4
0000 0010 0100 0110 1000 1010 1100 1110
0001 0011 0101 0111 1001 1011 1101 1111
d) "bit conversion BC"
Data-technically, the "bit conversion" is a change in the number of bits in the respective character (C1,2,3,4). It offers the possibility of functionally separating plaintext characters and ciphertext characters. The series of 8-bit sequences from the XOR-concatenation are divided into a series of 7-bit sequences. 63 8-bit sequences are converted to 72 7-bit sequences. The number of the bits remain the same. No bit is added and no bit is removed. The decimal values of the respective 7-bit sequences (+1) are used as index values to the positions of characters in the Ciphertext alphabet. Thus 8 cipher characters are performed out of 7 plaintext characters. The characters are then combined to form the ciphertext and transmitted to the addressee. Read the following two pdf-files:
The following scheme demonstrates the course:
Best known is the procedure "Coding Base 64" which converts 8-bit sequences into a series of 6-bit sequences. The decimal values of these sequences are indices to a cipher alphabet of 64 characters.
The cipher alphabet may be predetermined static once
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef [32]
ghijklmnopqrstuvwxyz0123456789+/ [64]
or be permutated dynamic permanently:
317WXIq8VCv9+5ZnxSOJyLAtHi0clsB4 [32]
egR6jkUGdzuYfQpbDo/PEahMrFKNTmw2 [64]
This cipher alphabet is permuted in CypherMatrix procedure by personal passphrase
"Yellowstonebridge" (12 to 24 characters). Further the cipher alphabet is generated
continuously anew in each round of e.g. 63 bytes plaintext distances. Compared with plaintext
the length of ciphertext expands at a ratio of 6:8.
In order to achieve the bit conversion the CypherMatrix procedure expands the cipher alphabet
to 128 characters. The series of 8-bit sequences of the XOR concatenations (0...255) are devided
into series of 7-bit sequences (0...127) as indices (+1) for the characters stored in the secret
Ciphertext array (1...128). Thus, the functional connection between plaintext and ciphertext
is interrupted.
The selected plaintext is going on to be encrypted as follows:
XOR-concatenation before bit conversion
D,R]F(˘2{o56zX|*.O.9..Xލ/!
EF 87 9A AF A9 DF 44 F5 2C AB 52 BE 87 BA 5D 46 28 B9 CB 98 9C
B5 B6 A9 32 F3 B9 7B 8D C4 6F 35 36 7A 58 F5 7C 89 AC 2A 10 4F
13 39 CB 03 F2 7F A6 A1 E8 E8 C8 08 58 AF DE 8D EB 2F 93 DB 21
>bit conversion<
8-bit XOR-sequences converted into 7-bit sequences as "index values"
8-bit: 11101111100001111001101010101111101010011101111101000100 ....
7-bit: 11101111100001111001101010101111101010011101111101000100 ....
Hexadecimal 7-bit values after >bit conversion<
77 61 73 2A 7D 27 3E 44 7A 4B 15 35 15 7A 0F 3A 2E 51 45 0B 4E
2E 31 1C 5A 6D 55 13 17 4E 72 7B 46 71 0D 73 29 59 74 58 7A 5F
11 1A 61 28 20 4F 09 4E 39 30 1F 49 7F 26 50 7A 1D 0C 40 21 31
2F 6F 23 3D 32 7C 4F 36 21
Decimal index values (+1) destinated to the ciphertext array
120 098 116 043 126 040 063 069 123 076 022 054 022 123 016 059
047 082 070 012 079 047 050 029 091 110 086 020 024 079 115 124
071 114 014 116 042 090 117 089 123 096 018 027 098 041 033 080
010 079 058 049 032 074 128 039 081 123 030 013 065 034 050 048
112 036 062 051 125 080 055 034
Encrypted >Ciphertext< extracted by pointers
h-vuʳW6[c[ryKdXKġ)XA;NvڑJ{]-:XmFC|1̹}ßb.
68 2D 76 75 CA B3 57 F5 F7 36 5B 63 5B F7 72 79 4B 9C B8 64 58
4B CC 7F C4 A1 E9 29 87 58 EB EE 41 3B 4E 76 8B DA 91 4A F7 7B
5D 86 2D 9D A9 83 3A 58 AC 6D A3 F8 46 93 8C F7 43 7C 31 D3 CC
B9 7D E1 62 1F E2 83 F1 D3
With inserting the start sequence the addressee creates an identical course and structure of the entire
procedure. The method searches for the received characters in the array of the ciphertext alphabet,
will establish the respective index of the character [1...128] (index values), and converts the index to a
binary 7-bit value and connects the values to a 7-bit sequence. This sequence is then again separated into
8-bit sequences. 72 7-bit sequences result into 63 8-bit sequences (bit conversion).
Every 8-bit value corresponds with the XOR concatenation generated at the sender and may then be reconverted
to the initial plaintext with the help of the identically generated block key.
A fundamental effect of "bit conversion" already becomes clear by this small example: The length of text expands in this case at a ratio of 7:8. The initial 7 plaintext characters have become 8 converted ciphertext characters.
You may download the program teleCypher.exe as latest development of
CypherMatrix method and check all functions by yourself.
In case the plaintext-alphabet with 256 characters has the same volume as the ciphertext-alphabet
with 256 characters, but do not share the same structure, then prima facies a "bit conversion"
is not possible naturally. But nonetheless a changing of structures can be performed.
The ciphertext-alphabet is threefold permuted at defined plaintext distances and stored in an
index array of 256 characters. After plaintext blocks are concatenated with equal long block keys (CYPHER22)
the resulting values will be substituted with the ciphertext characters stored at the same index
in that array. The following outline characterizes the procedure:
Because each single plaintext character is replaced by one ciphertext character the congruence of length survives. Insofar here is a difference to all other CypherMatrix encryptions. If you want once to test the procedure you may download the program CypherSC.exe (corresponds to Cypher71.exe) on your computer without affecting the system files.
The principles of bit-conversion are applicable by changing 8-bit-sequences to 9-bit-sequences, as well. Hence, the ciphertext alphabet has to comprise 2^9 = 512 characters. Best will be to create the alphabet with japanese and chinese letters (but which are not at Author's disposal).
Each 9 bytes (72 bits) - plaintext or XOR-concatenated - are rearranged into 8 index-values of 9-bit-sequences. After thoroughly permutation in each cycle the cipher characters are stored in a three dimension matrix (array) of 8x8x8 = 512 characters. An example:
Plaintext: "new world"
9 sequences of 8-bit:
110 101 119 32 119
0110111001100101011101110010000001110111
111 114 108 100
01101111011100100110110001100100
8 sequences of 9-bit:
220(334) 405(625) 441(671) 7(7)
011011100110010101110111001000000111
237(355) 476(734) 310(466) 100(144)
011101101111011100100110110001100100
Ciphertext: "fpduTcGIu"
(These characters are generated by the following program)
The highest 9-bit-value is: 111111111 = 512. By changing into decimal numbers 512 index-values may be arranged. If one element characters are used the cipher text reduces at a ratio of 9:8. Addressing the cipher text takes place with 512 elements of number system on base 8 (000 to 777, in above index values show in green color). Because ASCII-character set normally does not comprises 512 elements the best will be we take two digits from the number system on base 128 (00 to =[16383]) to form one cipher character in an alphabet array 8x8x8. But, this procedure bears a disadvantage : length of ciphertext file extends by factor 1.77 (natural due to doubling of character length).
Bit-conversions at higher level (10-bit-sequences and superior) are just possibly in the same way, but the need of distinctive cipher characters will increase considerable.
10-bit-sequence: 2^10 = 1024 characters
12-bit-sequence: 2^12 = 4096 characters
16-bit-sequence: 2^16 = 65536 characters
In order to make a study of the working of a program including conversion 8 bit sequences to 9 bit sequences
you may download the program CYPHER-89.EXE and test all by yourself.
Your system files will remain unaffected.
The procedure bit conversion can be extended onto other number systems, for instance on Number System on base 4.
The operation
converts 4-digit numbers of number system on base 4 into 3-digit numbers of the same base. The 4-digit numbers 0000 up to 3333 express all ASCII-index values in the range from 0 up to 255. 3-digit numbers 000 up to 333 cover the range from 0 up to 63. A variable alphabet (array of 64 characters) which is extracted by ((Hk+Hp) MOD 255)+1 out of the current CypherMatrix anew in each cyclus can be dealed with this 3-digit numbers as indexes.
Encryption is achieved with three functions:
1. plaintext --> base4(4) --> base4(3)
2. start sequence --> cipher-array(64)
3. base4(3) --> cipher-array(64) --> ciphertext
Connections are shown by the example: "Yellowstonepark":
Y e l l o w s t o n e p a r k ASCII dec: 89 101 108 108 111 119 115 116 111 110 101 112 97 114 107Base 4 four-digit
base 4 three-digit
112112111230123012331
313130313101233123
212111300120113021223
indexes cipher-alphabet:
22 22 21 44 27 6 61 55 28 55 17 47 27 38 21 48 24 23 9 43
Ciphertext:
wƓ]4Y4wk"d
In order to achieve a more secure encryption the operation may be combined with the above presented procedures.
The operation "bit-conversion" has a serious disadvantage: By changing 8-bit sequences into 7-bit sequences (Cipher-alphabet 128) the ciphertext compared with the plaintext lengthens in a ratio of 7 to 8. Often in practice one demands to store the ciphertext at the same memory space where the original plaintext had been stored. Thus, an equal length of both texts is obligatory. An additional amount of memory space is no longer required.
This disadvantage can be avoided by ordinary means: The "bit-conversion" is associated with a bit-regression (named by the author), 7-bit sequences are led back to 8-bit sequences and the primarily length will be attained again. Steps used at decryption process - changing 72 7-bit sequences back to 8-bit characters - seems to be an appropriate solution.
But, there rises a severe problem: When identical steps are implemented we surprisingly get back the original plaintext instead of the desired ciphertext. A second way has to be searched for. The found solution comprises the following: All digits of number system on base 128 are introduced as a second system array (128 digits) and used as transfer characters. The procedure covers five functions:
1. plaintext --> key --> 8-bit XOR-sequences
2. 8-bit XOR-sequences --> bit-conversion --> 7-bit index values
3. 7-bit index values --> system-array (128) --> transfer characters
4. transfer characters --> bit-regression --> 8-bit index values
5. 8-bit index values --> ASCII-alphabet --> ciphertext
Instrumental in performing the "regression" is the system array (128). The digits of
number system on base 128 are taken from the current CypherMatrix
(threefold permutation of ASCII-alphabet) and stored in a separate array (128):
digits of number system on base 128:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz&#
@{|}
(determined by the Author, not standardized)
7-bit sequences of the digits (transfer characters) are combined to a series of bits, which next will be devided into 8-bit segments. Each 8-bit sequence as index value searches for the appropriate character in the ASCII-alphabet and combines it to the desired cipher text.
The pseudo code demonstrates as follows:
FOR K=1 TO LEN(conversion)
digit = MID$(conversion,K,1)
CALL SystemNachSystem (128,2,digit,bin7number)
sequence7bit = sequence7bit + bin7number
NEXT K
FOR I=1 TO LEN(sequence7bit) STEP 8
bin8number = MID(sequence7bit,I,8)
CALL SystemNachDez (2,bin8number,decimal)
character = CHR$(decimal)
ciphertext = ciphertext + character
NEXT I
In order to test the operation you may download the demo programm CypherRE.exe
(corresponds to: Cypher92) and check it by yourself.
A further encryption technique "bit exchange BE" performs an exchanging of bits in a single byte (variation of 8 bits). Sequence of the bits may be any order, but each bit must retain its own value.
In this mode user inserts the bits 1 to 8 in any chosen order (written order of the bits in binary system contrary to bit technical numbering):
plaintext byte: a
binary: 01100001
bit order: b1, b2, b3, b4, b5, b6, b7, b8
code text: ac
chosen bit order: b7, b2, b3, b4, b8, b1, b6, b5
binary: 01101000
code text byte: h
Bits of plaintext byte a are exchanged as follows:
The following example substituts the plaintext word: "world"
User inserts alternatively his chosen bit order:
plaintext bit order: 1 2 3 4 5 6 7 8 plaintext: ... world ... decimal: 119 111 114 108 100 binary: 01110111 01101111 01110010 01101100 01100100 inserted bit order: 7 2 3 4 8 1 6 5 binary: 11111010 11101011 11110000 01100011 01100010 decimal: 250 235 240 99 98 code text: ...cb ...But bit exchange alone is not sufficient secure. A further encryption step must be added, at best with the combination: bit exchange - bit conversion (CYPHER28).
Due to the variation of 8 bits in a byte there are in total 8! = 40320 eventualities to create different encryption programs. In case of identical plain text bit order and exchanged bit order the mode of bit exchange will be naturally null and void, it results in a simple "bit conversion" (CYPHER13).
Formalized the following scheme shows the connections:
Switch S in the scheme above shifts from manual input to dynamic generating
of bit series. In case of manual input the addressee naturally has to insert the same
bit order as the sender.
Instead of manual input the program may be alternatively performed with generating the bit orders by dynamic parameters. In fixed sequences (7 to 84 bytes) arbitrary bit orders are extracted from the current CypherMatrix at parameter d3elta. By this the bit order is changed in every round (cycle) of the program.
The program Cypher28 for example creates with two different start sequences - which differ in one bit only - the following bit orders in the first 7 rounds:
Start Sequenz 1: Am 12.August hat es in München nur geregnet
Start Sequenz 2: Am 13.August hat es in München nur geregnet
binär: 2 = 00110010
binär: 3 = 00110011
round start sequence 1 start sequence 2
1 3 7 8 6 4 1 2 5 1 8 6 5 4 7 2 3
2 1 5 2 6 8 7 3 4 3 8 1 2 4 5 6 7
3 1 2 3 4 5 6 7 8 2 1 4 8 5 6 7 3
4 6 1 3 7 8 2 4 5 4 8 1 3 5 6 7 2
5 1 6 4 8 3 2 7 5 6 4 8 5 2 1 3 7
6 1 2 3 4 8 5 6 7 6 3 2 1 4 7 5 8
7 6 3 8 4 5 7 1 2 5 1 7 8 4 2 6 3
8 . . . . . . . . . . . . . . . .
By means of the same technique also 16-, 32-, or 64-bit series may be dynamic exchanged in their
internal order. In order to test this technique you may download the demoprogram
CypherBE.exe (equivalent to CYPHER28) and encrypt some texts on a trial basis.
Exchanging of bits is not restricted only to single bits, but can be extended by the same technique to all bits in a series of bytes, as comparatively to basis of customary "S-Boxes" with 64 bits.
Following demonstration shows how single bits in a series of 4 bytes are dynamically exchanged.
As an example the word: Welt:
Exchanging of bits covers alternatively blocks from 4 to 32 bytes length (Cypher55). During the first cycles for accordingly 4 bytes the operation creates following 32 bit series:
22 14 15 16 11 30 28 6 18 23 17 2 19 13 1 4 20 31 21 29 5 24 7 8 32 9 10 12 25 26 27 3 13 10 28 4 8 31 2 19 5 14 6 21 3 15 16 18 7 17 11 25 20 22 23 24 9 26 32 12 27 29 30 1 5 14 18 19 15 12 28 10 29 6 1 26 23 8 31 9 13 32 11 27 7 16 2 17 20 24 21 22 25 30 3 4 30 14 12 21 11 25 20 9 17 24 2 8 16 29 5 31 1 15 23 28 18 32 19 3 4 6 22 26 27 7 10 13 25 8 23 26 24 27 7 17 3 9 30 20 15 28 4 14 10 11 18 32 29 2 31 1 21 22 5 6 12 13 16 19 27 26 12 6 30 11 4 13 7 14 31 9 29 32 1 8 5 15 10 2 3 16 28 17 18 19 20 21 22 23 24 25 30 22 3 10 9 11 26 18 8 13 19 27 4 14 15 16 12 28 5 21 24 29 31 20 17 23 25 32 6 1 2 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Programs including bit-conversion (C2) (Cypher56 to Cypher58) must have blocks of at least 7 bytes (or a multiple of 7). In order to test the procedure you may download the demo program CypherSB.exe (corresponds to: Cypher57) and try some examples. Your system files will be unaffected.
In case of longer and more intensive working with the subject even more and new possibilities come into consideration. For instance : bit crossing, a further operation in addition to the above already introduced four combinations to perform encryptions:
Plaintext to be encrypted is devided into blocks of each 7 (or a multiple of 7) characters and the 8 bits of each single character are stored in an array (matrix of 7x8 bits). Plaintext block "Francis" as an example:
char ASCII array
8-bit
F 70 01000110
r 114 01110010
a 97 01100001
n 110 01101110
c 99 01100011
i 105 01101001
s 115 01110011
The procedure takes the 7 bits of each single column and converts them crossing into 7 bit sequence as
a line of a new array, which - changed into decimal numbers - serve as indexes (+1) for the secret cipher
characters (0...127) stored in the array "Cipher-alphabet 128":
7-bit index Cipher-alphabet
(+1) hex char
Sequenz 1 0000000 1 95
2 1111111 128 99
3 0111111 64 7A z
4 0100001 34 CF
5 0001010 11 7C |
6 1001000 73 C0
7 1101101 110 C1
8 0010111 23 61 a
Decryption goes the reverse way. Due to shortening 8-bit sequences to 7-bit sequences the same
advantage will be achieved comparable to cases of bit conversion. Especially in connection with the
already above presented operations further encryption modes are possible.
Next a substitution is illustrated which depends on Number System on Base 256. Due to short of standardized numerics the characters of extended ASCII-character set serve as basis.
Because plaintext containing messages to be encrypted can be expressed in ASCII-characters those signs
may be used as figures in number system on base 256 as well.
In so far each character of the plaintext is assigned to a definite number: 0 up to 255.
The following table shows the connection of single numbers with the corresponding character of the plaintext:
(determined by the Author, not standardized)
For encryption purposes the procedure reads the plaintext character to be a digit of the number system on base 256, changes this digit into the equivalent decimal number which as an index gets the allocated cipher from the current CypherMatrix and writes it to the resulting ciphertext serially.
As an example the word: Basis
Position Matrix
Klartext 256 element
B 11
a 37 P
s 55 v
i 45 "
s 55 v
A disadvantage of this procedure you see already by this small example: all characters inside a plaintext block (e.g. 21 characters)
will be encrypted to the same signs. In order to get secure results this procedure has to be connected with one or
more operations. In principle all operations introduced in this article are suitable for this task.
If you want to test encryptions by means of number system on base 256 a DEMO program
"Cypher98.exe" is on your disposal by downloading.
Supplementary you may demand the program "NumberAD.exe"
for changing numbers from system on base 2 up to base 256 an try out what this tool can do.
Your system files will not be affected by this.
Contrary to the bit and byte substitition demonstrated up to now the following operation comprises a byte transposition BT. Single bytes in plaintext blocks of defined length are mixed up inside the block.
The plaintext is devided into blocks of length N (7 bytes or a multiple of 7). Each byte is denoted with it's position inside the block and stored in an array (vector of length N). In each cycle the operation generates from the BASIC-VARIATION by MODULO N a dynamic number series with length of the respective block (e.g. MODULO 21, see part: D,1,b). The permuted number series perform the new order of the bytes in the array. By this way all single bytes are totally mixed up.
With the start sequence: Baron Münchhausen reitet über den Bodensee, the plaintext "HESSE.TXT" and a block length of N = 21 (delta: variabel) the first cycles result to the following byte series:
7 8 15 11 9 16 2 4 20 5 14 12 19 10 13 1 3 6 17 18 21
6 19 5 2 7 4 8 20 9 13 16 11 10 12 21 14 15 17 18 1 3
17 4 5 15 3 18 20 1 10 7 13 11 6 19 8 21 9 12 14 16 2
9 2 10 5 16 14 3 4 17 11 20 8 6 18 7 12 13 15 19 21 1
21 18 16 15 1 11 19 17 20 2 9 12 10 3 6 7 14 13 4 5 8
. . . . . . . . . . . . . . . . . . . . .
Next the procedure transposition BT can be combined with further operations.
In our example are combined first a substitution dyn24 and than a bit conversion C2
(Cypher53).
The first cycles of file "HESSE.TXT" with a chosen block length of 21 bytes show the connections as follows:
Als Siddhartha den Hain verließ, ......
Substitution dyn 24
>hexadecimal substitution dyn24<
DB BA B5 B5 B3 B7 C8 BD B2 3B 33 B7 B4 B3 3E C8 47 C8 C8 B3 C8
>bit conversion<
8-bit dyn24-sequences
11011011 10111010 10110101 10110101 10110011 10110111 11001000
10111101 10110010 00111011 00110011 10110111 10110100 10110011
00111110 11001000 01000111 11001000 11001000 10110011 11001000
7-bit sequences after conversion
1101101 1101110 1010110 1011011 0101101 1001110 1101111 1001000
1011110 1101100 1000111 0110011 0011101 1011110 1101001 0110011
0011111 0110010 0001000 1111100 1000110 0100010 1100111 1001000
>hexadecimal values of the conversion<
6D 6E 56 5B 2D 4E 6F 48 5E 6C 47 33 1D 5E 69 33 1F 32 08 7C 46 22 67 48
>Ciphertext<
WT$irUJi1J4:C
As an example of dynamic transposition the demo program CypherBT.exe (correspods to: CYPHER53)
is at your disposition. There is no effect on your system files.
One-time-pad is a perfect encryption mechanism, invented in 1917 by Joseph Mauborgne and Gilbert Vernam (known as Vernam Chiffre) [#19]. The problem arising in conjunction with one-time-pad encryption is to find a suitable way of exchanging a key of the length of the plaintext between sender and receiver [#20]. With the program described here this problem will be solved without difficulties. The key series will be best created with the Dynamic Number Generator.
The receiver of an encrypted message can generate an identical byte series by inserting the same start sequence as sender. Exchanging a key, as long as the plaintext, is not necessary any longer.
The key file DEVICE01.OTP (equal to SERIES03.RND) should be stored on the hard disk or, as recommended, may be burnt on a CD-ROM (key-CD). The receiver has to get a copy of this key CD, of course.
The following illustration shows a schematic overview of the cryptographic mechanism:
To encrypt plaintext files a definite offset must be chosen (e.g. 7654) in order to begin XOR-concatenation ongoing from that position. The effective key sequences are taken as part from the key file starting at the respective offset point. By this way the plain text to be XOR concatenated is as long as the partial key (one-time-pad). The space between offset and end of key file must be longer than the length of the plain text file, of course. Otherwise the key cannot be as long as the plain text to be encrypted [#21]. As an example:
length of key file: 1,280,000
length of plaintext: 380,561
----------------------------------
highest offset point: 899,439
chosen offset point: 7,654
The receiver must generate an identical key file or use the key-CD.
Decryption process starts at the same offset with XOR-concatenating cipher
text and block keys. The offset may vary each time and must be communicated between
sender and addresse on a secure way. As an example for encryption based on this principles
you may download the file Message7.zip and try to decrypt
it (start sequence and cipher text).
Getting access on the key is possible during the whole procedure. If a short sequence of the ciphertext shall be decrypted separately and its position from begin of the ciphertext is located, then a random access may succeed without decrypting the total file. XOR-concatenation leads to a ratio of 1:1 between ciphertext and plaintext. By this the difference (in bytes) from begin of ciphertext to the located position has to be added to the chosen offset of the key:
position in ciphertext: 987
chosen offset: 7.654
------------------------------------
position in key: 8.641
If ciphertex and key-sequence are XOR-concatenated beginning at the calculated position in the key
you may decrypt and read the respective part of the ciphertext.
"One-time-pad" procedure has two important diseconomies: The key - which has to be as long as the plaintext - has to be interchanged between sender and recipient by very secure channels and each key is allowed to be used only once.
"Multi-time-pad" procedure - name by the author - avoids this disadvantages on a simply way. The procedure works based on CypherMatrix procedure. A "start sequence" basically of 42 characters (here as an exception 48 characters) generates in each cycle of 36 plaintext characters synchronous and unlimited a dynamic key supply and a separate cycle-alphabet of 256 ASCII-characters. At constant "start sequences" the multi-time feature is achieved by entering a corresponding UserCode (number from 1 up to 999). Due to generating different parameters the "UserCode" effects a quite different course of the procedure and encryption results, as well. As the case arises the parties hereto have only to exchange the appropriate "UserCode".
The plaintext characters (block of 36) will be replaced by other characters from the cycle-alphabet, the substituted block then is subjected to a further substitution dyn24 and the resulting block is XOR-concatenated with a partial block key derived from the cycle key supply.
The following scheme demonstrates the course:
To achieve the decryption the course is running conversely. Plaintext and ciphertext remain equal. Hence, congruence of length is given and the procedure is submitted to all today known attacks. Because there is a threefold combination of encryption steps the procedure may be proved secure.
You may download a demo program CypherMT.exe and test all by yourself.
E. Comparing with customary procedures
Most of typical used encryption procedures today work on base of a uniform function
(one way function) and bit manipulation. In return to CypherMatrix procedure the coding function
is based on two separate ranges (generator and coding function) with three one way functions
(position weighted, expansion, contraction to BASIC-VARIATION and further integrated operations:
X,Y,C2,E,B4,CR,BT and SBE). The CypherMatrix procedure uses simple mathematics, MODULO calculations and
higher number systems (base 2 up to base 128).
Following outline demonstrates the connections:
The single signs mean:
pi = plaintext character
i = position in plaintext
k = key
ci = cipher sign
St = start sequence
n = procedure step (text block)
mn = matrix key
kn = block key
An = cipher alphabet
cii = cipher sign
In the demonstration topical procedure steps inside the function remain ignored caused by
simplification (particularly Feistel-steps and S-boxes).
Encryption (coding function) comprises all steps from inserting plaintext
pi to output of ciphertext ci:
ci = f (pi,k)The generator of CypherMatrix procedure creates for each plaintext block pn a matrix with 16x16 characters and the variables kn and An necessary for encryption and mn to loop back to start and processing the next cycle. The variables are depending on the matrix key derivated from respective foregoing matrix and by this causative on the start sequence St:
kn = fx (St)
An = fy (St)
Because there is no functioning connection between kn and An
the coding function shows as follows:
cii = f (pn,kn,An)As kn and An both depend causativ on start sequence St the coding function shortens to:
cii = f (pn,St)Quintessence: The start sequence St controls the entire procedure.
For decrypting purposes the procedure works the reverse course.
By inserting the start sequence the generator creates an identical course of the procedure as at sender and by this identical matrices and variables. Variables An and kn in the decoding function
pi = f (cii,An,kn)
pi = f (cii,St)
then lead back to the plaintext pi.
F. Cryptanalysis of the method
Compared with conventional bit-encryption methods the here presented method indicates a remarkable difference: in first case the structure of the bits are changed, only. The number of bits in the plaintext characters (input) and in the respective ciphertext character as well (output) are principaly equal (8-bit). It exists a Congruence of length. Insofar there is a uniform digital order system in the whole encryption procedure: ci = f (pi). This is the reason why the encrypted text has certain informations of the respective plaintext [#7].
In second case including additional "bit-conversion" there exists no uniform order system. The connection between plaintext (p) and ciphertext (c) is achieved by at least three separate functions:
c = f [f3, f2, f1]
f1 = "Plaintext bits" XOR-concatenated by "block keys",
f2 = Conversion of XOR-concatenated 8-bits into 7-bits "index values",
f3 = 7-bits index values leading to positions of characters in the
permuted ciphertext alphabet.
But ciphertext characters as result of the second function ("index values") are only "pointers" to supply the
third function with inputs in order to address the respective positions of ciphertext array at the recipient.
However, the "pointers" do not contain any information about the plaintext. Therefore, if the encrypted message is not carrying any information about the initial plaintext the secret text is actually of no value to any attacker. In a data-technical sense this is a "coding by pointers" [#8]. The only possible access is via the start sequence and by reproducing the correct CypherMatrix (encryption building as cipher device) at the addressee.
Attempts of drawing any conclusions from the ciphertext to the plain text presuppose that both areas can be compared. Insofar, there has to be a uniform order system which must be effective in plaintext and cipher text, as well. For the written text these are syntax and entropy of the language and for the digital representation of the characters as input and output it is bit structures.
Repetition patterns and word combinations, frequency structures and two-digit-groups, are part of the order criteria [#9].
However, an analysis on the basis of these features presupposes that plain text and cipher text are at a ratio of 1:1
to one another, i.e., that a specific ciphertext character must exist for each single plaintext character.
This condition is not met by the present method.
The "bit conversion" forms 8 cipher characters out of 7 plaintext characters. In addition, the
independent ciphertext alphabet comprises only 128 characters while the plaintext alphabet consists of a total
of 256 characters.
The best-known attacks on encrypted messages include structure analysis, "known plaintext attack", "chosen plaintext attack" and "brute force attack", and possibly also "differential" and "linear" cryptanalysis [#10]. These attacks are meant to filter out statistically acquirable regularities from the ciphertext which may possibly show a lead to the plaintext. However, all these methods presuppose that plaintext and ciphertext are of identical length. The idea is that every plaintext letter is brought into a relationship with the appertaining ciphertext character. Because of the bit-conversion and thereby caused the extension of the ciphertext this necessary condition is not implemented with the CypherMatrix. All attacks dispenses with a fundamental basis: the Congruence of length. Thus, related to CypherMatrix method, we may forget all these attacks. In order to test this statement you may download a ZIP-file with some by CypherMatrix programs encrypted messages "message5.ctx to message9.ctx" (7.2 MB) and try to break the cipher with the mentioned attacks.
If all conventional attacks do not succed due to lacking congruence of length an attemp of brute force attack should be still possible [#11]. For this the method offers the following entry situations:
1. Searching for the "start sequence" at the beginning,
2. taking advantage of certain points during running procedure and
3. backwards searching from ciphertext to plaintext.
The attacker will only have to try out all flow data of the program with all possible data
and then check the result for plausibility [#12].
a) Searching for "start sequences"
Sender and addressee as well initialize the total course of the procedure by the start sequence as a master key, only. Except plaintext other inputs to the running procedure are not necessary, even not possible. The entered key sequences of the user optimally encompass 42 bytes. Since the start sequence is usually made via the keyboard (approx. 100 characters) 100^42 = 1E+84 possibilities will be the result in practice (key range). If the key length is defined as exponent (x) to base 2, the exponentiation of which will be the combination of all input possibilities, the key length in this case will be about 266 bits (entropy = 265.75) [#13]. But because the length of the key may be chosen (between 36 up to 64 bytes) and principaly all 256 ASCII-characters may be used the key range will be much larger in reality. It extends maximal up to 256^64 = 1.34E+154 combinations. That is a key length of 512 bits (entropy = 511.99) and a complexity of O(2^512). If an attack cyclus lasts a moment of 1/1000 second then the time to result in a seccess will be 3.17E+114 years. That means more time till all material in the universum will become fluid at zero degree Kelvin [#16].
An attacker cannot have a leg to stand on success by analysing single parts or step by step parts of the start sequences. The key sequences must be found in one straight succession process. Results from foregoing attemps are helpless. But that requires enormous time. Dictionary attacks (on base of literary or colloquial quotations) can easyly be avoided by small variances. Main point is to keep the passphrase well in mind without writing down anywhere.
Another case of "brute force" is the so called "birthday attack" [#12a]. But this case can even have no
success. Primarly this method is fit for finding two identical sequences (in case of collisions)
but not to find the really used start sequence. But this is necessary to break into the procedure.
b) Survey points in the running procedure
For a "brute force attack" on principle there is no starting point in the running procedure. However one may try to reconstruct a matrix key. The offset of a "matrix key" in the respective CypherMatrix is determinated by modulo 196 +1 from the results of the expanded hash-function-series based on the foregoing "matrix key". Hence, this matrix key has to be found first before a "brute force attack" can be started. The continual matrix keys refer to 256 possible characters. With a key length of 42 bytes the possibilities for a character occurring (key range) will then be 256^42 = 1.4E+101. This corresponds with a key length of about 336 bits (entropy = 336.00).
Further, one could try to find the parameter of BASIC VARIATION which is necessary to create the CypherMatrix (16x16 characters). Every BASIC VARIATION is preceded by a selection of specific characters (256 ASCII characters). These characters form the elements for the CypherMatrix. If the BASIC VARIATION is subjected to a "brute force attack" the elements of the matrix and their distribution too must be known, of course prior to the generation of the BASIC VARIATION to be attacked. Selection of the characters and their distribution depend on the matrix key taken from the foregoing CypherMatrix. Which first are generated solely by the start sequence. But the attacker does not know them. After all, they are what the search is about.
Added to the possibilities of the Basic Variations are also the variations of the matrix elements and their distribution in the
preceding matrix. In the case of 256 characters (matrix 16x16) these are a total of 256! (faculty)=8.57E+506 combinations.
Therefore, the attacker would have to try a total of 2.09E+13 x 8.57E+506 = 1.79E+520 cases. Of course, no attacker will
survive this, nor his heirs.
c) No results in backward searching
But a "brute force" attack starting with the ciphertext backwards to the plaintext will even have no success by the following reason:
Principally the attacker knows the Ciphertext and the respective length of the encrypted message. Further he knows the method "CypherMatrix" with its three functions:
Because an attacker must assume the encoding process has been started by a start sequence between 36 to 64 bytes, he will dispense with an attack on the begin (key length = 512 bit). It seems to be much more promising to take the available cipher text as a basis and roll up the procedure from its end.
First the ciphertext array with 128 characters and their distribution in the matrix
have to be found out. The values of the ciphertext characters (hex or binary) are not qualified for this task,
because they are no functional part of the encryption procedure. The 7-bit values necessary for
reconverting to 8-bit sequences of the XOR-concatenation only will be given by the positions of
the characters in the ciphertext array. The 128 ciphertext characters in the array result in a combination
range of 128! (factorial) = 2.85E+215. Concerned with this data it is beyond all hope to find the
correct distribution by any calculation. The correct distribution can only be found by iterative
selection of all possible data. First starting point has to be an assumed structure of the
ciphertext array. To perform "brute force" then all other possible distributions have to be tried out.
The encrypted file >CANNERY.CTX< contains the following ciphertext characters:
Characters in the file CANNERY.CTX
File contains in total 459 characters,
of these are 177 different characters;
on the average 2 positions per character
h-vuʳW6[cryKdXġ)A;NڑJ
{]:mFC|1ӹ}ßb.Q*BLR
ǘGg/%(pZsHf4l
'V՞\i?eO_7.$oUIϒ2!
j9@PqS8Ԥ.TЈ0kν3MY
68 2D 76 75 CA B3 57 F5 F7 36 5B 63 72 79 4B 9C
B8 64 58 CC 7F C4 A1 E9 29 87 EB EE 41 3B 4E 8B
DA 91 4A 7B 5D 86 9D A9 83 3A AC 6D A3 F8 46 93
8C 43 7C 31 D3 B9 7D E1 62 1F E2 F1 A5 51 2A 85
99 42 4C 8A 52 CD BB C7 98 47 67 C1 2F E0 E5 25
28 C6 70 8D 80 A8 96 ED C3 5A 73 E7 48 F3 66 34
84 D8 C5 D1 6C D7 E8 F2 EA 27 56 D5 9E AB 5C D9
E4 FC BF BC FA 69 3F AF BE 65 8F 4F 5F C9 37 3E
24 6F 55 CB 49 CF 92 32 B4 B5 21 EC FE 6A B6 39
40 A6 50 71 D6 53 D2 38 D4 A4 3C 54 95 C2 D0 88
89 81 AD E3 30 F6 6B CE BD 33 4D F9 FB 97 B7 59
F0 0D 0A
Note: Finding out the ciphertext characters was achieved by the analysis functions
of the program >CypherXT.exe<. Some characters are shown as a small square or as a point.
As a possible starting point the following ciphertext alphabet is free chosen:
Chosen >ciphertext alpabet< (ASCII)
Index 1 - 16: h - v u W 6 [ c r y K
Index 17 - 32: d X ) A ; N
Index 33 - 48: J { ] : m F
Index 49 - 64: C | 1 } ß b . Q *