[Arianne-commits] marauroa/src/marauroa/common/crypto RSAPublicKey.java, 1.4, 1.5 Hash.java, 1.2, 1.3 RSAKey.java, 1.3, 1.4

[Daniel H. <wik...@us...>]

Update of /cvsroot/arianne/marauroa/src/marauroa/common/crypto
In directory sc8-pr-cvs11.sourceforge.net:/tmp/cvs-serv31203/src/marauroa/common/crypto

Modified Files:
	RSAPublicKey.java Hash.java RSAKey.java 
Log Message:
Java Code Conventions (Eclipse autoformatting)
Organized Import (Eclipse)

Index: RSAKey.java
===================================================================
RCS file: /cvsroot/arianne/marauroa/src/marauroa/common/crypto/RSAKey.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** RSAKey.java	16 Apr 2005 10:29:38 -0000	1.3
--- RSAKey.java	20 Aug 2006 15:40:17 -0000	1.4
***************
*** 13,141 ****
  package marauroa.common.crypto;
  
  import java.math.BigInteger;
  import java.security.SecureRandom;
- import java.io.PrintWriter;
- import java.io.PrintStream;
  
  public class RSAKey extends RSAPublicKey {
!   private BigInteger d;
! 
!   public RSAKey(BigInteger n, BigInteger d, BigInteger e) {
!     super(n,e);
!     this.d = d;
!   }
  
!   public void print(PrintWriter out) {
!     super.print(out);
!     out.println("d = " + d);
!   }
  
!   public void print(PrintStream out) {
!     super.print(out);
!     out.println("d = " + d);
!   }
  
!   public static RSAKey generateKey(int nbBits) {
!     BigInteger p;
!     BigInteger q;
!     BigInteger n;
!     BigInteger d;
!     BigInteger e = new BigInteger("15");
!     BigInteger phi;
  
!     byte[] nonce = new byte[(nbBits / 16) + 1];
  
!     SecureRandom rand;
!     try {
!       rand = SecureRandom.getInstance ("SHA1PRNG");
!       rand.nextBytes (nonce);
!     }
!     catch(Exception ex) {
!       System.err.println("Can't happen...");
!       ex.printStackTrace();
!       System.exit(1);
!     }
  
!     if(nonce[0] >= 0) {
!       nonce[0] -= 128;
!     }
  
!     p = new BigInteger(1,nonce);
  
!     p = p.subtract(p.remainder(big6)).subtract(big1);
!     q = p.subtract(big6);
  
!     //Select two prime numbers, p and q, such
!     // that n = p*q > max and the number of
!     // characters in n is <= blockSize, where
!     // max is the maximum possible data value in
!     // a data block.
!     //Use the incoming first guess for p and then
!     // iterate by increasing the value of p until
!     // a highly-probable prime number is
!     // found.
  
!     while(!(p.isProbablePrime(1000) && p.multiply(big2).add(big1).isProbablePrime(1000))){
!       p = p.add(big6);
!     }//end while loop
  
!     //Make the first guess for q one less than p
!     // and then iterate until a highly-probable
!     // prime number is found for q that satisfies
!     // the two conditions given above.
  
!     //The current value of q satisfies one of
!     // the required conditions, but may not be
!     // a prime number.  Get the next prime number
!     // smaller than the current value of q.
!     while(!(q.isProbablePrime(1000) && q.multiply(big2).add(big1).isProbablePrime(1000))){
!       q = q.subtract(big6);
!     }//end while loop
  
!     p = p.multiply(big2).add(big1);
!     q = q.multiply(big2).add(big1);
  
  
!     //Now we have a prime value for q that
!     // satisfies one of the two required
!     // conditions.  Compute the current value
!     // for n and start working to confirm or
!     // satisfy the other condition.
!     n = p.multiply(q);
  
!     //Compute phi, as (p - 1)*(q - 1).
!     BigInteger pPrime = p.subtract(big1);
!     BigInteger qPrime = q.subtract(big1);
!     phi = pPrime.multiply(qPrime);
  
!     //Compute e.  First guess is incoming
!     // value.
!     while(!e.gcd(phi).equals(big1)){
!       e = e.add(big1);
!     }//end while loop
  
!     //Compute the value for d
!     d = e.modInverse(phi);
!     return new RSAKey(n,d,e);
!   }
  
!   public BigInteger decode(BigInteger message) {
!     return message.modPow(d,n);
!   }
  
!   public byte[] decodeByteArray(byte[] message) {
!     return Hash.BigIntToBytes(decode(new BigInteger(message)));
!   }
  
!   public BigInteger sign(BigInteger message) {
!     return decode(message);
!   }
  
!   public RSAPublicKey getPublicKey() {
!     return new RSAPublicKey(n,e);
!   }
  
!   public BigInteger getD() {
!     return d;
!   }
  }
--- 13,141 ----
  package marauroa.common.crypto;
  
+ import java.io.PrintStream;
+ import java.io.PrintWriter;
  import java.math.BigInteger;
  import java.security.SecureRandom;
  
  public class RSAKey extends RSAPublicKey {
! 	private BigInteger d;
  
! 	public RSAKey(BigInteger n, BigInteger d, BigInteger e) {
! 		super(n, e);
! 		this.d = d;
! 	}
  
! 	public void print(PrintWriter out) {
! 		super.print(out);
! 		out.println("d = " + d);
! 	}
  
! 	public void print(PrintStream out) {
! 		super.print(out);
! 		out.println("d = " + d);
! 	}
  
! 	public static RSAKey generateKey(int nbBits) {
! 		BigInteger p;
! 		BigInteger q;
! 		BigInteger n;
! 		BigInteger d;
! 		BigInteger e = new BigInteger("15");
! 		BigInteger phi;
  
! 		byte[] nonce = new byte[(nbBits / 16) + 1];
  
! 		SecureRandom rand;
! 		try {
! 			rand = SecureRandom.getInstance("SHA1PRNG");
! 			rand.nextBytes(nonce);
! 		} catch (Exception ex) {
! 			System.err.println("Can't happen...");
! 			ex.printStackTrace();
! 			System.exit(1);
! 		}
  
! 		if (nonce[0] >= 0) {
! 			nonce[0] -= 128;
! 		}
  
! 		p = new BigInteger(1, nonce);
  
! 		p = p.subtract(p.remainder(big6)).subtract(big1);
! 		q = p.subtract(big6);
  
! 		// Select two prime numbers, p and q, such
! 		// that n = p*q > max and the number of
! 		// characters in n is <= blockSize, where
! 		// max is the maximum possible data value in
! 		// a data block.
! 		// Use the incoming first guess for p and then
! 		// iterate by increasing the value of p until
! 		// a highly-probable prime number is
! 		// found.
  
! 		while (!(p.isProbablePrime(1000) && p.multiply(big2).add(big1)
! 				.isProbablePrime(1000))) {
! 			p = p.add(big6);
! 		}// end while loop
  
! 		// Make the first guess for q one less than p
! 		// and then iterate until a highly-probable
! 		// prime number is found for q that satisfies
! 		// the two conditions given above.
  
! 		// The current value of q satisfies one of
! 		// the required conditions, but may not be
! 		// a prime number. Get the next prime number
! 		// smaller than the current value of q.
! 		while (!(q.isProbablePrime(1000) && q.multiply(big2).add(big1)
! 				.isProbablePrime(1000))) {
! 			q = q.subtract(big6);
! 		}// end while loop
  
+ 		p = p.multiply(big2).add(big1);
+ 		q = q.multiply(big2).add(big1);
  
! 		// Now we have a prime value for q that
! 		// satisfies one of the two required
! 		// conditions. Compute the current value
! 		// for n and start working to confirm or
! 		// satisfy the other condition.
! 		n = p.multiply(q);
  
! 		// Compute phi, as (p - 1)*(q - 1).
! 		BigInteger pPrime = p.subtract(big1);
! 		BigInteger qPrime = q.subtract(big1);
! 		phi = pPrime.multiply(qPrime);
  
! 		// Compute e. First guess is incoming
! 		// value.
! 		while (!e.gcd(phi).equals(big1)) {
! 			e = e.add(big1);
! 		}// end while loop
  
! 		// Compute the value for d
! 		d = e.modInverse(phi);
! 		return new RSAKey(n, d, e);
! 	}
  
! 	public BigInteger decode(BigInteger message) {
! 		return message.modPow(d, n);
! 	}
  
! 	public byte[] decodeByteArray(byte[] message) {
! 		return Hash.BigIntToBytes(decode(new BigInteger(message)));
! 	}
  
! 	public BigInteger sign(BigInteger message) {
! 		return decode(message);
! 	}
  
! 	public RSAPublicKey getPublicKey() {
! 		return new RSAPublicKey(n, e);
! 	}
  
! 	public BigInteger getD() {
! 		return d;
! 	}
  }

Index: RSAPublicKey.java
===================================================================
RCS file: /cvsroot/arianne/marauroa/src/marauroa/common/crypto/RSAPublicKey.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -d -r1.4 -r1.5
*** RSAPublicKey.java	1 Nov 2005 10:09:29 -0000	1.4
--- RSAPublicKey.java	20 Aug 2006 15:40:17 -0000	1.5
***************
*** 13,89 ****
  package marauroa.common.crypto;
  
- import java.math.BigInteger;
- import java.io.PrintWriter;
  import java.io.PrintStream;
  
! public class RSAPublicKey
! {
!   public static final BigInteger big0 = new BigInteger("0");
!   public static final BigInteger big1 = new BigInteger("1");
!   public static final BigInteger big2 = new BigInteger("2");
!   public static final BigInteger big6 = new BigInteger("6");
!   protected BigInteger           n;
!   protected BigInteger           e;
  
!   public RSAPublicKey(BigInteger n, BigInteger e)
!   {
!     this.n = n;
!     this.e = e;
!   }
  
!   public void print(PrintWriter out)
!   {
!     out.println("n = " + n);
!     out.println("e = " + e);
!   }
  
!   public void print(PrintStream out)
!   {
!     out.println("n = " + n);
!     out.println("e = " + e);
!   }
  
!   public BigInteger getN()
!   {
!     return n;
!   }
  
!   public BigInteger getE()
!   {
!     return e;
!   }
  
!   public BigInteger encode(BigInteger message)
!   {
!     return message.modPow(e, n);
!   }
  
!   public byte[] encodeByteArray(byte[] message)
!   {
!     return encode(Hash.BytesToBigInt(message)).toByteArray();
!   }
  
!   public boolean verifySignature(BigInteger message, BigInteger signature)
!   {
!     return message.equals(encode(signature));
!   }
  
!   public static BigInteger getValue(String str)
!   {
!     byte[] v = str.getBytes();
!     for (byte b : v)
!     {
!       if (b != 0)
!       {
!         return new BigInteger(1, v);
!       }
!     }
!     return big0;
!   }
  
!   public static String getString(BigInteger value)
!   {
!     return new String(value.toByteArray());
!   }
  
  }
--- 13,81 ----
  package marauroa.common.crypto;
  
  import java.io.PrintStream;
+ import java.io.PrintWriter;
+ import java.math.BigInteger;
  
! public class RSAPublicKey {
! 	public static final BigInteger big0 = new BigInteger("0");
  
! 	public static final BigInteger big1 = new BigInteger("1");
  
! 	public static final BigInteger big2 = new BigInteger("2");
  
! 	public static final BigInteger big6 = new BigInteger("6");
  
! 	protected BigInteger n;
  
! 	protected BigInteger e;
  
! 	public RSAPublicKey(BigInteger n, BigInteger e) {
! 		this.n = n;
! 		this.e = e;
! 	}
  
! 	public void print(PrintWriter out) {
! 		out.println("n = " + n);
! 		out.println("e = " + e);
! 	}
  
! 	public void print(PrintStream out) {
! 		out.println("n = " + n);
! 		out.println("e = " + e);
! 	}
  
! 	public BigInteger getN() {
! 		return n;
! 	}
  
! 	public BigInteger getE() {
! 		return e;
! 	}
! 
! 	public BigInteger encode(BigInteger message) {
! 		return message.modPow(e, n);
! 	}
! 
! 	public byte[] encodeByteArray(byte[] message) {
! 		return encode(Hash.BytesToBigInt(message)).toByteArray();
! 	}
! 
! 	public boolean verifySignature(BigInteger message, BigInteger signature) {
! 		return message.equals(encode(signature));
! 	}
! 
! 	public static BigInteger getValue(String str) {
! 		byte[] v = str.getBytes();
! 		for (byte b : v) {
! 			if (b != 0) {
! 				return new BigInteger(1, v);
! 			}
! 		}
! 		return big0;
! 	}
! 
! 	public static String getString(BigInteger value) {
! 		return new String(value.toByteArray());
! 	}
  
  }

Index: Hash.java
===================================================================
RCS file: /cvsroot/arianne/marauroa/src/marauroa/common/crypto/Hash.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** Hash.java	16 Apr 2005 10:29:30 -0000	1.2
--- Hash.java	20 Aug 2006 15:40:17 -0000	1.3
***************
*** 13,113 ****
  package marauroa.common.crypto;
  
  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
- import java.math.BigInteger;
  import java.security.SecureRandom;
  
! public class Hash
! {
!   private static String hex = "0123456789ABCDEF";
!   static private MessageDigest md;
!   static private SecureRandom random;
  
  
!   static {
!     try {
!       md = MessageDigest.getInstance("MD5");
!       random = SecureRandom.getInstance("SHA1PRNG");
!     }
!     catch(NoSuchAlgorithmException e) {
!       e.printStackTrace();
!       System.exit(1);
!     }
!   }
  
!   public static final byte[] hash(final String value) {
!     return hash(value.getBytes());
!   }
  
!   public static final int hashLength() {
!     return md.getDigestLength();
!   }
  
!   public static final byte[] hash(final byte[] value) {
!     md.reset();
!     md.update ( value );
!     return md.digest();
!   }
  
!   public static final byte[] xor(final byte[] b1, final byte[] b2) {
!     if(b1.length != b2.length) {
!       return null;
!     }
!     byte[] res = new byte[b1.length];
!     for(int i = 0; i < b1.length; i++) {
!       res[i] = (byte)(b1[i] ^ b2[i]);
!     }
!     return res;
!   }
  
!   public static final int compare(final byte[] b1, final byte[] b2) {
!     if(b1.length != b2.length) {
!       return (b1.length - b2.length);
!     }
!     for(int i = 0; i<b1.length; i++) {
!       if(b1[i] != b2[i]) {
!         return b1[i] - b2[i];
!       }
!     }
!     return 0;
!   }
  
!   public static final byte[] random(int nbBytes) {
!     byte[] res = new byte[nbBytes];
!     random.nextBytes(res);
!     return res;
!   }
  
!   public static final String toHexString(final byte[] bs) {
!     String res = "";
!     for(byte b : bs) {
!       res += hex.charAt(((b >>> 4) & 0xF));
!       res += hex.charAt((b & 0xF));
!     }
!     return res;
!   }
  
!   public static final byte[] BigIntToBytes(BigInteger b) {
!     byte[] preRes = b.toByteArray();
!     if(preRes[0] != 1) {
!       return preRes;
!     }
!     byte[] res = new byte[preRes.length - 1];
!     for(int i=0; i< res.length; i++) {
!       res[i] = preRes[i+1];
!     }
!     return res;
!   }
  
!   public static final BigInteger BytesToBigInt(byte[] b) {
!     if(b[0] > 1) {
!       return new BigInteger(b);
!     }
!     byte[] res = new byte[b.length + 1];
!     res[0] = 1;
!     for(int i=0; i< b.length; i++) {
!       res[i+1] = b[i];
!     }
!     return new BigInteger(res);
!   }
  }
--- 13,112 ----
  package marauroa.common.crypto;
  
+ import java.math.BigInteger;
  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
  import java.security.SecureRandom;
  
! public class Hash {
! 	private static String hex = "0123456789ABCDEF";
  
+ 	static private MessageDigest md;
  
! 	static private SecureRandom random;
  
! 	static {
! 		try {
! 			md = MessageDigest.getInstance("MD5");
! 			random = SecureRandom.getInstance("SHA1PRNG");
! 		} catch (NoSuchAlgorithmException e) {
! 			e.printStackTrace();
! 			System.exit(1);
! 		}
! 	}
  
! 	public static final byte[] hash(final String value) {
! 		return hash(value.getBytes());
! 	}
  
! 	public static final int hashLength() {
! 		return md.getDigestLength();
! 	}
  
! 	public static final byte[] hash(final byte[] value) {
! 		md.reset();
! 		md.update(value);
! 		return md.digest();
! 	}
  
! 	public static final byte[] xor(final byte[] b1, final byte[] b2) {
! 		if (b1.length != b2.length) {
! 			return null;
! 		}
! 		byte[] res = new byte[b1.length];
! 		for (int i = 0; i < b1.length; i++) {
! 			res[i] = (byte) (b1[i] ^ b2[i]);
! 		}
! 		return res;
! 	}
  
! 	public static final int compare(final byte[] b1, final byte[] b2) {
! 		if (b1.length != b2.length) {
! 			return (b1.length - b2.length);
! 		}
! 		for (int i = 0; i < b1.length; i++) {
! 			if (b1[i] != b2[i]) {
! 				return b1[i] - b2[i];
! 			}
! 		}
! 		return 0;
! 	}
  
! 	public static final byte[] random(int nbBytes) {
! 		byte[] res = new byte[nbBytes];
! 		random.nextBytes(res);
! 		return res;
! 	}
  
! 	public static final String toHexString(final byte[] bs) {
! 		String res = "";
! 		for (byte b : bs) {
! 			res += hex.charAt(((b >>> 4) & 0xF));
! 			res += hex.charAt((b & 0xF));
! 		}
! 		return res;
! 	}
  
! 	public static final byte[] BigIntToBytes(BigInteger b) {
! 		byte[] preRes = b.toByteArray();
! 		if (preRes[0] != 1) {
! 			return preRes;
! 		}
! 		byte[] res = new byte[preRes.length - 1];
! 		for (int i = 0; i < res.length; i++) {
! 			res[i] = preRes[i + 1];
! 		}
! 		return res;
! 	}
! 
! 	public static final BigInteger BytesToBigInt(byte[] b) {
! 		if (b[0] > 1) {
! 			return new BigInteger(b);
! 		}
! 		byte[] res = new byte[b.length + 1];
! 		res[0] = 1;
! 		for (int i = 0; i < b.length; i++) {
! 			res[i + 1] = b[i];
! 		}
! 		return new BigInteger(res);
! 	}
  }