Java 从jPBC保存和加载非对称密钥

我想要类似的功能

但我的情况不同。在上面的链接中，他们使用的是

javax.crypto.

，但在我的例子中，我使用的是

org.bouncycastle.crypto.

和

it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.generators.

我想在不同的文件中存储主密钥、公钥和私钥，并从文件中检索这些密钥。怎么做

下面是我留下的代码。可在上找到工作代码

导入it.unisa.dia.gas.crypto.circuit.booleanCuit；
导入it.unisa.dia.gas.crypto.circuit.booleancuit.booleancuitGate；
导入it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.engines.gghsw13引擎；
导入it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.generators.GGHSW13KeyPairGenerator；
导入it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.generators.gghsw13参数发生器；
导入it.unisa.dia.gas.CRYTO.jpbc.fe.abe.gghsw13.generators.gghsw13 SecretKeyGenerator；
导入it.unisa.dia.gas.crypto.jpbc.fe.abe.gghsw13.params.*；
导入it.unisa.dia.gas.crypto.kem.cipher.engines.kempier；
导入it.unisa.dia.gas.crypto.kem.cipher.params.kemcippherDecryptionParameters；
导入it.unisa.dia.gas.crypto.kem.cipher.params.kemcippherencyption参数；
导入it.unisa.dia.gas.plaf.jpbc.pairing.PairingFactory；
导入it.unisa.dia.gas.plaf.jpbc.util.concurrent.ExecutorServiceUtils；
导入org.bouncycastle.crypto.asymmetricipherkeypair；
导入org.bouncycastle.crypto.CipherParameters；
导入org.bouncycastle.jce.provider.BouncyCastleProvider；
导入javax.crypto.Cipher；
导入javax.crypto.spec.IvParameterSpec；
导入java.security.GeneralSecurityException；
导入java.security.SecureRandom；
导入java.security.security；
导入java.security.spec.AlgorithmParameterSpec；
导入java.util.ArrayList；
导入java.util.List；
导入静态it.unisa.dia.gas.crypto.circuit.Gate.Type.*；
公开课范例{
受保护的KEMPHIPER KEMPHIPER；
受保护算法参数规范iv；
受保护的不对称密钥对密钥对；
public Example（）抛出GeneralSecurityException{
this.kemchipher=新的kemchipher(
Cipher.getInstance（“AES/CBC/PKCS7Padding”，“BC”），
新GGHSW13KEmenEngine（）
);
//构建初始化向量。本例为全零，但
//可以是任何值，也可以使用随机数生成器生成。
iv=新的IvParameterSpec（新字节[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}）；
}
公共非对称密码密钥对设置（int n）{
GGHSW13KeyPairGenerator setup=新GGHSW13KeyPairGenerator（）；
setup.init（新的GGHSW13KeyPairGenerationParameters(
新的SecureRandom（），
新GGHSW13参数生成器（）.init(
PairingFactory.getPairing（“params/mm/ctl13/toy.properties”），
n） .generateParameters（）
));
返回（keyPair=setup.generateKeyPair（））；
}
公共字节[]初始化加密（字符串分配）{
试一试{
返回kemcippher.init(
是的，
新的KemcipherEncryption参数(
128,
新GGHSW13EncryptionParameters(
（GGHSW13PublicKeyParameters）keyPair.getPublic（），
分配
)
),
四,
);
}捕获（例外e）{
抛出新的运行时异常（e）；
}
}
公共字节[]加密（字符串消息）{
试一试{
返回kemCipher.doFinal（message.getBytes（））；
}捕获（例外e）{
抛出新的运行时异常（e）；
}
}
公共密码参数密钥发生器（布尔电路）{
GGHSW13SecretKeyGenerator keyGen=新GGHSW13SecretKeyGenerator（）；
keyGen.init（新GGHSW13SecretKeyGeneration参数(
（（GGHSW13PublicKeyParameters）keyPair.getPublic（）），
（（GGHSW13MasterSecretKeyParameters）keyPair.getPrivate（）），
电路
));
返回keyGen.generateKey（）；
}
公共字节[]解密（密码参数secretKey，字节[]封装，字节[]密文）{
试一试{
kemchipher.init(
假,，
新的KEMCipherDecryptionParameters（secretKey，封装，128），
四,
);
返回kemCipher.doFinal（密文）；
}捕获（例外e）{
抛出新的运行时异常（e）；
}
}
公共静态void main（字符串[]args）{
addProvider（新的BouncyCastleProvider（））；
试一试{
//设置
int n=4；
示例引擎=新示例（）；
引擎设置（n）；
//TODO:我想在这里存储（GGHSW13PublicKeyParameters）keyPair.getPublic（）和
//（GGHSW13MasterSecretKeyParameters）keyPair.getPrivate（），用于从文件中检索
//加密
字符串消息=“你好，世界！！！”；
字节[]封装=engine.initEncryption（“1101”）；
字节[]密文=引擎加密（消息）；
BooleanCircuitGate bcg1=新的BooleanCircuitGate（输入，0，1）；
BooleanCircuitGate[]bcgs=新的BooleanCircuitGate[]{
新的布尔电路门（输入，0，1），
新布尔电路门（输入，1，1），
新的布尔电路门（输入，2，1），
新的布尔电路门（输入，3，1），
新的布尔电路门（AND，4，2，新的int[]{0，1}），
新的布尔电路门（OR，5，2，新的int[]{2，3}），
新的布尔电路门（AND，6，3，新的int[]{4，5}），
};
List bcgList=new ArrayList（）；
bcgList.add（bcg1）；
B
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();
        }
    }

}

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.");
    }
}

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;
}