Return to Answer

AES GCM is a version of AES in counter mode, and a counter mode converts a block cipher into a stream cipher. The main advantage of a stream cipher is that we do not have to worry about padding. We get 16 bytes of pseudo random key stream per invocation of the AES encryption function, which gets XOR ed with the plaintext to get the corresponding ciphertext. When reading a file in programming languages like C or C++ or Python you can specify the number of bytes to read , while looping till you reach the end of file. It is advisable to choose a multiple of 16 in this case like 1024*1024 bytes or more, but keeping hardware limitations and efficiency in mind. Reading 16 bytes for every loop interation is inefficient. You can find an optimal value to read by trial and error, and some benchmarking. The number of bytes successfully read by these functions provided by those programming languages can also be checked (let that be called x). In the case of Python:

MY_BLOCK_SIZE = 1024*1024

with open(filename, "rb") as fobj:
     run = True
     while run:
         data = fobj.read(MY_BLOCK_SIZE)
         if len(data)==0 :
                  break
         elif (len(data)%MY_BLOCK_SIZE) == 0:
              #invoke AES encryption function MY_BLOCK_SIZE/16 times incrementing the counter each time
             # do all the things for calculating the authentication tag
              # Ciphertext is XOR(data, key_stream, len(data))
         else:
             #invoke AES encryption function MY_BLOCK_SIZE/16 times incrementing the counter each time # do all the things for calculating the authentication  # Ciphertext is XOR(data, key_stream, len(data))
     

Suppose you read a file of arbitrary length in blocks of bytes (which is a multiple of 16 ) , there are two possibilities, either the last block read might be exactly your block size (x = 16*n) or less than it (x < 16*n). In either case, you have to invoke the AES encryption function n times, but you use only, x bytes of the key stream, generated for that iteration, to XOR with the plaintext.

AES GCM is a version of AES in counter mode, and a counter mode converts a block cipher into a stream cipher. The main advantage of a stream cipher is that we do not have to worry about padding. We get 16 bytes of pseudo random key stream per invocation of the AES encryption function, which gets XOR ed with the plaintext to get the corresponding ciphertext. When reading a file in programming languages like C or C++ or Python you can specify the number of bytes to read , while looping till you reach the end of file. It is advisable to choose a multiple of 16 in this case like 1024*1024 bytes or more, but keeping hardware limitations and efficiency in mind. Reading 16 bytes for every loop interation is inefficient. You can find an optimal value to read by trial and error, and some benchmarking. The number of bytes successfully read by these functions provided by those programming languages can also be checked (let that be called x). In the case of Python:

# This is only for illustrative purposes!

MY_BLOCK_SIZE = 1024*1024

with open(filename, "rb") as fobj:
     run = True
     while run:
         data = fobj.read(MY_BLOCK_SIZE)
         x = len(data)
         if x == 0:       
               break
         elif (x%MY_BLOCK_SIZE) == 0:
              #invoke AES encryption function MY_BLOCK_SIZE/16 times incrementing the counter each time
             # do all the things for calculating the authentication tag
              # Ciphertext is XOR(data, key_stream, len(data))
         else:
             #invoke AES encryption function MY_BLOCK_SIZE/16 times incrementing the counter each time # do all the things for calculating the authentication  # Ciphertext is XOR(data, key_stream, len(data))
     

Suppose you read a file of arbitrary length in blocks of bytes (which is a multiple of 16 ) , there are two possibilities, either the last block read might be exactly your block size (x = 16*n) or less than it (x < 16*n). In either case, you have to invoke the AES encryption function n times, incrementing counter for every n, but you use only, x bytes of the key stream, generated for that iteration, to XOR with the plaintext.

AES GCM is a version of AES in counter mode, and a counter mode converts a block cipher into a stream cipher. The main advantage of a stream cipher is that we do not have to worry about padding. We get 16 bytes of pseudo random key stream per invocation of the AES encryption function, which gets XOR ed with the plaintext to get the corresponding ciphertext. When reading a file in programming languages like C or C++ or Python you can specify the number of bytes to read , while looping till you reach the end of file. It is advisable to choose a multiple of 16 in this case like 1024*1024 bytes or more, but keeping hardware limitations and efficiency in mind. Reading 16 bytes for every loop interation is inefficient. You can find an optimal value to read by trial and error, and some benchmarking. The number of bytes successfully read by these functions provided by those programming languages can also be checked (let that be called x). Suppose you read a file of arbitrary length in blocks of bytes (which is a multiple of 16 ) , there are two possibilities, either the last block read might be exactly your block size (16*n) or less than it. In either case, you have to invoke the AES encryption function n times, but you use only, bytes of the key stream for the XOR with the plaintext.

AES GCM is a version of AES in counter mode, and a counter mode converts a block cipher into a stream cipher. The main advantage of a stream cipher is that we do not have to worry about padding. We get 16 bytes of pseudo random key stream per invocation of the AES encryption function, which gets XOR ed with the plaintext to get the corresponding ciphertext. When reading a file in programming languages like C or C++ or Python you can specify the number of bytes to read , while looping till you reach the end of file. It is advisable to choose a multiple of 16 in this case like 1024*1024 bytes or more, but keeping hardware limitations and efficiency in mind. Reading 16 bytes for every loop interation is inefficient. You can find an optimal value to read by trial and error, and some benchmarking. The number of bytes successfully read by these functions provided by those programming languages can also be checked (let that be called x). In the case of Python:

MY_BLOCK_SIZE = 1024*1024

with open(filename, "rb") as fobj:
     run = True
     while run:
         data = fobj.read(MY_BLOCK_SIZE)
         if len(data)==0 :
                 break
         elif (len(data)%MY_BLOCK_SIZE) == 0:
              #invoke AES encryption function MY_BLOCK_SIZE/16 times incrementing the counter each time
             # do all the things for calculating the authentication tag
              # Ciphertext is XOR(data, key_stream, len(data))
         else:
             #invoke AES encryption function MY_BLOCK_SIZE/16 times incrementing the counter each time # do all the things for calculating the authentication  # Ciphertext is XOR(data, key_stream, len(data))
     

Suppose you read a file of arbitrary length in blocks of bytes (which is a multiple of 16 ) , there are two possibilities, either the last block read might be exactly your block size (x = 16*n) or less than it (x < 16*n). In either case, you have to invoke the AES encryption function n times, but you use only, x bytes of the key stream, generated for that iteration, to XOR with the plaintext.

AES GCM is a version of AES in counter mode, and a counter mode converts a block cipher into a stream cipher. The main advantage of a stream cipher is that we do not have to worry about padding. We get 16 bytes of pseudo random key stream per invocation of the AES encryption function, which gets XOR ed with the plaintext to get the corresponding ciphertext. When reading a file in programming languages like C or C++ or Python you can specify the number of bytes to read (choose a multiple of 16), while looping till you reach the end of file. The number of bytes read by these functions successfully can also be checked (let that be called $x$). Suppose you read a file of arbitrary length in blocks of bytes (which is a multiple of 16 ) , there are two possibilities, either the last block read might be exactly your block size (16*n) or less than it. In either case, you have to invoke the AES encryption function n times, but you use only, $x$ bytes of the key stream for the XOR with the plaintext.

AES GCM is a version of AES in counter mode, and a counter mode converts a block cipher into a stream cipher. The main advantage of a stream cipher is that we do not have to worry about padding. We get 16 bytes of pseudo random key stream per invocation of the AES encryption function, which gets XOR ed with the plaintext to get the corresponding ciphertext. When reading a file in programming languages like C or C++ or Python you can specify the number of bytes to read , while looping till you reach the end of file. It is advisable to choose a multiple of 16 in this case like 1024*1024 bytes or more, but keeping hardware limitations and efficiency in mind. Reading 16 bytes for every loop interation is inefficient. You can find an optimal value to read by trial and error, and some benchmarking. The number of bytes successfully read by these functions provided by those programming languages can also be checked (let that be called x). Suppose you read a file of arbitrary length in blocks of bytes (which is a multiple of 16 ) , there are two possibilities, either the last block read might be exactly your block size (16*n) or less than it. In either case, you have to invoke the AES encryption function n times, but you use only, bytes of the key stream for the XOR with the plaintext.