Exception errror in a program

[aman goyal]

This is the program:-

package org.crypto;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.math.BigInteger;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.interfaces.DSAKey;
import java.security.interfaces.DSAParams;
import java.security.interfaces.DSAPrivateKey;
import java.security.interfaces.DSAPublicKey;

public class testDSA {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {

			FileOutputStream outFile = new FileOutputStream("DSA.out");
			PrintStream output = new PrintStream(outFile);

	            // generate a DSA key pair
	            KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA");
			SecureRandom ran = new SecureRandom();
			byte[] bb = new byte[20];
			ran.nextBytes(bb);

			String w = cryptix.util.core.Hex.dumpString(bb);
			output.println("20 random bytes: " + w);

	 		keyGen.initialize(1024, ran);
	            KeyPair pair = keyGen.generateKeyPair();
		
	            // create a DSA Signature object
	            Signature dsa = Signature.getInstance("SHA/DSA"); 

			// cast as DSAKey in order to access G, P, Q directly
			BigInteger x, y, g, p, q, z, zz, phash, sig1;
			DSAKey priv2 = (DSAKey) pair.getPrivate();
			DSAParams params = priv2.getParams();
			g = (BigInteger) params.getG();
			w = cryptix.util.core.BI.dumpString(g);
			output.println("generator g = " + w);
			p = (BigInteger) params.getP();
			w = cryptix.util.core.BI.dumpString(p);
			output.println("prime p = " + w);
			q = (BigInteger) params.getQ();
			w = cryptix.util.core.BI.dumpString(q);
			output.println("order q of group G(q) = " + w);
			
			// check that the parameters are valid: does p mod q = 1?
			z = p.mod(q);
			w = cryptix.util.core.BI.dumpString(z);
	 		output.println("p mod q = " + w);
			
			// check that the parameters are valid: does g^q mod p = 1?
			z = g.modPow(q,p);
			w = cryptix.util.core.BI.dumpString(z);
	 		output.println("g^q mod p = " + w);

			// cast as DSAPrivateKey in order to access the private key (discrete log) X directly
	            DSAPrivateKey priv = (DSAPrivateKey) pair.getPrivate();
			x = (BigInteger) priv.getX();
			String sx = cryptix.util.core.BI.dumpString(x);
			output.println(" ");
			output.println("private key x = " + sx);

	            // cast as DSAPublicKey in order to access  the public key Y directly 
	            DSAPublicKey pub = (DSAPublicKey) pair.getPublic();
			y = (BigInteger) pub.getY();
			String sy = cryptix.util.core.BI.dumpString(y);
			output.println(" ");
			output.println("public key y = " + sy);

			// check the validity of the public-private key relationship
			z = g.modPow(x,p);
			w = cryptix.util.core.BI.dumpString(z);
			output.println(" ");
			output.println("Note here that the value of ");
	 		output.println("g^x mod p = " + w);
			output.println("which verifies the public key y.");		

			// create SHA-1 hash of y for fun (note that this is a DMT identifier) 
			output.println(" ");
			MessageDigest sha = MessageDigest.getInstance("SHA-1");
			byte[] yval = y.toByteArray();		
			byte[] ident = sha.digest(yval);
			String sident = cryptix.util.core.Hex.dumpString(ident);
			output.println("SHA-1 hash of y = " + sident);

	         	// initialize the Signature object for signing 
	         	dsa.initSign(priv);

	         	//update and sign the data
			//independently check the message digest
		  	MessageDigest md = MessageDigest.getInstance("SHA-1");
	        	FileInputStream fis = new FileInputStream(args[0]);
			byte b;
	        	while (fis.available() != 0) {
	        		b = (byte) fis.read();
	        		md.update(b);
	        		dsa.update(b);
	               		};
	        	fis.close();

			byte[] hash = md.digest();
			w = cryptix.util.core.Hex.dumpString(hash);
			output.println("the SHA-1 hash of " + args[0] + " is " + w);

	        	// now that all the data to be signed has been read in, sign it 
	        	byte[] sig = dsa.sign();
			w = cryptix.util.core.Hex.dumpString(sig);
			output.println("the DSA signature (byte array) is " + w);
			sig1 = new BigInteger(sig);
			w = cryptix.util.core.BI.dumpString(sig1);
			output.println("the DSA signature (BigInteger) is " + w);

	        	// extract the first part of signature 
			BigInteger Bfirst, Bsecond;
		  	byte[] bf = new byte[20];
		  	int i=0, j=0, k=0;

			// check if bytes are 0214h or 0215h and adjust accordingly
			// note that BigInteger from bytes must have positive sign
			if(sig[3]==21) j=1;
			if((j==0)&&(sig[25]==21)) k=1;
			else if((j==1)&&(sig[26]==21)) k=1;
			output.println(" j = " + j + " k = " + k);
			output.println(" sig[3] = " + sig[3] + " sig[25] = " + sig[25] + " sig[26] = " + sig[26]);
		  	for(i=4+j;i<24+j;i++) bf[i-4-j] = sig[i];
	        	Bfirst = new BigInteger(bf);
			if(j==1) {byte[] bg = new byte[21];
					    bg[0] = 0;
					    for(i=1;i<21;i++) bg[i]=bf[i-1];
					    Bfirst = new BigInteger(bg);
						}

			w = cryptix.util.core.BI.dumpString(Bfirst);
	        	output.println("The first number in signature = " + w);
	        	output.println(" ");

	        	// extract the second part of signature 
		  	byte[] bs = new byte[20];
		  	for(i=26+j+k;i<46+j+k;i++) bs[i-26-j-k] = sig[i];
	        	Bsecond = new BigInteger(bs);
			if(k==1) {byte[] bt = new byte[21];
					    bt[0] = 0;
					    for(i=1;i<21;i++) bt[i]=bs[i-1];
					    Bsecond = new BigInteger(bt);
						}
	       	w = cryptix.util.core.BI.dumpString(Bsecond);
	        	output.println("The second number in signature = " + w);
	        	output.println(" ");

			// verify signature by direct calculation
			// needed are the hash of the message, first and second
			//   parts of signature, public key Y, group generator G
			BigInteger Zero, Bhash, Bfirinv, Bsecinv, Bu1, Bu2, Ba, Bb, Bt, Bv;
			Zero = new BigInteger("0");
			Bhash = new BigInteger(hash);
			if(Bfirst.compareTo(Zero)==-1) output.println("verify = false");
			else if (Bsecond.compareTo(Zero)==-1) output.println("verify = false");
			else {
				Bsecinv = Bsecond.modInverse(q);   
				Bu1 = Bhash.multiply(Bsecinv);
				Bu1 = Bu1.mod(q);
				Bu2 = Bfirst.multiply(Bsecinv);
				Bu2 = Bu2.mod(q);
				Ba = g.modPow(Bu1,p);
				Bb = y.modPow(Bu2,p);
				Bt = Ba.multiply(Bb);
				Bt = Bt.mod(p);
				Bv = Bt.mod(q);
				if (Bv.compareTo(Bfirst)==0) output.println("verify (ind calculation) = true");
					else output.println("verify (ind calculation) = false");
	        		w = cryptix.util.core.BI.dumpString(Bv);
	        		output.println("verfication number is = " + w);
	        		output.println(" ");
				}
				
			// verify the signature using the verify function
			// initialize the Signature object for verification 

	            dsa.initVerify(pub);

	            // update and verify the data

	            fis = new FileInputStream(args[0]);
	            while (fis.available() != 0) {
	                b = (byte) fis.read();
	                dsa.update(b);
	                };

	            fis.close();

	            boolean verifies = dsa.verify(sig);
	            output.println("signature verifies (verification function): " + verifies);
			output.println(" ");

			outFile.close();
			System.out.println("File written");

	        } catch (Exception e) {
	            System.err.println("Caught exception " + e.toString());
	        }

	    }
		

	}

I am getting this error:-
Caught exception java.lang.ArrayIndexOutOfBoundsException: 0
Please help me to rectify the error

[Christophe Verré]

Next time UseCodeTags. I have added them for you.

[Christophe Verré]

I am getting this error:-
Caught exception java.lang.ArrayIndexOutOfBoundsException: 0

Posting the full stack trace would help a lot. It contains the exact line where the exception was raised.

[Evan Caballero]

perhaps there is a mistakes here : fis = new FileInputStream(args[0]);

If you do not pass any arguments to your program, the args array will be of length 0, so there won't be any element à index 0.