mraes.c

miracl-大数运算库,大家使用有什么问题请多多提意见

        y[3]=a->fkey[k+3]^ftable[MR_TOBYTE(x[3])]^
             ftable1[MR_TOBYTE(x[0]>>8)]^
             ftable2[MR_TOBYTE(x[1]>>16)]^
             ftable3[x[2]>>24];
#else
        y[0]=a->fkey[k]^ftable[MR_TOBYTE(x[0])]^
             ROTL8(ftable[MR_TOBYTE(x[1]>>8)])^
             ROTL16(ftable[MR_TOBYTE(x[2]>>16)])^
             ROTL24(ftable[x[3]>>24]);
        y[1]=a->fkey[k+1]^ftable[MR_TOBYTE(x[1])]^
             ROTL8(ftable[MR_TOBYTE(x[2]>>8)])^
             ROTL16(ftable[MR_TOBYTE(x[3]>>16)])^
             ROTL24(ftable[x[0]>>24]);
        y[2]=a->fkey[k+2]^ftable[MR_TOBYTE(x[2])]^
             ROTL8(ftable[MR_TOBYTE(x[3]>>8)])^
             ROTL16(ftable[MR_TOBYTE(x[0]>>16)])^
             ROTL24(ftable[x[1]>>24]);
        y[3]=a->fkey[k+3]^ftable[MR_TOBYTE(x[3])]^
             ROTL8(ftable[MR_TOBYTE(x[0]>>8)])^
             ROTL16(ftable[MR_TOBYTE(x[1]>>16)])^
             ROTL24(ftable[x[2]>>24]);
#endif
        k+=4;
        t=x; x=y; y=t;      /* swap pointers */
    }

/* Last Round */ 
    
    y[0]=a->fkey[k]^(MR_WORD)fbsub[MR_TOBYTE(x[0])]^
         ROTL8((MR_WORD)fbsub[MR_TOBYTE(x[1]>>8)])^
         ROTL16((MR_WORD)fbsub[MR_TOBYTE(x[2]>>16)])^
         ROTL24((MR_WORD)fbsub[x[3]>>24]);
    y[1]=a->fkey[k+1]^(MR_WORD)fbsub[MR_TOBYTE(x[1])]^
         ROTL8((MR_WORD)fbsub[MR_TOBYTE(x[2]>>8)])^
         ROTL16((MR_WORD)fbsub[MR_TOBYTE(x[3]>>16)])^
         ROTL24((MR_WORD)fbsub[x[0]>>24]);
    y[2]=a->fkey[k+2]^(MR_WORD)fbsub[MR_TOBYTE(x[2])]^
         ROTL8((MR_WORD)fbsub[MR_TOBYTE(x[3]>>8)])^
         ROTL16((MR_WORD)fbsub[MR_TOBYTE(x[0]>>16)])^
         ROTL24((MR_WORD)fbsub[x[1]>>24]);
    y[3]=a->fkey[k+3]^(MR_WORD)fbsub[MR_TOBYTE(x[3])]^
         ROTL8((MR_WORD)fbsub[MR_TOBYTE(x[0]>>8)])^
         ROTL16((MR_WORD)fbsub[MR_TOBYTE(x[1]>>16)])^
         ROTL24((MR_WORD)fbsub[x[2]>>24]);

    for (i=j=0;i<NB;i++,j+=4)
    {
        unpack(y[i],(MR_BYTE *)&buff[j]);
        x[i]=y[i]=0;   /* clean up stack */
    }
}

static void aes_ecb_decrypt(aes *a,MR_BYTE *buff)
{
    int i,j,k;
    MR_WORD p[4],q[4],*x,*y,*t;

    for (i=j=0;i<NB;i++,j+=4)
    {
        p[i]=pack((MR_BYTE *)&buff[j]);
        p[i]^=a->rkey[i];
    }

    k=NB;
    x=p; y=q;

/* State alternates between x and y */
    for (i=1;i<a->Nr;i++)
    { /* Nr is number of rounds. May be odd. */
#ifndef MR_SHORT_OF_MEMORY
        y[0]=a->rkey[k]^rtable[MR_TOBYTE(x[0])]^
             rtable1[MR_TOBYTE(x[3]>>8)]^
             rtable2[MR_TOBYTE(x[2]>>16)]^
             rtable3[x[1]>>24];
        y[1]=a->rkey[k+1]^rtable[MR_TOBYTE(x[1])]^
             rtable1[MR_TOBYTE(x[0]>>8)]^
             rtable2[MR_TOBYTE(x[3]>>16)]^
             rtable3[x[2]>>24];
        y[2]=a->rkey[k+2]^rtable[MR_TOBYTE(x[2])]^
             rtable1[MR_TOBYTE(x[1]>>8)]^
             rtable2[MR_TOBYTE(x[0]>>16)]^
             rtable3[x[3]>>24];
        y[3]=a->rkey[k+3]^rtable[MR_TOBYTE(x[3])]^
             rtable1[MR_TOBYTE(x[2]>>8)]^
             rtable2[MR_TOBYTE(x[1]>>16)]^
             rtable3[x[0]>>24];
#else
        y[0]=a->rkey[k]^rtable[MR_TOBYTE(x[0])]^
             ROTL8(rtable[MR_TOBYTE(x[3]>>8)])^
             ROTL16(rtable[MR_TOBYTE(x[2]>>16)])^
             ROTL24(rtable[x[1]>>24]);
        y[1]=a->rkey[k+1]^rtable[MR_TOBYTE(x[1])]^
             ROTL8(rtable[MR_TOBYTE(x[0]>>8)])^
             ROTL16(rtable[MR_TOBYTE(x[3]>>16)])^
             ROTL24(rtable[x[2]>>24]);
        y[2]=a->rkey[k+2]^rtable[MR_TOBYTE(x[2])]^
             ROTL8(rtable[MR_TOBYTE(x[1]>>8)])^
             ROTL16(rtable[MR_TOBYTE(x[0]>>16)])^
             ROTL24(rtable[x[3]>>24]);
        y[3]=a->rkey[k+3]^rtable[MR_TOBYTE(x[3])]^
             ROTL8(rtable[MR_TOBYTE(x[2]>>8)])^
             ROTL16(rtable[MR_TOBYTE(x[1]>>16)])^
             ROTL24(rtable[x[0]>>24]);
#endif
        k+=4;
        t=x; x=y; y=t;      /* swap pointers */
    }

/* Last Round */ 
    y[0]=a->rkey[k]^(MR_WORD)rbsub[MR_TOBYTE(x[0])]^
         ROTL8((MR_WORD)rbsub[MR_TOBYTE(x[3]>>8)])^
         ROTL16((MR_WORD)rbsub[MR_TOBYTE(x[2]>>16)])^
         ROTL24((MR_WORD)rbsub[x[1]>>24]);
    y[1]=a->rkey[k+1]^(MR_WORD)rbsub[MR_TOBYTE(x[1])]^
         ROTL8((MR_WORD)rbsub[MR_TOBYTE(x[0]>>8)])^
         ROTL16((MR_WORD)rbsub[MR_TOBYTE(x[3]>>16)])^
         ROTL24((MR_WORD)rbsub[x[2]>>24]);
    y[2]=a->rkey[k+2]^(MR_WORD)rbsub[MR_TOBYTE(x[2])]^
         ROTL8((MR_WORD)rbsub[MR_TOBYTE(x[1]>>8)])^
         ROTL16((MR_WORD)rbsub[MR_TOBYTE(x[0]>>16)])^
         ROTL24((MR_WORD)rbsub[x[3]>>24]);
    y[3]=a->rkey[k+3]^(MR_WORD)rbsub[MR_TOBYTE(x[3])]^
         ROTL8((MR_WORD)rbsub[MR_TOBYTE(x[2]>>8)])^
         ROTL16((MR_WORD)rbsub[MR_TOBYTE(x[1]>>16)])^
         ROTL24((MR_WORD)rbsub[x[0]>>24]);

    for (i=j=0;i<NB;i++,j+=4)
    {
        unpack(y[i],(MR_BYTE *)&buff[j]);
        x[i]=y[i]=0;   /* clean up stack */
    }

}

mr_unsign32 aes_encrypt(aes* a,char *buff)
{
    int j,bytes;
    char st[16];
    mr_unsign32 fell_off;

/* Supported Modes of Operation */

    fell_off=0;
    switch (a->mode)
    {
    case MR_ECB: 
        aes_ecb_encrypt(a,(MR_BYTE *)buff);
        return 0;
    case MR_CBC:
        for (j=0;j<4*NB;j++) buff[j]^=a->f[j];
        aes_ecb_encrypt(a,(MR_BYTE *)buff);
        for (j=0;j<4*NB;j++) a->f[j]=buff[j];
        return 0;

    case MR_CFB1:
    case MR_CFB2:
    case MR_CFB4:
        bytes=a->mode-MR_CFB1+1;
        for (j=0;j<bytes;j++) fell_off=(fell_off<<8)|a->f[j];
        for (j=0;j<4*NB;j++) st[j]=a->f[j];
        for (j=bytes;j<4*NB;j++) a->f[j-bytes]=a->f[j];
        aes_ecb_encrypt(a,(MR_BYTE *)st);
        for (j=0;j<bytes;j++) 
        {
            buff[j]^=st[j];
            a->f[16-bytes+j]=buff[j];
        }
        return fell_off;

    case MR_OFB1:
    case MR_OFB2:
    case MR_OFB4:
    case MR_OFB8:
    case MR_OFB16:

        bytes=a->mode-MR_OFB1+1;
        aes_ecb_encrypt(a,(MR_BYTE *)(a->f));
        for (j=0;j<bytes;j++) buff[j]^=a->f[j];
        return 0;

    case MR_PCFB1:   /* error propagating CFB */
    case MR_PCFB2:
    case MR_PCFB4:   
        bytes=a->mode-MR_PCFB1+1;
        for (j=0;j<bytes;j++) fell_off=(fell_off<<8)|a->f[j];
        for (j=0;j<4*NB;j++) st[j]=a->f[j];
        for (j=bytes;j<4*NB;j++) a->f[j-bytes]=a->f[j];
        aes_ecb_encrypt(a,(MR_BYTE *)st);
        for (j=0;j<bytes;j++) 
        {
            buff[j]^=st[j];
            a->f[16-bytes+j]=buff[j]^st[16-bytes+j];
        }
        return fell_off;

    default:
        return 0;
    }
}

mr_unsign32 aes_decrypt(aes *a,char *buff)
{
    int j,bytes;
    char st[16];
    mr_unsign32 fell_off;

   /* Supported modes of operation */
    fell_off=0;
    switch (a->mode)
    {
    case MR_ECB:
        aes_ecb_decrypt(a,(MR_BYTE *)buff);
        return 0;
    case MR_CBC:
        for (j=0;j<4*NB;j++) 
        {
            st[j]=a->f[j];
            a->f[j]=buff[j];
        }
        aes_ecb_decrypt(a,(MR_BYTE *)buff);
        for (j=0;j<4*NB;j++)
        { 
            buff[j]^=st[j];
            st[j]=0;
        }
        return 0;
    case MR_CFB1:
    case MR_CFB2:
    case MR_CFB4:
        bytes=a->mode-MR_CFB1+1;
        for (j=0;j<bytes;j++) fell_off=(fell_off<<8)|a->f[j];
        for (j=0;j<4*NB;j++) st[j]=a->f[j];
        for (j=bytes;j<4*NB;j++) a->f[j-bytes]=a->f[j];
        aes_ecb_encrypt(a,(MR_BYTE *)st);
        for (j=0;j<bytes;j++)
        {
            a->f[16-bytes+j]=buff[j];
            buff[j]^=st[j];
        }
        return fell_off;
    case MR_OFB1:
    case MR_OFB2:
    case MR_OFB4:
    case MR_OFB8:
    case MR_OFB16:
        bytes=a->mode-MR_OFB1+1;
        aes_ecb_encrypt(a,(MR_BYTE *)(a->f));
        for (j=0;j<bytes;j++) buff[j]^=a->f[j];
        return 0;

    case MR_PCFB1:   /* error propagating CFB */
    case MR_PCFB2:
    case MR_PCFB4:
        
        bytes=a->mode-MR_PCFB1+1;
        for (j=0;j<bytes;j++) fell_off=(fell_off<<8)|a->f[j];
        for (j=0;j<4*NB;j++) st[j]=a->f[j];
        for (j=bytes;j<4*NB;j++) a->f[j-bytes]=a->f[j];
        aes_ecb_encrypt(a,(MR_BYTE *)st);
        for (j=0;j<bytes;j++)
        {
            a->f[16-bytes+j]=buff[j]^st[16-bytes+j];
            buff[j]^=st[j];
        }
        return fell_off;
    default:
        return 0;
    }
}

void aes_end(aes *a)
{ /* clean up */
    int i;
    for (i=0;i<NB*(a->Nr+1);i++)
        a->fkey[i]=a->rkey[i]=0;
    for (i=0;i<4*NB;i++)
        a->f[i]=0;
}

/*
int main()
{ 
    int i,j,nk;
    aes a;
    MR_BYTE y,x,m;
    char key[32];
    char block[16];
    char iv[16];
    for (i=0;i<32;i++) key[i]=0;
    key[0]=1;
    for (i=0;i<16;i++) iv[i]=i;
    for (i=0;i<16;i++) block[i]=i;

    for (nk=16;nk<=32;nk+=8)
    {  
        printf("\nKey Size= %d bits\n",nk*8);
        if (!aes_init(&a,MR_CBC,nk,key,iv))
        {
            printf("Failed to Initialize\n");
            return 0;
        }

        printf("Plain=   ");
        for (i=0;i<4*NB;i++) printf("%02x",block[i]);
        printf("\n");
        aes_encrypt(&a,block);
        printf("Encrypt= ");
        for (i=0;i<4*NB;i++) printf("%02x",(unsigned char)block[i]);
        printf("\n");
        aes_reset(&a,MR_CBC,iv);
        aes_decrypt(&a,block);
        printf("Decrypt= ");
        for (i=0;i<4*NB;i++) printf("%02x",block[i]);
        printf("\n");

        aes_end(&a);
    }
    return 0;
}
*/