Botan::PKCS7_Padding Class Reference

#include <mode_pad.h>

Inheritance diagram for Botan::PKCS7_Padding:

Public Member Functions
void	add_padding (secure_vector< uint8_t > &buffer, size_t final_block_bytes, size_t block_size) const override
std::string	name () const override
size_t	unpad (const uint8_t[], size_t) const override
bool	valid_blocksize (size_t bs) const override

Static Public Member Functions
static std::unique_ptr< BlockCipherModePaddingMethod >	create (std::string_view algo_spec)

Detailed Description

PKCS#7 Padding

Definition at line 70 of file mode_pad.h.

Member Function Documentation

add_padding()

void Botan::PKCS7_Padding::add_padding ( secure_vector< uint8_t > & buffer, size_t final_block_bytes, size_t block_size ) const

overridevirtual

Add padding bytes to buffer.

Parameters

buffer	data to pad
final_block_bytes	size of the final block in bytes
block_size	size of each block in bytes

Implements Botan::BlockCipherModePaddingMethod.

Definition at line 46 of file mode_pad.cpp.

                                                                                                     {
   /*
   Padding format is
   01
   0202
   030303
   ...
   */
   BOTAN_DEBUG_ASSERT(last_byte_pos < BS);
 
   const uint8_t padding_len = static_cast<uint8_t>(BS - last_byte_pos);
 
   buffer.resize(buffer.size() + padding_len);
 
   CT::poison(&last_byte_pos, 1);
   CT::poison(buffer.data(), buffer.size());
 
   BOTAN_DEBUG_ASSERT(buffer.size() % BS == 0);
   BOTAN_DEBUG_ASSERT(buffer.size() >= BS);
 
   const size_t start_of_last_block = buffer.size() - BS;
   const size_t end_of_last_block = buffer.size();
   const size_t start_of_padding = buffer.size() - padding_len;
 
   for(size_t i = start_of_last_block; i != end_of_last_block; ++i) {
      auto needs_padding = CT::Mask<uint8_t>(CT::Mask<size_t>::is_gte(i, start_of_padding));
      buffer[i] = needs_padding.select(padding_len, buffer[i]);
   }
 
   CT::unpoison(buffer.data(), buffer.size());
   CT::unpoison(last_byte_pos);
}

References BOTAN_DEBUG_ASSERT, Botan::CT::poison(), and Botan::CT::unpoison().

create()

std::unique_ptr< BlockCipherModePaddingMethod > Botan::BlockCipherModePaddingMethod::create ( std::string_view algo_spec )

staticinherited

Get a block cipher padding mode by name (eg "NoPadding" or "PKCS7")

Parameters

algo_spec

block cipher padding mode name

Get a block cipher padding method by name

Definition at line 19 of file mode_pad.cpp.

                                                                                                         {
   if(algo_spec == "NoPadding") {
      return std::make_unique<Null_Padding>();
   }
 
   if(algo_spec == "PKCS7") {
      return std::make_unique<PKCS7_Padding>();
   }
 
   if(algo_spec == "OneAndZeros") {
      return std::make_unique<OneAndZeros_Padding>();
   }
 
   if(algo_spec == "X9.23") {
      return std::make_unique<ANSI_X923_Padding>();
   }
 
   if(algo_spec == "ESP") {
      return std::make_unique<ESP_Padding>();
   }
 
   return nullptr;
}

Referenced by Botan::Cipher_Mode::create().

name()

std::string Botan::PKCS7_Padding::name ( ) const

inlineoverridevirtual

Returns

name of the mode

Implements Botan::BlockCipherModePaddingMethod.

Definition at line 78 of file mode_pad.h.

{ return "PKCS7"; }

unpad()

size_t Botan::PKCS7_Padding::unpad ( const uint8_t block[], size_t len ) const

overridevirtual

Remove padding bytes from block

Parameters

block	the last block
len	the size of the block in bytes

Returns

number of data bytes, or if the padding is invalid returns len

Implements Botan::BlockCipherModePaddingMethod.

Definition at line 82 of file mode_pad.cpp.

                                                                            {
   if(!valid_blocksize(input_length)) {
      return input_length;
   }
 
   CT::poison(input, input_length);
 
   const uint8_t last_byte = input[input_length - 1];
 
   /*
   The input should == the block size so if the last byte exceeds
   that then the padding is certainly invalid
   */
   auto bad_input = CT::Mask<size_t>::is_gt(last_byte, input_length);
 
   const size_t pad_pos = input_length - last_byte;
 
   for(size_t i = 0; i != input_length - 1; ++i) {
      // Does this byte equal the expected pad byte?
      const auto pad_eq = CT::Mask<size_t>::is_equal(input[i], last_byte);
 
      // Ignore values that are not part of the padding
      const auto in_range = CT::Mask<size_t>::is_gte(i, pad_pos);
      bad_input |= in_range & (~pad_eq);
   }
 
   CT::unpoison(input, input_length);
 
   return bad_input.select_and_unpoison(input_length, pad_pos);
}

References Botan::CT::Mask< T >::is_equal(), Botan::CT::Mask< T >::is_gt(), Botan::CT::Mask< T >::is_gte(), Botan::CT::poison(), Botan::CT::unpoison(), and valid_blocksize().

valid_blocksize()

bool Botan::PKCS7_Padding::valid_blocksize ( size_t block_size ) const

inlineoverridevirtual

Parameters

block_size

of the cipher

Returns

valid block size for this padding mode

Implements Botan::BlockCipherModePaddingMethod.

Definition at line 76 of file mode_pad.h.

{ return (bs > 2 && bs < 256); }

Referenced by unpad().

---

The documentation for this class was generated from the following files:

• src/lib/modes/mode_pad/mode_pad.h
• src/lib/modes/mode_pad/mode_pad.cpp