udptortp.cpp

AES一种常用的加密解密方法 AES加密解密程序源码

MiNum.Data_type=data[1];
MiNum.Next_payload=data[2];
MiNum.V_Prf_func=data[3];
Csb_id=new char[lenth-]
*/

L=MikeyNum.HDRNum.Cs;   //MiNum.Cs;
n_b=MikeyNum.PayloadNum.KEMACNum.Encr_data_len;//MacNum.Encr_data_len;
Saltlenth=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Salt_len; //KeyNum.Salt_len;
Salt_data=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Key_data_buffer; 
//KeyNum.Salt_data_buffer
/*
if(MiNum.Cs
{
 unsigned char i=0;
 i=MiNum.Cs;
 struct Srtp
 {
  char Policy_no_i;
  char* Ssrc_i;
 char* Roc_i;
 }SrtpNum;
 SSRC=SrtpNum.Ssrc_i;
 ROC=SrtpNum.Roc_i;
}
*/
if(TimestampNum.Ts_type=2)
TS=MikeyNum.PayloadNum.TimestampNum.Ts_value;
char Type=0,Kv=0;
char Name=0;
char SPI=0,Interval=0;
char* Kv_data;
char* Key_data;
char* Salt_data;
Kv=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Type_kv&0x0f;
switch(Kv) 
{
case 0:
	Name=NULL;
	break;
case 1:
	{
		Name=SPI;
		Kv_data=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.KVNum.Kv_spiNum.SPI_data_buffer; //KeyNum.Kv_data_buffer;
	}
	break;
case 2:
	{
		Name=Interval;
		if(Updata_time>MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.KVNum.Kv_inNum.From)//KNum.From
		{
			
			if(Updata_time<MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.KVNum.Kv_inNum.To)//KNum.To
			{	
				if(MikeyNum.Data_type=0)//verification  //MiNum.Data_type
				{
					//	MikeyNum.Next_payload=1; //key data
					unsigned char TypeBitmap=0xf0;
					unsigned char KvBitmap=0x0f;
					TypeBitmap&=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Type_kv; //  KeyNum.Type_kv
					Type=TypeBitmap>>4;
					KvBitmap&=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Type_kv;
					Kv=KvBitmap;
					Len=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Key_data_len;  //KeyNum.Key_data_len;
					switch(Type) 
					{
					case 0:
						{
							Name=TGK;
							for(i=0;i<(unsigned long)Len;i++)
							{
								Key_data=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Key_data_buffer; //KeyNum.Key_data_buffer;
								MSK=Key_data;  //KeyNum.Key_data_buffer;
							}	
						}
						break;
					case 1:
						{
							Name=TGK+SALT;
							for(i=0;i<(unsigned long)Len;i++)
							{
								Key_data=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Salt_data_buffer; //KeyNum.Key_data_buffer
								Salt_data=Key_data;
							}
						}
						break;
					case 2:
						{
							Name=TEK;
							for(i=0;i<(unsigned long)Len;i++)
							{
								Key_data=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Key_data_buffer;  //KeyNum.Key_data_buffer;
								MTK=Key_data;
								printf("MTK OK");
							}
						}
						break;
					case 3:
						{
							Name=TEK+SALT;
							for(i=0;i<(unsigned long)Len;i++)
							{
								Key_data=MikeyNum.PayloadNum.KEMACNum.KEYSUBNum.Salt_data_buffer;
								Salt_data=Key_data;
							}
						}
						break;
					default:printf("Error");
						break;
					} 
					
				}
				else
				{	
					return;
					printf("Req for new MTK");
				}
			}
			else
			{
				return;
				printf("Req for new MTK");
			}
		}
		break;
default:printf("Error");
	break;
	}
	
}
}
////////////////////////////////////////////////////////////////////////////////
//解SRTP包为RTP 
////////////////////////////////////////////////////////////////////////////////
void UDPTORTP::MDPC_MTKD_DeRTP(char* buffer,int lenth,char* output)
{
	Aes	*MyAes;
	output=new char[lenth];
	unsigned char M;
	unsigned int SEQ;
	unsigned char PT;
	char* SRTPpacket;
	char*master_key=0;
	char* master_salt=0;
	char r=0,key_derivation_rate=0;
	//char index=0,a=0;
	
	char* keyinput=0;
	char* x=0; 
	char* k_s;
	int i=0,j=0;
	/////////////////////////////////////////////////////////////////////////////////
	//SRTP消息初始化 
	////////////////////////////////////////////////////////////////////////////////
	int Len=0;
	SRTPNum.V_CC=buffer[0];
	SRTPNum.M_TP=buffer[1];
    temp=0;
	temp=buffer[3];
	SRTPNum.SeqNum=temp<<8;
	temp=0;
	temp=buffer[2];
	SRTPNum.SeqNum+=temp;
	//SRTPNum.SeqNum=buffer[2]+buffer[3]<<8;
	temp=0;
	temp=buffer[7];
	SRTPNum.Timestamp=temp<<24;
	temp=0;
	temp=buffer[6];
	SRTPNum.Timestamp+=temp<<16;
	temp=0;
	temp=buffer[5];
	SRTPNum.Timestamp+=temp<<8;
	temp=0;
	temp=buffer[4];
	SRTPNum.Timestamp+=temp;
	//SRTPNum.Timestamp=buffer[4]+buffer[5]<<8+buffer[6]<<16+buffer[7]<<24;
	SRTPNum.SSRC=SRTPNum.Timestamp;
	temp=0;
	temp=buffer[13];
	SRTPNum.HeadExtNum.Profile=temp<<8;
	temp=0;
	temp=buffer[12];
	SRTPNum.HeadExtNum.Profile+=temp;
	//SRTPNum.HeadExtNum.Profile=buffer[12]+buffer[13]<<8;
	temp=0;
	temp=buffer[15];
	SRTPNum.HeadExtNum.Len=temp<<8;
	temp=0;
	temp=buffer[14];
	SRTPNum.HeadExtNum.Len+=temp;
	//SRTPNum.HeadExtNum.Len=buffer[14]+buffer[15]<<8;
	Len=SRTPNum.HeadExtNum.Len;
	memcpy(SRTPNum.HeadExtNum.Ext,buffer+16,Len);
	memcpy(SRTPNum.Payload,buffer+17+Len,buffer[1]&0x7f);
	
	
	/////////////////////////////////////////////////////////////////////////////////
	//初始化完成
	/////////////////////////////////////////////////////////////////////////////////
	SEQ=SRTPNum.SeqNum;
	SRTPpacket=SRTPNum.Payload;
	unsigned char TypeBitmap=0x7f;
	unsigned char KvBitmap=0x80;
	M=(SRTPNum.M_TP&TypeBitmap)>>7;
	PT=SRTPNum.M_TP&KvBitmap;
	master_salt=Salt_data;   //mtk.Salt_data
	r=key_derivation_rate;
	char put[12];  
	for(i=0;i<12;i++)
		put[i]=0;
	//i = 2^16 * ROC + SEQ.
	//a=index/r;
	
	char* x_half=0;  
	int put_lenth=0,x_lenth=0;
	if(k_e=NULL)
	{
		char label[3]="00";
		strcat(label,put);
		put_lenth=strlen(label);
		x_lenth=strlen(master_salt);
		for(i=0;i<put_lenth;i++)
			x_half[i]=put[i]^master_salt[i];
		for(i=put_lenth;i<x_lenth;i++)
			x[i]=master_salt[i];
		strcat(x,x_half);
		char k[5]="0000";
		strcat(x,k);
		//keyinput=(unsigned char*)x;
		strcpy(keyinput,x);
		// keyinput=x*y;
		MyAes = new Aes(32,(unsigned char*)master_key);
		//MyAes.Aes();
		MyAes->Cipher((unsigned char*)keyinput,(unsigned char*)output); //加密
		k_e=(char*)output;
	}
	else
		printf("No master_key!");
	
	if(k_s=NULL)
	{
		char label[3]="02";
		strcat(label,put);
		put_lenth=strlen(label);
		x_lenth=strlen(master_salt);
		for(i=0;i<put_lenth;i++)
			x_half[i]=put[i]^master_salt[i];
		for(i=put_lenth;i<x_lenth;i++)
			x[i]=master_salt[i];
		strcat(x,x_half);
		char* k="0000";
		strcat(x,k);
		//keyinput=x*y;
		MyAes = new Aes(32,(unsigned char*)master_key);
		// MyAes.Aes();
		MyAes->Cipher((unsigned char*)keyinput,(unsigned char*)output); 
		char* p=0;
		int p_lenth=0;
		p=output;
		p_lenth=strlen(p);
		for(int i=4;i<p_lenth;i++)
			k_s[i]=p[i];
	}
	else
		printf("No master_salt!");
	
    char* m=0;
    char* k_e_m=0;
	char* IV_temp=0;
	unsigned int half;
	int IV_lenth;
	half=0x00||M||PT||SEQ;
	for(i=0;i<L;i++)
	{
		IV_temp[i]=TS[i]||ROC[i]||SSRC[i];
	}
	IV_lenth=strlen(IV_temp);
	IV_temp[IV_lenth-2]=IV_temp[IV_lenth-2]||(half&0xff);
	IV_temp[IV_lenth-1]=IV_temp[IV_lenth-1]||((half>>8)&0xff);
	strcpy(IV,IV_temp);
	IV=IV_temp;
	//IV
	   // mtk.TS||mtk.SSRC||mtk.ROC;
	for(i=0;i<Saltlenth;i++)   
		m[i]=(k_s[i]||0x55)^k_e[i]; 
	strcpy(k_e_m,m);
	//k_e_m=k_e^m;
	MyAes=new Aes(32,(unsigned char*)k_e_m);
	MyAes->Cipher((unsigned char*)IV,(unsigned char*)output);  
	memcpy(IW,output,L);
	//L=N/n_b;   
    for(j=0;j<L;j++)
	{
		s(j,output);
		RtpCaculate(j,put,output);
	}
	//buffer=SRTPNum.Payload;
}
///////////////////////////////////////////////////////////////////////////////////
//SRTP包解为RTP包解包结束
///////////////////////////////////////////////////////////////////////////////////

void UDPTORTP::RtpCaculate(int m,const char* key,char* output)
{
	int i=0;
	for(i=0;i<m;i++)
		RTPNum.payload[i]=SRTPNum.Payload[i]^key[i];
	output=SRTPNum.Payload;
    RTPNum.length=m+RTPNum.length;
}


void UDPTORTP::keyCaculate(int m,const char* key1,const char* key2,char* output)
{
    int i=0;
	for(i=0;i<m;i++)
		stream[i]=key2[i]^key1[i];
	stream[m-2]=stream[m-2]||(m&0xff);
	stream[m-1]=stream[m-1]||((m>>8)&0xff);
	output=stream;
}

// S(j) = E(k_e, IV' XOR j XOR S(j-1))

UDPTORTP::s(int i,char* output)
{
	Aes	*MyAes;
	if (i==-1)
		state=0;
	put=new char[i];
	keyCaculate(i,IW,output,put);
    //stream=j^IW^s(j-1);
	//MyAes.Aes(24,k_e);
	MyAes=new Aes(32,(unsigned char*)k_e);
	MyAes->Cipher((unsigned char*)stream,(unsigned char*)put);
	//	RtpCaculate(i,put,);
}