1 /*

     2 * Copyright (c) 2001-2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  EAP and WLAN authentication protocols.

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #if !defined( _EAP_CRYPTO_API_H_ )

    22 #define _EAP_CRYPTO_API_H_

    23 

    24 #include "eap_am_types.h"

    25 #include "eap_variable_data.h"

    26 #include "eap_am_export.h"

    27 #include "abs_eap_am_crypto.h"

    28 #include "eap_array.h"

    29 

    30 #if defined(des_set_key)

    31 // OpenSSL defines this.

    32 #undef des_set_key

    33 #endif //#if defined(des_set_key)

    34 

    35 

    36 const u32_t HMAC_SHA1_SIZE = 20u; // bytes = 160 bits

    37 const u32_t HMAC_SHA1_128_SIZE = 16u; // bytes = 128 bits

    38 const u32_t HMAC_MD5_SIZE = 20u; // bytes = 160 bits

    39 const u32_t HMAC_MD5_128_SIZE = 16u; // bytes = 128 bits

    40 

    41 const u32_t WPA_PSK_LENGTH = 32;

    42 

    43 /// The abs_crypto_block_algorithm_c class describes interface of CBC block encryption algorithm.

    44 class EAP_EXPORT abs_crypto_cbc_block_algorithm_c

    45 {

    46 

    47 	// - - - - - - - - - - - - - - - - - - - - - - - -

    48 private:

    49 	// - - - - - - - - - - - - - - - - - - - - - - - -

    50 

    51 

    52 	// - - - - - - - - - - - - - - - - - - - - - - - -

    53 public:

    54 	// - - - - - - - - - - - - - - - - - - - - - - - -

    55 

    56 	EAP_FUNC_IMPORT virtual ~abs_crypto_cbc_block_algorithm_c();

    57 

    58 	/**

    59 	 * The set_is_valid() function sets the state of the

    60 	 * abs_crypto_block_algorithm_c object valid. The abs_crypto_block_algorithm_c object 

    61 	 * calls this function after it is initialized.

    62 	 */

    63 	virtual void set_is_valid() = 0;

    64 

    65 	/**

    66 	 * The get_is_valid() function returns the status of the abs_crypto_block_algorithm_c object.

    67 	 * True indicates the object is initialized.

    68 	 */

    69 	virtual bool get_is_valid() = 0;

    70 

    71 	// - - - - - - - - - - - - - - - - - - - - - - - -

    72 

    73 	/**

    74 	 * The get_encrypts() function returns true when encryption is initialized.

    75 	 * It returns false when decryption is initialized.

    76 	 */

    77 	virtual bool get_encrypts() = 0;

    78 

    79 	/**

    80 	 * This function returns the length of AES key in bytes.

    81 	 */

    82 	virtual u32_t get_key_length() = 0;

    83 

    84 	/**

    85 	 * This function returns the length of AES block size in bytes.

    86 	 */

    87 	virtual u32_t get_block_size() = 0;

    88 

    89 	/**

    90 	 * Calculates the data length aligned to block size.

    91 	 */

    92 	virtual u32_t aligned_data_length(

    93 		u32_t data_length) = 0;

    94 

    95 	/**

    96 	 * This function returns the internally stored initialization vector.

    97 	 * The last encrypted and decrypted block is stored to this buffer 

    98 	 * between subsequent encryption and decryption calls. 

    99 	 * User of crypto_cbc_c object could get the last stored block calling this function.

   100 	 */

   101 	virtual const eap_variable_data_c * get_tmp_IV() = 0;

   102 

   103 	/**

   104 	 * This function adds count padding bytes to buffer. All padding bytes are zero (0x00).

   105 	 */

   106 	virtual eap_status_e add_padding_bytes(

   107 		void * const buffer,

   108 		const u32_t buffer_length,

   109 		const u8_t padding_byte) = 0;

   110 

   111 	/**

   112 	 * This function checks the count padding bytes of buffer are zero (0x00).

   113 	 */

   114 	virtual eap_status_e check_padding_bytes(

   115 		const void * const buffer,

   116 		const u32_t buffer_length,

   117 		const u8_t padding_byte) = 0;

   118 

   119 	/**

   120 	 * This function sets the mode to encryption, 

   121 	 * sets the initialization vector and the encryption key.

   122 	 */

   123 	virtual eap_status_e set_encryption_key(

   124 		const void * const encryption_IV,

   125 		const u32_t encryption_IV_length,

   126 		const void * const key,

   127 		const u32_t key_length) = 0;

   128 

   129 	/**

   130 	 * This function sets the mode to decryption, 

   131 	 * sets the initialization vector and the decryption key.

   132 	 */

   133 	virtual eap_status_e set_decryption_key(

   134 		const void * const encryption_IV,

   135 		const u32_t encryption_IV_length,

   136 		const void * const key,

   137 		const u32_t key_length) = 0;

   138 

   139 	/**

   140 	 * This function encrypts continuous data bytes from data_in to data_out buffer. 

   141 	 * Note the length of the data must be aligned to block size of the cipher.

   142 	 */

   143 	virtual eap_status_e encrypt_data(

   144 		const void * const data_in,

   145 		void * const data_out,

   146 		const u32_t data_length) = 0;

   147 

   148 	/**

   149 	 * This function encrypts continuous data bytes in data_in_out buffer. 

   150 	 * Note the length of the data must be aligned to block size of the cipher.

   151 	 */

   152 	virtual eap_status_e encrypt_data(

   153 		void * const data_in_out,

   154 		const u32_t data_length) = 0;

   155 

   156 	/**

   157 	 * This function decrypts continuous data bytes from data_in to data_out buffer. 

   158 	 * Note the length of the data must be aligned to block size of the cipher.

   159 	 */

   160 	virtual eap_status_e decrypt_data(

   161 		const void * const data_in,

   162 		void * const data_out,

   163 		const u32_t data_length) = 0;

   164 

   165 	/**

   166 	 * This function decrypts continuous data bytes in data_in_out buffer. 

   167 	 * Note the length of the data must be aligned to block size of the cipher.

   168 	 */

   169 	virtual eap_status_e decrypt_data(

   170 		void * const data_in_out,

   171 		const u32_t data_length) = 0;

   172 

   173 	// - - - - - - - - - - - - - - - - - - - - - - - -

   174 

   175 	/**

   176 	 * The update_non_aligned() function updates the context of 

   177 	 * AES-algorithm with data bytes. The direction (encryption/decryption) 

   178 	 * depends of the initialized context. NOTE the length of data feed in 

   179 	 * separate calls of update_non_aligned() does not need to be 

   180 	 * aligned to AES-block size. Only the sum of whole data must be aligned to AES-block size.

   181 	 * This version takes pointers to input and output buffers as a parameter. 

   182 	 * Those buffers must be fully separated. Some optimizations are used 

   183 	 * taking advance from separate buffers. 

   184 	 */

   185 	virtual eap_status_e update_non_aligned(

   186 		const void * const msg_in,

   187 		void * const msg_out,

   188 		const u32_t msg_size) = 0;

   189 

   190 	// - - - - - - - - - - - - - - - - - - - - - - - -

   191 

   192 	/**

   193 	 * The update_non_aligned() function updates the context of 

   194 	 * AES-algorithm with data bytes. The direction (encryption/decryption) 

   195 	 * depends of the initialized context. NOTE the length of data feed in 

   196 	 * separate calls of update_non_aligned() does not need to be 

   197 	 * aligned to AES-block size. Only the sum of whole data must be aligned to AES-block size.

   198 	 * This version takes one pointer to buffer. The buffer is used for input and output data. 

   199 	 */

   200 	virtual eap_status_e update_non_aligned(

   201 		void * const msg_in_out,

   202 		const u32_t msg_size) = 0;

   203 

   204 	// - - - - - - - - - - - - - - - - - - - - - - - -

   205 

   206 	/**

   207 	 * The finalize_non_aligned() finalizes the AES-context. 

   208 	 * The sum of length of feed data must be aligned to AES-block size 

   209 	 * before this function is called.

   210 	 */

   211 	virtual eap_status_e finalize_non_aligned() = 0;

   212 

   213 	// - - - - - - - - - - - - - - - - - - - - - - - -

   214 };

   215 

   216 

   217 

   218 /// The abs_crypto_block_algorithm_c class describes interface of block encryption algorithm.

   219 class EAP_EXPORT abs_crypto_block_algorithm_c

   220 {

   221 

   222 	// - - - - - - - - - - - - - - - - - - - - - - - -

   223 private:

   224 	// - - - - - - - - - - - - - - - - - - - - - - - -

   225 

   226 

   227 	// - - - - - - - - - - - - - - - - - - - - - - - -

   228 public:

   229 	// - - - - - - - - - - - - - - - - - - - - - - - -

   230 

   231 	EAP_FUNC_IMPORT virtual ~abs_crypto_block_algorithm_c();

   232 

   233 	/**

   234 	 * The set_is_valid() function sets the state of the

   235 	 * abs_crypto_block_algorithm_c object valid. The abs_crypto_block_algorithm_c object 

   236 	 * calls this function after it is initialized.

   237 	 */

   238 	virtual void set_is_valid() = 0;

   239 

   240 	/**

   241 	 * The get_is_valid() function returns the status of the abs_crypto_block_algorithm_c object.

   242 	 * True indicates the object is initialized.

   243 	 */

   244 	virtual bool get_is_valid() = 0;

   245 

   246 	// - - - - - - - - - - - - - - - - - - - - - - - -

   247 

   248 	/**

   249 	 * The get_encrypts() function returns true when encryption is initialized.

   250 	 * It returns false when decryption is initialized.

   251 	 */

   252 	virtual bool get_encrypts() = 0;

   253 

   254 	/**

   255 	 * This function returns the length of key in bytes.

   256 	 */

   257 	virtual u32_t get_key_length() = 0;

   258 

   259 	/**

   260 	 * This function returns the length of block size in bytes.

   261 	 */

   262 	virtual u32_t get_block_size() = 0;

   263 

   264 	/**

   265 	 * This function sets the mode to encryption, 

   266 	 * sets the initialization vector and the encryption key.

   267 	 */

   268 	virtual eap_status_e set_encryption_key(

   269 		const void * const key,

   270 		const u32_t key_length) = 0;

   271 

   272 	/**

   273 	 * This function sets the mode to decryption, 

   274 	 * sets the initialization vector and the decryption key.

   275 	 */

   276 	virtual eap_status_e set_decryption_key(

   277 		const void * const key,

   278 		const u32_t key_length) = 0;

   279 

   280 	/**

   281 	 * This function encrypts continuous data bytes from data_in to data_out buffer. 

   282 	 * Note the length of the data must be aligned to block size of the cipher.

   283 	 */

   284 	virtual eap_status_e encrypt_block(

   285 		const void * const data_in,

   286 		void * const data_out,

   287 		const u32_t data_length) = 0;

   288 

   289 	/**

   290 	 * This function decrypts continuous data bytes from data_in to data_out buffer. 

   291 	 * Note the length of the data must be aligned to block size of the cipher.

   292 	 */

   293 	virtual eap_status_e decrypt_block(

   294 		const void * const data_in,

   295 		void * const data_out,

   296 		const u32_t data_length) = 0;

   297 

   298 	// - - - - - - - - - - - - - - - - - - - - - - - -

   299 };

   300 

   301 

   302 

   303 /// The abs_crypto_stream_algorithm_c class describes interface of stream encryption algorithm.

   304 class EAP_EXPORT abs_crypto_stream_algorithm_c

   305 {

   306 

   307 	// - - - - - - - - - - - - - - - - - - - - - - - -

   308 private:

   309 	// - - - - - - - - - - - - - - - - - - - - - - - -

   310 

   311 

   312 	// - - - - - - - - - - - - - - - - - - - - - - - -

   313 public:

   314 	// - - - - - - - - - - - - - - - - - - - - - - - -

   315 

   316 	EAP_FUNC_IMPORT virtual ~abs_crypto_stream_algorithm_c();

   317 

   318 	/**

   319 	 * The set_is_valid() function sets the state of the

   320 	 * abs_crypto_block_algorithm_c object valid. The abs_crypto_block_algorithm_c object 

   321 	 * calls this function after it is initialized.

   322 	 */

   323 	virtual void set_is_valid() = 0;

   324 

   325 	/**

   326 	 * The get_is_valid() function returns the status of the abs_crypto_block_algorithm_c object.

   327 	 * True indicates the object is initialized.

   328 	 */

   329 	virtual bool get_is_valid() = 0;

   330 

   331 	// - - - - - - - - - - - - - - - - - - - - - - - -

   332 

   333 	/**

   334 	 * This function sets the key.

   335 	 */

   336 	virtual eap_status_e set_key(

   337 		const eap_variable_data_c * const key) = 0;

   338 

   339 	/**

   340 	 * This function discards desired count of stream.

   341 	 */

   342 	virtual eap_status_e discard_stream(const u32_t count_of_discarded_octets) = 0;

   343 

   344 	/**

   345 	 * This function encrypts continuous data bytes in data_in_out buffer. 

   346 	 */

   347 	virtual eap_status_e encrypt_data(

   348 		void * const data_in_out,

   349 		const u32_t data_length) = 0;

   350 

   351 	/**

   352 	 * This function encrypts continuous data bytes from data_in to data_out buffer. 

   353 	 */

   354 	virtual eap_status_e encrypt_data(

   355 		const void * const data_in,

   356 		void * const data_out,

   357 		const u32_t data_length) = 0;

   358 

   359 	/**

   360 	 * This function encrypts continuous data bytes in data_in_out buffer. 

   361 	 */

   362 	virtual eap_status_e decrypt_data(

   363 		void * const data_in_out,

   364 		const u32_t data_length) = 0;

   365 

   366 	/**

   367 	 * This function decrypts continuous data bytes from data_in to data_out buffer. 

   368 	 */

   369 	virtual eap_status_e decrypt_data(

   370 		const void * const data_in,

   371 		void * const data_out,

   372 		const u32_t data_length) = 0;

   373 

   374 	// - - - - - - - - - - - - - - - - - - - - - - - -

   375 };

   376 

   377 

   378 

   379 /// The abs_crypto_hash_algorithm_c class describes interface the MAC algorithm.

   380 class EAP_EXPORT abs_crypto_hash_algorithm_c

   381 {

   382 

   383 	// - - - - - - - - - - - - - - - - - - - - - - - -

   384 private:

   385 	// - - - - - - - - - - - - - - - - - - - - - - - -

   386 

   387 

   388 	// - - - - - - - - - - - - - - - - - - - - - - - -

   389 public:

   390 	// - - - - - - - - - - - - - - - - - - - - - - - -

   391 

   392 	EAP_FUNC_IMPORT virtual ~abs_crypto_hash_algorithm_c();

   393 

   394 	/**

   395 	 * The set_is_valid() function sets the state of the

   396 	 * abs_crypto_hash_algorithm_c object valid. The abs_crypto_hash_algorithm_c object 

   397 	 * calls this function after it is initialized.

   398 	 */

   399 	virtual void set_is_valid() = 0;

   400 

   401 	/**

   402 	 * The get_is_valid() function returns the status of the abs_crypto_hash_algorithm_c object.

   403 	 * True indicates the object is initialized.

   404 	 */

   405 	virtual bool get_is_valid() = 0;

   406 

   407 	// - - - - - - - - - - - - - - - - - - - - - - - -

   408 

   409 	/**

   410 	 * This function returns the size of message digest of HASH-algorithm.

   411 	 */

   412 	virtual u32_t get_digest_length() = 0;

   413 

   414 	/**

   415 	 * This function returns the block size of HASH-algorithm.

   416 	 */

   417 	virtual u32_t get_block_size() = 0;

   418 

   419 	/**

   420 	 * This function sets the mode to encryption, 

   421 	 * sets the initialization vector and the encryption key.

   422 	 */

   423 	virtual eap_status_e hash_init() = 0;

   424 

   425 	/**

   426 	 * This function updates the context of HASH-algorithm with data.

   427 	 */

   428 	virtual eap_status_e hash_update(

   429 		const void * const data,

   430 		const u32_t data_length) = 0;

   431 

   432 	/**

   433 	 * This function writes the message digest to buffer. 

   434 	 * Length is set if md_length_or_null is non-NULL.

   435 	 */

   436 	virtual eap_status_e hash_final(

   437 		void * const message_digest,

   438 		u32_t *md_length_or_null) = 0;

   439 

   440 	/**

   441 	 * This function cleans up the HMAC-SHA1 context.

   442 	 */

   443 	virtual eap_status_e hash_cleanup() = 0;

   444 

   445 	/**

   446 	 * This function returns a copy of the context of HASH-algorithm.

   447 	 * Caller must free the copy.

   448 	 */

   449 	virtual abs_crypto_hash_algorithm_c * copy() = 0;

   450 

   451 	// - - - - - - - - - - - - - - - - - - - - - - - -

   452 };

   453 

   454 

   455 //------------------------------------------------------------

   456 

   457 

   458 /// The abs_crypto_mac_algorithm_c class describes interface the HMAC algorithm.

   459 class EAP_EXPORT abs_crypto_hmac_algorithm_c

   460 {

   461 

   462 	// - - - - - - - - - - - - - - - - - - - - - - - -

   463 private:

   464 	// - - - - - - - - - - - - - - - - - - - - - - - -

   465 

   466 

   467 	// - - - - - - - - - - - - - - - - - - - - - - - -

   468 public:

   469 	// - - - - - - - - - - - - - - - - - - - - - - - -

   470 

   471 	EAP_FUNC_IMPORT virtual ~abs_crypto_hmac_algorithm_c();

   472 

   473 	/**

   474 	 * The set_is_valid() function sets the state of the

   475 	 * abs_crypto_mac_algorithm_c object valid. The abs_crypto_mac_algorithm_c object 

   476 	 * calls this function after it is initialized.

   477 	 */

   478 	virtual void set_is_valid() = 0;

   479 

   480 	/**

   481 	 * The get_is_valid() function returns the status of the abs_crypto_mac_algorithm_c object.

   482 	 * True indicates the object is initialized.

   483 	 */

   484 	virtual bool get_is_valid() = 0;

   485 

   486 	// - - - - - - - - - - - - - - - - - - - - - - - -

   487 

   488 	/**

   489 	 * This function returns the size of message digest of HMAC-algorithm.

   490 	 */

   491 	virtual u32_t get_digest_length() = 0;

   492 

   493 	/**

   494 	 * This function sets the mode to encryption, 

   495 	 * sets the initialization vector and the encryption key.

   496 	 */

   497 	virtual eap_status_e hmac_set_key(

   498 		const eap_variable_data_c * const mac_key) = 0;

   499 

   500 	/**

   501 	 * This function updates the context of HMAC-algorithm with data.

   502 	 */

   503 	virtual eap_status_e hmac_update(

   504 		const void * const data,

   505 		const u32_t data_length) = 0;

   506 

   507 	/**

   508 	 * This function writes the message digest to buffer. 

   509 	 * Length is set if md_length_or_null is non-NULL.

   510 	 */

   511 	virtual eap_status_e hmac_final(

   512 		void * const message_digest,

   513 		u32_t *md_length_or_null) = 0;

   514 

   515 	/**

   516 	 * This function cleans up the HMAC context.

   517 	 */

   518 	virtual eap_status_e hmac_cleanup() = 0;

   519 

   520 	// - - - - - - - - - - - - - - - - - - - - - - - -

   521 };

   522 

   523 

   524 //------------------------------------------------------------

   525 

   526 

   527 /// The crypto_hmac_c class describes HMAC algorithm.

   528 class EAP_EXPORT crypto_hmac_c

   529 : public abs_crypto_hmac_algorithm_c

   530 {

   531 

   532 	// - - - - - - - - - - - - - - - - - - - - - - - -

   533 private:

   534 	// - - - - - - - - - - - - - - - - - - - - - - - -

   535 

   536 	/// This is pointer to the tools class.

   537 	abs_eap_am_tools_c * const m_am_tools;

   538 

   539 	/// This is pointer to the block encryption algorithm.

   540 	abs_crypto_hash_algorithm_c * m_crypto_hash_algorithm;

   541 

   542 	/// This is the initialized key.

   543 	eap_variable_data_c * m_key;

   544 

   545 	/// This is the initialized inner pad.

   546 	eap_variable_data_c * m_ipad;

   547 

   548 	/// This is the initialized outer pad.

   549 	eap_variable_data_c * m_opad;

   550 

   551 	/// This indicates whether this object was generated successfully.

   552 	bool m_is_valid;

   553 

   554 	/// This object must free m_crypto_hash_algorithm when this value is true.

   555 	bool m_free_crypto_hash_algorithm;

   556 

   557 

   558 	EAP_FUNC_IMPORT eap_status_e initialize_pad(

   559 		eap_variable_data_c * const p_pad,

   560 		const u8_t pad_value);

   561 

   562 	// - - - - - - - - - - - - - - - - - - - - - - - -

   563 public:

   564 	// - - - - - - - - - - - - - - - - - - - - - - - -

   565 

   566 	/**

   567 	 * Destructor resets the used internal buffers.

   568 	 */

   569 	EAP_FUNC_IMPORT virtual ~crypto_hmac_c();

   570 

   571 	/**

   572 	 * Constructor initializes the used internal buffers.

   573 	 */

   574 	EAP_FUNC_IMPORT crypto_hmac_c(

   575 		abs_eap_am_tools_c * const tools,

   576 		abs_crypto_hash_algorithm_c * const crypto_hash_algorithm,

   577 		const bool free_crypto_hash_algorithm);

   578 

   579 	/**

   580 	 * The set_is_valid() function sets the state of the

   581 	 * abs_crypto_mac_algorithm_c object valid. The abs_crypto_mac_algorithm_c object 

   582 	 * calls this function after it is initialized.

   583 	 */

   584 	EAP_FUNC_IMPORT void set_is_valid();

   585 

   586 	/**

   587 	 * The get_is_valid() function returns the status of the abs_crypto_mac_algorithm_c object.

   588 	 * True indicates the object is initialized.

   589 	 */

   590 	EAP_FUNC_IMPORT bool get_is_valid();

   591 

   592 	// - - - - - - - - - - - - - - - - - - - - - - - -

   593 

   594 	/**

   595 	 * This function returns the size of message digest of HMAC-algorithm.

   596 	 */

   597 	EAP_FUNC_IMPORT u32_t get_digest_length();

   598 

   599 	/**

   600 	 * This function sets the mode to encryption, 

   601 	 * sets the initialization vector and the encryption key.

   602 	 */

   603 	EAP_FUNC_IMPORT eap_status_e hmac_set_key(

   604 		const eap_variable_data_c * const hmac_key);

   605 

   606 	/**

   607 	 * This function updates the context of HMAC-algorithm with data.

   608 	 */

   609 	EAP_FUNC_IMPORT eap_status_e hmac_update(

   610 		const void * const data,

   611 		const u32_t data_length);

   612 

   613 	/**

   614 	 * This function writes the message digest to buffer. 

   615 	 * Length is set if md_length_or_null is non-NULL.

   616 	 */

   617 	EAP_FUNC_IMPORT eap_status_e hmac_final(

   618 		void * const message_digest,

   619 		u32_t *md_length_or_null);

   620 

   621 	/**

   622 	 * This function writes the message digest of HMAC of 128 bits in length to buffer. 

   623 	 * Length is set if md_length_or_null is non-NULL.

   624 	 */

   625 	EAP_FUNC_IMPORT eap_status_e hmac_128_final(

   626 		void * const message_digest,

   627 		u32_t *md_length_or_null);

   628 

   629 	/**

   630 	 * This function cleans up the HMAC context.

   631 	 */

   632 	EAP_FUNC_IMPORT eap_status_e hmac_cleanup();

   633 

   634 	// - - - - - - - - - - - - - - - - - - - - - - - -

   635 };

   636 

   637 

   638 //------------------------------------------------------------

   639 

   640 /// The crypto_cbc_c class includes the state of 

   641 /// one instance of CBC block encryption algorithm.

   642 class EAP_EXPORT crypto_cbc_c

   643 : public abs_crypto_cbc_block_algorithm_c

   644 {

   645 

   646 	// - - - - - - - - - - - - - - - - - - - - - - - -

   647 private:

   648 	// - - - - - - - - - - - - - - - - - - - - - - - -

   649 

   650 	/// This is pointer to the tools class.

   651 	abs_eap_am_tools_c * const m_am_tools;

   652 

   653 	/// This is pointer to the block encryption algorithm.

   654 	abs_crypto_block_algorithm_c * m_crypto_block_algorithm;

   655 

   656 	/// This indicates whether this object was generated successfully.

   657 	bool m_is_valid;

   658 

   659 	/// This stores the initialization vector between subsequent

   660 	/// calls of encryption or decryption.

   661 	eap_variable_data_c * m_tmp_IV;

   662 

   663 	/// This stores the offset of non-aligned data between 

   664 	/// subsequent calls of encryption or decryption.

   665 	i32_t m_encr_offset;

   666 

   667 	/// This stores pointers to non-aligned data targets between 

   668 	/// subsequent calls of encryption or decryption.

   669 	u8_t **m_encr_dispatch;

   670 

   671 	/// This stores the non-aligned data between subsequent 

   672 	/// calls of encryption or decryption.

   673 	u8_t *m_encr_hold;

   674 

   675 	u8_t *m_saved_in_buffer;

   676 	u8_t *m_saved_out_buffer;

   677 

   678 	u8_t *m_iv_buffer_1;

   679 	u8_t *m_iv_buffer_2;

   680 

   681 	bool m_free_crypto_block_algorithm;

   682 

   683 	// - - - - - - - - - - - - - - - - - - - - - - - -

   684 

   685 	EAP_FUNC_IMPORT void reset();

   686 

   687 	/**

   688 	 * Run xor to data and IV block.

   689 	 */

   690 	EAP_FUNC_IMPORT void cbc_xor_block(

   691 		const void * const encryption_IV,

   692 		void * const data_block,

   693 		const u32_t block_size,

   694 		const u32_t key_length);

   695 

   696 	/**

   697 	 * Copies source to target.

   698 	 */

   699 	EAP_FUNC_IMPORT void cbc_copy_block(

   700 		void * const target,

   701 		const void * const source,

   702 		const u32_t block_size,

   703 		const u32_t key_length);

   704 

   705 	/**

   706 	 * This function encrypts continuous data bytes from data_in to data_out buffer. 

   707 	 * Note the length of the data must be aligned to block size of the cipher.

   708 	 */

   709 	EAP_FUNC_IMPORT eap_status_e internal_encrypt_data(

   710 		const void * const data_in,

   711 		void * const data_out,

   712 		const u32_t data_length);

   713 

   714 	/**

   715 	 * This function decrypts continuous data bytes from data_in to data_out buffer. 

   716 	 * Note the length of the data must be aligned to block size of the cipher.

   717 	 */

   718 	EAP_FUNC_IMPORT eap_status_e internal_decrypt_data(

   719 		const void * const data_in,

   720 		void * const data_out,

   721 		const u32_t data_length);

   722 

   723 

   724 	// - - - - - - - - - - - - - - - - - - - - - - - -

   725 public:

   726 	// - - - - - - - - - - - - - - - - - - - - - - - -

   727 

   728 	/**

   729 	 * Destructor resets the used internal buffers.

   730 	 */

   731 	EAP_FUNC_IMPORT virtual ~crypto_cbc_c();

   732 

   733 	/**

   734 	 * Constructor initializes the used internal buffers.

   735 	 */

   736 	EAP_FUNC_IMPORT crypto_cbc_c(

   737 		abs_eap_am_tools_c * const tools,

   738 		abs_crypto_block_algorithm_c * const crypto_block_algorithm,

   739 		const bool free_crypto_block_algorithm);

   740 

   741 	/**

   742 	 * The get_encrypts() function returns true when encryption is initialized.

   743 	 * It returns false when decryption is initialized.

   744 	 */

   745 	EAP_FUNC_IMPORT virtual bool get_encrypts();

   746 

   747 	/**

   748 	 * This function returns the length of CBC key in bytes.

   749 	 */

   750 	EAP_FUNC_IMPORT virtual u32_t get_key_length();

   751 

   752 	/**

   753 	 * This function returns the length of CBC block size in bytes.

   754 	 */

   755 	EAP_FUNC_IMPORT virtual u32_t get_block_size();

   756 

   757 	/**

   758 	 * The set_is_valid() function sets the state of the

   759 	 * crypto_cbc_c object valid. The crypto_cbc_c object 

   760 	 * calls this function after it is initialized.

   761 	 */

   762 	EAP_FUNC_IMPORT void set_is_valid();

   763 

   764 	/**

   765 	 * The get_is_valid() function returns the status of the crypto_cbc_c object.

   766 	 * True indicates the object is initialized.

   767 	 */

   768 	EAP_FUNC_IMPORT bool get_is_valid();

   769 

   770 	/**

   771 	 * This function returns the internally stored initialization vector.

   772 	 * The last encrypted and decrypted block is stored to this buffer 

   773 	 * between subsequent encryption and decryption calls. 

   774 	 * User of crypto_cbc_c object could get the last stored block calling this function.

   775 	 */

   776 	EAP_FUNC_IMPORT const eap_variable_data_c * get_tmp_IV();

   777 

   778 	// - - - - - - - - - - - - - - - - - - - - - - - -

   779 

   780 	/**

   781 	 * Calculates the data length aligned to block size.

   782 	 */

   783 	EAP_FUNC_IMPORT u32_t aligned_data_length(

   784 		u32_t data_length);

   785 

   786 	/**

   787 	 * This function adds count padding bytes to buffer. All padding bytes are zero (0x00).

   788 	 */

   789 	EAP_FUNC_IMPORT eap_status_e add_padding_bytes(

   790 		void * const buffer,

   791 		const u32_t buffer_length,

   792 		const u8_t padding_byte);

   793 

   794 	/**

   795 	 * This function checks the count padding bytes of buffer are zero (0x00).

   796 	 */

   797 	EAP_FUNC_IMPORT eap_status_e check_padding_bytes(

   798 		const void * const buffer,

   799 		const u32_t buffer_length,

   800 		const u8_t padding_byte);

   801 

   802 	/**

   803 	 * This function sets the mode to encryption, 

   804 	 * sets the initialization vector and the encryption key.

   805 	 */

   806 	EAP_FUNC_IMPORT eap_status_e set_encryption_key(

   807 		const void * const encryption_IV,

   808 		const u32_t encryption_IV_length,

   809 		const void * const key,

   810 		const u32_t key_length);

   811 

   812 	/**

   813 	 * This function sets the mode to decryption, 

   814 	 * sets the initialization vector and the decryption key.

   815 	 */

   816 	EAP_FUNC_IMPORT eap_status_e set_decryption_key(

   817 		const void * const encryption_IV,

   818 		const u32_t encryption_IV_length,

   819 		const void * const key,

   820 		const u32_t key_length);

   821 

   822 	/**

   823 	 * This function encrypts continuous data bytes from data_in to data_out buffer. 

   824 	 * Note the length of the data must be aligned to block size of the cipher.

   825 	 */

   826 	EAP_FUNC_IMPORT eap_status_e encrypt_data(

   827 		const void * const data_in,

   828 		void * const data_out,

   829 		const u32_t data_length);

   830 

   831 	/**

   832 	 * This function encrypts continuous data bytes in data_in_out buffer. 

   833 	 * Note the length of the data must be aligned to block size of the cipher.

   834 	 */

   835 	EAP_FUNC_IMPORT eap_status_e encrypt_data(

   836 		void * const data_in_out,

   837 		const u32_t data_length);

   838 

   839 	/**

   840 	 * This function decrypts continuous data bytes from data_in to data_out buffer. 

   841 	 * Note the length of the data must be aligned to block size of the cipher.

   842 	 */

   843 	EAP_FUNC_IMPORT eap_status_e decrypt_data(

   844 		const void * const data_in,

   845 		void * const data_out,

   846 		const u32_t data_length);

   847 

   848 	/**

   849 	 * This function decrypts continuous data bytes in data_in_out buffer. 

   850 	 * Note the length of the data must be aligned to block size of the cipher.

   851 	 */

   852 	EAP_FUNC_IMPORT eap_status_e decrypt_data(

   853 		void * const data_in_out,

   854 		const u32_t data_length);

   855 

   856 	// - - - - - - - - - - - - - - - - - - - - - - - -

   857 

   858 	/**

   859 	 * The update_non_aligned() function updates the context of 

   860 	 * CBC-algorithm with data bytes. The direction (encryption/decryption) 

   861 	 * depends of the initialized context. NOTE the length of data feed in 

   862 	 * separate calls of update_non_aligned() does not need to be 

   863 	 * aligned to CBC-block size. Only the sum of whole data must be aligned to CBC-block size.

   864 	 * This version takes pointers to input and output buffers as a parameter. 

   865 	 * Those buffers must be fully separated. Some optimizations are used 

   866 	 * taking advance from separate buffers. 

   867 	 */

   868 	EAP_FUNC_IMPORT eap_status_e update_non_aligned(

   869 		const void * const msg_in,

   870 		void * const msg_out,

   871 		const u32_t msg_size);

   872 

   873 	// - - - - - - - - - - - - - - - - - - - - - - - -

   874 

   875 	/**

   876 	 * The update_non_aligned() function updates the context of 

   877 	 * CBC-algorithm with data bytes. The direction (encryption/decryption) 

   878 	 * depends of the initialized context. NOTE the length of data feed in 

   879 	 * separate calls of update_non_aligned() does not need to be 

   880 	 * aligned to CBC-block size. Only the sum of whole data must be aligned to CBC-block size.

   881 	 * This version takes one pointer to buffer. The buffer is used for input and output data. 

   882 	 */

   883 	EAP_FUNC_IMPORT eap_status_e update_non_aligned(

   884 		void * const msg_in_out,

   885 		const u32_t msg_size);

   886 

   887 	// - - - - - - - - - - - - - - - - - - - - - - - -

   888 

   889 	/**

   890 	 * The finalize_non_aligned() finalizes the CBC-context. 

   891 	 * The sum of length of feed data must be aligned to CBC-block size 

   892 	 * before this function is called.

   893 	 */

   894 	EAP_FUNC_IMPORT eap_status_e finalize_non_aligned();

   895 

   896 	// - - - - - - - - - - - - - - - - - - - - - - - -

   897 };

   898 

   899 

   900 //------------------------------------------------------------

   901 

   902 /// The crypto_aes_c class includes the state of 

   903 /// one instance of AES block encryption algorithm.

   904 class EAP_EXPORT crypto_aes_c

   905 : public abs_crypto_block_algorithm_c

   906 {

   907 

   908 	// - - - - - - - - - - - - - - - - - - - - - - - -

   909 private:

   910 	// - - - - - - - - - - - - - - - - - - - - - - - -

   911 

   912 	/// This is pointer to the tools class.

   913 	abs_eap_am_tools_c * const m_am_tools;

   914 

   915 	/// This indicates whether this object was generated successfully.

   916 	bool m_is_valid;

   917 

   918 	/// Context is stored to this variable.

   919 	/// This hides the whole implementation.

   920 	/// This includes the context of AES-block cipher.

   921 	/// This depends on the crypto library.

   922 	eap_variable_data_c m_aes_context;

   923 

   924 	/// This is the used block size.

   925 	u32_t m_block_size;

   926 

   927 	/// This is set true when encryption is the current mode.

   928 	/// Decryption initializes this false.

   929 	bool m_encrypt;

   930 

   931 

   932 	// - - - - - - - - - - - - - - - - - - - - - - - -

   933 public:

   934 	// - - - - - - - - - - - - - - - - - - - - - - - -

   935 

   936 	/**

   937 	 * Destructor resets the used internal buffers.

   938 	 */

   939 	EAP_FUNC_IMPORT virtual ~crypto_aes_c();

   940 

   941 	/**

   942 	 * Constructor initializes the used internal buffers.

   943 	 */

   944 	EAP_FUNC_IMPORT crypto_aes_c(abs_eap_am_tools_c * const tools);

   945 

   946 	EAP_FUNC_IMPORT bool get_encrypts();

   947 

   948 	/**

   949 	 * The set_is_valid() function sets the state of the

   950 	 * crypto_aes_c object valid. The crypto_aes_c object 

   951 	 * calls this function after it is initialized.

   952 	 */

   953 	EAP_FUNC_IMPORT void set_is_valid();

   954 

   955 	/**

   956 	 * The get_is_valid() function returns the status of the crypto_aes_c object.

   957 	 * True indicates the object is initialized.

   958 	 */

   959 	EAP_FUNC_IMPORT bool get_is_valid();

   960 

   961 	/**

   962 	 * This function returns the length of AES key in bytes.

   963 	 */

   964 	EAP_FUNC_IMPORT u32_t get_key_length();

   965 

   966 	/**

   967 	 * This function returns the length of AES block size in bytes.

   968 	 */

   969 	EAP_FUNC_IMPORT u32_t get_block_size();

   970 

   971 

   972 	/**

   973 	 * This function sets the mode to encryption, 

   974 	 * sets the initialization vector and the encryption key.

   975 	 */

   976 	EAP_FUNC_IMPORT eap_status_e set_encryption_key(

   977 		const void * const key,

   978 		const u32_t key_length);

   979 

   980 	/**

   981 	 * This function sets the mode to decryption, 

   982 	 * sets the initialization vector and the decryption key.

   983 	 */

   984 	EAP_FUNC_IMPORT eap_status_e set_decryption_key(

   985 		const void * const key,

   986 		const u32_t key_length);

   987 

   988 	// - - - - - - - - - - - - - - - - - - - - - - - -

   989 

   990 	/**

   991 	 * This function encrypts continuous data bytes from data_in to data_out buffer. 

   992 	 * Note the length of the data must be aligned to block size of the cipher.

   993 	 */

   994 	EAP_FUNC_IMPORT eap_status_e encrypt_block(

   995 		const void * const data_in,

   996 		void * const data_out,

   997 		const u32_t data_length);

   998 

   999 	/**

  1000 	 * This function decrypts continuous data bytes from data_in to data_out buffer. 

  1001 	 * Note the length of the data must be aligned to block size of the cipher.

  1002 	 */

  1003 	EAP_FUNC_IMPORT eap_status_e decrypt_block(

  1004 		const void * const data_in,

  1005 		void * const data_out,

  1006 		const u32_t data_length);

  1007 

  1008 	// - - - - - - - - - - - - - - - - - - - - - - - -

  1009 };

  1010 

  1011 

  1012 //------------------------------------------------------------

  1013 

  1014 /// The crypto_3des_ede_c class includes the state of 

  1015 /// one instance of 3DES-EDE block encryption algorithm.

  1016 class EAP_EXPORT crypto_3des_ede_c

  1017 : public abs_crypto_block_algorithm_c

  1018 {

  1019 

  1020 	// - - - - - - - - - - - - - - - - - - - - - - - -

  1021 private:

  1022 	// - - - - - - - - - - - - - - - - - - - - - - - -

  1023 

  1024 	/// This is pointer to the tools class.

  1025 	abs_eap_am_tools_c * const m_am_tools;

  1026 

  1027 	/// This indicates whether this object was generated successfully.

  1028 	bool m_is_valid;

  1029 

  1030 	/// Context is stored to this variable.

  1031 	/// This hides the whole implementation.

  1032 	/// This includes the context of 3DES-EDE-block cipher.

  1033 	/// This depends on the crypto library.

  1034 	eap_variable_data_c m_context;

  1035 

  1036 	/// This is the used block size.

  1037 	u32_t m_block_size;

  1038 

  1039 	/// This is set true when encryption is the current mode.

  1040 	/// Decryption initializes this false.

  1041 	bool m_encrypt;

  1042 

  1043 

  1044 	// - - - - - - - - - - - - - - - - - - - - - - - -

  1045 public:

  1046 	// - - - - - - - - - - - - - - - - - - - - - - - -

  1047 

  1048 	/**

  1049 	 * Destructor resets the used internal buffers.

  1050 	 */

  1051 	EAP_FUNC_IMPORT virtual ~crypto_3des_ede_c();

  1052 

  1053 	/**

  1054 	 * Constructor initializes the used internal buffers.

  1055 	 */

  1056 	EAP_FUNC_IMPORT crypto_3des_ede_c(abs_eap_am_tools_c * const tools);

  1057 

  1058 	EAP_FUNC_IMPORT bool get_encrypts();

  1059 

  1060 	/**

  1061 	 * The set_is_valid() function sets the state of the

  1062 	 * crypto_3des_ede_c object valid. The crypto_3des_ede_c object 

  1063 	 * calls this function after it is initialized.

  1064 	 */

  1065 	EAP_FUNC_IMPORT void set_is_valid();

  1066 

  1067 	/**

  1068 	 * The get_is_valid() function returns the status of the crypto_3des_ede_c object.

  1069 	 * True indicates the object is initialized.

  1070 	 */

  1071 	EAP_FUNC_IMPORT bool get_is_valid();

  1072 

  1073 	/**

  1074 	 * This function returns the length of 3DES-EDE key in bytes.

  1075 	 */

  1076 	EAP_FUNC_IMPORT u32_t get_key_length();

  1077 

  1078 	/**

  1079 	 * This function returns the length of 3DES-EDE block size in bytes.

  1080 	 */

  1081 	EAP_FUNC_IMPORT u32_t get_block_size();

  1082 

  1083 

  1084 	/**

  1085 	 * This function sets the mode to encryption, 

  1086 	 * sets the initialization vector and the encryption key.

  1087 	 */

  1088 	EAP_FUNC_IMPORT eap_status_e set_encryption_key(

  1089 		const void * const key,

  1090 		const u32_t key_length);

  1091 

  1092 	/**

  1093 	 * This function sets the mode to decryption, 

  1094 	 * sets the initialization vector and the decryption key.

  1095 	 */

  1096 	EAP_FUNC_IMPORT eap_status_e set_decryption_key(

  1097 		const void * const key,

  1098 		const u32_t key_length);

  1099 

  1100 	/**

  1101 	 * This function encrypts continuous data bytes from data_in to data_out buffer. 

  1102 	 * Note the length of the data must be aligned to block size of the cipher.

  1103 	 */

  1104 	EAP_FUNC_IMPORT eap_status_e encrypt_block(

  1105 		const void * const data_in,

  1106 		void * const data_out,

  1107 		const u32_t data_length);

  1108 

  1109 	/**

  1110 	 * This function decrypts continuous data bytes from data_in to data_out buffer. 

  1111 	 * Note the length of the data must be aligned to block size of the cipher.

  1112 	 */

  1113 	EAP_FUNC_IMPORT eap_status_e decrypt_block(

  1114 		const void * const data_in,

  1115 		void * const data_out,

  1116 		const u32_t data_length);

  1117 

  1118 	// - - - - - - - - - - - - - - - - - - - - - - - -

  1119 };

  1120 

  1121 

  1122 //------------------------------------------------------------

  1123 

  1124 

  1125 const u8_t EAP_CRYPTO_AES_WRAP_DEFAULT_INITIAL_IV[] = {

  1126 	0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6,

  1127 	};

  1128 

  1129 const u64_t EAP_CRYPTO_AES_WRAP_BLOCK_SIZE = sizeof(u64_t);

  1130 

  1131 

  1132 /// The crypto_aes_wrap_c class describes interface of block encryption algorithm.

  1133 class EAP_EXPORT crypto_aes_wrap_c

  1134 {