node_b_2.java

1、利用公钥密码技术实现对称密码技术密钥的分配； 2、利用所分配的对称密钥对通信内容进行加/解密；

import java.io.*;
import java.net.*;
import java.security.InvalidKeyException;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.SecretKey;

public class Node_b_2 
{
	public Node_b_2()
	{}
	
	public void ReceiveFile()
	{ 
		Socket s =null;
		ServerSocket ss =null; 
		String fileName = "d:\\team28\\3.txt";
		
		try
		{
			ss =new ServerSocket(8001);
			
			System.out.println("服务器端已经就绪...");
		    while(true)
		    {
		    	//接受客户端的请求,没有请求则阻塞
		    	s = ss.accept();   
		    	//以重新启动一个线程的方式，取得客户端发送的文件
		    	new Thread(new Servicer(s,fileName)).start();
		    }
		    
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
		finally
		{
			try
			{
				s.close();
			}
			catch(IOException ex)
			{
				ex.printStackTrace();
			}
		}  
	}
	
	public static void main(String args[])
	{
		Node_b_2 fileServer = new Node_b_2();
		fileServer.ReceiveFile();
	}
}

class Servicer implements Runnable
{
	Socket server =null;
	String fileName =null;
	//传递文件名和Socket
	Servicer(Socket s,String fileName)
	{
	    this.server = s;
	    this.fileName = fileName;
	}
	
	public void run()
	{
		DataInputStream dis =null;
		FileOutputStream fos =null;
		
		//创建Socket的输入输出流
	    try
	    {
	    	InputStream ips =server.getInputStream();
	        BufferedInputStream br = new BufferedInputStream(ips);
	        
	        //以DataInputStream来包装字节缓冲输入流
	        dis = new DataInputStream(br);
	        //文件输出流
	        fos = new FileOutputStream(fileName);
	       
	        //网络传输都是以字节的方式传递的

	        byte[] buf = new byte[4096];
	        
	        System.out.println("服务器端开始接收...");
	        
	        int count; 
	        count = dis.read(buf);
	        
	        byte[] temp = new byte[count];
		    for(int i = 0; i < temp.length; i++)
		    {
		    	temp[i] = buf[i];
		    }

	        //获得对称密钥
			SecretKey key = getSemKey();
	        //调用解密过程
			byte priInfo[] = new byte[0];
	        priInfo = decryptFile(temp,key);
	        
	        fos.write(priInfo);
    
	        System.out.println("服务器端接收完毕");
	        System.out.println("接受到的文件保存在本地：" + fileName);
	    }
	    catch(FileNotFoundException fe)
	    {
	       fe.printStackTrace();
	    }
	    catch(IOException e)
	    {
	    	e.printStackTrace();
	    }
	    finally
	    {
	    	try
	    	{
	    		fos.close();
	    		dis.close();
	    	}
	    	catch(IOException ex)
	    	{}
	     }
	}
	
//	从磁盘文件读取对称密钥
	public SecretKey getSemKey()
	{
		SecretKey key = null; 
		try 
		{
			ObjectInputStream in = 
				new ObjectInputStream(new FileInputStream("d:\\team28\\2.txt"));
		    key = (SecretKey)in.readObject();
		    in.close();
		} 
		catch (FileNotFoundException e) 
		{
			e.printStackTrace();
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	    
	    return key;
	}
	
	public byte[] decryptFile(byte buf[],SecretKey key)
	{
		Cipher cipher = null;
		byte[]decrypted = new byte[0];

		try 
        {
			cipher = Cipher.getInstance("DESede");
        	cipher.init(Cipher.DECRYPT_MODE,key);
            decrypted = cipher.doFinal(buf);
	    }
        catch (InvalidKeyException e) 
        {
            e.printStackTrace();
	    } 
        catch (IllegalBlockSizeException e)
        {
        	e.printStackTrace();
        }
        catch (BadPaddingException e)
        {
        	e.printStackTrace();
	    }
        catch(Exception e)
        {
        	e.printStackTrace();
        }
        
		return decrypted;
	}
}