有个一个需求,需要用java的RSA非对称加密算法去开发,但是要满足如下两个要求 1.服务器部署有两台机器 2.需要保证两台机器都可以用同一个私钥加密公钥解密
时间: 2024-02-17 13:02:20 浏览: 95
实现该需求,您需要遵循以下步骤:
1. 在一台机器上生成公私钥对,并将私钥保存在该机器上,同时将公钥保存在另一台机器上。这可以通过将公钥输出到文件,或将其存储在数据库中等方式实现。
2. 两台机器之间的通信可以通过 Socket 或 HTTP 等方式进行。在通信时,另一台机器将使用公钥对数据进行加密,发送给第一台机器。第一台机器使用私钥对数据进行解密。
3. 由于您要求两台机器都可以使用同一个私钥加密公钥解密,因此需要保证两台机器均可以访问到该私钥。您可以将私钥存储在网络文件系统或数据库中,以供两台机器访问。
下面是一个简单的示例代码,演示如何使用 RSA 加密和解密数据:
```java
import javax.crypto.Cipher;
import java.io.*;
import java.net.Socket;
import java.security.*;
public class RSAExample {
private static final String PRIVATE_KEY_PATH = "/path/to/private.key";
private static final String PUBLIC_KEY_PATH = "/path/to/public.key";
public static void main(String[] args) throws Exception {
// 加载私钥
PrivateKey privateKey = loadPrivateKey(PRIVATE_KEY_PATH);
// 加载公钥
PublicKey publicKey = loadPublicKey(PUBLIC_KEY_PATH);
// 服务器1
Server server1 = new Server(privateKey);
server1.start();
// 服务器2
Server server2 = new Server(privateKey);
server2.start();
// 客户端
Client client = new Client(publicKey);
client.send("Hello, world!", "localhost", 8888);
}
private static PrivateKey loadPrivateKey(String path) throws Exception {
byte[] keyBytes = loadKeyBytes(path);
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory kf = KeyFactory.getInstance("RSA");
return kf.generatePrivate(spec);
}
private static PublicKey loadPublicKey(String path) throws Exception {
byte[] keyBytes = loadKeyBytes(path);
X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
KeyFactory kf = KeyFactory.getInstance("RSA");
return kf.generatePublic(spec);
}
private static byte[] loadKeyBytes(String path) throws Exception {
InputStream is = new FileInputStream(path);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len;
while ((len = is.read(buffer)) != -1) {
baos.write(buffer, 0, len);
}
is.close();
return baos.toByteArray();
}
}
class Server extends Thread {
private final PrivateKey privateKey;
public Server(PrivateKey privateKey) {
this.privateKey = privateKey;
}
@Override
public void run() {
try {
ServerSocket serverSocket = new ServerSocket(8888);
while (true) {
Socket socket = serverSocket.accept();
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String encryptedData = reader.readLine();
byte[] encryptedBytes = Base64.getDecoder().decode(encryptedData);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] decryptedBytes = cipher.doFinal(encryptedBytes);
String decryptedData = new String(decryptedBytes);
System.out.println("Server received data: " + decryptedData);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Client {
private final PublicKey publicKey;
public Client(PublicKey publicKey) {
this.publicKey = publicKey;
}
public void send(String data, String host, int port) throws Exception {
Socket socket = new Socket(host, port);
OutputStream os = socket.getOutputStream();
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encryptedBytes = cipher.doFinal(data.getBytes());
String encryptedData = Base64.getEncoder().encodeToString(encryptedBytes);
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os));
writer.write(encryptedData);
writer.newLine();
writer.flush();
socket.close();
}
}
```
在此示例代码中,我们将私钥保存在两台服务器上,每个服务器都使用该私钥对数据进行解密。公钥保存在客户端,客户端使用该公钥对数据进行加密。两个服务器均监听端口 8888,客户端向其中一个服务器发送加密后的数据。
阅读全文