# What is cryptography?

Encryption is the transformation of data into a form that is (hopefully) impossible to read without the knowledge of a key. Its purpose is to ensure privacy by keeping information hidden from anyone for whom it is not intended.
Decryption is the reverse of encryption; it is the transformation of encrypted data back into an intelligible form.

Encryption and decryption generally require the use of some secret information, referred as key. Some encryption mechanisms use the same key for both encryption and decryption; others use different keys for the two processes.

Cryptography is fundamentally based on so called hard problems; i.e. problems that can be solved only with a large computation waste. Some examples are factoring, theorem-proving, and the "travelling salesman problem" (finding the route through a given collection of cities which minimizes the total length of the path).

There are two types of cryptosystems: secret key and public key.
In secret key cryptography (or symmetric cryptography) the same key is used for both encryption and decryption. The most popular secret-key cryptosystem in use today is known as DES (Data Encryption Standard), developed by IBM in the middle 1970's.
In public key cryptography, each user has a public key and a private key. The first one is made public and the second one remains secret. The public key is used during encryption, while decryption is done with the private key. Today the RSA public key cryptosystem is the most popular form of public key cryptography. RSA stands for Rivest, Shamir, and Adleman, the inventors of the RSA cryptosystem.
Another popular public key technique is the Digital Signature Algorithm (DSA), though it can only be used for signatures.

# Public key cryptography

In secret key (or symmetric) cryptography the sender and receiver of a message know and use the same secret key: the sender uses the secret key to encrypt the message, and the receiver uses the same secret key to decrypt the message.
Using a similar system the main problem to solve is the key management problem, or getting the sender and receiver to agree on the secret key without anyone else finding out. Anyone who intercepts the key in transit can later read, modify, and forge all messages encrypted or authenticated using that key.

In order to solve this problem, Whitfield Diffie and Martin Hellman introduced the concept of public key cryptography in 1976. In their system, each person gets a pair of keys, one called the public key and the other called the private key. The public key is published, while the private key is kept secret. The sender and the receiver don't need to share any secret information because all communications involve only public keys: no private key is ever transmitted or shared.
Anyone can send a confidential message by just using public information, but the message can only be decrypted with a private key, which is in the sole possession of the intended recipient.

The communication scheme is the following: when A wishes to send a secret message to B he uses B's public key to encrypt the message and sends it. B then uses his private key to decrypt the message and read it. Anyone can send an encrypted message to B, but only B can read it (because only B knows B's private key).

In a public key cryptosystem the private key is always linked mathematically to the public key. Therefore, it is always possible to attack a public key system by deriving the private key from the public key. Typically, the defense against this is to make the problem of deriving the private key from the public key as difficult as possible. Some public key cryptosystems are designed such that deriving the private key from the public key requires the attacker to factor a large number; in this case to perform the derivation is computationally infeasible because multiplying two prime integers together is easy, but as far as we know, factoring the product of two prime numbers is much more difficult.
That is the reason because factoring is the underlying, presumably hard problem upon which several public key cryptosystems are based, including the RSA algorithm.
It has not been proven that factoring must be difficult, and remains a possibility that a quick factoring method might be discovered, though this possibility is today considered remote.
In general, the larger the number the more time it takes to factor it. This is why the size of the modulus in RSA determines how secure an actual use of RSA is; the larger the modulus, the longer it would take an attacker to factor, and thus the more resistant the RSA modulus is to an attack.

# PGP (Pretty Good Privacy)

PGP is a program developped by Phil R. Zimmermann that allows you to communicate in a secure way over an insecure channel. Using PGP you can easily and securely protect the privacy of your data by encrypting them so that only intended individuals can read it.
PGP is based on public key cryptography: two complementary keys, called a key pair, are used to maintain secure communications. One of the keys is designated as a private key to which only you have access and the other is a public key which you freely exchange with other PGP users. Both your private and your public keys are stored in keyring files.

Before you begin using PGP, you need to generate this key pair.
After you created a key pair, you can begin corresponding with other PGP users. You will need a copy of their public key and they will need yours. The public key is just a block of text, so it's quite easy to trade keys with someone. Some standard techniques are including your public key in an email message, copying it to a file, or posting it on a public or corporate key server where anyone can get a copy when he need it. After you generated your key pair and exchanged public keys, you can begin encrypting and signing email messages and files.

### Making a key pair

The following informations and commands refer to PGP 5.0i. Some changes may occur using a different PGP release. Informations about getting and installing the program are not covered in this article.

In order to use PGP features, the first operation you must accomplish is generating a key pair. From the command line enter:

```
pgpk -g
```

You must reply to some question in order to generate your keys:

• The algorithm to use in the encrypting messages (DSS/DH or RSA).

• The key size, or the number of bits used to construct your digital key. A larger key is stronger but it takes more time to encrypt and decrypt. Unless you are exchanging extremely sensitive information you are safe using a key composed of 1024 bits.

• Enter your user ID. It's not absolutely necessary to enter your real name or even your email address. However, using your real name makes it easier for others to identify you as the owner of your public key. For example:

```
Matteo Dell'Omodarme <matt@martine2.difi.unipi.it>
```

If you do not have an email address, use your phone number or some other unique information that would help ensure that your user ID is unique.

• Enter a passphrase, a string of characters or words you want to use to maintain exclusive access to your private key.

The generated key pair is placed on your public and secret keyrings in your \$HOME/.pgp directory. Here you can find the file pubring.skr, containing the public keys and the file secring.skr, the file of your secret key.

pgpk is the command to use in order to manage public and private keys for PGP. So you can extract your public key from your keyring in such a way:

```pgpk -x my_username@my_hostname > my_key
```
To add a new public key, stored in keyfile, into your database:
```pgpk -a keyfile
```
and, to remove a key:
```pgpk -r newuser@new_hostname
```

### Encrypting and decrypting with PGP

pgpe encrypts and signs files using public key cryptography, or encrypts files using conventional cryptography.
The simplest use of the command is the following:

```pgpe text_file newuser@new_hostname
```
which encrypts the plaintext file text_file using the public key of the intended receiver. Many options are available (see the pgpe manual page), some of them are reported here:
• -a, --armor:
Turn on "ASCII Armoring". This outputs a text-only version of your encrypted text. This makes the result safe for mailing, but about 30% larger.

• -f:
Stream mode. Accepts input on stdin and places output on stdout. If no files are specified as arguments, PGP executes in this mode by default.

• -o outfile:
Specifies that output should go to outfile. If not specified, output goes to the default filename. The default filename for each input file is the input filename with ".pgp" appended, unless ASCII Armoring is turned on, in which case it is ".asc". It is an error to specify multiple input files with this option.

• -t:
Turns on text mode. This causes PGP to convert your input message to a platform-independent form. It is primarily for use when moving files from one operating system to another.

pgpv decrypts and verifies files encrypted and/or signed by PGP.
In order to decrypt a message encrypted using your public key enter the command:

```pgpv text_file.pgp
```
Some options are available; among them there are:
• -f:
Stream mode. Accepts input on stdin and places output on stdout. If no files are specified as arguments, PGP executes in this mode by default.

• -o outfile:
Specifies that output should go to outfile. If not specified, output goes to the default filename. The default filename for each input file is the input filename with the ".pgp" ".asc" or ".sig" removed. It is an error to specify multiple input files with this option.

# Configuring Pine to handle PGP messages automatically

An useful option of the the mailer Pine makes possible to handle automatically the encryption of outgoing messages and the decryption of the received ones. In the file \$HOME/.pinerc search for the lines starting with display-filters and sending-filters and do the following insertions:

```# This variable takes a list of programs that message text is piped into
# after MIME decoding, prior to display.
display-filters=_BEGINNING("-----BEGIN PGP MESSAGE-----")_ /usr/bin/pgpv

# This defines a program that message text is piped into before MIME
# encoding, prior to sending
sending-filters=/usr/bin/pgpe -taf _RECIPIENTS_
```

The display-filters line says that: "when a received mail starts with the given string (i.e. -----BEGIN PGP MESSAGE-----) process its contents using the program /usr/bin/pgpv". Since all PGP messages start in such a way all PGP encrypted messages are automatically trapped by pgpv and decrypted (obviously only if they are encrypted with your public key).

The sending-filters line sets /usr/bin/pgpe as the program processing outgoing messages, using the email address (i.e. _RECIPIENTS_) of the intended receiver to select which public key must be used by PGP encryption mechanism.

Occurred the previous modifications, you are able to send encrypted messages or plaintext messages, choosing among them at sending time. A question is asked before your mail is sent out:

```Send message (unfiltered)?
```

Replying Y to the question forces Pine to send the mail in a plaintext form, while hitting Ctrl-N sequence (i.e. Next Filter option) make you able to choose among different filters.
If pgpe is the sole filter defined, the following message is displayed:

```Send message (filtered thru "pgpe")?
```

Replying Y to that question makes Pine encrypt the message with the appropriate public key and send it.