RSA implementation using java

Question

I am implementing RSA in java I have encountered a code which is given below it is showing plaintext in numeric form after decrypting the plaintext, but I want it in simple engl

Answer 1

I edited Elton Da Costa's class a little bit adding that feature to convert Public key from String to PublicKey class. Because the user of this class might ultimately want to give out the public key to a third party for encryption of the message and keep the private key with himself for decryption.

            package com.custom.util;

            import java.math.BigInteger;
            import java.security.InvalidKeyException;
            import java.security.KeyFactory;
            import java.security.KeyPair;
            import java.security.KeyPairGenerator;
            import java.security.NoSuchAlgorithmException;
            import java.security.PrivateKey;
            import java.security.PublicKey;
            import java.security.spec.InvalidKeySpecException;
            import java.security.spec.PKCS8EncodedKeySpec;
            import java.security.spec.X509EncodedKeySpec;
            import java.util.Arrays;

            import javax.crypto.BadPaddingException;
            import javax.crypto.Cipher;
            import javax.crypto.IllegalBlockSizeException;
            import javax.crypto.NoSuchPaddingException;

            public class RSA {

                static String kPublic = "";
                static String kPrivate = "";

                public RSA() {

                }

                public class KeyPairStrings {
                    private String pubKey;
                    private String privKey;

                    public String getPubKey() {
                        return pubKey;
                    }

                    public String getPrivKey() {
                        return privKey;
                    }

                    @Override
                    public String toString() {
                        return "KeyPairStrings [pubKey=" + pubKey + ", privKey=" + privKey + "]";
                    }



                }

            public KeyPairStrings getKeyPair() throws NoSuchAlgorithmException{

                KeyPairStrings keyPairStrings = new RSA.KeyPairStrings();

                KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
                kpg.initialize(1024);
                KeyPair kp = kpg.genKeyPair();

                PublicKey publicKey = kp.getPublic();
                PrivateKey privateKey = kp.getPrivate();

                byte[] publicKeyBytes = publicKey.getEncoded();
                byte[] privateKeyBytes = privateKey.getEncoded();

                keyPairStrings.pubKey = bytesToString(publicKeyBytes);
                keyPairStrings.privKey = bytesToString(privateKeyBytes);

                return keyPairStrings ;
            }


            public String encrypt(String text , String pubKey) throws NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException{

                byte[] pubKeyByte = stringToBytes(pubKey) ;

                KeyFactory kf = KeyFactory.getInstance("RSA");

                PublicKey publicKey = null;
                try {

                    publicKey = kf.generatePublic(new X509EncodedKeySpec(pubKeyByte));

                } catch (InvalidKeySpecException e) {
                    e.printStackTrace();
                }

                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.ENCRYPT_MODE, publicKey );
                byte[] encryptedBytes = cipher.doFinal(text.getBytes());

                String encrypted = bytesToString(encryptedBytes);

                return encrypted;
            }

            public String decrypt(String encryptedText , String privKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{

                byte[] privKeyByte = stringToBytes(privKey) ;

                KeyFactory kf = KeyFactory.getInstance("RSA");

                PrivateKey privateKey = null;
                try {

                    privateKey = kf.generatePrivate(new PKCS8EncodedKeySpec(privKeyByte));

                } catch (InvalidKeySpecException e) {
                    e.printStackTrace();
                }

                String decrypted;

                Cipher cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                byte[] decryptedBytes = cipher.doFinal(stringToBytes(encryptedText));
                decrypted = new String(decryptedBytes);
                return decrypted;
            }


            public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {

                String text = "hello" ;

                RSA rsa = new RSA();

                KeyPairStrings keyPairStrings =  rsa.getKeyPair() ;

                System.out.println(keyPairStrings);

                String encrypted  = rsa.encrypt(text, keyPairStrings.getPubKey());

                System.out.println("encrypted : "+encrypted);   

                String textResult = rsa.decrypt(encrypted, keyPairStrings.getPrivKey());

                System.out.println("textResult : "+textResult);

            }



                public static String bytesToString(byte[] b) {
                    byte[] b2 = new byte[b.length + 1];
                    b2[0] = 1;
                    System.arraycopy(b, 0, b2, 1, b.length);
                    return new BigInteger(b2).toString(36);
                }

                public byte[] stringToBytes(String s) {
                    byte[] b2 = new BigInteger(s, 36).toByteArray();
                    return Arrays.copyOfRange(b2, 1, b2.length);
                }
            }