A cryptographic algorithm, also called a cipher, is the mathematical function used for encryption and decryption. (Generally, there are two related
functions: one for encryption and the other for decryption.)

If the security of an algorithm is based on keeping the way that algorithm works a secret, it is a

**restricted** algorithm. Restricted algorithms have
historical interest, but are woefully inadequate by today’s standards. A large orchanging group of users cannot use them, because every time a user leaves the
group everyone else must switch to a different algorithm. If someone accidentally reveals the secret, everyone must change their algorithm.

Modern cryptography solves this problem with a key, which in addition to algorithm is required to encrypt or decrypt data. All of the security in these algorithms is based in the key (or keys); none is based in the details of the algorithm. This means that the algorithm can be published and analyzed.

There are two general types of key-based algorithms: symmetric and public-key.

**Symmetric algorithms**, sometimes called conventional algorithms, are algorithms where the encryption key can be calculated from the decryption key and vice versa. In most symmetric algorithms, the encryption key and the decryption key are the same. These algorithms require that the sender and receiver agree on a key before they can communicate securely.

**Public-key algorithms** (also called asymmetric algorithms) are designed so that the key used for encryption is different from the key used for decryption. Furthermore, the decryption key cannot (at least in any reasonable amount of
time) be calculated from the encryption key. The algorithms are called “public-key” because the encryption key can be made public: A complete stranger can use the encryption key to encrypt a message, but only a specific person with the corresponding decryption key can decrypt the message. In these systems, the encryption key is often called the public key, and the decryption key is often called the private key.

**Security**
Categories of breaking an algorithm, in decreasing order of severity can be classified as:

- Total break. A cryptanalyst finds the key with which she can decrypt encrypted messages
- Global deduction. A cryptanalyst finds an alternate algorithm, letting him encrypt mesages without knowing key.
- Instance (or local) deduction. A cryptanalyst finds the plaintext of an intercepted ciphertext.
- Information deduction. A cryptanalyst gains some information about the key or plaintext. This information could be a few bits of the
key, some information about the form of the plaintext, and so forth.

An algorithm is unconditionally secure if, no matter how much ciphertext a cryptanalyst has, there is not enough information to recover the plaintext.

Cryptography is more concerned with cryptosystems that are computationally infeasible to break. An algorithm is considered computationally secure (sometimes called strong) if it cannot be broken with available resources, either current or future.

**Steganography**
Steganography serves to hide secret messages in other messages, such that the secret’s very existence is concealed. Generally the sender writes an innocuous
message and then conceals a secret message on the same piece of paper.

Historical tricks include invisible inks, tiny pin punctures on selected characters, minute differences between handwritten characters, pencil marks on typewritten characters, grilles which cover most of the message except for a few characters, and so on.

More recently, people are hiding secret messages in graphic images. Replace the least significant bit of each byte of the image with the bits of the message.
The graphical image won’t change appreciably—most graphics standards specify more gradations of color than the human eye can notice—and the message can be stripped out at the receiving end. You can store a 64-kilobyte message in a 1024 × 1024 grey-scale picture this way. Several public-domain programs do this sort of thing.

**Substitution ciphers**
A substitution cipher is one in which each character in the plaintext is substituted for another character in the ciphertext. The receiver inverts the substitution on the ciphertext to recover the plaintext.

**Transposition Ciphers**
In a transposition cipher the plaintext remains the same, but the order of characters is shuffled around. In a simple columnar transposition cipher, the
plaintext is written horizontally onto a piece of graph paper of fixed width and the ciphertext is read off vertically. Decryption is a matter of writing the ciphertext vertically onto a piece of graph paper of identical width and then reading the plaintext off horizontally.

**One-Time Pads**
There is a perfect encryption scheme. It’s called a one-time pad. Classically, a one-time pad is nothing more than a large nonrepeating set of truly random key letters, written on sheets of paper, and glued together in a pad. The sender uses each key letter on the pad to encrypt exactly one plaintext character. Encryption is the addition modulo 26 of the plaintext character and the one-time pad key character. Assuming an eavesdropper can’t get access to the one-time pad used to encrypt
the message, this scheme is perfectly secure.

The caveat, and this is a big one, is that the key letters have to be generated randomly. Any attacks against this scheme will be against the method used to generate the key letters. Using a pseudo-random number generator doesn’t count; they always have nonrandom properties. If you use a real random source—this is much harder than it might first appear, secure. The other important point is that you can never use the key sequence again, ever.