Generating symmetric key with RSA

Question

Hello,
I have a problem. I want to generate symmetric keys with the use of RSA. But RSA is not supported by Java 1.4.2 except for the signature class.
My question is can I generate symmetric keys using RSA and Bouncy Castle provider??? Or is there a way around ???
Thanks a lot,
Ravi

Answer 1

Or write your own RSA. here is some working code:
///////////////// class BigIntegerRSA /////////////////
import java.math.*;
import java.util.*;
public class BigIntegerRSA {
  int bits;
  BigInteger p, q, n, nPrime, e, d;
  public BigIntegerRSA(int _bits, BigInteger _p, BigInteger _q) {
    bits=_bits;
    p=_p;
    q=_q;
    n = p.multiply(q);
    nPrime = p.subtract(BigInteger.ONE).multiply( q.subtract(BigInteger.ONE));
    e=BigInteger.ZERO;
    BigInteger TEN=new BigInteger(""+10);
    for( e = nPrime.divide(TEN); !BigIntegerUtil.gcd( e, nPrime ).equals(BigInteger.ONE); e=e.add(BigInteger.ONE)){
    d = BigIntegerUtil.inverse( e, nPrime );
  public static BigIntegerRSA generate(int _bits) {
    BigIntegerRSA rsa= null;
    boolean verified=false;
    while(!verified){
      BigInteger p=BigInteger.probablePrime(_bits/2+1,new Random(System.currentTimeMillis()));
      BigInteger q=BigInteger.probablePrime(_bits/2+1,new Random(System.currentTimeMillis()));
      rsa= new BigIntegerRSA(_bits,p,q);
      verified= rsa.verify();
    return rsa;
  public BigIntegerRSAPublicKey getPublicKey(){
    return new BigIntegerRSAPublicKey(bits,e,n);
  public BigIntegerRSAPrivateKey getPrivateKey(){
    return new BigIntegerRSAPrivateKey(bits,d,n);
  public boolean verify() {
    //e * d % ( nPrime ) == 1
    BigInteger multiplied=e.multiply(d).mod(nPrime);
    if(!multiplied.equals(BigInteger.ONE)){
      return false;
    //test random
    BigIntegerRSAPublicKey pub=getPublicKey();
    BigIntegerRSAPrivateKey priv=getPrivateKey();
    BigInteger message, encoded, decoded;
    //random
    message=new BigInteger(bits-2, new Random(System.currentTimeMillis()));
    encoded=pub.code(message);
    decoded=priv.decode(encoded);
    if(!message.equals(decoded)){
      System.out.println("Failed to encode and decode "+message);
      return false;
    return true;
  public static void main( String [ ] args ){
    BigIntegerRSA rsa=BigIntegerRSA.generate(512);
    BigIntegerRSAPublicKey pub=rsa.getPublicKey();
    BigIntegerRSAPrivateKey priv=rsa.getPrivateKey();
    BigInteger message=new BigInteger("2938798723423429020");
    System.out.println( "message: " + message );
    BigInteger code = pub.code(message);
    BigInteger decode = priv.decode(code);
    System.out.println( "Code: " + code );
    System.out.println( "Decode: " + decode );
///////////////// class BigIntegerRSAPublicKey /////////////////
import java.math.*;
import java.util.*;
public class BigIntegerRSAPublicKey{
  int bits;
  BigInteger e,n;
  public BigIntegerRSAPublicKey(int _bits, BigInteger _e, BigInteger _n) {
    bits=_bits;
    e=_e;
    n=_n;
  public BigInteger code(BigInteger message) {
    if(message.bitLength()>bits){
      return null;//"Cannot encode anything with more bits than bits while message had message.bitLength() bits
    return message.modPow(e,n);
///////////////// class BigIntegerRSAPrivateKey /////////////////
import java.math.*;
import java.util.*;
public class BigIntegerRSAPrivateKey {
  int bits;
  BigInteger d, n;
  public BigIntegerRSAPrivateKey(int _bits, BigInteger _d, BigInteger _n) {
    bits=_bits;
    d=_d;
    n=_n;
  public BigInteger decode(BigInteger code)  {
    if(code.compareTo(n)>0){
      return null;//Cannot decode anything greater than n while code was code
    return code.modPow(d,n);
///////////////// class BigIntegerUtil /////////////////
import java.math.*;
import java.util.*;
public class BigIntegerUtil {
  // Internal variables for fullGcd
  private static BigInteger x;
  private static BigInteger y;
  public static BigInteger gcd( BigInteger a, BigInteger b )
    if( b.equals(BigInteger.ZERO) )
      return a;
    else
      return gcd( b, a.mod(b) );
  public static BigInteger inverse( BigInteger a, BigInteger n )
    fullGcd( a, n );
    return x.compareTo(BigInteger.ZERO)>0 ? x : x.add(n);
  private static void fullGcd( BigInteger a, BigInteger b )
    BigInteger x1, y1;
    if( b.equals(BigInteger.ZERO) )
      x = BigInteger.ONE;
      y = BigInteger.ZERO;
    else
      fullGcd( b, a.mod(b) );
      x1 = x; y1 = y;
      x = y1;
      y = x1.subtract(( a.divide(b) ).multiply(y1));
}And since BigInteger has the methods .toByteArray() and new BigInteger(byte[] b) this is perfect for encrypting and decrypting anything, eg a DES key or some other symmetric encryption