The Basic Idea
A dictionary is a complete set of character substitutions. Take a small number of dictionaries. These are of course shared between two computers. Add an array of random numbers that can be used as indeces in those dictionaries. Now, everytime you use a code from one of the dictionaries, use the next value in the random number array to determine another code in that same pad with which to swap values. That's basically it. Now you have effectively a small set of perpetual One Time Pads, so I call this encryption method, "Perpetual One Time Pad", or POTP.

The Basic POTP Method
One of the easiest ways to understand and implement this POTP is using 16-bit codes. 16-bits is a "short integer" in computer-ease. A 16-bit integer can hold 64K values, i.e. values ranging from 0 through 65,535. Create some number of 64K arrays of short integers with random numbers such that each array contains each number only once. I.e. each array represents a 2-way translation. E.g. the value at index 5 of an array is 3492, and 3492 does not appear at any other index in that array. We'll call these arrays dictionaries 0, 1, . . . .

Add another 128K array of random short integers. This is the "replacement" or "swap" array. Populate this array randomly, with each value represented at least once.

Let's call one side the "sender" and the other the "receiver". The sender sends a message to the reciever saying, "Hi, I'm <whoever it is>. Wanna talk?" The details of this message are not important except to minimize the potential effect of a DOS attack. I'll let you choose the details that are most appropriate to your application of the method, but keep in mind that the <whoever it is> can be encrypted.

The reciever responds with an encrypted message containing an integer sequence number. This message may contain other info, if you like. The sequence number determines the starting dictionary. E.g. if the sender and receiver share 10 dictionaries and the sequence number is 3502917, then the first dictionary to use is dictionary 7 (mod 10 arithmetic). (NOTE: The point of using the sequence number is to obfuscate which dicitonary is being used first to translate message. Other schemes could be used to accomplish this.)

Now the sender encrypts a message. Let's say the message is "aaaaaaaaaa". (The sender is trying to decide what to say:)) Let's say the value of the letter 'a' is decimal 97. So take the value in dictionary 7 at index 97. That's the encoding for the first 'a'. Look in the swap array at index 3502917 modulo 65536. Let's refer to the value at that index as n. Now swap the values in dictionary 7 at index 97 and index n. Do the same thing for the second 'a', using dictionary 8. Since this is the next encoding in the message, use the next index in the swap array. And so on. You see that the resulting encoding probably has all different codes, but if two or more of the codes are the same, it has not significance.

Before encrypting using POTP, compress the message. This obfuscates the length of the message, and increases the information density, i.e. reducing redundancy.

Added random bytes
A compression algorithm may leave areas of predictable values, e.g. the first hundred bytes or so, where it keeps header information. In such predicatable areas of the compressed message, alternate random bytes with the data bytes. Since the encryption is accomplished on a pair of bytes at a time, the previously predictable byte-pairs are no longer predictable. This eliminates a potential pattern in the unencrypted messages.

POTP is unbreakable. The hacker can record millions (or billions) of sequential messages, and still not have a clue about how to decrypt ANY part of ANY message. The hacker can have any amount of computing power and any amount of knowledge (short of the specific contents of the dictionaries and the original messages).

Why is POTP unbreakable? The answer is simple. The dictionaries change based on the actual data encrypted. This means that if a hacker does not have the original arrays or the original messages, or (even if she had the original arrays but) misses some messages that were sent, those new dictionaries are unknowable. As you can see from the example, no patterns are present in the encrypted data. But if you are concerned about a hacker being able to decypher any part of the billionth message, add a random number seed to this mix and have the sender and the reciever act as though they were sending/recieving randomly timed (based on the sequence number) and randomly valued messages--which messages are not actually sent, and thus cannot be known by any hacker.

Most readers probably see the applications quite clearly, but I'll name a few. In DoD, satellite to ground stations, planes to airports, ships to ports, etc. can use POTP. Spies can use POTP to safely send/receive messages across the Internet. Financial institutions can use POTP to communicate with each other and with their customers. I have some specific ideas about how to use POTP in ecommerce to make Internet banking safe forever.

POTP is not difficult to implement. It took me about 4 hours to implement a primitive version. If you are concerned (as you should be) about the sender and reciever data getting out of sync, consider re-sync options or simply use ACK/NAC or a method based on the database 2- or 3-phase commit. For satellite communications, I'd probably go to the 3-phase commit model.

Eliminating Sync Issues
More recently, I have developed a different slant on the basic POTP method that eliminates all sync issues. If you are interested, cantact me.

I published the basic concepts of POTP on three web forums. If you attempt to find a way to break POTP, please publish your findings and notify me. Publication is an important part of science. Thank you.