aes.c

flint库 RSA算法

    {
#ifdef AES_TEST
      fprintf (stderr, "AES_ERR_KEYLENGTH in line %d\n", __LINE__);
#endif
      return AES_ERR_KEYLENGTH;
    }

  for (col = col4 = 0; col < Nk - 1; col++, col4+=4)
    {
      keyptr = &ExpandedKey[col];
      *keyptr = UC2UL(&RawKey[col4]);
    }

  keyptr = &ExpandedKey[Nk-1];
  tmp = (*keyptr = UC2UL(&RawKey[(unsigned)(Nk-1)<<2]));

  for (col = Nk; col < Nb*(Nr + 1); col++)
    {
      keyptr1 = &ExpandedKey[col];
      keyptr2 = &ExpandedKey[col-Nk];

      if (col % Nk == 0)
        {
          tmp = ROR (tmp, 8);
          SubWord (tmp);
          tmp ^= rc[col/Nk];
        }

      else if ((Nk == 8) && (col % Nk == 4))
        {
          SubWord (tmp); /*lint !e771 At this point tmp is initialized! */
        }

      tmp = (*keyptr1 = *keyptr2 ^ tmp);
    }

#ifdef AES_SECURE
  ZeroUlong (&tmp);
#endif

  return 0;
}


/******************************************************************************/
/*                                                                            */
/*  Function:   AES key expansion to inverse key schedule for decryption      */
/*  Syntax:     int                                                           */
/*              AESInvKeyExpansion_l (AESXPKEY InvExpandedKey, AESKEY RawKey, */
/*                                           int KeyLength, int BlockLength); */
/*  Input:      AESKEY RawKey (User Key as byte array)                        */
/*              int KeyLength (Length of user key 128, 192 or 256 bit)        */
/*              int BlockLength (Length of Message block 128, 192 or 256 bit) */
/*  Output:     AESEXPKEY InvExpandedKey (Invers key schedule)                */
/*  Returns:    0                                                             */
/*                                                                            */
/******************************************************************************/
int __FLINT_API
AESInvKeyExpansion_l (AESXPKEY InvExpandedKey, AESKEY RawKey, 
                                int KeyLength, int BlockLength)
{
  int round, Nb, Nk, Nr, error;

  Nb = BlockLength/32;
  Nk = KeyLength/32;
  Nr = NR[(Nk - 4)/2][(Nb - 4)/2];

  if (0 != (error = AESKeyExpansion (InvExpandedKey, RawKey, KeyLength, BlockLength)))
    {
      return error;
    }

  for (round = 1; round < Nr; round++)
    {
      InvMixColumns (&InvExpandedKey[round*Nb], Nb);
    }

  return 0;
}


#ifndef AES_COMPACT

/******************************************************************************/
/*                                                                            */
/*  Function:   AES processing of state variable (encryption)                 */
/*              Fast table lookup                                             */
/*  Syntax:     int                                                           */
/*              AESEncState_l (AESSTATE State, AESXPKEY ExpandedKey,          */
/*                                                     int Nk, int Nb);       */
/*  Input:      AESSTATE State (State variable to process)                    */
/*              AESEXPKEY ExpandedKey (Key schedule)                          */
/*              int Nk (Keylength in 4-byte-words 4, 6, 8)                    */
/*              int Nb (Blocklength in 4-byte-words 4, 6, 8)                  */
/*  Output:     AESSTATE State (processed state variable)                     */
/*  Returns:    0                                                             */
/*                                                                            */
/******************************************************************************/
int __FLINT_API 
AESEncState_l (AESSTATE State, AESXPKEY ExpandedKey, int Nk, int Nb)
{
  int round, Nr = NR[(Nk - 4)/2][(Nb - 4)/2];
  ULONG *keyptr;
  ULONG a0, a1, a2, a3, a4, a5, a6, a7;
  ULONG b0, b1, b2, b3, b4, b5, b6;

  switch (Nb)
    {
      case 8:
        a7 = State[7] ^ ExpandedKey[7];
        a6 = State[6] ^ ExpandedKey[6];
      case 6:
        a5 = State[5] ^ ExpandedKey[5];
        a4 = State[4] ^ ExpandedKey[4];
      case 4:
        a3 = State[3] ^ ExpandedKey[3];
        a2 = State[2] ^ ExpandedKey[2];
        a1 = State[1] ^ ExpandedKey[1];
        a0 = State[0] ^ ExpandedKey[0];
    }

  for (keyptr = &ExpandedKey[Nb], round = 1; round < Nr; round++)
    {
      switch (Nb)
        {
          case 4:
            b0 = Table0[(a0      ) & 0xff]
               ^ Table1[(a1 >>  8) & 0xff]
               ^ Table2[(a2 >> 16) & 0xff]
               ^ Table3[(a3 >> 24)       ]; 
                          
            b1 = Table0[(a1      ) & 0xff]        
               ^ Table1[(a2 >>  8) & 0xff]
               ^ Table2[(a3 >> 16) & 0xff]
               ^ Table3[(a0 >> 24)       ];
                          
            b2 = Table0[(a2      ) & 0xff]
               ^ Table1[(a3 >>  8) & 0xff]
               ^ Table2[(a0 >> 16) & 0xff]
               ^ Table3[(a1 >> 24)       ];
                          
            a3 = Table0[(a3      ) & 0xff]
               ^ Table1[(a0 >>  8) & 0xff]
               ^ Table2[(a1 >> 16) & 0xff]
               ^ Table3[(a2 >> 24)       ]
               ^ keyptr[3];
            
            a0 = b0 ^ keyptr[0];
            a1 = b1 ^ keyptr[1];
            a2 = b2 ^ keyptr[2];
            break;

          case 6:
            b0 = Table0[(a0      ) & 0xff] 
               ^ Table1[(a1 >>  8) & 0xff]
               ^ Table2[(a2 >> 16) & 0xff]
               ^ Table3[(a3 >> 24)       ];
                          
            b1 = Table0[(a1      ) & 0xff] 
               ^ Table1[(a2 >>  8) & 0xff]
               ^ Table2[(a3 >> 16) & 0xff]
               ^ Table3[(a4 >> 24)       ];
                          
            b2 = Table0[(a2      ) & 0xff] 
               ^ Table1[(a3 >>  8) & 0xff]
               ^ Table2[(a4 >> 16) & 0xff]
               ^ Table3[(a5 >> 24)       ];
                          
            b3 = Table0[(a3      ) & 0xff] 
               ^ Table1[(a4 >>  8) & 0xff]
               ^ Table2[(a5 >> 16) & 0xff]
               ^ Table3[(a0 >> 24)       ];
                          
            b4 = Table0[(a4      ) & 0xff] 
               ^ Table1[(a5 >>  8) & 0xff]
               ^ Table2[(a0 >> 16) & 0xff]
               ^ Table3[(a1 >> 24)       ];

            a5 = Table0[(a5      ) & 0xff] 
               ^ Table1[(a0 >>  8) & 0xff]
               ^ Table2[(a1 >> 16) & 0xff]
               ^ Table3[(a2 >> 24)       ]
               ^ keyptr[5];

            a0 = b0 ^ keyptr[0];
            a1 = b1 ^ keyptr[1];
            a2 = b2 ^ keyptr[2];
            a3 = b3 ^ keyptr[3];
            a4 = b4 ^ keyptr[4];
            break;

          case 8:
            /* col 0 */
            b0 = Table0[(a0      ) & 0xff] 
               ^ Table1[(a1 >>  8) & 0xff]
               ^ Table2[(a3 >> 16) & 0xff]
               ^ Table3[(a4 >> 24)       ];
                                    
            /* col 1 */             
            b1 = Table0[(a1      ) & 0xff] 
               ^ Table1[(a2 >>  8) & 0xff]
               ^ Table2[(a4 >> 16) & 0xff]
               ^ Table3[(a5 >> 24)       ];
                                    
            /* col 2 */             
            b2 = Table0[(a2      ) & 0xff] 
               ^ Table1[(a3 >>  8) & 0xff]
               ^ Table2[(a5 >> 16) & 0xff]
               ^ Table3[(a6 >> 24)       ];
                                    
            /* col 3 */             
            b3 = Table0[(a3      ) & 0xff] 
               ^ Table1[(a4 >>  8) & 0xff]
               ^ Table2[(a6 >> 16) & 0xff]
               ^ Table3[(a7 >> 24)       ];
                                    
            /* col 4 */             
            b4 = Table0[(a4      ) & 0xff] 
               ^ Table1[(a5 >>  8) & 0xff]
               ^ Table2[(a7 >> 16) & 0xff]
               ^ Table3[(a0 >> 24)       ];
                                    
            /* col 5 */             
            b5 = Table0[(a5      ) & 0xff] 
               ^ Table1[(a6 >>  8) & 0xff]
               ^ Table2[(a0 >> 16) & 0xff]
               ^ Table3[(a1 >> 24)       ];
                                    
            /* col 6 */             
            b6 = Table0[(a6      ) & 0xff] 
               ^ Table1[(a7 >>  8) & 0xff]
               ^ Table2[(a1 >> 16) & 0xff]
               ^ Table3[(a2 >> 24)       ];
                                    
            /* col 7 */             
            a7 = Table0[(a7      ) & 0xff] 
               ^ Table1[(a0 >>  8) & 0xff]
               ^ Table2[(a2 >> 16) & 0xff]
               ^ Table3[(a3 >> 24)       ]
               ^ keyptr[7];

            a0 = b0 ^ keyptr[0];
            a1 = b1 ^ keyptr[1];
            a2 = b2 ^ keyptr[2];
            a3 = b3 ^ keyptr[3];
            a4 = b4 ^ keyptr[4];
            a5 = b5 ^ keyptr[5];
            a6 = b6 ^ keyptr[6];
            break;
        }
    
      keyptr += Nb;
    }

  /* Final round */
  switch (Nb)
    {
      case 4:
        State[0] = (SBox[(a0      ) & 0xff]      )
                 ^ (SBox[(a1 >>  8) & 0xff] <<  8)
                 ^ (SBox[(a2 >> 16) & 0xff] << 16)
                 ^ (SBox[(a3 >> 24)       ] << 24)
                 ^ keyptr[0];
                             
        State[1] = (SBox[(a1      ) & 0xff]      )
                 ^ (SBox[(a2 >>  8) & 0xff] <<  8)