Return to aead.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / crypto

Annotation of embedaddon/strongswan/src/libstrongswan/crypto/aead.h, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * Copyright (C) 2013 Tobias Brunner
                      3:  * HSR Hochschule fuer Technik Rapperswil
                      4:  *
                      5:  * Copyright (C) 2010 Martin Willi
                      6:  * Copyright (C) 2010 revosec AG
                      7:  *
                      8:  * This program is free software; you can redistribute it and/or modify it
                      9:  * under the terms of the GNU General Public License as published by the
                     10:  * Free Software Foundation; either version 2 of the License, or (at your
                     11:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
                     12:  *
                     13:  * This program is distributed in the hope that it will be useful, but
                     14:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
                     15:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
                     16:  * for more details.
                     17:  */
                     18: 
                     19: /**
                     20:  * @defgroup aead aead
                     21:  * @{ @ingroup crypto
                     22:  */
                     23: 
                     24: #ifndef AEAD_H_
                     25: #define AEAD_H_
                     26: 
                     27: typedef struct aead_t aead_t;
                     28: 
                     29: #include <library.h>
                     30: #include <crypto/crypters/crypter.h>
                     31: #include <crypto/signers/signer.h>
                     32: #include <crypto/iv/iv_gen.h>
                     33: 
                     34: /**
                     35:  * Authenticated encryption / authentication decryption interface.
                     36:  */
                     37: struct aead_t {
                     38: 
                     39:        /**
                     40:         * Encrypt and sign data, sign associated data.
                     41:         *
                     42:         * The plain data must be a multiple of get_block_size(), the IV must
                     43:         * have a length of get_iv_size().
                     44:         * If encrypted is NULL, the encryption is done inline. The buffer must
                     45:         * have space for additional get_icv_size() data, the ICV value is
                     46:         * appended silently to the plain chunk.
                     47:         *
                     48:         * @param plain                 data to encrypt and sign
                     49:         * @param assoc                 associated data to sign
                     50:         * @param iv                    initialization vector
                     51:         * @param encrypted             allocated encryption result
                     52:         * @return                              TRUE if successfully encrypted
                     53:         */
                     54:        bool (*encrypt)(aead_t *this, chunk_t plain, chunk_t assoc, chunk_t iv,
                     55:                                        chunk_t *encrypted) __attribute__((warn_unused_result));
                     56: 
                     57:        /**
                     58:         * Decrypt and verify data, verify associated data.
                     59:         *
                     60:         * The IV must have a length of get_iv_size().
                     61:         * If plain is NULL, the decryption is done inline. The decrypted data
                     62:         * is returned in the encrypted chunk, the last get_icv_size() bytes
                     63:         * contain the verified ICV.
                     64:         *
                     65:         * @param encrypted             data to decrypt and verify
                     66:         * @param assoc                 associated data to verify
                     67:         * @param iv                    initialization vector
                     68:         * @param plain                 allocated result, if successful
                     69:         * @return                              TRUE if MAC verification successful
                     70:         */
                     71:        bool (*decrypt)(aead_t *this, chunk_t encrypted, chunk_t assoc, chunk_t iv,
                     72:                                        chunk_t *plain);
                     73: 
                     74:        /**
                     75:         * Get the block size for encryption.
                     76:         *
                     77:         * @return                              block size in bytes
                     78:         */
                     79:        size_t (*get_block_size)(aead_t *this);
                     80: 
                     81:        /**
                     82:         * Get the integrity check value size of the algorithm.
                     83:         *
                     84:         * @return                              ICV size in bytes
                     85:         */
                     86:        size_t (*get_icv_size)(aead_t *this);
                     87: 
                     88:        /**
                     89:         * Get the size of the initialization vector.
                     90:         *
                     91:         * @return                              IV size in bytes
                     92:         */
                     93:        size_t (*get_iv_size)(aead_t *this);
                     94: 
                     95:        /**
                     96:         * Get the IV generator implementation
                     97:         *
                     98:         * @return                              IV generator
                     99:         */
                    100:        iv_gen_t *(*get_iv_gen)(aead_t *this);
                    101: 
                    102:        /**
                    103:         * Get the size of the key material (for encryption and authentication).
                    104:         *
                    105:         * This includes any additional bytes requires for the implicit nonce part.
                    106:         * For AEADs based on traditional ciphers, the length is for both
                    107:         * the integrity and the encryption key in total.
                    108:         *
                    109:         * @return                              key size in bytes
                    110:         */
                    111:        size_t (*get_key_size)(aead_t *this);
                    112: 
                    113:        /**
                    114:         * Set the key for encryption and authentication.
                    115:         *
                    116:         * If the AEAD uses an implicit nonce, the last part of the key shall
                    117:         * be the implicit nonce. For AEADs based on traditional ciphers, the
                    118:         * key shall include both integrity and encryption keys, concatenated
                    119:         * in that order.
                    120:         *
                    121:         * @param key                   encryption and authentication key
                    122:         * @return                              TRUE if key set successfully
                    123:         */
                    124:        bool (*set_key)(aead_t *this,
                    125:                                        chunk_t key) __attribute__((warn_unused_result));
                    126: 
                    127:        /**
                    128:         * Destroy an aead_t.
                    129:         */
                    130:        void (*destroy)(aead_t *this);
                    131: };
                    132: 
                    133: /**
                    134:  * Create a aead instance using traditional transforms.
                    135:  *
                    136:  * @param crypter              encryption transform for this aead
                    137:  * @param signer               integrity transform for this aead
                    138:  * @param iv_gen               suitable IV generator for encryption algorithm
                    139:  * @return                             aead transform
                    140:  */
                    141: aead_t *aead_create(crypter_t *crypter, signer_t *signer, iv_gen_t *iv_gen);
                    142: 
                    143: #endif /** AEAD_H_ @}*/