Playing with KeyPair

[Mike Litherland]

Hi,

I have java.security.KeyPairGenerator making RSA KeyPairs for me, but I'm not sure what to do with the encoded data. On my public and private keys I call the getEncoded() method, which returns a binary representation of the key, but how can I turn the binary representation back into a key object? I've been poking around the documentation for about a day without any luck.

Thanks,
Mike

Edit: More generally, if someone knows of a tutorial about working with KeyPairs in java other than the sun standard ones, it would be appreciated. Figuring stuff out from google snippets and API docs isn't exactly fun.

[ November 14, 2005: Message edited by: M Litherland ]

Edit 2: I found an example of getting the key pair back from the encoding here: http://javaalmanac.com/egs/java.security/GetKeyPairBytes.html?l=rel
[ November 14, 2005: Message edited by: M Litherland ]

[summer summer]

I used to translate .net key file to java key file.
You could learn a lot from this Example

 

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.digester.Digester;
 
import org.apache.log4j.PropertyConfigurator;
 
import java.io.File;
 
import java.math.BigInteger;
 
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.DSAPrivateKeySpec;
import java.security.spec.DSAPublicKeySpec;
 
/**
 *
 * @author msn:[e-mail]
 */
public class DotnetKeyPairImporter {
    private File dotnetkeyFile;
    private File pubkeyFile;
    private File prikeyFile;
 
    public static void main(String[] args) {
        if (args.length < 2) {
            System.err.println("Usage: DotnetKeyPairImporter dotnetkey.xml pubkey.dat[ prikey.dat]");
            System.exit(-1);
        }
 
        PropertyConfigurator.configure(DotnetKeyPairImporter.class.getResource("log4j-console.props"));
 
        try {
            DotnetKeyPairImporter importer = new DotnetKeyPairImporter();
 
            importer.dotnetkeyFile = new File(args[0]).getCanonicalFile();
            importer.pubkeyFile    = new File(args[1]).getCanonicalFile();
 
            if (args.length > 2) {
                importer.prikeyFile = new File(args[2]).getCanonicalFile();
            }
 
            importer.run();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }
 
    public void run() throws Exception {
        XmlKey     key        = parse(dotnetkeyFile);
        KeyFactory keyFactory = KeyFactory.getInstance("DSA");
        PublicKey  pubkey     = null;
        PrivateKey prikey     = null;
 
        // get public key。
        DSAPublicKeySpec pubkeySpec = new DSAPublicKeySpec(key.getY(), key.getP(), key.getQ(),
                                                           key.getG());
 
        pubkey = keyFactory.generatePublic(pubkeySpec);
 
        // get private key。
        if (prikeyFile != null) {
            if (key.getX() == null) {
                System.err.println("WARN: specified .NET key file does not contain information of private key");
            } else {
                DSAPrivateKeySpec prikeySpec = new DSAPrivateKeySpec(key.getX(), key.getP(),
                                                                     key.getQ(), key.getG());
 
                prikey = keyFactory.generatePrivate(prikeySpec);
            }
        }
 
        // serialize key pair to file 
        DSAKeyPairGenerator.savePublicKey(pubkey, pubkeyFile);
 
        if (prikey != null) {
            DSAKeyPairGenerator.savePrivateKey(prikey, prikeyFile);
        }
    }
 
    /**
     * parse .net XML file，make XmlKey Object。
     */
    private XmlKey parse(File file) throws Exception {
        Digester digester = new Digester();
 
        digester.push(new XmlKey());
 
        digester.addCallMethod("DSAKeyValue/P", "setP", 0);
        digester.addCallMethod("DSAKeyValue/G", "setG", 0);
        digester.addCallMethod("DSAKeyValue/Q", "setQ", 0);
        digester.addCallMethod("DSAKeyValue/Y", "setY", 0);
        digester.addCallMethod("DSAKeyValue/X", "setX", 0);
 
        return (XmlKey) digester.parse(file);
    }
 
    private static class XmlKey {
        private BigInteger p;
        private BigInteger g;
        private BigInteger q;
        private BigInteger y;
        private BigInteger x;
 
        public BigInteger getP() {
            return p;
        }
 
        public void setP(String p) {
            this.p = base64ToBigInteger(p);
        }
 
        public BigInteger getG() {
            return g;
        }
 
        public void setG(String g) {
            this.g = base64ToBigInteger(g);
        }
 
        public BigInteger getQ() {
            return q;
        }
 
        public void setQ(String q) {
            this.q = base64ToBigInteger(q);
        }
 
        public BigInteger getY() {
            return y;
        }
 
        public void setY(String y) {
            this.y = base64ToBigInteger(y);
        }
 
        public BigInteger getX() {
            return x;
        }
 
        public void setX(String x) {
            this.x = base64ToBigInteger(x);
        }
 
        private BigInteger base64ToBigInteger(String base64) {
            return new BigInteger(1, Base64.decodeBase64(base64.getBytes()));
        }
    }
}