destest.c

基于DSP的用C语言实现语音编码解码

                printf("Key error %d\n",j);
				err=1;
				}
		memset(cbc_out,0,40);
		memset(cbc_in,0,40);
		i=strlen((char *)cbc_data)+1;
		i=((i+7)/8)*8;
		memcpy(iv3,cbc_iv,sizeof(cbc_iv));

		des_ede3_cbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
				16L,ks,ks2,ks3,(C_Block *)iv3,DES_ENCRYPT);
		des_ede3_cbc_encrypt((C_Block *)&(cbc_data[16]),
				(C_Block *)&(cbc_out[16]),
				(long)i-16,ks,ks2,ks3,(C_Block *)iv3,DES_ENCRYPT);
		if (memcmp(cbc_out,cbc3_ok,
				(unsigned int)(strlen((char *)cbc_data)+1+7)/8*8) != 0)
				{
                printf("des_ede3_cbc_encrypt encrypt error\n");
				err=1;
				}

		memcpy(iv3,cbc_iv,sizeof(cbc_iv));
		des_ede3_cbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
				(long)i,ks,ks2,ks3,(C_Block *)iv3,DES_DECRYPT);
		if (memcmp(cbc_in,cbc_data,strlen(cbc_data)+1) != 0)
				{
                printf("des_ede3_cbc_encrypt decrypt error\n");
				err=1;
				}

        printf("Doing pcbc\n");
		if ((j=key_sched((C_Block *)cbc_key,ks)) != 0)
				{
                printf("Key error %d\n",j);
				err=1;
				}
		memset(cbc_out,0,40);
		memset(cbc_in,0,40);
		des_pcbc_encrypt((C_Block *)cbc_data,(C_Block *)cbc_out,
				(long)strlen(cbc_data)+1,ks,(C_Block *)cbc_iv,DES_ENCRYPT);
		if (memcmp(cbc_out,pcbc_ok,32) != 0)
				{
                printf("pcbc_encrypt encrypt error\n");
				err=1;
				}
		des_pcbc_encrypt((C_Block *)cbc_out,(C_Block *)cbc_in,
				(long)strlen(cbc_data)+1,ks,(C_Block *)cbc_iv,DES_DECRYPT);
		if (memcmp(cbc_in,cbc_data,32) != 0)
				{
                printf("pcbc_encrypt decrypt error\n");
				err=1;
				}

        printf("Doing ");
        printf("cfb8 ");
		err+=cfb_test(8,cfb_cipher8);
        printf("cfb16 ");
		err+=cfb_test(16,cfb_cipher16);
        printf("cfb32 ");
		err+=cfb_test(32,cfb_cipher32);
        printf("cfb48 ");
		err+=cfb_test(48,cfb_cipher48);
        printf("cfb64 ");
		err+=cfb_test(64,cfb_cipher64);

        printf("cfb64() ");
		err+=cfb64_test(cfb_cipher64);

		memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
		for (i=0; i<sizeof(plain); i++)
				des_cfb_encrypt(&(plain[i]),&(cfb_buf1[i]),
						8,(long)1,ks,(C_Block *)cfb_tmp,DES_ENCRYPT);
		if (memcmp(cfb_cipher8,cfb_buf1,sizeof(plain)) != 0)
				{
                printf("cfb_encrypt small encrypt error\n");
				err=1;
				}

		memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
		for (i=0; i<sizeof(plain); i++)
				des_cfb_encrypt(&(cfb_buf1[i]),&(cfb_buf2[i]),
						8,(long)1,ks,(C_Block *)cfb_tmp,DES_DECRYPT);
		if (memcmp(plain,cfb_buf2,sizeof(plain)) != 0)
				{
                printf("cfb_encrypt small decrypt error\n");
				err=1;
				}

        printf("ede_cfb64() ");
		err+=ede_cfb64_test(cfb_cipher64);

        printf("done\n");

        printf("Doing ofb\n");
		key_sched((C_Block *)ofb_key,ks);
		memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
		des_ofb_encrypt(plain,ofb_buf1,64,(long)sizeof(plain)/8,ks,
				(C_Block *)ofb_tmp);
		if (memcmp(ofb_cipher,ofb_buf1,sizeof(ofb_buf1)) != 0)
				{
                printf("ofb_encrypt encrypt error\n");
				err=1;
				}
		memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
		des_ofb_encrypt(ofb_buf1,ofb_buf2,64,(long)sizeof(ofb_buf1)/8,ks,
				(C_Block *)ofb_tmp);
		if (memcmp(plain,ofb_buf2,sizeof(ofb_buf2)) != 0)
				{
                printf("ofb_encrypt decrypt error\n");
				err=1;
				}

        printf("Doing ofb64\n");
		key_sched((C_Block *)ofb_key,ks);
		memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
		memset(ofb_buf1,0,sizeof(ofb_buf1));
		memset(ofb_buf2,0,sizeof(ofb_buf1));
		num=0;
		for (i=0; i<sizeof(plain); i++)
				{
				des_ofb64_encrypt(&(plain[i]),&(ofb_buf1[i]),1,ks,
						(C_Block *)ofb_tmp,&num);
				}
		if (memcmp(ofb_cipher,ofb_buf1,sizeof(ofb_buf1)) != 0)
				{
                printf("ofb64_encrypt encrypt error\n");
				err=1;
				}
		memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
		num=0;
		des_ofb64_encrypt(ofb_buf1,ofb_buf2,(long)sizeof(ofb_buf1),ks,
				(C_Block *)ofb_tmp,&num);
		if (memcmp(plain,ofb_buf2,sizeof(ofb_buf2)) != 0)
				{
                printf("ofb64_encrypt decrypt error\n");
				err=1;
				}

        printf("Doing ede_ofb64\n");
		key_sched((C_Block *)ofb_key,ks);
		memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
		memset(ofb_buf1,0,sizeof(ofb_buf1));
		memset(ofb_buf2,0,sizeof(ofb_buf1));
		num=0;
		for (i=0; i<sizeof(plain); i++)
				{
				des_ede3_ofb64_encrypt(&(plain[i]),&(ofb_buf1[i]),1,ks,ks,ks,
						(C_Block *)ofb_tmp,&num);
				}
		if (memcmp(ofb_cipher,ofb_buf1,sizeof(ofb_buf1)) != 0)
				{
                printf("ede_ofb64_encrypt encrypt error\n");
				err=1;
				}
		memcpy(ofb_tmp,ofb_iv,sizeof(ofb_iv));
		num=0;
		des_ede3_ofb64_encrypt(ofb_buf1,ofb_buf2,(long)sizeof(ofb_buf1),ks,
				ks,ks,(C_Block *)ofb_tmp,&num);
		if (memcmp(plain,ofb_buf2,sizeof(ofb_buf2)) != 0)
				{
                printf("ede_ofb64_encrypt decrypt error\n");
				err=1;
				}

        printf("Doing cbc_cksum\n");
		key_sched((C_Block *)cbc_key,ks);
		cs=cbc_cksum((C_Block *)cbc_data,(C_Block *)cret,
				(long)strlen(cbc_data),ks,(C_Block *)cbc_iv);
		if (cs != cbc_cksum_ret)
				{
                printf("bad return value (%08lX), should be %08lX\n",
						cs,cbc_cksum_ret);
				err=1;
				}
		if (memcmp(cret,cbc_cksum_data,8) != 0)
				{
                printf("bad cbc_cksum block returned\n");
				err=1;
				}

        printf("Doing quad_cksum\n");
		cs=quad_cksum((C_Block *)cbc_data,(C_Block *)qret,
				(long)strlen(cbc_data),2,(C_Block *)cbc_iv);
		for (i=0; i<4; i++)
				{
				lqret[i]=0;
				memcpy(&(lqret[i]),&(qret[i][0]),4);
				}
		{ /* Big-endian fix */
		static unsigned long l=1;
		static unsigned char *c=(unsigned char *)&l;
		unsigned long ll;

		if (!c[0])
				{
				ll=lqret[0]^lqret[3];
				lqret[0]^=ll;
				lqret[3]^=ll;
				ll=lqret[1]^lqret[2];
				lqret[1]^=ll;
				lqret[2]^=ll;
				}
		}
		if (cs != 0x70d7a63aL)
				{
                printf("quad_cksum error, ret %08lx should be 70d7a63a\n",cs);
				err=1;
				}
		if (lqret[0] != 0x327eba8dL)
				{
                printf("quad_cksum error, out[0] %08lx is not %08lx\n",
						lqret[0],0x327eba8dL);
				err=1;
				}
		if (lqret[1] != 0x201a49ccL)
				{
                printf("quad_cksum error, out[1] %08lx is not %08lx\n",
						lqret[1],0x201a49ccL);
				err=1;
				}
		if (lqret[2] != 0x70d7a63aL)
				{
                printf("quad_cksum error, out[2] %08lx is not %08lx\n",
						lqret[2],0x70d7a63aL);
				err=1;
				}
		if (lqret[3] != 0x501c2c26L)
				{
                printf("quad_cksum error, out[3] %08lx is not %08lx\n",
						lqret[3],0x501c2c26L);
				err=1;
				}

        printf("input word alignment test");
		for (i=0; i<4; i++)
				{
                printf(" %d",i);
				des_cbc_encrypt((C_Block *)&(cbc_out[i]),(C_Block *)cbc_in,
						(long)strlen(cbc_data)+1,ks,(C_Block *)cbc_iv,
						DES_ENCRYPT);
				}
        printf("\noutput word alignment test");
		for (i=0; i<4; i++)
				{
                printf(" %d",i);
				des_cbc_encrypt((C_Block *)cbc_out,(C_Block *)&(cbc_in[i]),
						(long)strlen(cbc_data)+1,ks,(C_Block *)cbc_iv,
						DES_ENCRYPT);
				}
        printf("\n");
        printf("fast crypt test ");
        str=crypt("testing","ef");
        if (strcmp("efGnQx2725bI2",str) != 0)
				{
                printf("fast crypt error, %s should be efGnQx2725bI2\n",str);
				err=1;
				}
        str=crypt("bca76;23","yA");
        if (strcmp("yA1Rp/1hZXIJk",str) != 0)
				{
                printf("fast crypt error, %s should be yA1Rp/1hZXIJk\n",str);
				err=1;
				}
        printf("\n");
		exit(err);
#ifdef LINT
		return(0);
#endif
		}

static char *pt(p)
unsigned char *p;
		{
		static char bufs[10][20];
		static int bnum=0;
		char *ret;
		int i;
        static char *f="0123456789ABCDEF";

		ret= &(bufs[bnum++][0]);
		bnum%=10;
		for (i=0; i<8; i++)
				{
				ret[i*2]=f[(p[i]>>4)&0xf];
				ret[i*2+1]=f[p[i]&0xf];
				}
        ret[16]='\0';
		return(ret);
		}

static int cfb_test(bits, cfb_cipher)
int bits;
unsigned char *cfb_cipher;
		{
		des_key_schedule ks;
		int i,err=0;

		key_sched((C_Block *)cfb_key,ks);
		memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
		des_cfb_encrypt(plain,cfb_buf1,bits,(long)sizeof(plain),ks,
				(C_Block *)cfb_tmp,DES_ENCRYPT);
		if (memcmp(cfb_cipher,cfb_buf1,sizeof(plain)) != 0)
				{
				err=1;
                printf("cfb_encrypt encrypt error\n");
				for (i=0; i<24; i+=8)
                        printf("%s\n",pt(&(cfb_buf1[i])));
				}
		memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
		des_cfb_encrypt(cfb_buf1,cfb_buf2,bits,(long)sizeof(plain),ks,
				(C_Block *)cfb_tmp,DES_DECRYPT);
		if (memcmp(plain,cfb_buf2,sizeof(plain)) != 0)
				{
				err=1;
                printf("cfb_encrypt decrypt error\n");
				for (i=0; i<24; i+=8)
                        printf("%s\n",pt(&(cfb_buf1[i])));
				}
		return(err);
		}

static int cfb64_test(cfb_cipher)
unsigned char *cfb_cipher;
		{
		des_key_schedule ks;
		int err=0,i,n;

		key_sched((C_Block *)cfb_key,ks);
		memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
		n=0;
		des_cfb64_encrypt(plain,cfb_buf1,(long)12,ks,
				(C_Block *)cfb_tmp,&n,DES_ENCRYPT);
		des_cfb64_encrypt(&(plain[12]),&(cfb_buf1[12]),
				(long)sizeof(plain)-12,ks,
				(C_Block *)cfb_tmp,&n,DES_ENCRYPT);
		if (memcmp(cfb_cipher,cfb_buf1,sizeof(plain)) != 0)
				{
				err=1;
                printf("cfb_encrypt encrypt error\n");
				for (i=0; i<24; i+=8)
                        printf("%s\n",pt(&(cfb_buf1[i])));
				}
		memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
		n=0;
		des_cfb64_encrypt(cfb_buf1,cfb_buf2,(long)17,ks,
				(C_Block *)cfb_tmp,&n,DES_DECRYPT);
		des_cfb64_encrypt(&(cfb_buf1[17]),&(cfb_buf2[17]),
				(long)sizeof(plain)-17,ks,
				(C_Block *)cfb_tmp,&n,DES_DECRYPT);
		if (memcmp(plain,cfb_buf2,sizeof(plain)) != 0)
				{
				err=1;
                printf("cfb_encrypt decrypt error\n");
				for (i=0; i<24; i+=8)
                        printf("%s\n",pt(&(cfb_buf2[i])));
				}
		return(err);
		}

static int ede_cfb64_test(cfb_cipher)
unsigned char *cfb_cipher;
		{
		des_key_schedule ks;
		int err=0,i,n;

		key_sched((C_Block *)cfb_key,ks);
		memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
		n=0;
		des_ede3_cfb64_encrypt(plain,cfb_buf1,(long)12,ks,ks,ks,
				(C_Block *)cfb_tmp,&n,DES_ENCRYPT);
		des_ede3_cfb64_encrypt(&(plain[12]),&(cfb_buf1[12]),
				(long)sizeof(plain)-12,ks,ks,ks,
				(C_Block *)cfb_tmp,&n,DES_ENCRYPT);
		if (memcmp(cfb_cipher,cfb_buf1,sizeof(plain)) != 0)
				{
				err=1;
                printf("ede_cfb_encrypt encrypt error\n");
				for (i=0; i<24; i+=8)
                        printf("%s\n",pt(&(cfb_buf1[i])));
				}
		memcpy(cfb_tmp,cfb_iv,sizeof(cfb_iv));
		n=0;
		des_ede3_cfb64_encrypt(cfb_buf1,cfb_buf2,(long)17,ks,ks,ks,
				(C_Block *)cfb_tmp,&n,DES_DECRYPT);
		des_ede3_cfb64_encrypt(&(cfb_buf1[17]),&(cfb_buf2[17]),
				(long)sizeof(plain)-17,ks,ks,ks,
				(C_Block *)cfb_tmp,&n,DES_DECRYPT);
		if (memcmp(plain,cfb_buf2,sizeof(plain)) != 0)
				{
				err=1;
                printf("ede_cfb_encrypt decrypt error\n");
				for (i=0; i<24; i+=8)
                        printf("%s\n",pt(&(cfb_buf2[i])));
				}
		return(err);
		}