- A. Historical examples
- B. Basic principle of the method
- C. CypherMatrix as cryptographic Basic Function
- D. Applications based on the procedure
- 1. Dynamic Number Generator (DNG)
- 2. Dynamic Hash Function
- 3. Extended digital Signature
- 4. Performing of digital Encryptions
- a) Combined operations
- b) XOR concatenation
- c) Substitution "dyn24"
- d) "bit conversion BC"
- e) "bit exchange BE"
- (1) Manual input
- (2) Dynamic bit series
- (3) Extended bit series

- f) "bit crossing (CR)"
- g) Number System on Base 256
- h) Byte-transposition BT
- i) "One-time-pad" procedure
- (1) Defined offset
- (2) Elective access

- j) "Multi-time-pad" procedure

- E. Bits and Bytes in Cryptography
- F. Cryptanalysis of the method
- G. Multifarious implementations
- H. Quintessence
- I. Final remarks
- J. References
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):

The plaintext alphabet with 64 characters [#1] will be stored in a two-dimensional**abcdefghijklmnopqrstuvwxyz 01234 56789/ABCDEFGHIJKLMNOPQRSTUVWXYZ****matrix 8x8**(array) and subjected to a thorough mixing (**permutation**) in every encryption cycle:

The ciphertext alphabet (transfer characters) with 32 characters, independent of the plaintext alphabet, consists of completely**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****different characters**:

The characters are stored in a**@ # / &****vector**(array) and also thoroughly mixed (**permutation**) for every encryption cycle:

The following transfer text will result for the plaintext "**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 @ &****Kryptographie**":

Because the plaintext alphabet comprises 64 (8x8) characters the characters are changed from numbersystem on**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****base 8**to binary values (**6-bit sequences**):

A**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 111110****bit conversion**separates the**6 bit**sequences into**5 bit**sequences, which get as index values the correspondent characters from the Ciphertext alphabet.

The characters found by this procedure are then used as**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 7****transfer text**:

At the addressee the method creates identical plaintext and ciphertext alphabets. The indices of the received transfer characters in the**ciphertext: # # 12 7 21 22 31 18 12 30 3 26 13 15 2 21 7****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).The newest up-to-date of the procedure (2014) you may read in

**white paper**:*Codegraphy as part of Cryptography*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:

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**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]****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:

Addressee generates by the same**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.****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:

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**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.****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):

For the following explanations we choose the start sequence:**sequence = a**_{1}a_{2}a_{3}... a_{i}... a_{n}Horse racing on the banks of San Bernardino To assign the start sequence univalent with a value (

**H**) each character (_{k}**a**) 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._{i}Following abbreviations mean:

First assignment by addition:**n = length of start sequence a**_{i}= character of start sequence (extended ASCII-character set with 256 elements) p_{i}= position in start sequence H_{k}= position-weighted hash value

But the thus calculated value is far away to serve as**H**_{k}= a_{1}+ a_{2}+ a_{3}+... a_{i}+... a_{n}(Single values for "a_{i}" are increased by (+1) because otherwise ASCII-zero would not be considered)_{n}H_{k}=_{}(a_{i}+ 1)^{i = 1}H_{k}= 4007**hash value**. In order to obtain a unmistakable association of all bytes some more features have to be addedAs 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**a**) is marked by ASCII-indexes and time may be neglect (t_{i}_{i}= 1) we state position (**p**) inside the sequence to be the location of the concerned character_{i}**a**._{i}Each sequence character (

**a**) is_{i}**position weighted**by multiplying its value with its location (**p**)_{i}

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._{n}H_{k}=_{}(a_{i}+ 1) * p_{i}* t_{i}^{i = 1}t_{i}= 1For 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 C**is explained detalied in the pdf-file:_{k}**Determinants leading to collision free**

**Constant C**depends on length of the hash sequence and an individually fixed user code. The constant is calculated as follows:_{k}**n = Length of start sequence C**_{k}= [(n - (n/(n-1))) / (n/(n-1) - 1)] + Code C_{k}= n * (n - 2) + Code n = sqrt(C_{k}+ 1 - Code) + 1The following graph demonstrates the interdependence between possible collisions and constant value

**C**:_{k}

**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

**H**which excludes collisions:_{k}

The calculated value_{n}H_{k}=_{}(a_{i}+ 1) * (C_{k}+ p_{i})^{i = 1}H_{k}= 7158981 n = length of start sequence a_{i}= element of the start sequence (extended ASCII-character set with 256 elements) p_{i}= position in the start sequence C_{k}= hash constant H_{k}= position-weighted hash value**H**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_{k}**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 (**a**) into digits of higher number systems. Converting factor may be determined individually from_{i}**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**(S_{r}) and a partial**hash value H**according to following formula:_{p}

Chosen number system on base 83 comprises the following digits:_{n}S_{r}=_{}(a_{i}+ 1) * p_{i}* H_{k}+ ( p_{i}+ c + r)^{i = 1}_{m}H_{p}=_{}S_{r}^{r = 1}n = length of start sequence p_{i}= position in the start sequence a_{i}= element of the start sequence (extended ASCII-character set with 256 elements) s_{r}= single result of expansion calculation for series r r = series r m = number of series r c = user code H_{k}= position-weighted hash value H_{p}= partial hash value expansion base: 83 contracting base: 84 digit: number in number system on base 83 Reihe: hash-function-series

(determined by the Author, not standardized)**0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg hijklmnopqrstuvwxyz&#@{|**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:

Control parameters derived from destination Data show as follows:**hash constant (C**_{k}: 1763 + 1 = 1764 position weighted value (Hk): 7158981 partial hash value (Hp): 636211483478 total hash value (Hk+Hp): 636218642459

In defining the offsets of**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 series****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:

Expanding variables to**char a**_{i}+1 p_{i}(a_{i}+1)*p_{i}H_{k}(a_{i}+1)*p_{i}*H_{k}s_{i}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**"Hash-function-series"**

the procedure calculates 257 digits in number system on base 83**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:

Expanding variables to "Hash function series"**Changed start sequence: Horse racing on the banks of San Bernardinn o = 01101111 n = 01101110 hash constant (C**_{k}: 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

the procedure calculates 257 digits in number system base 83

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.**1WnAB0&yX@zq2a9H{hs@HITXxd1cXS1ZJeak1qye51Jh2IBf2MH cG@v4S2c6328BLq6l3oxgF3a2gs03hMSFn1GiTWH3@iM1Q3C7cL4r1Y44w n0i5MSL1kW#8t5f41@5Jo81zQ4m3TGz5hDL|6bu8&G1{JJai4BjFs6eWYbb7 hTIRR7cVCw6#p5SS8CVsah7SMfjE7Y#c8d6Gtv8tot3****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:

By this we get the following abridged derivation:**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**

(begin of reconversion at parameter: variante = 6)

In the first round the following array**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 ... ...... ... ...****Variation(k)**is derivated with 256 elements

(If an element appears double the following is increased by +1)

Distribution of elements in the array depends on**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****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**.

BASIC-VARIATION is a**f: Start-Sequence ---> BASIC-VARIATION****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):

In three loops a total**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****permutation**of all characters is performed :

Blue signed characters show the**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***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:

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.**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**

The**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****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):

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.**Matrix key (at offset: Gamma = 104 --> 42 bytes) ,6CHZJvGϹ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**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:

Length of plaintext blocks - and by this length of block keys, as well - may be fixed alternatively with 35, 42, 49, 56,**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****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:

In applications predefined**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****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:

The most important of them are described in the following.**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.****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:

Parameter**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****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"**Sven Hedin is sailing around the Northpole**

and 20.000 cycles generate the following file:

**SERIES03.RND**:

The test program**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 'qB`Crf]恂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 ----------------------------------------------------------------------- **FIPS PUB 140-1**of U.S.NIST confirm the following results:

The well known test program "ENT.EXE" (available on demand) states on byte level the following result:**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****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:

The random files generated with both the foregoing start sequences are marked by quite different hash values:**Sven Hedin is sailing around the Northpole Sven Hedin is sailing around the Northpold e = 0110 0101 d = 0110 0100**

You may download both the random files**SERIES03.RND Base 62: qq0Pjg9Ny9 Base 16: 9ED32B019D575E5 Base 10: 715283647750829541 SERIES04.RND Base 62: qpiZRTfk1h Base 16: 9EDF9898CF0ED09 Base 10: 715220810015501577****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:

By means of the same technique basic series for 16-, 32-, 64- or other bit series may be generated. For instance: In customary**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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .****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**C**, 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_{k}**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:

Applied to the identification Data of the Author (**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).****113 bytes**) the following results come up:

In a**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****RFID chip**stored the hash value can be**selected and adjusted**mobilely.

Even if the Data are changed only in**one bit**-

(at last position number 9 is changed to number 8)

then the following results show up:**9 = 111 001****8 = 111 000**

If the CM-Hash value is to be seen as**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****finger print**, then SHA and MD5 are a**Tatzelwurm**!

With the CM-Hash value of the average 9 to 11 indications in the number system on**base 62**alltogether different values without collisions can be represented up to**62^11 = 5,2E+19**.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:

As key parameters are embedded:**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).**

Connections are shown by the following schemes:**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<.**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: (Note: name and data are free devised)

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**:

If the hash value of**ID-Data hash User-Code base 62 1daTPYK2Ke ---> YoXuUvgO7e base 16 4ECD51CD806BA8 ---> 68A62761356923A decimal 22180799407221672 ---> 471297370283741754****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

If sender's User-Code is stored in an internet database ("**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".****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:

**Eine einfache digitale Signatur****.pdf Datei****4. Performing 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.For encryption programs always is postulated that plaintext and ciphertext should have the same length [#23,#24,#25]. As argumentation often is mentioned, the encrypted text has to be stored at the same sector from where the plaintext was taken. But, the real background is another reason: If plaintext and ciphertext cover same length it is absolute urgent that they have an equal number of signs (bytes). Hence, encrypting a plaintext character to a ciphertext sign occurs inside the sign by a special function (bit series), even if the way comprises longer bit sequences. Using characters containing 8 bits in plaintext and ciphertext as well there must take place an unified regulative provision (bit system on base 8) and an identical system-alphabet of 256 signs (paradigm of cryptography). Details on systemizing bit series you will find in article:

**Paradigmenwechsel in der Kryptographie**(sorry, language is German).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:

The following scheme shows the connections:**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

**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.*John Steinbeck, Cannery Row, New York 1945 **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.

To implement a**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****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:

Operating with the expanded ASCII-character set we get the substituted sequence:**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****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

or be permutated**ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef [32] ghijklmnopqrstuvwxyz0123456789+/ [64]****dynamic**permanently:

This cipher alphabet is permuted in CypherMatrix procedure by personal passphrase "**317WXIq8VCv9+5ZnxSOJyLAtHi0clsB4 [32] egR6jkUGdzuYfQpbDo/PEahMrFKNTmw2 [64]****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:

With inserting the**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****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"**

Ciphertext: "**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****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.

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**10-bit-sequence: 2^10 = 1024 characters 12-bit-sequence: 2^12 = 4096 characters 16-bit-sequence: 2^16 = 65536 characters****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 in**bit system on base 10**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:**Sven Hedin is sailing arround the Northpole in a green nutshell**[63 bytes]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:

Alpha = 330 defines the offset of extracting the first**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]oLG纴'{fg\xh.fQ!****Cipher-Alphabet**(array of 128 characters) out of the current**CypherMatrix**:

(determined by the Author, not standardized)**Base Alpha = VCF5IN25CNIOTB7V15IL51DT71HRAFCBO2P7V9F2FT1NP2BII23HVT19ALSSUIRVA4H01RKFBEGU5L55621DUR5VDA811FUSSFGFVS3N9LB52V9CBUGABTBNGRN1IAUL Alphabet = WEX%U;O'7"rBq)VD**For encryption purposes we take words of John Steinbeck from the file "CANNERY.TXT" (see. sector 4,b)

In order to demonstrate the**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 ....**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**

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**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****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**rsp. in**bit system on base 12**.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:

Encrypting the file**"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]****CANNERY.TXT**with the above start sequence "Sven Hedin ..." the procedure creates in second cycle the following destination factors and parameters:

The procedure works in two different modes:**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 4096Parameter

**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

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:

Connections are shown by the example:**1. plaintext --> base4(4) --> base4(3) 2. start sequence --> cipher-array(64) 3. base4(3) --> cipher-array(64) --> ciphertext****"Yellowstonepark"**:

Base 4 four-digit**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**

**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:

Instrumental in performing the "regression" is the**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****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):

(determined by the Author, not standardized)**digits of number system on base 128: 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz&# @{|}**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):

Bits of plaintext byte**plaintext byte: a binary: 01100001 bit order: b**_{1}, b_{2}, b_{3}, b_{4}, b_{5}, b_{6}, b_{7}, b_{8}code text: a_{c}chosen bit order: b_{7}, b_{2}, b_{3}, b_{4}, b_{8}, b_{1}, b_{6}, b_{5}binary: 01101000 code text byte: h**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:

But**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 ...****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

for example creates with two different start sequences - which differ in one bit only - the following bit orders in the first 7 rounds:*Cypher28*

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**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 . . . . . . . . . . . . . . . .***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:

Programs including**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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .****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:

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**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****secret cipher characters**(0...127) stored in the array "Cipher-alphabet 128":

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**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****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:

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**

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.**Position Matrix Klartext 256 element B 11 a 37 P s 55 v i 45 " s 55 v**

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:

Next the procedure**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 . . . . . . . . . . . . . . . . . . . . .****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ß, ......*

As an example of dynamic transposition the demo program CypherBT.exe (correspods to:*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*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:

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.**position in ciphertext: 987 chosen offset: 7.654 ------------------------------------ position in key: 8.641**"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. Bits and Bytes in Cryptography****1. Systematization of Bit Sequence Series**Cryptography is

**writing**and**reading**of**secret messages**by charateristic methods (encryption). Since millenia people changed signs of their languages in such a manner the legitimate recipient only was able to decipher the message. Doing this they used exclusively whole signs of their concerned language. Since computers came up this reflection changed. Computer work in binary techniques (number system on base 2, only). As a consequence of electronic techniques they are able to distinguish between two states only: "exists" (voltage) or "not exists" (no voltage). That means in figures of number system on base 2: "one" or "zero". This condition is named as "bit", normaly.In data technical view a computer is able to create "bit sequences", only (1 to oo). Their length is unlimited. It seems to be comparable to the amount of all numbers. In order to work with bit sequences systematically, to recognize connections and regularities and to create programs (in particular ciphering) the bit sequences have to be

**systemized**, that is to devide into definite segments (units). All identical bit lengths, for instance 4-bit, 7-bit, 8-bit, 12-bit, 16-bit or other lengths present units (8-bit sequences = "bytes"). In this case a structural comparison with the number system should be advisable. "Bit" is on a par with "figure", "byte" (resp. "unit") conforms to "number" and "system-alphabet" describes the assorted quantity. Appropriate to the number system one may formulate "8-bit series" as "bit system on base 8".system alphabet Bit series: 1-bit = bit system on base 1 = 2^1 char 2 units 2-bit = bit system on base 2 = 2^2 char 4 units 3-bit = bit system on base 3 = 2^3 char 8 units 4-bit = bit system on base 4 = 2^4 char 16 units 6-bit = bit system on base 6 = 2^6 char 64 units 7-bit = bit system on base 7 = 2^7 char 128 units

**8-bit = bit system on base 8 = 2^8 char 256 bytes***The main area for almost all cryptographic operations*9-bit = bit system on base 9 = 2^9 char 512 units 11-bit = bit system on base 11 = 2^11 char 2048 units 12-bit = bit system on base 12 = 2^12 char 4096 units 16-bit = bit system on base 16 = 2^16 char 65536 units 32-bit = bit system on base 32 = 2^32 char 4294967296 unitsEach single "bit system" and "system alphabet" are quite independent from each other. But difficulty arises in finding own symbols for each sign (unit) in the respective system alphabet. In bit system on base 1 there are the units: "0" and "1" or historic: "L" and "H". Bit system on base 4 knows the unit "nibble" and bit system on base 16 comprises the unit "word". Up from bit system on base 9 and higher two signs have to be combined or UNICODE must be used.

By systemizing of bit series and the assigned system alphabets a new technique of encryption will be visible. As shown in the "white paper"

**Paradigma change in Cryptography**in cryptographic scientific disciplines there are some undocumented areas, so to say: a**crypto incognito**. Basic foundation of the new considerations are explained in detail in "white paper":**Alternatives in digital Cryptography****2. Comparison with Conventional Procedures**Nowadays actually used enciphering procedures work mostly with

**bit manipulations**in bit system on**base 8**. For this it is neccessary to manage the way from plaintext character to ciphertext character by a**function**based on a homogeneous bit system. Further it is a demand that ciphertext and plaintext should have an equally length. By this follows: For each plaintext character there is only one specific cipher character in bit system on**base 8**.But, however CypherMatrix procedure works in two separated function areas:

**Generator**and**Coding Area**. The generator makes available all parameters for process control. Essential proceding occurs in a separated**coding area**. In principle enciphering is achieved by changing the information bit series from one bit system to another bit systemAn example for exchanging in CypherMatrix procedures: The word

**"Buddha"**will be changed from bit system on**base 8**to signs in bit system on**base 11**:Alphabet bitsystem on base 8 (ASCII: 256 bytes) byte$(66) = "B" byte$(97) = "a" byte$(100) = "d" byte$(104) = "h" byte$(117) = "u" .... index 66 117 100 100 104 97 .... 01000010 01110101 01100100 01100100 01101000 01100001 .... bitsystem zu base 11 .... 01000010011 10101011001 00011001000 11010000110 0001 .... index 531 1369 200 1670 alphabet bitsystem on base 11 (2048 char) (characters are combined out of two ASCII-signs) alphabet$(200) = "fY" alphabet$(531) = "cY" alphabet$(1369) = "g#" alphabet$(1670) = "hZ" ciphertext base 11: ...cYg#fYhz....

The procedure devides the 8-bit sequences into 11-bit segments. Number of bits and their order remain identical. No bit is added and no bit is removed. Decimal values of signs in system on base 11 are index-values for the ciphertext signs in the system-alphabet. Exchanging may apply to all bit systems from base 1 up to base 12 (and higher).

Enciphering in CypherMatrix procedures work principally as follows: By inserting

**start sequence**the respective CypherMatrix will be created from wich the parameters for process control are extracted. Plaintext blocks in system on base 8 are XOR concatenated with a key of equal length. The result in base 8 is exchanged into the defined alternated bit system (base 1 up to base 12). The thus resulted indices get the respective assigned character and combine them to the ciphertext. Deciphering goes the reverse way.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:

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**p**_{i}= plaintext character i = position in plaintext k = key c_{i}= cipher sign St = start sequence n = procedure step (text block) m_{n}= matrix key k_{n}= block key A_{n}= cipher alphabet c_{ii}= cipher sign**p**to output of ciphertext_{i}**c**:_{i}

The generator of CypherMatrix procedure creates for each plaintext block**c**_{i}= f (p_{i},k)**p**a matrix with 16x16 characters and the variables_{n}**k**and_{n}**A**necessary for encryption and_{n}**m**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_{n}**St**:

Because there is no functioning connection between**k**_{n}= fx (St) A_{n}= fy (St)**k**and_{n}**A**the coding function shows as follows:_{n}

As**c**_{ii}= f (p_{n},k_{n},A_{n})**k**and_{n}**A**both depend causativ on start sequence_{n}**St**the coding function shortens to:

Quintessence: The start sequence**c**_{ii}= f (p_{n},St)**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

**A**and_{n}**k**in the decoding function_{n}

then lead back to the plaintext**p**_{i}= f (c_{ii},A_{n},k_{n}) p_{i}= f (c_{ii},St)**p**._{i}**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:**c**. This is the reason why the encrypted text has certain informations of the respective plaintext [#7]._{i}= f (p_{i})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**:

But ciphertext characters as result of the second function ("index values") are only "**c = f [f**_{3}, f_{2}, f_{1}] f_{1}= "Plaintext bits" XOR-concatenated by "block keys", f_{2}= Conversion of XOR-concatenated 8-bits into 7-bits "index values", f_{3}= 7-bits index values leading to positions of characters in the permuted ciphertext alphabet.**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:

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].**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.****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:**Plaintext --> key --> XOR-concatenation**

8-bit XOR-concatenation --> bit-conversion --> 7-bit index values (0...127)

7-bit index values --> ciphertext array (0...127) --> ciphertext

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:

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.**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**As a possible starting point the following

**ciphertext alphabet**is free chosen:

The single characters of the ciphertext**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**

lead from their positions in the chosen**h-vuʳW6[c[ryKdXKġ)XA;NvڑJ{]-:XmFC|1̹}ßb.****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:

The 8-bit series coresponds to the**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.****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.

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:**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

But that is not the plaintext we searched for. It seems to be possible, but quite**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.****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:

The 8-bit sequences of the XOR-concatenation series backwards XOR-concatenated with the chosen key results in the following plaintext:**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

This found plaintext is possible, as well, but even**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****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.

And that's**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****Dutch**, but we didn't expected that at all.

Conclusion: even "**brute force**" does not result in an unmistakable outcome. Thus, we**may forget**"brute force", as well.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.

Finding out the cipher text**c**_{m}= f [ f_{1}(p_{n},k_{1}), f_{2}(b_{1},b_{2}), f_{3}(b_{2},k_{2}) ] p_{n}= f [ f_{3}(c_{m},k_{2}), f_{2}(b_{2},b_{1}), f_{1}(b_{1},k_{1}) ] f_{x}= function p_{n}= plaintext k_{1}= key b_{1}= 8-bit sequence b_{2}= 7-bit index-value k_{2}= array (128) c_{m}= cipher text**c**and searching retrograde for the plaintext_{m}**p**means forming equations with two_{n}**unknown variables: k**and_{1}**k**. 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_{2}**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=k**and the_{1}**array (128)=k**(cipher alphabet) generated in the same cycle. Both are extracted out of the current CypherMatrix but they have no functional connection (k_{2}_{1}--> (H_{k}MOD 169)+1) and (H_{k}+H_{p}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:

Variable**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****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:

An attacker only knows the cipher text and the**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).****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:

Each single program can be created with different design parameters as an**1. Fixing of the "start sequence", 2. Selectible constitutive criteria by the user and 3. Fixed constitutive criteria by the producer.****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:

By this you may see which datatechnical difference only**(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****one herring**causes in the Yellowstone Lake.**2. User's selectible constitutive criteria**User may choose the following operation parameters:

Combination of all choices result in**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).****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:

In total there are**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.****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.

But this task oversteps the possibilities of the author. Up to now no competent partner has shown his interest.**Input: start sequence, block length (plaintext, key) Output: key sequences, ciphertext alphabets and unlimited bytes stream.**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:

*eschnoor@multi-matrix.de*[#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) [#23] Strukturvergleich Klartext und Geheimtext, http://www.telecypher.net/ Equilang.pdf [#24] Paar, Christof und Petzl, Jan, Understanding Cryptography, Berlin.Heidelberg 2010, S.124 [#25] Schmeh, Klaus, a.a.O., S.61

**Munich, in August 2012****Copyright (c)****Diplomkaufmann**

**Ernst Erich Schnoor**