实现两个主机之间的密钥分发和安全传输

已于 2023-04-15 13:58:48 修改
阅读量3k 收藏 16
点赞数 1
分类专栏： 密码学 文章标签： linux 密码学 网络安全 网络 计算机网络
于 2022-10-19 22:07:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43919144/article/details/118774262
版权

实现两个主机之间的密钥分发和安全传输

一、设计要求

编写一段程序，实现两个主机之间的密钥分发和安全传输。
要求：

  1. 用 RSA 算法实现两个主机之间的密钥分发，分发的密钥为 0x 01
    23 45 67 或 0x 01 23 45 67 89 AB CD EF；
  2. 用分发的密钥和 AES 加密算法，实现两个主机之间的加密数据
    传输，测试数据是“NPU-SCS”和其他自己构造的 7 条消息；
  3. 以上 2 个步骤在程序中自动执行完，无手动参与；程序可以在
    同一台主机上完成，但数据必须经过网络传输（可以本地发送，本地
    接收）；

二、设计思路

  1. 在Linux下通过socket编程实现客户端和服务端的双工通信，从而达到两个主机之间的密钥分发以及加密数据传输。
  2. 服务端使用RSA算法生成一对公钥和密钥，通过网络传输将公钥发送给服务端，因为私钥在服务端自己手中不需要经过传输所以很安全，由于RSA是非对称加密算法即使公钥被劫持加密的数据也不会有被破译的风险。
  3. 客户端通过接收网络传输来的公钥加密自己的AES密钥，并用AES密钥加密需要传输的数据得到密文，客户端将RSA公钥加密过的AES密钥和AES密钥加密过的密文发送给服务端。
  4. 服务端用自己手上的RSA私钥解密AES密钥，通过解密后得到的AES密钥解密密文，得到最后想要的明文。

流程图：
实验流程

三、socket编程：

1、实现步骤：
TCP 套接字编程中，服务器端实现的步骤：
（1）使用 socket()函数创建套接字；
（2）为创建的套接字绑定到指定的地址结构；
（3）listen()函数设置套接字为监听模式，使服务器进入被动打开的转态；
（4）接受客户端的连接请求，建立连接；
（5）接收、应答客户端的数据请求；
（6）终止连接。
客户器端实现的步骤相对比较简单：
（1）使用 socket()函数创建套接字；
（2）调用 connect 函数建立一个与 TCP 服务器的连接；
（3）发送数据请求，接收服务器的数据应答；
（4）终止连接。
2、流程图
在这里插入图片描述

3、主要函数

  • int socket(int family, int type, int protocol)；

socket 函数中 family 参数指明协议族。type 参数指明产生套接字的类型。protocol 参数是
协议标志，一般在调用 socket 函数时将其置为 0，但如果是原始套接字，就需要为 protocol
指定一个常值。
该函数如果调用成功，将返回一个小的非负的整数值，它与文件描述符类似，这里称之
为套接字描述符（socket descriptor），简称套接字，之后的 I/O 操作都由该套接字完成。如果
函数调用失败，则返回-1。

  • int bind(int sockfd, const struct sockaddr *server, socklen_len addrlen)；

绑定函数的作用就是为调用 socket 函数产生的套接字分配一个本地协议地址，建立地址
与套接字的对应关系。对于网际协议，协议地址包括 32 位的 IPv4 地址或 128 位的 IPv6 地址
和 16 位的 UDP 或 TCP 的端口号。

  • int listen(int sockfd, int backlog);

在调用 listen 函数后，服务器的状态从 CLOSED 转换到了
LISTEN 状态。参数 sockfd 是要设置的描述符。backlog 参数规定了请求队列中的最大连接个数，它对
队列中等待服务请求的数目进行了限制。如果一个服务请求到来时，输入队列已满，该套接
字将拒绝连接请求。

  • int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

connect 函数用于激发 TCP 的三路握手过程，建立与远程服务器的连接。参数 sockfd 是
由 socket函数返回的套接字描述符。第二个参数 addr是指向服务器的套接字地址结构的指针，
如果是 IPv4 地址，server 指向的就是一个 sockaddr_in 地址结构，在进行 connect 函数调用时，
必须将 sockaddr_in 结构转换成通用地址结构 sockaddr。最后一个参数 addrlen 是该套接字地
址结构的大小。

  • int accept(int listenfd, struct sockaddr *client, socklen_t *addrlen);

listenfd 参数是由 socket 函数产生的套接字描述符，在调用 accept 函数前，已经调用 listen函数将此套接字变成了监听套接字。client 和 addrlen 参数用来返回连接对方的套接字地址结构和对应的结构长度。这里的 addrlen 是一个值-结果参数，调用前，将 addrlen 指针所指的整 数值置为 client 所指的套接字地址结构的长度。

  • ssize_t send (int sockfd, const void *buf, size_t len, int flags);

参数 sockfd 是套接字描述符。对于服务器是 accept()函数返回的已连接套接字描述符。对于客户端是调用 socket()函数返回的套接字描述符。参数 buf 是指向一个用于发送信息的数据缓冲区。len 指明传送数据缓冲区的大小。

  • ssize_t recv(int sockfd, void *buf ,size_t len, int flags);

参数 sockfd 是套接字描述符。对于服务器是 accept()函数返回的已连接套接字描述符；
对于客户端是调用 socket()函数返回的套接字描述符。参数 buf 是指向一个用于接收信息的数据缓冲区。len 指明接收数据缓冲区的大小。

...
struct sockaddr_in server;
struct sockaddr_in client;
socklen_t addrlen;//前面是声明变量



/*现在开始创建socket*/
if((listenfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
 perror("Create socket failed");
 exit(1);
}
int opt=SO_REUSEADDR;
setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));//地址重用

bzero(&server,sizeof(server));

/*开始配置socket*/
server.sin_family=AF_INET;
server.sin_addr.s_addr=htonl(INADDR_ANY);
server.sin_port=htons(PORT);


/*开始绑定socket*/
if(bind(listenfd,(struct sockaddr*)&server,sizeof(server))==-1)
{
perror("bind error");
exit(1);
}

/*开始监听*/
if(listen(listenfd,BACKLOG)==-1)
{
	perror("listen error");
	exit(1);
	
}
/*接受客户连接*/
addrlen=sizeof(client);
if((connectfd=accept(listenfd,(struct sockaddr*)&client,&addrlen))==-1)
{
	perror("connect error");
	exit(1);
}
...

四、RSA算法

1、实现步骤：
在本程序中，RSA算法的步骤如下：
1.由服务器端先随机选择两个不相等的质数p和q，选择的质数越大，则越难破解；然后计算p和q的乘积n，n的长度即为密钥长度，在实际应用中，RSA的密钥一般为1024位；
2.计算n的欧拉函数φ(n)=（p-1）*(q-1)，随机选择一个整数e，条件是1< e < φ(n)，且e与φ(n)互质；
3. 计算e对于φ(n)的模反元素d，所谓“模反元素”就是指有一个整数d，可以使得ed被φ(n)除的余数为1。
ed ≡ 1 (mod φ(n))，即 ed – 1 = k φ(n)
通过扩展欧几里得算法求解得到d的值作为私钥的一部分。
4.将n和e封装成公钥，n和d封装成私钥，将公钥通过网络传输给客户端，实现RSA密钥的分发，客户端得到RSA公钥后，对AES的密钥进行加密传输给服务器端，即用公钥（n,e）算出m^e≡c (mod n)中c的值；服务器利用私钥解密得到AES的密钥，同样也是利用m^e≡c (mod n)算出c的值即为AES的密钥。

2、主要函数：

int modpow(long long a, long long b, int c)// 计算a^b mod c
{
     int ans=1;
    a=a%c;
    while(b>0)
    {
        if(b%2==1)
            ans=ans*a%c;
        a=a*a%c;
        b=b/2;
    }
    return ans; 
}

/*计算Jacobi符号（a,n）*/
int jacobi(int a, int n) {
    int twos, temp;
    int mult = 1;
    while(a > 1 && a != n) {
        a = a % n;
        if(a <= 1 || a == n) break;
        twos = 0;
        while(a % 2 == 0 && ++twos) a /= 2; /* Factor out multiples of 2 ,减去2的倍数*/
        if(twos > 0 && twos % 2 == 1) mult *= (n % 8 == 1 || n % 8 == 7) * 2 - 1;
        if(a <= 1 || a == n) break;
        if(n % 4 != 1 && a % 4 != 1) mult *= -1; /* Coefficient for flipping，翻转系数 */
        temp = a;
        a = n;
        n = temp;
    }
    if(a == 0) return 0;
    else if(a == 1) return mult;
    else return 0; /* a == n => gcd(a, n) != 1 */
}

/*检查a是否为n的欧拉见证 */
int solovayPrime(int a, int n) {
    int x = jacobi(a, n);
    if(x == -1) x = n - 1;
    return x != 0 && modpow(a, (n - 1)/2, n) == x;
}


/*在3和（n-1）之间找一个随机素数*/
int randPrime(int n) {
    int prime = rand() % n;
    n += n % 2; /* n needs to be even so modulo wrapping preserves oddness */
    prime += 1 - prime % 2;
    while(1) {
        if(probablePrime(prime, ACCURACY)) return prime;
        prime = (prime + 2) % n;
    }
}

/*计算最大公约数*/
int gcd(int a, int b) {
    int temp;
    while(b != 0) {
        temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

/*在3和n-1之间找到随机指数x，使得gcd(x,phi)=1*/
int randExponent(int phi, int n) {
    int e = rand() % n;
    while(1) {
        if(gcd(e, phi) == 1) return e;
        e = (e + 1) % n;
        if(e <= 2) e = 3;
    }
}

/*用扩展欧几里得法计算n^-1 mod m*/
int inverse(int n, int modulus) {
    int a = n, b = modulus;
    int x = 0, y = 1, x0 = 1, y0 = 0, q, temp;
    while(b != 0) {
        q = a / b;
        temp = a % b;
        a = b;
        b = temp;
        temp = x; x = x0 - q * x; x0 = temp;
        temp = y; y = y0 - q * y; y0 = temp;
    }
    if(x0 < 0) x0 += modulus;
    return x0;
}

/*使用公共指数和模量对消息m进行编码，c = m^e Mod n*/
int encode(int m, int e, int n) {
    return modpow(m, e, n);
}

/*用私有指数和公共模量解码密码c，m = c^d Mod n*/
int decode(int c, int d, int n) {
    return modpow(c, d, n);
}

/* 使用私钥（指数、模数)解码给定长度的密码）
 每个加密的数据包应该按照编码消息表示“字节”字符。
 返回的消息大小为len*字节。*/
int* decodeMessage(int len, int bytes, int* cryptogram, int exponent, int modulus) {
    int *decoded = (int *)malloc(len * bytes * sizeof(int));
    int x, i, j;
    for(i = 0; i < len; i++) {
        x = decode(cryptogram[i], exponent, modulus);
        for(j = 0; j < bytes; j++) {
            decoded[i*bytes + j] = (x >> (7 * j)) % 128;
#ifndef MEASURE
            if(decoded[i*bytes + j] != '\0') printf("%c", decoded[i*bytes + j]);
#endif
        }
    }
    return decoded;
}

五、AES算法

实现步骤
1.首先AES加密会把明文按128位16字节切成一段一段的数据，如果数据的最后不够16个字节，则用Padding进行填充；
2.对密钥进行密钥扩展，所谓密钥扩展，就是根据初始密钥生成后面的10轮密钥的操作，在AES-128标准中，一共会对每一组明文进行11轮加密，所以AES会通过一个简单快速的混合操作，根据初始密钥依次生成后面10轮的密钥，每一轮的密钥都是依据上面一轮生成的，在这种模式下，每一轮的密钥都作为下一轮密钥的输入对明文进行异或运算3.初始轮：将128位的明文数据与128位的初始密钥进行异或操作；
4.重复轮：将字节混淆、行移位、列混轮、加轮密钥这四个操作重复执行九轮；
将初始轮得到的状态矩阵经过一个置换盒，会输出一个新的矩阵，我们这里叫它为字节混淆矩阵；
对字节混淆矩阵进行行移位，每一行分别向左挪0、1、2、3个字节，然后重新放一下字节，这样行移位就算完成，得到的新矩阵称之为行移位矩阵；
然后用模不可约多项式将每列混乱，得到一个新的矩阵，我们称之为列混乱矩阵；
在每一轮结束的时候，我们需要把列混乱矩阵和下一轮的密钥做一下异或操作，得到一个新的矩阵，我们这里称之为加轮秘钥矩阵；
128位密钥重复轮重复执行9次：上一轮的加轮密钥矩阵就是下一轮的状态矩阵，拿着这个新的状态矩阵返回去，重复执行字节混淆、行移位、列混乱、加轮密钥这四个操作9次，就会进入加密的最终轮了。
5.最终轮：和重复轮的操作差不多，只是在最终轮我们丢弃了列混乱这个操作，因为我们不会再有下一轮了，所以没必要再进行列混乱，再进行的话也加强不了安全性了，只会白白的浪费时间、拖延加密效率。最终轮结束后，我们就算完成了一次AES加密，就会得到一块明文数据的密文。
因此，每执行一次AES加密，其实内部共进行了11轮加密，包括1个初始轮，9个拥有4个操作的重复轮，1个拥有3个操作的最终轮，才算得到密文。

主要函数

void SubBytes(int * ex_state, int * S_box)                //字节代换函数；
{
 int i,k;
 for(i=0;i<16;i++)
 {
  k=ex_state[i];
  ex_state[i]=S_box[k];
 }
}

void ShiftRows(int * ex_state)     //行移位函数；
{
 int k,temp;
 /*--------------*////第二行；
 temp=ex_state[4];
 ex_state[4]=ex_state[5];
 ex_state[5]=ex_state[6];
 ex_state[6]=ex_state[7];
 ex_state[7]=temp;
 /*-------------------*////第三行；
 temp=ex_state[8];
 ex_state[8]=ex_state[10];
 ex_state[10]=temp;
 temp=ex_state[9];
 ex_state[9]=ex_state[11];
 ex_state[11]=temp;
 /*-------------------*///第四行；这里的话就需要两个缓存来辅助了；
    temp=ex_state[13];
 ex_state[13]=ex_state[12];
 k=ex_state[14];
 ex_state[14]=temp;
 temp=ex_state[15];
 ex_state[15]=k;
 ex_state[12]=temp;
 /*--------------------*/ 
}

void AddRoundKey(int * ex_state, int * RoundKey)        //密钥加函数；
{
 int i;
 for(i=0;i<4;i++)
 {
  ex_state[i]^=RoundKey[i];
  ex_state[i+4]^=RoundKey[i+4];
  ex_state[i+8]^=RoundKey[i+8];
  ex_state[i+12]^=RoundKey[i+12];
 }
}

/*----------------------------------------------------*////以下三个函数都属于MixColumns函数范畴；
int xtime(int n)   //!> 用来把这个数*0x02;
{
 int temp;
 temp=n<<1;
 if(n&0x80)
 {
  temp=temp^0x1b;
 }
 return temp;
}
 
int mixcolumn(int m,int n)
{
 int temp;
 for(temp=m,m=0;n;n=n>>1)
 {
  if(n&1)
  {
   m=m^temp;
  }
  temp=xtime(temp);
 }
 return m&0xff;
}
void MixColumns(int * ex_state)     //列混合函数；还需要一个mix()函数来帮助这个函数;
{
 int i;
 int p_state[16]={0};             //定义一个新的p-state来记录输入的ex_state,以免ex_state发生变化时，p-state还能使用原先的那个ex_state;
 for(i=0;i<16;i++)
  p_state[i]=ex_state[i];
 for(i=0;i<16;i++)
 {
  if(i>=0&&i<4)
  {
   ex_state[i]=mixcolumn(ex_state[i],0x02)^mixcolumn(ex_state[i+1*4],0x03)^p_state[i+2*4]^p_state[i+3*4];
  }
  else if(i>=4&&i<8)
  {
   ex_state[i]=p_state[i-4]^mixcolumn(ex_state[i],0x02)^mixcolumn(ex_state[i+1*4],0x03)^p_state[i+2*4]; 
  }
  else if(i>=8&&i<12)
  {
   ex_state[i]=p_state[i-2*4]^p_state[i-1*4]^mixcolumn(ex_state[i],0x02)^mixcolumn(ex_state[i+1*4],0x03);
  }
  else if(i>=12&&i<16)
  {
   ex_state[i]=mixcolumn(p_state[i-3*4],0x03)^p_state[i-2*4]^p_state[i-1*4]^mixcolumn(ex_state[i],0x02);
  }
 } 
 }

void Round(int * ex_state, int * S_box,int * RoundKey)     //轮函数;
{
 SubBytes(ex_state,S_box);
 ShiftRows(ex_state);
 MixColumns(ex_state);
 AddRoundKey(ex_state,RoundKey); 
}
void Final_Round(int * ex_state, int * S_box,int * RoundKey)     //最后轮函数；
{
 SubBytes(ex_state,S_box);
 ShiftRows(ex_state);
 AddRoundKey(ex_state,RoundKey); 


void RotByte(int * temp)     //移位函数（作为Key_Schedule函数的辅助函数）
{
 int j=0;
 j=temp[0];         //对它进行移位；
 temp[0]=temp[1];
 temp[1]=temp[2];
 temp[2]=temp[3];
 temp[3]=j;
}
void Key_Schedule(int * cphkey,int RoundKey[10][16],int * S_box,int * Rcon) //生成轮密钥的函数；
{
 int i,j,m,n;
 int temp_first[4]={0};    
 int temp_last[4]={0};   
 for(i=0;i<4;i++)          //!>把最后一列的数据赋给temp_last数组；
 {
  temp_last[i]=cphkey[i*4+3];
 }
 RotByte(temp_last); //移位
 for(i=0;i<4;i++)   //进行S_box转换；
 {
  temp_last[i]=S_box[temp_last[i]];
 }
 for(i=0;i<4;i++)    //把第一列的数据赋给temp_first数组；
 {
  temp_first[i]=cphkey[i*4];
 }
 for(i=0;i<4;i++)    //生成第一轮的RoundKey;
 {
  RoundKey[0][i*4]=temp_first[i]^temp_last[i]^Rcon[i*10];  //!>注意Rcon为*10；
 }
 for(i=1;i<4;i++)
 {
  for(j=0;j<4;j++)
  {
   RoundKey[0][j*4+i]=RoundKey[0][j*4+i-1]^cphkey[j*4+i];
  }
 }
 for(i=1;i<10;i++)
 {
  for(m=0;m<4;m++)          //把最后一列的数据赋给temp_last数组；
  {
   temp_last[m]=RoundKey[i-1][m*4+3];
  }
  RotByte(temp_last); //移位;
  for(m=0;m<4;m++)   //进行S_box转换；
  {
   temp_last[m]=S_box[temp_last[m]];
  }
  for(m=0;m<4;m++)  
  {
   RoundKey[i][m*4]=RoundKey[i-1][m*4]^temp_last[m]^Rcon[m*10+i];
  }
  for(j=1;j<4;j++)
  {
   for(n=0;n<4;n++)
   {
    RoundKey[i][n*4+j]=RoundKey[i][n*4+j-1]^RoundKey[i-1][n*4+j];
   }
  }
 }
}
void Aes_Encrypt(int * ex_state, int * S_box,int *cphkey,int RoundKey[10][16]) //加密函数；
{
 int i,j;
 Key_Schedule(cphkey,RoundKey,S_box,Rcon);
 AddRoundKey(ex_state, cphkey);
 for(i=0;i<9;i++)
 {
  Round(ex_state,S_box,RoundKey[i]);
 
 Final_Round(ex_state, S_box,RoundKey[9]);
}

由于AES算法是对称加密算法所以解密过程其实是加密的逆操作，轮密钥加由于是异或过程，两次异或就可以得到原来的值，其他的几个步骤只要按顺序逆推就好了。发送其他信息也是同样的原理只需要改明文数组就好了。

最终结果图如下所示：
在这里插入图片描述

五、总结

这次实验对我来说是不小的挑战，考试周和毕业实习让能研究实验的时间少了很多，所幸之前学过网络编程、应用密码学、信息安全数学基础等课程才能把实验做成这样。实验虽然大体做完但是还是有部分内容存在问题，例如经常编译后会出现乱码，怀疑是利用指针和TCP传输时造成的内存溢出，但是还没有解决。

D3sT1ny622
关注
专栏目录
端到端安全的视频会议密钥分发解决方案（附实验报告以及python源代码）
lunan的博客
07-15 1036
本团队针对视频应用环境，设计了一套高效的视频会议密钥分发方案。 文章目录本团队针对视频应用环境，设计了一套高效的视频会议密钥分发方案。核心流程：功能目标：安全目标的实现：潜在性问题解决方案：以下是我们小组的一个实验报告的部分截图供大家参考 核心流程：  会议创建：首先会有一个会议创始人即会议主持人，在会议创建时候，创始人会自定义会议的密码，以及输入参会人员的用户名，这些用户名也就是将要加入会议人员的名单。  数据库初始化：服务器会在它的数据库中存储这些用户名，存储时是采用加密存储的模式，数据库中的数据都
密码学与网络安全 - 13 数字签名 & 14 密钥的管理和分发
weixin_51487151的博客
05-14 1071
13 数字签名 数字签名前面已经讲过很多次了，我们再来详细的看一下 13.1 数字签名概述 13.1.1 特征 消息认证可以保护消息不受第三方攻击，但是不能保证交易双方的错误 必须能验证签名者、签名日期和时间 必须能认证被签的消息内容 由第三方仲裁以解决争执 13.1.2 攻击和伪造 唯密钥攻击，破解私钥 已知消息攻击，用公钥和合法签名破解 一般选择消息攻击，基于消息攻击 定向选择消息攻击，可以轮训A 何为成功破解 完全破译 通用伪造；能伪造出合法签名 选择伪造；伪造出对特定信息的合法签名 存在性
14.1 基于对称加密的对称密钥分发
tang7mj的博客
01-07 2423
对称加密是一种加密方法，其中加密和解密使用相同的密钥。由于其加解密效率高，它广泛用于文件加密、安全通信等场景。对称密钥分发是对称加密实现安全通信的关键。通过理解和实施有效的密钥分发机制和安全策略，我们可以在数字世界中更安全地传递信息。随着技术的发展，新的密钥分发方法和安全措施将不断涌现，进一步加强通信的安全性。在进入这一章的学习之前，让我们明确我们希望通过本章的学习达到的目标。论述密钥分层的概念：理解密钥如何被分层组织以及这种分层结构如何帮助有效地管理密钥。理解利用非对称加密分配对称密钥的技术问题。
对称密码中的密钥是如何实现安全配送的？
最新发布
chinansa的博客
09-19 566
接收方使用自己的私钥对加密的对称密钥进行解密，得到对称密钥后，再使用对称密钥对密文进行解密。KDC 根据双方的身份和安全策略，生成一个会话密钥，并使用双方的公钥或预先共享的密钥对会话密钥进行加密，然后分别发送给通信双方。例如，在电子邮件加密中，发送方可以使用接收方的公钥对对称密钥进行加密，然后将加密后的对称密钥和用对称密钥加密的邮件内容一起发送给接收方。这样，A 和 B 就协商出了一个相同的共享密钥 K，该密钥是椭圆曲线上的一个点，可以通过某种方式转换为一个整数作为实际使用的密钥。
密钥分配方案
z869123342的博客
12-30 3472
为了解决秘密密钥建立问题而提出了三种方案：1.密钥预分配（KPS）2.会话密钥分配（SKDS）3.密钥协商（KAS）。
linux秘钥分发
weixin_30827565的博客
08-31 415
秘钥分发 ssh-copy-id -i /root/.ssh/id_rsa.pub "-p 9000 root@192.168.1.100" 传送文件 scp -P9000 -rp 2018-08-29-2_slow.log root@192.168.1.100:/data/mysql 转载于:https://www.cnblogs.com/xiaoyaoren/...
密钥分配方案简述 集中式和分布式
yooppa的博客
04-28 2511
集中式： ①A→KDC：IDA∥IDB∥N1 A向KDC发出会话密钥请求。请求的消息由两个数据项组成：一是A和B的身份IDA和IDB，二是本次业务的唯一标识符N1，每次请求所用的N1都应不同，常用一个时间戳、一个计数器或一个随机数作为这个标识符。 ② KDC→A：EKa[Ks∥IDA∥IDB∥N1∥EKb[Ks∥IDA]]。 KDC对A的请求发出应答。应答是由加密Ka加密的信息，因此只有A才能成功地对这一信息解密，并A相信信息的确是由KDC发出的。 ③ A→B：EKb[ Ks∥IDA]。 A收到KDC响应的
安全传输与身份认证
albon arith
09-08 1655
什么是 TLS 安全传输呢？ 传输层安全性协议（英语：Transport Layer Security，缩写作TLS），及其前身安全套接层（Secure Sockets Layer，缩写作SSL）是一种安全协议，目的是为互联网通信提供安全及数据完整性保障。 TLS 在传输数据之前有一个握手阶段，利用密钥交换算法 RSA 和 Diffie-Hellman 来交换数据密钥，然后在传输数据时就可以使用该...
centos脚本实现密钥分发
guchengxinfen的博客
10-30 805
ssh(secure sHell)协议 ssh(secure sHell)协议：实现数据在网络上加密传输 加密方式：有RSA和DSA两种方式 RSA加密算法是一种非对称加密算法，RSA公开密钥密码体制。所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥，是一种“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。 DSA(Digital Signature Algorithm)...
移动代理安全：密钥传播与关键组件
本文主要探讨了移动代理的安全性问题，特别是在移动代码环境中，针对主机安全性（保护主机不受恶意代理攻击）和代码安全性（保护代理免受恶意平台侵害）两个关键方面。作者引用了相关文献，指出移动代理作为一种潜在...
基于对称加密的密钥分配和Kerberos认证
Hsuyeungpeng的专栏
09-16 7955
基于对称加密的密钥分配和Kerberos认证 对于对称加密，加密双方必须共享同一密钥，而且必须保护密钥不被他人读取。此外，常常需要频繁地改变密钥来减少某个攻击者可能知道密钥带来的数据泄露。因此，任何密码系统的强度都取决于密钥分发技术。密钥分发技术指的是将密钥传递给希望安全交换私密数据的双方，且不允许其他人看见密钥的方法。 密钥分发能用很多方法实现，对 A 和 B 双方，有下列选择： A 能...
SHamir分发密钥机制
11-10
关于密码学的密钥分发机制，不过我觉得不是一个好的方案，不如多重签名
基于RSA通信密钥分发的加密通信
07-09
基于RSA通信密钥分发的加密通信，采用pycrypto中的RSA、AES模块实现
应用密码学课程设计 密钥分发
weixin_45513552的博客
12-01 1615
密钥分发的简单流程展示
Linux下实现SSH Key 批量分发管理
飞翔的荷兰人
11-15 2020
1）首先先实现ssh免密码登陆，可参考http://blog.csdn.net/qq_30256711/article/details/78537472 2) 编辑分发脚本fenfa.sh #!/bin/bash file="$1" remotedir="$2" . /etc/init.d/functions if [ $# -ne 2 ] then   echo "
LINUX用户建立秘钥认证实现SHELL脚本管理,分发,部署
weixin_33877885的博客
06-15 81
环境：sshserver:192.168.100.29server.example.comsshclient:192.168.100.30client.example.com通过root用户建立秘钥认证实现SHELL脚本管理,分发，部署首先client端创建秘钥对，并将公钥分发给需要登录的SSH服务端注：公钥相当于锁，私钥相当于钥匙，我们这里相当于在客户端创建...
数据安全常见加密方法及密钥的安全传输和安全存储
2301_77455673的博客
12-02 1037
密钥管理分层管理机制将密钥分为三层，即根密钥、密钥加密密钥和工作密钥 下层密钥为上层密钥提供加密保护，采用分层的密钥结构有助于密钥的管理满足本规范的要求 工作密钥 工作密钥对本地保存的敏感数据和需要在不安全信道上传输的数据提供机密性、完整性保护，还可提供认证和签名等密码学服务。根密钥 位于密钥管理分层结构的最底端，用于对上层密钥（如密钥加密密钥）的机密性进行保护 规则 密钥分层管理至少选择两层结构进行管理 密钥的分层管理机制最少把密钥分为两层，即：根密钥和工作密钥，根密钥为工作密钥提供加密保护。
(Python)编写一段程序，实现两个主机之间的密钥分发和加密传输（RSA & AES）
coderge's CSDN Blog.
04-06 3187
1 设计要求 编写一段程序，实现两个主机之间的密钥分发和加密传输。 要求： （1）用RSA算法实现两个主机之间的密钥分发，分发的密钥是“12345678”； （2）用分发的密钥和AES加密算法，实现两个主机之间的加密数据传输，传输的数据是“NPU”； （3）两个步骤在程序中自动执行完，无手动参与；程序可以在同一台主机上完成，但数据必须经过网络传输（可以本地发送，本地接收）； （4）RSA和AES算法必须是源码编译得到，不能直接用编译过的库文件；RSA和AES算法的源码可以来自于网络或其他任意渠道
ssh-keygen产生公钥与私钥对，及密钥分发，ssh远程执行常用命令方法，和如何防止SSH登录入侵或被破解
阿啄debugIT
01-08 7101
前言 SSH是安全的加密协议，用于远程连接Linux服务器，默认端口是22，安全协议版本是SSH2 。 SSH原理 SSH(远程连接工具)连接原理：ssh服务是一个守护进程(demon)，系统后台监听客户端的连接，ssh服务端的进程名为sshd，负责实时监听客户端的请求(IP 22端口)，包括公共秘钥等交换等信息。 ssh服务端由2部分组成： openssh(提供ssh服务)、openssl(提供加密的程序)，主要功能是提供SSH连接和作为SFTP服务器。 ssh的客户端：包含ssh连接命令和远.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值