Java 接收Diffie-Hellman密钥超过套接字错误

我已经做了很多研究，但找不到解决这个问题的方法。我已经花了好几个小时，但我想不出答案，所以我希望这里的某个比我更有经验的人能帮上忙。本课程可能不是最佳实践，但它是针对作业的

我正在使用RSA传输公钥，但更重要的是，我正在尝试将Diffie Hellman参数从Bob（服务器）传输到Alice（客户端）。运行程序时，我遇到以下错误：

线程“main”java.security.spec.InvalidKeySpecException中的异常： 不适当的密钥规格在 com.sun.crypto.provider.DHKeyFactory.EngineeGeneratePublic（DHKeyFactory.java:85） 位于java.security.KeyFactory.generatePublic（KeyFactory.java:334） client.client.main（client.java:114）由以下原因引起： java.security.InvalidKeyException:在解析密钥编码时出错 com.sun.crypto.provider.DHPublicKey.（DHPublicKey.java:178）位于 com.sun.crypto.provider.DHKeyFactory.EngineeGeneratePublic（DHKeyFactory.java:78） ... 另外2个原因：java.io.IOException： DerInputStream.getLength（）：lengthTag=127，太大。在 sun.security.util.DerInputStream.getLength（DerInputStream.java:561） 位于sun.security.util.DerValue.init（DerValue.java:365） sun.security.util.DerValue.（DerValue.java:320）位于 com.sun.crypto.provider.DHPublicKey（DHPublicKey.java:125）。。。 3个以上

代码如下： Client.java：

package client;
import java.io.*;
import java.security.*;
import javax.crypto.*;
import java.util.*;
import java.net.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import javax.crypto.spec.DHParameterSpec;
import java.security.spec.*;


class Client{
    private static PublicKey publicKey = null;
    private static PrivateKey privateKey = null;
    private static PublicKey rsaBobPub = null;
    private static SecretKey SecretSharedKeyCipher = null;
    private static SecretKey SecretSharedKeyIntgSend = null;
    private static SecretKey SecretSharedKeyIntRecv = null; 
    private static KeyAgreement aKeyAgreement = null;


    public static void main(String args[]) throws ClassNotFoundException, `IOException, NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException, InvalidParameterSpecException, InvalidKeySpecException{`
        Client client = new Client();
        KeyPairGenerator keyGen;
        byte[] alicePub;
        Cipher cipher2;
        byte[] encryptedDH = null;  
        byte[] bobEncryptedDH = null;
        OutputStream dh;
        InputStream bobDHConn;

            Socket connection = new Socket("localhost", 4129);

            //Generate Keys & then send to Bob
                keyGen = KeyPairGenerator.getInstance("RSA");
                keyGen.initialize(2048);
                KeyPair keyPair = keyGen.genKeyPair();
                publicKey = keyPair.getPublic();
                privateKey = keyPair.getPrivate();

           //Send Public Key to Bob
                ObjectOutputStream toBob = new ObjectOutputStream(connection.getOutputStream());
                toBob.writeObject(publicKey);

           //Receive Bob's Public Key
                ObjectInputStream fromBob;
                fromBob = new ObjectInputStream(connection.getInputStream());
                rsaBobPub = (PublicKey) fromBob.readObject();

  //SET UP DIFFIE HELLMAN PROTOCOL
  //For some reason, when receiving Bob's DH param, I am getting a lot of issues.
            //Exchange DH info
                DHParameterSpec paramSpec;
                AlgorithmParameterGenerator paramGen = AlgorithmParameterGenerator.getInstance("DH");
                paramGen.init(512);
                AlgorithmParameters parameters = paramGen.generateParameters();
                paramSpec = (DHParameterSpec) parameters.getParameterSpec(DHParameterSpec.class);

            //Generate Key Pair
                KeyPairGenerator aliceKpGen = KeyPairGenerator.getInstance("DH");
                aliceKpGen.initialize(paramSpec);
                KeyPair aliceKp = aliceKpGen.generateKeyPair();
                aKeyAgreement = KeyAgreement.getInstance("DH");
                aKeyAgreement.init(aliceKp.getPrivate());
                alicePub = aliceKp.getPublic().getEncoded();
                //System.out.println(aliceKp.getPublic())
                //System.out.println(aliceKp.getPublic().getEncoded())
                //Send Alice's encrypted DH byte info to Bob
               /*     cipher2 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
                    cipher2.init(Cipher.ENCRYPT_MODE, rsaBobPub);
                    encryptedDH = cipher2.doFinal(alicePub);
                    System.out.print(encryptedDH);
                */
                    dh = connection.getOutputStream();
                    dh.write(alicePub);

             //Recieve Bob's DH Info
                bobDHConn = connection.getInputStream();
                int length;
                byte[] bobDH = null;


                while((length = bobDHConn.available()) == 0){
                    bobDH = new byte[length];
                    int i = 0;
                    while(i < length){
                        i+= bobDHConn.read(bobDH, i, length - i);
                    }
                } 
          //NOT WORKING
           KeyFactory clientKeyFac = KeyFactory.getInstance("DH");
           X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(bobDH);
           PublicKey bobsDHPubKey = clientKeyFac.generatePublic(x509KeySpec);
           aKeyAgreement.doPhase(bobsDHPubKey, true);


        //Generate AES Secret Keys
        SecretKey aesKeyGen = aKeyAgreement.generateSecret("AES");


    }
}

包客户端；
导入java.io.*；
导入java.security.*；
导入javax.crypto.*；
导入java.util.*；
导入java.net。*；
导入java.util.logging.Level；
导入java.util.logging.Logger；
导入java.io.ObjectInputStream；
导入java.io.ObjectOutputStream；
导入javax.crypto.spec.DHParameterSpec；
导入java.security.spec.*；
类客户端{
私有静态公钥PublicKey=null；
private static PrivateKey PrivateKey=null；
私有静态公钥rsaBobPub=null；
私有静态SecretKey SecretSharedKeyCipher=null；
私有静态SecretKey SecretSharedKeyIntgSend=null；
私有静态SecretKey SecretSharedKeyIntRecv=null；
私有静态密钥协议aKeyAgreement=null；
公共静态void main（字符串args[]）抛出ClassNotFoundException、`IOException、NoSuchAlgorithmException、InvalidKeyException、NoSuchPaddingException、IllegalBlockSizeException、BadPaddingException、InvalidAlgorithmParameterSpecException、InvalidKeySpecException{`
客户端=新客户端（）；
KeyPair发电机keyGen；
字节[]alicePub；
密码2；
字节[]encryptedDH=null；
字节[]bobEncryptedDH=null；
输出流dh；
输入流bobDHConn；
套接字连接=新套接字（“localhost”，4129）；
//生成密钥并发送给Bob
keyGen=KeyPairGenerator.getInstance（“RSA”）；
密钥初始化（2048）；
KeyPair KeyPair=keyGen.genKeyPair（）；
publicKey=keyPair.getPublic（）；
privateKey=keyPair.getPrivate（）；
//将公钥发送给Bob
ObjectOutputStream toBob=新的ObjectOutputStream（connection.getOutputStream（））；
toBob.writeObject（公钥）；
//接收Bob的公钥
objectInputStreamfromBob；
fromBob=newObjectInputStream（connection.getInputStream（））；
rsaBobPub=（PublicKey）fromBob.readObject（）；
//建立DIFFIE-HELLMAN协议
//出于某种原因，在收到Bob的DH param时，我遇到了很多问题。
//交换卫生署资料
DHParameterSpec-paramSpec；
AlgorithmParameterGenerator paramGen=AlgorithmParameterGenerator.getInstance（“DH”）；
参数初始化（512）；
AlgorithmParameters=paramGen.generateParameters（）；
paramSpec=（DHParameterSpec）parameters.getParameterSpec（DHParameterSpec.class）；
//生成密钥对
KeyPairGenerator aliceKpGen=KeyPairGenerator.getInstance（“DH”）；
aliceKpGen.initialize（paramSpec）；
KeyPair aliceKp=aliceKpGen.generateKeyPair（）；
aKeyAgreement=KeyAgreement.getInstance（“DH”）；
init（aliceKp.getPrivate（））；
alicePub=aliceKp.getPublic（）.getEncoded（）；
//System.out.println（aliceKp.getPublic（））
//System.out.println（aliceKp.getPublic（）.getEncoded（））
//将Alice的加密DH字节信息发送给Bob
/*cipher2=Cipher.getInstance（“RSA/ECB/PKCS1Padding”）；
cipher2.init（Cipher.ENCRYPT_模式，rsaBobPub）；
encryptedDH=cipher2.doFinal（alicePub）；
系统输出打印（encryptedDH）；
*/
dh=connection.getOutputStream（）；
dh.write（alicePub）；
//接收鲍勃的DH信息
bobDHConn=connection.getInputStream（）；
整数长度；
字节[]bobDH=null；
而（（length=bobDHConn.available（））==0）{
bobDH=新字节[长度]；
int i=0；
while（i

Server.java

package server;
import java.io.*;
import java.security.*;
import javax.crypto.*;
import java.util.*;
import java.net.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;

public class Server{
    private static int port = 4129;
    private static PublicKey publicKey = null;
    private static PrivateKey privateKey = null;
    private static PublicKey rsaAlicePub = null;
    private static ServerSocket server = null;
    private static SecretKey SecretSharedKeyCipher = null;
    private static SecretKey SecretSharedKeyIntgSend = null;
    private static SecretKey SecretSharedKeyIntRecv = null;

    public static void main(String args[]) throws ClassNotFoundException, NoSuchAlgorithmException, IOException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException, InvalidAlgorithmParameterException{
        //Declarations
            Server serv = new Server();
            server = new ServerSocket(4129);
            server.setReuseAddress(true);
            KeyPairGenerator keyGen;
            byte[] cipherText = null;
            InputStream input = null;
            byte[] data = null;
            byte[] decryptedDH;
            InputStream DH = null;
            byte[] DHinfo = null;
            int length;
            byte[] aliceEncryptedDH = null;    
            SecretKey keyGenDH= null;
            InputStream aliceDH = null;
            Cipher cipher;
            PublicKey bobDHPub = null;
            OutputStream sendDH;

            //String message = "bbbbbbbbbbbbbb";
            String message = "bbbbbbb";
            Socket client = server.accept();

            //Get Public Key froM Alice
                ObjectInputStream alicePK;
                alicePK = new ObjectInputStream(client.getInputStream());
                rsaAlicePub = (PublicKey)alicePK.readObject();

            //Generate Bob's keys
                keyGen = KeyPairGenerator.getInstance("RSA");
                keyGen.initialize(2048);
                KeyPair keyPair = keyGen.genKeyPair();
                privateKey = keyPair.getPrivate();
                publicKey = keyPair.getPublic();

            //Send Bob's public Key to Alice
                ObjectOutputStream bobPK;
                bobPK = new ObjectOutputStream(client.getOutputStream());
                bobPK.writeObject(publicKey);

            //Exchange information for DH
            //Decrypt received information using Bob PK
            //You can assume that Bob selects the public parameters of Diffie‐Hellman protocol, and send them to Alice

            DH = client.getInputStream();
            while((length = DH.available()) == 0);
            int i = 0;
            DHinfo = new byte[length];
            while (i < length) {
                i += DH.read(DHinfo, i, length - i);
            }
/*
            cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            decryptedDH = cipher.doFinal(DHinfo);
           */ 
            KeyFactory clientKeyFac = KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(DHinfo);
            bobDHPub = clientKeyFac.generatePublic(x509KeySpec);

            DHParameterSpec dhParamSpec = ((DHPublicKey) bobDHPub).getParams();

            //Create Bob DH Keys
                KeyPairGenerator bobKpGen = KeyPairGenerator.getInstance("DH");
                bobKpGen.initialize(dhParamSpec);
                KeyPair bobsKeys = bobKpGen.generateKeyPair();

                KeyAgreement bobKeyAgreement = KeyAgreement.getInstance("DH");
                bobKeyAgreement.init(bobsKeys.getPrivate());
                bobKeyAgreement.doPhase(bobDHPub, true);

            //Send Bob's DH Parameters to Alice
            //send bobsKeys.getPublic().getEncoded()
                    sendDH = client.getOutputStream();
                    sendDH.write(bobsKeys.getPublic().getEncoded());

            //Encrypt message.getBytes();

    }

    private void Server() throws IOException{
        server = new ServerSocket(port);


    }



}

包服务器；
导入java.io.*；
导入java.security.*；
导入javax.crypto.*；
导入java.util.*；
感应电动机
toBob.writeObject(alicePub);

DHinfo = (byte[]) alicePK.readObject();