Ashish Thengare: March 2017

Friday, 24 March 2017

Diffie Hellman algortihm java code

package diffiehellman;
import java.util.*;
import java.io.*;
class DiffieHellman
{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.println(“Enter the value of Xa & Xb”);
int Xa=sc.nextInt();
int Xb=sc.nextInt();
System.out.println(“Enter a Prime no. p”);
int p=sc.nextInt();
System.out.println(“Enter Primitive Root a, such that a<p”);
int a=sc.nextInt();
int Ya=(int)((Math.pow(a,Xa))%p);
int Yb=(int)((Math.pow(a,Xb))%p);
int Ka=(int)((Math.pow(Yb,Xa))%p);
int Kb=(int)((Math.pow(Ya,Xb))%p);
if(Ka==Kb)
{
System.out.println(“Transmission successful”);
}
else
{
System.out.println(“Transmission failed”);
}
}
}

message digest technique MD5 algorithm

package create.digest;
import java.io.*;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.*;
public class CreateDigest {
public static void main(String[] args)throws FileNotFoundException{
try{
FileOutputStream fos = new FileOutputStream("sample.txt");
MessageDigest md= MessageDigest.getInstance("MD5");
ObjectOutputStream oos = new ObjectOutputStream(fos);
String data = "I am ashish";
byte buffer []=data.getBytes();
System.out.println("buffer:-"+buffer);
md.update(buffer);
oos.writeObject(data);
oos.writeObject(md.digest());
System.out.println("Message Digest"+md);
System.out.println("Data:-"+data);
System.out.println("Digest:-"+(md.digest()).toString());
System.out.println("Done...!");
}catch(Exception e){
e.printStackTrace();
}
}
}

output:
run:
buffer:-[B@a88bc2
Message DigestMD5 Message Digest from SUN, <initialized>

Data:-I am ashish
Digest:-[B@17d7c01
Done...!

BUILD SUCCESSFUL (total time: 7 seconds)

Tuesday, 14 March 2017

RSA algorithm java code

```
import java.io.DataInputStream;
```
```
import java.io.IOException;
```
```
import java.math.BigInteger;
```
```
import java.util.Random;
```
```
 
```
```
public class RSA
```
```
{
```
```
    private BigInteger p;
```
```
    private BigInteger q;
```
```
    private BigInteger N;
```
```
    private BigInteger phi;
```
```
    private BigInteger e;
```
```
    private BigInteger d;
```

    private int        bitlength = 1024;

```
    private Random     r;
```
```
 
```
```
    public RSA()
```
```
    {
```
```
        r = new Random();
```

        p = BigInteger.probablePrime(bitlength, r);

        q = BigInteger.probablePrime(bitlength, r);

```
        N = p.multiply(q);
```

        phi = p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE));

        e = BigInteger.probablePrime(bitlength / 2, r);

        while (phi.gcd(e).compareTo(BigInteger.ONE) > 0 && e.compareTo(phi) < 0)

```
        {
```
```
            e.add(BigInteger.ONE);
```
```
        }
```
```
        d = e.modInverse(phi);
```
```
    }
```
```
 
```

    public RSA(BigInteger e, BigInteger d, BigInteger N)

```
    {
```
```
        this.e = e;
```
```
        this.d = d;
```
```
        this.N = N;
```
```
    }
```
```
 
```
```
    @SuppressWarnings("deprecation")
```

    public static void main(String[] args) throws IOException

```
    {
```
```
        RSA rsa = new RSA();
```

        DataInputStream in = new DataInputStream(System.in);

```
        String teststring;
```

        System.out.println("Enter the plain text:");

```
        teststring = in.readLine();
```

        System.out.println("Encrypting String: " + teststring);

        System.out.println("String in Bytes: "

                + bytesToString(teststring.getBytes()));

```
        // encrypt
```

        byte[] encrypted = rsa.encrypt(teststring.getBytes());

```
        // decrypt
```

        byte[] decrypted = rsa.decrypt(encrypted);

        System.out.println("Decrypting Bytes: " + bytesToString(decrypted));

        System.out.println("Decrypted String: " + new String(decrypted));

```
    }
```
```
 
```

    private static String bytesToString(byte[] encrypted)

```
    {
```
```
        String test = "";
```
```
        for (byte b : encrypted)
```
```
        {
```
```
            test += Byte.toString(b);
```
```
        }
```
```
        return test;
```
```
    }
```
```
 
```
```
    // Encrypt message
```

    public byte[] encrypt(byte[] message)

```
    {
```

        return (new BigInteger(message)).modPow(e, N).toByteArray();

```
    }
```
```
 
```
```
    // Decrypt message
```

    public byte[] decrypt(byte[] message)

```
    {
```

        return (new BigInteger(message)).modPow(d, N).toByteArray();

```
    }
```
```
}
```