我想要与Easy way to store/restore encryption key for decrypting string in java处方类似的功能
但是我的情况不同。在上面的链接中，他们使用的是javax.crypto.*，但就我而言，我使用的是org.bouncycastle.crypto.*和it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.generators.*
我想将主密钥，公钥和私钥存储在不同的文件中，并且还从文件中检索那些密钥。怎么做 ？
下面是我离开TODO的代码。可以在github上找到工作代码。
import it.unisa.dia.gas.crypto.circuit.BooleanCircuit;
import it.unisa.dia.gas.crypto.circuit.BooleanCircuit.BooleanCircuitGate;
import it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.engines.GGHSW13KEMEngine;
import it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.generators.GGHSW13KeyPairGenerator;
import it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.generators.GGHSW13ParametersGenerator;
import it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.generators.GGHSW13SecretKeyGenerator;
import it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.params.*;
import it.unisa.dia.gas.crypto.kem.cipher.engines.KEMCipher;
import it.unisa.dia.gas.crypto.kem.cipher.params.KEMCipherDecryptionParameters;
import it.unisa.dia.gas.crypto.kem.cipher.params.KEMCipherEncryptionParameters;
import it.unisa.dia.gas.plaf.jpbc.pairing.PairingFactory;
import it.unisa.dia.gas.plaf.jpbc.util.concurrent.ExecutorServiceUtils;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import java.security.GeneralSecurityException;
import java.security.SecureRandom;
import java.security.Security;
import java.security.spec.AlgorithmParameterSpec;
import java.util.ArrayList;
import java.util.List;
import static it.unisa.dia.gas.crypto.circuit.Gate.Type.*;
public class Example {
protected KEMCipher kemCipher;
protected AlgorithmParameterSpec iv;
protected AsymmetricCipherKeyPair keyPair;
public Example() throws GeneralSecurityException {
this.kemCipher = new KEMCipher(
Cipher.getInstance("AES/CBC/PKCS7Padding", "BC"),
new GGHSW13KEMEngine()
);
// build the initialization vector. This example is all zeros, but it
// could be any value or generated using a random number generator.
iv = new IvParameterSpec(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
}
public AsymmetricCipherKeyPair setup(int n) {
GGHSW13KeyPairGenerator setup = new GGHSW13KeyPairGenerator();
setup.init(new GGHSW13KeyPairGenerationParameters(
new SecureRandom(),
new GGHSW13ParametersGenerator().init(
PairingFactory.getPairing("params/mm/ctl13/toy.properties"),
n).generateParameters()
));
return (keyPair = setup.generateKeyPair());
}
public byte[] initEncryption(String assignment) {
try {
return kemCipher.init(
true,
new KEMCipherEncryptionParameters(
128,
new GGHSW13EncryptionParameters(
(GGHSW13PublicKeyParameters) keyPair.getPublic(),
assignment
)
),
iv
);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public byte[] encrypt(String message) {
try {
return kemCipher.doFinal(message.getBytes());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public CipherParameters keyGen(BooleanCircuit circuit) {
GGHSW13SecretKeyGenerator keyGen = new GGHSW13SecretKeyGenerator();
keyGen.init(new GGHSW13SecretKeyGenerationParameters(
((GGHSW13PublicKeyParameters) keyPair.getPublic()),
((GGHSW13MasterSecretKeyParameters) keyPair.getPrivate()),
circuit
));
return keyGen.generateKey();
}
public byte[] decrypt(CipherParameters secretKey, byte[] encapsulation, byte[] ciphertext) {
try {
kemCipher.init(
false,
new KEMCipherDecryptionParameters(secretKey, encapsulation, 128),
iv
);
return kemCipher.doFinal(ciphertext);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
Security.addProvider(new BouncyCastleProvider());
try {
// Setup
int n = 4;
Example engine = new Example();
engine.setup(n);
// TODO: Here I want to store (GGHSW13PublicKeyParameters) keyPair.getPublic() and
// (GGHSW13MasterSecretKeyParameters) keyPair.getPrivate() in files and later to retrieve from file
// Encrypt
String message = "Hello World!!!";
byte[] encapsulation = engine.initEncryption("1101");
byte[] ciphertext = engine.encrypt(message);
BooleanCircuitGate bcg1 = new BooleanCircuitGate(INPUT, 0, 1);
BooleanCircuitGate[] bcgs = new BooleanCircuitGate[]{
new BooleanCircuitGate(INPUT, 0, 1),
new BooleanCircuitGate(INPUT, 1, 1),
new BooleanCircuitGate(INPUT, 2, 1),
new BooleanCircuitGate(INPUT, 3, 1),
new BooleanCircuitGate(AND, 4, 2, new int[]{0, 1}),
new BooleanCircuitGate(OR, 5, 2, new int[]{2, 3}),
new BooleanCircuitGate(AND, 6, 3, new int[]{4, 5}),
};
List<BooleanCircuitGate> bcgList = new ArrayList<BooleanCircuitGate>();
bcgList.add(bcg1);
bcgList.add(new BooleanCircuitGate(INPUT, 1, 1));
bcgList.add(new BooleanCircuitGate(INPUT, 2, 1));
bcgList.add(new BooleanCircuitGate(INPUT, 3, 1));
bcgList.add(new BooleanCircuitGate(AND, 4, 2, new int[]{0, 1}));
bcgList.add(new BooleanCircuitGate(OR, 5, 2, new int[]{2, 3}));
bcgList.add(new BooleanCircuitGate(AND, 6, 3, new int[]{4, 5}));
// Decrypt
int q = 3;
BooleanCircuit circuit = new BooleanCircuit(n, q, 3, bcgList.toArray(new BooleanCircuitGate[bcgList.size()]));
GGHSW13SecretKeyParameters secretKey = (GGHSW13SecretKeyParameters) engine.keyGen(circuit);
// TODO: Want to store secretKey in file and later to retrieve from file
byte[] plaintext = engine.decrypt(secretKey, encapsulation, ciphertext);
System.out.println(new String(plaintext));
} catch (Exception e) {
e.printStackTrace();
} finally {
ExecutorServiceUtils.shutdown();
}
}
}
最佳答案
生成主密钥和公共参数之后，应该存储它们，以便以后可以实际使用它们。 jPBC无法为您提供存储这些密钥的方法。同样，由于键继承自org.bouncycastle.crypto.params.AsymmetricKeyParameter，因此您不能使用Java的序列化，因为AsymmetricKeyParameter不实现Serializable接口。它doesn't没有工作。
您将需要自己实现序列化。首先，您必须考虑要序列化的密钥中包含哪种对象。对于GGHSW13MasterSecretKeyParameters类，这是Element，int和Pairing。
首先，您必须考虑是否要在序列化密钥中包含Pairing。如果这样做，则必须将其写入开头，以便以后可以使用它反序列化Element。
如果我们假设Pairing实例是恒定的，或者总是由外部代码提供的，则序列化非常容易。您应该在前面写一个格式版本，这样一来您就可以更改格式，而不会丢弃所有以前的序列化密钥。由于两年前我遇到了一个错误，因此编写元素会有些棘手。基本思想是写元素的字节长度，然后是元素的内容。
public void serialize(GGHSW13MasterSecretKeyParameters msk, OutputStream out) throws IOException {
DataOutputStream dOut = new DataOutputStream(out);
dOut.writeInt(1); // version of the serialized format
dOut.writeInt(msk.getParameters().getN());
serialize(msk.getAlpha(), dOut, msk.getParameters().getPairing());
}
public void serialize(Element elem, DataOutputStream dOut, Pairing pairing) throws IOException {
dOut.writeBoolean(elem == null);
if (elem == null) {
return;
}
dOut.writeInt(pairing.getFieldIndex(elem.getField()));
byte[] bytes = elem.toBytes();
dOut.writeInt(bytes.length);
dOut.write(bytes);
// this is a workaround because it.unisa.dia.gas.plaf.jpbc.field.curve.CurveElement does not serialize the infFlag
dOut.writeBoolean(elem instanceof CurveElement && elem.isZero());
if (elem instanceof CurveElement && elem.isZero()) {
throw new IOException("Infinite element detected. They should not happen.");
}
}
OutputStream可以是FileOutputSteam或ByteArrayOutputStream之类的东西。反序列化同样容易，但是您需要显式提供
Pairing，并且需要确保始终读取所需的字节数。从数据前面写入的长度int可以知道您请求的字节数。如果不检查该长度是否合理，则可能会引入安全问题，例如拒绝服务漏洞或远程执行代码。public GGHSW13MasterSecretKeyParameters deserialize(InputStream in, Pairing pairing) throws IOException {
DataInputStream dIn = new DataInputStream(in);
int version = dIn.readInt();
if (version != 1) {
throw new RuntimeException("Unknown key format version: " + version);
}
int n = dIn.getInt();
Element alpha = deserialize(dIn, pairing);
return new GGHSW13MasterSecretKeyParameters(
new GGHSW13Parameters(pairing, n),
alpha
);
}
public Element deserialize(DataInputStream dIn, Pairing pairing) throws IOException {
if (dIn.readBoolean()) {
return null;
}
int fieldIndex = dIn.readInt(); // TODO: check if this is in a sensible range
int length = dIn.readInt(); // TODO: check if this is in a sensible range
byte[] bytes = new byte[length];
dIn.readFully(bytes); // throws an exception if there is a premature EOF
Element e = pairing.getFieldAt(fieldIndex).newElementFromBytes(bytes);
// this is a workaround because it.unisa.dia.gas.plaf.jpbc.field.curve.CurveElement does not serialize the infFlag
boolean instOfCurveElementAndInf = dIn.readBoolean();
if (instOfCurveElementAndInf) {
//e.setToZero(); // according to the code this simply sets the infFlag to 1
throw new IOException("The point is infinite. This shouldn't happen.");
}
return e;
}
这是一个二进制序列化，很小。还有其他可能性，例如将所有组件编码为字符串并使用JSON。