introduction graphic in pc

1. INTRODUCTION

Introduction to Cryptography:

In the era of information technology, the possibility that the information stored in a

person’s computer or the information that are being transferred through network of

computers or internet being read by other people is very high. This causes a major

concern for privacy, identity theft, electronic payments, corporate security, military

communications and many others. We need an efficient and simple way of securing

the electronic documents from being read or used by people other than who are

authorized to do it. Cryptography is a standard way of securing the electronic

documents.

1.1 Basic idea of Cryptography:

Basic idea of cryptography is to mumble-jumble the original message into something

that is unreadable or to something that is readable but makes no sense of what the

original message is. To retrieve the original message again, we have to transform the

mumble-jumbled message back into the original message again.

1.2 Basic Terminologies used in Cryptography:

Data that can be read and understood without any special measures is called plaintext

or cleartext. This is the message or data that has to be secured. The method of

disguising plaintext in such a way as to hide its substance is called encryption.

Encrypting plaintext results in unreadable gibberish called ciphertext. You use

encryption to ensure that information is hidden from anyone for whom it is not

intended, even those who can see the encrypted data. The process of reverting

ciphertext to its original plaintext is called decryption.

Cryptography is the science of mathematics to “encrypt” and “decrypt” data.

Cryptography enables us to store sensitive information or transmit it across insecure

networks like Internet so that no one else other the intended recipient can read it.

Cryptanalysis is the art of breaking Ciphers that is retrieving the original message

1

without knowing the proper key. Cryptography deals with all aspects of secure

messaging, authentication, digital signatures, electronic money, and other

applications.

1.3 Cryptographic Algorithms:

Cryptographic algorithms are mathematical functions that are used in the encryption

and decryption process. A cryptographic algorithms works in combination with a key

(a number, word or phrase), to encrypt the plain text. Same plain text encrypts to

different cipher texts for different keys. Strength of a cryptosystems depends on the

strength of the algorithm and the secrecy of the key.

1.4 Two Kinds of Cryptography Systems:

There are two kinds of cryptosystems: symmetric and asymmetric. Symmetric

cryptosystems use the same key (the secret key) to encrypt and decrypt a message,

and asymmetric cryptosystems use one key (the public key) to encrypt a message and

a different key (the private key) to decrypt it. Symmetric cryptosystems are also called

2

as private key cryptosystems and asymmetric cryptosystems are also called as public

key cryptosystems.

3

Overview of Private Key Cryptography:

In private-key cryptography, the sender and recipient agree beforehand on a secret private

key. The plaintext is somehow combined with the key to create the ciphertext. The method of

combination is such that, it is hoped, an adversary could not determine the meaning of the

message without decrypting the message, for which he needs the key. The following diagram

illustrates the encryption process:

The following diagram illustrates the decryption process:

4

Message to be encrypted or plain text

Encryption Algorithm

Encrypted message or Cipher text

Private Key known only to sender and receiver

Message to be decrypted or cipher text

Decryption Algorithm

Decrypted message or Plain text

Private Key known only to sender and receiver

To break a message encrypted with private-key cryptography, an adversary must

either exploit a weakness in the encryption algorithm itself, or else try an exhaustive

search of all possible keys (brute force method). If the key is large enough (e.g., 128

bits), such a search would take a very long time (few years), even with very powerful

computers.

Private-key methods are efficient and difficult to break. However, one major

drawback is that the key must be exchanged between the sender and recipient

beforehand, raising the issue of how to protect the secrecy of the key. When the

President of the United States exchanges launch codes with a nuclear weapons site

under his command, the key is accompanied by a team of armed couriers. Banks

likewise use high security in transferring their keys between branches. These types of

key exchanges are not practical, however, for e-commerce between, say, amazon.com

and a casual web surfer.

5

2. Literature survey

Literature survey is the most important step in software development process. Before

developing the tool it is necessary to determine the time factor, economy n company

strength. Once these things r satisfied, ten next steps are to determine which operating

system and language can be used for developing the tool. Once the programmers start

building the tool the programmers need lot of external support. This support can be

obtained from senior programmers, from book or from websites. Before building the

system the above consideration r taken into account for developing the proposed

system.

Overview of Public Key Cryptography:

Public Key cryptography uses two keys Private key (known only by the recipient) and

a Public key (known to everybody). The public key is used to encrypt the message

and then it is sent to the recipient who can decrypt the message using the private key.

The message encrypted with the public key cannot be decrypted with any other key

except for its corresponding private key. The following Diagram illustrates the

encryption process in the public key cryptography

6




Public Key known to everyone

http://www.blurtit.com/q876299.html




The following diagram illustrates the decryption process in the public key

cryptography:

The public-key algorithm uses a one-way function to translate plaintext to ciphertext.

Then, without the private key, it is very difficult for anyone (including the sender) to

reverse the process (i.e., translate the ciphertext back to plaintext). A one-way

function is a function that is easy to apply, but extremely difficult to invert. The most

common one-way function used in public-key cryptography involves factoring very

large numbers. The idea is that it is relatively easy to multiply numbers, even large

ones, with a computer; however, it is very difficult to factor large numbers. The only

known algorithms basically have to do a sort of exhaustive search (Does 2 go in to?

Does 3? 4? 5? 6? and so on). With numbers 128 bits long, such a search requires

performing as many tests as there are particles in the universe.

For instance, someone wishing to receive encrypted messages can multiply two very

large numbers together. She keeps the two original numbers a secret, but sends the

product to anyone who wishes to send her a message. The encryption/decryption

algorithm is based upon combining the public number with the plaintext. Because it is

a one-way function, the only way to reverse the process is to use one of the two

original numbers. However, assuming the two original numbers are very large, their

product is even bigger; it would be impractical for an adversary to try every

possibility to determine what the two original numbers were.

7




Private Key known only to receiver

2.1 RSA – Public Key Cryptography Algorithm:

2.1.1 Introduction to RSA Algorithm:

RSA is one of the most popular and successful public key cryptography algorithms.

The algorithm has been implemented in many commercial applications. It is named

after its inventor’s Ronald L. Rivest, Adi Shamir, and Leonard Adleman. They

invented this algorithm in the year 1977. They utilized the fact that when prime

numbers are chosen as a modulus, operations behave “conveniently”. They found that

if we use a prime for the modulus, then raising a number to the power (prime - 1) is 1.

RSA algorithm simply capitalizes on the fact that there is no efficient way to factor

very large integers. The security of the whole algorithm relies on that fact. If someone

comes up with an easy way of factoring a large number, then that’s the end of the

RSA algorithm. Then any message encrypted with the RSA algorithm is no more

secure.

2.1.2 RSA Algorithm:

The encryption and decryption in the RSA algorithm is done as follows. Before

encryption and decryption is done, we have to generate the key pair and then those

keys are used for encryption and decryption.

Key Generation:

The first step in RSA encryption is to generate a key pair. Two keys are generated of which

one is used as the public key and the other is used as the private key. The keys are generated

with the help of two large prime numbers. The keys are generated as follows

1. Generate two large random primes p and q.

2. Compute n which is equal to product of those two prime numbers, n = pq

3. Compute φ(n) = (p-1)(q-1).

4. Choose an integer e, 1 < e < φ(n), such that gcd(e, φ(n)) = 1.

5. Compute the secret exponent d, 1 < d < φ(n), such that ed ≡ 1 (mod φ(n)).

8

6. The public key is (n, e) and the private key is (n, d). The values of p, q, and

φ(n) should also be kept secret.

n is known as the modulus.

e is known as the public exponent or encryption exponent.

d is known as the secret exponent or decryption exponent.

Encryption:

Encryption is done using the public key component e and the modulus n. To

whomever we need to send the message, we encrypt the message with their public key

(e,n). Encryption is done by taking an exponentiation of the message m with the

public key e and then taking a modulus of it. The following steps are done in

encryption.

1. Obtain the recipient’s public key (n,e)

2. Represent the plaintext message as a positive integer m < n

3. Compute the ciphertext c = m^e mod n.

4. Send the ciphertext c to the recipient.

Decryption:

Decryption is done using the Private key. The person who is receiving the encrypted message

uses his own private key to decrypt the message. Decryption is similar to the encryption

except that the keys used are different.

1. Recipient uses his private key (n,d) to compute m = c^d mod n.

2. Extract the plaintext from the integer representative m.

The RSA algorithm has been implemented in many applications and it is currently

one of the most popularly used encryption algorithm. RSA algorithm is based fully on

mathematics and in the next section we will see the mathematics behind RSA.

2.1.3 Mathematics behind RSA:

9

The RSA algorithm works as follows. It first finds two prime numbers and generates a

key pair using those two prime numbers. Then the encryption and decryption are done

using the key pair.

p and q are distinct primes

N = pq

Find a, b such that ab = 1 mod (p-1)(q-1)

Encryption Key: e = (b, n)

Decryption Key: d = (a, n)

Encryption of message m: Ee(m) = mb mod n = C (cipher)

Decryption of C : Dd(C) = ca mod n = m

So in-order for RSA to work we must have the property :

(mb)a = m mod n

We have to prove that the above equation is true. If the above equation is proved then

we can say that the RSA algorithm really works. In the coming sections we will prove

the above equation and we will also look at the efficient ways of generating the prime

numbers. We will also look at how to find the keys a & b. There are many methods of

finding these numbers and we will see a few of them.

Preliminaries:

Before entering into the proofs, we must first know about the following terms and

symbols in order to follow it. These are basics of the RSA proof.

1. Zn = {0, 1, 2, … n-1}. This set is very familiar. Zn is the set of integers from 0 to n-

1.

2. Z*n = {x <n-1 | x and n are relatively prime}. Basically Z*n is the set that contains

all the numbers that is less than n and are relatively prime to n.

3. (n) = number of elements of Zn that are relatively prime to n. Hence (n) = | Z*n|

10

How to find (n)

We know that p and q are two prime numbers and n is the product of p and q. So n

factors into p and q. Therefore all those number that are not multiples of p or q are in

(n). If we count all the multiples of p and q, we get (n).

0, 1

p, 2p, 3p,…. (q-1)p = q-1

q, 2q, 3q,…. (p-1)q = p-1

hence to find the (n), we need to count all the multiples given above, which is

nothing but

(n) = pq – 1 – (q– 1) – (p– 1) = pq – p – q +1 = (p– 1)(q– 1)

Example: p=3, q=5 n=15.

Now (n) = 2*4 = 8 = {1, 2, 4, 7, 8, 11, 13, 14}

Before going to the proof of RSA lets have a look at some of the rules in the modulo

arithmetic. In the following sections, we will look at those rules and will prove some

of them.

5.1.1 Z*n is closed under multiplication mod n:

If a,b Z*n then ab and n are relatively prime i.e. ab shares no primes with n. By

definition of Z*n a, b do not share primes with n. Their product, ab, gets its primes

from a and b and therefore does not share primes with n.

The product can be written as ab = n + . We just need to show that is in Z*n .

But if it is not, then it shares primes with n and the right hand side is divisible by

some prime that is a factor of n. But then, so is the left side, which is impossible as we

showed that it is relatively prime with n.

11

5.1.2 Sa Z*n:

Lets first define what Sa is. Before that we know that we can represent Z*n as

Z*n = {b1, b2, … , b(n)}

Now for any a Z*n,

Let Sa = {ab1 mod n, ab2 mod n, …, ab(n) mod n}

First, by the proof shown in the section 5.1.1, all elements of Sa are in Z*n

Second, no two elements can be the same. Suppose they were, then for some bi and bj

(bi < bj)

a bi = n +

a bj = n +

Subtracting, (bi – bj)a = (-)n or x a = y n

x a and y n are the “same product of primes. Since a and n do not share any

common primes. All primes that form n has to appear in x.

Hence x>= n. That is a contradiction, as bj <n.

Since all elements of Sa are distinct, and in Z*n, then Sa and Z*n are identical. Note

that since all elements of Z*n are produced when a is multiplied by each element of

Z*n, then the element 1 is also a result of such a multiplication. Hence we get the

following condition:

if a Z*n then bk Z*n, s.t. abk = 1 mod n

5.1.3 if a Z*n then a(n) = 1 mod n

To prove this, lets first define c and A such that:

b1 b2 … b(n) = c mod n

(ab1 ab2 … ab(n)) = A mod n [Note, A and c are less than n]

Now since ab1 mod n ab2 mod n … ab(n) = A mod n

By the proof in the section 5.1.2, ab1 mod n, ab2 mod n,… ab(n) mod n is a

permutation of Z*n

12

Hence: A = c (plain arithmetic)

Now distributing the sequence differently:

(ab1 ab2 … ab(n)) = a(n) (b1 b2 … b(n)) ….. [1]

Let a(n) = mod n

Taking the modulo of both sides of [1] uses rule given below

A = c,

Replacing A with c, c = c , (plain arithmetic, not modulo).

Hence = 1.

Thus: a(n) = 1 mod n

For all a, b Zn (not Z*n)

if (ab = c mod n) and (a = x mod n) and (b = y mod n) and (xy = z mod n)

then c = z

5.1.4 If a and (n) are relatively prime then b, s.t. ab = 1 mod (n)

If a and (n) are relatively prime, then a Z* (n) and from Corollary of Claim 2 we

know that b exists (and is a member of Z* (n)).

Thus there exists a and b, both relatively prime to (n), such that:

ab = k(n) + 1 (regular arithmetic)

5.1.5 Proof of RSA (for all messages in Z*n)

Take a message m < n and choose a relatively prime to (n) and find b such that a

b=1 mod (n).

Now compute (ma)b using modulo n arithmetic:

13

(ma)b = mk(n) + 1 = mk(n) m = m(n) m(n) … … m(n) m

Take the modulo of the last term and since m(n) = 1 mod n, then result is m.

Hence (ma)b = m mod n

Deficiency of this proof: The proof is for all messages in Z*n

If n=512 bit number, then the chance of a number being in Zn but not in Z*n is about

10–25. That is negligible.

5.1.6 How to really find a, b?

We know that given a, b exists, but how to find them?

Find a, relatively prime number to n (3, 5, 7 etc – start with a small odd number and

work your way up). Note that (n) is even. To find b using extended Euclidean

algorithm as follows

Extended Euclidean Algorithm:

Given p and q, p>q the algorithm finds x and y, such that

xp * yq = GCD(p, q) [note: regular arithmetic, x or y is negative]

So we use it as follows:

We provide n and a as input and get x and y [note: GCD(a,n) = 1]

We know ab = αn + 1

Or – αn + ab = 1

So b = y

Hence in modulo arithmetic,

b = y, if y is positive and

b = (n) – y, if y is negative

14

Hence the keys, a and b can be computed easily using the Extended Euclidian

algorithm.

2.1.4 Finding Prime Numbers and hence the modulus N:

p and q are large prime numbers. So the problem is to find large prime numbers. Till

recently there was no good deterministic way of doing this. Very recently a Professor

from the IIT Kanpur, India and two of his students came up with a deterministic

polynomial time algorithm for finding if a number is prime or not. However, in prior

years this was done with probabilistic algorithms. There are very good probabilistic

algorithms, which can generate prime numbers in a very fast rate at 99.99%

probability that the number given by that algorithm is a prime. The actual fact is that

there are lots of large prime numbers. The number of prime numbers below N is about

N/(ln n) and hence for a random 2048 bit number, the probability of it being prime is

about 0.0007(one in 1500).

5.2.1 Prime Number Hunt:

But how would we really find the prime numbers? There are many theorems available

that can be used to find if the given number is prime or not. One of the most popularly

used theorems for finding if a given number is prime or not is the Fermat’s little

theorem. It states that for any a that is less than p, ap-1 = 1 mod p. We can use this

theorem to test the primality of a number, called as primality testing. The proof of the

theorem is given below.

Since p is prime, a Z* p and (p) = p – 1

Thus ap-1 = a(p) = 1 mod p.

Now to find the prime number, we can do the following steps

Choose a number p, randomly. This number, if large has a chance of being

prime in the order of 1 in several thousand.

15

Then choose a number a < p, randomly. We will use a to test the primality of

p. First, we know that if p is prime, ap-1 is 1 (mod p). Secondly, we know that

if for some x (where x is not 1 or p-1), if x2 is 1 or p-1 (mod p) then p is not

prime.

16

2.2. Computational complexity of the RSA algorithm:

The computational complexity of the RSA algorithm completely depends upon the

key length and the length of the modulus n. We exponent the key with the message

and take a modulus of that value with the modulus n. So the computational

complexity will depend upon these two factors. To find the exponentiation, we can

square the message and then multiply it again with the squared value. For example to

find 5^8, we can first find 5^2 by squaring 5 and then can find 5^4 by squaring the

resulted value of 5^2 and then can find 5^8 by squaring the resulted value of 5^4.

Hence the complexity of the encryption and decryption depends on how long the key

is.

Well, when we compute the complexity of the RSA we will have to look at all the

steps involved in the protocol right from the Prime number generation. Lets leave the

complexity of generating prime numbers aside for a while, as we are going to look at

a deterministic polynomial time algorithm in order to find the prime p. So lets start

with computing the complexities of the other steps in RSA.

The computational complexity of RSA encryption and decryption of a single n bit

block is approximately O(n^3), with n is denoting both the block length and key

length (exponent and modulus). This is due to the complexity of multiplication is

O(n^2 ), and the complexity of exponentiation is O(n) when square and multiply is

used. Although multiplication and exponentiation algorithms exist that have lower

asymptotic complexity, they are of limited technical interest when n<1000 is

assumed. If the message length m is sufficiently larger than the block length n, the

number of steps required to process a single message bit is of complexity O(n^2 ). If a

k bit datapath is used to speed up computation of n bit key length RSA, with k = n +

epsilon , the number of steps required to process a single message bit is O(n), as the

complexity of hardware is also O(n). When using shorter keys, e.g. 512 bit, the

execution time decreases approximately linearly.

The complexity of O(n^3) is clearly not a very high complexity since it is in

polynomial time. Next, we have to calculate the computational complexity of finding

17

the encryption component e and a decryption component d. This is done using the

Extended Euclidian algorithm. That is we need to find a number e, such that gcd(e,

(n)) = 1. All the powering and gcd calculations are clearly in polynomial time in the

number of bits of n. Our task is to find a number e such that gcd(e, (n)) = 1. We

know that the fraction of elements, which are relatively prime to N, is (1/ logN). So

setting N = (n), after o(logN) random trials for e, we should be able to get an e which

is prime to (n). This is still all polynomial in the number of bits of n.

Hence the complexity of the RSA algorithm is polynomial in time with respect to the

length of the key and the modulus, n.

2.3. Primes is in P:

As we saw in the previous sections, Prime numbers are basis for RSA encryption and

decryption. But how do you know that the number we chose is prime or not? There has been

research going on for more than 200 years in finding out a good deterministic polynomial

time algorithm which will take a number as a input and will tell if it is prime or not in

polynomial time. Till recently no one was able to produce a deterministic polynomial time

algorithm for this problem, though there had been lot of random polynomial time algorithm

and probabilistic algorithms available. Recently in the year 2002, a professor and two of his

students from the Indian Institute of Technology, Kanpur came up with a deterministic

polynomial time algorithm for this problem. Thanks to them as the 200 year problem has been

solved. In this section we will look at that algorithm and how it works. In the next section, we

will look at the complexity of the algorithm.

2.3.1 Basic notations:

In this section, we will look at some algebraic and number theoretic results, which the author

of this algorithm has used in the proofs. The symbol Fpd denotes the finite field, where p is a

prime. Recall that if p is a prime and h(x) is a polynomial of degree d and irreducible in Fp,

then Fp[x]=(h(x)) is a finite field of order pd.

18

Next h(x) will be a factor of xr-1/x-1 unless stated otherwise. The author has used the

symbol ~O(t(n)) for O(t(n)poly(log t(n))), where t(n) is some function of n. Unless

stated otherwise, the author uses log with respect to base 2.

Next look at some of the algebraic results that are useful in understanding this

algorithm. Let p and r be prime numbers, p != r. the following results are observed

and some of the results were proved by the author. In this section I am just producing

the rules that are used and for the proofs, please refer to the original paper by the

authors.

1. The multiplicative group of any field Fpt for t > 0, denoted by F*pt is cyclic.

2. Let f(x) be a polynomial with integral coefficients. Then

f(x)p f(xp) (mod p)

3. Let h(x) be any factor of xr - 1. Let m mr (mod r). Then

xm xmr (mod h(x)):

4. Let or(p) be the order of p modulo r. Then in Fp, xr-1/x-1 factorises into irreducible

polynomials each of degree or(p).

In addition to the above algebraic facts, we will need the following two number

theoretic facts.

Let P(n) denote the greatest prime divisor of n. There exist constants c > 0 and

n0 such that, for all x >= n0

|{P| P is prime, P<=x and P(p-1) > x2/3}| >= C x/log x

Let (n) be the number of primes <= n. Then for n >= 1

n/6log n <= (n) <= 8n/log n

2.3.2 Algorithm:

The algorithm that computes and tells if the given number is prime or not is given

below. This algorithm gets an input that is greater than 1 and computes and outputs

either COMPOSITE or PRIME.

Input: integer n > 1

19

1. if ( n is of the form ab, b > 1 ) output COMPOSITE;

2. r = 2;

3. while(r < n) {

4. if ( gcd(n,r) != 1 ) output COMPOSITE;

5. if (r is prime)

6. let q be the largest prime factor of r - 1;

7. if (q >= 4r log n) and (nr-1/q ! (mod r)

8. break;

9. r = r + 1;

10. }

11. for a = 1 to 2r log n

12. if ( (x - a)n ! (xn - a) (mod xr – 1, n)) output

COMPOSITE;

13. output PRIME;

The above algorithm returns PRIME is n is prime and returns COMPOSITE if n is

composite. Lets look at how it works by looking at the correctness of the algorithm.

The author has proved that the above algorithm works properly. Lets look at how it

works.

2.3.3 Correctness of the Algorithm:

2.3.3.1 If n is prime, the algorithm returns PRIME.

The while loop cannot return COMPOSITE since gcd(n, r) = 1 for all r <= c2(log n)6,

where c2 is defined in one of the lemmas given by the author. We know by the fact 2

that the for loop also cannot return COMPOSITE. Thus, algorithm will identify n as

PRIME. Now let us turn our attention to the case where a composite n is input to our

algorithm. The significance of the r found by the while loop arises when n is

composite with say pi; 1 <= i <= k, as its prime factors. In this case or(n) |

20

lcmi{or(pi)} and hence there exists a prime factor p of n such that q | o r(p), where q is

the largest prime factor of r-1. For the remainder of the argument, let p be such a

prime factor of n.

The second loop of the algorithm uses the value of r obtained to do polynomial

computations on l = 2r log n binomials: (x-a) for 1 <= a <= l. By fact 4, we have a

polynomial h(x) (factor of xr _ 1) of degree d = or(p) irreducible in Fp. Note that

(x - a)n (xn - a)(mod xr - 1, n)

the above equation implies that

(x - a)n (xn - a)(mod h(x), p)

So the identities on each binomial hold in the field Fp[x]/(h(x)). The set of l binomials

form a large cyclic group in this field.

2.3.3.2 If n is composite, the algorithm returns COMPOSITE.

Suppose that the algorithm returns PRIME instead. Thus, the for loop ensures that for

all

1 <= a <= 2r log n,

(x - a)n (xn - a)(mod xr - 1, p)

Notice that g(x) is just a product of powers of l binomials (x _ a), (1 <= a <= l) all of

which satisfy the above equation. Thus,

g(x)n g(xn) (mod xr _ 1, p)

Then author goes on to use two more lemmas that he has showed in his paper to

determine the values of Ig(x). Finally he proves that n = p is a contradictory. Hence

the algorithm returns COMPOSITE if n is composite.

21

2.3.4 Time Complexity Analysis of the algorithm:

The author has calculated the time complexity of the algorithm in a pretty

straightforward manner and the asymptotic time complexity of the algorithm turns out

to be O(log12 n).

Calculation of the time complexity:

The first step of the algorithm takes asymptotic time O(log3 n). As noted during the

analysis of the algorithm in the previous section, the while loop makes O(log6 n)

iterations. Let us now measure the work done in one iteration of the while loop. The

first step (gcd computation) takes poly(log log r) asymptotic time. The next two steps

would take atmost r1/2poly(log log n) time in the brute-force implementation. The next

three steps take atmost poly(log log n) steps. Thus, total asymptotic time taken by the

while loop is

O(log6n . r1/2 ) = O(log9 n).

The for loop does modular computation over polynomials. If repeated-squaring and Fast-

Fourier Multiplication is used then one iteration of this for loop takes O(log n_r log n) steps.

Thus, the for loop takes asymptotic time

O(r3/2 log3 n) = O(log12 n).

In practice, however, this algorithm is likely to work much faster. The reason is that even

though we only know that there are “many" primes r such that P(r - 1) > r2/3, a stronger

property is believed to be true. In fact it is believed that for many primes r,

P(r - 1) = (r –1)/2 .

Such primes are called Sophie Germain primes.

This ends the time complexity computation of the algorithm. As per the author, they are

trying to improve the running time complexity of the algorithm to O(log3 n).

22

2.4. Comparison of the RSA algorithm with other

algorithms:

RSA is one of the most popularly used cryptography algorithms, but still there are

many other algorithms that are being used today. One of the popularly used

algorithms other than RSA is Elliptic Curve (EC) cryptography algorithm. Let’s first

see a comparison with the EC algorithm

8.1 Comparison with EC algorithm:

People say that ECC is very much faster than RSA, but actually ECC is significantly

faster than RSA only when used with precomputed values. That is, you can store your

ECC key in a small space, but if you want to get the performance advantage, you also

have to store some tables of precomputed values. These tables can be as many as

20,000 bytes. But if you don’t have 20,000 bytes of storage space lying around (say

your smart card), you may not be able to use the precomputed tables. But if you don’t,

the ECC is not that much faster than RSA. With ECC you can sign fast or save

storage space, but you can’t do both. Of course, saving storage space and transmission

size may be reason enough.

Furthermore, using ECC with or without precomputed values to perform key

exchange is not that much faster than RSA. So the only real advantage to using ECC

to perform key exchange is key and transmission size.

Another disadvantage to ECC is certificates. Public-key crypto does not really work

without digital certificates, and digital certificates don’t really work without

certificate authorities. It’s hard to find ECC digital certificates. So even if you want to

use ECC, you might not be able to get a certificate.

Currently in the industry, RSA is winning. The key size, transmission size and

signature performance issues concern makers of small devices. But they often find

23

that RSA is fast and small enough. Sure, it’s not the fastest signer or the smallest key,

but it still works just fine. And RSA has a well-developed certificate infrastructure.

N

24

3. SYSTEM ANALYSIS

EXISTING SYSTEM:

Generally, the utilization of the encryption techniques has raises different

security issues, which consisted mostly on how to effectively manage the

encryption keys to ensure that they are safeguarded throughout their life cycle

and are protected from unauthorized disclosure and modification.

Several reasons in the encryption of information over block cipher are

observed in terms of key management, which known as an important issue to

the public safety community, most of these issues addressed the following:

o Difficulties in addressing the security issues regarding encryption key

management;

o Lacks in providing a suitable details about the different threats in terms

of decision makers on the importance of key management;

o Difficulties in generating the suitable recommendations for

establishing proper key management.

PROPOSED SYSTEM:

Sequentially, providing a secure and flexible cryptography mechanism raises

the needs for analyzing and comparing different encryption algorithms for the

aim of enhancing the security during the encryption process.

Hence, this paper suggested a cryptography mechanism in the block cipher by

managing the keys sequentially.

These keys will works dependently for extracting and generating the content

relation to be managed later by the key management that helps to

communicate and share sensitive information.

In particular, the importance of thorough, consistent key management

processes among public safety agencies with interoperable functions cannot be

overstated.

25

This model aims to secure dissemination, loading, saving, and eliminating

faults of keys to make encryption implementations effective.

There are inherent possibilities if suitable key management processes are not

accompanied because of the intricacy of dispensing keys to all block in a

certain fashion.

This risk can be meaningfully appeased through sufficient key controls and

proper education on encryption key management.

System Requirements:

Hardware Requirements:

• System : Pentium IV 2.4 GHz.

• Hard Disk : 40 GB.

• Floppy Drive : 1.44 Mb.

• Monitor : 15 VGA Colour.

• Mouse : Logitech.

• Ram : 256 Mb.

Software Requirements:

• Operating system :- Windows XP Professional

• Front End :- JAVA, Swing(JFC)

• Tool :Eclipse 3.3

26

4. SYSTEM STUDY

2.1 FEASIBILITY STUDY

The feasibility of the project is analyzed in this phase and business

proposal is put forth with a very general plan for the project and some cost

estimates. During system analysis the feasibility study of the proposed system is

to be carried out. This is to ensure that the proposed system is not a burden to the

company. For feasibility analysis, some understanding of the major requirements

for the system is essential.

Three key considerations involved in the feasibility analysis are

ECONOMICAL FEASIBILITY

TECHNICAL FEASIBILITY

SOCIAL FEASIBILITY

ECONOMICAL FEASIBILITY This study is carried out to check the economic impact that the system will

have on the organization. The amount of fund that the company can pour into the

research and development of the system is limited. The expenditures must be justified.

Thus the developed system as well within the budget and this was achieved because

most of the technologies used are freely available. Only the customized products had

to be purchased.

TECHNICAL FEASIBILITY

This study is carried out to check the technical feasibility, that is, the

technical requirements of the system. Any system developed must not have a high

demand on the available technical resources. This will lead to high demands on the

available technical resources. This will lead to high demands being placed on the

client. The developed system must have a modest requirement, as only minimal or

null changes are required for implementing this system.

SOCIAL FEASIBILITY The aspect of study is to check the level of acceptance of the system by the user.

This includes the process of training the user to use the system efficiently. The user

must not feel threatened by the system, instead must accept it as a necessity. The level

27

of acceptance by the users solely depends on the methods that are employed to

educate the user about the system and to make him familiar with it. His level of

confidence must be raised so that he is also able to make some constructive criticism,

which is welcomed, as he is the final user of the system.

28

5. SYSTEM DESIGN

Data Flow Diagram / Use Case Diagram / Flow Diagram

The DFD is also called as bubble chart. It is a simple graphical

formalism that can be used to represent a system in terms of the input data to the

system, various processing carried out on these data, and the output data is generated

by the system.

29

Secret data secret data

30

sender receiver

Encrypt the data Decrypt the data

Embed the data Extract the data

6. IMPLEMENTATION

Implementation is the stage of the project when the theoretical design is turned out

into a working system. Thus it can be considered to be the most critical stage in

achieving a successful new system and in giving the user, confidence that the new

system will work and be effective.

The implementation stage involves careful planning, investigation of the

existing system and it’s constraints on implementation, designing of methods to

achieve changeover and evaluation of changeover methods.

Main Modules:-

MODULES:

• Homophonic Cryptographic IDE

• Encryption Module with Key Generation

• Decryption Module

31

7. SYSTEM TESTING

The purpose of testing is to discover errors. Testing is the process of trying to

discover every conceivable fault or weakness in a work product. It provides a way to

check the functionality of components, sub assemblies, assemblies and/or a finished

product It is the process of exercising software with the intent of ensuring that the

Software system meets its requirements and user expectations and does not fail in an

unacceptable manner. There are various types of test. Each test type addresses a

specific testing requirement.

TYPES OF TESTS

Unit testing Unit testing involves the design of test cases that validate that the internal

program logic is functioning properly, and that program inputs produce valid outputs.

All decision branches and internal code flow should be validated. It is the testing of

individual software units of the application .it is done after the completion of an

individual unit before integration. This is a structural testing, that relies on knowledge

of its construction and is invasive. Unit tests perform basic tests at component level

and test a specific business process, application, and/or system configuration. Unit

tests ensure that each unique path of a business process performs accurately to the

documented specifications and contains clearly defined inputs and expected results.

Integration testing

Integration tests are designed to test integrated software components to

determine if they actually run as one program. Testing is event driven and is more

concerned with the basic outcome of screens or fields. Integration tests demonstrate

that although the components were individually satisfaction, as shown by successfully

32

unit testing, the combination of components is correct and consistent. Integration

testing is specifically aimed at exposing the problems that arise from the

combination of components.

Functional test

Functional tests provide systematic demonstrations that functions tested are

available as specified by the business and technical requirements, system

documentation, and user manuals.

Functional testing is centered on the following items:

Valid Input : identified classes of valid input must be accepted.

Invalid Input : identified classes of invalid input must be rejected.

Functions : identified functions must be exercised.

Output : identified classes of application outputs must be exercised.

Systems/Procedures: interfacing systems or procedures must be invoked.

Organization and preparation of functional tests is focused on requirements, key

functions, or special test cases. In addition, systematic coverage pertaining to identify

Business process flows; data fields, predefined processes, and successive processes

must be considered for testing. Before functional testing is complete, additional tests

are identified and the effective value of current tests is determined.

System Test System testing ensures that the entire integrated software system meets

requirements. It tests a configuration to ensure known and predictable results. An

example of system testing is the configuration oriented system integration test.

System testing is based on process descriptions and flows, emphasizing pre-driven

process links and integration points.

White Box Testing White Box Testing is a testing in which in which the software tester has

knowledge of the inner workings, structure and language of the software, or at least its

33

purpose. It is purpose. It is used to test areas that cannot be reached from a black box

level.

Black Box Testing Black Box Testing is testing the software without any knowledge of the inner

workings, structure or language of the module being tested. Black box tests, as most

other kinds of tests, must be written from a definitive source document, such as

specification or requirements document, such as specification or requirements

document. It is a testing in which the software under test is treated, as a black

box .you cannot “see” into it. The test provides inputs and responds to outputs without

considering how the software works.

6.1 Unit Testing:

Unit testing is usually conducted as part of a combined code and unit test

phase of the software lifecycle, although it is not uncommon for coding and unit

testing to be conducted as two distinct phases.

Test strategy and approach

Field testing will be performed manually and functional tests will be written in

detail.

Test objectives

• All field entries must work properly.

• Pages must be activated from the identified link.

• The entry screen, messages and responses must not be delayed.

Features to be tested

• Verify that the entries are of the correct format

• No duplicate entries should be allowed

• All links should take the user to the correct page.

34

6.2 Integration Testing

Software integration testing is the incremental integration testing of two or

more integrated software components on a single platform to produce failures caused

by interface defects.

The task of the integration test is to check that components or software

applications, e.g. components in a software system or – one step up – software

applications at the company level – interact without error.

Test Results: All the test cases mentioned above passed successfully. No defects

encountered.

6.3 Acceptance Testing

User Acceptance Testing is a critical phase of any project and requires

significant participation by the end user. It also ensures that the system meets the

functional requirements.

Test Results: All the test cases mentioned above passed successfully. No defects

encountered.

35

8. RESULTS

SAMPLE SCREENS

Screen shots

36

CONCLUSION

Cryptography can be a technology that develops, but as long as security is made by

man, cryptography is as good as the practice of people who uses it. This paper

focused on the different security issues for providing a secure and effective

cryptography technique over the block cipher. Most of these issues occurred when

users leave keys unattended, keys that were chosen were easy to remember or

maintain the same keys for years. This can be resolved by the suggested model, using

the encrypting key that existed independently as an external tool by managing keys

sequentially.

40

10. BIBLIOGRAPHY

Good Teachers are worth more than thousand books, we have them in Our

Department

References Made From:

[1] W. Ehrsam, et al., "A cryptographic key management scheme for implementing

the Data Encryption Standard," IBM Systems Journal, vol. 17, pp. 106-125, 2010.

[2] J. Katz and Y. Lindell, Introduction to modern cryptography: Chapman &

Hall/CRC, 2008.

[3] W. Stallings, Cryptography and network security: principles and practice: Prentice

Hall, 2010.

[4] T. Fukunaga and J. Takahashi, "Practical fault attack on a cryptographic LSI with

ISO/IEC 18033-3 block ciphers," 2010, pp. 84-92.

[5] J. Amigo, et al., "Theory and practice of chaotic cryptography," Physics Letters A,

vol. 366, pp. 211-216, 2007.

[6] X. Zhang and K. Parhi, "Implementation approaches for the advanced encryption

standard algorithm," Circuits and Systems Magazine, IEEE, vol. 2, pp. 24-46, 2003.

[7] S. Heron, "Advanced Encryption Standard (AES)," Network Security, vol. 2009,

pp. 8-12, 2009.

[8] A. Barenghi, et al., "Low voltage fault attacks to AES and RSA on general

purpose processors," IACR eprint archive, vol. 130, 2010.

41

[9] B. Jyrwa and R. Paily, "An area-throughput efficient FPGA implementation of the

block cipher AES algorithm," 2010, pp. 328-332.

[10] N. Potlapally, et al., "A study of the energy consumption characteristics of

cryptographic algorithms and security protocols," IEEE Transactions on Mobile

Computing, pp. 128-143, 2006.

[11] K. Chan and F. Fekri, "A block cipher cryptosystem using wavelet transforms

over finite fields," Signal Processing, IEEE Transactions on, vol. 52, pp. 2975-2991,

2004.

[12] S. Lian, et al., "A block cipher based on a suitable use of the chaotic standard

map," Chaos, Solitons & Fractals, vol. 26, pp. 117-129, 2005.

[13] A. Biryukov and A. Shamir, "Cryptanalytic time/memory/data tradeoffs for

stream ciphers," Advances in Cryptology—ASIACRYPT 2000, pp. 1-13, 2000.

[14] T. Xiang, et al., "A novel block cryptosystem based on iterating a chaotic map,"

Physics Letters A, vol. 349, pp. 109-115, 2006.

[15] K. Gupta and P. Sarkar, "Construction of perfect nonlinear and maximally

nonlinear multi-output Boolean functions satisfying higher order strict avalanche

criteria," Progress in Cryptology- INDOCRYPT 2003, pp. 85-87, 2003.

[16] A. Mousa and A. Hamad, "Evaluation of the RC4 Algorithm for Data

Encryption," Proc. Of 418 International Journal Computer Science & Applications,

vol. 3, 2006.

[17] A. Ray and D. Das, "Encryption Algorithm for Block Ciphers Based on

Programmable Cellular Automata," Information Processing and Management, pp.

269-275, 2010.

Sites Referred:

http://java.sun.com

42

http://www.sourcefordgde.com

http://www.networkcomputing.com/

http://www.roseindia.com/

http://www.java2s.com/

43

introduction graphic in pc

Documents