百度一下 藏锋者 就能快速找到本站! 每日资讯归档 下载藏锋者到桌面一键访问

当前位置:主页 > 网络安全 > 编程实现Kerberos安全协议解析

编程实现Kerberos安全协议解析

所在栏目:网络安全 时间:04-12 20:08 分享:

本文将向大家介绍一种网络安全认证协议——Kerberos安全协议的基本原理,并通过编程实现向大家展示如何借助编码设计,简单实现此协议。本文的读者可以是信息安全科班出身的学生但又未涉及到Kerberos或者对安全协议感兴趣的任何读者,只要具有一定的安全编程知识即可。

其实安全协议的研究很早就存在,只是以前国内的研究者比较少,也没有开设信息安全专业的相关课程,如密码学等课程。直到网络信息高速发展的今天,大量的信息非法盗取、恶意篡改、木马、病毒像幽灵般穿梭在网络中时,大家才开始紧密的关注网络安全技术领域,各大高校也都开始纷纷设立信息安全专业。从信息通信专家Shannon发表《保密系统的信息理论》文章开始,基本上就掀起了信息通信保密学的研究热潮。OK,不多说了,下面直接切入正题。

Kerberos安全认证协议基本框架

Kerberos安全认证协议是由MIT的Athena计划的认证服务而开发的,并广泛的应用于开放式的网络环境中,为通信双方提供很好的双向认证服务,在客户与服务器之间构筑了一个安全桥梁,要求用户对每个向服务器提交的服务请求及其权限,必须预先经过第三方认证中心服务器的认证后,才被允许执行。换句话说,Kerberos的整体设计方案是完全基于协议可信任的第三方认证服务,客户和服务器均信任Kerberos认证服务器的认证。现在我们来揭开它的基本原理。

一个Kerberos环境包含一台Kerberos服务器、若个客户端以及一些应用服务器。Kerberos服务器将客户端用户的用户名及口令均存放在它的数据库中。应用服务器和所有的客户都必须在初始化阶段到Kerberos服务器中注册。基本框架如图1所示。

Kerberos安全认证协议基本结构

图1 Kerberos安全认证协议基本结构

 Kerberos双向认证过程与逆向推理分析

1)Client→AS:客户端向认证服务器发送认证请求KRB_AS_REQ,其内容是:{ c,Tgs,TS1}。其中,c表示客户标识,告诉AS 客户端身份,便于AS到数据库中查询c的密钥; Tgs是TGS服务器标识,告诉AS用户请求访问的TGS;TS1用于使AS能验证客户端时钟是否与AS时钟同步,其实也就是一个时间戳的概念,给AS作参考判断来自Client端的消息是否已经过期。

2)AS→Client:向客户端发送认证回应KRB_AS_REP,其内容为{K(c,Tgs),TS2,lifetime,Tickets_Tgs}Kc。K(c,Tgs)是由AS随机产生的一个密钥,用于Client与TGS共享的一个会话私钥。TS2是票据发放的时间戳;Tickets_Tgs是AS发给Client的用于访问TGS的票据授权票据;有了此票据后,用户就可以向TGS申请任意的应用服务器,而不需要每次重复输入Client端的登录密钥。它定义为:Tickets_Tgs={ K(c, tgs),c,c_mac,Tgs,TS2,lifetime2} Ktgs。其中Tickets_Tgs已经采用TGS的私钥加密。这部分其实在Kerberos V5版已经作了修改,因为Tickets_Tgs已经采用TGS的私钥加密,故没有必要采用客户端的私钥再次加密。

3)C→TGS:Client在第2步中获得AS认证,并取得票据授权票据后,Client即可向服务授权服务器(TGS)申请服务票据。发送的消息定义为KRB_TGS_REQ={AppServ, Tickets_Tgs, Authen_info},其中AppServ是用户期望访问的服务器;Authen_info是发送的一条认证消息,用于确认发送票据Tickets_Tgs的用户合法。定义为:Authen_info={ c,c_mac,TS3 }K(c,tgs)。

这里我们可以假设,若不发送Authen_info消息,则当Cracker截获了Tickets_Tgs票据,同时向TGS发送此票据,那么TGS只针对此Tickets_Tgs票据是无法判断此票据是否真正来自合法客户端,而验证器消息Authen_info则正好解决了此问题,当TGS收到Client发来的Req请求服务授权票据时,TGS首先会采用自己的私钥Ktgs解密Tickets_Tgs,获取AS为Client和TGS双方随机产生的共享密钥K(c,tgs),然后利用此密钥解密Authen_info消息,提取出客户端用户名及其MAC地址,将这些同Tickets_Tgs包含的C和c_mac进行比较,若一致,则断定此次Req来自合法客户端。

4)TGS→C:当TGS验证Req来自合法Client时,则构造消息KRB_TGS_REP={K(c,s),AppServ,TS4,S_Tickets}K(c,tgs)发送到Client端。其中K(c,s)是TGS随机生成的密钥,为Client端和AppServ共享的会话密钥。S_Tickets为服务授权票据,定义为S_Tickets={K(c,s),c,c_mac,AppServ,TS4,lifetime}Ks;采用AppServ的私钥Ks加密此票据。

看到这里,仔细阅读的读者可能会想,为什么Kerberos协议会介入一个应用服务器,当客户端送来合法的票据后,直接由TGS转入到相应的AS处理不就可以了吗?大家应该都看过《无间道》这部影片吧,警方中有犯罪团伙的卧底,同样犯罪分子中也有警方的卧底。给一个场景:若你一直对公司领导忽视你的才能,长期不提拔而感到懊恼,想跳槽到其它公司去,现需要打印一份求职简历,请求打印服务器资源,向TGS发送Req,但TGS却直接将此Req转到了老总办公室的打印机上打印,这显然不是你想要的。其实这就是安全协议中经常涉及到的双方认证协议。如何设计一种安全协议,使得双方都能在远端彼此信任。

Client端在给TGS发送Req时,并不急于将需要服务的内容传送给TGS,而是等待TGS正常解密此消息,并产生KRB_TGS_REP应答消息返回给Client端,让Client端确认TGS为合法服务器。

5)C→AppServ:当客户端收到TGS传送来的服务授权票据后,Client端直接将此票据和验证器发送给应用服务器AppServ即可。KRB_APPSERV_REQ={S_Tickets, Authent_infor}Kc,这里的Authent_info消息需要采用会话密钥K(c,s)加密。

6)AppServ→C:应用服务器再次发送确认消息给Client端,告知对方它期待的服务器已收到它的服务请求。此时Client端与应用服务器即实现了可信的双方认证。

讲了这么多,若仍然存在对此协议不太清楚的读者,可以参考我的博客,里面转载了MIT为了帮助更多的读者很好的理解Kerberos协议设计的一篇精彩对话,看完以后相信你会对这个协议的设计有进一步的认识。OK,下面我们来编码设计实现此协议吧。

Kerberos协议简单编程实现

从前面设计的加密算法大家应该可以推测出来,采用的肯定是私钥加密算法,即对称加密算法,因为协议中涉及到Client和TGS、AppServ共享会话密钥的情形,故采用的是对称加密算法。这里我们采用CBC模式的DES加密算法,为了算法的安全强度性,大家也可以采用triple-des或者AES加密算法。现简要的给出CBC模式下的DES加密算法:

void DES::Des(int mode, unsigned char input[], unsigned char output[])//加密函数入口
{
int i;
IPConvert1(input,Xmatrix);//初始转换,打乱顺序
Left=&Xmatrix[0];//将比特块分为两部分
Right=&Xmatrix[32];
for(i=1;i<=16;i++) {//16轮循环
BackupRight(RightT,Right);//将明文矩阵后半部分备份
if(mode==0)//加密与解密只是用的密钥顺序不一样
ProductTransform(Right,SubKey[i-1],R_F);
else if(mode==1) ProductTransform(Right,SubKey[16-i],R_F);
//第i-1轮明文的前半部分与F函数的结果做异或运算,其结果为第i轮明文矩阵的后半部分
Xor32(Right,Left,R_F);
CopyRtoL(Left,RightT);//将明文矩阵第i-1轮的后半部分复制至第i轮的前半部分
}
ConnectLeftRight(M_connect,Right,Left);//将两部分比特块合在一起
IPConvert2(M_connect,output);//末尾转换,还原顺序
}

void CKerberos_servDlg::DES_CBC_Encrypt(char *theKey,char *theInputFile,char *theOutputFile, int fsize)  //对文件进行加密
{
unsigned char in[64],out[64],key[64]; //输入64比特明文,输出64比特密文
unsigned char tOut,ch[8],ck; //tOut用于向输出文件写数据,ch数组用于读取每64比特
int i,j; //i,j作循环之用,to8用于判断数据块有没有8字节,即64比特
unsigned long int block=0,last=0; //last文件余数,block文件整块数
unsigned int theInFilePos=0,theOutFilePos=0; //输入输出文件在内存中的读写指针位置
DES a_des;
for(i=0;i<8;i++) {
//从8字节的密钥转化为64比特key
ck=theKey[i];
for(j=7;j>-1;j--){
key[8*i+j]=ck,ck>>=1;
}
}

a_des.GetSubKeys(key); //获取16轮迭代的每轮子密钥
block = fsize;
last = block % 8;
block /= 8;
//这里我做了一个处理,将文件大小存放到了密文的前5字节处。为了方便文件的解密操作,将每8字节的块暂存到前4字节中,对8字节取模的余数存放到第5字节处
((unsigned long int*)theOutputFile)[theOutFilePos]=block; theOutFilePos+=4;
theOutputFile[theOutFilePos++]=last;
SetIV(out);//设置初始向量
while(block>0){
for(i=0;i<8;i++)//读取64比特
ch[i]=theInputFile[theInFilePos++];
for(i=0;i<8;i++){//分解64比特位,存储至in数组中
ck=ch[i];
for(j=7;j>-1;j--){
in[8*i+j]=ck&1,ck>>=1;
}
}
Xor_CBC(in,out); //CBC
a_des.Des(0, in, out);//按mode模式对in加密或解密处理,其结果保存在out中
for(i=0;i<8;i++){//解读out,将结果写到输出文件中去
tOut=(out[8*i])*128+(out[8*i+1])*64+(out[8*i+2])*32+(out[8*i+3])*16+(out[8*i+4])*8+(out[8*i+5])*4+(out[8*i+6])*2+out[8*i+7];
theOutputFile[theOutFilePos++]=tOut;
}
block--;
}
if(last!=0) {//存在数据块不足64比特
for(i=0;i<last;i++)
ch[i]=theInputFile[theInFilePos++];
for(i=0;i<last;i++){
ck=ch[i];
for(j=7;j>-1;j--){
in[8*i+j]=ck&1,ck>>=1;
}
}
Xor_CBC(in,out);
a_des.Des(0,in,out);
for(i=0;i<8;i++){
tOut=(out[8*i])*128+(out[8*i+1])*64+(out[8*i+2])*32+(out[8*i+3])*16+(out[8*i+4])*8+(out[8*i+5])*4+(out[8*i+6])*2+out[8*i+7];
theOutputFile[theOutFilePos++]=tOut;
}
}}

对DES的更深入理解可以参考本文所附的基于CBC模式的DES加密算法C语言实现版本,这里就不再多说了。要编程实现Kerberos协议,肯定要涉及到Socket编程了,我们可以采用面向连接的TCP协议实现。

首先,Client端构造KRB_AS_REQ消息发送给AS端。

void CKerberos_clientDlg::OnSendReqToAS()
{
char req_buf[50] = {0};
char dest_addr[] = "127.0.0.1";
short port = 6000;
SYSTEMTIME sys_time; //变量声明
GetSystemTime(&sys_time); //取得现在的日期时间
sprintf(req_buf, "Name:kevin\\Tgs:mailServ\\Req:AS");
sendMsgToAs(req_buf, dest_addr, port);
}

AS解析发送的Req消息,访问数据库查阅Client注册时提供的私钥和Client请求的TGS的私钥,最后构造KRB_AS_REP消息。这里我们采用V5版本的说明,不再对Ktgs加密后生成的票据授权票据再次实施加密。编程实现上,我采用先将Tickets_Tgs和{k(c,tgs),tgs,TS2,lifetime}Kc密文写入本地文件,然后再通过TCP协议发送到Client端。相关代码如下:

void CKerberos_servDlg::Translate_Msg(char *recv_buf, char *client_addr)
{
char *p, *q, temp[10]={0};
char keys_client_tgs[300], tickets[300];
char clientName[30], tgs[30];
p = strstr(recv_buf, "Req:");
strcpy(temp, p+4);
if(!strcmp(temp, "AS")) {
//***获取客户端用户名********//
memset(temp, 0, sizeof(temp));
p = strstr(recv_buf, "Name:");
q = strstr(recv_buf, "Tgs:");
strncpy(temp, p+5, q-p-6);
memset(clientName, 0, sizeof(clientName));
strcpy(clientName, temp);

//*******获取Tgs服务器**********//
memset(temp, 0, sizeof(temp));
p = strstr(recv_buf, "Tgs:");
q = strstr(recv_buf, "Req:");
strncpy(temp, p+4, q-p-5);
memset(tgs, 0, sizeof(tgs));
strcpy(tgs, temp);

//**访问数据库查询Client私钥和TGS私钥*****//
char Kc[9] = "12345678";
//客户端用户在AS服务器登记的密钥
char Key_Tgs[9] = "23456789";
//TGS服务器在AS服务器登记的密钥

//**构造随机密钥(Client和TGS共享的会话密钥)*****//
srand(GetTickCount());
char keys_client_tgs[8] = {0};
char buf[2];
for(int i=0;i<8;i++){
memset(buf, 0, sizeof(buf));
sprintf(buf, "%d", rand() % 10);
strcat(keys_client_tgs, buf);
}

SYSTEMTIME sys_time; //变量声明
GetSystemTime(&sys_time); //取得现在的日期时间
char time_stamp[30] = {0};
sprintf(time_stamp, "%4d-%2d-%2d %2d:%2d:%2d", sys_time.wYear,sys_time.wMonth,sys_time.wDay,sys_time.wHour,sys_time.wMinute,sys_time.wSecond);
unsigned int lifetime = 240;  //定义有效期为4小时
memset(tickets, 0, sizeof(tickets));
sprintf(tickets, "K(c,tgs):%s\\C:%s\\AD(c):%s\\tgs:%s\\TS:%s\\lifeTime:%d",
keys_client_tgs, clientName, client_addr,tgs, time_stamp, lifetime);
int Tgs_ticket_len = strlen(tickets);
char *Tickets_Tgs = new char[Tgs_ticket_len+5]; //多申请5字节存放明文文件大小
memset(Tickets_Tgs, 0, sizeof(Tickets_Tgs));
((unsigned int*)Tickets_Tgs)[0] = Tgs_ticket_len; //前4个字节标定文件的大小
//调用CBC模式的DES加密算法,加密文件使其成为一个票据授权票据
DES_CBC_Encrypt(Key_Tgs, tickets, Tickets_Tgs, Tgs_ticket_len);

//构造{k(c,tgs),tgs,TS2,lifetime}消息,并用Kc私钥加密
char AS_Rep_P[300];
sprintf(AS_Rep_P, "K(c,tgs):%s\\tgs:%s\\TS:%s\\lifetime:%d",
keys_client_tgs, tgs, time_stamp, lifetime);
int AStoClient_len = strlen(AS_Rep_P);
char *AS_Rep_S = new char[AStoClient_len+5];
memset(AS_Rep_S, 0, sizeof(AS_Rep_S));
((unsigned int*)AS_Rep_S)[0] = AStoClient_len;
DES_CBC_Encrypt(Kc, AS_Rep_P, AS_Rep_S, AStoClient_len);
//将这些信息写入到本地文件
FILE *fp = fopen("d:\\AStoClient.txt", "w+");
if(!fp){
printf("open file failure!\n");
return;
}
fwrite("Client:", sizeof(char), strlen("Client:"), fp);
fwrite(AS_Rep_S, sizeof(char), AStoClient_len+5, fp);
fwrite("\r\nTickets:", sizeof(char), strlen("\r\nTickets:"), fp);
fwrite(Tickets_Tgs, sizeof(char), Tgs_ticket_len+5, fp);
fwrite("\\Rep:AS", sizeof(char), strlen("Rep:AS"), fp);
fclose(fp); return;
}
}

构造好如图2所示的消息后,即可向Client端发送此KRB_AS_REP消息了。

构造好的KRB_AS_REP消息

图 2 构造好的KRB_AS_REP消息

注意,这里最好不要使用sprintf、strncpy等函数对密文字符串格式化及拷贝等操作,因为密文字符串中极有可能存在空字符,若存在会导致忽略空格后面的字符,使得发送Client端的密文无法正常解密,进而使得Client端将合法的AS或者TGS认为非法端,而做出放弃再次发出Req的举动。

OK,现在AS可以将AStoClient.txt文件发送到Client端了。文件之间的发送大家应该会吧,还是采用TCP协议实现,代码如下:

1)AS端的实现

FILE *fp = fopen("d:\\AStoClient.txt", "rb");
if(!fp){
printf("open file failure!\n"); return;
}
fseek(fp, 0, SEEK_END); //将文件指针移动到末端,获取文件大小
unsigned int fsize = ftell(fp);
char f_size[4] = {0}; //用于存放文件大小
*((unsigned int*)&f_size[0]) = fsize;
send(sockClient,f_size,4,0); //首先将文件大小发送到客户端
char buff[1024] = {0};
fseek(fp, 0, SEEK_SET); //文件指针重新回到文件头位置
unsigned int readbytes = 0;
while(fsize > 0){
readbytes = fread(buff, sizeof(char), 1024, fp); //每次读取1024字节
send(sockClient,buff,readbytes,0); //将读取到得字节发送到Client端
fsize -= readbytes;
} fclose(fp);

2)Client端的实现
//**接收AS服务器发送来的票据授权票据文件**//
FILE *fp;
fp = fopen("D:\\mytext.txt", "w+");
if(!fp){
printf("file open failure!\n"); return;
}
char f_size[4] = {0},buff[1024] = {0};
int fsize,  recvbytes;
recv(sockClient, f_size, 4, 0); //接收文件大小
fsize = *((int*)&f_size[0]);
while(fsize>0){
//根据文件大小与每次循环接收到的字节数来判断循环次数
recvbytes = recv(sockClient, buff, 1024, 0);
//将接收到的字节写入到Client端的文件中,便于调用Translate_ASMsg()函数进一步解析
if(!fwrite(buff, sizeof(char), recvbytes, fp)){
printf("write failed!\n");
}
fsize -= recvbytes;
}
fclose(fp);
Translate_ASMsg();
//客户端解析AS发送来的票据授权票据消息

当文件成功接收后,Client端就可以在本地解析此文件了,将文件中的票据授权票据Tickets_tgs和{k(c,tgs),tgs,TS2,lifetime}kc正确分离出来,并调用DES_CBC_Decrypt()函数解密{k(c,tgs),tgs,TS2,lifetime}kc消息,因为Client在向AS注册时已经和AS共享了自己的私钥Kc。正确解密后,则可在此消息中提取出AS为Client和TGS随机产生的共享会话密钥K(c, tgs),进而构造发往TGS的KRB_TGS_REQ = {AppServ, Tickets_Tgs, Authen_info}消息。相关实现代码如下:

FILE *fp;
fp = fopen("D:\\AStoClient.txt", "rb");
if(!fp){
printf("file open failure!\n"); return;
}
//**提取AS发给client端的加密消息***
char line[300] = {0};
fgets(line, 300, fp);
if(strstr(line,"Client:")){
memset(line, 0, sizeof(line));
fseek(fp, strlen("Client:"), SEEK_SET);
fgets(line, 300, fp);
}
char Kc[9] = "12345678";
//客户端用户在AS服务器登记的密钥。从密文中提取出加密前的明文大小含8字节的块数,这就是为何在加密前需要对密文数组多申请5个字节空间的缘由,方便后面的解密操作,当然这也必须是加密双方协商后的结果,否则解密方不知道你所做的处理
int block = ((unsigned int *)line)[0];
int last = line[4]; //文件大小对8字节取余的结果
int fsize = block * 8 + last; //计算出文件大小
char *ASToC_Plain = new char[fsize];
memset(ASToC_Plain, 0, sizeof(ASToC_Plain));
//调用CBC模式的DES加密算法解密{K(c,tgs), tgs, TS2, lifetime}
DES_CBC_Decrypt(Kc, line, ASToC_Plain);

//**从client端的加密消息中提取tgs和客户端共享的密钥k(c,tgs)**//
char *p, *q;
char key_c_tgs[9] = {0};
p = strstr(ASToC_Plain, "K(c,tgs):");
q = strstr(ASToC_Plain, "tgs:");
memcpy(key_c_tgs, p+9, q-p-10);

//**构造验证器消息{c,ADc,TS3}K(c,tgs)**//
SYSTEMTIME sys_time; //变量声明
GetSystemTime(&sys_time); //取得现在的日期时间
char time_stamp[30] = {0};
sprintf(time_stamp, "%4d-%2d-%2d %2d:%2d:%2d", sys_time.wYear,sys_time.wMonth,
sys_time.wDay,sys_time.wHour,sys_time.wMinute,sys_time.wSecond);
char Authen_info[100];
memset(Authen_info, 0, sizeof(Authen_info));
sprintf(Authen_info, "Name:kevin\\c_ip:127.0.0.1\\TS:%s", time_stamp);
int Authen_info_len = strlen(Authen_info);
char *Authen_info_S = new char[Authen_info_len+5];
memset(Authen_info_S, 0, sizeof(Authen_info_S));
((unsigned int*)Authen_info_S)[0] = Authen_info_len;
//采用密钥K(c,tgs)加密验证器消息
DES_CBC_Encrypt(key_c_tgs, Authen_info, Authen_info_S, Authen_info_len);

//**提取AS发给Client端的票据授权票据**//
memset(line, 0, sizeof(line));
fgets(line, 300, fp);
if(strstr(line,"Tickets:")){
memset(line, 0, sizeof(line));
fseek(fp, strlen("Tickets:"), SEEK_CUR);
fgets(line, 300, fp);
}
char tgs_tickets[300] = {0};
memcpy(tgs_tickets, line, strlen(line)-7); //获得票据
fclose(fp);
fp = fopen("D:\\CToTgs.txt", "w+");
if(!fp){
MessageBox("file open failure!\n");
return;
}
fwrite("AppServ:FTPServ", sizeof(char), strlen("AppServ:FTPServ"), fp);
fwrite("\r\nTickets:", sizeof(char), strlen("\r\nTickets:"), fp);
fwrite(tgs_tickets, sizeof(char), strlen(tgs_tickets), fp);
fwrite("\r\nAuthen_info:", sizeof(char), strlen("\r\nAuthen_info:"), fp);
fwrite(Authen_info_S, sizeof(char), Authen_info_len+5, fp);
fclose(fp);

接下来大家应该知道如何操作了,就是将文件发送给TGS。TGS接收到消息后解析出Tickets_tgs,然后采用自己的私钥Ktgs解密此票据,判断是否为合法Client的请求,以便进一步处理。OK,关键的部分全部分析完了,相信大家应该知道如何实现了吧?一定要动手自己编写代码试试哦。

小结

本文分析了Kerberos安全认证协议的基本原理,并通过简单编程实现了此协议,给出了编程过程中需要注意的部分及核心代码说明。希望本文能激发更多的人关注网络安全协议的研究,若对安全协议感兴趣,推荐大家品读下范红编写的《安全协议理论与方法》及其密码学经典作《现代密码学理论与实践》。初学者建议大家阅读密码学大牛Schneier所著的《应用密码学—协议、算法与C源程序》,相信它们会带给你不一样的感觉,也欢迎大家一起交流学习。

编程实现Kerberos安全协议解析 免费邮件订阅: 邮件订阅

图片推荐

热点排行榜

CopyRight? 2013 www.cangfengzhe.com All rights reserved