~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/tipc/crypto.c

Version: ~ [ linux-6.11.5 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.58 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.114 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.169 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.228 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.284 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.322 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /net/tipc/crypto.c (Version linux-6.11.5) and /net/tipc/crypto.c (Version linux-5.13.19)


  1 // SPDX-License-Identifier: GPL-2.0                 1 // SPDX-License-Identifier: GPL-2.0
  2 /*                                                  2 /*
  3  * net/tipc/crypto.c: TIPC crypto for key hand      3  * net/tipc/crypto.c: TIPC crypto for key handling & packet en/decryption
  4  *                                                  4  *
  5  * Copyright (c) 2019, Ericsson AB                  5  * Copyright (c) 2019, Ericsson AB
  6  * All rights reserved.                             6  * All rights reserved.
  7  *                                                  7  *
  8  * Redistribution and use in source and binary      8  * Redistribution and use in source and binary forms, with or without
  9  * modification, are permitted provided that t      9  * modification, are permitted provided that the following conditions are met:
 10  *                                                 10  *
 11  * 1. Redistributions of source code must reta     11  * 1. Redistributions of source code must retain the above copyright
 12  *    notice, this list of conditions and the      12  *    notice, this list of conditions and the following disclaimer.
 13  * 2. Redistributions in binary form must repr     13  * 2. Redistributions in binary form must reproduce the above copyright
 14  *    notice, this list of conditions and the      14  *    notice, this list of conditions and the following disclaimer in the
 15  *    documentation and/or other materials pro     15  *    documentation and/or other materials provided with the distribution.
 16  * 3. Neither the names of the copyright holde     16  * 3. Neither the names of the copyright holders nor the names of its
 17  *    contributors may be used to endorse or p     17  *    contributors may be used to endorse or promote products derived from
 18  *    this software without specific prior wri     18  *    this software without specific prior written permission.
 19  *                                                 19  *
 20  * Alternatively, this software may be distrib     20  * Alternatively, this software may be distributed under the terms of the
 21  * GNU General Public License ("GPL") version      21  * GNU General Public License ("GPL") version 2 as published by the Free
 22  * Software Foundation.                            22  * Software Foundation.
 23  *                                                 23  *
 24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT      24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCL     25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND F     26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYR     27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL     28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT L     29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,      30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THE     31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUD     32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 33  * ARISING IN ANY WAY OUT OF THE USE OF THIS S     33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 34  * POSSIBILITY OF SUCH DAMAGE.                     34  * POSSIBILITY OF SUCH DAMAGE.
 35  */                                                35  */
 36                                                    36 
 37 #include <crypto/aead.h>                           37 #include <crypto/aead.h>
 38 #include <crypto/aes.h>                            38 #include <crypto/aes.h>
 39 #include <crypto/rng.h>                            39 #include <crypto/rng.h>
 40 #include "crypto.h"                                40 #include "crypto.h"
 41 #include "msg.h"                                   41 #include "msg.h"
 42 #include "bcast.h"                                 42 #include "bcast.h"
 43                                                    43 
 44 #define TIPC_TX_GRACE_PERIOD    msecs_to_jiffi     44 #define TIPC_TX_GRACE_PERIOD    msecs_to_jiffies(5000) /* 5s */
 45 #define TIPC_TX_LASTING_TIME    msecs_to_jiffi     45 #define TIPC_TX_LASTING_TIME    msecs_to_jiffies(10000) /* 10s */
 46 #define TIPC_RX_ACTIVE_LIM      msecs_to_jiffi     46 #define TIPC_RX_ACTIVE_LIM      msecs_to_jiffies(3000) /* 3s */
 47 #define TIPC_RX_PASSIVE_LIM     msecs_to_jiffi     47 #define TIPC_RX_PASSIVE_LIM     msecs_to_jiffies(15000) /* 15s */
 48                                                    48 
 49 #define TIPC_MAX_TFMS_DEF       10                 49 #define TIPC_MAX_TFMS_DEF       10
 50 #define TIPC_MAX_TFMS_LIM       1000               50 #define TIPC_MAX_TFMS_LIM       1000
 51                                                    51 
 52 #define TIPC_REKEYING_INTV_DEF  (60 * 24) /* d     52 #define TIPC_REKEYING_INTV_DEF  (60 * 24) /* default: 1 day */
 53                                                    53 
 54 /*                                                 54 /*
 55  * TIPC Key ids                                    55  * TIPC Key ids
 56  */                                                56  */
 57 enum {                                             57 enum {
 58         KEY_MASTER = 0,                            58         KEY_MASTER = 0,
 59         KEY_MIN = KEY_MASTER,                      59         KEY_MIN = KEY_MASTER,
 60         KEY_1 = 1,                                 60         KEY_1 = 1,
 61         KEY_2,                                     61         KEY_2,
 62         KEY_3,                                     62         KEY_3,
 63         KEY_MAX = KEY_3,                           63         KEY_MAX = KEY_3,
 64 };                                                 64 };
 65                                                    65 
 66 /*                                                 66 /*
 67  * TIPC Crypto statistics                          67  * TIPC Crypto statistics
 68  */                                                68  */
 69 enum {                                             69 enum {
 70         STAT_OK,                                   70         STAT_OK,
 71         STAT_NOK,                                  71         STAT_NOK,
 72         STAT_ASYNC,                                72         STAT_ASYNC,
 73         STAT_ASYNC_OK,                             73         STAT_ASYNC_OK,
 74         STAT_ASYNC_NOK,                            74         STAT_ASYNC_NOK,
 75         STAT_BADKEYS, /* tx only */                75         STAT_BADKEYS, /* tx only */
 76         STAT_BADMSGS = STAT_BADKEYS, /* rx onl     76         STAT_BADMSGS = STAT_BADKEYS, /* rx only */
 77         STAT_NOKEYS,                               77         STAT_NOKEYS,
 78         STAT_SWITCHES,                             78         STAT_SWITCHES,
 79                                                    79 
 80         MAX_STATS,                                 80         MAX_STATS,
 81 };                                                 81 };
 82                                                    82 
 83 /* TIPC crypto statistics' header */               83 /* TIPC crypto statistics' header */
 84 static const char *hstats[MAX_STATS] = {"ok",      84 static const char *hstats[MAX_STATS] = {"ok", "nok", "async", "async_ok",
 85                                         "async     85                                         "async_nok", "badmsgs", "nokeys",
 86                                         "switc     86                                         "switches"};
 87                                                    87 
 88 /* Max TFMs number per key */                      88 /* Max TFMs number per key */
 89 int sysctl_tipc_max_tfms __read_mostly = TIPC_     89 int sysctl_tipc_max_tfms __read_mostly = TIPC_MAX_TFMS_DEF;
 90 /* Key exchange switch, default: on */             90 /* Key exchange switch, default: on */
 91 int sysctl_tipc_key_exchange_enabled __read_mo     91 int sysctl_tipc_key_exchange_enabled __read_mostly = 1;
 92                                                    92 
 93 /*                                                 93 /*
 94  * struct tipc_key - TIPC keys' status indicat     94  * struct tipc_key - TIPC keys' status indicator
 95  *                                                 95  *
 96  *         7     6     5     4     3     2         96  *         7     6     5     4     3     2     1     0
 97  *      +-----+-----+-----+-----+-----+-----+-     97  *      +-----+-----+-----+-----+-----+-----+-----+-----+
 98  * key: | (reserved)|passive idx| active idx|p     98  * key: | (reserved)|passive idx| active idx|pending idx|
 99  *      +-----+-----+-----+-----+-----+-----+-     99  *      +-----+-----+-----+-----+-----+-----+-----+-----+
100  */                                               100  */
101 struct tipc_key {                                 101 struct tipc_key {
102 #define KEY_BITS (2)                              102 #define KEY_BITS (2)
103 #define KEY_MASK ((1 << KEY_BITS) - 1)            103 #define KEY_MASK ((1 << KEY_BITS) - 1)
104         union {                                   104         union {
105                 struct {                          105                 struct {
106 #if defined(__LITTLE_ENDIAN_BITFIELD)             106 #if defined(__LITTLE_ENDIAN_BITFIELD)
107                         u8 pending:2,             107                         u8 pending:2,
108                            active:2,              108                            active:2,
109                            passive:2, /* rx on    109                            passive:2, /* rx only */
110                            reserved:2;            110                            reserved:2;
111 #elif defined(__BIG_ENDIAN_BITFIELD)              111 #elif defined(__BIG_ENDIAN_BITFIELD)
112                         u8 reserved:2,            112                         u8 reserved:2,
113                            passive:2, /* rx on    113                            passive:2, /* rx only */
114                            active:2,              114                            active:2,
115                            pending:2;             115                            pending:2;
116 #else                                             116 #else
117 #error  "Please fix <asm/byteorder.h>"            117 #error  "Please fix <asm/byteorder.h>"
118 #endif                                            118 #endif
119                 } __packed;                       119                 } __packed;
120                 u8 keys;                          120                 u8 keys;
121         };                                        121         };
122 };                                                122 };
123                                                   123 
124 /**                                               124 /**
125  * struct tipc_tfm - TIPC TFM structure to for    125  * struct tipc_tfm - TIPC TFM structure to form a list of TFMs
126  * @tfm: cipher handle/key                        126  * @tfm: cipher handle/key
127  * @list: linked list of TFMs                     127  * @list: linked list of TFMs
128  */                                               128  */
129 struct tipc_tfm {                                 129 struct tipc_tfm {
130         struct crypto_aead *tfm;                  130         struct crypto_aead *tfm;
131         struct list_head list;                    131         struct list_head list;
132 };                                                132 };
133                                                   133 
134 /**                                               134 /**
135  * struct tipc_aead - TIPC AEAD key structure     135  * struct tipc_aead - TIPC AEAD key structure
136  * @tfm_entry: per-cpu pointer to one entry in    136  * @tfm_entry: per-cpu pointer to one entry in TFM list
137  * @crypto: TIPC crypto owns this key             137  * @crypto: TIPC crypto owns this key
138  * @cloned: reference to the source key in cas    138  * @cloned: reference to the source key in case cloning
139  * @users: the number of the key users (TX/RX)    139  * @users: the number of the key users (TX/RX)
140  * @salt: the key's SALT value                    140  * @salt: the key's SALT value
141  * @authsize: authentication tag size (max = 1    141  * @authsize: authentication tag size (max = 16)
142  * @mode: crypto mode is applied to the key       142  * @mode: crypto mode is applied to the key
143  * @hint: a hint for user key                     143  * @hint: a hint for user key
144  * @rcu: struct rcu_head                          144  * @rcu: struct rcu_head
145  * @key: the aead key                             145  * @key: the aead key
146  * @gen: the key's generation                     146  * @gen: the key's generation
147  * @seqno: the key seqno (cluster scope)          147  * @seqno: the key seqno (cluster scope)
148  * @refcnt: the key reference counter             148  * @refcnt: the key reference counter
149  */                                               149  */
150 struct tipc_aead {                                150 struct tipc_aead {
151 #define TIPC_AEAD_HINT_LEN (5)                    151 #define TIPC_AEAD_HINT_LEN (5)
152         struct tipc_tfm * __percpu *tfm_entry;    152         struct tipc_tfm * __percpu *tfm_entry;
153         struct tipc_crypto *crypto;               153         struct tipc_crypto *crypto;
154         struct tipc_aead *cloned;                 154         struct tipc_aead *cloned;
155         atomic_t users;                           155         atomic_t users;
156         u32 salt;                                 156         u32 salt;
157         u8 authsize;                              157         u8 authsize;
158         u8 mode;                                  158         u8 mode;
159         char hint[2 * TIPC_AEAD_HINT_LEN + 1];    159         char hint[2 * TIPC_AEAD_HINT_LEN + 1];
160         struct rcu_head rcu;                      160         struct rcu_head rcu;
161         struct tipc_aead_key *key;                161         struct tipc_aead_key *key;
162         u16 gen;                                  162         u16 gen;
163                                                   163 
164         atomic64_t seqno ____cacheline_aligned    164         atomic64_t seqno ____cacheline_aligned;
165         refcount_t refcnt ____cacheline_aligne    165         refcount_t refcnt ____cacheline_aligned;
166                                                   166 
167 } ____cacheline_aligned;                          167 } ____cacheline_aligned;
168                                                   168 
169 /**                                               169 /**
170  * struct tipc_crypto_stats - TIPC Crypto stat    170  * struct tipc_crypto_stats - TIPC Crypto statistics
171  * @stat: array of crypto statistics              171  * @stat: array of crypto statistics
172  */                                               172  */
173 struct tipc_crypto_stats {                        173 struct tipc_crypto_stats {
174         unsigned int stat[MAX_STATS];             174         unsigned int stat[MAX_STATS];
175 };                                                175 };
176                                                   176 
177 /**                                               177 /**
178  * struct tipc_crypto - TIPC TX/RX crypto stru    178  * struct tipc_crypto - TIPC TX/RX crypto structure
179  * @net: struct net                               179  * @net: struct net
180  * @node: TIPC node (RX)                          180  * @node: TIPC node (RX)
181  * @aead: array of pointers to AEAD keys for e    181  * @aead: array of pointers to AEAD keys for encryption/decryption
182  * @peer_rx_active: replicated peer RX active     182  * @peer_rx_active: replicated peer RX active key index
183  * @key_gen: TX/RX key generation                 183  * @key_gen: TX/RX key generation
184  * @key: the key states                           184  * @key: the key states
185  * @skey_mode: session key's mode                 185  * @skey_mode: session key's mode
186  * @skey: received session key                    186  * @skey: received session key
187  * @wq: common workqueue on TX crypto             187  * @wq: common workqueue on TX crypto
188  * @work: delayed work sched for TX/RX            188  * @work: delayed work sched for TX/RX
189  * @key_distr: key distributing state             189  * @key_distr: key distributing state
190  * @rekeying_intv: rekeying interval (in minut    190  * @rekeying_intv: rekeying interval (in minutes)
191  * @stats: the crypto statistics                  191  * @stats: the crypto statistics
192  * @name: the crypto name                         192  * @name: the crypto name
193  * @sndnxt: the per-peer sndnxt (TX)              193  * @sndnxt: the per-peer sndnxt (TX)
194  * @timer1: general timer 1 (jiffies)             194  * @timer1: general timer 1 (jiffies)
195  * @timer2: general timer 2 (jiffies)             195  * @timer2: general timer 2 (jiffies)
196  * @working: the crypto is working or not         196  * @working: the crypto is working or not
197  * @key_master: flag indicates if master key e    197  * @key_master: flag indicates if master key exists
198  * @legacy_user: flag indicates if a peer join    198  * @legacy_user: flag indicates if a peer joins w/o master key (for bwd comp.)
199  * @nokey: no key indication                      199  * @nokey: no key indication
200  * @flags: combined flags field                   200  * @flags: combined flags field
201  * @lock: tipc_key lock                           201  * @lock: tipc_key lock
202  */                                               202  */
203 struct tipc_crypto {                              203 struct tipc_crypto {
204         struct net *net;                          204         struct net *net;
205         struct tipc_node *node;                   205         struct tipc_node *node;
206         struct tipc_aead __rcu *aead[KEY_MAX +    206         struct tipc_aead __rcu *aead[KEY_MAX + 1];
207         atomic_t peer_rx_active;                  207         atomic_t peer_rx_active;
208         u16 key_gen;                              208         u16 key_gen;
209         struct tipc_key key;                      209         struct tipc_key key;
210         u8 skey_mode;                             210         u8 skey_mode;
211         struct tipc_aead_key *skey;               211         struct tipc_aead_key *skey;
212         struct workqueue_struct *wq;              212         struct workqueue_struct *wq;
213         struct delayed_work work;                 213         struct delayed_work work;
214 #define KEY_DISTR_SCHED         1                 214 #define KEY_DISTR_SCHED         1
215 #define KEY_DISTR_COMPL         2                 215 #define KEY_DISTR_COMPL         2
216         atomic_t key_distr;                       216         atomic_t key_distr;
217         u32 rekeying_intv;                        217         u32 rekeying_intv;
218                                                   218 
219         struct tipc_crypto_stats __percpu *sta    219         struct tipc_crypto_stats __percpu *stats;
220         char name[48];                            220         char name[48];
221                                                   221 
222         atomic64_t sndnxt ____cacheline_aligne    222         atomic64_t sndnxt ____cacheline_aligned;
223         unsigned long timer1;                     223         unsigned long timer1;
224         unsigned long timer2;                     224         unsigned long timer2;
225         union {                                   225         union {
226                 struct {                          226                 struct {
227                         u8 working:1;             227                         u8 working:1;
228                         u8 key_master:1;          228                         u8 key_master:1;
229                         u8 legacy_user:1;         229                         u8 legacy_user:1;
230                         u8 nokey: 1;              230                         u8 nokey: 1;
231                 };                                231                 };
232                 u8 flags;                         232                 u8 flags;
233         };                                        233         };
234         spinlock_t lock; /* crypto lock */        234         spinlock_t lock; /* crypto lock */
235                                                   235 
236 } ____cacheline_aligned;                          236 } ____cacheline_aligned;
237                                                   237 
238 /* struct tipc_crypto_tx_ctx - TX context for     238 /* struct tipc_crypto_tx_ctx - TX context for callbacks */
239 struct tipc_crypto_tx_ctx {                       239 struct tipc_crypto_tx_ctx {
240         struct tipc_aead *aead;                   240         struct tipc_aead *aead;
241         struct tipc_bearer *bearer;               241         struct tipc_bearer *bearer;
242         struct tipc_media_addr dst;               242         struct tipc_media_addr dst;
243 };                                                243 };
244                                                   244 
245 /* struct tipc_crypto_rx_ctx - RX context for     245 /* struct tipc_crypto_rx_ctx - RX context for callbacks */
246 struct tipc_crypto_rx_ctx {                       246 struct tipc_crypto_rx_ctx {
247         struct tipc_aead *aead;                   247         struct tipc_aead *aead;
248         struct tipc_bearer *bearer;               248         struct tipc_bearer *bearer;
249 };                                                249 };
250                                                   250 
251 static struct tipc_aead *tipc_aead_get(struct     251 static struct tipc_aead *tipc_aead_get(struct tipc_aead __rcu *aead);
252 static inline void tipc_aead_put(struct tipc_a    252 static inline void tipc_aead_put(struct tipc_aead *aead);
253 static void tipc_aead_free(struct rcu_head *rp    253 static void tipc_aead_free(struct rcu_head *rp);
254 static int tipc_aead_users(struct tipc_aead __    254 static int tipc_aead_users(struct tipc_aead __rcu *aead);
255 static void tipc_aead_users_inc(struct tipc_ae    255 static void tipc_aead_users_inc(struct tipc_aead __rcu *aead, int lim);
256 static void tipc_aead_users_dec(struct tipc_ae    256 static void tipc_aead_users_dec(struct tipc_aead __rcu *aead, int lim);
257 static void tipc_aead_users_set(struct tipc_ae    257 static void tipc_aead_users_set(struct tipc_aead __rcu *aead, int val);
258 static struct crypto_aead *tipc_aead_tfm_next(    258 static struct crypto_aead *tipc_aead_tfm_next(struct tipc_aead *aead);
259 static int tipc_aead_init(struct tipc_aead **a    259 static int tipc_aead_init(struct tipc_aead **aead, struct tipc_aead_key *ukey,
260                           u8 mode);               260                           u8 mode);
261 static int tipc_aead_clone(struct tipc_aead **    261 static int tipc_aead_clone(struct tipc_aead **dst, struct tipc_aead *src);
262 static void *tipc_aead_mem_alloc(struct crypto    262 static void *tipc_aead_mem_alloc(struct crypto_aead *tfm,
263                                  unsigned int     263                                  unsigned int crypto_ctx_size,
264                                  u8 **iv, stru    264                                  u8 **iv, struct aead_request **req,
265                                  struct scatte    265                                  struct scatterlist **sg, int nsg);
266 static int tipc_aead_encrypt(struct tipc_aead     266 static int tipc_aead_encrypt(struct tipc_aead *aead, struct sk_buff *skb,
267                              struct tipc_beare    267                              struct tipc_bearer *b,
268                              struct tipc_media    268                              struct tipc_media_addr *dst,
269                              struct tipc_node     269                              struct tipc_node *__dnode);
270 static void tipc_aead_encrypt_done(void *data, !! 270 static void tipc_aead_encrypt_done(struct crypto_async_request *base, int err);
271 static int tipc_aead_decrypt(struct net *net,     271 static int tipc_aead_decrypt(struct net *net, struct tipc_aead *aead,
272                              struct sk_buff *s    272                              struct sk_buff *skb, struct tipc_bearer *b);
273 static void tipc_aead_decrypt_done(void *data, !! 273 static void tipc_aead_decrypt_done(struct crypto_async_request *base, int err);
274 static inline int tipc_ehdr_size(struct tipc_e    274 static inline int tipc_ehdr_size(struct tipc_ehdr *ehdr);
275 static int tipc_ehdr_build(struct net *net, st    275 static int tipc_ehdr_build(struct net *net, struct tipc_aead *aead,
276                            u8 tx_key, struct s    276                            u8 tx_key, struct sk_buff *skb,
277                            struct tipc_crypto     277                            struct tipc_crypto *__rx);
278 static inline void tipc_crypto_key_set_state(s    278 static inline void tipc_crypto_key_set_state(struct tipc_crypto *c,
279                                              u    279                                              u8 new_passive,
280                                              u    280                                              u8 new_active,
281                                              u    281                                              u8 new_pending);
282 static int tipc_crypto_key_attach(struct tipc_    282 static int tipc_crypto_key_attach(struct tipc_crypto *c,
283                                   struct tipc_    283                                   struct tipc_aead *aead, u8 pos,
284                                   bool master_    284                                   bool master_key);
285 static bool tipc_crypto_key_try_align(struct t    285 static bool tipc_crypto_key_try_align(struct tipc_crypto *rx, u8 new_pending);
286 static struct tipc_aead *tipc_crypto_key_pick_    286 static struct tipc_aead *tipc_crypto_key_pick_tx(struct tipc_crypto *tx,
287                                                   287                                                  struct tipc_crypto *rx,
288                                                   288                                                  struct sk_buff *skb,
289                                                   289                                                  u8 tx_key);
290 static void tipc_crypto_key_synch(struct tipc_    290 static void tipc_crypto_key_synch(struct tipc_crypto *rx, struct sk_buff *skb);
291 static int tipc_crypto_key_revoke(struct net *    291 static int tipc_crypto_key_revoke(struct net *net, u8 tx_key);
292 static inline void tipc_crypto_clone_msg(struc    292 static inline void tipc_crypto_clone_msg(struct net *net, struct sk_buff *_skb,
293                                          struc    293                                          struct tipc_bearer *b,
294                                          struc    294                                          struct tipc_media_addr *dst,
295                                          struc    295                                          struct tipc_node *__dnode, u8 type);
296 static void tipc_crypto_rcv_complete(struct ne    296 static void tipc_crypto_rcv_complete(struct net *net, struct tipc_aead *aead,
297                                      struct ti    297                                      struct tipc_bearer *b,
298                                      struct sk    298                                      struct sk_buff **skb, int err);
299 static void tipc_crypto_do_cmd(struct net *net    299 static void tipc_crypto_do_cmd(struct net *net, int cmd);
300 static char *tipc_crypto_key_dump(struct tipc_    300 static char *tipc_crypto_key_dump(struct tipc_crypto *c, char *buf);
301 static char *tipc_key_change_dump(struct tipc_    301 static char *tipc_key_change_dump(struct tipc_key old, struct tipc_key new,
302                                   char *buf);     302                                   char *buf);
303 static int tipc_crypto_key_xmit(struct net *ne    303 static int tipc_crypto_key_xmit(struct net *net, struct tipc_aead_key *skey,
304                                 u16 gen, u8 mo    304                                 u16 gen, u8 mode, u32 dnode);
305 static bool tipc_crypto_key_rcv(struct tipc_cr    305 static bool tipc_crypto_key_rcv(struct tipc_crypto *rx, struct tipc_msg *hdr);
306 static void tipc_crypto_work_tx(struct work_st    306 static void tipc_crypto_work_tx(struct work_struct *work);
307 static void tipc_crypto_work_rx(struct work_st    307 static void tipc_crypto_work_rx(struct work_struct *work);
308 static int tipc_aead_key_generate(struct tipc_    308 static int tipc_aead_key_generate(struct tipc_aead_key *skey);
309                                                   309 
310 #define is_tx(crypto) (!(crypto)->node)           310 #define is_tx(crypto) (!(crypto)->node)
311 #define is_rx(crypto) (!is_tx(crypto))            311 #define is_rx(crypto) (!is_tx(crypto))
312                                                   312 
313 #define key_next(cur) ((cur) % KEY_MAX + 1)       313 #define key_next(cur) ((cur) % KEY_MAX + 1)
314                                                   314 
315 #define tipc_aead_rcu_ptr(rcu_ptr, lock)          315 #define tipc_aead_rcu_ptr(rcu_ptr, lock)                                \
316         rcu_dereference_protected((rcu_ptr), l    316         rcu_dereference_protected((rcu_ptr), lockdep_is_held(lock))
317                                                   317 
318 #define tipc_aead_rcu_replace(rcu_ptr, ptr, lo    318 #define tipc_aead_rcu_replace(rcu_ptr, ptr, lock)                       \
319 do {                                              319 do {                                                                    \
320         struct tipc_aead *__tmp = rcu_derefere    320         struct tipc_aead *__tmp = rcu_dereference_protected((rcu_ptr),  \
321                                                   321                                                 lockdep_is_held(lock)); \
322         rcu_assign_pointer((rcu_ptr), (ptr));     322         rcu_assign_pointer((rcu_ptr), (ptr));                           \
323         tipc_aead_put(__tmp);                     323         tipc_aead_put(__tmp);                                           \
324 } while (0)                                       324 } while (0)
325                                                   325 
326 #define tipc_crypto_key_detach(rcu_ptr, lock)     326 #define tipc_crypto_key_detach(rcu_ptr, lock)                           \
327         tipc_aead_rcu_replace((rcu_ptr), NULL,    327         tipc_aead_rcu_replace((rcu_ptr), NULL, lock)
328                                                   328 
329 /**                                               329 /**
330  * tipc_aead_key_validate - Validate a AEAD us    330  * tipc_aead_key_validate - Validate a AEAD user key
331  * @ukey: pointer to user key data                331  * @ukey: pointer to user key data
332  * @info: netlink info pointer                    332  * @info: netlink info pointer
333  */                                               333  */
334 int tipc_aead_key_validate(struct tipc_aead_ke    334 int tipc_aead_key_validate(struct tipc_aead_key *ukey, struct genl_info *info)
335 {                                                 335 {
336         int keylen;                               336         int keylen;
337                                                   337 
338         /* Check if algorithm exists */           338         /* Check if algorithm exists */
339         if (unlikely(!crypto_has_alg(ukey->alg    339         if (unlikely(!crypto_has_alg(ukey->alg_name, 0, 0))) {
340                 GENL_SET_ERR_MSG(info, "unable    340                 GENL_SET_ERR_MSG(info, "unable to load the algorithm (module existed?)");
341                 return -ENODEV;                   341                 return -ENODEV;
342         }                                         342         }
343                                                   343 
344         /* Currently, we only support the "gcm    344         /* Currently, we only support the "gcm(aes)" cipher algorithm */
345         if (strcmp(ukey->alg_name, "gcm(aes)")    345         if (strcmp(ukey->alg_name, "gcm(aes)")) {
346                 GENL_SET_ERR_MSG(info, "not su    346                 GENL_SET_ERR_MSG(info, "not supported yet the algorithm");
347                 return -ENOTSUPP;                 347                 return -ENOTSUPP;
348         }                                         348         }
349                                                   349 
350         /* Check if key size is correct */        350         /* Check if key size is correct */
351         keylen = ukey->keylen - TIPC_AES_GCM_S    351         keylen = ukey->keylen - TIPC_AES_GCM_SALT_SIZE;
352         if (unlikely(keylen != TIPC_AES_GCM_KE    352         if (unlikely(keylen != TIPC_AES_GCM_KEY_SIZE_128 &&
353                      keylen != TIPC_AES_GCM_KE    353                      keylen != TIPC_AES_GCM_KEY_SIZE_192 &&
354                      keylen != TIPC_AES_GCM_KE    354                      keylen != TIPC_AES_GCM_KEY_SIZE_256)) {
355                 GENL_SET_ERR_MSG(info, "incorr    355                 GENL_SET_ERR_MSG(info, "incorrect key length (20, 28 or 36 octets?)");
356                 return -EKEYREJECTED;             356                 return -EKEYREJECTED;
357         }                                         357         }
358                                                   358 
359         return 0;                                 359         return 0;
360 }                                                 360 }
361                                                   361 
362 /**                                               362 /**
363  * tipc_aead_key_generate - Generate new sessi    363  * tipc_aead_key_generate - Generate new session key
364  * @skey: input/output key with new content       364  * @skey: input/output key with new content
365  *                                                365  *
366  * Return: 0 in case of success, otherwise < 0    366  * Return: 0 in case of success, otherwise < 0
367  */                                               367  */
368 static int tipc_aead_key_generate(struct tipc_    368 static int tipc_aead_key_generate(struct tipc_aead_key *skey)
369 {                                                 369 {
370         int rc = 0;                               370         int rc = 0;
371                                                   371 
372         /* Fill the key's content with a rando    372         /* Fill the key's content with a random value via RNG cipher */
373         rc = crypto_get_default_rng();            373         rc = crypto_get_default_rng();
374         if (likely(!rc)) {                        374         if (likely(!rc)) {
375                 rc = crypto_rng_get_bytes(cryp    375                 rc = crypto_rng_get_bytes(crypto_default_rng, skey->key,
376                                           skey    376                                           skey->keylen);
377                 crypto_put_default_rng();         377                 crypto_put_default_rng();
378         }                                         378         }
379                                                   379 
380         return rc;                                380         return rc;
381 }                                                 381 }
382                                                   382 
383 static struct tipc_aead *tipc_aead_get(struct     383 static struct tipc_aead *tipc_aead_get(struct tipc_aead __rcu *aead)
384 {                                                 384 {
385         struct tipc_aead *tmp;                    385         struct tipc_aead *tmp;
386                                                   386 
387         rcu_read_lock();                          387         rcu_read_lock();
388         tmp = rcu_dereference(aead);              388         tmp = rcu_dereference(aead);
389         if (unlikely(!tmp || !refcount_inc_not    389         if (unlikely(!tmp || !refcount_inc_not_zero(&tmp->refcnt)))
390                 tmp = NULL;                       390                 tmp = NULL;
391         rcu_read_unlock();                        391         rcu_read_unlock();
392                                                   392 
393         return tmp;                               393         return tmp;
394 }                                                 394 }
395                                                   395 
396 static inline void tipc_aead_put(struct tipc_a    396 static inline void tipc_aead_put(struct tipc_aead *aead)
397 {                                                 397 {
398         if (aead && refcount_dec_and_test(&aea    398         if (aead && refcount_dec_and_test(&aead->refcnt))
399                 call_rcu(&aead->rcu, tipc_aead    399                 call_rcu(&aead->rcu, tipc_aead_free);
400 }                                                 400 }
401                                                   401 
402 /**                                               402 /**
403  * tipc_aead_free - Release AEAD key incl. all    403  * tipc_aead_free - Release AEAD key incl. all the TFMs in the list
404  * @rp: rcu head pointer                          404  * @rp: rcu head pointer
405  */                                               405  */
406 static void tipc_aead_free(struct rcu_head *rp    406 static void tipc_aead_free(struct rcu_head *rp)
407 {                                                 407 {
408         struct tipc_aead *aead = container_of(    408         struct tipc_aead *aead = container_of(rp, struct tipc_aead, rcu);
409         struct tipc_tfm *tfm_entry, *head, *tm    409         struct tipc_tfm *tfm_entry, *head, *tmp;
410                                                   410 
411         if (aead->cloned) {                       411         if (aead->cloned) {
412                 tipc_aead_put(aead->cloned);      412                 tipc_aead_put(aead->cloned);
413         } else {                                  413         } else {
414                 head = *get_cpu_ptr(aead->tfm_    414                 head = *get_cpu_ptr(aead->tfm_entry);
415                 put_cpu_ptr(aead->tfm_entry);     415                 put_cpu_ptr(aead->tfm_entry);
416                 list_for_each_entry_safe(tfm_e    416                 list_for_each_entry_safe(tfm_entry, tmp, &head->list, list) {
417                         crypto_free_aead(tfm_e    417                         crypto_free_aead(tfm_entry->tfm);
418                         list_del(&tfm_entry->l    418                         list_del(&tfm_entry->list);
419                         kfree(tfm_entry);         419                         kfree(tfm_entry);
420                 }                                 420                 }
421                 /* Free the head */               421                 /* Free the head */
422                 crypto_free_aead(head->tfm);      422                 crypto_free_aead(head->tfm);
423                 list_del(&head->list);            423                 list_del(&head->list);
424                 kfree(head);                      424                 kfree(head);
425         }                                         425         }
426         free_percpu(aead->tfm_entry);             426         free_percpu(aead->tfm_entry);
427         kfree_sensitive(aead->key);               427         kfree_sensitive(aead->key);
428         kfree(aead);                              428         kfree(aead);
429 }                                                 429 }
430                                                   430 
431 static int tipc_aead_users(struct tipc_aead __    431 static int tipc_aead_users(struct tipc_aead __rcu *aead)
432 {                                                 432 {
433         struct tipc_aead *tmp;                    433         struct tipc_aead *tmp;
434         int users = 0;                            434         int users = 0;
435                                                   435 
436         rcu_read_lock();                          436         rcu_read_lock();
437         tmp = rcu_dereference(aead);              437         tmp = rcu_dereference(aead);
438         if (tmp)                                  438         if (tmp)
439                 users = atomic_read(&tmp->user    439                 users = atomic_read(&tmp->users);
440         rcu_read_unlock();                        440         rcu_read_unlock();
441                                                   441 
442         return users;                             442         return users;
443 }                                                 443 }
444                                                   444 
445 static void tipc_aead_users_inc(struct tipc_ae    445 static void tipc_aead_users_inc(struct tipc_aead __rcu *aead, int lim)
446 {                                                 446 {
447         struct tipc_aead *tmp;                    447         struct tipc_aead *tmp;
448                                                   448 
449         rcu_read_lock();                          449         rcu_read_lock();
450         tmp = rcu_dereference(aead);              450         tmp = rcu_dereference(aead);
451         if (tmp)                                  451         if (tmp)
452                 atomic_add_unless(&tmp->users,    452                 atomic_add_unless(&tmp->users, 1, lim);
453         rcu_read_unlock();                        453         rcu_read_unlock();
454 }                                                 454 }
455                                                   455 
456 static void tipc_aead_users_dec(struct tipc_ae    456 static void tipc_aead_users_dec(struct tipc_aead __rcu *aead, int lim)
457 {                                                 457 {
458         struct tipc_aead *tmp;                    458         struct tipc_aead *tmp;
459                                                   459 
460         rcu_read_lock();                          460         rcu_read_lock();
461         tmp = rcu_dereference(aead);              461         tmp = rcu_dereference(aead);
462         if (tmp)                                  462         if (tmp)
463                 atomic_add_unless(&rcu_derefer    463                 atomic_add_unless(&rcu_dereference(aead)->users, -1, lim);
464         rcu_read_unlock();                        464         rcu_read_unlock();
465 }                                                 465 }
466                                                   466 
467 static void tipc_aead_users_set(struct tipc_ae    467 static void tipc_aead_users_set(struct tipc_aead __rcu *aead, int val)
468 {                                                 468 {
469         struct tipc_aead *tmp;                    469         struct tipc_aead *tmp;
470         int cur;                                  470         int cur;
471                                                   471 
472         rcu_read_lock();                          472         rcu_read_lock();
473         tmp = rcu_dereference(aead);              473         tmp = rcu_dereference(aead);
474         if (tmp) {                                474         if (tmp) {
475                 do {                              475                 do {
476                         cur = atomic_read(&tmp    476                         cur = atomic_read(&tmp->users);
477                         if (cur == val)           477                         if (cur == val)
478                                 break;            478                                 break;
479                 } while (atomic_cmpxchg(&tmp->    479                 } while (atomic_cmpxchg(&tmp->users, cur, val) != cur);
480         }                                         480         }
481         rcu_read_unlock();                        481         rcu_read_unlock();
482 }                                                 482 }
483                                                   483 
484 /**                                               484 /**
485  * tipc_aead_tfm_next - Move TFM entry to the     485  * tipc_aead_tfm_next - Move TFM entry to the next one in list and return it
486  * @aead: the AEAD key pointer                    486  * @aead: the AEAD key pointer
487  */                                               487  */
488 static struct crypto_aead *tipc_aead_tfm_next(    488 static struct crypto_aead *tipc_aead_tfm_next(struct tipc_aead *aead)
489 {                                                 489 {
490         struct tipc_tfm **tfm_entry;              490         struct tipc_tfm **tfm_entry;
491         struct crypto_aead *tfm;                  491         struct crypto_aead *tfm;
492                                                   492 
493         tfm_entry = get_cpu_ptr(aead->tfm_entr    493         tfm_entry = get_cpu_ptr(aead->tfm_entry);
494         *tfm_entry = list_next_entry(*tfm_entr    494         *tfm_entry = list_next_entry(*tfm_entry, list);
495         tfm = (*tfm_entry)->tfm;                  495         tfm = (*tfm_entry)->tfm;
496         put_cpu_ptr(tfm_entry);                   496         put_cpu_ptr(tfm_entry);
497                                                   497 
498         return tfm;                               498         return tfm;
499 }                                                 499 }
500                                                   500 
501 /**                                               501 /**
502  * tipc_aead_init - Initiate TIPC AEAD            502  * tipc_aead_init - Initiate TIPC AEAD
503  * @aead: returned new TIPC AEAD key handle po    503  * @aead: returned new TIPC AEAD key handle pointer
504  * @ukey: pointer to user key data                504  * @ukey: pointer to user key data
505  * @mode: the key mode                            505  * @mode: the key mode
506  *                                                506  *
507  * Allocate a (list of) new cipher transformat    507  * Allocate a (list of) new cipher transformation (TFM) with the specific user
508  * key data if valid. The number of the alloca    508  * key data if valid. The number of the allocated TFMs can be set via the sysfs
509  * "net/tipc/max_tfms" first.                     509  * "net/tipc/max_tfms" first.
510  * Also, all the other AEAD data are also init    510  * Also, all the other AEAD data are also initialized.
511  *                                                511  *
512  * Return: 0 if the initiation is successful,     512  * Return: 0 if the initiation is successful, otherwise: < 0
513  */                                               513  */
514 static int tipc_aead_init(struct tipc_aead **a    514 static int tipc_aead_init(struct tipc_aead **aead, struct tipc_aead_key *ukey,
515                           u8 mode)                515                           u8 mode)
516 {                                                 516 {
517         struct tipc_tfm *tfm_entry, *head;        517         struct tipc_tfm *tfm_entry, *head;
518         struct crypto_aead *tfm;                  518         struct crypto_aead *tfm;
519         struct tipc_aead *tmp;                    519         struct tipc_aead *tmp;
520         int keylen, err, cpu;                     520         int keylen, err, cpu;
521         int tfm_cnt = 0;                          521         int tfm_cnt = 0;
522                                                   522 
523         if (unlikely(*aead))                      523         if (unlikely(*aead))
524                 return -EEXIST;                   524                 return -EEXIST;
525                                                   525 
526         /* Allocate a new AEAD */                 526         /* Allocate a new AEAD */
527         tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC    527         tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC);
528         if (unlikely(!tmp))                       528         if (unlikely(!tmp))
529                 return -ENOMEM;                   529                 return -ENOMEM;
530                                                   530 
531         /* The key consists of two parts: [AES    531         /* The key consists of two parts: [AES-KEY][SALT] */
532         keylen = ukey->keylen - TIPC_AES_GCM_S    532         keylen = ukey->keylen - TIPC_AES_GCM_SALT_SIZE;
533                                                   533 
534         /* Allocate per-cpu TFM entry pointer     534         /* Allocate per-cpu TFM entry pointer */
535         tmp->tfm_entry = alloc_percpu(struct t    535         tmp->tfm_entry = alloc_percpu(struct tipc_tfm *);
536         if (!tmp->tfm_entry) {                    536         if (!tmp->tfm_entry) {
537                 kfree_sensitive(tmp);             537                 kfree_sensitive(tmp);
538                 return -ENOMEM;                   538                 return -ENOMEM;
539         }                                         539         }
540                                                   540 
541         /* Make a list of TFMs with the user k    541         /* Make a list of TFMs with the user key data */
542         do {                                      542         do {
543                 tfm = crypto_alloc_aead(ukey->    543                 tfm = crypto_alloc_aead(ukey->alg_name, 0, 0);
544                 if (IS_ERR(tfm)) {                544                 if (IS_ERR(tfm)) {
545                         err = PTR_ERR(tfm);       545                         err = PTR_ERR(tfm);
546                         break;                    546                         break;
547                 }                                 547                 }
548                                                   548 
549                 if (unlikely(!tfm_cnt &&          549                 if (unlikely(!tfm_cnt &&
550                              crypto_aead_ivsiz    550                              crypto_aead_ivsize(tfm) != TIPC_AES_GCM_IV_SIZE)) {
551                         crypto_free_aead(tfm);    551                         crypto_free_aead(tfm);
552                         err = -ENOTSUPP;          552                         err = -ENOTSUPP;
553                         break;                    553                         break;
554                 }                                 554                 }
555                                                   555 
556                 err = crypto_aead_setauthsize(    556                 err = crypto_aead_setauthsize(tfm, TIPC_AES_GCM_TAG_SIZE);
557                 err |= crypto_aead_setkey(tfm,    557                 err |= crypto_aead_setkey(tfm, ukey->key, keylen);
558                 if (unlikely(err)) {              558                 if (unlikely(err)) {
559                         crypto_free_aead(tfm);    559                         crypto_free_aead(tfm);
560                         break;                    560                         break;
561                 }                                 561                 }
562                                                   562 
563                 tfm_entry = kmalloc(sizeof(*tf    563                 tfm_entry = kmalloc(sizeof(*tfm_entry), GFP_KERNEL);
564                 if (unlikely(!tfm_entry)) {       564                 if (unlikely(!tfm_entry)) {
565                         crypto_free_aead(tfm);    565                         crypto_free_aead(tfm);
566                         err = -ENOMEM;            566                         err = -ENOMEM;
567                         break;                    567                         break;
568                 }                                 568                 }
569                 INIT_LIST_HEAD(&tfm_entry->lis    569                 INIT_LIST_HEAD(&tfm_entry->list);
570                 tfm_entry->tfm = tfm;             570                 tfm_entry->tfm = tfm;
571                                                   571 
572                 /* First entry? */                572                 /* First entry? */
573                 if (!tfm_cnt) {                   573                 if (!tfm_cnt) {
574                         head = tfm_entry;         574                         head = tfm_entry;
575                         for_each_possible_cpu(    575                         for_each_possible_cpu(cpu) {
576                                 *per_cpu_ptr(t    576                                 *per_cpu_ptr(tmp->tfm_entry, cpu) = head;
577                         }                         577                         }
578                 } else {                          578                 } else {
579                         list_add_tail(&tfm_ent    579                         list_add_tail(&tfm_entry->list, &head->list);
580                 }                                 580                 }
581                                                   581 
582         } while (++tfm_cnt < sysctl_tipc_max_t    582         } while (++tfm_cnt < sysctl_tipc_max_tfms);
583                                                   583 
584         /* Not any TFM is allocated? */           584         /* Not any TFM is allocated? */
585         if (!tfm_cnt) {                           585         if (!tfm_cnt) {
586                 free_percpu(tmp->tfm_entry);      586                 free_percpu(tmp->tfm_entry);
587                 kfree_sensitive(tmp);             587                 kfree_sensitive(tmp);
588                 return err;                       588                 return err;
589         }                                         589         }
590                                                   590 
591         /* Form a hex string of some last byte    591         /* Form a hex string of some last bytes as the key's hint */
592         bin2hex(tmp->hint, ukey->key + keylen     592         bin2hex(tmp->hint, ukey->key + keylen - TIPC_AEAD_HINT_LEN,
593                 TIPC_AEAD_HINT_LEN);              593                 TIPC_AEAD_HINT_LEN);
594                                                   594 
595         /* Initialize the other data */           595         /* Initialize the other data */
596         tmp->mode = mode;                         596         tmp->mode = mode;
597         tmp->cloned = NULL;                       597         tmp->cloned = NULL;
598         tmp->authsize = TIPC_AES_GCM_TAG_SIZE;    598         tmp->authsize = TIPC_AES_GCM_TAG_SIZE;
599         tmp->key = kmemdup(ukey, tipc_aead_key    599         tmp->key = kmemdup(ukey, tipc_aead_key_size(ukey), GFP_KERNEL);
600         if (!tmp->key) {                       << 
601                 tipc_aead_free(&tmp->rcu);     << 
602                 return -ENOMEM;                << 
603         }                                      << 
604         memcpy(&tmp->salt, ukey->key + keylen,    600         memcpy(&tmp->salt, ukey->key + keylen, TIPC_AES_GCM_SALT_SIZE);
605         atomic_set(&tmp->users, 0);               601         atomic_set(&tmp->users, 0);
606         atomic64_set(&tmp->seqno, 0);             602         atomic64_set(&tmp->seqno, 0);
607         refcount_set(&tmp->refcnt, 1);            603         refcount_set(&tmp->refcnt, 1);
608                                                   604 
609         *aead = tmp;                              605         *aead = tmp;
610         return 0;                                 606         return 0;
611 }                                                 607 }
612                                                   608 
613 /**                                               609 /**
614  * tipc_aead_clone - Clone a TIPC AEAD key        610  * tipc_aead_clone - Clone a TIPC AEAD key
615  * @dst: dest key for the cloning                 611  * @dst: dest key for the cloning
616  * @src: source key to clone from                 612  * @src: source key to clone from
617  *                                                613  *
618  * Make a "copy" of the source AEAD key data t    614  * Make a "copy" of the source AEAD key data to the dest, the TFMs list is
619  * common for the keys.                           615  * common for the keys.
620  * A reference to the source is hold in the "c    616  * A reference to the source is hold in the "cloned" pointer for the later
621  * freeing purposes.                              617  * freeing purposes.
622  *                                                618  *
623  * Note: this must be done in cluster-key mode    619  * Note: this must be done in cluster-key mode only!
624  * Return: 0 in case of success, otherwise < 0    620  * Return: 0 in case of success, otherwise < 0
625  */                                               621  */
626 static int tipc_aead_clone(struct tipc_aead **    622 static int tipc_aead_clone(struct tipc_aead **dst, struct tipc_aead *src)
627 {                                                 623 {
628         struct tipc_aead *aead;                   624         struct tipc_aead *aead;
629         int cpu;                                  625         int cpu;
630                                                   626 
631         if (!src)                                 627         if (!src)
632                 return -ENOKEY;                   628                 return -ENOKEY;
633                                                   629 
634         if (src->mode != CLUSTER_KEY)             630         if (src->mode != CLUSTER_KEY)
635                 return -EINVAL;                   631                 return -EINVAL;
636                                                   632 
637         if (unlikely(*dst))                       633         if (unlikely(*dst))
638                 return -EEXIST;                   634                 return -EEXIST;
639                                                   635 
640         aead = kzalloc(sizeof(*aead), GFP_ATOM    636         aead = kzalloc(sizeof(*aead), GFP_ATOMIC);
641         if (unlikely(!aead))                      637         if (unlikely(!aead))
642                 return -ENOMEM;                   638                 return -ENOMEM;
643                                                   639 
644         aead->tfm_entry = alloc_percpu_gfp(str    640         aead->tfm_entry = alloc_percpu_gfp(struct tipc_tfm *, GFP_ATOMIC);
645         if (unlikely(!aead->tfm_entry)) {         641         if (unlikely(!aead->tfm_entry)) {
646                 kfree_sensitive(aead);            642                 kfree_sensitive(aead);
647                 return -ENOMEM;                   643                 return -ENOMEM;
648         }                                         644         }
649                                                   645 
650         for_each_possible_cpu(cpu) {              646         for_each_possible_cpu(cpu) {
651                 *per_cpu_ptr(aead->tfm_entry,     647                 *per_cpu_ptr(aead->tfm_entry, cpu) =
652                                 *per_cpu_ptr(s    648                                 *per_cpu_ptr(src->tfm_entry, cpu);
653         }                                         649         }
654                                                   650 
655         memcpy(aead->hint, src->hint, sizeof(s    651         memcpy(aead->hint, src->hint, sizeof(src->hint));
656         aead->mode = src->mode;                   652         aead->mode = src->mode;
657         aead->salt = src->salt;                   653         aead->salt = src->salt;
658         aead->authsize = src->authsize;           654         aead->authsize = src->authsize;
659         atomic_set(&aead->users, 0);              655         atomic_set(&aead->users, 0);
660         atomic64_set(&aead->seqno, 0);            656         atomic64_set(&aead->seqno, 0);
661         refcount_set(&aead->refcnt, 1);           657         refcount_set(&aead->refcnt, 1);
662                                                   658 
663         WARN_ON(!refcount_inc_not_zero(&src->r    659         WARN_ON(!refcount_inc_not_zero(&src->refcnt));
664         aead->cloned = src;                       660         aead->cloned = src;
665                                                   661 
666         *dst = aead;                              662         *dst = aead;
667         return 0;                                 663         return 0;
668 }                                                 664 }
669                                                   665 
670 /**                                               666 /**
671  * tipc_aead_mem_alloc - Allocate memory for A    667  * tipc_aead_mem_alloc - Allocate memory for AEAD request operations
672  * @tfm: cipher handle to be registered with t    668  * @tfm: cipher handle to be registered with the request
673  * @crypto_ctx_size: size of crypto context fo    669  * @crypto_ctx_size: size of crypto context for callback
674  * @iv: returned pointer to IV data               670  * @iv: returned pointer to IV data
675  * @req: returned pointer to AEAD request data    671  * @req: returned pointer to AEAD request data
676  * @sg: returned pointer to SG lists              672  * @sg: returned pointer to SG lists
677  * @nsg: number of SG lists to be allocated       673  * @nsg: number of SG lists to be allocated
678  *                                                674  *
679  * Allocate memory to store the crypto context    675  * Allocate memory to store the crypto context data, AEAD request, IV and SG
680  * lists, the memory layout is as follows:        676  * lists, the memory layout is as follows:
681  * crypto_ctx || iv || aead_req || sg[]           677  * crypto_ctx || iv || aead_req || sg[]
682  *                                                678  *
683  * Return: the pointer to the memory areas in     679  * Return: the pointer to the memory areas in case of success, otherwise NULL
684  */                                               680  */
685 static void *tipc_aead_mem_alloc(struct crypto    681 static void *tipc_aead_mem_alloc(struct crypto_aead *tfm,
686                                  unsigned int     682                                  unsigned int crypto_ctx_size,
687                                  u8 **iv, stru    683                                  u8 **iv, struct aead_request **req,
688                                  struct scatte    684                                  struct scatterlist **sg, int nsg)
689 {                                                 685 {
690         unsigned int iv_size, req_size;           686         unsigned int iv_size, req_size;
691         unsigned int len;                         687         unsigned int len;
692         u8 *mem;                                  688         u8 *mem;
693                                                   689 
694         iv_size = crypto_aead_ivsize(tfm);        690         iv_size = crypto_aead_ivsize(tfm);
695         req_size = sizeof(**req) + crypto_aead    691         req_size = sizeof(**req) + crypto_aead_reqsize(tfm);
696                                                   692 
697         len = crypto_ctx_size;                    693         len = crypto_ctx_size;
698         len += iv_size;                           694         len += iv_size;
699         len += crypto_aead_alignmask(tfm) & ~(    695         len += crypto_aead_alignmask(tfm) & ~(crypto_tfm_ctx_alignment() - 1);
700         len = ALIGN(len, crypto_tfm_ctx_alignm    696         len = ALIGN(len, crypto_tfm_ctx_alignment());
701         len += req_size;                          697         len += req_size;
702         len = ALIGN(len, __alignof__(struct sc    698         len = ALIGN(len, __alignof__(struct scatterlist));
703         len += nsg * sizeof(**sg);                699         len += nsg * sizeof(**sg);
704                                                   700 
705         mem = kmalloc(len, GFP_ATOMIC);           701         mem = kmalloc(len, GFP_ATOMIC);
706         if (!mem)                                 702         if (!mem)
707                 return NULL;                      703                 return NULL;
708                                                   704 
709         *iv = (u8 *)PTR_ALIGN(mem + crypto_ctx    705         *iv = (u8 *)PTR_ALIGN(mem + crypto_ctx_size,
710                               crypto_aead_alig    706                               crypto_aead_alignmask(tfm) + 1);
711         *req = (struct aead_request *)PTR_ALIG    707         *req = (struct aead_request *)PTR_ALIGN(*iv + iv_size,
712                                                   708                                                 crypto_tfm_ctx_alignment());
713         *sg = (struct scatterlist *)PTR_ALIGN(    709         *sg = (struct scatterlist *)PTR_ALIGN((u8 *)*req + req_size,
714                                                   710                                               __alignof__(struct scatterlist));
715                                                   711 
716         return (void *)mem;                       712         return (void *)mem;
717 }                                                 713 }
718                                                   714 
719 /**                                               715 /**
720  * tipc_aead_encrypt - Encrypt a message          716  * tipc_aead_encrypt - Encrypt a message
721  * @aead: TIPC AEAD key for the message encryp    717  * @aead: TIPC AEAD key for the message encryption
722  * @skb: the input/output skb                     718  * @skb: the input/output skb
723  * @b: TIPC bearer where the message will be d    719  * @b: TIPC bearer where the message will be delivered after the encryption
724  * @dst: the destination media address            720  * @dst: the destination media address
725  * @__dnode: TIPC dest node if "known"            721  * @__dnode: TIPC dest node if "known"
726  *                                                722  *
727  * Return:                                        723  * Return:
728  * * 0                   : if the encryption h    724  * * 0                   : if the encryption has completed
729  * * -EINPROGRESS/-EBUSY : if a callback will     725  * * -EINPROGRESS/-EBUSY : if a callback will be performed
730  * * < 0                 : the encryption has     726  * * < 0                 : the encryption has failed
731  */                                               727  */
732 static int tipc_aead_encrypt(struct tipc_aead     728 static int tipc_aead_encrypt(struct tipc_aead *aead, struct sk_buff *skb,
733                              struct tipc_beare    729                              struct tipc_bearer *b,
734                              struct tipc_media    730                              struct tipc_media_addr *dst,
735                              struct tipc_node     731                              struct tipc_node *__dnode)
736 {                                                 732 {
737         struct crypto_aead *tfm = tipc_aead_tf    733         struct crypto_aead *tfm = tipc_aead_tfm_next(aead);
738         struct tipc_crypto_tx_ctx *tx_ctx;        734         struct tipc_crypto_tx_ctx *tx_ctx;
739         struct aead_request *req;                 735         struct aead_request *req;
740         struct sk_buff *trailer;                  736         struct sk_buff *trailer;
741         struct scatterlist *sg;                   737         struct scatterlist *sg;
742         struct tipc_ehdr *ehdr;                   738         struct tipc_ehdr *ehdr;
743         int ehsz, len, tailen, nsg, rc;           739         int ehsz, len, tailen, nsg, rc;
744         void *ctx;                                740         void *ctx;
745         u32 salt;                                 741         u32 salt;
746         u8 *iv;                                   742         u8 *iv;
747                                                   743 
748         /* Make sure message len at least 4-by    744         /* Make sure message len at least 4-byte aligned */
749         len = ALIGN(skb->len, 4);                 745         len = ALIGN(skb->len, 4);
750         tailen = len - skb->len + aead->authsi    746         tailen = len - skb->len + aead->authsize;
751                                                   747 
752         /* Expand skb tail for authentication     748         /* Expand skb tail for authentication tag:
753          * As for simplicity, we'd have made s    749          * As for simplicity, we'd have made sure skb having enough tailroom
754          * for authentication tag @skb allocat    750          * for authentication tag @skb allocation. Even when skb is nonlinear
755          * but there is no frag_list, it shoul    751          * but there is no frag_list, it should be still fine!
756          * Otherwise, we must cow it to be a w    752          * Otherwise, we must cow it to be a writable buffer with the tailroom.
757          */                                       753          */
758         SKB_LINEAR_ASSERT(skb);                   754         SKB_LINEAR_ASSERT(skb);
759         if (tailen > skb_tailroom(skb)) {         755         if (tailen > skb_tailroom(skb)) {
760                 pr_debug("TX(): skb tailroom i    756                 pr_debug("TX(): skb tailroom is not enough: %d, requires: %d\n",
761                          skb_tailroom(skb), ta    757                          skb_tailroom(skb), tailen);
762         }                                         758         }
763                                                   759 
764         nsg = skb_cow_data(skb, tailen, &trail !! 760         if (unlikely(!skb_cloned(skb) && tailen <= skb_tailroom(skb))) {
765         if (unlikely(nsg < 0)) {               !! 761                 nsg = 1;
766                 pr_err("TX: skb_cow_data() ret !! 762                 trailer = skb;
767                 return nsg;                    !! 763         } else {
                                                   >> 764                 /* TODO: We could avoid skb_cow_data() if skb has no frag_list
                                                   >> 765                  * e.g. by skb_fill_page_desc() to add another page to the skb
                                                   >> 766                  * with the wanted tailen... However, page skbs look not often,
                                                   >> 767                  * so take it easy now!
                                                   >> 768                  * Cloned skbs e.g. from link_xmit() seems no choice though :(
                                                   >> 769                  */
                                                   >> 770                 nsg = skb_cow_data(skb, tailen, &trailer);
                                                   >> 771                 if (unlikely(nsg < 0)) {
                                                   >> 772                         pr_err("TX: skb_cow_data() returned %d\n", nsg);
                                                   >> 773                         return nsg;
                                                   >> 774                 }
768         }                                         775         }
769                                                   776 
770         pskb_put(skb, trailer, tailen);           777         pskb_put(skb, trailer, tailen);
771                                                   778 
772         /* Allocate memory for the AEAD operat    779         /* Allocate memory for the AEAD operation */
773         ctx = tipc_aead_mem_alloc(tfm, sizeof(    780         ctx = tipc_aead_mem_alloc(tfm, sizeof(*tx_ctx), &iv, &req, &sg, nsg);
774         if (unlikely(!ctx))                       781         if (unlikely(!ctx))
775                 return -ENOMEM;                   782                 return -ENOMEM;
776         TIPC_SKB_CB(skb)->crypto_ctx = ctx;       783         TIPC_SKB_CB(skb)->crypto_ctx = ctx;
777                                                   784 
778         /* Map skb to the sg lists */             785         /* Map skb to the sg lists */
779         sg_init_table(sg, nsg);                   786         sg_init_table(sg, nsg);
780         rc = skb_to_sgvec(skb, sg, 0, skb->len    787         rc = skb_to_sgvec(skb, sg, 0, skb->len);
781         if (unlikely(rc < 0)) {                   788         if (unlikely(rc < 0)) {
782                 pr_err("TX: skb_to_sgvec() ret    789                 pr_err("TX: skb_to_sgvec() returned %d, nsg %d!\n", rc, nsg);
783                 goto exit;                        790                 goto exit;
784         }                                         791         }
785                                                   792 
786         /* Prepare IV: [SALT (4 octets)][SEQNO    793         /* Prepare IV: [SALT (4 octets)][SEQNO (8 octets)]
787          * In case we're in cluster-key mode,     794          * In case we're in cluster-key mode, SALT is varied by xor-ing with
788          * the source address (or w0 of id), o    795          * the source address (or w0 of id), otherwise with the dest address
789          * if dest is known.                      796          * if dest is known.
790          */                                       797          */
791         ehdr = (struct tipc_ehdr *)skb->data;     798         ehdr = (struct tipc_ehdr *)skb->data;
792         salt = aead->salt;                        799         salt = aead->salt;
793         if (aead->mode == CLUSTER_KEY)            800         if (aead->mode == CLUSTER_KEY)
794                 salt ^= __be32_to_cpu(ehdr->ad    801                 salt ^= __be32_to_cpu(ehdr->addr);
795         else if (__dnode)                         802         else if (__dnode)
796                 salt ^= tipc_node_get_addr(__d    803                 salt ^= tipc_node_get_addr(__dnode);
797         memcpy(iv, &salt, 4);                     804         memcpy(iv, &salt, 4);
798         memcpy(iv + 4, (u8 *)&ehdr->seqno, 8);    805         memcpy(iv + 4, (u8 *)&ehdr->seqno, 8);
799                                                   806 
800         /* Prepare request */                     807         /* Prepare request */
801         ehsz = tipc_ehdr_size(ehdr);              808         ehsz = tipc_ehdr_size(ehdr);
802         aead_request_set_tfm(req, tfm);           809         aead_request_set_tfm(req, tfm);
803         aead_request_set_ad(req, ehsz);           810         aead_request_set_ad(req, ehsz);
804         aead_request_set_crypt(req, sg, sg, le    811         aead_request_set_crypt(req, sg, sg, len - ehsz, iv);
805                                                   812 
806         /* Set callback function & data */        813         /* Set callback function & data */
807         aead_request_set_callback(req, CRYPTO_    814         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
808                                   tipc_aead_en    815                                   tipc_aead_encrypt_done, skb);
809         tx_ctx = (struct tipc_crypto_tx_ctx *)    816         tx_ctx = (struct tipc_crypto_tx_ctx *)ctx;
810         tx_ctx->aead = aead;                      817         tx_ctx->aead = aead;
811         tx_ctx->bearer = b;                       818         tx_ctx->bearer = b;
812         memcpy(&tx_ctx->dst, dst, sizeof(*dst)    819         memcpy(&tx_ctx->dst, dst, sizeof(*dst));
813                                                   820 
814         /* Hold bearer */                         821         /* Hold bearer */
815         if (unlikely(!tipc_bearer_hold(b))) {     822         if (unlikely(!tipc_bearer_hold(b))) {
816                 rc = -ENODEV;                     823                 rc = -ENODEV;
817                 goto exit;                        824                 goto exit;
818         }                                         825         }
819                                                   826 
820         /* Now, do encrypt */                     827         /* Now, do encrypt */
821         rc = crypto_aead_encrypt(req);            828         rc = crypto_aead_encrypt(req);
822         if (rc == -EINPROGRESS || rc == -EBUSY    829         if (rc == -EINPROGRESS || rc == -EBUSY)
823                 return rc;                        830                 return rc;
824                                                   831 
825         tipc_bearer_put(b);                       832         tipc_bearer_put(b);
826                                                   833 
827 exit:                                             834 exit:
828         kfree(ctx);                               835         kfree(ctx);
829         TIPC_SKB_CB(skb)->crypto_ctx = NULL;      836         TIPC_SKB_CB(skb)->crypto_ctx = NULL;
830         return rc;                                837         return rc;
831 }                                                 838 }
832                                                   839 
833 static void tipc_aead_encrypt_done(void *data, !! 840 static void tipc_aead_encrypt_done(struct crypto_async_request *base, int err)
834 {                                                 841 {
835         struct sk_buff *skb = data;            !! 842         struct sk_buff *skb = base->data;
836         struct tipc_crypto_tx_ctx *tx_ctx = TI    843         struct tipc_crypto_tx_ctx *tx_ctx = TIPC_SKB_CB(skb)->crypto_ctx;
837         struct tipc_bearer *b = tx_ctx->bearer    844         struct tipc_bearer *b = tx_ctx->bearer;
838         struct tipc_aead *aead = tx_ctx->aead;    845         struct tipc_aead *aead = tx_ctx->aead;
839         struct tipc_crypto *tx = aead->crypto;    846         struct tipc_crypto *tx = aead->crypto;
840         struct net *net = tx->net;                847         struct net *net = tx->net;
841                                                   848 
842         switch (err) {                            849         switch (err) {
843         case 0:                                   850         case 0:
844                 this_cpu_inc(tx->stats->stat[S    851                 this_cpu_inc(tx->stats->stat[STAT_ASYNC_OK]);
845                 rcu_read_lock();                  852                 rcu_read_lock();
846                 if (likely(test_bit(0, &b->up)    853                 if (likely(test_bit(0, &b->up)))
847                         b->media->send_msg(net    854                         b->media->send_msg(net, skb, b, &tx_ctx->dst);
848                 else                              855                 else
849                         kfree_skb(skb);           856                         kfree_skb(skb);
850                 rcu_read_unlock();                857                 rcu_read_unlock();
851                 break;                            858                 break;
852         case -EINPROGRESS:                        859         case -EINPROGRESS:
853                 return;                           860                 return;
854         default:                                  861         default:
855                 this_cpu_inc(tx->stats->stat[S    862                 this_cpu_inc(tx->stats->stat[STAT_ASYNC_NOK]);
856                 kfree_skb(skb);                   863                 kfree_skb(skb);
857                 break;                            864                 break;
858         }                                         865         }
859                                                   866 
860         kfree(tx_ctx);                            867         kfree(tx_ctx);
861         tipc_bearer_put(b);                       868         tipc_bearer_put(b);
862         tipc_aead_put(aead);                      869         tipc_aead_put(aead);
863 }                                                 870 }
864                                                   871 
865 /**                                               872 /**
866  * tipc_aead_decrypt - Decrypt an encrypted me    873  * tipc_aead_decrypt - Decrypt an encrypted message
867  * @net: struct net                               874  * @net: struct net
868  * @aead: TIPC AEAD for the message decryption    875  * @aead: TIPC AEAD for the message decryption
869  * @skb: the input/output skb                     876  * @skb: the input/output skb
870  * @b: TIPC bearer where the message has been     877  * @b: TIPC bearer where the message has been received
871  *                                                878  *
872  * Return:                                        879  * Return:
873  * * 0                   : if the decryption h    880  * * 0                   : if the decryption has completed
874  * * -EINPROGRESS/-EBUSY : if a callback will     881  * * -EINPROGRESS/-EBUSY : if a callback will be performed
875  * * < 0                 : the decryption has     882  * * < 0                 : the decryption has failed
876  */                                               883  */
877 static int tipc_aead_decrypt(struct net *net,     884 static int tipc_aead_decrypt(struct net *net, struct tipc_aead *aead,
878                              struct sk_buff *s    885                              struct sk_buff *skb, struct tipc_bearer *b)
879 {                                                 886 {
880         struct tipc_crypto_rx_ctx *rx_ctx;        887         struct tipc_crypto_rx_ctx *rx_ctx;
881         struct aead_request *req;                 888         struct aead_request *req;
882         struct crypto_aead *tfm;                  889         struct crypto_aead *tfm;
883         struct sk_buff *unused;                   890         struct sk_buff *unused;
884         struct scatterlist *sg;                   891         struct scatterlist *sg;
885         struct tipc_ehdr *ehdr;                   892         struct tipc_ehdr *ehdr;
886         int ehsz, nsg, rc;                        893         int ehsz, nsg, rc;
887         void *ctx;                                894         void *ctx;
888         u32 salt;                                 895         u32 salt;
889         u8 *iv;                                   896         u8 *iv;
890                                                   897 
891         if (unlikely(!aead))                      898         if (unlikely(!aead))
892                 return -ENOKEY;                   899                 return -ENOKEY;
893                                                   900 
894         nsg = skb_cow_data(skb, 0, &unused);      901         nsg = skb_cow_data(skb, 0, &unused);
895         if (unlikely(nsg < 0)) {                  902         if (unlikely(nsg < 0)) {
896                 pr_err("RX: skb_cow_data() ret    903                 pr_err("RX: skb_cow_data() returned %d\n", nsg);
897                 return nsg;                       904                 return nsg;
898         }                                         905         }
899                                                   906 
900         /* Allocate memory for the AEAD operat    907         /* Allocate memory for the AEAD operation */
901         tfm = tipc_aead_tfm_next(aead);           908         tfm = tipc_aead_tfm_next(aead);
902         ctx = tipc_aead_mem_alloc(tfm, sizeof(    909         ctx = tipc_aead_mem_alloc(tfm, sizeof(*rx_ctx), &iv, &req, &sg, nsg);
903         if (unlikely(!ctx))                       910         if (unlikely(!ctx))
904                 return -ENOMEM;                   911                 return -ENOMEM;
905         TIPC_SKB_CB(skb)->crypto_ctx = ctx;       912         TIPC_SKB_CB(skb)->crypto_ctx = ctx;
906                                                   913 
907         /* Map skb to the sg lists */             914         /* Map skb to the sg lists */
908         sg_init_table(sg, nsg);                   915         sg_init_table(sg, nsg);
909         rc = skb_to_sgvec(skb, sg, 0, skb->len    916         rc = skb_to_sgvec(skb, sg, 0, skb->len);
910         if (unlikely(rc < 0)) {                   917         if (unlikely(rc < 0)) {
911                 pr_err("RX: skb_to_sgvec() ret    918                 pr_err("RX: skb_to_sgvec() returned %d, nsg %d\n", rc, nsg);
912                 goto exit;                        919                 goto exit;
913         }                                         920         }
914                                                   921 
915         /* Reconstruct IV: */                     922         /* Reconstruct IV: */
916         ehdr = (struct tipc_ehdr *)skb->data;     923         ehdr = (struct tipc_ehdr *)skb->data;
917         salt = aead->salt;                        924         salt = aead->salt;
918         if (aead->mode == CLUSTER_KEY)            925         if (aead->mode == CLUSTER_KEY)
919                 salt ^= __be32_to_cpu(ehdr->ad    926                 salt ^= __be32_to_cpu(ehdr->addr);
920         else if (ehdr->destined)                  927         else if (ehdr->destined)
921                 salt ^= tipc_own_addr(net);       928                 salt ^= tipc_own_addr(net);
922         memcpy(iv, &salt, 4);                     929         memcpy(iv, &salt, 4);
923         memcpy(iv + 4, (u8 *)&ehdr->seqno, 8);    930         memcpy(iv + 4, (u8 *)&ehdr->seqno, 8);
924                                                   931 
925         /* Prepare request */                     932         /* Prepare request */
926         ehsz = tipc_ehdr_size(ehdr);              933         ehsz = tipc_ehdr_size(ehdr);
927         aead_request_set_tfm(req, tfm);           934         aead_request_set_tfm(req, tfm);
928         aead_request_set_ad(req, ehsz);           935         aead_request_set_ad(req, ehsz);
929         aead_request_set_crypt(req, sg, sg, sk    936         aead_request_set_crypt(req, sg, sg, skb->len - ehsz, iv);
930                                                   937 
931         /* Set callback function & data */        938         /* Set callback function & data */
932         aead_request_set_callback(req, CRYPTO_    939         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
933                                   tipc_aead_de    940                                   tipc_aead_decrypt_done, skb);
934         rx_ctx = (struct tipc_crypto_rx_ctx *)    941         rx_ctx = (struct tipc_crypto_rx_ctx *)ctx;
935         rx_ctx->aead = aead;                      942         rx_ctx->aead = aead;
936         rx_ctx->bearer = b;                       943         rx_ctx->bearer = b;
937                                                   944 
938         /* Hold bearer */                         945         /* Hold bearer */
939         if (unlikely(!tipc_bearer_hold(b))) {     946         if (unlikely(!tipc_bearer_hold(b))) {
940                 rc = -ENODEV;                     947                 rc = -ENODEV;
941                 goto exit;                        948                 goto exit;
942         }                                         949         }
943                                                   950 
944         /* Now, do decrypt */                     951         /* Now, do decrypt */
945         rc = crypto_aead_decrypt(req);            952         rc = crypto_aead_decrypt(req);
946         if (rc == -EINPROGRESS || rc == -EBUSY    953         if (rc == -EINPROGRESS || rc == -EBUSY)
947                 return rc;                        954                 return rc;
948                                                   955 
949         tipc_bearer_put(b);                       956         tipc_bearer_put(b);
950                                                   957 
951 exit:                                             958 exit:
952         kfree(ctx);                               959         kfree(ctx);
953         TIPC_SKB_CB(skb)->crypto_ctx = NULL;      960         TIPC_SKB_CB(skb)->crypto_ctx = NULL;
954         return rc;                                961         return rc;
955 }                                                 962 }
956                                                   963 
957 static void tipc_aead_decrypt_done(void *data, !! 964 static void tipc_aead_decrypt_done(struct crypto_async_request *base, int err)
958 {                                                 965 {
959         struct sk_buff *skb = data;            !! 966         struct sk_buff *skb = base->data;
960         struct tipc_crypto_rx_ctx *rx_ctx = TI    967         struct tipc_crypto_rx_ctx *rx_ctx = TIPC_SKB_CB(skb)->crypto_ctx;
961         struct tipc_bearer *b = rx_ctx->bearer    968         struct tipc_bearer *b = rx_ctx->bearer;
962         struct tipc_aead *aead = rx_ctx->aead;    969         struct tipc_aead *aead = rx_ctx->aead;
963         struct tipc_crypto_stats __percpu *sta    970         struct tipc_crypto_stats __percpu *stats = aead->crypto->stats;
964         struct net *net = aead->crypto->net;      971         struct net *net = aead->crypto->net;
965                                                   972 
966         switch (err) {                            973         switch (err) {
967         case 0:                                   974         case 0:
968                 this_cpu_inc(stats->stat[STAT_    975                 this_cpu_inc(stats->stat[STAT_ASYNC_OK]);
969                 break;                            976                 break;
970         case -EINPROGRESS:                        977         case -EINPROGRESS:
971                 return;                           978                 return;
972         default:                                  979         default:
973                 this_cpu_inc(stats->stat[STAT_    980                 this_cpu_inc(stats->stat[STAT_ASYNC_NOK]);
974                 break;                            981                 break;
975         }                                         982         }
976                                                   983 
977         kfree(rx_ctx);                            984         kfree(rx_ctx);
978         tipc_crypto_rcv_complete(net, aead, b,    985         tipc_crypto_rcv_complete(net, aead, b, &skb, err);
979         if (likely(skb)) {                        986         if (likely(skb)) {
980                 if (likely(test_bit(0, &b->up)    987                 if (likely(test_bit(0, &b->up)))
981                         tipc_rcv(net, skb, b);    988                         tipc_rcv(net, skb, b);
982                 else                              989                 else
983                         kfree_skb(skb);           990                         kfree_skb(skb);
984         }                                         991         }
985                                                   992 
986         tipc_bearer_put(b);                       993         tipc_bearer_put(b);
987 }                                                 994 }
988                                                   995 
989 static inline int tipc_ehdr_size(struct tipc_e    996 static inline int tipc_ehdr_size(struct tipc_ehdr *ehdr)
990 {                                                 997 {
991         return (ehdr->user != LINK_CONFIG) ? E    998         return (ehdr->user != LINK_CONFIG) ? EHDR_SIZE : EHDR_CFG_SIZE;
992 }                                                 999 }
993                                                   1000 
994 /**                                               1001 /**
995  * tipc_ehdr_validate - Validate an encryption    1002  * tipc_ehdr_validate - Validate an encryption message
996  * @skb: the message buffer                       1003  * @skb: the message buffer
997  *                                                1004  *
998  * Return: "true" if this is a valid encryptio    1005  * Return: "true" if this is a valid encryption message, otherwise "false"
999  */                                               1006  */
1000 bool tipc_ehdr_validate(struct sk_buff *skb)     1007 bool tipc_ehdr_validate(struct sk_buff *skb)
1001 {                                                1008 {
1002         struct tipc_ehdr *ehdr;                  1009         struct tipc_ehdr *ehdr;
1003         int ehsz;                                1010         int ehsz;
1004                                                  1011 
1005         if (unlikely(!pskb_may_pull(skb, EHDR    1012         if (unlikely(!pskb_may_pull(skb, EHDR_MIN_SIZE)))
1006                 return false;                    1013                 return false;
1007                                                  1014 
1008         ehdr = (struct tipc_ehdr *)skb->data;    1015         ehdr = (struct tipc_ehdr *)skb->data;
1009         if (unlikely(ehdr->version != TIPC_EV    1016         if (unlikely(ehdr->version != TIPC_EVERSION))
1010                 return false;                    1017                 return false;
1011         ehsz = tipc_ehdr_size(ehdr);             1018         ehsz = tipc_ehdr_size(ehdr);
1012         if (unlikely(!pskb_may_pull(skb, ehsz    1019         if (unlikely(!pskb_may_pull(skb, ehsz)))
1013                 return false;                    1020                 return false;
1014         if (unlikely(skb->len <= ehsz + TIPC_    1021         if (unlikely(skb->len <= ehsz + TIPC_AES_GCM_TAG_SIZE))
1015                 return false;                    1022                 return false;
1016                                                  1023 
1017         return true;                             1024         return true;
1018 }                                                1025 }
1019                                                  1026 
1020 /**                                              1027 /**
1021  * tipc_ehdr_build - Build TIPC encryption me    1028  * tipc_ehdr_build - Build TIPC encryption message header
1022  * @net: struct net                              1029  * @net: struct net
1023  * @aead: TX AEAD key to be used for the mess    1030  * @aead: TX AEAD key to be used for the message encryption
1024  * @tx_key: key id used for the message encry    1031  * @tx_key: key id used for the message encryption
1025  * @skb: input/output message skb                1032  * @skb: input/output message skb
1026  * @__rx: RX crypto handle if dest is "known"    1033  * @__rx: RX crypto handle if dest is "known"
1027  *                                               1034  *
1028  * Return: the header size if the building is    1035  * Return: the header size if the building is successful, otherwise < 0
1029  */                                              1036  */
1030 static int tipc_ehdr_build(struct net *net, s    1037 static int tipc_ehdr_build(struct net *net, struct tipc_aead *aead,
1031                            u8 tx_key, struct     1038                            u8 tx_key, struct sk_buff *skb,
1032                            struct tipc_crypto    1039                            struct tipc_crypto *__rx)
1033 {                                                1040 {
1034         struct tipc_msg *hdr = buf_msg(skb);     1041         struct tipc_msg *hdr = buf_msg(skb);
1035         struct tipc_ehdr *ehdr;                  1042         struct tipc_ehdr *ehdr;
1036         u32 user = msg_user(hdr);                1043         u32 user = msg_user(hdr);
1037         u64 seqno;                               1044         u64 seqno;
1038         int ehsz;                                1045         int ehsz;
1039                                                  1046 
1040         /* Make room for encryption header */    1047         /* Make room for encryption header */
1041         ehsz = (user != LINK_CONFIG) ? EHDR_S    1048         ehsz = (user != LINK_CONFIG) ? EHDR_SIZE : EHDR_CFG_SIZE;
1042         WARN_ON(skb_headroom(skb) < ehsz);       1049         WARN_ON(skb_headroom(skb) < ehsz);
1043         ehdr = (struct tipc_ehdr *)skb_push(s    1050         ehdr = (struct tipc_ehdr *)skb_push(skb, ehsz);
1044                                                  1051 
1045         /* Obtain a seqno first:                 1052         /* Obtain a seqno first:
1046          * Use the key seqno (= cluster wise)    1053          * Use the key seqno (= cluster wise) if dest is unknown or we're in
1047          * cluster key mode, otherwise it's b    1054          * cluster key mode, otherwise it's better for a per-peer seqno!
1048          */                                      1055          */
1049         if (!__rx || aead->mode == CLUSTER_KE    1056         if (!__rx || aead->mode == CLUSTER_KEY)
1050                 seqno = atomic64_inc_return(&    1057                 seqno = atomic64_inc_return(&aead->seqno);
1051         else                                     1058         else
1052                 seqno = atomic64_inc_return(&    1059                 seqno = atomic64_inc_return(&__rx->sndnxt);
1053                                                  1060 
1054         /* Revoke the key if seqno is wrapped    1061         /* Revoke the key if seqno is wrapped around */
1055         if (unlikely(!seqno))                    1062         if (unlikely(!seqno))
1056                 return tipc_crypto_key_revoke    1063                 return tipc_crypto_key_revoke(net, tx_key);
1057                                                  1064 
1058         /* Word 1-2 */                           1065         /* Word 1-2 */
1059         ehdr->seqno = cpu_to_be64(seqno);        1066         ehdr->seqno = cpu_to_be64(seqno);
1060                                                  1067 
1061         /* Words 0, 3- */                        1068         /* Words 0, 3- */
1062         ehdr->version = TIPC_EVERSION;           1069         ehdr->version = TIPC_EVERSION;
1063         ehdr->user = 0;                          1070         ehdr->user = 0;
1064         ehdr->keepalive = 0;                     1071         ehdr->keepalive = 0;
1065         ehdr->tx_key = tx_key;                   1072         ehdr->tx_key = tx_key;
1066         ehdr->destined = (__rx) ? 1 : 0;         1073         ehdr->destined = (__rx) ? 1 : 0;
1067         ehdr->rx_key_active = (__rx) ? __rx->    1074         ehdr->rx_key_active = (__rx) ? __rx->key.active : 0;
1068         ehdr->rx_nokey = (__rx) ? __rx->nokey    1075         ehdr->rx_nokey = (__rx) ? __rx->nokey : 0;
1069         ehdr->master_key = aead->crypto->key_    1076         ehdr->master_key = aead->crypto->key_master;
1070         ehdr->reserved_1 = 0;                    1077         ehdr->reserved_1 = 0;
1071         ehdr->reserved_2 = 0;                    1078         ehdr->reserved_2 = 0;
1072                                                  1079 
1073         switch (user) {                          1080         switch (user) {
1074         case LINK_CONFIG:                        1081         case LINK_CONFIG:
1075                 ehdr->user = LINK_CONFIG;        1082                 ehdr->user = LINK_CONFIG;
1076                 memcpy(ehdr->id, tipc_own_id(    1083                 memcpy(ehdr->id, tipc_own_id(net), NODE_ID_LEN);
1077                 break;                           1084                 break;
1078         default:                                 1085         default:
1079                 if (user == LINK_PROTOCOL &&     1086                 if (user == LINK_PROTOCOL && msg_type(hdr) == STATE_MSG) {
1080                         ehdr->user = LINK_PRO    1087                         ehdr->user = LINK_PROTOCOL;
1081                         ehdr->keepalive = msg    1088                         ehdr->keepalive = msg_is_keepalive(hdr);
1082                 }                                1089                 }
1083                 ehdr->addr = hdr->hdr[3];        1090                 ehdr->addr = hdr->hdr[3];
1084                 break;                           1091                 break;
1085         }                                        1092         }
1086                                                  1093 
1087         return ehsz;                             1094         return ehsz;
1088 }                                                1095 }
1089                                                  1096 
1090 static inline void tipc_crypto_key_set_state(    1097 static inline void tipc_crypto_key_set_state(struct tipc_crypto *c,
1091                                                  1098                                              u8 new_passive,
1092                                                  1099                                              u8 new_active,
1093                                                  1100                                              u8 new_pending)
1094 {                                                1101 {
1095         struct tipc_key old = c->key;            1102         struct tipc_key old = c->key;
1096         char buf[32];                            1103         char buf[32];
1097                                                  1104 
1098         c->key.keys = ((new_passive & KEY_MAS    1105         c->key.keys = ((new_passive & KEY_MASK) << (KEY_BITS * 2)) |
1099                       ((new_active  & KEY_MAS    1106                       ((new_active  & KEY_MASK) << (KEY_BITS)) |
1100                       ((new_pending & KEY_MAS    1107                       ((new_pending & KEY_MASK));
1101                                                  1108 
1102         pr_debug("%s: key changing %s ::%pS\n    1109         pr_debug("%s: key changing %s ::%pS\n", c->name,
1103                  tipc_key_change_dump(old, c-    1110                  tipc_key_change_dump(old, c->key, buf),
1104                  __builtin_return_address(0))    1111                  __builtin_return_address(0));
1105 }                                                1112 }
1106                                                  1113 
1107 /**                                              1114 /**
1108  * tipc_crypto_key_init - Initiate a new user    1115  * tipc_crypto_key_init - Initiate a new user / AEAD key
1109  * @c: TIPC crypto to which new key is attach    1116  * @c: TIPC crypto to which new key is attached
1110  * @ukey: the user key                           1117  * @ukey: the user key
1111  * @mode: the key mode (CLUSTER_KEY or PER_NO    1118  * @mode: the key mode (CLUSTER_KEY or PER_NODE_KEY)
1112  * @master_key: specify this is a cluster mas    1119  * @master_key: specify this is a cluster master key
1113  *                                               1120  *
1114  * A new TIPC AEAD key will be allocated and     1121  * A new TIPC AEAD key will be allocated and initiated with the specified user
1115  * key, then attached to the TIPC crypto.        1122  * key, then attached to the TIPC crypto.
1116  *                                               1123  *
1117  * Return: new key id in case of success, oth    1124  * Return: new key id in case of success, otherwise: < 0
1118  */                                              1125  */
1119 int tipc_crypto_key_init(struct tipc_crypto *    1126 int tipc_crypto_key_init(struct tipc_crypto *c, struct tipc_aead_key *ukey,
1120                          u8 mode, bool master    1127                          u8 mode, bool master_key)
1121 {                                                1128 {
1122         struct tipc_aead *aead = NULL;           1129         struct tipc_aead *aead = NULL;
1123         int rc = 0;                              1130         int rc = 0;
1124                                                  1131 
1125         /* Initiate with the new user key */     1132         /* Initiate with the new user key */
1126         rc = tipc_aead_init(&aead, ukey, mode    1133         rc = tipc_aead_init(&aead, ukey, mode);
1127                                                  1134 
1128         /* Attach it to the crypto */            1135         /* Attach it to the crypto */
1129         if (likely(!rc)) {                       1136         if (likely(!rc)) {
1130                 rc = tipc_crypto_key_attach(c    1137                 rc = tipc_crypto_key_attach(c, aead, 0, master_key);
1131                 if (rc < 0)                      1138                 if (rc < 0)
1132                         tipc_aead_free(&aead-    1139                         tipc_aead_free(&aead->rcu);
1133         }                                        1140         }
1134                                                  1141 
1135         return rc;                               1142         return rc;
1136 }                                                1143 }
1137                                                  1144 
1138 /**                                              1145 /**
1139  * tipc_crypto_key_attach - Attach a new AEAD    1146  * tipc_crypto_key_attach - Attach a new AEAD key to TIPC crypto
1140  * @c: TIPC crypto to which the new AEAD key     1147  * @c: TIPC crypto to which the new AEAD key is attached
1141  * @aead: the new AEAD key pointer               1148  * @aead: the new AEAD key pointer
1142  * @pos: desired slot in the crypto key array    1149  * @pos: desired slot in the crypto key array, = 0 if any!
1143  * @master_key: specify this is a cluster mas    1150  * @master_key: specify this is a cluster master key
1144  *                                               1151  *
1145  * Return: new key id in case of success, oth    1152  * Return: new key id in case of success, otherwise: -EBUSY
1146  */                                              1153  */
1147 static int tipc_crypto_key_attach(struct tipc    1154 static int tipc_crypto_key_attach(struct tipc_crypto *c,
1148                                   struct tipc    1155                                   struct tipc_aead *aead, u8 pos,
1149                                   bool master    1156                                   bool master_key)
1150 {                                                1157 {
1151         struct tipc_key key;                     1158         struct tipc_key key;
1152         int rc = -EBUSY;                         1159         int rc = -EBUSY;
1153         u8 new_key;                              1160         u8 new_key;
1154                                                  1161 
1155         spin_lock_bh(&c->lock);                  1162         spin_lock_bh(&c->lock);
1156         key = c->key;                            1163         key = c->key;
1157         if (master_key) {                        1164         if (master_key) {
1158                 new_key = KEY_MASTER;            1165                 new_key = KEY_MASTER;
1159                 goto attach;                     1166                 goto attach;
1160         }                                        1167         }
1161         if (key.active && key.passive)           1168         if (key.active && key.passive)
1162                 goto exit;                       1169                 goto exit;
1163         if (key.pending) {                       1170         if (key.pending) {
1164                 if (tipc_aead_users(c->aead[k    1171                 if (tipc_aead_users(c->aead[key.pending]) > 0)
1165                         goto exit;               1172                         goto exit;
1166                 /* if (pos): ok with replacin    1173                 /* if (pos): ok with replacing, will be aligned when needed */
1167                 /* Replace it */                 1174                 /* Replace it */
1168                 new_key = key.pending;           1175                 new_key = key.pending;
1169         } else {                                 1176         } else {
1170                 if (pos) {                       1177                 if (pos) {
1171                         if (key.active && pos    1178                         if (key.active && pos != key_next(key.active)) {
1172                                 key.passive =    1179                                 key.passive = pos;
1173                                 new_key = pos    1180                                 new_key = pos;
1174                                 goto attach;     1181                                 goto attach;
1175                         } else if (!key.activ    1182                         } else if (!key.active && !key.passive) {
1176                                 key.pending =    1183                                 key.pending = pos;
1177                                 new_key = pos    1184                                 new_key = pos;
1178                                 goto attach;     1185                                 goto attach;
1179                         }                        1186                         }
1180                 }                                1187                 }
1181                 key.pending = key_next(key.ac    1188                 key.pending = key_next(key.active ?: key.passive);
1182                 new_key = key.pending;           1189                 new_key = key.pending;
1183         }                                        1190         }
1184                                                  1191 
1185 attach:                                          1192 attach:
1186         aead->crypto = c;                        1193         aead->crypto = c;
1187         aead->gen = (is_tx(c)) ? ++c->key_gen    1194         aead->gen = (is_tx(c)) ? ++c->key_gen : c->key_gen;
1188         tipc_aead_rcu_replace(c->aead[new_key    1195         tipc_aead_rcu_replace(c->aead[new_key], aead, &c->lock);
1189         if (likely(c->key.keys != key.keys))     1196         if (likely(c->key.keys != key.keys))
1190                 tipc_crypto_key_set_state(c,     1197                 tipc_crypto_key_set_state(c, key.passive, key.active,
1191                                           key    1198                                           key.pending);
1192         c->working = 1;                          1199         c->working = 1;
1193         c->nokey = 0;                            1200         c->nokey = 0;
1194         c->key_master |= master_key;             1201         c->key_master |= master_key;
1195         rc = new_key;                            1202         rc = new_key;
1196                                                  1203 
1197 exit:                                            1204 exit:
1198         spin_unlock_bh(&c->lock);                1205         spin_unlock_bh(&c->lock);
1199         return rc;                               1206         return rc;
1200 }                                                1207 }
1201                                                  1208 
1202 void tipc_crypto_key_flush(struct tipc_crypto    1209 void tipc_crypto_key_flush(struct tipc_crypto *c)
1203 {                                                1210 {
1204         struct tipc_crypto *tx, *rx;             1211         struct tipc_crypto *tx, *rx;
1205         int k;                                   1212         int k;
1206                                                  1213 
1207         spin_lock_bh(&c->lock);                  1214         spin_lock_bh(&c->lock);
1208         if (is_rx(c)) {                          1215         if (is_rx(c)) {
1209                 /* Try to cancel pending work    1216                 /* Try to cancel pending work */
1210                 rx = c;                          1217                 rx = c;
1211                 tx = tipc_net(rx->net)->crypt    1218                 tx = tipc_net(rx->net)->crypto_tx;
1212                 if (cancel_delayed_work(&rx->    1219                 if (cancel_delayed_work(&rx->work)) {
1213                         kfree(rx->skey);         1220                         kfree(rx->skey);
1214                         rx->skey = NULL;         1221                         rx->skey = NULL;
1215                         atomic_xchg(&rx->key_    1222                         atomic_xchg(&rx->key_distr, 0);
1216                         tipc_node_put(rx->nod    1223                         tipc_node_put(rx->node);
1217                 }                                1224                 }
1218                 /* RX stopping => decrease TX    1225                 /* RX stopping => decrease TX key users if any */
1219                 k = atomic_xchg(&rx->peer_rx_    1226                 k = atomic_xchg(&rx->peer_rx_active, 0);
1220                 if (k) {                         1227                 if (k) {
1221                         tipc_aead_users_dec(t    1228                         tipc_aead_users_dec(tx->aead[k], 0);
1222                         /* Mark the point TX     1229                         /* Mark the point TX key users changed */
1223                         tx->timer1 = jiffies;    1230                         tx->timer1 = jiffies;
1224                 }                                1231                 }
1225         }                                        1232         }
1226                                                  1233 
1227         c->flags = 0;                            1234         c->flags = 0;
1228         tipc_crypto_key_set_state(c, 0, 0, 0)    1235         tipc_crypto_key_set_state(c, 0, 0, 0);
1229         for (k = KEY_MIN; k <= KEY_MAX; k++)     1236         for (k = KEY_MIN; k <= KEY_MAX; k++)
1230                 tipc_crypto_key_detach(c->aea    1237                 tipc_crypto_key_detach(c->aead[k], &c->lock);
1231         atomic64_set(&c->sndnxt, 0);             1238         atomic64_set(&c->sndnxt, 0);
1232         spin_unlock_bh(&c->lock);                1239         spin_unlock_bh(&c->lock);
1233 }                                                1240 }
1234                                                  1241 
1235 /**                                              1242 /**
1236  * tipc_crypto_key_try_align - Align RX keys     1243  * tipc_crypto_key_try_align - Align RX keys if possible
1237  * @rx: RX crypto handle                         1244  * @rx: RX crypto handle
1238  * @new_pending: new pending slot if aligned     1245  * @new_pending: new pending slot if aligned (= TX key from peer)
1239  *                                               1246  *
1240  * Peer has used an unknown key slot, this on    1247  * Peer has used an unknown key slot, this only happens when peer has left and
1241  * rejoned, or we are newcomer.                  1248  * rejoned, or we are newcomer.
1242  * That means, there must be no active key bu    1249  * That means, there must be no active key but a pending key at unaligned slot.
1243  * If so, we try to move the pending key to t    1250  * If so, we try to move the pending key to the new slot.
1244  * Note: A potential passive key can exist, i    1251  * Note: A potential passive key can exist, it will be shifted correspondingly!
1245  *                                               1252  *
1246  * Return: "true" if key is successfully alig    1253  * Return: "true" if key is successfully aligned, otherwise "false"
1247  */                                              1254  */
1248 static bool tipc_crypto_key_try_align(struct     1255 static bool tipc_crypto_key_try_align(struct tipc_crypto *rx, u8 new_pending)
1249 {                                                1256 {
1250         struct tipc_aead *tmp1, *tmp2 = NULL;    1257         struct tipc_aead *tmp1, *tmp2 = NULL;
1251         struct tipc_key key;                     1258         struct tipc_key key;
1252         bool aligned = false;                    1259         bool aligned = false;
1253         u8 new_passive = 0;                      1260         u8 new_passive = 0;
1254         int x;                                   1261         int x;
1255                                                  1262 
1256         spin_lock(&rx->lock);                    1263         spin_lock(&rx->lock);
1257         key = rx->key;                           1264         key = rx->key;
1258         if (key.pending == new_pending) {        1265         if (key.pending == new_pending) {
1259                 aligned = true;                  1266                 aligned = true;
1260                 goto exit;                       1267                 goto exit;
1261         }                                        1268         }
1262         if (key.active)                          1269         if (key.active)
1263                 goto exit;                       1270                 goto exit;
1264         if (!key.pending)                        1271         if (!key.pending)
1265                 goto exit;                       1272                 goto exit;
1266         if (tipc_aead_users(rx->aead[key.pend    1273         if (tipc_aead_users(rx->aead[key.pending]) > 0)
1267                 goto exit;                       1274                 goto exit;
1268                                                  1275 
1269         /* Try to "isolate" this pending key     1276         /* Try to "isolate" this pending key first */
1270         tmp1 = tipc_aead_rcu_ptr(rx->aead[key    1277         tmp1 = tipc_aead_rcu_ptr(rx->aead[key.pending], &rx->lock);
1271         if (!refcount_dec_if_one(&tmp1->refcn    1278         if (!refcount_dec_if_one(&tmp1->refcnt))
1272                 goto exit;                       1279                 goto exit;
1273         rcu_assign_pointer(rx->aead[key.pendi    1280         rcu_assign_pointer(rx->aead[key.pending], NULL);
1274                                                  1281 
1275         /* Move passive key if any */            1282         /* Move passive key if any */
1276         if (key.passive) {                       1283         if (key.passive) {
1277                 tmp2 = rcu_replace_pointer(rx    1284                 tmp2 = rcu_replace_pointer(rx->aead[key.passive], tmp2, lockdep_is_held(&rx->lock));
1278                 x = (key.passive - key.pendin    1285                 x = (key.passive - key.pending + new_pending) % KEY_MAX;
1279                 new_passive = (x <= 0) ? x +     1286                 new_passive = (x <= 0) ? x + KEY_MAX : x;
1280         }                                        1287         }
1281                                                  1288 
1282         /* Re-allocate the key(s) */             1289         /* Re-allocate the key(s) */
1283         tipc_crypto_key_set_state(rx, new_pas    1290         tipc_crypto_key_set_state(rx, new_passive, 0, new_pending);
1284         rcu_assign_pointer(rx->aead[new_pendi    1291         rcu_assign_pointer(rx->aead[new_pending], tmp1);
1285         if (new_passive)                         1292         if (new_passive)
1286                 rcu_assign_pointer(rx->aead[n    1293                 rcu_assign_pointer(rx->aead[new_passive], tmp2);
1287         refcount_set(&tmp1->refcnt, 1);          1294         refcount_set(&tmp1->refcnt, 1);
1288         aligned = true;                          1295         aligned = true;
1289         pr_info_ratelimited("%s: key[%d] -> k    1296         pr_info_ratelimited("%s: key[%d] -> key[%d]\n", rx->name, key.pending,
1290                             new_pending);        1297                             new_pending);
1291                                                  1298 
1292 exit:                                            1299 exit:
1293         spin_unlock(&rx->lock);                  1300         spin_unlock(&rx->lock);
1294         return aligned;                          1301         return aligned;
1295 }                                                1302 }
1296                                                  1303 
1297 /**                                              1304 /**
1298  * tipc_crypto_key_pick_tx - Pick one TX key     1305  * tipc_crypto_key_pick_tx - Pick one TX key for message decryption
1299  * @tx: TX crypto handle                         1306  * @tx: TX crypto handle
1300  * @rx: RX crypto handle (can be NULL)           1307  * @rx: RX crypto handle (can be NULL)
1301  * @skb: the message skb which will be decryp    1308  * @skb: the message skb which will be decrypted later
1302  * @tx_key: peer TX key id                       1309  * @tx_key: peer TX key id
1303  *                                               1310  *
1304  * This function looks up the existing TX key    1311  * This function looks up the existing TX keys and pick one which is suitable
1305  * for the message decryption, that must be a    1312  * for the message decryption, that must be a cluster key and not used before
1306  * on the same message (i.e. recursive).         1313  * on the same message (i.e. recursive).
1307  *                                               1314  *
1308  * Return: the TX AEAD key handle in case of     1315  * Return: the TX AEAD key handle in case of success, otherwise NULL
1309  */                                              1316  */
1310 static struct tipc_aead *tipc_crypto_key_pick    1317 static struct tipc_aead *tipc_crypto_key_pick_tx(struct tipc_crypto *tx,
1311                                                  1318                                                  struct tipc_crypto *rx,
1312                                                  1319                                                  struct sk_buff *skb,
1313                                                  1320                                                  u8 tx_key)
1314 {                                                1321 {
1315         struct tipc_skb_cb *skb_cb = TIPC_SKB    1322         struct tipc_skb_cb *skb_cb = TIPC_SKB_CB(skb);
1316         struct tipc_aead *aead = NULL;           1323         struct tipc_aead *aead = NULL;
1317         struct tipc_key key = tx->key;           1324         struct tipc_key key = tx->key;
1318         u8 k, i = 0;                             1325         u8 k, i = 0;
1319                                                  1326 
1320         /* Initialize data if not yet */         1327         /* Initialize data if not yet */
1321         if (!skb_cb->tx_clone_deferred) {        1328         if (!skb_cb->tx_clone_deferred) {
1322                 skb_cb->tx_clone_deferred = 1    1329                 skb_cb->tx_clone_deferred = 1;
1323                 memset(&skb_cb->tx_clone_ctx,    1330                 memset(&skb_cb->tx_clone_ctx, 0, sizeof(skb_cb->tx_clone_ctx));
1324         }                                        1331         }
1325                                                  1332 
1326         skb_cb->tx_clone_ctx.rx = rx;            1333         skb_cb->tx_clone_ctx.rx = rx;
1327         if (++skb_cb->tx_clone_ctx.recurs > 2    1334         if (++skb_cb->tx_clone_ctx.recurs > 2)
1328                 return NULL;                     1335                 return NULL;
1329                                                  1336 
1330         /* Pick one TX key */                    1337         /* Pick one TX key */
1331         spin_lock(&tx->lock);                    1338         spin_lock(&tx->lock);
1332         if (tx_key == KEY_MASTER) {              1339         if (tx_key == KEY_MASTER) {
1333                 aead = tipc_aead_rcu_ptr(tx->    1340                 aead = tipc_aead_rcu_ptr(tx->aead[KEY_MASTER], &tx->lock);
1334                 goto done;                       1341                 goto done;
1335         }                                        1342         }
1336         do {                                     1343         do {
1337                 k = (i == 0) ? key.pending :     1344                 k = (i == 0) ? key.pending :
1338                         ((i == 1) ? key.activ    1345                         ((i == 1) ? key.active : key.passive);
1339                 if (!k)                          1346                 if (!k)
1340                         continue;                1347                         continue;
1341                 aead = tipc_aead_rcu_ptr(tx->    1348                 aead = tipc_aead_rcu_ptr(tx->aead[k], &tx->lock);
1342                 if (!aead)                       1349                 if (!aead)
1343                         continue;                1350                         continue;
1344                 if (aead->mode != CLUSTER_KEY    1351                 if (aead->mode != CLUSTER_KEY ||
1345                     aead == skb_cb->tx_clone_    1352                     aead == skb_cb->tx_clone_ctx.last) {
1346                         aead = NULL;             1353                         aead = NULL;
1347                         continue;                1354                         continue;
1348                 }                                1355                 }
1349                 /* Ok, found one cluster key     1356                 /* Ok, found one cluster key */
1350                 skb_cb->tx_clone_ctx.last = a    1357                 skb_cb->tx_clone_ctx.last = aead;
1351                 WARN_ON(skb->next);              1358                 WARN_ON(skb->next);
1352                 skb->next = skb_clone(skb, GF    1359                 skb->next = skb_clone(skb, GFP_ATOMIC);
1353                 if (unlikely(!skb->next))        1360                 if (unlikely(!skb->next))
1354                         pr_warn("Failed to cl    1361                         pr_warn("Failed to clone skb for next round if any\n");
1355                 break;                           1362                 break;
1356         } while (++i < 3);                       1363         } while (++i < 3);
1357                                                  1364 
1358 done:                                            1365 done:
1359         if (likely(aead))                        1366         if (likely(aead))
1360                 WARN_ON(!refcount_inc_not_zer    1367                 WARN_ON(!refcount_inc_not_zero(&aead->refcnt));
1361         spin_unlock(&tx->lock);                  1368         spin_unlock(&tx->lock);
1362                                                  1369 
1363         return aead;                             1370         return aead;
1364 }                                                1371 }
1365                                                  1372 
1366 /**                                              1373 /**
1367  * tipc_crypto_key_synch: Synch own key data     1374  * tipc_crypto_key_synch: Synch own key data according to peer key status
1368  * @rx: RX crypto handle                         1375  * @rx: RX crypto handle
1369  * @skb: TIPCv2 message buffer (incl. the ehd    1376  * @skb: TIPCv2 message buffer (incl. the ehdr from peer)
1370  *                                               1377  *
1371  * This function updates the peer node relate    1378  * This function updates the peer node related data as the peer RX active key
1372  * has changed, so the number of TX keys' use    1379  * has changed, so the number of TX keys' users on this node are increased and
1373  * decreased correspondingly.                    1380  * decreased correspondingly.
1374  *                                               1381  *
1375  * It also considers if peer has no key, then    1382  * It also considers if peer has no key, then we need to make own master key
1376  * (if any) taking over i.e. starting grace p    1383  * (if any) taking over i.e. starting grace period and also trigger key
1377  * distributing process.                         1384  * distributing process.
1378  *                                               1385  *
1379  * The "per-peer" sndnxt is also reset when t    1386  * The "per-peer" sndnxt is also reset when the peer key has switched.
1380  */                                              1387  */
1381 static void tipc_crypto_key_synch(struct tipc    1388 static void tipc_crypto_key_synch(struct tipc_crypto *rx, struct sk_buff *skb)
1382 {                                                1389 {
1383         struct tipc_ehdr *ehdr = (struct tipc    1390         struct tipc_ehdr *ehdr = (struct tipc_ehdr *)skb_network_header(skb);
1384         struct tipc_crypto *tx = tipc_net(rx-    1391         struct tipc_crypto *tx = tipc_net(rx->net)->crypto_tx;
1385         struct tipc_msg *hdr = buf_msg(skb);     1392         struct tipc_msg *hdr = buf_msg(skb);
1386         u32 self = tipc_own_addr(rx->net);       1393         u32 self = tipc_own_addr(rx->net);
1387         u8 cur, new;                             1394         u8 cur, new;
1388         unsigned long delay;                     1395         unsigned long delay;
1389                                                  1396 
1390         /* Update RX 'key_master' flag accord    1397         /* Update RX 'key_master' flag according to peer, also mark "legacy" if
1391          * a peer has no master key.             1398          * a peer has no master key.
1392          */                                      1399          */
1393         rx->key_master = ehdr->master_key;       1400         rx->key_master = ehdr->master_key;
1394         if (!rx->key_master)                     1401         if (!rx->key_master)
1395                 tx->legacy_user = 1;             1402                 tx->legacy_user = 1;
1396                                                  1403 
1397         /* For later cases, apply only if mes    1404         /* For later cases, apply only if message is destined to this node */
1398         if (!ehdr->destined || msg_short(hdr)    1405         if (!ehdr->destined || msg_short(hdr) || msg_destnode(hdr) != self)
1399                 return;                          1406                 return;
1400                                                  1407 
1401         /* Case 1: Peer has no keys, let's ma    1408         /* Case 1: Peer has no keys, let's make master key take over */
1402         if (ehdr->rx_nokey) {                    1409         if (ehdr->rx_nokey) {
1403                 /* Set or extend grace period    1410                 /* Set or extend grace period */
1404                 tx->timer2 = jiffies;            1411                 tx->timer2 = jiffies;
1405                 /* Schedule key distributing     1412                 /* Schedule key distributing for the peer if not yet */
1406                 if (tx->key.keys &&              1413                 if (tx->key.keys &&
1407                     !atomic_cmpxchg(&rx->key_    1414                     !atomic_cmpxchg(&rx->key_distr, 0, KEY_DISTR_SCHED)) {
1408                         get_random_bytes(&del    1415                         get_random_bytes(&delay, 2);
1409                         delay %= 5;              1416                         delay %= 5;
1410                         delay = msecs_to_jiff    1417                         delay = msecs_to_jiffies(500 * ++delay);
1411                         if (queue_delayed_wor    1418                         if (queue_delayed_work(tx->wq, &rx->work, delay))
1412                                 tipc_node_get    1419                                 tipc_node_get(rx->node);
1413                 }                                1420                 }
1414         } else {                                 1421         } else {
1415                 /* Cancel a pending key distr    1422                 /* Cancel a pending key distributing if any */
1416                 atomic_xchg(&rx->key_distr, 0    1423                 atomic_xchg(&rx->key_distr, 0);
1417         }                                        1424         }
1418                                                  1425 
1419         /* Case 2: Peer RX active key has cha    1426         /* Case 2: Peer RX active key has changed, let's update own TX users */
1420         cur = atomic_read(&rx->peer_rx_active    1427         cur = atomic_read(&rx->peer_rx_active);
1421         new = ehdr->rx_key_active;               1428         new = ehdr->rx_key_active;
1422         if (tx->key.keys &&                      1429         if (tx->key.keys &&
1423             cur != new &&                        1430             cur != new &&
1424             atomic_cmpxchg(&rx->peer_rx_activ    1431             atomic_cmpxchg(&rx->peer_rx_active, cur, new) == cur) {
1425                 if (new)                         1432                 if (new)
1426                         tipc_aead_users_inc(t    1433                         tipc_aead_users_inc(tx->aead[new], INT_MAX);
1427                 if (cur)                         1434                 if (cur)
1428                         tipc_aead_users_dec(t    1435                         tipc_aead_users_dec(tx->aead[cur], 0);
1429                                                  1436 
1430                 atomic64_set(&rx->sndnxt, 0);    1437                 atomic64_set(&rx->sndnxt, 0);
1431                 /* Mark the point TX key user    1438                 /* Mark the point TX key users changed */
1432                 tx->timer1 = jiffies;            1439                 tx->timer1 = jiffies;
1433                                                  1440 
1434                 pr_debug("%s: key users chang    1441                 pr_debug("%s: key users changed %d-- %d++, peer %s\n",
1435                          tx->name, cur, new,     1442                          tx->name, cur, new, rx->name);
1436         }                                        1443         }
1437 }                                                1444 }
1438                                                  1445 
1439 static int tipc_crypto_key_revoke(struct net     1446 static int tipc_crypto_key_revoke(struct net *net, u8 tx_key)
1440 {                                                1447 {
1441         struct tipc_crypto *tx = tipc_net(net    1448         struct tipc_crypto *tx = tipc_net(net)->crypto_tx;
1442         struct tipc_key key;                     1449         struct tipc_key key;
1443                                                  1450 
1444         spin_lock_bh(&tx->lock);              !! 1451         spin_lock(&tx->lock);
1445         key = tx->key;                           1452         key = tx->key;
1446         WARN_ON(!key.active || tx_key != key.    1453         WARN_ON(!key.active || tx_key != key.active);
1447                                                  1454 
1448         /* Free the active key */                1455         /* Free the active key */
1449         tipc_crypto_key_set_state(tx, key.pas    1456         tipc_crypto_key_set_state(tx, key.passive, 0, key.pending);
1450         tipc_crypto_key_detach(tx->aead[key.a    1457         tipc_crypto_key_detach(tx->aead[key.active], &tx->lock);
1451         spin_unlock_bh(&tx->lock);            !! 1458         spin_unlock(&tx->lock);
1452                                                  1459 
1453         pr_warn("%s: key is revoked\n", tx->n    1460         pr_warn("%s: key is revoked\n", tx->name);
1454         return -EKEYREVOKED;                     1461         return -EKEYREVOKED;
1455 }                                                1462 }
1456                                                  1463 
1457 int tipc_crypto_start(struct tipc_crypto **cr    1464 int tipc_crypto_start(struct tipc_crypto **crypto, struct net *net,
1458                       struct tipc_node *node)    1465                       struct tipc_node *node)
1459 {                                                1466 {
1460         struct tipc_crypto *c;                   1467         struct tipc_crypto *c;
1461                                                  1468 
1462         if (*crypto)                             1469         if (*crypto)
1463                 return -EEXIST;                  1470                 return -EEXIST;
1464                                                  1471 
1465         /* Allocate crypto */                    1472         /* Allocate crypto */
1466         c = kzalloc(sizeof(*c), GFP_ATOMIC);     1473         c = kzalloc(sizeof(*c), GFP_ATOMIC);
1467         if (!c)                                  1474         if (!c)
1468                 return -ENOMEM;                  1475                 return -ENOMEM;
1469                                                  1476 
1470         /* Allocate workqueue on TX */           1477         /* Allocate workqueue on TX */
1471         if (!node) {                             1478         if (!node) {
1472                 c->wq = alloc_ordered_workque    1479                 c->wq = alloc_ordered_workqueue("tipc_crypto", 0);
1473                 if (!c->wq) {                    1480                 if (!c->wq) {
1474                         kfree(c);                1481                         kfree(c);
1475                         return -ENOMEM;          1482                         return -ENOMEM;
1476                 }                                1483                 }
1477         }                                        1484         }
1478                                                  1485 
1479         /* Allocate statistic structure */       1486         /* Allocate statistic structure */
1480         c->stats = alloc_percpu_gfp(struct ti    1487         c->stats = alloc_percpu_gfp(struct tipc_crypto_stats, GFP_ATOMIC);
1481         if (!c->stats) {                         1488         if (!c->stats) {
1482                 if (c->wq)                       1489                 if (c->wq)
1483                         destroy_workqueue(c->    1490                         destroy_workqueue(c->wq);
1484                 kfree_sensitive(c);              1491                 kfree_sensitive(c);
1485                 return -ENOMEM;                  1492                 return -ENOMEM;
1486         }                                        1493         }
1487                                                  1494 
1488         c->flags = 0;                            1495         c->flags = 0;
1489         c->net = net;                            1496         c->net = net;
1490         c->node = node;                          1497         c->node = node;
1491         get_random_bytes(&c->key_gen, 2);        1498         get_random_bytes(&c->key_gen, 2);
1492         tipc_crypto_key_set_state(c, 0, 0, 0)    1499         tipc_crypto_key_set_state(c, 0, 0, 0);
1493         atomic_set(&c->key_distr, 0);            1500         atomic_set(&c->key_distr, 0);
1494         atomic_set(&c->peer_rx_active, 0);       1501         atomic_set(&c->peer_rx_active, 0);
1495         atomic64_set(&c->sndnxt, 0);             1502         atomic64_set(&c->sndnxt, 0);
1496         c->timer1 = jiffies;                     1503         c->timer1 = jiffies;
1497         c->timer2 = jiffies;                     1504         c->timer2 = jiffies;
1498         c->rekeying_intv = TIPC_REKEYING_INTV    1505         c->rekeying_intv = TIPC_REKEYING_INTV_DEF;
1499         spin_lock_init(&c->lock);                1506         spin_lock_init(&c->lock);
1500         scnprintf(c->name, 48, "%s(%s)", (is_    1507         scnprintf(c->name, 48, "%s(%s)", (is_rx(c)) ? "RX" : "TX",
1501                   (is_rx(c)) ? tipc_node_get_    1508                   (is_rx(c)) ? tipc_node_get_id_str(c->node) :
1502                                tipc_own_id_st    1509                                tipc_own_id_string(c->net));
1503                                                  1510 
1504         if (is_rx(c))                            1511         if (is_rx(c))
1505                 INIT_DELAYED_WORK(&c->work, t    1512                 INIT_DELAYED_WORK(&c->work, tipc_crypto_work_rx);
1506         else                                     1513         else
1507                 INIT_DELAYED_WORK(&c->work, t    1514                 INIT_DELAYED_WORK(&c->work, tipc_crypto_work_tx);
1508                                                  1515 
1509         *crypto = c;                             1516         *crypto = c;
1510         return 0;                                1517         return 0;
1511 }                                                1518 }
1512                                                  1519 
1513 void tipc_crypto_stop(struct tipc_crypto **cr    1520 void tipc_crypto_stop(struct tipc_crypto **crypto)
1514 {                                                1521 {
1515         struct tipc_crypto *c = *crypto;         1522         struct tipc_crypto *c = *crypto;
1516         u8 k;                                    1523         u8 k;
1517                                                  1524 
1518         if (!c)                                  1525         if (!c)
1519                 return;                          1526                 return;
1520                                                  1527 
1521         /* Flush any queued works & destroy w    1528         /* Flush any queued works & destroy wq */
1522         if (is_tx(c)) {                          1529         if (is_tx(c)) {
1523                 c->rekeying_intv = 0;            1530                 c->rekeying_intv = 0;
1524                 cancel_delayed_work_sync(&c->    1531                 cancel_delayed_work_sync(&c->work);
1525                 destroy_workqueue(c->wq);        1532                 destroy_workqueue(c->wq);
1526         }                                        1533         }
1527                                                  1534 
1528         /* Release AEAD keys */                  1535         /* Release AEAD keys */
1529         rcu_read_lock();                         1536         rcu_read_lock();
1530         for (k = KEY_MIN; k <= KEY_MAX; k++)     1537         for (k = KEY_MIN; k <= KEY_MAX; k++)
1531                 tipc_aead_put(rcu_dereference    1538                 tipc_aead_put(rcu_dereference(c->aead[k]));
1532         rcu_read_unlock();                       1539         rcu_read_unlock();
1533         pr_debug("%s: has been stopped\n", c-    1540         pr_debug("%s: has been stopped\n", c->name);
1534                                                  1541 
1535         /* Free this crypto statistics */        1542         /* Free this crypto statistics */
1536         free_percpu(c->stats);                   1543         free_percpu(c->stats);
1537                                                  1544 
1538         *crypto = NULL;                          1545         *crypto = NULL;
1539         kfree_sensitive(c);                      1546         kfree_sensitive(c);
1540 }                                                1547 }
1541                                                  1548 
1542 void tipc_crypto_timeout(struct tipc_crypto *    1549 void tipc_crypto_timeout(struct tipc_crypto *rx)
1543 {                                                1550 {
1544         struct tipc_net *tn = tipc_net(rx->ne    1551         struct tipc_net *tn = tipc_net(rx->net);
1545         struct tipc_crypto *tx = tn->crypto_t    1552         struct tipc_crypto *tx = tn->crypto_tx;
1546         struct tipc_key key;                     1553         struct tipc_key key;
1547         int cmd;                                 1554         int cmd;
1548                                                  1555 
1549         /* TX pending: taking all users & sta    1556         /* TX pending: taking all users & stable -> active */
1550         spin_lock(&tx->lock);                    1557         spin_lock(&tx->lock);
1551         key = tx->key;                           1558         key = tx->key;
1552         if (key.active && tipc_aead_users(tx-    1559         if (key.active && tipc_aead_users(tx->aead[key.active]) > 0)
1553                 goto s1;                         1560                 goto s1;
1554         if (!key.pending || tipc_aead_users(t    1561         if (!key.pending || tipc_aead_users(tx->aead[key.pending]) <= 0)
1555                 goto s1;                         1562                 goto s1;
1556         if (time_before(jiffies, tx->timer1 +    1563         if (time_before(jiffies, tx->timer1 + TIPC_TX_LASTING_TIME))
1557                 goto s1;                         1564                 goto s1;
1558                                                  1565 
1559         tipc_crypto_key_set_state(tx, key.pas    1566         tipc_crypto_key_set_state(tx, key.passive, key.pending, 0);
1560         if (key.active)                          1567         if (key.active)
1561                 tipc_crypto_key_detach(tx->ae    1568                 tipc_crypto_key_detach(tx->aead[key.active], &tx->lock);
1562         this_cpu_inc(tx->stats->stat[STAT_SWI    1569         this_cpu_inc(tx->stats->stat[STAT_SWITCHES]);
1563         pr_info("%s: key[%d] is activated\n",    1570         pr_info("%s: key[%d] is activated\n", tx->name, key.pending);
1564                                                  1571 
1565 s1:                                              1572 s1:
1566         spin_unlock(&tx->lock);                  1573         spin_unlock(&tx->lock);
1567                                                  1574 
1568         /* RX pending: having user -> active     1575         /* RX pending: having user -> active */
1569         spin_lock(&rx->lock);                    1576         spin_lock(&rx->lock);
1570         key = rx->key;                           1577         key = rx->key;
1571         if (!key.pending || tipc_aead_users(r    1578         if (!key.pending || tipc_aead_users(rx->aead[key.pending]) <= 0)
1572                 goto s2;                         1579                 goto s2;
1573                                                  1580 
1574         if (key.active)                          1581         if (key.active)
1575                 key.passive = key.active;        1582                 key.passive = key.active;
1576         key.active = key.pending;                1583         key.active = key.pending;
1577         rx->timer2 = jiffies;                    1584         rx->timer2 = jiffies;
1578         tipc_crypto_key_set_state(rx, key.pas    1585         tipc_crypto_key_set_state(rx, key.passive, key.active, 0);
1579         this_cpu_inc(rx->stats->stat[STAT_SWI    1586         this_cpu_inc(rx->stats->stat[STAT_SWITCHES]);
1580         pr_info("%s: key[%d] is activated\n",    1587         pr_info("%s: key[%d] is activated\n", rx->name, key.pending);
1581         goto s5;                                 1588         goto s5;
1582                                                  1589 
1583 s2:                                              1590 s2:
1584         /* RX pending: not working -> remove     1591         /* RX pending: not working -> remove */
1585         if (!key.pending || tipc_aead_users(r    1592         if (!key.pending || tipc_aead_users(rx->aead[key.pending]) > -10)
1586                 goto s3;                         1593                 goto s3;
1587                                                  1594 
1588         tipc_crypto_key_set_state(rx, key.pas    1595         tipc_crypto_key_set_state(rx, key.passive, key.active, 0);
1589         tipc_crypto_key_detach(rx->aead[key.p    1596         tipc_crypto_key_detach(rx->aead[key.pending], &rx->lock);
1590         pr_debug("%s: key[%d] is removed\n",     1597         pr_debug("%s: key[%d] is removed\n", rx->name, key.pending);
1591         goto s5;                                 1598         goto s5;
1592                                                  1599 
1593 s3:                                              1600 s3:
1594         /* RX active: timed out or no user ->    1601         /* RX active: timed out or no user -> pending */
1595         if (!key.active)                         1602         if (!key.active)
1596                 goto s4;                         1603                 goto s4;
1597         if (time_before(jiffies, rx->timer1 +    1604         if (time_before(jiffies, rx->timer1 + TIPC_RX_ACTIVE_LIM) &&
1598             tipc_aead_users(rx->aead[key.acti    1605             tipc_aead_users(rx->aead[key.active]) > 0)
1599                 goto s4;                         1606                 goto s4;
1600                                                  1607 
1601         if (key.pending)                         1608         if (key.pending)
1602                 key.passive = key.active;        1609                 key.passive = key.active;
1603         else                                     1610         else
1604                 key.pending = key.active;        1611                 key.pending = key.active;
1605         rx->timer2 = jiffies;                    1612         rx->timer2 = jiffies;
1606         tipc_crypto_key_set_state(rx, key.pas    1613         tipc_crypto_key_set_state(rx, key.passive, 0, key.pending);
1607         tipc_aead_users_set(rx->aead[key.pend    1614         tipc_aead_users_set(rx->aead[key.pending], 0);
1608         pr_debug("%s: key[%d] is deactivated\    1615         pr_debug("%s: key[%d] is deactivated\n", rx->name, key.active);
1609         goto s5;                                 1616         goto s5;
1610                                                  1617 
1611 s4:                                              1618 s4:
1612         /* RX passive: outdated or not workin    1619         /* RX passive: outdated or not working -> free */
1613         if (!key.passive)                        1620         if (!key.passive)
1614                 goto s5;                         1621                 goto s5;
1615         if (time_before(jiffies, rx->timer2 +    1622         if (time_before(jiffies, rx->timer2 + TIPC_RX_PASSIVE_LIM) &&
1616             tipc_aead_users(rx->aead[key.pass    1623             tipc_aead_users(rx->aead[key.passive]) > -10)
1617                 goto s5;                         1624                 goto s5;
1618                                                  1625 
1619         tipc_crypto_key_set_state(rx, 0, key.    1626         tipc_crypto_key_set_state(rx, 0, key.active, key.pending);
1620         tipc_crypto_key_detach(rx->aead[key.p    1627         tipc_crypto_key_detach(rx->aead[key.passive], &rx->lock);
1621         pr_debug("%s: key[%d] is freed\n", rx    1628         pr_debug("%s: key[%d] is freed\n", rx->name, key.passive);
1622                                                  1629 
1623 s5:                                              1630 s5:
1624         spin_unlock(&rx->lock);                  1631         spin_unlock(&rx->lock);
1625                                                  1632 
1626         /* Relax it here, the flag will be se    1633         /* Relax it here, the flag will be set again if it really is, but only
1627          * when we are not in grace period fo    1634          * when we are not in grace period for safety!
1628          */                                      1635          */
1629         if (time_after(jiffies, tx->timer2 +     1636         if (time_after(jiffies, tx->timer2 + TIPC_TX_GRACE_PERIOD))
1630                 tx->legacy_user = 0;             1637                 tx->legacy_user = 0;
1631                                                  1638 
1632         /* Limit max_tfms & do debug commands    1639         /* Limit max_tfms & do debug commands if needed */
1633         if (likely(sysctl_tipc_max_tfms <= TI    1640         if (likely(sysctl_tipc_max_tfms <= TIPC_MAX_TFMS_LIM))
1634                 return;                          1641                 return;
1635                                                  1642 
1636         cmd = sysctl_tipc_max_tfms;              1643         cmd = sysctl_tipc_max_tfms;
1637         sysctl_tipc_max_tfms = TIPC_MAX_TFMS_    1644         sysctl_tipc_max_tfms = TIPC_MAX_TFMS_DEF;
1638         tipc_crypto_do_cmd(rx->net, cmd);        1645         tipc_crypto_do_cmd(rx->net, cmd);
1639 }                                                1646 }
1640                                                  1647 
1641 static inline void tipc_crypto_clone_msg(stru    1648 static inline void tipc_crypto_clone_msg(struct net *net, struct sk_buff *_skb,
1642                                          stru    1649                                          struct tipc_bearer *b,
1643                                          stru    1650                                          struct tipc_media_addr *dst,
1644                                          stru    1651                                          struct tipc_node *__dnode, u8 type)
1645 {                                                1652 {
1646         struct sk_buff *skb;                     1653         struct sk_buff *skb;
1647                                                  1654 
1648         skb = skb_clone(_skb, GFP_ATOMIC);       1655         skb = skb_clone(_skb, GFP_ATOMIC);
1649         if (skb) {                               1656         if (skb) {
1650                 TIPC_SKB_CB(skb)->xmit_type =    1657                 TIPC_SKB_CB(skb)->xmit_type = type;
1651                 tipc_crypto_xmit(net, &skb, b    1658                 tipc_crypto_xmit(net, &skb, b, dst, __dnode);
1652                 if (skb)                         1659                 if (skb)
1653                         b->media->send_msg(ne    1660                         b->media->send_msg(net, skb, b, dst);
1654         }                                        1661         }
1655 }                                                1662 }
1656                                                  1663 
1657 /**                                              1664 /**
1658  * tipc_crypto_xmit - Build & encrypt TIPC me    1665  * tipc_crypto_xmit - Build & encrypt TIPC message for xmit
1659  * @net: struct net                              1666  * @net: struct net
1660  * @skb: input/output message skb pointer        1667  * @skb: input/output message skb pointer
1661  * @b: bearer used for xmit later                1668  * @b: bearer used for xmit later
1662  * @dst: destination media address               1669  * @dst: destination media address
1663  * @__dnode: destination node for reference i    1670  * @__dnode: destination node for reference if any
1664  *                                               1671  *
1665  * First, build an encryption message header     1672  * First, build an encryption message header on the top of the message, then
1666  * encrypt the original TIPC message by using    1673  * encrypt the original TIPC message by using the pending, master or active
1667  * key with this preference order.               1674  * key with this preference order.
1668  * If the encryption is successful, the encry    1675  * If the encryption is successful, the encrypted skb is returned directly or
1669  * via the callback.                             1676  * via the callback.
1670  * Otherwise, the skb is freed!                  1677  * Otherwise, the skb is freed!
1671  *                                               1678  *
1672  * Return:                                       1679  * Return:
1673  * * 0                   : the encryption has    1680  * * 0                   : the encryption has succeeded (or no encryption)
1674  * * -EINPROGRESS/-EBUSY : the encryption is     1681  * * -EINPROGRESS/-EBUSY : the encryption is ongoing, a callback will be made
1675  * * -ENOKEK             : the encryption has    1682  * * -ENOKEK             : the encryption has failed due to no key
1676  * * -EKEYREVOKED        : the encryption has    1683  * * -EKEYREVOKED        : the encryption has failed due to key revoked
1677  * * -ENOMEM             : the encryption has    1684  * * -ENOMEM             : the encryption has failed due to no memory
1678  * * < 0                 : the encryption has    1685  * * < 0                 : the encryption has failed due to other reasons
1679  */                                              1686  */
1680 int tipc_crypto_xmit(struct net *net, struct     1687 int tipc_crypto_xmit(struct net *net, struct sk_buff **skb,
1681                      struct tipc_bearer *b, s    1688                      struct tipc_bearer *b, struct tipc_media_addr *dst,
1682                      struct tipc_node *__dnod    1689                      struct tipc_node *__dnode)
1683 {                                                1690 {
1684         struct tipc_crypto *__rx = tipc_node_    1691         struct tipc_crypto *__rx = tipc_node_crypto_rx(__dnode);
1685         struct tipc_crypto *tx = tipc_net(net    1692         struct tipc_crypto *tx = tipc_net(net)->crypto_tx;
1686         struct tipc_crypto_stats __percpu *st    1693         struct tipc_crypto_stats __percpu *stats = tx->stats;
1687         struct tipc_msg *hdr = buf_msg(*skb);    1694         struct tipc_msg *hdr = buf_msg(*skb);
1688         struct tipc_key key = tx->key;           1695         struct tipc_key key = tx->key;
1689         struct tipc_aead *aead = NULL;           1696         struct tipc_aead *aead = NULL;
1690         u32 user = msg_user(hdr);                1697         u32 user = msg_user(hdr);
1691         u32 type = msg_type(hdr);                1698         u32 type = msg_type(hdr);
1692         int rc = -ENOKEY;                        1699         int rc = -ENOKEY;
1693         u8 tx_key = 0;                           1700         u8 tx_key = 0;
1694                                                  1701 
1695         /* No encryption? */                     1702         /* No encryption? */
1696         if (!tx->working)                        1703         if (!tx->working)
1697                 return 0;                        1704                 return 0;
1698                                                  1705 
1699         /* Pending key if peer has active on     1706         /* Pending key if peer has active on it or probing time */
1700         if (unlikely(key.pending)) {             1707         if (unlikely(key.pending)) {
1701                 tx_key = key.pending;            1708                 tx_key = key.pending;
1702                 if (!tx->key_master && !key.a    1709                 if (!tx->key_master && !key.active)
1703                         goto encrypt;            1710                         goto encrypt;
1704                 if (__rx && atomic_read(&__rx    1711                 if (__rx && atomic_read(&__rx->peer_rx_active) == tx_key)
1705                         goto encrypt;            1712                         goto encrypt;
1706                 if (TIPC_SKB_CB(*skb)->xmit_t    1713                 if (TIPC_SKB_CB(*skb)->xmit_type == SKB_PROBING) {
1707                         pr_debug("%s: probing    1714                         pr_debug("%s: probing for key[%d]\n", tx->name,
1708                                  key.pending)    1715                                  key.pending);
1709                         goto encrypt;            1716                         goto encrypt;
1710                 }                                1717                 }
1711                 if (user == LINK_CONFIG || us    1718                 if (user == LINK_CONFIG || user == LINK_PROTOCOL)
1712                         tipc_crypto_clone_msg    1719                         tipc_crypto_clone_msg(net, *skb, b, dst, __dnode,
1713                                                  1720                                               SKB_PROBING);
1714         }                                        1721         }
1715                                                  1722 
1716         /* Master key if this is a *vital* me    1723         /* Master key if this is a *vital* message or in grace period */
1717         if (tx->key_master) {                    1724         if (tx->key_master) {
1718                 tx_key = KEY_MASTER;             1725                 tx_key = KEY_MASTER;
1719                 if (!key.active)                 1726                 if (!key.active)
1720                         goto encrypt;            1727                         goto encrypt;
1721                 if (TIPC_SKB_CB(*skb)->xmit_t    1728                 if (TIPC_SKB_CB(*skb)->xmit_type == SKB_GRACING) {
1722                         pr_debug("%s: gracing    1729                         pr_debug("%s: gracing for msg (%d %d)\n", tx->name,
1723                                  user, type);    1730                                  user, type);
1724                         goto encrypt;            1731                         goto encrypt;
1725                 }                                1732                 }
1726                 if (user == LINK_CONFIG ||       1733                 if (user == LINK_CONFIG ||
1727                     (user == LINK_PROTOCOL &&    1734                     (user == LINK_PROTOCOL && type == RESET_MSG) ||
1728                     (user == MSG_CRYPTO && ty    1735                     (user == MSG_CRYPTO && type == KEY_DISTR_MSG) ||
1729                     time_before(jiffies, tx->    1736                     time_before(jiffies, tx->timer2 + TIPC_TX_GRACE_PERIOD)) {
1730                         if (__rx && __rx->key    1737                         if (__rx && __rx->key_master &&
1731                             !atomic_read(&__r    1738                             !atomic_read(&__rx->peer_rx_active))
1732                                 goto encrypt;    1739                                 goto encrypt;
1733                         if (!__rx) {             1740                         if (!__rx) {
1734                                 if (likely(!t    1741                                 if (likely(!tx->legacy_user))
1735                                         goto     1742                                         goto encrypt;
1736                                 tipc_crypto_c    1743                                 tipc_crypto_clone_msg(net, *skb, b, dst,
1737                                                  1744                                                       __dnode, SKB_GRACING);
1738                         }                        1745                         }
1739                 }                                1746                 }
1740         }                                        1747         }
1741                                                  1748 
1742         /* Else, use the active key if any */    1749         /* Else, use the active key if any */
1743         if (likely(key.active)) {                1750         if (likely(key.active)) {
1744                 tx_key = key.active;             1751                 tx_key = key.active;
1745                 goto encrypt;                    1752                 goto encrypt;
1746         }                                        1753         }
1747                                                  1754 
1748         goto exit;                               1755         goto exit;
1749                                                  1756 
1750 encrypt:                                         1757 encrypt:
1751         aead = tipc_aead_get(tx->aead[tx_key]    1758         aead = tipc_aead_get(tx->aead[tx_key]);
1752         if (unlikely(!aead))                     1759         if (unlikely(!aead))
1753                 goto exit;                       1760                 goto exit;
1754         rc = tipc_ehdr_build(net, aead, tx_ke    1761         rc = tipc_ehdr_build(net, aead, tx_key, *skb, __rx);
1755         if (likely(rc > 0))                      1762         if (likely(rc > 0))
1756                 rc = tipc_aead_encrypt(aead,     1763                 rc = tipc_aead_encrypt(aead, *skb, b, dst, __dnode);
1757                                                  1764 
1758 exit:                                            1765 exit:
1759         switch (rc) {                            1766         switch (rc) {
1760         case 0:                                  1767         case 0:
1761                 this_cpu_inc(stats->stat[STAT    1768                 this_cpu_inc(stats->stat[STAT_OK]);
1762                 break;                           1769                 break;
1763         case -EINPROGRESS:                       1770         case -EINPROGRESS:
1764         case -EBUSY:                             1771         case -EBUSY:
1765                 this_cpu_inc(stats->stat[STAT    1772                 this_cpu_inc(stats->stat[STAT_ASYNC]);
1766                 *skb = NULL;                     1773                 *skb = NULL;
1767                 return rc;                       1774                 return rc;
1768         default:                                 1775         default:
1769                 this_cpu_inc(stats->stat[STAT    1776                 this_cpu_inc(stats->stat[STAT_NOK]);
1770                 if (rc == -ENOKEY)               1777                 if (rc == -ENOKEY)
1771                         this_cpu_inc(stats->s    1778                         this_cpu_inc(stats->stat[STAT_NOKEYS]);
1772                 else if (rc == -EKEYREVOKED)     1779                 else if (rc == -EKEYREVOKED)
1773                         this_cpu_inc(stats->s    1780                         this_cpu_inc(stats->stat[STAT_BADKEYS]);
1774                 kfree_skb(*skb);                 1781                 kfree_skb(*skb);
1775                 *skb = NULL;                     1782                 *skb = NULL;
1776                 break;                           1783                 break;
1777         }                                        1784         }
1778                                                  1785 
1779         tipc_aead_put(aead);                     1786         tipc_aead_put(aead);
1780         return rc;                               1787         return rc;
1781 }                                                1788 }
1782                                                  1789 
1783 /**                                              1790 /**
1784  * tipc_crypto_rcv - Decrypt an encrypted TIP    1791  * tipc_crypto_rcv - Decrypt an encrypted TIPC message from peer
1785  * @net: struct net                              1792  * @net: struct net
1786  * @rx: RX crypto handle                         1793  * @rx: RX crypto handle
1787  * @skb: input/output message skb pointer        1794  * @skb: input/output message skb pointer
1788  * @b: bearer where the message has been rece    1795  * @b: bearer where the message has been received
1789  *                                               1796  *
1790  * If the decryption is successful, the decry    1797  * If the decryption is successful, the decrypted skb is returned directly or
1791  * as the callback, the encryption header and    1798  * as the callback, the encryption header and auth tag will be trimed out
1792  * before forwarding to tipc_rcv() via the ti    1799  * before forwarding to tipc_rcv() via the tipc_crypto_rcv_complete().
1793  * Otherwise, the skb will be freed!             1800  * Otherwise, the skb will be freed!
1794  * Note: RX key(s) can be re-aligned, or in c    1801  * Note: RX key(s) can be re-aligned, or in case of no key suitable, TX
1795  * cluster key(s) can be taken for decryption    1802  * cluster key(s) can be taken for decryption (- recursive).
1796  *                                               1803  *
1797  * Return:                                       1804  * Return:
1798  * * 0                   : the decryption has    1805  * * 0                   : the decryption has successfully completed
1799  * * -EINPROGRESS/-EBUSY : the decryption is     1806  * * -EINPROGRESS/-EBUSY : the decryption is ongoing, a callback will be made
1800  * * -ENOKEY             : the decryption has    1807  * * -ENOKEY             : the decryption has failed due to no key
1801  * * -EBADMSG            : the decryption has    1808  * * -EBADMSG            : the decryption has failed due to bad message
1802  * * -ENOMEM             : the decryption has    1809  * * -ENOMEM             : the decryption has failed due to no memory
1803  * * < 0                 : the decryption has    1810  * * < 0                 : the decryption has failed due to other reasons
1804  */                                              1811  */
1805 int tipc_crypto_rcv(struct net *net, struct t    1812 int tipc_crypto_rcv(struct net *net, struct tipc_crypto *rx,
1806                     struct sk_buff **skb, str    1813                     struct sk_buff **skb, struct tipc_bearer *b)
1807 {                                                1814 {
1808         struct tipc_crypto *tx = tipc_net(net    1815         struct tipc_crypto *tx = tipc_net(net)->crypto_tx;
1809         struct tipc_crypto_stats __percpu *st    1816         struct tipc_crypto_stats __percpu *stats;
1810         struct tipc_aead *aead = NULL;           1817         struct tipc_aead *aead = NULL;
1811         struct tipc_key key;                     1818         struct tipc_key key;
1812         int rc = -ENOKEY;                        1819         int rc = -ENOKEY;
1813         u8 tx_key, n;                            1820         u8 tx_key, n;
1814                                                  1821 
1815         tx_key = ((struct tipc_ehdr *)(*skb)-    1822         tx_key = ((struct tipc_ehdr *)(*skb)->data)->tx_key;
1816                                                  1823 
1817         /* New peer?                             1824         /* New peer?
1818          * Let's try with TX key (i.e. cluste    1825          * Let's try with TX key (i.e. cluster mode) & verify the skb first!
1819          */                                      1826          */
1820         if (unlikely(!rx || tx_key == KEY_MAS    1827         if (unlikely(!rx || tx_key == KEY_MASTER))
1821                 goto pick_tx;                    1828                 goto pick_tx;
1822                                                  1829 
1823         /* Pick RX key according to TX key if    1830         /* Pick RX key according to TX key if any */
1824         key = rx->key;                           1831         key = rx->key;
1825         if (tx_key == key.active || tx_key ==    1832         if (tx_key == key.active || tx_key == key.pending ||
1826             tx_key == key.passive)               1833             tx_key == key.passive)
1827                 goto decrypt;                    1834                 goto decrypt;
1828                                                  1835 
1829         /* Unknown key, let's try to align RX    1836         /* Unknown key, let's try to align RX key(s) */
1830         if (tipc_crypto_key_try_align(rx, tx_    1837         if (tipc_crypto_key_try_align(rx, tx_key))
1831                 goto decrypt;                    1838                 goto decrypt;
1832                                                  1839 
1833 pick_tx:                                         1840 pick_tx:
1834         /* No key suitable? Try to pick one f    1841         /* No key suitable? Try to pick one from TX... */
1835         aead = tipc_crypto_key_pick_tx(tx, rx    1842         aead = tipc_crypto_key_pick_tx(tx, rx, *skb, tx_key);
1836         if (aead)                                1843         if (aead)
1837                 goto decrypt;                    1844                 goto decrypt;
1838         goto exit;                               1845         goto exit;
1839                                                  1846 
1840 decrypt:                                         1847 decrypt:
1841         rcu_read_lock();                         1848         rcu_read_lock();
1842         if (!aead)                               1849         if (!aead)
1843                 aead = tipc_aead_get(rx->aead    1850                 aead = tipc_aead_get(rx->aead[tx_key]);
1844         rc = tipc_aead_decrypt(net, aead, *sk    1851         rc = tipc_aead_decrypt(net, aead, *skb, b);
1845         rcu_read_unlock();                       1852         rcu_read_unlock();
1846                                                  1853 
1847 exit:                                            1854 exit:
1848         stats = ((rx) ?: tx)->stats;             1855         stats = ((rx) ?: tx)->stats;
1849         switch (rc) {                            1856         switch (rc) {
1850         case 0:                                  1857         case 0:
1851                 this_cpu_inc(stats->stat[STAT    1858                 this_cpu_inc(stats->stat[STAT_OK]);
1852                 break;                           1859                 break;
1853         case -EINPROGRESS:                       1860         case -EINPROGRESS:
1854         case -EBUSY:                             1861         case -EBUSY:
1855                 this_cpu_inc(stats->stat[STAT    1862                 this_cpu_inc(stats->stat[STAT_ASYNC]);
1856                 *skb = NULL;                     1863                 *skb = NULL;
1857                 return rc;                       1864                 return rc;
1858         default:                                 1865         default:
1859                 this_cpu_inc(stats->stat[STAT    1866                 this_cpu_inc(stats->stat[STAT_NOK]);
1860                 if (rc == -ENOKEY) {             1867                 if (rc == -ENOKEY) {
1861                         kfree_skb(*skb);         1868                         kfree_skb(*skb);
1862                         *skb = NULL;             1869                         *skb = NULL;
1863                         if (rx) {                1870                         if (rx) {
1864                                 /* Mark rx->n    1871                                 /* Mark rx->nokey only if we dont have a
1865                                  * pending re    1872                                  * pending received session key, nor a newer
1866                                  * one i.e. i    1873                                  * one i.e. in the next slot.
1867                                  */              1874                                  */
1868                                 n = key_next(    1875                                 n = key_next(tx_key);
1869                                 rx->nokey = !    1876                                 rx->nokey = !(rx->skey ||
1870                                                  1877                                               rcu_access_pointer(rx->aead[n]));
1871                                 pr_debug_rate    1878                                 pr_debug_ratelimited("%s: nokey %d, key %d/%x\n",
1872                                                  1879                                                      rx->name, rx->nokey,
1873                                                  1880                                                      tx_key, rx->key.keys);
1874                                 tipc_node_put    1881                                 tipc_node_put(rx->node);
1875                         }                        1882                         }
1876                         this_cpu_inc(stats->s    1883                         this_cpu_inc(stats->stat[STAT_NOKEYS]);
1877                         return rc;               1884                         return rc;
1878                 } else if (rc == -EBADMSG) {     1885                 } else if (rc == -EBADMSG) {
1879                         this_cpu_inc(stats->s    1886                         this_cpu_inc(stats->stat[STAT_BADMSGS]);
1880                 }                                1887                 }
1881                 break;                           1888                 break;
1882         }                                        1889         }
1883                                                  1890 
1884         tipc_crypto_rcv_complete(net, aead, b    1891         tipc_crypto_rcv_complete(net, aead, b, skb, rc);
1885         return rc;                               1892         return rc;
1886 }                                                1893 }
1887                                                  1894 
1888 static void tipc_crypto_rcv_complete(struct n    1895 static void tipc_crypto_rcv_complete(struct net *net, struct tipc_aead *aead,
1889                                      struct t    1896                                      struct tipc_bearer *b,
1890                                      struct s    1897                                      struct sk_buff **skb, int err)
1891 {                                                1898 {
1892         struct tipc_skb_cb *skb_cb = TIPC_SKB    1899         struct tipc_skb_cb *skb_cb = TIPC_SKB_CB(*skb);
1893         struct tipc_crypto *rx = aead->crypto    1900         struct tipc_crypto *rx = aead->crypto;
1894         struct tipc_aead *tmp = NULL;            1901         struct tipc_aead *tmp = NULL;
1895         struct tipc_ehdr *ehdr;                  1902         struct tipc_ehdr *ehdr;
1896         struct tipc_node *n;                     1903         struct tipc_node *n;
1897                                                  1904 
1898         /* Is this completed by TX? */           1905         /* Is this completed by TX? */
1899         if (unlikely(is_tx(aead->crypto))) {     1906         if (unlikely(is_tx(aead->crypto))) {
1900                 rx = skb_cb->tx_clone_ctx.rx;    1907                 rx = skb_cb->tx_clone_ctx.rx;
1901                 pr_debug("TX->RX(%s): err %d,    1908                 pr_debug("TX->RX(%s): err %d, aead %p, skb->next %p, flags %x\n",
1902                          (rx) ? tipc_node_get    1909                          (rx) ? tipc_node_get_id_str(rx->node) : "-", err, aead,
1903                          (*skb)->next, skb_cb    1910                          (*skb)->next, skb_cb->flags);
1904                 pr_debug("skb_cb [recurs %d,     1911                 pr_debug("skb_cb [recurs %d, last %p], tx->aead [%p %p %p]\n",
1905                          skb_cb->tx_clone_ctx    1912                          skb_cb->tx_clone_ctx.recurs, skb_cb->tx_clone_ctx.last,
1906                          aead->crypto->aead[1    1913                          aead->crypto->aead[1], aead->crypto->aead[2],
1907                          aead->crypto->aead[3    1914                          aead->crypto->aead[3]);
1908                 if (unlikely(err)) {             1915                 if (unlikely(err)) {
1909                         if (err == -EBADMSG &    1916                         if (err == -EBADMSG && (*skb)->next)
1910                                 tipc_rcv(net,    1917                                 tipc_rcv(net, (*skb)->next, b);
1911                         goto free_skb;           1918                         goto free_skb;
1912                 }                                1919                 }
1913                                                  1920 
1914                 if (likely((*skb)->next)) {      1921                 if (likely((*skb)->next)) {
1915                         kfree_skb((*skb)->nex    1922                         kfree_skb((*skb)->next);
1916                         (*skb)->next = NULL;     1923                         (*skb)->next = NULL;
1917                 }                                1924                 }
1918                 ehdr = (struct tipc_ehdr *)(*    1925                 ehdr = (struct tipc_ehdr *)(*skb)->data;
1919                 if (!rx) {                       1926                 if (!rx) {
1920                         WARN_ON(ehdr->user !=    1927                         WARN_ON(ehdr->user != LINK_CONFIG);
1921                         n = tipc_node_create(    1928                         n = tipc_node_create(net, 0, ehdr->id, 0xffffu, 0,
1922                                                  1929                                              true);
1923                         rx = tipc_node_crypto    1930                         rx = tipc_node_crypto_rx(n);
1924                         if (unlikely(!rx))       1931                         if (unlikely(!rx))
1925                                 goto free_skb    1932                                 goto free_skb;
1926                 }                                1933                 }
1927                                                  1934 
1928                 /* Ignore cloning if it was T    1935                 /* Ignore cloning if it was TX master key */
1929                 if (ehdr->tx_key == KEY_MASTE    1936                 if (ehdr->tx_key == KEY_MASTER)
1930                         goto rcv;                1937                         goto rcv;
1931                 if (tipc_aead_clone(&tmp, aea    1938                 if (tipc_aead_clone(&tmp, aead) < 0)
1932                         goto rcv;                1939                         goto rcv;
1933                 WARN_ON(!refcount_inc_not_zer    1940                 WARN_ON(!refcount_inc_not_zero(&tmp->refcnt));
1934                 if (tipc_crypto_key_attach(rx    1941                 if (tipc_crypto_key_attach(rx, tmp, ehdr->tx_key, false) < 0) {
1935                         tipc_aead_free(&tmp->    1942                         tipc_aead_free(&tmp->rcu);
1936                         goto rcv;                1943                         goto rcv;
1937                 }                                1944                 }
1938                 tipc_aead_put(aead);             1945                 tipc_aead_put(aead);
1939                 aead = tmp;                      1946                 aead = tmp;
1940         }                                        1947         }
1941                                                  1948 
1942         if (unlikely(err)) {                     1949         if (unlikely(err)) {
1943                 tipc_aead_users_dec((struct t    1950                 tipc_aead_users_dec((struct tipc_aead __force __rcu *)aead, INT_MIN);
1944                 goto free_skb;                   1951                 goto free_skb;
1945         }                                        1952         }
1946                                                  1953 
1947         /* Set the RX key's user */              1954         /* Set the RX key's user */
1948         tipc_aead_users_set((struct tipc_aead    1955         tipc_aead_users_set((struct tipc_aead __force __rcu *)aead, 1);
1949                                                  1956 
1950         /* Mark this point, RX works */          1957         /* Mark this point, RX works */
1951         rx->timer1 = jiffies;                    1958         rx->timer1 = jiffies;
1952                                                  1959 
1953 rcv:                                             1960 rcv:
1954         /* Remove ehdr & auth. tag prior to t    1961         /* Remove ehdr & auth. tag prior to tipc_rcv() */
1955         ehdr = (struct tipc_ehdr *)(*skb)->da    1962         ehdr = (struct tipc_ehdr *)(*skb)->data;
1956                                                  1963 
1957         /* Mark this point, RX passive still     1964         /* Mark this point, RX passive still works */
1958         if (rx->key.passive && ehdr->tx_key =    1965         if (rx->key.passive && ehdr->tx_key == rx->key.passive)
1959                 rx->timer2 = jiffies;            1966                 rx->timer2 = jiffies;
1960                                                  1967 
1961         skb_reset_network_header(*skb);          1968         skb_reset_network_header(*skb);
1962         skb_pull(*skb, tipc_ehdr_size(ehdr));    1969         skb_pull(*skb, tipc_ehdr_size(ehdr));
1963         if (pskb_trim(*skb, (*skb)->len - aea !! 1970         pskb_trim(*skb, (*skb)->len - aead->authsize);
1964                 goto free_skb;                << 
1965                                                  1971 
1966         /* Validate TIPCv2 message */            1972         /* Validate TIPCv2 message */
1967         if (unlikely(!tipc_msg_validate(skb))    1973         if (unlikely(!tipc_msg_validate(skb))) {
1968                 pr_err_ratelimited("Packet dr    1974                 pr_err_ratelimited("Packet dropped after decryption!\n");
1969                 goto free_skb;                   1975                 goto free_skb;
1970         }                                        1976         }
1971                                                  1977 
1972         /* Ok, everything's fine, try to sync    1978         /* Ok, everything's fine, try to synch own keys according to peers' */
1973         tipc_crypto_key_synch(rx, *skb);         1979         tipc_crypto_key_synch(rx, *skb);
1974                                                  1980 
1975         /* Re-fetch skb cb as skb might be ch << 
1976         skb_cb = TIPC_SKB_CB(*skb);           << 
1977                                               << 
1978         /* Mark skb decrypted */                 1981         /* Mark skb decrypted */
1979         skb_cb->decrypted = 1;                   1982         skb_cb->decrypted = 1;
1980                                                  1983 
1981         /* Clear clone cxt if any */             1984         /* Clear clone cxt if any */
1982         if (likely(!skb_cb->tx_clone_deferred    1985         if (likely(!skb_cb->tx_clone_deferred))
1983                 goto exit;                       1986                 goto exit;
1984         skb_cb->tx_clone_deferred = 0;           1987         skb_cb->tx_clone_deferred = 0;
1985         memset(&skb_cb->tx_clone_ctx, 0, size    1988         memset(&skb_cb->tx_clone_ctx, 0, sizeof(skb_cb->tx_clone_ctx));
1986         goto exit;                               1989         goto exit;
1987                                                  1990 
1988 free_skb:                                        1991 free_skb:
1989         kfree_skb(*skb);                         1992         kfree_skb(*skb);
1990         *skb = NULL;                             1993         *skb = NULL;
1991                                                  1994 
1992 exit:                                            1995 exit:
1993         tipc_aead_put(aead);                     1996         tipc_aead_put(aead);
1994         if (rx)                                  1997         if (rx)
1995                 tipc_node_put(rx->node);         1998                 tipc_node_put(rx->node);
1996 }                                                1999 }
1997                                                  2000 
1998 static void tipc_crypto_do_cmd(struct net *ne    2001 static void tipc_crypto_do_cmd(struct net *net, int cmd)
1999 {                                                2002 {
2000         struct tipc_net *tn = tipc_net(net);     2003         struct tipc_net *tn = tipc_net(net);
2001         struct tipc_crypto *tx = tn->crypto_t    2004         struct tipc_crypto *tx = tn->crypto_tx, *rx;
2002         struct list_head *p;                     2005         struct list_head *p;
2003         unsigned int stat;                       2006         unsigned int stat;
2004         int i, j, cpu;                           2007         int i, j, cpu;
2005         char buf[200];                           2008         char buf[200];
2006                                                  2009 
2007         /* Currently only one command is supp    2010         /* Currently only one command is supported */
2008         switch (cmd) {                           2011         switch (cmd) {
2009         case 0xfff1:                             2012         case 0xfff1:
2010                 goto print_stats;                2013                 goto print_stats;
2011         default:                                 2014         default:
2012                 return;                          2015                 return;
2013         }                                        2016         }
2014                                                  2017 
2015 print_stats:                                     2018 print_stats:
2016         /* Print a header */                     2019         /* Print a header */
2017         pr_info("\n=============== TIPC Crypt    2020         pr_info("\n=============== TIPC Crypto Statistics ===============\n\n");
2018                                                  2021 
2019         /* Print key status */                   2022         /* Print key status */
2020         pr_info("Key status:\n");                2023         pr_info("Key status:\n");
2021         pr_info("TX(%7.7s)\n%s", tipc_own_id_    2024         pr_info("TX(%7.7s)\n%s", tipc_own_id_string(net),
2022                 tipc_crypto_key_dump(tx, buf)    2025                 tipc_crypto_key_dump(tx, buf));
2023                                                  2026 
2024         rcu_read_lock();                         2027         rcu_read_lock();
2025         for (p = tn->node_list.next; p != &tn    2028         for (p = tn->node_list.next; p != &tn->node_list; p = p->next) {
2026                 rx = tipc_node_crypto_rx_by_l    2029                 rx = tipc_node_crypto_rx_by_list(p);
2027                 pr_info("RX(%7.7s)\n%s", tipc    2030                 pr_info("RX(%7.7s)\n%s", tipc_node_get_id_str(rx->node),
2028                         tipc_crypto_key_dump(    2031                         tipc_crypto_key_dump(rx, buf));
2029         }                                        2032         }
2030         rcu_read_unlock();                       2033         rcu_read_unlock();
2031                                                  2034 
2032         /* Print crypto statistics */            2035         /* Print crypto statistics */
2033         for (i = 0, j = 0; i < MAX_STATS; i++    2036         for (i = 0, j = 0; i < MAX_STATS; i++)
2034                 j += scnprintf(buf + j, 200 -    2037                 j += scnprintf(buf + j, 200 - j, "|%11s ", hstats[i]);
2035         pr_info("Counter     %s", buf);          2038         pr_info("Counter     %s", buf);
2036                                                  2039 
2037         memset(buf, '-', 115);                   2040         memset(buf, '-', 115);
2038         buf[115] = '\0';                         2041         buf[115] = '\0';
2039         pr_info("%s\n", buf);                    2042         pr_info("%s\n", buf);
2040                                                  2043 
2041         j = scnprintf(buf, 200, "TX(%7.7s) ",    2044         j = scnprintf(buf, 200, "TX(%7.7s) ", tipc_own_id_string(net));
2042         for_each_possible_cpu(cpu) {             2045         for_each_possible_cpu(cpu) {
2043                 for (i = 0; i < MAX_STATS; i+    2046                 for (i = 0; i < MAX_STATS; i++) {
2044                         stat = per_cpu_ptr(tx    2047                         stat = per_cpu_ptr(tx->stats, cpu)->stat[i];
2045                         j += scnprintf(buf +     2048                         j += scnprintf(buf + j, 200 - j, "|%11d ", stat);
2046                 }                                2049                 }
2047                 pr_info("%s", buf);              2050                 pr_info("%s", buf);
2048                 j = scnprintf(buf, 200, "%12s    2051                 j = scnprintf(buf, 200, "%12s", " ");
2049         }                                        2052         }
2050                                                  2053 
2051         rcu_read_lock();                         2054         rcu_read_lock();
2052         for (p = tn->node_list.next; p != &tn    2055         for (p = tn->node_list.next; p != &tn->node_list; p = p->next) {
2053                 rx = tipc_node_crypto_rx_by_l    2056                 rx = tipc_node_crypto_rx_by_list(p);
2054                 j = scnprintf(buf, 200, "RX(%    2057                 j = scnprintf(buf, 200, "RX(%7.7s) ",
2055                               tipc_node_get_i    2058                               tipc_node_get_id_str(rx->node));
2056                 for_each_possible_cpu(cpu) {     2059                 for_each_possible_cpu(cpu) {
2057                         for (i = 0; i < MAX_S    2060                         for (i = 0; i < MAX_STATS; i++) {
2058                                 stat = per_cp    2061                                 stat = per_cpu_ptr(rx->stats, cpu)->stat[i];
2059                                 j += scnprint    2062                                 j += scnprintf(buf + j, 200 - j, "|%11d ",
2060                                                  2063                                                stat);
2061                         }                        2064                         }
2062                         pr_info("%s", buf);      2065                         pr_info("%s", buf);
2063                         j = scnprintf(buf, 20    2066                         j = scnprintf(buf, 200, "%12s", " ");
2064                 }                                2067                 }
2065         }                                        2068         }
2066         rcu_read_unlock();                       2069         rcu_read_unlock();
2067                                                  2070 
2068         pr_info("\n======================== D    2071         pr_info("\n======================== Done ========================\n");
2069 }                                                2072 }
2070                                                  2073 
2071 static char *tipc_crypto_key_dump(struct tipc    2074 static char *tipc_crypto_key_dump(struct tipc_crypto *c, char *buf)
2072 {                                                2075 {
2073         struct tipc_key key = c->key;            2076         struct tipc_key key = c->key;
2074         struct tipc_aead *aead;                  2077         struct tipc_aead *aead;
2075         int k, i = 0;                            2078         int k, i = 0;
2076         char *s;                                 2079         char *s;
2077                                                  2080 
2078         for (k = KEY_MIN; k <= KEY_MAX; k++)     2081         for (k = KEY_MIN; k <= KEY_MAX; k++) {
2079                 if (k == KEY_MASTER) {           2082                 if (k == KEY_MASTER) {
2080                         if (is_rx(c))            2083                         if (is_rx(c))
2081                                 continue;        2084                                 continue;
2082                         if (time_before(jiffi    2085                         if (time_before(jiffies,
2083                                         c->ti    2086                                         c->timer2 + TIPC_TX_GRACE_PERIOD))
2084                                 s = "ACT";       2087                                 s = "ACT";
2085                         else                     2088                         else
2086                                 s = "PAS";       2089                                 s = "PAS";
2087                 } else {                         2090                 } else {
2088                         if (k == key.passive)    2091                         if (k == key.passive)
2089                                 s = "PAS";       2092                                 s = "PAS";
2090                         else if (k == key.act    2093                         else if (k == key.active)
2091                                 s = "ACT";       2094                                 s = "ACT";
2092                         else if (k == key.pen    2095                         else if (k == key.pending)
2093                                 s = "PEN";       2096                                 s = "PEN";
2094                         else                     2097                         else
2095                                 s = "-";         2098                                 s = "-";
2096                 }                                2099                 }
2097                 i += scnprintf(buf + i, 200 -    2100                 i += scnprintf(buf + i, 200 - i, "\tKey%d: %s", k, s);
2098                                                  2101 
2099                 rcu_read_lock();                 2102                 rcu_read_lock();
2100                 aead = rcu_dereference(c->aea    2103                 aead = rcu_dereference(c->aead[k]);
2101                 if (aead)                        2104                 if (aead)
2102                         i += scnprintf(buf +     2105                         i += scnprintf(buf + i, 200 - i,
2103                                        "{\"0x    2106                                        "{\"0x...%s\", \"%s\"}/%d:%d",
2104                                        aead->    2107                                        aead->hint,
2105                                        (aead-    2108                                        (aead->mode == CLUSTER_KEY) ? "c" : "p",
2106                                        atomic    2109                                        atomic_read(&aead->users),
2107                                        refcou    2110                                        refcount_read(&aead->refcnt));
2108                 rcu_read_unlock();               2111                 rcu_read_unlock();
2109                 i += scnprintf(buf + i, 200 -    2112                 i += scnprintf(buf + i, 200 - i, "\n");
2110         }                                        2113         }
2111                                                  2114 
2112         if (is_rx(c))                            2115         if (is_rx(c))
2113                 i += scnprintf(buf + i, 200 -    2116                 i += scnprintf(buf + i, 200 - i, "\tPeer RX active: %d\n",
2114                                atomic_read(&c    2117                                atomic_read(&c->peer_rx_active));
2115                                                  2118 
2116         return buf;                              2119         return buf;
2117 }                                                2120 }
2118                                                  2121 
2119 static char *tipc_key_change_dump(struct tipc    2122 static char *tipc_key_change_dump(struct tipc_key old, struct tipc_key new,
2120                                   char *buf)     2123                                   char *buf)
2121 {                                                2124 {
2122         struct tipc_key *key = &old;             2125         struct tipc_key *key = &old;
2123         int k, i = 0;                            2126         int k, i = 0;
2124         char *s;                                 2127         char *s;
2125                                                  2128 
2126         /* Output format: "[%s %s %s] -> [%s     2129         /* Output format: "[%s %s %s] -> [%s %s %s]", max len = 32 */
2127 again:                                           2130 again:
2128         i += scnprintf(buf + i, 32 - i, "[");    2131         i += scnprintf(buf + i, 32 - i, "[");
2129         for (k = KEY_1; k <= KEY_3; k++) {       2132         for (k = KEY_1; k <= KEY_3; k++) {
2130                 if (k == key->passive)           2133                 if (k == key->passive)
2131                         s = "pas";               2134                         s = "pas";
2132                 else if (k == key->active)       2135                 else if (k == key->active)
2133                         s = "act";               2136                         s = "act";
2134                 else if (k == key->pending)      2137                 else if (k == key->pending)
2135                         s = "pen";               2138                         s = "pen";
2136                 else                             2139                 else
2137                         s = "-";                 2140                         s = "-";
2138                 i += scnprintf(buf + i, 32 -     2141                 i += scnprintf(buf + i, 32 - i,
2139                                (k != KEY_3) ?    2142                                (k != KEY_3) ? "%s " : "%s", s);
2140         }                                        2143         }
2141         if (key != &new) {                       2144         if (key != &new) {
2142                 i += scnprintf(buf + i, 32 -     2145                 i += scnprintf(buf + i, 32 - i, "] -> ");
2143                 key = &new;                      2146                 key = &new;
2144                 goto again;                      2147                 goto again;
2145         }                                        2148         }
2146         i += scnprintf(buf + i, 32 - i, "]");    2149         i += scnprintf(buf + i, 32 - i, "]");
2147         return buf;                              2150         return buf;
2148 }                                                2151 }
2149                                                  2152 
2150 /**                                              2153 /**
2151  * tipc_crypto_msg_rcv - Common 'MSG_CRYPTO'     2154  * tipc_crypto_msg_rcv - Common 'MSG_CRYPTO' processing point
2152  * @net: the struct net                          2155  * @net: the struct net
2153  * @skb: the receiving message buffer            2156  * @skb: the receiving message buffer
2154  */                                              2157  */
2155 void tipc_crypto_msg_rcv(struct net *net, str    2158 void tipc_crypto_msg_rcv(struct net *net, struct sk_buff *skb)
2156 {                                                2159 {
2157         struct tipc_crypto *rx;                  2160         struct tipc_crypto *rx;
2158         struct tipc_msg *hdr;                    2161         struct tipc_msg *hdr;
2159                                                  2162 
2160         if (unlikely(skb_linearize(skb)))        2163         if (unlikely(skb_linearize(skb)))
2161                 goto exit;                       2164                 goto exit;
2162                                                  2165 
2163         hdr = buf_msg(skb);                      2166         hdr = buf_msg(skb);
2164         rx = tipc_node_crypto_rx_by_addr(net,    2167         rx = tipc_node_crypto_rx_by_addr(net, msg_prevnode(hdr));
2165         if (unlikely(!rx))                       2168         if (unlikely(!rx))
2166                 goto exit;                       2169                 goto exit;
2167                                                  2170 
2168         switch (msg_type(hdr)) {                 2171         switch (msg_type(hdr)) {
2169         case KEY_DISTR_MSG:                      2172         case KEY_DISTR_MSG:
2170                 if (tipc_crypto_key_rcv(rx, h    2173                 if (tipc_crypto_key_rcv(rx, hdr))
2171                         goto exit;               2174                         goto exit;
2172                 break;                           2175                 break;
2173         default:                                 2176         default:
2174                 break;                           2177                 break;
2175         }                                        2178         }
2176                                                  2179 
2177         tipc_node_put(rx->node);                 2180         tipc_node_put(rx->node);
2178                                                  2181 
2179 exit:                                            2182 exit:
2180         kfree_skb(skb);                          2183         kfree_skb(skb);
2181 }                                                2184 }
2182                                                  2185 
2183 /**                                              2186 /**
2184  * tipc_crypto_key_distr - Distribute a TX ke    2187  * tipc_crypto_key_distr - Distribute a TX key
2185  * @tx: the TX crypto                            2188  * @tx: the TX crypto
2186  * @key: the key's index                         2189  * @key: the key's index
2187  * @dest: the destination tipc node, = NULL i    2190  * @dest: the destination tipc node, = NULL if distributing to all nodes
2188  *                                               2191  *
2189  * Return: 0 in case of success, otherwise <     2192  * Return: 0 in case of success, otherwise < 0
2190  */                                              2193  */
2191 int tipc_crypto_key_distr(struct tipc_crypto     2194 int tipc_crypto_key_distr(struct tipc_crypto *tx, u8 key,
2192                           struct tipc_node *d    2195                           struct tipc_node *dest)
2193 {                                                2196 {
2194         struct tipc_aead *aead;                  2197         struct tipc_aead *aead;
2195         u32 dnode = tipc_node_get_addr(dest);    2198         u32 dnode = tipc_node_get_addr(dest);
2196         int rc = -ENOKEY;                        2199         int rc = -ENOKEY;
2197                                                  2200 
2198         if (!sysctl_tipc_key_exchange_enabled    2201         if (!sysctl_tipc_key_exchange_enabled)
2199                 return 0;                        2202                 return 0;
2200                                                  2203 
2201         if (key) {                               2204         if (key) {
2202                 rcu_read_lock();                 2205                 rcu_read_lock();
2203                 aead = tipc_aead_get(tx->aead    2206                 aead = tipc_aead_get(tx->aead[key]);
2204                 if (likely(aead)) {              2207                 if (likely(aead)) {
2205                         rc = tipc_crypto_key_    2208                         rc = tipc_crypto_key_xmit(tx->net, aead->key,
2206                                                  2209                                                   aead->gen, aead->mode,
2207                                                  2210                                                   dnode);
2208                         tipc_aead_put(aead);     2211                         tipc_aead_put(aead);
2209                 }                                2212                 }
2210                 rcu_read_unlock();               2213                 rcu_read_unlock();
2211         }                                        2214         }
2212                                                  2215 
2213         return rc;                               2216         return rc;
2214 }                                                2217 }
2215                                                  2218 
2216 /**                                              2219 /**
2217  * tipc_crypto_key_xmit - Send a session key     2220  * tipc_crypto_key_xmit - Send a session key
2218  * @net: the struct net                          2221  * @net: the struct net
2219  * @skey: the session key to be sent             2222  * @skey: the session key to be sent
2220  * @gen: the key's generation                    2223  * @gen: the key's generation
2221  * @mode: the key's mode                         2224  * @mode: the key's mode
2222  * @dnode: the destination node address, = 0     2225  * @dnode: the destination node address, = 0 if broadcasting to all nodes
2223  *                                               2226  *
2224  * The session key 'skey' is packed in a TIPC    2227  * The session key 'skey' is packed in a TIPC v2 'MSG_CRYPTO/KEY_DISTR_MSG'
2225  * as its data section, then xmit-ed through     2228  * as its data section, then xmit-ed through the uc/bc link.
2226  *                                               2229  *
2227  * Return: 0 in case of success, otherwise <     2230  * Return: 0 in case of success, otherwise < 0
2228  */                                              2231  */
2229 static int tipc_crypto_key_xmit(struct net *n    2232 static int tipc_crypto_key_xmit(struct net *net, struct tipc_aead_key *skey,
2230                                 u16 gen, u8 m    2233                                 u16 gen, u8 mode, u32 dnode)
2231 {                                                2234 {
2232         struct sk_buff_head pkts;                2235         struct sk_buff_head pkts;
2233         struct tipc_msg *hdr;                    2236         struct tipc_msg *hdr;
2234         struct sk_buff *skb;                     2237         struct sk_buff *skb;
2235         u16 size, cong_link_cnt;                 2238         u16 size, cong_link_cnt;
2236         u8 *data;                                2239         u8 *data;
2237         int rc;                                  2240         int rc;
2238                                                  2241 
2239         size = tipc_aead_key_size(skey);         2242         size = tipc_aead_key_size(skey);
2240         skb = tipc_buf_acquire(INT_H_SIZE + s    2243         skb = tipc_buf_acquire(INT_H_SIZE + size, GFP_ATOMIC);
2241         if (!skb)                                2244         if (!skb)
2242                 return -ENOMEM;                  2245                 return -ENOMEM;
2243                                                  2246 
2244         hdr = buf_msg(skb);                      2247         hdr = buf_msg(skb);
2245         tipc_msg_init(tipc_own_addr(net), hdr    2248         tipc_msg_init(tipc_own_addr(net), hdr, MSG_CRYPTO, KEY_DISTR_MSG,
2246                       INT_H_SIZE, dnode);        2249                       INT_H_SIZE, dnode);
2247         msg_set_size(hdr, INT_H_SIZE + size);    2250         msg_set_size(hdr, INT_H_SIZE + size);
2248         msg_set_key_gen(hdr, gen);               2251         msg_set_key_gen(hdr, gen);
2249         msg_set_key_mode(hdr, mode);             2252         msg_set_key_mode(hdr, mode);
2250                                                  2253 
2251         data = msg_data(hdr);                    2254         data = msg_data(hdr);
2252         *((__be32 *)(data + TIPC_AEAD_ALG_NAM    2255         *((__be32 *)(data + TIPC_AEAD_ALG_NAME)) = htonl(skey->keylen);
2253         memcpy(data, skey->alg_name, TIPC_AEA    2256         memcpy(data, skey->alg_name, TIPC_AEAD_ALG_NAME);
2254         memcpy(data + TIPC_AEAD_ALG_NAME + si    2257         memcpy(data + TIPC_AEAD_ALG_NAME + sizeof(__be32), skey->key,
2255                skey->keylen);                    2258                skey->keylen);
2256                                                  2259 
2257         __skb_queue_head_init(&pkts);            2260         __skb_queue_head_init(&pkts);
2258         __skb_queue_tail(&pkts, skb);            2261         __skb_queue_tail(&pkts, skb);
2259         if (dnode)                               2262         if (dnode)
2260                 rc = tipc_node_xmit(net, &pkt    2263                 rc = tipc_node_xmit(net, &pkts, dnode, 0);
2261         else                                     2264         else
2262                 rc = tipc_bcast_xmit(net, &pk    2265                 rc = tipc_bcast_xmit(net, &pkts, &cong_link_cnt);
2263                                                  2266 
2264         return rc;                               2267         return rc;
2265 }                                                2268 }
2266                                                  2269 
2267 /**                                              2270 /**
2268  * tipc_crypto_key_rcv - Receive a session ke    2271  * tipc_crypto_key_rcv - Receive a session key
2269  * @rx: the RX crypto                            2272  * @rx: the RX crypto
2270  * @hdr: the TIPC v2 message incl. the receiv    2273  * @hdr: the TIPC v2 message incl. the receiving session key in its data
2271  *                                               2274  *
2272  * This function retrieves the session key in    2275  * This function retrieves the session key in the message from peer, then
2273  * schedules a RX work to attach the key to t    2276  * schedules a RX work to attach the key to the corresponding RX crypto.
2274  *                                               2277  *
2275  * Return: "true" if the key has been schedul    2278  * Return: "true" if the key has been scheduled for attaching, otherwise
2276  * "false".                                      2279  * "false".
2277  */                                              2280  */
2278 static bool tipc_crypto_key_rcv(struct tipc_c    2281 static bool tipc_crypto_key_rcv(struct tipc_crypto *rx, struct tipc_msg *hdr)
2279 {                                                2282 {
2280         struct tipc_crypto *tx = tipc_net(rx-    2283         struct tipc_crypto *tx = tipc_net(rx->net)->crypto_tx;
2281         struct tipc_aead_key *skey = NULL;       2284         struct tipc_aead_key *skey = NULL;
2282         u16 key_gen = msg_key_gen(hdr);          2285         u16 key_gen = msg_key_gen(hdr);
2283         u32 size = msg_data_sz(hdr);          !! 2286         u16 size = msg_data_sz(hdr);
2284         u8 *data = msg_data(hdr);                2287         u8 *data = msg_data(hdr);
2285         unsigned int keylen;                  << 
2286                                               << 
2287         /* Verify whether the size can exist  << 
2288         if (unlikely(size < sizeof(struct tip << 
2289                 pr_debug("%s: message data si << 
2290                 goto exit;                    << 
2291         }                                     << 
2292                                               << 
2293         keylen = ntohl(*((__be32 *)(data + TI << 
2294                                               << 
2295         /* Verify the supplied size values */ << 
2296         if (unlikely(size != keylen + sizeof( << 
2297                      keylen > TIPC_AEAD_KEY_S << 
2298                 pr_debug("%s: invalid MSG_CRY << 
2299                 goto exit;                    << 
2300         }                                     << 
2301                                                  2288 
2302         spin_lock(&rx->lock);                    2289         spin_lock(&rx->lock);
2303         if (unlikely(rx->skey || (key_gen ==     2290         if (unlikely(rx->skey || (key_gen == rx->key_gen && rx->key.keys))) {
2304                 pr_err("%s: key existed <%p>,    2291                 pr_err("%s: key existed <%p>, gen %d vs %d\n", rx->name,
2305                        rx->skey, key_gen, rx-    2292                        rx->skey, key_gen, rx->key_gen);
2306                 goto exit_unlock;             !! 2293                 goto exit;
2307         }                                        2294         }
2308                                                  2295 
2309         /* Allocate memory for the key */        2296         /* Allocate memory for the key */
2310         skey = kmalloc(size, GFP_ATOMIC);        2297         skey = kmalloc(size, GFP_ATOMIC);
2311         if (unlikely(!skey)) {                   2298         if (unlikely(!skey)) {
2312                 pr_err("%s: unable to allocat    2299                 pr_err("%s: unable to allocate memory for skey\n", rx->name);
2313                 goto exit_unlock;             !! 2300                 goto exit;
2314         }                                        2301         }
2315                                                  2302 
2316         /* Copy key from msg data */             2303         /* Copy key from msg data */
2317         skey->keylen = keylen;                !! 2304         skey->keylen = ntohl(*((__be32 *)(data + TIPC_AEAD_ALG_NAME)));
2318         memcpy(skey->alg_name, data, TIPC_AEA    2305         memcpy(skey->alg_name, data, TIPC_AEAD_ALG_NAME);
2319         memcpy(skey->key, data + TIPC_AEAD_AL    2306         memcpy(skey->key, data + TIPC_AEAD_ALG_NAME + sizeof(__be32),
2320                skey->keylen);                    2307                skey->keylen);
2321                                                  2308 
                                                   >> 2309         /* Sanity check */
                                                   >> 2310         if (unlikely(size != tipc_aead_key_size(skey))) {
                                                   >> 2311                 kfree(skey);
                                                   >> 2312                 skey = NULL;
                                                   >> 2313                 goto exit;
                                                   >> 2314         }
                                                   >> 2315 
2322         rx->key_gen = key_gen;                   2316         rx->key_gen = key_gen;
2323         rx->skey_mode = msg_key_mode(hdr);       2317         rx->skey_mode = msg_key_mode(hdr);
2324         rx->skey = skey;                         2318         rx->skey = skey;
2325         rx->nokey = 0;                           2319         rx->nokey = 0;
2326         mb(); /* for nokey flag */               2320         mb(); /* for nokey flag */
2327                                                  2321 
2328 exit_unlock:                                  !! 2322 exit:
2329         spin_unlock(&rx->lock);                  2323         spin_unlock(&rx->lock);
2330                                                  2324 
2331 exit:                                         << 
2332         /* Schedule the key attaching on this    2325         /* Schedule the key attaching on this crypto */
2333         if (likely(skey && queue_delayed_work    2326         if (likely(skey && queue_delayed_work(tx->wq, &rx->work, 0)))
2334                 return true;                     2327                 return true;
2335                                                  2328 
2336         return false;                            2329         return false;
2337 }                                                2330 }
2338                                                  2331 
2339 /**                                              2332 /**
2340  * tipc_crypto_work_rx - Scheduled RX works h    2333  * tipc_crypto_work_rx - Scheduled RX works handler
2341  * @work: the struct RX work                     2334  * @work: the struct RX work
2342  *                                               2335  *
2343  * The function processes the previous schedu    2336  * The function processes the previous scheduled works i.e. distributing TX key
2344  * or attaching a received session key on RX     2337  * or attaching a received session key on RX crypto.
2345  */                                              2338  */
2346 static void tipc_crypto_work_rx(struct work_s    2339 static void tipc_crypto_work_rx(struct work_struct *work)
2347 {                                                2340 {
2348         struct delayed_work *dwork = to_delay    2341         struct delayed_work *dwork = to_delayed_work(work);
2349         struct tipc_crypto *rx = container_of    2342         struct tipc_crypto *rx = container_of(dwork, struct tipc_crypto, work);
2350         struct tipc_crypto *tx = tipc_net(rx-    2343         struct tipc_crypto *tx = tipc_net(rx->net)->crypto_tx;
2351         unsigned long delay = msecs_to_jiffie    2344         unsigned long delay = msecs_to_jiffies(5000);
2352         bool resched = false;                    2345         bool resched = false;
2353         u8 key;                                  2346         u8 key;
2354         int rc;                                  2347         int rc;
2355                                                  2348 
2356         /* Case 1: Distribute TX key to peer     2349         /* Case 1: Distribute TX key to peer if scheduled */
2357         if (atomic_cmpxchg(&rx->key_distr,       2350         if (atomic_cmpxchg(&rx->key_distr,
2358                            KEY_DISTR_SCHED,      2351                            KEY_DISTR_SCHED,
2359                            KEY_DISTR_COMPL) =    2352                            KEY_DISTR_COMPL) == KEY_DISTR_SCHED) {
2360                 /* Always pick the newest one    2353                 /* Always pick the newest one for distributing */
2361                 key = tx->key.pending ?: tx->    2354                 key = tx->key.pending ?: tx->key.active;
2362                 rc = tipc_crypto_key_distr(tx    2355                 rc = tipc_crypto_key_distr(tx, key, rx->node);
2363                 if (unlikely(rc))                2356                 if (unlikely(rc))
2364                         pr_warn("%s: unable t    2357                         pr_warn("%s: unable to distr key[%d] to %s, err %d\n",
2365                                 tx->name, key    2358                                 tx->name, key, tipc_node_get_id_str(rx->node),
2366                                 rc);             2359                                 rc);
2367                                                  2360 
2368                 /* Sched for key_distr releas    2361                 /* Sched for key_distr releasing */
2369                 resched = true;                  2362                 resched = true;
2370         } else {                                 2363         } else {
2371                 atomic_cmpxchg(&rx->key_distr    2364                 atomic_cmpxchg(&rx->key_distr, KEY_DISTR_COMPL, 0);
2372         }                                        2365         }
2373                                                  2366 
2374         /* Case 2: Attach a pending received     2367         /* Case 2: Attach a pending received session key from peer if any */
2375         if (rx->skey) {                          2368         if (rx->skey) {
2376                 rc = tipc_crypto_key_init(rx,    2369                 rc = tipc_crypto_key_init(rx, rx->skey, rx->skey_mode, false);
2377                 if (unlikely(rc < 0))            2370                 if (unlikely(rc < 0))
2378                         pr_warn("%s: unable t    2371                         pr_warn("%s: unable to attach received skey, err %d\n",
2379                                 rx->name, rc)    2372                                 rx->name, rc);
2380                 switch (rc) {                    2373                 switch (rc) {
2381                 case -EBUSY:                     2374                 case -EBUSY:
2382                 case -ENOMEM:                    2375                 case -ENOMEM:
2383                         /* Resched the key at    2376                         /* Resched the key attaching */
2384                         resched = true;          2377                         resched = true;
2385                         break;                   2378                         break;
2386                 default:                         2379                 default:
2387                         synchronize_rcu();       2380                         synchronize_rcu();
2388                         kfree(rx->skey);         2381                         kfree(rx->skey);
2389                         rx->skey = NULL;         2382                         rx->skey = NULL;
2390                         break;                   2383                         break;
2391                 }                                2384                 }
2392         }                                        2385         }
2393                                                  2386 
2394         if (resched && queue_delayed_work(tx-    2387         if (resched && queue_delayed_work(tx->wq, &rx->work, delay))
2395                 return;                          2388                 return;
2396                                                  2389 
2397         tipc_node_put(rx->node);                 2390         tipc_node_put(rx->node);
2398 }                                                2391 }
2399                                                  2392 
2400 /**                                              2393 /**
2401  * tipc_crypto_rekeying_sched - (Re)schedule     2394  * tipc_crypto_rekeying_sched - (Re)schedule rekeying w/o new interval
2402  * @tx: TX crypto                                2395  * @tx: TX crypto
2403  * @changed: if the rekeying needs to be resc    2396  * @changed: if the rekeying needs to be rescheduled with new interval
2404  * @new_intv: new rekeying interval (when "ch    2397  * @new_intv: new rekeying interval (when "changed" = true)
2405  */                                              2398  */
2406 void tipc_crypto_rekeying_sched(struct tipc_c    2399 void tipc_crypto_rekeying_sched(struct tipc_crypto *tx, bool changed,
2407                                 u32 new_intv)    2400                                 u32 new_intv)
2408 {                                                2401 {
2409         unsigned long delay;                     2402         unsigned long delay;
2410         bool now = false;                        2403         bool now = false;
2411                                                  2404 
2412         if (changed) {                           2405         if (changed) {
2413                 if (new_intv == TIPC_REKEYING    2406                 if (new_intv == TIPC_REKEYING_NOW)
2414                         now = true;              2407                         now = true;
2415                 else                             2408                 else
2416                         tx->rekeying_intv = n    2409                         tx->rekeying_intv = new_intv;
2417                 cancel_delayed_work_sync(&tx-    2410                 cancel_delayed_work_sync(&tx->work);
2418         }                                        2411         }
2419                                                  2412 
2420         if (tx->rekeying_intv || now) {          2413         if (tx->rekeying_intv || now) {
2421                 delay = (now) ? 0 : tx->rekey    2414                 delay = (now) ? 0 : tx->rekeying_intv * 60 * 1000;
2422                 queue_delayed_work(tx->wq, &t    2415                 queue_delayed_work(tx->wq, &tx->work, msecs_to_jiffies(delay));
2423         }                                        2416         }
2424 }                                                2417 }
2425                                                  2418 
2426 /**                                              2419 /**
2427  * tipc_crypto_work_tx - Scheduled TX works h    2420  * tipc_crypto_work_tx - Scheduled TX works handler
2428  * @work: the struct TX work                     2421  * @work: the struct TX work
2429  *                                               2422  *
2430  * The function processes the previous schedu    2423  * The function processes the previous scheduled work, i.e. key rekeying, by
2431  * generating a new session key based on curr    2424  * generating a new session key based on current one, then attaching it to the
2432  * TX crypto and finally distributing it to p    2425  * TX crypto and finally distributing it to peers. It also re-schedules the
2433  * rekeying if needed.                           2426  * rekeying if needed.
2434  */                                              2427  */
2435 static void tipc_crypto_work_tx(struct work_s    2428 static void tipc_crypto_work_tx(struct work_struct *work)
2436 {                                                2429 {
2437         struct delayed_work *dwork = to_delay    2430         struct delayed_work *dwork = to_delayed_work(work);
2438         struct tipc_crypto *tx = container_of    2431         struct tipc_crypto *tx = container_of(dwork, struct tipc_crypto, work);
2439         struct tipc_aead_key *skey = NULL;       2432         struct tipc_aead_key *skey = NULL;
2440         struct tipc_key key = tx->key;           2433         struct tipc_key key = tx->key;
2441         struct tipc_aead *aead;                  2434         struct tipc_aead *aead;
2442         int rc = -ENOMEM;                        2435         int rc = -ENOMEM;
2443                                                  2436 
2444         if (unlikely(key.pending))               2437         if (unlikely(key.pending))
2445                 goto resched;                    2438                 goto resched;
2446                                                  2439 
2447         /* Take current key as a template */     2440         /* Take current key as a template */
2448         rcu_read_lock();                         2441         rcu_read_lock();
2449         aead = rcu_dereference(tx->aead[key.a    2442         aead = rcu_dereference(tx->aead[key.active ?: KEY_MASTER]);
2450         if (unlikely(!aead)) {                   2443         if (unlikely(!aead)) {
2451                 rcu_read_unlock();               2444                 rcu_read_unlock();
2452                 /* At least one key should ex    2445                 /* At least one key should exist for securing */
2453                 return;                          2446                 return;
2454         }                                        2447         }
2455                                                  2448 
2456         /* Lets duplicate it first */            2449         /* Lets duplicate it first */
2457         skey = kmemdup(aead->key, tipc_aead_k    2450         skey = kmemdup(aead->key, tipc_aead_key_size(aead->key), GFP_ATOMIC);
2458         rcu_read_unlock();                       2451         rcu_read_unlock();
2459                                                  2452 
2460         /* Now, generate new key, initiate &     2453         /* Now, generate new key, initiate & distribute it */
2461         if (likely(skey)) {                      2454         if (likely(skey)) {
2462                 rc = tipc_aead_key_generate(s    2455                 rc = tipc_aead_key_generate(skey) ?:
2463                      tipc_crypto_key_init(tx,    2456                      tipc_crypto_key_init(tx, skey, PER_NODE_KEY, false);
2464                 if (likely(rc > 0))              2457                 if (likely(rc > 0))
2465                         rc = tipc_crypto_key_    2458                         rc = tipc_crypto_key_distr(tx, rc, NULL);
2466                 kfree_sensitive(skey);           2459                 kfree_sensitive(skey);
2467         }                                        2460         }
2468                                                  2461 
2469         if (unlikely(rc))                        2462         if (unlikely(rc))
2470                 pr_warn_ratelimited("%s: reke    2463                 pr_warn_ratelimited("%s: rekeying returns %d\n", tx->name, rc);
2471                                                  2464 
2472 resched:                                         2465 resched:
2473         /* Re-schedule rekeying if any */        2466         /* Re-schedule rekeying if any */
2474         tipc_crypto_rekeying_sched(tx, false,    2467         tipc_crypto_rekeying_sched(tx, false, 0);
2475 }                                                2468 }
2476                                                  2469 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php