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: fWZFaDjZo
Hash value base 16: 20 36 0F 3A 18 91 18
Hash value base 10: 9 066 638 281 838 872
Start sequence 2: Blue flamingos flying to Northern Sutherlane
e = 0110 0101
Hash value base 62: fTwps8Pfd
Hash value base 16: 20 2D AB 51 BF DB 39
Hash value base 10: 9 057 413 088 926 521
(Hash values are calculated with program "CMhash.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 (r: 1...m).
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 (extended: up to 256). In our example we choose number system on base 83. In other applications
may be base 77 used alternatively.
The procedure generates hash-function-series (Sr) and a partial hash value Hp according to following formula:
n
Sr = (ai + 1) * pi * Hk + ( pi + c + r)
i = 1
m
Hp = Sr
r = 1
n = length of start sequence
pi = position in the start sequence
ai = element of the start sequence (extended
ASCII-character set with 256 elements)
sr = single result of expansion calculation for series r
r = series r
m = number of series r
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 Basic Function 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
Foregoing demonstration comprises one cycle, only. To extend the procedure to a universally practicable cryptographic mechanism a new start sequence -Matrix key - is extracted out of the current CypherMatrix and lead back to the beginning ("loop"). Thus, the next cycle is initialized. Consequently the number of repeated cycles will be unlimited. By this way CypherMatrix procedure turns out to become a universally cryptographic device which can be used in most areas of cryptography as, so to say: "coding machine". Detailed explanations you will find in the pdf-file: Basic Function in Byte Techniques.
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.
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 (section C,2,a-d). 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).
Applied to the identification Data of the Author (113 bytes) the following results come up:
CypherMatrix Hash Basis 62: dnpjkSi7l
Basis 16: 1EE033B3567631
Basis 10: 8 690 761 958 061 627
SHA 1:
47 19 58 FF 6D 10 F5 CD 85 A3 0F 56 61 E9 E2 BE 0C 77 82 C4
MD5:
D9 B3 04 D2 E1 14 95 20 47 89 69 C1 8B DA FE 50
In a RFID chip stored the hash value can be selected and adjusted mobilely.(at last position number 9 is changed to number 8) 9 = 111 001
8 = 111 000
then the following results show up:
CypherMatrix Hash Basis 62: gLjlviYBm
Basis 16: 20D9ED1E651012
Basis 10: 9 246 811 695 157 266
SHA 1:
95 99 E1 4E 95 DA D9 DD E9 BA F6 92 BB 5F BC 99 29 49 CE 3E
MD5:
AB DA 29 40 D2 63 F8 D0 04 F0 82 42 14 04 06 AE
If the CM-Hash value is to be seen as finger print, then
SHA and MD5 are a Tatzelwurm!In case SHA1 it will be 2^160 = 1,5E+48 and at MD5 2^128 = 3,4E+38 values.
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 >Hash Sequences< : 16-256 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
>Hash Sequence< takes the place of >Matrix Key<.
Connections are shown by the following schemes:
In order to test the procedure you may download the DEMO program CMhash.exe. Above this development and working features of "CypherMatrix Hash Function" are detailed demonstrated in the following Pdf-file:
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 >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
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. The up to now generated combinations are aggregated in the file:CM-CypherEn.pdf.
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.
A higher level bit-conversion as from 8-bit sequences to 10-bit sequences is shown by the following example:
To achieve course and control of the program in each cycle a CypherMatrix (GF32^2) in number system on base 32 is generated.
Number system on base 32 comprises the following figures: 0123456789ABCDEFGHIJKLMNOPQRSTUV
In order to optimize Expansion and Contraction for creating BASIC VARIATION the start sequence has to be longer than
42 bytes. For our example we choose the start sequence:
The Basic Function processes the start sequence successively by position weighting, multiplying with hash constant C(k), expanding to Hash-Function-Series, then contracting by MODULO 1024 to BASIC VARATION and finally fixing as CypherMatrix (GF32^2). First cycle serves with following destination factors and parameters:
hash constant C(k) = 3843+1=3844
position weighted value H(k) = 22835519
partial hash value H(p) = 4350508904364
total hash value H(k)+H(p) = 4350531739883
Variante: (H(k) MOD 11)+1 = 4 begin contraction
Alpha: ((H(k)+H(p)) MOD 1023)+1 = 330 cipher alphabet
Beta: (H(k) MOD 960)+1 = 960 block key
Gamma: ((H(p)+Code) MOD 944)+1) = 62 matrix key
CypherMatrix (GF32^2)
1 98 PU D4 UP 1M CM 70 JB R2 VK ED M9 7N V2 DS 94 T5 I7 M0 EE O3 8P U4 6R VV FA 8J D8 0O 6M 65 R4 32
33 9R ST 0D 0S KM U7 37 PL I8 U8 D3 LH FN 66 IH Q7 PE U9 IB 39 K8 9J 6U VI P0 CG DC KI 3K RE NQ U5 64
65 L8 ES EV 4G EM LF VU 47 07 3Q TN SP IT V4 7S JF OV MG 2C U6 27 FE V7 DQ TK H7 U1 JR VQ R6 J7 L2 96
97 C6 2S F0 C4 V3 5Q 3O 38 5R 1E B6 DM OS QH 4N 91 6K GQ BS GG 50 VB TO I9 VP QT KE N4 NV 6L 3A RH 128
129 9Q 5H V8 EN UN JN UH JC D5 BH TD 0Q AQ GT 08 FR 6T SH IC TH EB A3 SV P4 HP EO 28 CP EG ML EU ID 160
161 PJ Q2 D1 E1 2B K4 G6 61 HD OU AI QI HQ 7P P1 EH 7G BK 9S SN OB 9H VD LD 3B 75 F4 P8 FS 1O 2I OI 192
193 NE 64 D6 PB 1P BV F7 HK FJ 1Q MF 8K DF SD H6 DP 00 UO FO QA SJ 5P GB MR 3S 8U JS CH QO 3R 7U 7O 224
225 L3 6A CK 83 O4 I0 A8 3F JI S2 AK NJ OQ SE F8 EP O0 EL NU OA 33 0V 7I B8 QF G7 EQ K0 13 JT BA CC 256
257 D7 AU DN D2 LV UA GJ OL PR MT 9K BD 9I MB 80 UQ BO UB JJ IJ 6V BC 05 A1 MK 95 D9 2H 3D L5 B9 FB 288
289 FC 20 31 86 TT Q8 DO PQ B4 RT ER VA 85 2T ET G1 M2 79 7T KJ 1T FP PD 29 0B J1 60 RI 1L M5 FU I6 320
321 6O N0 NO T4 MP J5 S0 F1 09 VC F5 IN 25 CN IO TB 7V 15 IL 51 DT 71 HR AF CB O2 P7 V9 F2 FT 1N P2 352
353 BI I2 3H VT 19 AL SS UI RV A4 H0 1R KF BE GU 5L 55 62 1D UR 5V DA 81 1F US SF GF VS 3N 9L B5 2V 384
385 9C BU GA BT BN GR N1 IA UL CL PC UU S7 C0 V5 0G DR 3V ND GE F3 2A UC OD SK 74 HN Q1 8H M7 N5 N6 416
417 ON S3 7J A2 9M KK P6 IR BB AE IS CO 2K IQ 04 A7 KB IE EA 6J V6 MO UV 5M JO AS A6 II L4 E3 KD IF 448
449 P3 EC AV 57 CQ JK 5G K1 MN AA IG LE LM 8V CR MQ C1 5T L7 82 G8 LB P9 QB 30 5N 12 N3 FK 0H HL BL 480
481 AH J3 F6 A5 TV GD QP O5 8R DU VJ K5 PM Q6 I4 IK C2 AR 3E LO 7F 0U 84 OT 1G 87 8G MJ G9 K6 UT KC 512
513 E8 6S M3 P5 SC H8 5A DB 3L MH QM 72 AC BR 9T RJ 88 EF V1 HM RA FV MM 0P 45 40 IP G4 MS BM Q9 9F 544
545 SQ JG 1H N2 F9 LS IU 4O SI 2J O7 2L PV LA 90 PA FD HO O1 BF LQ MU S9 A9 NF 3T HS DD RQ T0 BP C3 576
577 2R TG RU 5S 58 4V TI QC UD T1 9N NI 8N VE Q4 HT H9 M8 1S JU BG RC TE 1V 1I IM TP MC QD G0 7K RR 608
609 BJ J4 KN GC 7A NC PF LN 97 OP 5O FL CI OR CS 01 RD 26 QE HA 3U C5 4T PH JV HU KO TJ K2 2U E4 2M 640
641 92 K3 VM KP MV 8L KL AD N7 G2 LC SG QQ 9U 0C 89 4P C7 FM GL K7 DV 41 LP G5 OJ UE UJ PG UF RS QR 672
673 TC LI NP O6 99 0I KQ L9 59 9E K9 UM FQ IV HV CU 1U 63 UG CJ J6 GM G3 CT N8 6N BQ 8A 48 C9 PS TU 704
705 J0 8T GH KA 2D 0N 8B VF VG J2 LR MD N9 GI 2P 7L 32 C8 CV 8C QJ EI AB 3P O8 1C 96 T6 D0 GK Q5 68 736
737 QS 34 M4 DE GN 14 CA QN UK JP J8 V0 42 TQ U3 LT CD KR 02 8M FF CE CF GO EJ 9A Q0 DG VH 21 DH 73 768
769 JD R3 VL EK MA 7Q VN E0 9B T7 J9 M1 FG O9 8Q VO 76 03 FH 8O DI 0R 6P 67 R5 9V SU 0E 0T KS VR 3C 800
801 PN JA 06 DJ LJ GP 69 JE QG PI 0A JH 3G KG 9O 77 0F PK DK DL KT 3M RF NR 0J LG FI GS 4H GV LK 0K 832
833 49 0L 43 TR SR JL 0M 8D JM PO MI 2E 10 2F H1 11 E2 TL HB U2 KH 16 R7 JQ L6 E5 35 H2 E6 17 5U 44 864
865 3I 6B 1J B7 E7 PP QK 4Q 93 6Q H3 E9 H4 52 18 TS KU 1A QU KV NA OC 78 3J RK A0 5I 1B H5 1K L0 22 896
897 L1 HC HE TF 23 AT HF 24 HG 7B SL LL TM HH AG T2 PT I1 HI 2G HJ I3 NB I5 LU Q3 QL M6 ME 2N NG NH 928
929 6C NK QV AJ R0 NL 7R R1 NM 7H NN AM SO OE 9P 2O NS 46 7C NT R8 OF 2Q 36 OK OG 6D OH R9 4A OM OO 960
961 RB RG 4B RL 8S RM SM RN RO 4C 4D RP S1 T3 6E S4 S5 4E 9D S6 S8 SA 4F 8E 8F SB 6F T8 8I T9 TA AN 992
993 4I U0 4J AO 4K 4L 4M 4R 4S 4U 53 54 56 5B 5C 7M 5D 5E 5F 5J 5K 6G 6H 6I 7D 7E B0 9G AP B1 B2 B3 1024
BlockKey = OORBRG4BRL8SRMSMRNRO4C4DRPS1T36ES4S54E9DS6S8SA4F8E8FSB6FT88IT9TAAN4IU0
Block 10-bit = 110001100011011010111101110000001000101111011101010100011100110111011011100101101101110111110111100000100011000010001101110111100111100000011110100011001
MatrixKey = RENQU5L8ESEV4GEMLFVU47073QTNSPITV47SJFOVMG2CU627FEV7DQTKH7U1JRVQR6J7L2C62SF0C4V35Q3O385R1EB6DMOSQH4N916KGQBSGG50VBTOI9VPQTKEN4
ASCII-set = nŨߐ֯z]o LG纴'{fg\xh.f Q!
Alpha = 330 defines the offset of extracting the first Cipher-Alphabet (array of 128 characters)
out of the current CypherMatrix:
Base Alpha = VCF5IN25CNIOTB7V15IL51DT71HRAFCBO2P7V9F2FT1NP2BII23HVT19ALSSUIRVA4H01RKFBEGU5L55621DUR5VDA811FUSSFGFVS3N9LB52V9CBUGABTBNGRN1IAUL
Alphabet = WEX%U;O'7"rBq)VD Plain text: The WORD is a symbol and a delight ..."
Hex: 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 ....
8-bit: 01010100 01101000 01100101 00100000 01010111 01001111 01010010 01000100 00100000 01101001 01110011 00100000 ....
10-bit: 0101010001 1010000110 0101001000 0001010111 0100111101 0100100100 0100001000 0001101001 0111001100 1000000110 ....
base 32: AH K6 A8 2N 9T 94 88 39 EC G6
blockkey: OO RB RG 4B RL 8S RM SM RN RO
10-bit: 1100011000 1101101011 1101110000 0010001011 1101110101 0100011100 1101110110 1110010110 1101110111 1101111000 ....
XOR: 1001001001 0111101101 1000111000 0011011100 1001001000 0000111000 1001111110 1111111111 1010111011 0101111110 ....
7-bit: 1001001 0010111 1011011 0001110 0000110 1110010 0100100 0000011 1000100 1111110 1111111 1111010 1110110 ....
index: 73+1 23+1 91+1 14+1 6+1 114+1 36+1 3+1 68+1 126+1 127+1 122+1 118+1 ....
cipher: B O E A 9 u ....
Ciphertext: BOڥEA9uF'u/P`OǔwkNW~t-M#_~:ĠIQ;$O;{1-֪R?d ....
In order to demonstrate the sensibility of the procedure we change one bit from "0" to "1" namely the last bit
in the last byte of the start sequence. All other characters remain unchanged.
Sven Hedin is sailing arround the Northpole in a green nutshelm
l = 1101100
m = 1101101
hash constant C(k) = 3843+1=3844
position weighted value H(k) = 22839426
partial hash value H(p) = 4352692130307
total hash value H(k)+H(p) = 4352714969733
Variante: (H(k) MOD 11)+1 = 6 begin contraction
Alpha: ((H(k)+H(p)) MOD 1023)+1 = 868 cipher alphabet
Beta: (H(k) MOD 960)+1 = 67 block key
Gamma: ((H(p)+Code) MOD 944)+1) = 389 matrix key
CypherMatrix (GF32^2)
1 I2 1T LS IA SO JU 1F IF B2 VV PR 2E N4 S1 V2 4T FK MN RH K8 T1 11 AJ 6M HN MG IQ 5I OD IR ON 6C 32
33 1S GE EI T6 K3 SI L8 KO B3 V9 3J M0 4D 8F AU QI 9G II RE L7 L6 LL 0I QR DT CG AO G1 IB K4 3E C0 64
65 37 8D E5 BB AV 7N 4N DU 7B CJ 49 8C RC JV T9 5T K6 K1 GF 6R VT 42 4F GH OE JI 5D E6 T3 VQ I6 CC 96
97 NT 2I JO 90 DS TG FR DQ G5 OO EO VC J1 56 PA 8U 5K T4 IJ 1M JS OU 4U QB 3I JR P2 OV FJ 1U OR QM 128
129 IO LN C8 M1 QJ T7 Q8 O7 PI TB 7L QV VU 4E SA SK KQ QU JQ U5 FS LM IN NK 9O I7 TK 6N 9U DN D3 EJ 160
161 B1 CP MA 8P SD R3 4P VK JP 9H 23 H5 2P PD BC S3 FM P0 PS BT 3G KD JD 0F O0 IP 6I CR 47 58 93 U4 192
193 7K 9S P4 3P 13 LD 1B AK 7R JC UV T0 7I SS QS IC PG 6F MT 9B 57 GJ QD I1 9I 6D 96 FE T8 72 FT KB 224
225 ID J3 1K 4G G9 Q1 1J B0 I9 9J R0 9C GG 5M A4 GM PT H7 92 L1 4H C5 LV F9 9T Q4 9R D7 9K 5R FC I0 256
257 4J N5 RT E0 CM PV 78 1H MI RO J9 VR I3 7M C3 P5 91 6L 9D 3T 4O DC 8V 2F PJ 0N 55 SJ CU BV E7 3D 288
289 HU HV 6O CH UJ EM 7U 2R ST Q2 DM OA 00 38 1E EH ED RI L4 9A FV 1L L5 FL 5F HO HK 0O CA EE CK US 320
321 SV SM G6 F3 03 EC H6 KE 7D J2 EF DH KG B9 O1 L9 07 67 DV CD MV MJ TI N0 ML 0B 76 N3 7H 20 O4 3S 352
353 K0 3C 5H MB RN VS VB 0L TV LU V5 IG FN M2 R9 LA EG UC FU GD 1O VA 66 HP BU 94 S7 FP G2 0M 2L CI 384
385 25 D1 01 HB MM QK 7O 9V IS F0 VL FQ V3 VP DA V1 Q3 TE JE U9 P7 MR 46 02 4K S4 A0 RV KK LB U3 15 416
417 2V 9Q 5P EK 0P 2D U8 84 5V A5 6P DO JA 1R 2S 7T UF I4 1V 68 N7 KL JF K2 LH G0 9P RJ VD BD A2 98 448
449 IK 7J EP A1 PU IT G7 P1 NS V0 VM 1I 50 3F MC AN CL 8N EQ R8 6H 7P PK 0H 2Q 04 5E 3U 0U K5 SN 6E 480
481 LC 41 E4 P3 5G DR JH E8 L3 PL 8E F4 1A JB FH CB AA 63 3K JT CQ L2 TU OJ UI EA TS C1 0S NL RU H9 512
513 9N H8 EL M9 V4 1N AL K7 MD VE 4Q J0 32 KM UK AP 73 2N UL Q7 4I VN 0T 7Q 05 1P LE 88 HI A3 TJ 5C 544
545 29 LF 59 85 BR 8B 0Q 69 LG 33 AF F8 0V 35 E1 BL 74 4L FO 1Q M4 AR RK AM K9 LO PO T2 MO IH 4M NU 576
577 7S TO VF M3 R1 A6 Q6 U0 I8 MQ LI Q9 G3 9E HM IU QQ SE B7 G4 0R LJ KS LK LP CE SC 51 7V MP 61 QE 608
609 77 CS CV QF MS EN BE G8 CF 4R KA A7 10 65 FF JJ 8I 43 UN SP MU 4C 12 GA C2 TM NQ DK N1 SB N6 GB 640
641 4S V6 5J 2T 18 21 VG T5 S0 QG 1G IL S8 TA 6T KI KR QA 22 RA TC TR 6S O8 H2 7C 60 S9 54 GN BJ MK 672
673 AH ER E2 24 CN F1 2G C4 I5 62 26 A8 GR SR 9L LQ N8 J4 GQ SF ME KV V7 DB CO U1 70 19 3R 6G ES 4V 704
705 SQ A9 GI NO CT AS C6 IV L0 2A NN P6 QL AC M5 OQ VH KU TP KC 27 TT HA E3 ET JG PM KF M6 J8 D9 VI 736
737 C7 IE JK GC N2 6A 82 NV KH C9 LR LT Q5 MF N9 06 QC 64 SU DD M7 BH DG VJ QH IM 28 M8 J5 TD KJ 2B 768
769 J6 B4 08 Q0 2H NA S2 V8 52 GK NB RL KN TF 14 AQ 6Q HQ MH J7 5L OF JL OP 6J 2C GL EU TH KP SL NC 800
801 KT B5 VO 3L ND 53 8G B6 QN 9M JM RF NE NF NG 0J QT E9 D0 AT GO JN NH 3H D2 39 8H EB BF B8 80 5A 832
833 EV 7E D4 4A 8J RD NI TL 5U NJ NM GP 6U 09 44 5B GS OG NP 5N F2 TN 0A NR D5 O2 2J O3 95 F5 TQ GT 864
865 F6 GU OS F7 0C O5 5O PB 97 5Q U2 O6 2K O9 P8 5S QO 3M OB P9 PC GV 2M OT QP OC OH D6 OI R2 U6 R4 896
897 OK PN U7 81 R5 0D 6B SG UA OL R6 OM UB H0 PE PF PH AB PP UD 6V AD DP D8 FA BA DE PQ 8Q SH R7 6K 928
929 0E RB AE 2O HC 2U RG BG S5 H1 RM RP DF 3N RQ RR 0G RS S6 71 DI 48 75 99 UE 83 AG UG 3Q 16 UH 1C 960
961 BI 86 UM 0K UO 87 UP UQ UR UT 79 UU 9F 7A H3 17 1D AI 7F BK FG 30 7G H4 31 34 36 3A 89 HD 3B 3O 992
993 BM 3V BN 40 BO HE 8A BP HF 45 HG BQ 4B 8K DJ 8L FB BS 8M DL FD FI 8O HH 8R 8S 8T HJ HL HR HS HT 1024
BlockKey = E5BBAV7N4NDU7BCJ498CRCJVT95TK6K1GF6RVT424FGHOEJI5DE6T3VQI6CCNT2IJO90DS
Block 10-bit = 011100010101011010110101011111001111011100100101110110111110001110101101100100110010001001010000110011011011001001111111111010100100101111011010000110101
MatrixKey = MMQK7O9VISF0VLFQV3VPDAV1Q3TEJEU9P7MR46024KS4A0RVKKLBU3152V9Q5PEK0P2DU8845VA56PDOJA1R2S7TUFI41V68N7KLJFK2LHG09PRJVDBDA298IK7JEP
ASCII-set = T?\Cn'ۆ@%_:MEٸj;\D?o9smB(T...
Base Alpha = F70CO55OPB975QU2O62KO9P85SQO3MOBP9PCGV2MOTQPOCOHD6OIR2U6R4OKPNU781R50D6BSGUAOLR6OMUBH0PEPFPHABPPUD6VADDPD8FABADEPQ8QSHR76K0ERBAE
Alphabet = +'T(Xv),VYbd7eːf./1K9Mj:gkNZ-^pq!wyxz{|*P}&0r2#34Rt`$ahil5m~68;습<"%=>?@ABCJ
Hexadecimal
E7 B8 2B 27 BA C2 54 28 BC 58 76 29 2C 56 59 A6
62 C6 64 37 C7 65 CB 90 CA 66 CC 2E 2F 31 4B 39
CD 4D B9 A8 EA 6A AE 3A 91 67 D4 6B 4E 5A 2D 5E
70 71 85 21 77 79 AF 78 7A 7B 7C 86 E1 88 E5 2A
CE 50 D0 7D 26 D1 30 72 D6 D8 D9 DA E9 32 EB 23
33 34 52 EF 74 F0 60 F1 24 61 68 69 6C 35 6D 7E
7F 80 81 82 83 36 84 38 87 3B 89 8B B3 EC 8A B5
ED F2 3C 22 25 3D 3E 3F 40 41 42 43 BD 4A 98 8C
ASCII-Alphabet
1 + ' T ( X v ) , V Y 16
17 b d 7 e f . / 1 K 9 32
33 M j : g k N Z - ^ 48
49 p q ! w y x z { | * 64
65 P } & 0 r 2 # 80
81 3 4 R t ` $ a h i l 5 m ~ 96
97 6 8 ; 112
113 . " % = . ? @ A B C J 128
Ciphertext: d#h6X*j)adTꃋ}i`wvd)+@^r֨$.?h/z1fzǣOԦ;izV.FoQ
Compare the changed destination factors and parameters with the forgoing Data above and valuate the differences.
To get an own inpression you may download the program CYPHER3B.EXE and try once all by yourself.
Further another higher level bit conversion can be attained by 12-bit sequences and number system
on base 64.
The Basic Function generates a CypherMatrix GF(64^2) of 64x64 elements.
All necessary 4096 different signs are taken from number system on base 64.
Each sign consists of two digits. The system comprises the following figures:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz&#
The start sequence must have about 112 up to 128 characters especially to get a completely mixed BASIC VARIATION.
For this some examples:
"Sven Hedin is sailing around the North Pole in a green nutshell. In Far Rockaway Beach
he changes for the Yellow Submarine" [123 bytes]
"Horse racing on the banks of Clearwaterbay with 7362 blue donkeys and kangaroos which
are taken from the island of Spitzbergen" [126 bytes]
"Till Eulenspiegel sitzt auf der Zugspitze und raucht Zigarren. In Hinterzarten
steigt er um in den Zug nach Irgendwo" [117 bytes]
Encrypting the file CANNERY.TXT with the above start sequence "Sven Hedin ..." the procedure
creates in second cycle the following destination factors and parameters:
hash constant C(k) = 65024+1=65025
position weighted value H(k) = 1425941158
partial hash value H(p) = 3.99835041459442E+15
total hash value H(k)+H(p) = 3.99835184053557E+15
Alpha: ((H(k)+H(p)) MOD 3720)+1 = 3095 cipher alphabet
Beta: (H(k) MOD 3968)+1 = 679 block key
Gamma: ((H(p)+Code) MOD 3872)+1) = 146 matrix key
CypherMatrix GF(64^2) [64x64 elements]
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
1 aM w4 NP eA Is Zr ot SI qU fc f6 g8 kC Rk hy ai .. .. E& 9a c7 wv b& Ir TF tW tk Al fr FX 9O ga 1u eb 64
65 VK dU 0n Bx 94 Ye u2 5q u1 &f kn 14 F2 LZ IH &M .. .. 0a Ic dV FQ Ts ew Mp G8 io Y8 ny Vl IZ Wm Gl GH 128
129 SS FZ 8k KZ 6Y DH S& bl 3O pI 6h WS Rl kz 7b xl .. .. EQ UO fN LK a5 a2 Ga q2 hm NO Ci 25 FE U4 v3 Ez 192
193 9P #T rm g4 lO uI Og f7 vc jJ 6Z DI T8 n& zK Qb .. .. BZ MA 4K Ku 4o CB 5T jp Kc VM 9M kP Tr rV 58 fV 256
257 p0 ge M9 oY Xy rD vm nt pF Wt 4w 3J X7 92 lj 5W .. .. Hi iI &W dt Ik Y4 UD sK Su 2z 6c PG 9V 4C 9z GQ 320
321 UB ra t5 ld q3 Ey wx bW gd Ck 0b zI cX a1 lq XZ .. .. 8Q Nx Pp NU ro 8d BN &a Pz uT za Ox GE 09 oa 7c 384
385 OC d& Cl Cx op cJ Ta BP 9Z oG K8 MK fZ 7k cE Pf .. .. Vs JC Rb 5A TQ Sk xV RQ Sv hH hQ Ay QF pr dM Jj 448
449 PT CX 5S mC 7f i8 hL Il c5 78 PD ya O1 ko A7 Fp .. .. am r9 ub Q& bb &p 3g bc mc xE E6 hq FR p# yk 8s 512
513 0j j4 AD js yV rt 8W &9 #h 0q UC 9I bX m5 RS w2 .. .. OD eR hP dd EC 5B 1q I2 Vc Do OZ m9 eC hz xo zo 576
577 6w gF rB q# c# u6 zH pi ER Mm eY Jt aT T3 Sl RR .. .. bt IY de Zh sC Hf mj Dl 1a xJ z& Tp jG R8 5l vr 640
641 Qs fX Qc DB fH hf Ff KY WI cL #P ec lp 3l xr Vt .. .. ty ih 3K Es 18 Xj xO JT Iz Gp fd 7Y &H HA pn HB 704
705 Rv Mg vb dX I3 oB lz Oe ho &g 3L eJ 8Y JA sO 2m .. .. zf c& td na aA Th Qx PR tx BE lJ Mo Ee H# rA jL 768
769 K7 NM Oy fA fl aR Yx O7 X8 h5 mm sH Ve q0 xK Hq .. .. yw 7M Ie Ch fe 8S yq aP j& lg 3M hR sU P0 fW 6F 832
833 zv EP 1b C2 d4 FP 36 PQ hj L0 ZQ DP Fx t6 bx cy .. .. mX kF Nh U2 s3 ns ii sF xD oD og Qq ov J0 gL JL 896
897 cs pR Zw O8 4& Cj 1Z vC &G bd aJ Uo f# l3 UE Pe .. .. qk x6 2n rO m4 4# Rd Xi 51 GJ o8 Yr 7x 3N sg Ti 960
961 go WC Wn DG QQ uj VN 0I kN Ln &K ly 1n 8p fk Y0 .. .. 16 oS 28 Ae U5 L8 aS Ot Et Gi Ul AK WJ mY 4z gM 1024
... .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ....
.... .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ....
3073 EJ 6& h9 z6 VT #S C7 m3 81 vJ zW dZ zZ PM 1s &6 .. .. 3s vq TV 2b kD E7 1z Xh vK 2T cG jT Bh 82 nG 10 3136
3137 TN B# Ho bu C0 e& 11 12 w6 1h Xu yM Di 5R QY xy .. .. Uz Xw w7 fz QO z8 k6 6y ne m7 TE m8 tr #8 i3 F3 3200
3201 cu mE nX tt qZ Gw Ov B4 cQ d9 Er i5 wa X5 Ud Ue .. .. nn Qh 3Y 1N 88 cO 5j kH KI Kr OU rE ZM B9 kf bE 3264
3265 aY wf 0C XB LT HK #s vL 8A f1 20 EM WX 5k QP uR .. .. wp BM qo #t iL 8I Fj K4 BU jU Ba gP uU VI y3 Lg 3328
3329 Fv kw uW Bb ze KJ &Q y4 Lh S5 Ma Br QR FU CL fv .. .. oL d8 Sm YT 1f xB 40 Tx cP 6L i6 ql vt aE 2M Lr 3392
3393 2h Bj XP y8 V3 y9 F& 1O 1Q kS To ZA Ls fw #V kt .. .. 8K X0 Kw wq kY u& Ns fy nc 66 2Q 2t di Kx TL Lz 3456
3457 n# WP yE Bg dr Fa Bi w8 #v gC Rz ZN #x iA &R pd .. .. iN I8 QV pe 6d 67 iZ 1U P1 YU #m mG VB gS v1 &T 3520
3521 Ty VC 3a Bz wA v9 z4 2d 4v F0 Z9 TO ax G& Ky yG .. .. D8 Lt SL yQ Hr pX yy bF #& 21 k8 Nq N6 CQ YF wH 3584
3585 Td oA j0 wg R5 #2 3F Iq Q9 22 YG 5I VE mH Zc &D .. .. Iv yR 8N CF q7 2R QA ND wP #d &F Ly Ph cU X1 &c 3648
3649 QC Jq N9 2S jj 5K gA Vk ZG dw qI J9 gX dR yz ZU .. .. Nc P2 5L &U x0 6a Tf mP 5N fE GA Dc x2 41 fF FB 3712
3713 CW 2e lI YV WR #n Sq VF fQ gD L3 &V aW x3 qd yZ .. .. FV 6B RY q9 iQ D4 yi YZ yl ZY FC qA Iw D5 HN jd 3776
3777 YH Qu VZ ym y& 43 z0 45 nB NH db WA bC FD XQ Jb .. .. Zt oy SJ qb gW ib ic kJ R& ie al dj oz P8 YN R# 3840
3841 M2 im &e &u b8 HQ oN DL DM WB DN #0 DO cW oT kK .. .. Yl #y 6e 03 06 k# 4F FK M5 JF 0D o# Dw 0E 0G 0O 3904
3905 JG kW XC MC JP 0T 6g 5O D# Ze MD U1 5P Nb 5Q 8P .. .. EA XH bs 6s pQ 6u XI S0 l0 FN 6z kc qv P5 FO kd 3968
3969 ki p1 NL Nf p3 JR p4 Zu lG Fr Fs Fw Ss G0 GC Je .. .. IC P9 pE JS pa JV Jf Zz ph Jg R9 Jm Nr Nm Nn Nt 4032
4033 aH Nu aI aK aZ N& O2 O3 ab ae qJ O4 b0 b3 O5 qK .. .. Sh Si r4 bG bH bI bJ bK bL bM bV bk eH eI eL eM 4096
The procedure works in two different modes:
Parameter alpha fixes an offset in the current CypherMatrix (4096 elements) from where 256 characters
are taken and stored in a separate cipher-alphabet. This alphabet changes with each new plaintext block of 84 characters.
The ASCII-value (index) of a plaintext character gets the concerning character from the cipher alphabet and combines it to the encrypted cipher text.
As second mode the program first changes 84 8-bit plaintext sequences into 56 12-bit sequences
which are XOR concatenated with block key sequences of equal length (dynamic one-time-pad). Then this bit series are devided into 96 7-bit segments which get
the coresponding cipher characters from the cipher alphabet (arry of 128 elements) and form the cipher text.
The sensibility of the procedure will be shown when only one bit is changed from "1" to "0" namely the last bit
in the last byte of the start sequence. All other characters remain unchanged.
Sven Hedin is sailing arround the Northpole in a green nutshell.
In Far Rockaway Beach he changes for the Yellow Submarind"
e = 1101101
d = 1101100
hash constant C(k) = 65024+1=65025
position weighted value H(k) = 1506022709
partial hash value H(p) = 4.47263744599346E+15
total hash value H(k)+H(p) = 4.47263895201617E+15
Alpha: ((H(k)+H(p)) MOD 3720)+1 = 288 cipher alphabet
Beta: (H(k) MOD 3968)+1 = 54 block key
Gamma: ((H(p)+Code) MOD 3872)+1) = 84 matrix key
Compare this results with the destination factors and parameters above.
Mounting the extensive CypherMatrix GF(64^2) of 4096 elements requires much time thus the program works relatively slow, but
in return due to the feature of bit conversion the procedure is absolutly secure and unbreakable.
Whith such a program the "one-time-pad" connection between Washington and Moscow during the cold war could have
been managed with much less costs.
Speeding up the procedure can be achieved when generating of CypherMatrix GF(64^2) is confined to
the first two cycles, both. The calculated destination factors and control parameters concerning further cycles are
related to the CypherMatrix of the second cycle. The huge range of 4096 elements maintains
a sufficient variety of variables. Security of the program is not reduced, at all. You may download the DEMO program
Cypher6D.exe and test all once by yourself. Your system files will not be involved.
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 107
Base 4 four-digit
112112111230123012331313
130313101233
123212111300120113021223
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
By this way all procedures with combined bit-conversion, C2 and consequently resulting in extended length of ciphertext
can be led back to original length of the plaintext. The former claimed memory space may be used again.
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:
Bit(1) goes to bit(7), bits(2),(3),(4) keep their positions, bit(5) changes to bit(8), bit(6) gets the first position bit(1),
bit(7) becomes bit(6) and bit(8) goes to bit(5) and all result in a new binary code text h.
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 *
Index 65 - 80: B L R G g / %
Index 81 - 96: ( p Z s H f 4
Index 97 - 112: l ' V \
Index 113 - 128: i ? e O _ 7 >
Chosen >ciphertext alphabet< (hex)
Index 1 - 16: 68 2D 76 75 CA B3 57 F5 F7 36 5B 63 72 79 4B 9C
Index 17 - 32: B8 64 58 CC 7F C4 A1 E9 29 87 EB EE 41 3B 4E 8B
Index 33 - 48: DA 91 4A 7B 5D 86 9D A9 83 3A AC 6D A3 F8 46 93
Index 49 - 64: 8C 43 7C 31 D3 B9 7D E1 62 1F E2 F1 A5 51 2A 85
Index 65 - 80: 99 42 4C 8A 52 CD BB C7 98 47 67 C1 2F E0 E5 25
Index 81 - 96: 28 C6 70 8D 80 A8 96 ED C3 5A 73 E7 48 F3 66 34
Index 97 - 112: 84 D8 C5 D1 6C D7 E8 F2 EA 27 56 D5 9E AB 5C D9
Index 113 - 128: E4 FC BF BC FA 69 3F AF BE 65 8F 4F 5F C9 37 3E
The single characters of the ciphertext
h-vuʳW6[c[ryKdXKġ)XA;NvڑJ{]-:XmFC|1̹}ßb.
lead from their positions in the chosen ciphertext array to following Data:
char: h - v u W 6 [ c [ r
index: 1 2 3 4 5 6 7 8 9 10 11 12 11 9 13
7-bit dec: 0 1 2 3 4 5 6 7 8 9 10 11 10 8 12
7-bit hex: 00 01 02 03 04 05 06 07 08 09 0A 0B 0A 08 0C
char: y K d X K ) X
index: 14 15 16 17 18 19 15 20 21 22 23 24 25 26 19
7-bit dec: 13 14 15 16 17 18 14 19 20 21 22 23 24 25 18
7-bit hex: 0D 0E 0F 10 11 12 0E 13 14 15 16 17 18 19 12
char: A ; N v J { ] -
index: 27 28 29 30 31 3 32 33 34 35 9 36 37 38 2
7-bit dec: 26 27 28 29 30 2 31 32 33 34 8 35 36 37 1
7-bit hex: 1A 1B 1C 1D 1E 02 1F 20 21 22 08 23 24 25 01
char: : X m F C |
index: 39 40 41 42 19 43 44 45 46 47 48 49 9 50 51
7-bit dec: 38 39 40 41 18 42 43 44 45 46 47 48 8 49 50
7-bit hex: 26 27 28 29 12 2A 2B 2C 2D 2E 2F 30 08 31 32
char: 1 } ß b .
index: 52 53 20 54 55 56 57 58 59 41 60 53
7-bit dec: 51 52 19 53 54 55 56 57 58 40 59 52
7-bit hex: 33 34 13 35 36 37 38 39 3A 28 3B 34
The connected conversion of the 7-bit index values into 8-bit sequences give the following Data:
72 index values (7-bit series):
00 01 02 03 04 05 06 07 08
09 0A 0B 0A 08 0C 0D 0E 0F
10 11 12 0E 13 14 15 16 17
18 19 12 1A 1B 1C 1D 1E 02
1F 20 21 22 08 23 24 25 01
26 27 28 29 12 2A 2B 2C 2D
2E 2F 30 08 31 32 33 34 13
35 36 37 38 39 3A 28 3B 34
binary (7-bit series)
0000000 0000001 0000010 0000011 0000100 0000101 0000110 0000111
0001000 0001001 0001010 0001011 0001010 0001000 0001100 0001101
0001110 0001111 0010000 0010001 0010010 0001110 0010011 0010100
0010101 0010110 0010111 0011000 0011001 0010010 0011010 0011011
....... ....... .......
binary (reconverted into 8-bit series)
00000000 00000100 00010000 00110000 10000001 01000011 00000111
00010000 00100100 01010000 10110001 01000010 00000110 00001101
00011100 00111100 10000001 00010010 01000011 10001001 10010100
00101010 01011000 10111001 10000011 00100100 10001101 00011011
........ ........ ........
63 XOR-values (8-bit series):
00 04 10 30 81 43 07
10 24 50 B1 42 06 0D
1C 3C 81 12 43 89 94
2A 58 B9 83 24 8D 1B
38 74 F0 23 E8 10 A2
10 8D 22 50 29 93 A8
52 49 52 B5 8B 57 2F
60 21 8A 26 6D 09 B5
6C DD C3 97 4A 1D B4
..0üC..$PB. .<ü.Cö*X$.8t#.."P)RIRW/`!&ml×J.
The 8-bit series coresponds to the XOR-concatenation of key sequences and
assumed plaintext. Now the correct block key has to be found out. But here,
iteration only is the possible way, as well. Because the parameter beta may include
all elements of the CypherMatrix thus all of 256 ASCII-characters may be admissible for the key.
But any character in a block key is allowed only once because in the CypherMatrix from where
the key sequences are extraxted each element is unique only.
But it's the question, where to begin? For the first assumed block key we choose free the following sequence of 63 bytes. Further combinations of 63 bytes must be search for and tried to find the real encrypted plaintext.
wluBcsxAp7bdhS2*D8ͣWoQ.JtqM%]:,r$[.LI.).&iÜ
chosen block key (hex)
77 6C 75 42 E4 63 73
78 41 70 D0 37 62 64
68 53 F3 32 2A FA B4
44 38 CD A3 57 EC 6F
51 07 96 4A 8D 74 82
71 EF 4D 25 5D B3 DC
3A 2C 72 C6 F2 24 5B
05 4C AA 49 0B 29 D6
03 B2 B7 E5 26 69 9A
The 8-bit sequences of the XOR-concatenation series backwards XOR-concatenated with the chosen
block key should lead to the encrypted plaintext. We find as a result:
assumed plaintext (hex)
77 68 65 72 65 20 74
68 65 20 61 75 64 69
74 6F 72 20 69 73 20
6E 60 74 20 73 61 74
69 73 66 69 65 64 20
61 62 6F 75 74 20 74
68 65 20 73 79 73 74
65 6D 20 6F 66 20 63
6F 6F 74 72 6C 74 2E
where the auditor is n`t satisfied about the system of cootrlt.
But that is not the plaintext we searched for. It seems to be possible, but quite
inapplicable. We had expected:
The WORD is a symbol and a delight which sucks up men and scene
One more example:
Out of the key range we choose an alternative possible block key:
L#qR&isApetc.Oa7Nx.wY.ÖEürdM>.4/;:B.L..`.8y
chosen block key (hex)
4C 23 71 52 F2 26 69
73 41 70 D5 65 74 63
3C 4F F8 61 37 EC F9
4E 78 DD E6 04 FD 77
59 1A 99 45 81 72 C3
64 E4 4D 3E 09 E0 DE
34 2F 3B C6 EA 3A 42
05 4C FE 06 0B 60 D4
0E B1 A6 B7 38 79 DA
The 8-bit sequences of the XOR-concatenation series backwards XOR-concatenated with the chosen
key results in the following plaintext:
assumed plaintext (hex)
4C 27 61 62 73 65 6E
63 65 20 64 27 72 6E
20 73 79 73 74 65 6D
64 20 64 65 20 70 6C
61 6E 69 66 69 62 61
74 69 6F 6E 20 73 76
66 66 69 73 61 6D 6D
65 6D 74 20 66 69 61
62 6C 65 20 72 64 6E
L'absence d'rn systemd de planifibation svffisammemt fiable rdn
This found plaintext is possible, as well, but even inapplicable like the foregoing attempt.
With more possible keys from the combination ranges regarding ciphertext alphabet and
key sequences there are still a lot of different plaintext examples which can be derived
from these iterated data. The samples can be any extended and they don't spare even foreign languages.
Yet another chosen block key (hex)
53 61 7C 55 E2 37 62 75 56 70 D4 27 68 2D 7E 53 EE 79 2E E8 E6
41 78 D6 ED 04 FB 7F 4A 16 99 4D 8C 80 CC 77 AD 57 35 09 FE C9
39 2C 3C 95 E7 32 5B 40 45 EF 06 0A 6C C2 10 B3 B0 E3 2F 3D C4
from it the XOR decrypted plain text
53 65 6C 65 63 74 65 65 72 20 65 65 6E 20 62 6F 6F 6B 6D 61 72
6B 20 6F 6E 20 76 64 72 62 69 6E 64 90 6E 67 20 75 65 20 6D 61
6B 65 6E 20 6C 65 74 20 64 65 20 67 65 77 7C 6E 73 74 65 20 70
Selecteer een bookmark on vdrbindng ue maken let de gew|nste p
And that's Dutch, but we didn't expected that at all.
The aforesaid somewhat astonishing conclusion that even brute force does not result in a final success can be proven mathematically too:
The method includes three functions:
1. Plaintext --> key --> 8-bit XOR-sequences
2. 8-bit sequences --> 7-bit index-values
3. 7-bit index-values --> array (128) --> cipher text
The parameters key and array (128) are two variables independent each from another.
cm = f [ f1 (pn,k1), f2 (b1,b2), f3 (b2,k2) ]
pn = f [ f3 (cm,k2), f2 (b2,b1), f1 (b1,k1) ]
fx = function
pn = plaintext
k1 = key
b1 = 8-bit sequence
b2 = 7-bit index-value
k2 = array (128)
cm = cipher text
Finding out the cipher text cm and searching retrograde for the plaintext pn means forming
equations with two unknown variables: k1 and k2. This results in a definite solution only
if one of the unknown can be derived from the other unknown variable or if there are two equations with the same variables.
There are a lot of pairs array / key which result in a readable plaintext when
an encryption algorithm is performed on it but they don't match the correct plaintext [#14].
The reason is why there is no connection between the respective key=k1 and the array (128)=k2 (cipher alphabet) generated in the same cycle. Both are extracted out of the current CypherMatrix but they have no functional connection (k1 --> (Hk MOD 169)+1) and (Hk+Hp MOD 255)+1)). Both their common roots are the initial start sequence only. But to that position is no way back (one way function).
Furthermore by the law of commutativity both the variables can be changed against each other.
Insofar it is made evident that in this case "brute force" does not attain any definite result at all.
Apparently this are comparable mathematical facts such as to the proof that an "one-time-pad" cannot be broken [#15].
3. "Conversion" und "Regression"
Disadvantage of "bit-conversion" - extending ciphertext at a ratio of 7 to 8 - can be avoided by a "bit-regression" (see obove: segment D,4,d,6). By this 72 7-bit sequences are rechanged into 63 8-bit sequences and the ciphertext is reduced to original length of the plaintext.
The functions above explained are extended by regression as follows:
plaintext --> key --> 8-bit XOR-sequences
8-bit XOR-sequences --> bit-conversion --> 7-bit index values
7-bit index values --> system-array (128) --> transfer characters
transfer characters --> bit-regression --> 8-bit index values
8-bit index values --> ASCII-alphabet --> ciphertext
Variable array (128) will be replaced by the system-array (128).
Principle of the procedure - equations with at least two unknown parameters -
remains preserved. Thus, here we may state that "bit-conversion" combined with
"bit-regression" is unbreakable as well.
In case of a "man in the middle attack" (mitm-attack) the attacker - in figurative view - is sitting online between sender and addressee and suggests each time to be the other party [#15a]. But, if the participants are able to sheck the integrity of their messages a mitm-attack is not possible. Encryption programs with CypherMatrix as symmetric procedures contain an integrity proof in every case, thus this attacks will not succeed.
5. Attacks on Side Areas: "Side Channel Attacks"
Attacks on side areas of the procedure (Article:"Side channel attacks") are aligned to win conclusions on individual bits from species-characteristic technical accompaniments - particularly on used keys - at time of the decoding excution. As typically processing related side areas are known:
1. Analysing the time it takes for different units to perform operations
(timming attack),
2. Power consumption of units while performing calculations in order to
gain conclusions on the used keys (power consumption analysis),
3. Generating faults during operations (differential fault analysis)
4. and elektromagnetic radiations possibly caused while processing
operations (TEMPEST).
An attacker only knows the cipher text and the CypherMatrix procedure. The respective aplied program and the
single parameters - start sequence included - are not known to him.
Side channel attacks are dedicated especially to find single bits which may lead to further conclusions and
knowledges. But the CypherMatrix procedure does almost exclusively work with bytes (Byte Technology).
Processing related bits are not in use, at all.
At each cycle decryption process works as follows:
The cipher text - handled in cycles of e.g. 72 signs - contains neither any bit nor bytes of the original plaintext. The signs are sole pointers to positions in the cipher alphabet. Moreover, the cipher text does not include any data of the start sequence or other references to the program and its control parameters. In the generator working area there are used no data or characteristic features of the plaintext. Only the start sequence at the beginning of the procedure, controls the entire process (processing generator).
The unknown quantities A and B necessary for decoding are occasionally created anew at each cycle.
Hence, after a cycle is done no performing Data (excepting cipher text) will be stored neither in cache nor elsewhere
which could be a target for attacks on side areas. Last of all we have to state that there will be no chance
for "side channel attacks" on CypherMatrix decoding procedures.
G. Multifarious implementation
CypherMatrix procedure comprises three areas which may be used to implement different programs by user and/or producer:
1. Fixing of the "start sequence", 2. Selectible constitutive criteria by the user and 3. Fixed constitutive criteria by the producer.Each single program can be created with different design parameters as an unique item. A user may free decide to whom he will hand over the unique program in order to perform a confidential communication. He may hold under his control who is in possession of the program. A worldwide operating enterprise may establish its own safe and confidential information net. All others are completely excluded. Perhaps they know the program but they dont know the individually fixed design parameters. These facts extend the key length of the "start sequence" many times.
1. Choosing the "start sequence"
Safety and security of an encryption finally depend on the length and structure of the start sequence (passphrase). The start sequence requires at least a length of 36 characters (bytes) and at most of 64 characters (bytes). The structure may comprise the whole ASCII-character set of 256 bytes. In practice the inputs are limited mostly to the range of computers keyboard about 100 keys. This will result - as demonstrated above - in a key length of 416 bits (entropy 415.99).
The start sequence preferably should be a catchy and possibly funny word order which one may keep in mind and is not necessary to write it down. Each divergence in the start sequence - even if 1 bit only - regardless at which position leads to quite different results.
For example in the following two sequences:
(1) The Yellowstone Lake contains 273956 herrings
control factors:
pos. weighted value (Hk): 8055705
partial hash value (Hp): 748673056665
Variante: 10
Alpha: 61
Beta: 152
Gamma: 39
Delta: 151
Theta: 26
273 digits in number system to base 77
3jjwrbJa8Um9f2j9byUJEz51Q9Wf1#Ii2KXjM2j#yTw2g3haar3zVePC4
DvAP4PorcS4m8n@4glYw1hxDH3#LI5JIaqX68IQf65bkl024&JM6gBN7pOfQ
V7bPfW8sMy2z7iZD8d9HZ9JHMoA08ON2YV4sNSWy5PogB58IcNY5tP75m8
zNT5ub3m&26cBR9mB@kTMQDrA&#mE2c2zSDJHMEFyaA2DlnPAjFfG
(2) The Yellowstone Lake contains 273957 herrings
control factors:
pos. weighted value (Hk): 8057677
partial hash value (Hp): 749146404801
Variante: 2
Alpha: 44
Beta: 96
Gamma: 139
Delta: 99
Theta: 14
273 digits in number system to base 77
3jxHfKbJbHTLmAXxA&hvUJwrn1QBSkG1#LmAa2KuS12jgW1303HH3i4okC3zb2u14
D#FN4Pux74mFodT4gs4@o1i23yd33aoI5JQ7UC68RGZ465kW9F24JVM6gLSkC7pZp9
x7m@jc8sZVE7j3aQY8e1bAU9JVO1vA16nEo2Gtr4sUFK&5PwMDs58P351IGy5mG
1607#Yp3mNEyBiRtPB@#hTaDrUqzWE2wV1RDJaeoTEG46nWDl79uFfddC8
By this you may see which datatechnical difference only one herring causes
in the Yellowstone Lake.
2. User's selectible constitutive criteria
User may choose the following operation parameters:
a) Length of the matrix keys: (36 - 64 bytes; 28 choices),
b) Length of the block keys and plaintext segments:
(35, 42, 49, 56, 63, 70 bytes; 6 choices),
c) Definition of the expansions base (base 36 to base 96; 60 choices),
d) Choosing the transfer channel (10 choices) and
e) Personal user code (99 choices).
Combination of all choices result in 9.979.200 different created programs which
are neither compatible nor interdependent with each other.
3. Fixed constitutive criteria by the producer
The producer of a program may fix the following operation factors:
a) MODULO factors regarding Variante, Alpha, Beta and Gamma and Delta
(27 x 27 possibilities; 729 choices),
b) Fixing the ciphertext alphabets (4 variables of 128 characters each;
512 choices),
c) Code for variable "Unikat" (99 choices) and
d) Several different factors at installation.
In total there are 36.951.552 possibilities to create a program differently.
Every user may get from the producer an unique program which can be used
only by him and his communication partners. All others do not have his personal
program at their disposal.
Kerckhoffs motto: "The enemy knows the program" [#17], can be restricted to the
statement "The enemy knows the principles but does not know the constitutive
criterias". To find the single criterias by trying "brute force" of course is excluded as well.
If all conventional attacks against the CypherMatrix method does not lead to any success in consequence of bit conversion and missing "congruence of length" and by this reasons the only remaining way -"brute force" attack - will be hopeless then the definitely quintessence will be: The method is secure and unbreakable. Opposition against this statement will be accepted at every time and checked at length.
The next task should be developing of a platform independent Chip including all features of CypherMatrix for using in all cryptographic procedures.
Input: start sequence,
block length (plaintext, key)
Output: key sequences,
ciphertext alphabets and
unlimited bytes stream.
But this task oversteps the possibilities of the author. Up to now no competent partner
has shown his interest.
This explanations have some changes compared with former descriptions. The corrections are caused by recognizing of some weaknesses in the course of intensive testing. Derivating all elements from the foregoing matrix directly to the following matrix causes a repetition of sequences in some cases, which should be avoided, absolutely. But this weakness is now eliminated.
Copies and translations of this article, as well as using CypherMatrix method and the mentioned programs beyond pure test purposes require the express permission of the author. Surely, serious partner interested in dealing with further developments of the method will get an respective agreement. Criticisms, suggestions and improvements to the method and information about experience with the program are appreciated and wellcomed at any time.
Please forward any communication by e-mail to:
[#1] Not to confuse with "encoding base 64".
[#2] Authors patent, DPMA 19811593 vom 18.03.1998,
[#3] Schneier, Bruce, Angewandte Kryptographie (deutsche Ausgabe)
Bonn ... 1996, S. 280,
[#4] Schneier, Bruce, a.a.O., S. 34,
[#5] Schmeh, Klaus, Safer Net, Kryptografie im Internet und Intranet,
Heidelberg 1998, S. 115,
[#6] Schneier, Bruce, a.a.O., Sn. 15 und 16,
[#7] Schneier, Bruce, a.a.O., S. 275,
[#8] Meganet Corporation, Virtual Matrix Encryption,
"Stated simply, the content of the message is not sent with the
encrypted data. Rather, the encrypted data consists of pointers to
locations within the virtual matrix ..."
Contrary to Meganet's "virtual matrix encryption" the here presented
method performs a "real matrix encryption",
[#9] Bauer, Friedrich L., Entzifferte Geheimnisse - Methoden und
Maximen der Kryptologie, Berlin Heidelberg New York, 1995,
Sn. 186 und 213,
[#10] Wobst, Reinhard, Abenteuer Kryptologie, Bonn 1997, S. 56,
[#11] Schneier, Bruce, a.a.O., Sn. 9, 177 und 181,
[#12] Schneier, Bruce, a.a.O., S. 9,
[#12a] Schneier, Bruce, a.a.O., S. 194,
[#13] Schneier, Bruce, a.a.O., S. 177,
[#14] Schneier, Bruce, a.a.O., Sn. 281/282,
[#15] Schneier, Bruce, a.a.O., S. 17 and
Wobst, Reinhard, a.a.O., S. 53,
[#16] Schneier, Bruce, a.a.O., S. 21,
[#17] Bauer, Friedrich L., a.a.O., S. 171.
[#18] "simple private signatur" contrary to
"qualified electronic signature" as defined
in german "Signaturgesetz vom 22.05.2001",
[#19] Schneier, Bruce, a.a.O., S. 17ff and
Schmeh, Klaus, a.a.O., S. 58ff,
[#20] Schneier, Bruce, a.a.O., S. 17
[#21] Schmeh, Klaus, a.a.O., S. 59.
[#22] following: Descartes, René, (without further mention)
