Encryption employing RSA algorithm in java
Introduction
In this write-up I will offer you an tactic of employing RSA algorithm for lengthy String. As you know that RSA algorithm is restricted 117 bytes, lengthy strings can not be encrypted or decrypted. Nevertheless it is achievable to break the bytes into quite a few chunks and then to encrypt or decrypt the contents. This algorithm is used for asymmetric cryptography. For asymmetric cryptography, you can click this url.
Technicalities
In this write-up I offer beneath the comprehensive instance for encryption and decryption of lengthy strings. If you use the method of Cipher class ie.doFinal( byte[] bytesString), it will toss exception that it can be encrypted for a lot more than 117 bytes for RSA. But in the true software, you might not be certain about the length of the String you want to encrypt or decrypt. In this situation you have to break the bytes and then to encrypt it. Be sure to refer to the
Subsequent comprehensive instance.
Full instance
Course name : SecurityUtil.java
package deal com.dds.main.protection
import java.protection.KeyFactory
import java.protection.KeyPair
import java.protection.KeyPairGenerator
import java.protection.PrivateKey
import java.protection.PublicKey
import java.protection.Safety
import java.protection.spec.EncodedKeySpec
import java.protection.spec.PKCS8EncodedKeySpec
import java.protection.spec.X509EncodedKeySpec
import javax.crypto.Cipher
import sun.misc.BASE64Decoder
import sun.misc.BASE64Encoder
import com.sun.crypto.company.SunJCE
/**This is a utility class which provides
* effortless method for protection. This
* class provides the way where you can
* encrypt and decrypt the String having
* a lot more than 117 bytes for RSA algorithm
* which is an asymmetric a person.
* @writer Debadatta Mishra(PIKU)
*
*/
community class SecurityUtil {
/**
* Object of type @url KeyPair
*/
non-public KeyPair keyPair
/**
* String variable which denotes the algorithm
*/
non-public static final String ALGORITHM = “RSA”
/**
* varibale for the keysize
*/
non-public static final int KEYSIZE = 1024
/**
* Default constructor
*/
community SecurityUtil()
super()
Safety.addProvider(new SunJCE())
/**
* This method is used to make
* the crucial pair.
*/
community void invokeKeys()
try
KeyPairGenerator keypairGenerator = KeyPairGenerator
.getInstance(ALGORITHM)
keypairGenerator.initialize(KEYSIZE)
keyPair = keypairGenerator.generateKeyPair()
catch (Exception e)
e.printStackTrace()
/**This method is used to attain the String
* representation of the PublicKey.
* @param publicKey of type @url PublicKey
* @return PublicKey as a String
*/
community String getPublicKeyString(PublicKey publicKey)
return new BASE64Encoder().encode(publicKey.getEncoded())
/**This method is used to attain the String
* representation of the PrivateKey.
* @param privateKey of type @url PrivateKey
* @return PrivateKey as a String
*/
community String getPrivateKeyString(PrivateKey privateKey)
return new BASE64Encoder().encode(privateKey.getEncoded())
/**This method is used to attain the
* @url PrivateKey item from the
* String representation.
* @param crucial of type String
* @return @url PrivateKey
* @throws Exception
*/
community PrivateKey getPrivateKeyFromString(String crucial) throws Exception
PrivateKey privateKey = null
try
KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM)
EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(
new BASE64Decoder().decodeBuffer(crucial))
privateKey = keyFactory.generatePrivate(privateKeySpec)
catch (Exception e)
e.printStackTrace()
return privateKey
/**This method is used to attain the @url PublicKey
* from the String representation of the Community Critical.
* @param crucial of type String
* @return @url PublicKey
* @throws Exception
*/
community PublicKey getPublicKeyFromString(String crucial) throws Exception
PublicKey publicKey = null
try
KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM)
EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(
new BASE64Decoder().decodeBuffer(crucial))
publicKey = keyFactory.generatePublic(publicKeySpec)
catch (Exception e)
e.printStackTrace()
return publicKey
/**This method is used to attain the
* encrypted contents from the primary
* contents by passing the @url PublicKey.
* This method is beneficial when the byte is a lot more
* than 117.
* @param textual content of type String
* @param crucial of type @url PublicKey
* @return encrypted benefit as a String
* @throws Exception
*/
community String getEncryptedValue(String textual content, PublicKey crucial)
throws Exception {
String encryptedText
try
byte[] textBytes = textual content.getBytes(“UTF8”)
Cipher cipher = Cipher.getInstance(“RSA/ECB/PKCS1Padding”)
cipher.init(Cipher.ENCRYPT_Method, crucial)
int textBytesChunkLen = one hundred
int encryptedChunkNum = (textBytes.length – 1) / textBytesChunkLen
+ 1
// RSA returns 128 bytes as output for one hundred textual content bytes
int encryptedBytesChunkLen = 128
int encryptedBytesLen = encryptedChunkNum * encryptedBytesChunkLen
Method.out.println(“Encrypted bytes length——-“
+ encryptedBytesChunkLen)
// Determine the Output array.
byte[] encryptedBytes = new byte[encryptedBytesLen]
int textBytesChunkIndex =
int encryptedBytesChunkIndex =
for (int i = i < encryptedChunkNum i++)
if (i < encryptedChunkNum - 1)
encryptedBytesChunkIndex = encryptedBytesChunkIndex
+ cipher.doFinal(textBytes, textBytesChunkIndex,
textBytesChunkLen, encryptedBytes,
encryptedBytesChunkIndex)
textBytesChunkIndex = textBytesChunkIndex
+ textBytesChunkLen
else
cipher.doFinal(textBytes, textBytesChunkIndex,
textBytes.length – textBytesChunkIndex,
encryptedBytes, encryptedBytesChunkIndex)
encryptedText = new BASE64Encoder().encode(encryptedBytes)
catch (Exception e)
toss e
return encryptedText
}
/**This method is used to decrypt the contents.
* This method is beneficial when the size of the
* bytes is a lot more than 117.
* @param textual content of type String indicating the
* encrypted contents.
* @param crucial of type @url PrivateKey
* @return decrypted benefit as a String
*/
community String getDecryptedValue(String textual content, PrivateKey crucial) {
String end result = null
try
byte[] encryptedBytes = new BASE64Decoder().decodeBuffer(textual content)
Cipher cipher = Cipher.getInstance(“RSA/ECB/PKCS1Padding”)
cipher.init(Cipher.DECRYPT_Method, crucial)
int encryptedByteChunkLen = 128
int encryptedChunkNum = encryptedBytes.length
/ encryptedByteChunkLen
int decryptedByteLen = encryptedChunkNum * encryptedByteChunkLen
byte[] decryptedBytes = new byte[decryptedByteLen]
int decryptedIndex =
int encryptedIndex =
for (int i = i < encryptedChunkNum i++)
if (i < encryptedChunkNum - 1)
decryptedIndex = decryptedIndex
+ cipher.doFinal(encryptedBytes, encryptedIndex,
encryptedByteChunkLen, decryptedBytes,
decryptedIndex)
encryptedIndex = encryptedIndex + encryptedByteChunkLen
else
decryptedIndex = decryptedIndex
+ cipher.doFinal(encryptedBytes, encryptedIndex,
encryptedBytes.length – encryptedIndex,
decryptedBytes, decryptedIndex)
end result = new String(decryptedBytes).trim()
catch (Exception e)
e.printStackTrace()
return end result
}
/**This method is used attain the
* @url PublicKey
* @return @url PublicKey
*/
community PublicKey getPublicKey()
return keyPair.getPublic()
/**This method is used to attain
* the @url PrivateKey
* @return @url PrivateKey
*/
community PrivateKey getPrivateKey()
return keyPair.getPrivate()
}
The over class provides quite a few beneficial approaches for technology of Non-public crucial , Community Critical and encryption of String and decryption of String.
Be sure to refer to the next subordinate courses for the over class.
Course name : KeyGenerator.java
package deal com.dds.main.protection
import java.io.File
import java.io.FileOutputStream
import java.io.OutputStream
import java.protection.PrivateKey
import java.protection.PublicKey
import java.util.Homes
/**This class is used to make the
* Non-public and Community crucial and merchants
* them in files.
* @writer Debadatta Mishra(PIKU)
*
*/
community class KeyGenerator
/**This method is used to attain the
* route of the keys listing where
* Non-public and Community crucial files are
* stored.
* @return route of the keys listing
*/
non-public static String getKeyFilePath()
String keyDirPath = null
try
keyDirPath = Method.getProperty(“consumer.dir”) + File.separator
+ “keys”
File keyDir = new File(keyDirPath)
if (!keyDir.exists())
keyDir.mkdirs()
catch (Exception e)
e.printStackTrace()
return keyDirPath
/**
* This method is used to make the
* Non-public and Community keys.
*/
community static void generateKeys()
Homes publicProp = new Homes()
Homes privateProp = new Homes()
try
OutputStream pubOut = new FileOutputStream(getKeyFilePath()
+ File.separator + “community.crucial”)
OutputStream priOut = new FileOutputStream(getKeyFilePath()
+ File.separator + “non-public.crucial”)
SecurityUtil secureUtil = new SecurityUtil()
secureUtil.invokeKeys()
PublicKey publicKey = secureUtil.getPublicKey()
PrivateKey privateKey = secureUtil.getPrivateKey()
String publicString = secureUtil.getPublicKeyString(publicKey)
String privateString = secureUtil.getPrivateKeyString(privateKey)
publicProp.put(“crucial”, publicString)
publicProp.store(pubOut, “Community Critical Information”)
privateProp.put(“crucial”, privateString)
privateProp.store(priOut, “Non-public Critical Information”)
catch (Exception e)
e.printStackTrace()
The over class is used to make the Community and Non-public keys. It generates and merchants them in unique files termed Community.crucial and Non-public.crucial. Be sure to refer the test harness class for the over class.
Course name: TestKeyGenerator
import com.dds.main.protection.KeyGenerator
/**This is a testharness class
* for the KeyGenerator class.
* @writer Debadatta Mishra(PIKU)
*
*/
community class TestKeyGenerator
community static void key(String[] args)
KeyGenerator.generateKeys()
If you operate the over class, you will locate a listing termed keys in your root route of your software folder. In this folder you will locate two files a person is for Non-public Critical details and an additional is for Community Critical.
There is an additional class which is used to attain the Non-public crucial and Community crucial details stored in the files.
Course name: KeyReader.java
package deal com.dds.main.protection
import java.io.File
import java.io.FileInputStream
import java.io.InputStream
import java.protection.PublicKey
import java.util.Homes
/**This class is used to study the
* keys from the file.
* @writer Debadatta Mishra(PIKU)
*
*/
community class KeyReader
/**This method is used to attain the
* string benefit of the Community Critical
* from the file.
* @return String of @url PublicKey
*/
community static String getPublicKeyString()
String publicString = null
try
Homes prop = new Homes()
String publicKeyPath = Method.getProperty(“consumer.dir”)
+ File.separator + “keys” + File.separator + “community.crucial”
InputStream in = new FileInputStream(publicKeyPath)
prop.load(in)
publicString = prop.getProperty(“crucial”)
catch (Exception e)
e.printStackTrace()
return publicString
/**This method is used to attain the
* String of Non-public Critical from the file.
* @return String of non-public crucial
*/
community static String getPrivateKeyString()
String publicString = null
try
Homes prop = new Homes()
String publicKeyPath = Method.getProperty(“consumer.dir”)
+ File.separator + “keys” + File.separator + “non-public.crucial”
InputStream in = new FileInputStream(publicKeyPath)
prop.load(in)
publicString = prop.getProperty(“crucial”)
catch (Exception e)
e.printStackTrace()
return publicString
This is a utility class to study the Community and Non-public keys from the files.
Now refer to the test harness class which tends to make encryption and decryption of String.
import java.protection.PrivateKey
import java.protection.PublicKey
import com.dds.main.protection.KeyReader
import com.dds.main.protection.SecurityUtil
/**
* This is a test harness class for encryption and decryption.
*
* @writer Debadatta Mishra(PIKU)
*
*/
community class TestEncryption
community static void key(String[] args)
String privateKeyString = KeyReader.getPrivateKeyString()
SecurityUtil securityUtil = new SecurityUtil()
String publicKeyString = KeyReader.getPublicKeyString()
try
PublicKey publicKey = securityUtil
.getPublicKeyFromString(publicKeyString)
PrivateKey privateKey = securityUtil
.getPrivateKeyFromString(privateKeyString)
String originalValue = “offer some quite lengthy string”
String encryptedValue = securityUtil.getEncryptedValue(
originalValue, publicKey)
Method.out.println(“EncryptedValue—–” + encryptedValue)
String decryptedValue = securityUtil.getDecryptedValue(
encryptedValue, privateKey)
Method.out.println(“Primary Benefit——” + decryptedValue)
catch (Exception e)
e.printStackTrace()
This test harness class is used to encrypt and decrypt the lengthy string contents. You can also use the exact method for file encryption and decryption. Initially you have to study the contents of a file as String and then you can utilize method to encrypt it.
Conclusion
I hope that you will enjoy my write-up for this asymmetric cryptography for RSA. For asymmetric cryptography remember to refer to the url http://www.articlesbase.com/details-technology-article content/asymmetric-cryptography-in-java-438155.html. If you locate any complications or faults, remember to truly feel cost-free to ship me a mail in the handle [email protected] . This write-up is only meant for those people who are new to java advancement. This write-up does not bear any commercial significance. Be sure to offer me the feed-back about this write-up
More Stories
How to Successfully Sell a Two-Bedroom Apartment on MLS Without a Realtor’s Help
Top 8 WordPress Plugins for WooCommerce Store
How to Roll 3 Dice in Google