aes.c

wi－fi手机原代码

        s0 =
            Td0[(t0 >> 24)       ] ^
            Td1[(t3 >> 16) & 0xff] ^
            Td2[(t2 >>  8) & 0xff] ^
            Td3[(t1      ) & 0xff] ^
            rk[0];
        s1 =
            Td0[(t1 >> 24)       ] ^
            Td1[(t0 >> 16) & 0xff] ^
            Td2[(t3 >>  8) & 0xff] ^
            Td3[(t2      ) & 0xff] ^
            rk[1];
        s2 =
            Td0[(t2 >> 24)       ] ^
            Td1[(t1 >> 16) & 0xff] ^
            Td2[(t0 >>  8) & 0xff] ^
            Td3[(t3      ) & 0xff] ^
            rk[2];
        s3 =
            Td0[(t3 >> 24)       ] ^
            Td1[(t2 >> 16) & 0xff] ^
            Td2[(t1 >>  8) & 0xff] ^
            Td3[(t0      ) & 0xff] ^
            rk[3];
    }
#endif /* ?FULL_UNROLL */
    /*
	 * apply last round and
	 * map cipher state to byte array block:
	 */
   	s0 =
   		(Td4[(t0 >> 24)       ] & 0xff000000) ^
   		(Td4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
   		(Td4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
   		(Td4[(t1      ) & 0xff] & 0x000000ff) ^
   		rk[0];
	PUTU32(out     , s0);
   	s1 =
   		(Td4[(t1 >> 24)       ] & 0xff000000) ^
   		(Td4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
   		(Td4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
   		(Td4[(t2      ) & 0xff] & 0x000000ff) ^
   		rk[1];
	PUTU32(out +  4, s1);
   	s2 =
   		(Td4[(t2 >> 24)       ] & 0xff000000) ^
   		(Td4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
   		(Td4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
   		(Td4[(t3      ) & 0xff] & 0x000000ff) ^
   		rk[2];
	PUTU32(out +  8, s2);
   	s3 =
   		(Td4[(t3 >> 24)       ] & 0xff000000) ^
   		(Td4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
   		(Td4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
   		(Td4[(t0      ) & 0xff] & 0x000000ff) ^
   		rk[3];
	PUTU32(out + 12, s3);
}

#endif /* ndef OPENSSL_FIPS */
/*
    ivec is the initialisation vector.
*/

void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
		     const unsigned long length, const AES_KEY *key,
		     unsigned char *ivec, const int enc) {

	unsigned long n;
	unsigned long len = length;
	unsigned char tmp[AES_BLOCK_SIZE];

	assert(in && out && key && ivec);
	assert((AES_ENCRYPT == enc)||(AES_DECRYPT == enc));

	if (AES_ENCRYPT == enc) {
		while (len >= AES_BLOCK_SIZE) {
			for(n=0; n < AES_BLOCK_SIZE; ++n)
				tmp[n] = in[n] ^ ivec[n];
			AES_encrypt(tmp, out, key);
			memcpy(ivec, out, AES_BLOCK_SIZE);
			len -= AES_BLOCK_SIZE;
			in += AES_BLOCK_SIZE;
			out += AES_BLOCK_SIZE;
		}
		if (len) {
			for(n=0; n < len; ++n)
				tmp[n] = in[n] ^ ivec[n];
			for(n=len; n < AES_BLOCK_SIZE; ++n)
				tmp[n] = ivec[n];
			AES_encrypt(tmp, tmp, key);
			memcpy(out, tmp, AES_BLOCK_SIZE);
			memcpy(ivec, tmp, AES_BLOCK_SIZE);
		}			
	} else {
		while (len >= AES_BLOCK_SIZE) {
			memcpy(tmp, in, AES_BLOCK_SIZE);
			AES_decrypt(in, out, key);
			for(n=0; n < AES_BLOCK_SIZE; ++n)
				out[n] ^= ivec[n];
			memcpy(ivec, tmp, AES_BLOCK_SIZE);
			len -= AES_BLOCK_SIZE;
			in += AES_BLOCK_SIZE;
			out += AES_BLOCK_SIZE;
		}
		if (len) {
			memcpy(tmp, in, AES_BLOCK_SIZE);
			AES_decrypt(tmp, tmp, key);
			for(n=0; n < len; ++n)
				out[n] = tmp[n] ^ ivec[n];
			memcpy(ivec, tmp, AES_BLOCK_SIZE);
		}
	}
}

int set_hex(const unsigned char *in, unsigned char *out, int size)
{
    int i,n;
    unsigned char j;

    n=strlen(in);
    if (n > (size*2))
    {
        return(0);
    }
    memset(out,0,size);
    for (i=0; i<n; i++)
    {
        j=(unsigned char)*(in+i);
        if (j == 0) break;
        if ((j >= '0') && (j <= '9'))
            j-='0';
        else if ((j >= 'A') && (j <= 'F'))
            j=j-'A'+10;
        else if ((j >= 'a') && (j <= 'f'))
            j=j-'a'+10;
        else
        {
            return(0);
        }
        if (i&1)
            out[i/2]|=j;
        else
            out[i/2]=(j<<4);
    }
    return(1);
}


#define MAX_BLOCK_SIZE  128
#define MAX_MESSAGE_LEN 64*1024
#define MAX_KEY_SIZE     256

void Ext_AES_cbc_encrypt(const unsigned char *in,const unsigned long in_len,
			unsigned char *out,unsigned long *out_len,const unsigned char *userkey)
{

    unsigned char iv[MAX_BLOCK_SIZE/8];
    unsigned char ckey[MAX_KEY_SIZE/8];

    AES_KEY key;
    memset(iv,0,sizeof(iv));
    memset(out,0,sizeof(out));
    //memset(ckey,0x20,sizeof(ckey));
    if(!set_hex(userkey, ckey, MAX_KEY_SIZE/8))
        return;

/*    {
	int fd;
	fd = open("enkey.txt",O_WRONLY|O_CREAT);
	write(fd,ckey,32);
	close(fd);
    }*/
    *out_len = (in_len+15)/16 *16;
    if (AES_set_encrypt_key( ckey, MAX_KEY_SIZE, &key ))
        return;

    AES_cbc_encrypt(in,out,in_len,&key,iv,AES_ENCRYPT);
        return;
}

void Ext_AES_cbc_decrypt(unsigned char *in,unsigned long in_len,
                        unsigned char *out,unsigned char *userkey)
{

    unsigned char iv[MAX_BLOCK_SIZE/8];
    unsigned char ckey[MAX_KEY_SIZE/8];
    AES_KEY dkey;

    memset(iv,0,sizeof(iv));
    memset(out,0,sizeof(out));
    //memset(ckey,0x20,sizeof(ckey));
    if(!set_hex(userkey, ckey, MAX_KEY_SIZE/8))
        return;

/*    {
	int fd;
	fd = open("dekey.txt",O_WRONLY|O_CREAT);
	write(fd,ckey,32);
	close(fd);
    }*/
    if (AES_set_decrypt_key( ckey, MAX_KEY_SIZE, &dkey ))
        return ;

    AES_cbc_encrypt(in,out,in_len,&dkey,iv,AES_DECRYPT);
        return ;
}
#if 0
int main(int argc,char **argv)
{
        int enc=1;
        char *inf=NULL,*outf=NULL;
        char *keystr=NULL;

        argc--;
        argv++;
        while (argc >= 1)
	{
                if      (strcmp(*argv,"-e") == 0)
                {
		        enc=1;
		}
                else if (strcmp(*argv,"-d") == 0)
                {
		        enc=0;
		}
                else if (strcmp(*argv,"-in") == 0)
                {
                        if (--argc < 1) goto bad;
                        inf= *(++argv);
                }
                else if (strcmp(*argv,"-out") == 0)
                {
                        if (--argc < 1) goto bad;
                        outf= *(++argv);
                }
                else if (strcmp(*argv,"-k") == 0)
                {
                        if (--argc < 1) goto bad;
                        keystr= *(++argv);
                }
                else
                {
                        goto bad;
                }
                argc--;
                argv++;
        }

        if(1 == enc)
	{
		int fd,size;
		unsigned long outlen;
		char buffer[MAX_MESSAGE_LEN];
		char s[MAX_MESSAGE_LEN];
                memset(s,0,sizeof(s));
		fd = open(inf,O_RDONLY);
		size = read(fd,buffer,sizeof(buffer));
		close(fd);
		Ext_AES_cbc_encrypt(buffer,size,s,&outlen,keystr);
		fd = open(outf,O_WRONLY|O_CREAT);
		write(fd,s,outlen);
		close(fd);
	}
	else
	{
		int fd,size;
		char buffer[MAX_MESSAGE_LEN];
		char s[MAX_MESSAGE_LEN];
                memset(s,0,sizeof(s));
		fd = open(inf,O_RDONLY);
		size = read(fd,buffer,sizeof(buffer));
		close(fd);
                Ext_AES_cbc_decrypt(buffer,size,s,keystr);
		fd = open(outf,O_WRONLY|O_CREAT);
		write(fd,s,size);
		close(fd);
	}
	return 1;
bad:
	return 0;
}
#endif