Botan  1.11.15
Public Member Functions | Static Public Member Functions
Botan::mceliece_message_parts Class Reference

#include <mceliece.h>

List of all members.

Public Member Functions

secure_vector< byteget_concat () const
secure_vector< gf2mget_error_positions () const
secure_vector< byteget_error_vector () const
secure_vector< byteget_message_word () const
 mceliece_message_parts (const secure_vector< gf2m > &err_pos, const byte *message, u32bit message_length, u32bit code_length)
 mceliece_message_parts (const secure_vector< gf2m > &err_pos, const secure_vector< byte > &message, unsigned code_length)
 mceliece_message_parts (const byte *message_concat_errors, size_t message_concat_errors_len, unsigned code_length)

Static Public Member Functions

static secure_vector< byteerror_vector_from_error_positions (const gf2m *err_pos, size_t err_pos_len, size_t code_length)

Detailed Description

Definition at line 28 of file mceliece.h.


Constructor & Destructor Documentation

Botan::mceliece_message_parts::mceliece_message_parts ( const secure_vector< gf2m > &  err_pos,
const byte message,
u32bit  message_length,
u32bit  code_length 
) [inline]

Definition at line 32 of file mceliece.h.

References Botan::copy_mem().

                                                                                                                                 :
         m_error_vector(error_vector_from_error_positions(&err_pos[0], err_pos.size(), code_length)),
         m_code_length(code_length)
         {
         m_message_word.resize(message_length);
         copy_mem(&m_message_word[0], message, message_length);
         }
Botan::mceliece_message_parts::mceliece_message_parts ( const secure_vector< gf2m > &  err_pos,
const secure_vector< byte > &  message,
unsigned  code_length 
) [inline]

Definition at line 40 of file mceliece.h.

                                                                                                                           :
         m_error_vector(error_vector_from_error_positions(&err_pos[0], err_pos.size(), code_length)),
         m_message_word(message),
         m_code_length(code_length)
         {}
Botan::mceliece_message_parts::mceliece_message_parts ( const byte message_concat_errors,
size_t  message_concat_errors_len,
unsigned  code_length 
) [inline]

Definition at line 62 of file mceliece.h.

References Botan::copy_mem().

                                                                                                                        :
         m_code_length(code_length)
         {
         size_t err_vec_len = (code_length+7)/8;
         if(message_concat_errors_len < err_vec_len )
            {
            throw Invalid_Argument("cannot split McEliece message parts");
            }
         size_t err_vec_start_pos = message_concat_errors_len - err_vec_len;
         m_message_word = secure_vector<byte>(err_vec_start_pos );
         copy_mem(&m_message_word[0], &message_concat_errors[0], err_vec_start_pos);
         m_error_vector = secure_vector<byte>(err_vec_len );
         copy_mem(&m_error_vector[0],  &message_concat_errors[err_vec_start_pos], err_vec_len);
         }

Member Function Documentation

static secure_vector<byte> Botan::mceliece_message_parts::error_vector_from_error_positions ( const gf2m err_pos,
size_t  err_pos_len,
size_t  code_length 
) [inline, static]

Definition at line 46 of file mceliece.h.

References _BITP_TO_BYTEOFFS, and _BITP_TO_BYTEP.

         {
         secure_vector<byte> result((code_length+7)/8);
         for(unsigned i = 0; i < err_pos_len; i++)
            {
            u16bit pos = err_pos[i];
            u32bit byte_pos = _BITP_TO_BYTEP(pos);
            if(byte_pos > result.size())
               {
               throw Invalid_Argument("error position larger than code size");
               }
            result[byte_pos] |= (1 << _BITP_TO_BYTEOFFS(pos));
            }
         return result;
         }
secure_vector<byte> Botan::mceliece_message_parts::get_concat ( ) const [inline]

Definition at line 77 of file mceliece.h.

References Botan::copy_mem().

Referenced by Botan::McEliece_PrivateKey::check_key(), and Botan::McEliece_KEM_Encryptor::encrypt().

         {
         secure_vector<byte> result(m_error_vector.size() + m_message_word.size());
         copy_mem(&result[0], &m_message_word[0], m_message_word.size());
         copy_mem(&result[m_message_word.size()], &m_error_vector[0], m_error_vector.size());
         return result;
         }
secure_vector<gf2m> Botan::mceliece_message_parts::get_error_positions ( ) const [inline]

Definition at line 85 of file mceliece.h.

References _BITP_TO_BYTEOFFS, and _BITP_TO_BYTEP.

Referenced by Botan::McEliece_Public_Operation::encrypt().

         {
         secure_vector<gf2m> result;
         for(unsigned i = 0; i < m_code_length; i++)
            {
            if(i >= m_code_length)
               {
               throw Invalid_Argument("index out of range in get_error_positions()");
               }
            if((m_error_vector[_BITP_TO_BYTEP(i)] >> _BITP_TO_BYTEOFFS(i)) & 1)
               {
               result.push_back(i);
               }
            }
         return result;
         }
secure_vector<byte> Botan::mceliece_message_parts::get_error_vector ( ) const [inline]

Definition at line 102 of file mceliece.h.

{ return m_error_vector; }
secure_vector<byte> Botan::mceliece_message_parts::get_message_word ( ) const [inline]

Definition at line 103 of file mceliece.h.

{ return m_message_word; }

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