eric: comparison src/eric7/Utilities/crypto/py3AES.py

-:2fe91fe443dd
+:328f3ec4b77a
 def append_PKCS7_padding(b):
 """
 Function to pad the given data to a multiple of 16-bytes by PKCS7 padding.
-@param b data to be padded (bytes)
+@param b data to be padded
-@return padded data (bytes)
+@type bytes
+@return padded data
+@rtype bytes
 """
 numpads = 16 - (len(b) % 16)
 return b + numpads * bytes(chr(numpads), encoding="ascii")
 def strip_PKCS7_padding(b):
 """
 Function to strip off PKCS7 padding.
-@param b data to be stripped (bytes)
+@param b data to be stripped
-@return stripped data (bytes)
+@type bytes
+@return stripped data
+@rtype bytes
 @exception ValueError data padding is invalid
 """
 if len(b) % 16 or not b:
 raise ValueError("Data of len {0} can't be PCKS7-padded".format(len(b)))
 numpads = b[-1]
 def __getSBoxValue(self, num):
 """
 Private method to retrieve a given S-Box value.
-@param num position of the value (integer)
+@param num position of the value
-@return value of the S-Box (integer)
+@type int
+@return value of the S-Box
+@rtype int
 """
 return self.sbox[num]
 def __getSBoxInvert(self, num):
 """
 Private method to retrieve a given Inverted S-Box value.
-@param num position of the value (integer)
+@param num position of the value
-@return value of the Inverted S-Box (integer)
+@type int
+@return value of the Inverted S-Box
+@rtype int
 """
 return self.rsbox[num]
 def __rotate(self, data):
 """
 Private method performing Rijndael's key schedule rotate operation.
 Rotate the data word eight bits to the left: eg,
 rotate(1d2c3a4f) == 2c3a4f1d.
-@param data data of size 4 (bytearray)
+@param data data of size 4
-@return rotated data (bytearray)
+@type bytearray
+@return rotated data
+@rtype bytearray
 """
 return data[1:] + data[:1]
 def __getRconValue(self, num):
 """
 Private method to retrieve a given Rcon value.
-@param num position of the value (integer)
+@param num position of the value
-@return Rcon value (integer)
+@type int
+@return Rcon value
+@rtype int
 """
 return self.Rcon[num]
 def __core(self, data, iteration):
 """
 Private method performing the key schedule core operation.
-@param data data to operate on (bytearray)
+@param data data to operate on
-@param iteration iteration counter (integer)
+@type bytearray
-@return modified data (bytearray)
+@param iteration iteration counter
+@type int
+@return modified data
+@rtype bytearray
 """
 # rotate the 32-bit word 8 bits to the left
 data = self.__rotate(data)
 # apply S-Box substitution on all 4 parts of the 32-bit word
 for i in range(4):
 """
 Private method performing Rijndael's key expansion.
 Expands a 128, 192 or 256 bit key into a 176, 208 or 240 bit key.
-@param key key to be expanded (bytes or bytearray)
+@param key key to be expanded
+@type bytes or bytearray
 @param size size of the key in bytes (16, 24 or 32)
-@param expandedKeySize size of the expanded key (integer)
+@type int
-@return expanded key (bytearray)
+@param expandedKeySize size of the expanded key
+@type int
+@return expanded key
+@rtype bytearray
 """
 # current expanded keySize, in bytes
 currentSize = 0
 rconIteration = 1
 expandedKey = bytearray(expandedKeySize)
 def __addRoundKey(self, state, roundKey):
 """
 Private method to add (XORs) the round key to the state.
-@param state state to be changed (bytearray)
+@param state state to be changed
-@param roundKey key to be used for the modification (bytearray)
+@type bytearray
-@return modified state (bytearray)
+@param roundKey key to be used for the modification
+@type bytearray
+@return modified state
+@rtype bytearray
 """
 buf = state[:]
 for i in range(16):
 buf[i] ^= roundKey[i]
 return buf
 def __createRoundKey(self, expandedKey, roundKeyPointer):
 """
 Private method to create a round key.
-@param expandedKey expanded key to be used (bytearray)
+@param expandedKey expanded key to be used
-@param roundKeyPointer position within the expanded key (integer)
+@type bytearray
-@return round key (bytearray)
+@param roundKeyPointer position within the expanded key
+@type int
+@return round key
+@rtype bytearray
 """
 roundKey = bytearray(16)
 for i in range(4):
 for j in range(4):
 roundKey[j * 4 + i] = expandedKey[roundKeyPointer + i * 4 + j]
 def __galois_multiplication(self, a, b):
 """
 Private method to perform a Galois multiplication of 8 bit characters
 a and b.
-@param a first factor (byte)
+@param a first factor
-@param b second factor (byte)
+@type bytes
-@return result (byte)
+@param b second factor
+@type bytes
+@return result
+@rtype bytes
 """
 p = 0
 for _counter in range(8):
 if b & 1:
 p ^= a
 def __subBytes(self, state, isInv):
 """
 Private method to substitute all the values from the state with the
 value in the SBox using the state value as index for the SBox.
-@param state state to be worked on (bytearray)
+@param state state to be worked on
-@param isInv flag indicating an inverse operation (boolean)
+@type bytearray
-@return modified state (bytearray)
+@param isInv flag indicating an inverse operation
+@type bool
+@return modified state
+@rtype bytearray
 """
 state = state[:]
 getter = self.__getSBoxInvert if isInv else self.__getSBoxValue
 for i in range(16):
 state[i] = getter(state[i])
 def __shiftRows(self, state, isInv):
 """
 Private method to iterate over the 4 rows and call __shiftRow() with
 that row.
-@param state state to be worked on (bytearray)
+@param state state to be worked on
-@param isInv flag indicating an inverse operation (boolean)
+@type bytearray
-@return modified state (bytearray)
+@param isInv flag indicating an inverse operation
+@type bool
+@return modified state
+@rtype bytearray
 """
 state = state[:]
 for i in range(4):
 state = self.__shiftRow(state, i * 4, i, isInv)
 return state
 def __shiftRow(self, state, statePointer, nbr, isInv):
 """
 Private method to shift the bytes of a row to the left.
-@param state state to be worked on (bytearray)
+@param state state to be worked on
-@param statePointer index into the state (integer)
+@type bytearray
-@param nbr number of positions to shift (integer)
+@param statePointer index into the state
-@param isInv flag indicating an inverse operation (boolean)
+@type int
-@return modified state (bytearray)
+@param nbr number of positions to shift
+@type int
+@param isInv flag indicating an inverse operation
+@type bool
+@return modified state
+@rtype bytearray
 """
 state = state[:]
 for _ in range(nbr):
 if isInv:
 state[statePointer : statePointer + 4] = (
 def __mixColumns(self, state, isInv):
 """
 Private method to perform a galois multiplication of the 4x4 matrix.
-@param state state to be worked on (bytearray)
+@param state state to be worked on
-@param isInv flag indicating an inverse operation (boolean)
+@type bytearray
-@return modified state (bytearray)
+@param isInv flag indicating an inverse operation
+@type bool
+@return modified state
+@rtype bytearray
 """
 state = state[:]
 # iterate over the 4 columns
 for i in range(4):
 # construct one column by slicing over the 4 rows
 def __mixColumn(self, column, isInv):
 """
 Private method to perform a galois multiplication of 1 column the
 4x4 matrix.
-@param column column to be worked on (bytearray)
+@param column column to be worked on
-@param isInv flag indicating an inverse operation (boolean)
+@type bytearray
-@return modified column (bytearray)
+@param isInv flag indicating an inverse operation
+@type bool
+@return modified column
+@rtype bytearray
 """
 column = column[:]
 mult = [14, 9, 13, 11] if isInv else [2, 1, 1, 3]
 cpy = column[:]
 g = self.__galois_multiplication
 def __aes_round(self, state, roundKey):
 """
 Private method to apply the 4 operations of the forward round in
 sequence.
-@param state state to be worked on (bytearray)
+@param state state to be worked on
-@param roundKey round key to be used (bytearray)
+@type bytearray
-@return modified state (bytearray)
+@param roundKey round key to be used
+@type bytearray
+@return modified state
+@rtype bytearray
 """
 state = self.__subBytes(state, False)
 state = self.__shiftRows(state, False)
 state = self.__mixColumns(state, False)
 state = self.__addRoundKey(state, roundKey)
 def __aes_invRound(self, state, roundKey):
 """
 Private method to apply the 4 operations of the inverse round in
 sequence.
-@param state state to be worked on (bytearray)
+@param state state to be worked on
-@param roundKey round key to be used (bytearray)
+@type bytearray
-@return modified state (bytearray)
+@param roundKey round key to be used
+@type bytearray
+@return modified state
+@rtype bytearray
 """
 state = self.__shiftRows(state, True)
 state = self.__subBytes(state, True)
 state = self.__addRoundKey(state, roundKey)
 state = self.__mixColumns(state, True)
 Perform the initial operations, the standard round, and the
 final operations of the forward AES, creating a round key for
 each round.
-@param state state to be worked on (bytearray)
+@param state state to be worked on
-@param expandedKey expanded key to be used (bytearray)
+@type bytearray
-@param nbrRounds number of rounds to be done (integer)
+@param expandedKey expanded key to be used
-@return modified state (bytearray)
+@type bytearray
+@param nbrRounds number of rounds to be done
+@type int
+@return modified state
+@rtype bytearray
 """
 state = self.__addRoundKey(state, self.__createRoundKey(expandedKey, 0))
 i = 1
 while i < nbrRounds:
 state = self.__aes_round(state, self.__createRoundKey(expandedKey, 16 * i))
 Perform the initial operations, the standard round, and the
 final operations of the inverse AES, creating a round key for
 each round.
-@param state state to be worked on (bytearray)
+@param state state to be worked on
-@param expandedKey expanded key to be used (bytearray)
+@type bytearray
-@param nbrRounds number of rounds to be done (integer)
+@param expandedKey expanded key to be used
-@return modified state (bytearray)
+@type bytearray
+@param nbrRounds number of rounds to be done
+@type int
+@return modified state
+@rtype bytearray
 """
 state = self.__addRoundKey(
 state, self.__createRoundKey(expandedKey, 16 * nbrRounds)
 )
 i = nbrRounds - 1
 def encrypt(self, iput, key, size):
 """
 Public method to encrypt a 128 bit input block against the given key
 of size specified.
-@param iput input data (bytearray)
+@param iput input data
-@param key key to be used (bytes or bytearray)
+@type bytearray
+@param key key to be used
+@type bytes or bytearray
 @param size key size (16, 24 or 32)
-@return encrypted data (bytes)
+@type int
+@return encrypted data
+@rtype bytes
 @exception ValueError key size is invalid
 """
 if size not in self.KeySize.values():
 raise ValueError("Wrong key size given ({0}).".format(size))
 def decrypt(self, iput, key, size):
 """
 Public method to decrypt a 128 bit input block against the given key
 of size specified.
-@param iput input data (bytearray)
+@param iput input data
-@param key key to be used (bytes or bytearray)
+@type bytearray
+@param key key to be used
+@type bytes or bytearray
 @param size key size (16, 24 or 32)
-@return decrypted data (bytes)
+@type int
+@return decrypted data
+@rtype bytes
 @exception ValueError key size is invalid
 """
 if size not in self.KeySize.values():
 raise ValueError("Wrong key size given ({0}).".format(size))
 def __extractBytes(self, inputData, start, end, mode):
 """
 Private method to extract a range of bytes from the input.
-@param inputData input data (bytes)
+@param inputData input data
-@param start start index (integer)
+@type bytes
-@param end end index (integer)
+@param start start index
+@type int
+@param end end index
+@type int
 @param mode mode of operation (0, 1, 2)
-@return extracted bytes (bytearray)
+@type int
+@return extracted bytes
+@rtype bytearray
 """
 if end - start > 16:
 end = start + 16
 ar = bytearray(16) if mode == self.ModeOfOperation["CBC"] else bytearray()
 def encrypt(self, inputData, mode, key, size, IV):
 """
 Public method to perform the encryption operation.
-@param inputData data to be encrypted (bytes)
+@param inputData data to be encrypted
+@type bytes
 @param mode mode of operation (0, 1 or 2)
-@param key key to be used (bytes)
+@type int
+@param key key to be used
+@type bytes
 @param size length of the key (16, 24 or 32)
-@param IV initialisation vector (bytearray)
+@type int
+@param IV initialisation vector
+@type bytearray
 @return tuple with mode of operation, length of the input data and
-the encrypted data (integer, integer, bytes)
+the encrypted data
+@rtype tuple of (int, int, bytes)
 @exception ValueError key size is invalid or decrypted data is invalid
 """
 if len(key) % size:
 raise ValueError("Illegal size ({0}) for key '{1}'.".format(size, key))
 if len(IV) % 16:
 # IV - the 128 bit number array Initilization Vector
 def decrypt(self, cipherIn, originalsize, mode, key, size, IV):
 """
 Public method to perform the decryption operation.
-@param cipherIn data to be decrypted (bytes)
+@param cipherIn data to be decrypted
+@type bytes
 @param originalsize unencrypted string length (required for CBC)
-(integer)
+@type int
 @param mode mode of operation (0, 1 or 2)
-@param key key to be used (bytes)
+@type int
+@param key key to be used
+@type bytes
 @param size length of the key (16, 24 or 32)
-@param IV initialisation vector (bytearray)
+@type int
-@return decrypted data (bytes)
+@param IV initialisation vector
+@type bytearray
+@return decrypted data
+@rtype bytes
 @exception ValueError key size is invalid or decrypted data is invalid
 """
 if len(key) % size:
 raise ValueError("Illegal size ({0}) for key '{1}'.".format(size, key))
 if len(IV) % 16:
 def encryptData(key, data, mode=AESModeOfOperation.ModeOfOperation["CBC"]):
 """
 Module function to encrypt the given data with the given key.
-@param key key to be used for encryption (bytes)
+@param key key to be used for encryption
-@param data data to be encrypted (bytes)
+@type bytes
+@param data data to be encrypted
+@type bytes
 @param mode mode of operations (0, 1 or 2)
-@return encrypted data prepended with the initialization vector (bytes)
+@type int
+@return encrypted data prepended with the initialization vector
+@rtype bytes
 @exception ValueError raised to indicate an invalid key size
 """
 key = bytearray(key)
 if mode == AESModeOfOperation.ModeOfOperation["CBC"]:
 data = append_PKCS7_padding(data)
 def decryptData(key, data, mode=AESModeOfOperation.ModeOfOperation["CBC"]):
 """
 Module function to decrypt the given data with the given key.
-@param key key to be used for decryption (bytes)
+@param key key to be used for decryption
+@type bytes
 @param data data to be decrypted (with initialization vector prepended)
-(bytes)
+@type bytes
 @param mode mode of operations (0, 1 or 2)
-@return decrypted data (bytes)
+@type int
+@return decrypted data
+@rtype bytes
 @exception ValueError raised to indicate an invalid key size
 """
 key = bytearray(key)
 keysize = len(key)
 if keysize not in AES.KeySize.values():

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Utilities/crypto/py3AES.py

src/eric7/Utilities/crypto/py3AES.py