catalogue
Generate public and private keys
Private key encryption private key decryption
Private key encryption public key decryption
Public key encryption and public key decryption
Asymmetric encryption
Introduction:
① Asymmetric encryption algorithm is also called modern encryption algorithm.
② Asymmetric encryption is the cornerstone of computer communication security, which ensures that the encrypted data will not be cracked.
③ Unlike symmetric encryption algorithms, asymmetric encryption algorithms require two keys: public key and private key
④ Public and private keys are a pair
⑤ If the data is encrypted with a public key, it can only be decrypted with the corresponding private key.
⑥ If the data is encrypted with a private key, it can only be decrypted with the corresponding public key.
⑦ Because encryption and decryption use two different keys, this algorithm is called asymmetric encryption algorithm.
- Example
- First, a key pair is generated. The public key is (5,14) and the private key is (11,14)
- Now A wants to send original 2 to B
- A uses the public key to encrypt data 2 to the 5th power mod 14 = 4, send ciphertext 4 to B
- B decrypts data using the private key 4 to the 11th power mod14 = 2, get the original 2
- characteristic
- Encryption and decryption use different keys
- If you use private key encryption, you can only use public key decryption
- If you use public key encryption, you can only decrypt using the private key
- Processing data is slower because of the high level of security
- Common algorithms
- RSA
- ECC
Generate public and private keys
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
public class RSAdemo {
public static void main(String[] args) throws Exception {
// encryption algorithm
String algorithm = "RSA";
// Create key pair generator object
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// Generate key pair
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// Generate private key
PrivateKey privateKey = keyPair.getPrivate();
// Generate public key
PublicKey publicKey = keyPair.getPublic();
// Get private key byte array
byte[] privateKeyEncoded = privateKey.getEncoded();
// Get public key byte array
byte[] publicKeyEncoded = publicKey.getEncoded();
// base64 encoding of public and private keys
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// Print private key
System.out.println(privateKeyString);
// Print public key
System.out.println(publicKeyString);
}
}
Run the program: the private key is printed first, and the public key is printed later
Private key encryption
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "silicon valley";
// encryption algorithm
String algorithm = "RSA";
// Create key pair generator object
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// Generate key pair
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// Generate private key
PrivateKey privateKey = keyPair.getPrivate();
// Generate public key
PublicKey publicKey = keyPair.getPublic();
// Get private key byte array
byte[] privateKeyEncoded = privateKey.getEncoded();
// Get public key byte array
byte[] publicKeyEncoded = publicKey.getEncoded();
// base64 encoding of public and private keys
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// Create encrypted object
// The parameter represents the encryption algorithm
Cipher cipher = Cipher.getInstance(algorithm);
// Initialize encryption
// First parameter: encryption mode
// Second parameter: use private key for encryption
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
// Private key encryption
byte[] bytes = cipher.doFinal(input.getBytes());
System.out.println(Base64.encode(bytes));
}
}
Run program
Private key encryption private key decryption
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "silicon valley";
// encryption algorithm
String algorithm = "RSA";
// Create key pair generator object
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// Generate key pair
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// Generate private key
PrivateKey privateKey = keyPair.getPrivate();
// Generate public key
PublicKey publicKey = keyPair.getPublic();
// Get private key byte array
byte[] privateKeyEncoded = privateKey.getEncoded();
// Get public key byte array
byte[] publicKeyEncoded = publicKey.getEncoded();
// base64 encoding of public and private keys
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// Create encrypted object
// The parameter represents the encryption algorithm
Cipher cipher = Cipher.getInstance(algorithm);
// Initialize encryption
// First parameter: encryption mode
// The second parameter: use the private key for encryption
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
// Private key encryption
byte[] bytes = cipher.doFinal(input.getBytes());
System.out.println(Base64.encode(bytes));
// Decrypt the private key
cipher.init(Cipher.DECRYPT_MODE,publicKey);
// To decrypt the ciphertext, base64 is not required, because the original text will not be garbled
byte[] bytes1 = cipher.doFinal(bytes);
System.out.println(new String(bytes1));
}
}
Run the program because the private key is encrypted and can only be decrypted by the public key
Private key encryption public key decryption
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "silicon valley";
// encryption algorithm
String algorithm = "RSA";
// Create key pair generator object
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// Generate key pair
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// Generate private key
PrivateKey privateKey = keyPair.getPrivate();
// Generate public key
PublicKey publicKey = keyPair.getPublic();
// Get private key byte array
byte[] privateKeyEncoded = privateKey.getEncoded();
// Get public key byte array
byte[] publicKeyEncoded = publicKey.getEncoded();
// base64 encoding of public and private keys
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// Create encrypted object
// The parameter represents the encryption algorithm
Cipher cipher = Cipher.getInstance(algorithm);
// Initialize encryption
// First parameter: encryption mode
// Second parameter: use private key for encryption
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
// Private key encryption
byte[] bytes = cipher.doFinal(input.getBytes());
System.out.println(Base64.encode(bytes));
// Decrypt the private key
cipher.init(Cipher.DECRYPT_MODE,publicKey);
// To decrypt the ciphertext, base64 is not required, because the original text will not be garbled
byte[] bytes1 = cipher.doFinal(bytes);
System.out.println(new String(bytes1));
}
}
Run program
Public key encryption and public key decryption
It will also report an error
Save public and private keys
The previous code will generate encryption and decryption every time. We need to transfer all the encryption and decryption methods to the local root directory.
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "silicon valley";
// encryption algorithm
String algorithm = "RSA";
//Generate a key pair and save it in a local file
generateKeyToFile(algorithm, "a.pub", "a.pri");
//encryption
// String s = encryptRSA(algorithm, privateKey, input);
// decrypt
// String s1 = decryptRSA(algorithm, publicKey, s);
// System.out.println(s1);
}
/**
* Generate a key pair and save it in a local file
*
* @param algorithm : algorithm
* @param pubPath : Public key saving path
* @param priPath : Private key saving path
* @throws Exception
*/
private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// Get key pair generator
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// Get key pair
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// Get public key
PublicKey publicKey = keyPair.getPublic();
// Get private key
PrivateKey privateKey = keyPair.getPrivate();
// Get byte array
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// Base64 encoding
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// Save file
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
}
/**
* Decrypt data
*
* @param algorithm : algorithm
* @param encrypted : ciphertext
* @param key : secret key
* @return : original text
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// Create encrypted object
// The parameter represents the encryption algorithm
Cipher cipher = Cipher.getInstance(algorithm);
// Decrypt the private key
cipher.init(Cipher.DECRYPT_MODE,key);
// Since the ciphertext is Base64 encoded, it needs to be decoded here
byte[] decode = Base64.decode(encrypted);
// To decrypt the ciphertext, base64 is not required, because the original text will not be garbled
byte[] bytes1 = cipher.doFinal(decode);
System.out.println(new String(bytes1));
return new String(bytes1);
}
/**
* Encrypt data with a key
*
* @param algorithm : algorithm
* @param input : original text
* @param key : secret key
* @return : ciphertext
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// Create encrypted object
// The parameter represents the encryption algorithm
Cipher cipher = Cipher.getInstance(algorithm);
// Initialize encryption
// First parameter: encryption mode
// Second parameter: use private key for encryption
cipher.init(Cipher.ENCRYPT_MODE,key);
// Private key encryption
byte[] bytes = cipher.doFinal(input.getBytes());
// Base64 encoding of ciphertext
System.out.println(Base64.encode(bytes));
return Base64.encode(bytes);
}
}
Run to generate the private key at the root of the project
Run to generate the public key at the root of the project
Read private key
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "silicon valley";
// encryption algorithm
String algorithm = "RSA";
PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
}
public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
// Convert file contents to strings
String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
// Get key factory
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// Build key specification for Base64 decoding
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
// Generate private key
return keyFactory.generatePrivate(spec);
}
/**
* Generate a key pair and save it in a local file
*
* @param algorithm : algorithm
* @param pubPath : Public key saving path
* @param priPath : Private key saving path
* @throws Exception
*/
private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// Get key pair generator
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// Get key pair
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// Get public key
PublicKey publicKey = keyPair.getPublic();
// Get private key
PrivateKey privateKey = keyPair.getPrivate();
// Get byte array
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// Base64 encoding
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// Save file
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
}
/**
* Decrypt data
*
* @param algorithm : algorithm
* @param encrypted : ciphertext
* @param key : secret key
* @return : original text
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// Create encrypted object
// The parameter represents the encryption algorithm
Cipher cipher = Cipher.getInstance(algorithm);
// Decrypt the private key
cipher.init(Cipher.DECRYPT_MODE,key);
// Since the ciphertext is Base64 encoded, it needs to be decoded here
byte[] decode = Base64.decode(encrypted);
// To decrypt the ciphertext, base64 is not required, because the original text will not be garbled
byte[] bytes1 = cipher.doFinal(decode);
System.out.println(new String(bytes1));
return new String(bytes1);
}
/**
* Encrypt data with a key
*
* @param algorithm : algorithm
* @param input : original text
* @param key : secret key
* @return : ciphertext
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// Create encrypted object
// The parameter represents the encryption algorithm
Cipher cipher = Cipher.getInstance(algorithm);
// Initialize encryption
// First parameter: encryption mode
// Second parameter: use private key for encryption
cipher.init(Cipher.ENCRYPT_MODE,key);
// Private key encryption
byte[] bytes = cipher.doFinal(input.getBytes());
// Base64 encoding of ciphertext
System.out.println(Base64.encode(bytes));
return Base64.encode(bytes);
}
}
Read public key
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = "silicon valley";
// encryption algorithm
String algorithm = "RSA";
PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
PublicKey publicKey = getPublicKey("a.pub", algorithm);
String s = encryptRSA(algorithm, privateKey, input);
String s1 = decryptRSA(algorithm, publicKey, s);
System.out.println(s1);
}
public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
// Convert file contents to strings
String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
// Get key factory
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// Build key specification for Base64 decoding
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
// Generate public key
return keyFactory.generatePublic(spec);
}
public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
// Convert file contents to strings
String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
// Get key factory
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// Build key specification for Base64 decoding
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
// Generate private key
return keyFactory.generatePrivate(spec);
}
/**
* Generate a key pair and save it in a local file
*
* @param algorithm : algorithm
* @param pubPath : Public key saving path
* @param priPath : Private key saving path
* @throws Exception
*/
public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// Get key pair generator
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// Get key pair
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// Get public key
PublicKey publicKey = keyPair.getPublic();
// Get private key
PrivateKey privateKey = keyPair.getPrivate();
// Get byte array
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// Base64 encoding
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// Save file
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
}
/**
* Decrypt data
*
* @param algorithm : algorithm
* @param encrypted : ciphertext
* @param key : secret key
* @return : original text
* @throws Exception
*/
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
// Create encrypted object
// The parameter represents the encryption algorithm
Cipher cipher = Cipher.getInstance(algorithm);
// Decrypt the private key
cipher.init(Cipher.DECRYPT_MODE,key);
// Since the ciphertext is Base64 encoded, it needs to be decoded here
byte[] decode = Base64.decode(encrypted);
// To decrypt the ciphertext, base64 is not required, because the original text will not be garbled
byte[] bytes1 = cipher.doFinal(decode);
return new String(bytes1);
}
/**
* Encrypt data with a key
*
* @param algorithm : algorithm
* @param input : original text
* @param key : secret key
* @return : ciphertext
* @throws Exception
*/
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
// Create encrypted object
// The parameter represents the encryption algorithm
Cipher cipher = Cipher.getInstance(algorithm);
// Initialize encryption
// First parameter: encryption mode
// Second parameter: use private key for encryption
cipher.init(Cipher.ENCRYPT_MODE,key);
// Private key encryption
byte[] bytes = cipher.doFinal(input.getBytes());
// Base64 encoding of ciphertext
return Base64.encode(bytes);
}
}
Run program
