The idea behind Soundex (or SNDX, although not usually referenced in that manner) is to provide a representation of a name that will match for any minor variations that do not greatly alter the pronounciation. Pronunciation. Whichever.

The idea being that Robert and Rupert will be represented the same (R163) but Rubin will differ (R150). Because it was intended for names, it’s function is limited outside that scope. The original soundex structure calls for first letter followed by 3 digits, making the algorithm questionable for large words.

1. Keep first letter of word or name, this is the first value in the Soundex value
2. For remaining letters, convert all consonants with the table after the jump.
3. All adjacent duplicate digits are collapsed into a single instance of each
4. All remaining characters (vowels) are dropped
5. The first three numbers are the remainder of the Soundex Value

• B F P V => 1
• C G J K Q S X Z => 2
• D T => 3
• L => 4
• M N => 5
• R => 6

But I also think it makes a great deal of sense now.  Because now I can link the bits to their posts.  WHEE!

Setup (Initial Permutation)
Do 16x:

Process Key (Key Manipulations)
Process L & R with K through f (Main Algorithm)

Done
Finish (Final Permutation)

FINI

The demonstrated versions are going to be HUGE!  And start Tuesday!

40 8 48 16 56 24 64 32
39 7 47 15 55 23 63 31
38 6 46 14 54 22 62 30
37 5 45 13 53 21 61 29
36 4 44 12 52 20 60 28
35 3 43 11 51 19 59 27
34 2 42 10 50 18 58 26
33 1 41 9 49 17 57 25

L(i+1) = R(i)
R(i+1) = L XOR f(R(i),K(i+1))

For function f, R(i) is expanded from 32-bit to 48-bit R’(i)

32 1 2 3 4 5
4 5 6 7 8 9
8 9 10 11 12 13
12 13 14 15 16 17
16 17 18 19 20 21
20 21 22 23 24 25
24 25 26 27 28 29
28 29 30 31 32 1

R’(i) XOR K(i+1) (RK(i))is then broken into 8 6-bit chunks and permuted through S tables. (See S-Table post)

This permutation is then FURTHER permuted, which gives us the result (F(i)) of f(R(i),K(i+1))

16 7 20 21
29 12 28 17
1 15 23 26
5 18 31 10
2 8 24 14
32 27 3 9
19 13 30 6
22 11 4 25

F(i) is then XOR’d with L(i) (from WAAAY back), giving us the R(i+1).

The first and last bits define which ROW, and the middle 4-bits define the COLUMN

S(1)

RC 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

00

01

10

11

Full listings after the break

S1
14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7
0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8
4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0
15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13

S2
15 1 8 14 6 11 3 4 9 7 2 13 12 0 5 10
3 13 4 7 15 2 8 14 12 0 1 10 6 9 11 5
0 14 7 11 10 4 13 1 5 8 12 6 9 3 2 15
13 8 10 1 3 15 4 2 11 6 7 12 0 5 14 9

S3
10 0 9 14 6 3 15 5 1 13 12 7 11 4 2 8
13 7 0 9 3 4 6 10 2 8 5 14 12 11 15 1
13 6 4 9 8 15 3 0 11 1 2 12 5 10 14 7
1 10 13 0 6 9 8 7 4 15 14 3 11 5 2 12

S4
7 13 14 3 0 6 9 10 1 2 8 5 11 12 4 15
13 8 11 5 6 15 0 3 4 7 2 12 1 10 14 9
10 6 9 0 12 11 7 13 15 1 3 14 5 2 8 4
3 15 0 6 10 1 13 8 9 4 5 11 12 7 2 14

S5
2 12 4 1 7 10 11 6 8 5 3 15 13 0 14 9
14 11 2 12 4 7 13 1 5 0 15 10 3 9 8 6
4 2 1 11 10 13 7 8 15 9 12 5 6 3 0 14
11 8 12 7 1 14 2 13 6 15 0 9 10 4 5 3

S6
12 1 10 15 9 2 6 8 0 13 3 4 14 7 5 11
10 15 4 2 7 12 9 5 6 1 13 14 0 11 3 8
9 14 15 5 2 8 12 3 7 0 4 10 1 13 11 6
4 3 2 12 9 5 15 10 11 14 1 7 6 0 8 13

S7
4 11 2 14 15 0 8 13 3 12 9 7 5 10 6 1
13 0 11 7 4 9 1 10 14 3 5 12 2 15 8 6
1 4 11 13 12 3 7 14 10 15 6 8 0 5 9 2
6 11 13 8 1 4 10 7 9 5 0 15 14 2 3 12

S8
13 2 8 4 6 15 11 1 10 9 3 14 5 0 12 7
1 15 13 8 10 3 7 4 12 5 6 11 0 14 9 2
7 11 4 1 9 12 14 2 0 6 10 13 15 3 5 8
2 1 14 7 4 10 8 13 15 12 9 0 3 5 6 11

From this 64-bit KEY we need to define two 24-bit blocks (C and D)

C(0)
57 49 41 33 25 17 9
1 58 50 42 34 26 18
10 2 59 51 43 35 27
19 11 3 60 52 44 36

D(0)
63 55 47 39 31 23 15
7 62 54 46 38 30 22
14 6 61 53 45 37 29
21 13 5 28 20 12 4

From here, each C/D 1..16 are generated by Left Rotating the previous C/D according to the following table:
1 1
2 1
3 2
4 2
5 2
6 2
7 2
8 2
9 1
10 2
11 2
12 2
13 2
14 2
15 2
16 1

Thus C(1) is LR(1) C(0), D(15) is LR(2) D(14), etc

We then catenate C and D (making it one longer block), and can now define our K with the following 56-to-48 bit conversion table

K(1)

14 17 11 24 1 5
3 28 15 6 21 10
23 19 12 4 26 8
16 7 27 20 13 2
41 52 31 37 47 55
30 40 51 45 33 48
44 49 39 56 34 53
46 42 50 36 29 32

The first step in a DES encryption is to munge the initial block to create two new datablocks

L(0)
58 50 42 34 26 18 10 2
60 52 44 36 28 20 12 4
62 54 46 38 30 22 14 6
64 56 48 40 32 24 16 8

R(0)
57 49 41 33 25 17 9 1
59 51 43 35 27 19 11 3
61 53 45 37 29 21 13 5
63 55 47 39 31 23 15 7

So, now I’m redoing it in a series of posts, with the intent that the smaller chunkiness will permit semi-reasonable walkthrough.

I can still foresee some issues herein, but they may be less insurmountable

The first is “ROT-13 encoding,” which despite it’s name isn’t really an encoding. ROT-13 substitutes each letter with the letter 13 away (half an alphabet), which eliminates the need to define a direction in the shift. A becomes M, M becomes A. D becomes P, P becomes D.

Second is a “Rotation Cipher,” more commonly known as a “Caesar Cipher,” which is actually a more general version of ROT-13. A Rotation Cipher would generally be named with a direction and a number. ROT Right 5, or ROT-L-9. ROT-13 is a special case because L and R would be identical (26 letters, 13 is halfway around, either direction). Rotation Ciphers are frequently put on “secret decoder rings.”

The third is the generic case of “substitution cipher.” In this instance, A may be mapped to X and then B to C, there is no relation between mappings. This can either be a 13-letter table (where, then, X would map to A and C to B) or a full 26 (C may map to A, and X would become I).

In terms of data security, none of these is any good. These are more useful for either pre-coding a message for actual encoding or encryption, or for passing insecure data. There are ways to complicate these techniques (which I will work up separately), which make them more secure.

The basic use for a Simple Cipher is to make data require some level of work to read (to slow someone down), and to make for ready manual processing. With the “decoder ring”, anyone can easily tick through an arbitrarily long message with a consistent time per letter, and a consistent process.

(This is a post I’m migrating from the first edition of this blog)