## Archive for the ‘**Python**’ Category

## Phase of product of complex-circular Gaussian random variables

What is the distribution of the phase of the product of two independent zero-mean complex-circular Gaussian random variables? I try to answer the question in this IPython notebook.

## RSA : Public Key Cryptography Algorithm ( Project on Abstract Algebra )

Abstract Algebra was one of the mathematics course I took for the Fall semester which has just ended. The complete course has two parts taught over two semesters. I took the first part and it mainly covered some basic Number Theory and largely Group Theory. As a part of the project I had to a class project and my choice was RSA : A Public Key Cryptography Algorithm. The strength of RSA is based on difficulty in factoring large integers, specially those formed as product of two integers. The algorithm uses Number Theory concepts of modulo exponentiation, the Euler’s function and the decryption is based on Euler’s theorem. My objectives were to study the algorithm itself and do a simple implementation.

In public key cryptography, the key has a *public part* and a *private part*. The public part is made known to everybody where as the private part is kept secret by the receiver ( My PGP public key ). Anyone who intends to send a message to the receiver encrypts the plaintext using the public key corresponding to the receiver. Once encrypted using the public key, the ciphertext can only be decrypted using the private key, which is safe with the receiver.

RSA is a public key cryptography algorithm jointly developed by R. Rivest, A. Shamir and L. Adleman and it was described in a paper in 1978. The name of the algorithm comprises of the first letters of the three authors surnames. The algorithm was originally patented by M.I.T. but was released to public domain in September 2000. The algorithm has three steps (1) Key generation (2) Encryption (3) Decryption.

**Key Generation**

The RSA key pair is generated as follows

* Generate a pair of prime numbers $latex *p$* and

* Compute $latex *n = pq$$*

* Compute the Euler’s function

* Find an integer $e$ such that and is coprime with i.e. $gcd(e,\phi(n)) = 1$.

* Find another integer such that . This is determined using extended Euclidean algorithm which gives where $k$ is some integer.

The public key consists of the pair and the private key consists of the pair .

**Encryption and Decryption**

RSA algorithm uses modulo exponentiation operation for both encryption and decryption. The plaintext is first converted to numeric codes before they are encrypted. For instance, the letters in the plaintext are represented as integers for example ‘a’ = 00, ‘b’ = 01 ‘z’ = 25. Once the plaintext is represented by numeric codes the ciphertext is generated as

The receiver decrypts the ciphertext using modulo exponentiation operation with private key pair as

The decryption works as follows:

Now according to the Fermat’s Little theorem, for any integer x and prime number p (which is not a factor of x), . Also by definition of the Euler’s function . Thus

This is true even when . Following similar argument for the prime number q,

Combining above two equations according to the Chinese Remainder Theorem, we get

.

Hence

( A complete explanation is available in the original paper )

As a second part of the project, I implemented a simple version of RSA algorithm in Python . The program can generate an RSA public and private key pair, encrypt a plaintext string and recover original message from the ciphertext. The keys generated are eight digits long. The plaintext can be a string ( Roman alphabets only for now, no special characters ). The program can be downloaded here.

## Nth Prime Number

Python implementation for finding Nth prime number#!/usr/bin/python # thousandPrime.py : Finds the 1000th prime number, fork of Problem Set 1 MIT 6.00 # Programmed: Saurav R Tuladhar # Date: Oct 7, 2011 # Declare state variables counter = 1; # Counts number of primes idx = 1; testNum = 2*idx + 1; # Odd numbers > 2 as candidates primeList = [2]; isPrime = True while counter < 10000: for x in primeList: if testNum % x == 0: # Only check for prime numbers < testNum. Based on Fundamental Theorem of Arithmetic. isPrime = False break if isPrime == True: primeList = primeList + [testNum] counter = counter + 1 # Reset variables isPrime = True idx = idx + 1 testNum = 2*idx + 1 print primeList[-1]