Visions of a Freeman - 15 of June of 2013
Uncrackable code.

This vision is intended for spy agencies and it's purpose is to show that there really is a way to create messages that are impossible to decode by unauthorized persons. It cannot de deciphered even with the use of the most powerful computers, making it impossible to crack. That is why this vision is called "Uncrackable code".

Lets start with the basics, the source of comparison.

The source of comparison.

To make things simple I will simply say that the base of comparison is just a lot of numbers.

For example: 23,45,82,67,34,94,103,77,123,90,103,245,124,6,8

These numbers are the base of the message, it is one base of numbers per message.

By themselves they hold no message at all, it is just a bunch of random numbers.

These numbers are mailed in a physical way (using real material mail) to the person that will decode the messages.

I will talk later about adding security to the process but to keep it simple, for now, lets just say we receive the numbers in a CD using regular mail.

Now we have the source of comparison number that can be of any length, next we need the comparison number.

The values.

To keep it as simple as possible let me show the basic characters that will be used and their numeric equivalency:
     
a = 1
b = 2
c = 3
d = 4
e = 5
f = 6
g = 7
h = 8
i = 9
j = 10
k = 11
l = 12
m = 13
n = 14
o = 15
p = 16
q = 17
r = 18
s = 19
t = 20
u = 21
v = 22
w = 23
x = 24
y = 25
z = 26
= 27 (Start all Uppercase)
! = 28 (End all Uppercase)
* = 29 (Another character)
_ = 30 (Space)
1 = 31
2 = 32
3 = 33
4 = 34
5 = 35
6 = 36
7 = 37
8 = 38
9 = 39
0 = 40
= 41 (New key, next 4 spaces define a key)

When "" is used the program understands that everything that follows will be in uppercase until it reaches a "!" if it is provided to return to lowercase.

The special character "*" is followed by another value that indicates what that special character is.

Let me invent some special character combinations:
       
*1 = !  
*2 = "  
*3 = @  
*4 = $  
*5 = %  
*6 = &  
*7 = /  
*8 = (  
*9 = )  
*10 = "R" Repeat last character, ignore new character until space or another special character is found(29) and (ignore that too).
*11 = ?  
*12 =  
*13 =  
*14 = '  
*15 = ,  
*16 = ;  
*17 = .  
*18 = :  
*19 = [  
*20 = ]  
*21 = {  
*22 = }  
*23 = *  
*24 =  
*25 = <  
*26 = >  
*27 = #  
*28 = (Accent after this character)
*29 = +  
*30 = -  
*31 = =  
*32 = "I" Ignore previous number.
*33 = "C" The next number is a place holder indicating what character to copy from the message and place next.
*34 = "P" The next number is a place holder indicating what word to copy and place next. If > 255 then use following number too and add up.

It's just a small example. Now lets create a message that says: "Hello World".

In that case the numbers will be:
     
H = (27),h(8),!(28)
e = 5
l = 12
l = 12
o = 15
_ = 30
W = (27),w(23),!(28)
o = 15
r = 18
l = 12
d = 4

These number codes can and must be shuffled from time to time to destroy the sequence of creation of the messages. They can be changed every week and are sent by mail, the keys do not show the message themselves, but I will write about how that is done in a more graphical way later.

The message code will look like this:

27,8,28,5,12,15,30,27,23,28,15,18,12,4

And the keys line will look like this:

131232333434535636737838939040a1b2c3d4e5f6g7h8i9j10k11l12m13n14o15p16q17r18s19t20u21v22w23x24y25z2627!28*29_3041!1"2@3$4%5&6/7(8)9R10?111213'14,15;16.17:18[19]20{21}22*2324<25>26#2728+29-30=31I32C33P34

The result number.

The result number is a number that will be compared to the source of comparison numbers and the difference between them will give a different set of numbers.

To create the result number (The actual message) we take the "Source of comparison" number (which is just a bunch of random numbers) and the "Keyed message" numbers.
   
Source number: 023,045,082,067,034,094,103,077,123,090,103,245,124,006,008
Keyed message: 027,008,028,005,012,012,015,030,027,023,028,015,018,012,004
Now to create the comparison number all we need to do is add to value of the keyed number on to the source number. If any number is greater than 255 then subtract, instead of adding.
Resulting number: 050,053,110,072,046,106,118,107,150,113,131,230,142,018,012
As you can see, if you take the resulting number and subtract the source number you will end up with the Keyed message values, just remember to remove the negative character (-):
  050,053,110,072,046,106,118,107,150,113,131,230,142,018,012
  023,045,082,067,034,094,103,077,123,090,103,245,124,006,008
Result - Source: 027,008,028,005,012,012,015,030,027,023,028,-015,018,012,004

Without the source number it is impossible to determine what the message is. It does not matter how much computing power they use, they will never get the message from just a bunch of numbers.

We could also add numbers that are repeated in the source number and in the resulting number, in that case the program will simply ignore those repeated numbers, as if they do not exist to it.

For example:
  050,053,013,110,072,046,055,106,118,107,150,066,113,131,230,241,142,018,012
  023,045,013,082,067,034,055,094,103,077,123,066,090,103,245,241,124,006,008
Result - Source: 027,008,028,005,012,012,015,030,027,023,028,-015,018,012,004

Sending the message.

We would send the Keys and the source number by using a removable media, like a memory or a USB drive.

First we have to put an index number to the message, lets say we define that the maximum index number will be 99,999,999, then if the number is less than 10 million we fill in the space with a zero. In that case 100,001 would be "00100001".

For example:

00100001
1
31232333434535636737838939040a1b2c3d4e5f6g7h8i9j10k11l12m13n14o15p16q17r18s19t20u21v22w23x24y25
z
264127!28*29_30!1"2@3$4%5&6/7(8)9R10?111213'14,15;16.17:18[19]20{21}22*2324<25>26#2728+29
-
30=31I32C33P34
050,053,013,110,072,046,055,106,118,107,150,066,113,131,230,241,142,018,012


If it is the very first message you will send, (probably the only one that needs to be send by normal mail) you might want to use a three number placeholder for each number in the keys.

For example:

00100001
1
031203230334034503560367037803890390040a001b002c003d004e005f006g007h008i009j010k011l012m013n014
o
015p016q017r018s019t020u021v022w023x024y025z026041027!028*029_030!001"002@003$004%005&006/007(008)009R010?011012013'014,015;016.017:018[019]020{021}022*023024<025>026#027028+029-030=031I032C033P034
050,053,013,110,072,046,055,106,118,107,150,066,113,131,230,241,142,018,012


It helps to make sure that the program will not make errors on the first message.

It is always a good idea to include all control characters.

You could always shuffle the values in the source keys:

00100001
90390040a001b002c003l012m013n01410312032303340345035603670378038o015p016q017r018s019t020u021v022
w
023x024y025z026027!028*029_030!001"002@003$004%005&006/007(008)009R010?011012013'014,015;016
.
017:018[019]020{021}022*023024<025>026#027028+029-030=031I032C033P034d004e005f006g007h008i009
j
010k011041


And you can add letters that are not part of the of the table of keys and that will simply be converted into zeroes by the program. In this vision I used only the capital letters R, P, I and C so any other letter would just be converted to zero.

Example:

00100001
90390A40a001b002c003l012m013n01410312032303340345Z35603670378038o015p016q017r018s019t020u021v022
w
023x024y025zA26027!028*029_E30!001"002@003$004%005&006/007(008)009RD10?F11012013'F14,Y15;016
.
017:W18[019]020{X21}022*023024<A25>026#027028+T29-030=031I032C033P034dR04e005f006g007h008i009
j
010k011041


This kind of masking is used when the key is sent inside a message, using the Internet. It helps scramble the message further.

The New Key character.

The new key character tells the program that a new key is being defined inside the message. The character code (41) if followed by the character and then the number.

For example this would be the definition of a new asterisk:

041(),029(Another character),023(* of another character),40(0),032(2),033(3)

Which the program would translate as:

**023

You can send new definitions that are contained all over the message text. Once all the letters are included the message with the new keys can be sent. The definitions of the letters can be contained inside the message itself.

For example it can say:

Hel*023lo World

That way a message can contain a new set of keys to prepare the way for another new message.
 
Every message has to be processed in order to be able to read the following message after a keys definition message has been sent. That means that the initial keys definition will no longer work making it impossible to crack any of the new messages without the latest keys definition.

The two tier code system.

You might want to have two initial codes, the first on is the code that will permit you to read the first messages and keys definition and the second code is for emergencies to be able to recover a new code system if it has been lost.

For example if one of the five agents failed to receive a keys definition it would be sent to him using the second code, to upgrade that second code and the first code, which allows the user to read the messages as he normally would.

Small number crunching.

You could define a new character (\) and give it the value of number 1, instead of the a, which would be number 5.

This character is the "Vocal move" character.

It is followed by a number from 1 to 5, indicating a, e, i, o and u. After that character and it's value you can follow it by a number that indicated how many spaces must the cursor move to the right to find a letter plus 1. For example if we want the letter X we would use: 1(/),5(for fifth vocal),4(to move 3 spaces)

If you do use a number cruncher trick you might want to put the start uppercase and end uppercase at the second and third values:

(Start all Uppercase)=2
! (End all Uppercase)=3
* (Another character)=4
a = 5

The number crunch character followed by a 6 indicates that the next number refers to a numeric character.

For example 5 can be character 35 without the number cruncher but with it it would be:

1(\), 6(for number),5(the number).

1, 6 and 5 affect the numbers in the source a lot less than 35.

You can also number crunch the special characters in units of 5.

Making it easier for humans using graphics.

A bunch of numbers require a way to be presented so that the we can refer to each message as an image.

For that we use pictures to define a message and in that picture will be the numbers we need.

Every point of the image, or pixel has a red, green and blue value, each one is a number from 0 to 255.

It is in those colors that the information will be placed. There can be three channels of communication in those colors, we could use the red, the green and the blue channels.

It is a good practice to store a message in one channel and an alternate (counter intelligence) message in another color channel. There is no way to tell which is color channel was actually used if the picture was correctly randomized when the source of comparison was created. Even if that would alter the look of the picture, yet the picture can still be seen and remembered.

For example you would ask the person that received your message: "Did you get the bicycle picture?" instead of: "Did you get the whole bunch of numbers starting with 00100001?". Pictures are easier to remember.

It requires a programmer to modify the pixel color values and to be able to read those values back. There are three useful channels there that can be used with a variation of 41. That means a red value can be increased or decreased by 41, which is a strong change that can be perceived. You can use a small number cruncher character to better preserve the original colors of the source image.

The only reason that an image is used is because it is easier to remember and to refer to it.

With number crunching tricks the images will be less affected by the message being sent.

Always remember that the values must be randomized a bit in order to not make it evident when a different tone of color is present. With the number crunch the difference can be of 8 for each tone of red, green or blue, added to the existing color that has been randomized by adding or subtracting 8. The tricky junk code like letters inside key definitions or code that refers to other letters or words are what make it impossible to decipher apart from the randomness of it all.

The snail mail sources.

There are two ways to create the sources. One is to send them by mail. Each image being different and being sent by regular mail, not email.

Hundreds of images can be used for that purpose.

The other way is to actually instruct the computer to modify the original picture used as a source with a code that is send next to the message but that would eventually make it harder to keep the original image or might even deform it, making it harder to refer to it and remember.

A removable memory can store hundreds of picture sources and can be sent back and forth by normal mail. If any such mails are intercepted then the entire sources are discarded and the second tier system is enforced.

Communicating.

There are four computers involved in the process.

Two of them do not have internet or a network.

The computer that creates the sources and the messages does not have internet.

The computer that reads the messages to be sent on the internet and not the sources does have internet.

The computer that receives the image and decodes it does not have internet.

The computer that only receives the image from the internet and has to send the data to the decoder computer does have internet.

But how to communicate between the computer that has internet and the decoder that does not have internet or network at all?

The answer is by programming the web cam.

The computer would read the numeric values from the red, green and blue values in the picture and each number produced will be a color.

For example:

1 is White
2 is Yellow
3 is Green
4 is Blue
5 is Purple
6 is Red
7 is Orange
8 is Cyan
9 is Grey
0 is Black

Light purple and Light Green are the calibration colors, it tells the program that will process the image from the web cam where it will find the colors it needs to read the numbers.

Communicating data using web cams is a very good dream for the ultimate paranoiac or people that need extreme security.

The computer that will communicate displays an image that the computer that will read can take a picture of and process. That way the computers can communicate using the web cams and not using any type of network connections, making that kind of visual, web cam network uncrackable.

It requires 2 computers or computer devices such as cell phones per point and provided that everyone has the sources of everyone else. It might seem a bit complicated but in reality the programs take care of all the action, the users just have to remember what image they sent when referring to the message, as opposed to the message itself.

For example a military agent would ask: "Did you receive the pink canary" (The image was a pink canary) instead of: "Did you receive the list of military personnel".

The security of this system is that it relies on normal mail for the base of each coded message. Might not be as secure as normal mail but it is more secure than purely digital communications and with a proper program the images with the messages are worthless and impossible to decode without the source, source that never touches the internet and is always offline.

The image with the message can be read with the web cam, loaded into memory, compared with the source, deciphered and the message show, then the source can simply be deleted by covering all the bits it once occupied in the memory device... Making it impossible to recover.

I think this is by far the most secure and fastest way to communicate in secret and all the programming technology is easily available. Its a combination of Internet, offline computers, web cams and normal (snail) mail.

The communications between good programmers are only intercept able if the programmer is lazy or voluntarily allows it. There is no way to currently crack the communications between professional programmers that want privacy.

We programmers made the systems for snooping into other people's lives, we can make it stop too.

Technology for the future.

In the future special devices can be made to enhance the performance of visual data operations.

Even if they looks less secure than the actual cameras they can help speed up the process of retrieving the data.

The device is connected to the monitor port of the computer and the monitor is connected to it.

It has a USB cable that can connect to a third computer.

The only command that can be sent to the device from the computer that is connected to it via USB is a single bit to have it take a picture of the screen. It proceeds to create a BMP file of the image of the screen and stores it in a memory device but unlike a digital camera it only takes one picture at a time.

The memory device sets the picture to read only, so that nothing can be done to alter it.

With those pictures and the command of taking a picture from the monitor's screen the process can be faster in regards to visual data transmissions.

Back to index.