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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.