# Evolution Of Large Integers Factorization Computer Science Essay

Published:

This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.

In this paper we worked on facing the problem of different types of attacks, attacks on cipher text and leak the large amount of confidential information. Our goal in this paper is to survey some of these attacks and describe the mathematical methods which are used in these different types' attacks. This different approach provides higher security assurance. Some attacks breaking RSA algorithms for steeled important data from different resources. we seek a very conservative definition that ensure security even if the attacker is given access to a decryption, so how can we hope to achieve any meaningful notation of security.

The answer is that we marginally weaken the decryption to prevent the user from it on the challenge cipher text. We do not require any information about the plain text we also show how the plaintext can be recovered without having access to the cipher text at all. Side conduit attacks are an important class of implementation level attacks on cryptographic systems. Our goals are inform about intermediate values or calculations, whether by timing or other side channels or otherwise may be able to determine information about the keying data and the recipient private key.

Introduction:

RSA be subject to the effort of factorizing large integers such as n addicted on its fundamental p and q. With

The growth in the quickness of computers and the enlargement of factorization methods, it becomes gradually feasible to factorize large numbers. It is Pervasive in balanced calculations, public key cryptography or computer algebra. Many gcd procedures have been planned. Superficially hard mathematical difficulties stand at the central of recent cryptography. A classic security evidence for a cryptographic protocol narrates its conflict against a specific attack to the toughness of some measured problem. Very few complications survived the systematic analysis of scientists, the most traditional ones being the integer factoring problem and the isolated logarithm problem.

The Extended Euclidean algorithm offers a debauched explanation to the problem of ï¬nding the leading public divisor of two numbers. In this paper, we introduce one of three applications of the algorithm to the safety and confidentiality ï¬eld. The ï¬rst one is a method for monitoring the release of discrete logarithm based public keys. It can be used to secretly supply a public key to a set of recipients. The other one is a validation approach to be used in circumstances in which a public key arrangement is not available. Finally, the third approach of the Extended Euclidean algorithm is a zero tolerance immune that decreases the amount of messages between the two chunks who involved in it. Attack can be done with the information of the private key. Here, we tried to find out the private key d with multiplicative inverse algorithm which is more secure than previous approach. Conversely, with factorization of N we can recover the d value.

Problem definition:

Integer Factorization in the circumstance of Cryptography In particular public key cryptography can be used for confirming the confidentiality authenticity and integrity of information, in an organization. To protect the sensitive information in an organization, encryption can be pragmatic to conceal sensitive data so that the encrypted data is completely worthless except to the authorized individuals with the correct decryption key. Factoring large integers is one of the most striking problems of computational mathematics. FindingÂ d from nÂ andÂ eÂ is as hard as factoringÂ nÂ intoÂ pÂ andÂ q up to a polynomial time variance. Â However, Press-studs to protect the sensitive information in an union, encryption can be applied to conceal delicate data so that the encrypted data is completely meaningless except to the authorized individuals with the correct decryption key. To preserve the authenticity and integrity of data, digital signature can be performed on the data such that other people can neither imitate the correct signer nor modify the signed data without being detected. RSA is one of the most popular public key cryptographic algorithms in used in exchange.

Suppose tony wants to send an encrypted message to tom Let the public key of tom be <e,n> and the private key of tom be <d,n> where n is the product of two prime numbers p and q (with ed=1 (mod (p-1)(q-1)). In this consequence, <e, n> is accessible to anyone who wants to send encrypted messages to tom while d is kept secretly by tom. To encrypt a Message M for tom, tony has to compute M = Me (mod n). Tom can decrypt M' by computing M = (Me) d=M (mod n). No one except tom can decrypt M since d is only known to tom. To calculate d from e, it is necessary to factor n to get p and q. With p and q, it is possible to calculate (p-1) (q-1). By moving back the key generation technique, d can be calculated by computing e-1 (mod (p-1) (q-1)). The security of RSA depends on the difficulty in factoring n into p and q if n is sufficiently large. Therefore, the size of n should be chosen such that the time and cost for execution the factorization exceeds the value of the encoded facts.

Solution approach:

How it work in a scheme the server verifies whether the product of the factors sent by the client is equal to the N value sent by the server to the client (N=p*q). If this situation is not satisfied or the values are not sent by the client, then the server will drop the request. When the server is fronting normal flow of traffic the requests to the server is less than the beginning value, we do not interfere with the web application. When the number of requests received at the server crosses the threshold value, our solution is invoked and the server starts sending N to all the clients. A user using a web browser will involvement a momentary delay when the JavaScript calculates the values p and q on his patron machine but then his request get through when presented to the server An aggressor who is using a malicious client will not send these p and q values and his requests get released. If he now modifies his client to read the JavaScript and compute p and q the quantity of requests that he can send will drop down drastically. If the distributed attack Sustains or deepens, we can increase the number of digits in N and this will correct the malevolent clients further without collective any load on the server.

Solution methodology:

In cryptographies system, it is usually required to calculate the inverse of modulus purpose of one number to another. The extended Euclidean's algorithm provides an sophisticated way to calculate this inverse function. The algorithm calculates the greatest common divisor (gcd) of two integers. We will number the steps of the Euclidean algorithm starting with step 1. The quotient obtained at step 2, I will be denoted by qi. As we convey out each step of the Euclidean algorithm, we will also calculate an supplementary number, yi for the first two steps the value of this number is given. Y0 =0 and y1=1. For the remainder of the steps, we recursively calculate yi = yi-2-yi-1 qi-2(mod n). Continue this calculation for one step elsewhere the last step of the Euclidean algorithm. The algorithm starts by dividing n by x. if the last non zero remainder occurs at step k, and then If this remainder is 1x has an inverse and it is YK+2.

If remainder is not 1, then x does not have an inverse.

Now be present an illustration:

Treasure the illustration of 15 mod 26.

Step 1> 26=1(15) +11 y0=1

Step 2> 15=1(11) +4 y1=1

Step 3> 11=2(4) +3 y2= 0-1(1) mod 26 =25

Step 4> 4=1(3) +0 y4 =25-2(2)

Step 5> 3=3(1) +0 y4= 25-2(2) mod26=21 Y5=2-21(1) mod26= -19mod26 = 7

We got it 15(7) = 105 = 1+4(26) is corresponding to 1 (mod26).

## Coding:

import java.io.*;

import java.util.*;

class GCD

## {

public static void main (String[] args)

## {

int a=0, b=0, d;

int sign_a = 1, sign_b = 1;

int[] ans = new int[3];

Scanner obj=new Scanner(System.in);

if (args.length < 2) {

System.out.println("-----------------Please input two arguments!----------------------------");

System.out.println(" Please input FIRST arguments!==:");

a=obj.nextInt();

System.out.println("Please input SECOND arguments==:");

b=obj.nextInt();

## }

else if (args.length > 0) {

try {

## }

catch (NumberFormatException e) {

System.err.println("\n Arguments must be integers!\n");

// System.exit(1);

## }

try {

## }

catch (NumberFormatException e) {

System.err.println("\n Arguments must be integers!\n");

//System.exit(1);

## }

## }

if ((a == 0) && (b == 0)) {

System.out.println("\n Oops, both arguments are zero! No GCD of zero!\n");

System.exit(1);

## }

if ( a < 0 )

## {

sign_a = -1;

a = Math.abs(a);

## }

if ( b < 0 )

## {

sign_b = -1;

b = Math.abs(b);

## }

ans = ExtendedEuclid(a,b);

System.out.println("\n gcd(" + a*sign_a + "," + b*sign_b +") = " + ans[0]);

System.out.print(" " + ans[0] + " = (" + sign_a*ans[1] + ") (" + sign_a*a +")");

System.out.println(" + (" + sign_b*ans[2] + ") (" + sign_b*b + ")\n");

## }

public static int[] ExtendedEuclid(int a, int b)

## {

int[] ans = new int[3];

int q;

if (b == 0) {

ans[0] = a;

ans[1] = 1;

ans[2] = 0;

## }

else

## {

q = a/b;

ans = ExtendedEuclid (b, a % b);

int temp = ans[1] - ans[2]*q;

ans[1] = ans[2];

ans[2] = temp;

## }

return ans;

## }

## }

Output:

Implementation: First we take 2 prime numbers randomly. With the multiplication of these numbers we get RSA modulus N value. With the formula of Ð¤(n)=(p-1)(q-1) we check the condition (1<e<Ð¤(n)) and gcd(e,Ð¤(n))=1 then we take the value e and n value and apply multiplicative inverse method on it and we get the different values for each of e, here value of e is the prime number greater than 100 which satisfies the above two conditions. With the method of multiplicative inverse formula we get two values t1 and t1 with the mod of these two values we find the d value which is the private key. We get different private key for each of the e value.

Result: We take the prime number which is greater than 100 so the probability of getting d value is very high. Here, we get different key values for each e value of same RSA modulus N here is d is the private key which is used to encrypt the data, where e is the public key exponent.

Analysis: We did probabilistic examines of a fast substitute of the large integer fractions through such gcd algorithm, which uses the values of multiplicative inverse method. We have to change the constraints of RSA algorithm to intensification the complexity of algorithm so we need to outspread the Euclidean algorithm.

Over and done with this algorithm we can more defending compared to the basement exploration attacks such as factorization attacks. And finally the problems in factorization of n bulky integer also increase the convolution of crypt analyzing so the algorithm will also get complex. It is all about to provide more sanctuary to RSA.

## Conclusions and Future works:

A Euclidean algorithm is to expand system performance by on condition that the capacity of the large, secure efficiency with an access time close to that of the fast access. In this paper, we have obtainable a new technique on integer number factorization method, which one included the Euclidean algorithm for providing the better result without fail. This simple methodology implements a form of by passing the altered keys value. We develop a large integer factorization on RSA security methodology to evaluate the performance of the recommended direct or indirect attacks on data system which will be more dangerous for large information and database. Euclidean algorithm augments the reuse activities of the temporal data while cultivating the reuse of the no temporal data by RSA. From our investigational results, we see that our method is both fast and perfect.