## Posts Tagged ‘**Security**’

## Zero-Knowledge Proofs

I think I’m going to make Sundays “Learn About Cryptology Day”. Here’s the first installment: Zero-Knowledge Proofs. ZKP is an interactive process in which one party can prove that they know a secret without revealing any information about that secret. In doing this, a ZKP must satisfy three criteria:

- Must be
**complete**in the sense that if a person follows the protocol and passes then they have successfully proved that they are honest (within reasonable probability) - Must be
**sound**such that a dishonest party cannot fool anyone (within reasonable probability) - Must be
**zero-knowledge**meaning it cannot reveal any information about the secret, thus a dishonest party cannot learn anything while faking the process.

### Cave Example

To demonstrate a hypothetical system I need to introduce some characters. ZKPs are usually a two party systems, there is a *prover* (Peggy) whose goal is to convince a *verifier* (Victor) something. In this example, Peggy will know a secret that opens a door in a cave. The cave is circular and there is a door on the far end that blocks the path.

Victor would like to purchase this password from Peggy, but he doesn’t want to give her any money until he is convinced that she knows the password. Peggy is not about to tell him anything about the password since that would devalue it. Together, they devise a system that will convince Victor that Peggy knows the password but satisfy Peggy’s need to secrecy.

Peggy enters the cave by selecting a path, A or B, at random. Victor does not know which direction she chose. Once Peggy is beyond the bend, Victor enters the front of the cave, picks a direction, A or B, and shouts it to Peggy. She must exit the cave in this direction. If she has to pass the door to do this, then she must unlock the door with the password. There is a probability of 0.5 that Victor will chose the path that Peggy entered and she can simply turn around an leave. This at first might seem like it ruins the whole procedure, but consider the probability of Peggy successfully anticipating Victor’s request say, 100 times (0.5^100 = 7.8×10^-31). The chances of this happening are sufficiently low to be considered within reasonable probability. The protocol is shown below (images from Wikipedia)

NP Problems

A more realistic implementation of ZKP is done with NP-complete problems. NP-complete problems are a set of problems that are computationally difficult to solve, but easy to verify given then question and the solution. They are a subset of NP (**N**on-deterministic **P**olynomial time) class problems. A common implementation of ZKP with an NP-complete problem is to use Isomorphic graph transformations and Hamiltonian cycles. Given a graph *G*, a Hamiltonian cycle is a path around *G* that visits each vertex exactly once and returns to the starting vertex. There are many different cycles for each graph, provided the graph has a cycle to begin with. In this example, Peggy knows a graph *G*, and a Hamiltonian cycle*. *Victor knows the graph, but not the cycle. Peggy aims to convince Victor that she knows the cycle without revealing anything about it.

- Peggy creates an isomorphic graph of G, call it
*H*, - Victor now asks Peggy to do one of two things: show that
*H*is isomorphic to*G*, or give a Hamiltonian cycle to*H*. By revealing the cycle of*H*Peggy proves that she knows the cycle of*G*, because it is trivial to transform the cycle of*G*to that of*H*if*G*and*H*are isomorphic. - If Victor asked Peggy to show that
*H*is isomorphic to*G*then she must provide the vertex translations needed to transform*H*into*G*. - If Victor asked Peggy for a Hamiltonian cycle for
*H*then she transforms the cycle that she has for*G*and sends it to Victor. This reveals nothing about the cycle of*G*since Victor won’t have the vertex translations and doesn’t know exactly how*H*is isomorphic to*G*.

This problem is exactly the same as cave, with a probability of 0.5 that Peggy will be able to fool Victor at each step. Any NP-complete problem can be adapted and used in a ZKP, provided there hasn’t been a break through that allows NP-complete problems to be solved efficiently (P=NP). The security of these systems rely on the number of times the system is repeated, each time making it more and more difficult for Peggy to continue to fool Victor.

There are many adaptations of ZKP, including a non-interactive version, and research is ongoing trying to find ways to incorporate these into authentication systems and the Internet. Post questions in the comments section below.

## Public Key Cryptography – RSA

In this post I plan to discuss the concept of public key cryptography and explain how the RSA algorithm works. The inspiration for this post is two fold. First, I’m currently working on a encrypted messaging application named Scytale which should be released relatively soon and secondly because I find it particularly fascinating.

Crypto-systems fall into two separate categories, symmetric and asymmetric. Symmetric systems use a single key for encrypting and decrypting. A simple example of this is the Caesarian Shift cipher, which takes the alphabet and shifts it a certain number of characters. Below is an example of a Caesarian cipher with a shift of 4 characters.

Alphabet: abcdefghijklmnopqrstuvwxyz

Shift: defghijklmnopqrstuvwxzyabc

attack at dawn = dwwdfn aw gdyq

The symmetric key used here would be 4. This key would have to be known by both parties involved, and kept secret from any enemies. Of course, this is a trivial example and not a very secure was to encrypt any information. A more modern example would be the previous encryption standard DES, or the current standard Rijndael.

Asymmetric crypto-systems are an entirely different breed. They are called asymmetric because one key is used for encryption and another for decryption. The parties involved can post their respective encryption keys publicly, and keep their decryption keys to themselves. These systems are deeply rooted in mathematics and number theory. In this post I will explain one of the more popular asymmetric systems, RSA.

The security of RSA is based on the difficulty of calculating the prime factors of large composite numbers. The system has three components: Key generation, encryption, and decryption.

Key Generation

Each party that wishes to receive encrypted messages must first generate a key. This key will have two parts, a public key and a private key. To generate the key, two sufficiently large prime numbers are selected, *p* and *q*. These two primes are multiplied together to form the composite number *n*. The size of *n* is the strength of the system. If the person wants 2048 bit encryption, then *n* must be a 2048 bit number. The encrypting exponent *e* is now selected at random. This can be any number, as long as it is greater than 1 and less than the Euler totient of *n*, and is coprime to the Euler totient of *n*. The Euler totient of a number n is defined to be the number of positive integers less than *n* that are coprime to *n. *Because *n *is a composite number generated from two prime numbers, it is very easy to calculate it’s Euler totient (p-1)(q-1), if the two prime factors are known. Now the decrypting, *d*, exponent must be calculated. *d *is simply the inverse of *e* modulus the Euler totient of *n*. The modulus operator (mod) is simply the remainder of division. 5 mod 2 is equivalent to 2, because 5/2=4 with 1 remaining. Inverse in modulus arithmetic is trivial to find if the modding interger m (in this case the Euler totient of n) is known. I wrote a Powershell script to solve the inverse mod which can be found here. If the modding integer is not known however, it is quite difficult. Here in lies the security of RSA: for *d* to be calculated, the totient(n) must be known and for the totient(n) to be calculated, the prime factors of n (p and q) must be known. Now the participants can publish their public key {e, n} while making sure to keep their private key {d, p, q} to themselves.

Encryption

A plaintext message M is converted into a series of numbers (usually base 64), and split into blocks the size of *n*. Each block is encrypted separately and combined together to produce the cipher text. Each block is raised to the exponent* e* and modded by *n*. This is generally a quick calculation because *e* is usually small.

Decryption

A cipher text C is broken into blocks the size of *n* and decrypted separately. Each block is raised to the decrypting exponent *d* and modded by *n*. This operation can be done quite quickly by utilizing Chinese Remainder Theorem and Fermat’s Little theorem. CRT states that if the modding integer can be broken into prime factors, then the operation can be broken into two smaller operations and then combined together. This is shown below:

Yes, that looks pretty ugly, but it is significantly faster than computing the exponent without the theorem. Because p and q are prime, d can be reduced quickly to d mod p-1 or d mod q-1, depending on the equation. Also, since C will be larger than p and q, C can be quickly reduced to C mod p, or C mod q. This greatly reduces the time needed to compute the plain text.

Let’s do an example.

Simple, eh?

RSA has it’s drawbacks though. For starters, the cipher text size is rounded up to powers of *n*, meaning the message will get very large quickly. Also, the security of the system is based the difficulty to factor *n* into its two prime factors. This is a very difficult problem if *n* is large. The problem is, how large does *n* have to be? So far, a 1024 bit *n* has been factored in a fairly reasonable amount of time. For a message to be secure, a key size of 2048 bits to 4096 bits is recommended. As technology improves, the key size will have to grow accordingly. Elliptic curve cryptology, which can be adapted to any algorithm, is now being used in place of standard RSA to combat the key size problem. I will introduce elliptic cryptology in a later post.

Later I will present several other crypto-systems and introduce Scytale when it is complete.