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