API tools faq
paste
Advertisement
Guest User

aes.py

a guest
Jun 22nd, 2014
285
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 9.23 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3.  
  4. """ GLOBALS """
  5.  
  6. sbox = [    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
  7.             0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
  8.             0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
  9.             0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
  10.             0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
  11.             0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
  12.             0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
  13.             0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
  14.             0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
  15.             0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
  16.             0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
  17.             0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
  18.             0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
  19.             0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
  20.             0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
  21.             0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16]
  22.    
  23. rcon = [[0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36],
  24.         [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00],
  25.         [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00],
  26.         [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00]]
  27.        
  28. rgfield = [[0x02,0x03,0x01,0x01],
  29.            [0x01,0x02,0x03,0x01],
  30.            [0x01,0x01,0x02,0x03],
  31.            [0x03,0x01,0x01,0x02]]
  32.  
  33. schedule = None     # Round keys 1-10
  34. cnst = 0b00011011   # Constant XOR multiplication value
  35.  
  36. class libutils:
  37.    
  38.     """ n       ->  nº of column to change
  39.         block   ->  block 4x4 (key)
  40.         column  ->  block 4x1 (RotWord)
  41.     """
  42.     ## Example of use libutils._changecolumn(antKey,[0x09,0xcf,0x4f,0x3c],0) ##
  43.     @staticmethod
  44.     def _changecolumn(block,column,n):
  45.         for i in xrange(4):
  46.             block[i][n] = column[i]
  47.         return block
  48.        
  49.     ## PRECONDITION n<=col(block) ##
  50.     @staticmethod
  51.     def _getcolumn(block,n):
  52.         return [block[i][n] for i in xrange(len(block))]
  53.    
  54.     @staticmethod
  55.     def _getallcolumns(block):
  56.         return [libutils._getcolumn(block,n) for n in xrange(len(block))]
  57.        
  58.     @staticmethod
  59.     ## Change first byte at last byte of the column ##
  60.     def _rotword(column):
  61.         tmp = column[0]
  62.         for i in xrange(len(column)-1):
  63.             column[i] = column[i+1]
  64.         column[len(column)-1] = tmp
  65.         return column
  66.    
  67.     @staticmethod
  68.     ## Make SubBytes process applied to column ##
  69.     def _subbytes(column):
  70.         return [sbox[i] for i in column]
  71.    
  72.     @staticmethod
  73.     ## Make SubBytes process applied to matrix ##
  74.     def _subbytesmatrix(matrix):
  75.         for i in xrange(len(matrix)):
  76.             for j in xrange(len(matrix)):
  77.                 matrix[i][j] = sbox[matrix[i][j]]
  78.         return matrix
  79.        
  80.     @staticmethod
  81.     ## Xor 3 columns -> key schedule col1 xor col2 xor Rcon[i] ##
  82.     ## PRECONDITION len(col1) == len(col2) == len(col3) ##
  83.     def _xor3columns(col1,col2,col3):
  84.         return [col1[i] ^ col2[i] ^ col3[i] for i in xrange(len(col1))]
  85.        
  86.     @staticmethod
  87.     ## Xor 2 columns ##
  88.     ## PRECONDITION: len(col1) == len(col2) ##
  89.     def _xor2columns(col1,col2):
  90.         return [col1[i] ^ col2[i] for i in xrange(len(col1))]
  91.    
  92.     @staticmethod
  93.     ## Build matrix by columns ##
  94.     def _buildmatrixcol(*args):
  95.         matrix = [[0x00]*len(args) for i in xrange(len(args))]
  96.         for i in xrange(len(args)):
  97.             libutils._changecolumn(matrix,args[i],i)
  98.         return matrix
  99.    
  100.     @staticmethod
  101.     ## AddRoundKey process ##
  102.     ## PRECONDITION: Square matrices (4x4 in this case)
  103.     def _addroundkey(matrix1,matrix2):
  104.         matrix = [[0x00]*4 for i in xrange(len(matrix1))]
  105.         for i in xrange(len(matrix1)):
  106.             matrix = libutils._changecolumn(matrix,libutils._xor2columns(libutils._getcolumn(matrix1,i),libutils._getcolumn(matrix2,i)),i)
  107.         return matrix
  108.    
  109.     @staticmethod
  110.     ## Rotate fil n of matrix i times ##
  111.     ## Trick: << i -> pos[0] = pos[i], pos[1] = pos[(1+i)%3], pos[2] = pos[(2+i)%3], pos[3] = pos[(3+i)%3]
  112.     def _rotate(fil,n,i):
  113.         auxfil = [p for p in fil]
  114.         for j in xrange(len(fil)):
  115.             fil[j] = 0x00 | auxfil[(j+i)%len(fil)]
  116.         return fil
  117.        
  118.     @staticmethod
  119.     ## ShiftRows process   ##
  120.     def _shiftrows(matrix):
  121.         for i in xrange(len(matrix)):
  122.             # Rotate fil i, i times #
  123.             matrix[i] = libutils._rotate(matrix[i],i,i)
  124.         return matrix
  125.  
  126.  
  127.     @staticmethod
  128.     ## MixColumns process ##
  129.     ## PRECONDITION: 8-bits elements in matrix, else it will be truncated at 8-bits or filled with zeros ##
  130.     def _mixcolumns(matrix):
  131.         actCol  = []
  132.         acum    = 0x00
  133.         endCol  = [0x00]*4
  134.         tmp     = 0x00
  135.         for i in xrange(len(matrix)):
  136.             actCol = libutils._getcolumn(matrix,i)
  137.             for j in xrange(len(rgfield)):
  138.                 for x in xrange(len(rgfield[j])):
  139.                     actCol[x] = actCol[x] & 0x000000FF   # If it has more than 8-bits truncate it
  140.                     xored = actCol[x] & 0x00000080
  141.                     if rgfield[j][x] == 0x01:
  142.                         tmp = actCol[x]                
  143.                     elif rgfield[j][x] == 0x02:
  144.                         tmp = actCol[x] << 1
  145.                         if xored != 0x00000080:
  146.                             tmp = tmp ^ cnst                                           
  147.                     else:  
  148.                         tmp = actCol[x] << 1
  149.                         if xored != 0x00000080:
  150.                             tmp = tmp ^ cnst   
  151.                         tmp = tmp ^ actCol[x]              
  152.                     acum = acum ^ tmp
  153.                     acum &= 0x000000FF
  154.                     tmp = 0x00
  155.                 endCol[j] = acum
  156.                 acum      = 0x00
  157.             matrix = libutils._changecolumn(matrix,endCol,i)
  158.         return matrix
  159.        
  160.        
  161.     @staticmethod
  162.     ## Extract round key n from schedule ##
  163.     ##
  164.     def _extractroundkey(schedule,n):
  165.         roundKey = [[],[],[],[]]
  166.         for i in xrange(len(schedule)):
  167.             for j in range(n*4,(n*4)+4):
  168.                 roundKey[i].append(schedule[i][j])
  169.         return roundKey
  170.                    
  171.    
  172. class cipheralgorithms:
  173.    
  174.     @staticmethod
  175.     def _aes(*args):
  176.         cipherText = [[0x32,0x88,0x31,0xe0],[0x43,0x5a,0x31,0x37],[0xf6,0x30,0x98,0x07],[0xa8,0x8d,0xa2,0x34]]
  177.         cipherKey  = [[0x2b,0x28,0xab,0x09],[0x7e,0xae,0xf7,0xcf],[0x15,0xd2,0x15,0x4f],[0x16,0xa6,0x88,0x3c]]
  178.         auxBlock   = [[0x00]*4]
  179.         if args != ():
  180.             cipherText = args[0]
  181.             if len(args) == 2:
  182.                 cipherKey  = args[1]
  183.         # Set schedule -> we can obtain later all round keys by this matrix #
  184.         schedule  = cipheralgorithms.__keyschedule(cipherKey)
  185.        
  186.         ###################### Show ######################
  187.         def _showBlock(auxBlock):
  188.             for i in auxBlock:
  189.                 for j in i:
  190.                     print hex(j)," ",
  191.                 print "\n"
  192.         ###################### End Show ######################
  193.          
  194.         # Make init AddRoundKey with cipherKey #
  195.         auxBlock = libutils._addroundkey(cipherText,libutils._extractroundkey(schedule,0))
  196.         print "First AddRoundKey: \n"
  197.         _showBlock(auxBlock)
  198.         # Make 9 main rounds #
  199.         for x in range(1,10):  
  200.             ## SubBytes      ##
  201.             auxBlock = libutils._subbytesmatrix(auxBlock)
  202.             print "Round " + str(x) + " SubBytes: \n"
  203.             _showBlock(auxBlock)
  204.             ## ShiftRows     ##
  205.             auxBlock = libutils._shiftrows(auxBlock)
  206.             print "Round " + str(x) + " ShiftRows: \n"
  207.             _showBlock(auxBlock)
  208.             ## MixColumns    ##
  209.             auxBlock = libutils._mixcolumns(auxBlock)
  210.             print "Round " + str(x) + " MixColumns: \n"
  211.             _showBlock(auxBlock)
  212.             ## AddRoundKey   ##
  213.             print "Round " + str(x) + " Key to cipher in this round: \n"
  214.             _showBlock(libutils._extractroundkey(schedule,x))
  215.             print "Round " + str(x) + " Keyed: \n"
  216.             auxBlock = libutils._addroundkey(auxBlock,libutils._extractroundkey(schedule,x))
  217.             _showBlock(auxBlock)
  218.            
  219.         ## Make final round  ##
  220.         ## SubBytes      ##
  221.         auxBlock = libutils._subbytesmatrix(auxBlock)
  222.         print "Final subbytes: \n"
  223.         _showBlock(auxBlock)
  224.         ## ShiftRows     ##
  225.         auxBlock = libutils._shiftrows(auxBlock)
  226.         print "Final shiftrows: \n"
  227.         _showBlock(auxBlock)
  228.         ## AddRoundKey   ##
  229.         auxBlock = libutils._addroundkey(auxBlock,libutils._extractroundkey(schedule,10))
  230.         print "Final keyed: \n"
  231.         _showBlock(auxBlock)
  232.            
  233.     @staticmethod
  234.     def __keyschedule(cipherKey):              
  235.         antKey,schedule,actCol,i,actPos,actPosRcon = cipherKey,[],None,0,0,0
  236.         ## Fill schedule 4x40 ##
  237.         schedule = [[0x00]*44 for i in xrange(4)]
  238.         ## Set initial status of schedule ##
  239.         for col in libutils._getallcolumns(antKey):
  240.             schedule = libutils._changecolumn(schedule,col,actPos)
  241.             actPos += 1
  242.         for i in xrange(40):
  243.             ## Take ant col ##
  244.             actCol = libutils._getcolumn(schedule,actPos-1)
  245.             ## If is word in multiple of 4, rotword and subbytes ##
  246.             if(actPos%4==0):
  247.                 actCol = libutils._rotword(actCol)
  248.                 actCol = libutils._subbytes(actCol)
  249.                 actCol = libutils._xor3columns(libutils._getcolumn(schedule,actPos-4),actCol,libutils._getcolumn(rcon,actPosRcon))
  250.                 actPosRcon += 1
  251.             else:
  252.                 actCol = libutils._xor2columns(libutils._getcolumn(schedule,actPos-4),actCol)
  253.             libutils._changecolumn(schedule,actCol,actPos)
  254.             actPos += 1
  255.         return schedule
  256.        
  257.    
  258. if __name__ == "__main__":
  259.     # Si no hay argumentos se tomarán por defecto los valores del ejemplo #
  260.     # 1º -> CipherText (Bloque de 128bits)
  261.     # 2º -> CipherKey  (Bloque de 128bits)
  262.     cipheralgorithms._aes()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!