]> Git Repo - linux.git/blame - net/tipc/crypto.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'driver-core-5.7-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux.git] / net / tipc / crypto.c
CommitLineData
fc1b6d6d
TL		 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.h"
40
41#define TIPC_TX_PROBE_LIM msecs_to_jiffies(1000) /* > 1s */
42#define TIPC_TX_LASTING_LIM msecs_to_jiffies(120000) /* 2 mins */
43#define TIPC_RX_ACTIVE_LIM msecs_to_jiffies(3000) /* 3s */
44#define TIPC_RX_PASSIVE_LIM msecs_to_jiffies(180000) /* 3 mins */
45#define TIPC_MAX_TFMS_DEF 10
46#define TIPC_MAX_TFMS_LIM 1000
47
48/**
49 * TIPC Key ids
50 */
51enum {
52 KEY_UNUSED = 0,
53 KEY_MIN,
54 KEY_1 = KEY_MIN,
55 KEY_2,
56 KEY_3,
57 KEY_MAX = KEY_3,
58};
59
60/**
61 * TIPC Crypto statistics
62 */
63enum {
64 STAT_OK,
65 STAT_NOK,
66 STAT_ASYNC,
67 STAT_ASYNC_OK,
68 STAT_ASYNC_NOK,
69 STAT_BADKEYS, /* tx only */
70 STAT_BADMSGS = STAT_BADKEYS, /* rx only */
71 STAT_NOKEYS,
72 STAT_SWITCHES,
73
74 MAX_STATS,
75};
76
77/* TIPC crypto statistics' header */
78static const char *hstats[MAX_STATS] = {"ok", "nok", "async", "async_ok",
79 "async_nok", "badmsgs", "nokeys",
80 "switches"};
81
82/* Max TFMs number per key */
83int sysctl_tipc_max_tfms __read_mostly = TIPC_MAX_TFMS_DEF;
84
85/**
86 * struct tipc_key - TIPC keys' status indicator
87 *
88 * 7 6 5 4 3 2 1 0
89 * +-----+-----+-----+-----+-----+-----+-----+-----+
90 * key: | (reserved)|passive idx| active idx|pending idx|
91 * +-----+-----+-----+-----+-----+-----+-----+-----+
92 */
93struct tipc_key {
94#define KEY_BITS (2)
95#define KEY_MASK ((1 << KEY_BITS) - 1)
96 union {
97 struct {
98#if defined(__LITTLE_ENDIAN_BITFIELD)
99 u8 pending:2,
100 active:2,
101 passive:2, /* rx only */
102 reserved:2;
103#elif defined(__BIG_ENDIAN_BITFIELD)
104 u8 reserved:2,
105 passive:2, /* rx only */
106 active:2,
107 pending:2;
108#else
109#error "Please fix <asm/byteorder.h>"
110#endif
111 } __packed;
112 u8 keys;
113 };
114};
115
116/**
117 * struct tipc_tfm - TIPC TFM structure to form a list of TFMs
118 */
119struct tipc_tfm {
120 struct crypto_aead *tfm;
121 struct list_head list;
122};
123
124/**
125 * struct tipc_aead - TIPC AEAD key structure
126 * @tfm_entry: per-cpu pointer to one entry in TFM list
127 * @crypto: TIPC crypto owns this key
128 * @cloned: reference to the source key in case cloning
129 * @users: the number of the key users (TX/RX)
130 * @salt: the key's SALT value
131 * @authsize: authentication tag size (max = 16)
132 * @mode: crypto mode is applied to the key
133 * @hint[]: a hint for user key
134 * @rcu: struct rcu_head
135 * @seqno: the key seqno (cluster scope)
136 * @refcnt: the key reference counter
137 */
138struct tipc_aead {
139#define TIPC_AEAD_HINT_LEN (5)
140 struct tipc_tfm * __percpu *tfm_entry;
141 struct tipc_crypto *crypto;
142 struct tipc_aead *cloned;
143 atomic_t users;
144 u32 salt;
145 u8 authsize;
146 u8 mode;
147 char hint[TIPC_AEAD_HINT_LEN + 1];
148 struct rcu_head rcu;
149
150 atomic64_t seqno ____cacheline_aligned;
151 refcount_t refcnt ____cacheline_aligned;
152
153} ____cacheline_aligned;
154
155/**
156 * struct tipc_crypto_stats - TIPC Crypto statistics
157 */
158struct tipc_crypto_stats {
159 unsigned int stat[MAX_STATS];
160};
161
162/**
163 * struct tipc_crypto - TIPC TX/RX crypto structure
164 * @net: struct net
165 * @node: TIPC node (RX)
166 * @aead: array of pointers to AEAD keys for encryption/decryption
167 * @peer_rx_active: replicated peer RX active key index
168 * @key: the key states
169 * @working: the crypto is working or not
170 * @stats: the crypto statistics
171 * @sndnxt: the per-peer sndnxt (TX)
172 * @timer1: general timer 1 (jiffies)
173 * @timer2: general timer 1 (jiffies)
174 * @lock: tipc_key lock
175 */
176struct tipc_crypto {
177 struct net *net;
178 struct tipc_node *node;
179 struct tipc_aead __rcu *aead[KEY_MAX + 1]; /* key[0] is UNUSED */
180 atomic_t peer_rx_active;
181 struct tipc_key key;
182 u8 working:1;
183 struct tipc_crypto_stats __percpu *stats;
184
185 atomic64_t sndnxt ____cacheline_aligned;
186 unsigned long timer1;
187 unsigned long timer2;
188 spinlock_t lock; /* crypto lock */
189
190} ____cacheline_aligned;
191
192/* struct tipc_crypto_tx_ctx - TX context for callbacks */
193struct tipc_crypto_tx_ctx {
194 struct tipc_aead *aead;
195 struct tipc_bearer *bearer;
196 struct tipc_media_addr dst;
197};
198
199/* struct tipc_crypto_rx_ctx - RX context for callbacks */
200struct tipc_crypto_rx_ctx {
201 struct tipc_aead *aead;
202 struct tipc_bearer *bearer;
203};
204
205static struct tipc_aead *tipc_aead_get(struct tipc_aead __rcu *aead);
206static inline void tipc_aead_put(struct tipc_aead *aead);
207static void tipc_aead_free(struct rcu_head *rp);
208static int tipc_aead_users(struct tipc_aead __rcu *aead);
209static void tipc_aead_users_inc(struct tipc_aead __rcu *aead, int lim);
210static void tipc_aead_users_dec(struct tipc_aead __rcu *aead, int lim);
211static void tipc_aead_users_set(struct tipc_aead __rcu *aead, int val);
212static struct crypto_aead *tipc_aead_tfm_next(struct tipc_aead *aead);
213static int tipc_aead_init(struct tipc_aead **aead, struct tipc_aead_key *ukey,
214 u8 mode);
215static int tipc_aead_clone(struct tipc_aead **dst, struct tipc_aead *src);
216static void *tipc_aead_mem_alloc(struct crypto_aead *tfm,
217 unsigned int crypto_ctx_size,
218 u8 **iv, struct aead_request **req,
219 struct scatterlist **sg, int nsg);
220static int tipc_aead_encrypt(struct tipc_aead *aead, struct sk_buff *skb,
221 struct tipc_bearer *b,
222 struct tipc_media_addr *dst,
223 struct tipc_node *__dnode);
224static void tipc_aead_encrypt_done(struct crypto_async_request *base, int err);
225static int tipc_aead_decrypt(struct net *net, struct tipc_aead *aead,
226 struct sk_buff *skb, struct tipc_bearer *b);
227static void tipc_aead_decrypt_done(struct crypto_async_request *base, int err);
228static inline int tipc_ehdr_size(struct tipc_ehdr *ehdr);
229static int tipc_ehdr_build(struct net *net, struct tipc_aead *aead,
230 u8 tx_key, struct sk_buff *skb,
231 struct tipc_crypto *__rx);
232static inline void tipc_crypto_key_set_state(struct tipc_crypto *c,
233 u8 new_passive,
234 u8 new_active,
235 u8 new_pending);
236static int tipc_crypto_key_attach(struct tipc_crypto *c,
237 struct tipc_aead *aead, u8 pos);
238static bool tipc_crypto_key_try_align(struct tipc_crypto *rx, u8 new_pending);
239static struct tipc_aead *tipc_crypto_key_pick_tx(struct tipc_crypto *tx,
240 struct tipc_crypto *rx,
241 struct sk_buff *skb);
242static void tipc_crypto_key_synch(struct tipc_crypto *rx, u8 new_rx_active,
243 struct tipc_msg *hdr);
244static int tipc_crypto_key_revoke(struct net *net, u8 tx_key);
245static void tipc_crypto_rcv_complete(struct net *net, struct tipc_aead *aead,
246 struct tipc_bearer *b,
247 struct sk_buff **skb, int err);
248static void tipc_crypto_do_cmd(struct net *net, int cmd);
249static char *tipc_crypto_key_dump(struct tipc_crypto *c, char *buf);
250#ifdef TIPC_CRYPTO_DEBUG
251static char *tipc_key_change_dump(struct tipc_key old, struct tipc_key new,
252 char *buf);
253#endif
254
255#define key_next(cur) ((cur) % KEY_MAX + 1)
256
257#define tipc_aead_rcu_ptr(rcu_ptr, lock) \
258 rcu_dereference_protected((rcu_ptr), lockdep_is_held(lock))
259
fc1b6d6d
TL		 260#define tipc_aead_rcu_replace(rcu_ptr, ptr, lock) \
261do { \
262 typeof(rcu_ptr) __tmp = rcu_dereference_protected((rcu_ptr), \
263 lockdep_is_held(lock)); \
264 rcu_assign_pointer((rcu_ptr), (ptr)); \
265 tipc_aead_put(__tmp); \
266} while (0)
267
268#define tipc_crypto_key_detach(rcu_ptr, lock) \
269 tipc_aead_rcu_replace((rcu_ptr), NULL, lock)
270
271/**
272 * tipc_aead_key_validate - Validate a AEAD user key
273 */
274int tipc_aead_key_validate(struct tipc_aead_key *ukey)
275{
276 int keylen;
277
278 /* Check if algorithm exists */
279 if (unlikely(!crypto_has_alg(ukey->alg_name, 0, 0))) {
280 pr_info("Not found cipher: \"%s\"!\n", ukey->alg_name);
281 return -ENODEV;
282 }
283
284 /* Currently, we only support the "gcm(aes)" cipher algorithm */
285 if (strcmp(ukey->alg_name, "gcm(aes)"))
286 return -ENOTSUPP;
287
288 /* Check if key size is correct */
289 keylen = ukey->keylen - TIPC_AES_GCM_SALT_SIZE;
290 if (unlikely(keylen != TIPC_AES_GCM_KEY_SIZE_128 &&
291 keylen != TIPC_AES_GCM_KEY_SIZE_192 &&
292 keylen != TIPC_AES_GCM_KEY_SIZE_256))
293 return -EINVAL;
294
295 return 0;
296}
297
298static struct tipc_aead *tipc_aead_get(struct tipc_aead __rcu *aead)
299{
300 struct tipc_aead *tmp;
301
302 rcu_read_lock();
303 tmp = rcu_dereference(aead);
304 if (unlikely(!tmp || !refcount_inc_not_zero(&tmp->refcnt)))
305 tmp = NULL;
306 rcu_read_unlock();
307
308 return tmp;
309}
310
311static inline void tipc_aead_put(struct tipc_aead *aead)
312{
313 if (aead && refcount_dec_and_test(&aead->refcnt))
314 call_rcu(&aead->rcu, tipc_aead_free);
315}
316
317/**
318 * tipc_aead_free - Release AEAD key incl. all the TFMs in the list
319 * @rp: rcu head pointer
320 */
321static void tipc_aead_free(struct rcu_head *rp)
322{
323 struct tipc_aead *aead = container_of(rp, struct tipc_aead, rcu);
324 struct tipc_tfm *tfm_entry, *head, *tmp;
325
326 if (aead->cloned) {
327 tipc_aead_put(aead->cloned);
328 } else {
329 head = *this_cpu_ptr(aead->tfm_entry);
330 list_for_each_entry_safe(tfm_entry, tmp, &head->list, list) {
331 crypto_free_aead(tfm_entry->tfm);
332 list_del(&tfm_entry->list);
333 kfree(tfm_entry);
334 }
335 /* Free the head */
336 crypto_free_aead(head->tfm);
337 list_del(&head->list);
338 kfree(head);
339 }
340 free_percpu(aead->tfm_entry);
341 kfree(aead);
342}
343
344static int tipc_aead_users(struct tipc_aead __rcu *aead)
345{
346 struct tipc_aead *tmp;
347 int users = 0;
348
349 rcu_read_lock();
350 tmp = rcu_dereference(aead);
351 if (tmp)
352 users = atomic_read(&tmp->users);
353 rcu_read_unlock();
354
355 return users;
356}
357
358static void tipc_aead_users_inc(struct tipc_aead __rcu *aead, int lim)
359{
360 struct tipc_aead *tmp;
361
362 rcu_read_lock();
363 tmp = rcu_dereference(aead);
364 if (tmp)
365 atomic_add_unless(&tmp->users, 1, lim);
366 rcu_read_unlock();
367}
368
369static void tipc_aead_users_dec(struct tipc_aead __rcu *aead, int lim)
370{
371 struct tipc_aead *tmp;
372
373 rcu_read_lock();
374 tmp = rcu_dereference(aead);
375 if (tmp)
376 atomic_add_unless(&rcu_dereference(aead)->users, -1, lim);
377 rcu_read_unlock();
378}
379
380static void tipc_aead_users_set(struct tipc_aead __rcu *aead, int val)
381{
382 struct tipc_aead *tmp;
383 int cur;
384
385 rcu_read_lock();
386 tmp = rcu_dereference(aead);
387 if (tmp) {
388 do {
389 cur = atomic_read(&tmp->users);
390 if (cur == val)
391 break;
392 } while (atomic_cmpxchg(&tmp->users, cur, val) != cur);
393 }
394 rcu_read_unlock();
395}
396
397/**
398 * tipc_aead_tfm_next - Move TFM entry to the next one in list and return it
399 */
400static struct crypto_aead *tipc_aead_tfm_next(struct tipc_aead *aead)
401{
402 struct tipc_tfm **tfm_entry = this_cpu_ptr(aead->tfm_entry);
403
404 *tfm_entry = list_next_entry(*tfm_entry, list);
405 return (*tfm_entry)->tfm;
406}
407
408/**
409 * tipc_aead_init - Initiate TIPC AEAD
410 * @aead: returned new TIPC AEAD key handle pointer
411 * @ukey: pointer to user key data
412 * @mode: the key mode
413 *
414 * Allocate a (list of) new cipher transformation (TFM) with the specific user
415 * key data if valid. The number of the allocated TFMs can be set via the sysfs
416 * "net/tipc/max_tfms" first.
417 * Also, all the other AEAD data are also initialized.
418 *
419 * Return: 0 if the initiation is successful, otherwise: < 0
420 */
421static int tipc_aead_init(struct tipc_aead **aead, struct tipc_aead_key *ukey,
422 u8 mode)
423{
424 struct tipc_tfm *tfm_entry, *head;
425 struct crypto_aead *tfm;
426 struct tipc_aead *tmp;
427 int keylen, err, cpu;
428 int tfm_cnt = 0;
429
430 if (unlikely(*aead))
431 return -EEXIST;
432
433 /* Allocate a new AEAD */
434 tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC);
435 if (unlikely(!tmp))
436 return -ENOMEM;
437
438 /* The key consists of two parts: [AES-KEY][SALT] */
439 keylen = ukey->keylen - TIPC_AES_GCM_SALT_SIZE;
440
441 /* Allocate per-cpu TFM entry pointer */
442 tmp->tfm_entry = alloc_percpu(struct tipc_tfm *);
443 if (!tmp->tfm_entry) {
444 kzfree(tmp);
445 return -ENOMEM;
446 }
447
448 /* Make a list of TFMs with the user key data */
449 do {
450 tfm = crypto_alloc_aead(ukey->alg_name, 0, 0);
451 if (IS_ERR(tfm)) {
452 err = PTR_ERR(tfm);
453 break;
454 }
455
456 if (unlikely(!tfm_cnt &&
457 crypto_aead_ivsize(tfm) != TIPC_AES_GCM_IV_SIZE)) {
458 crypto_free_aead(tfm);
459 err = -ENOTSUPP;
460 break;
461 }
462
c33fdc34 463 err = crypto_aead_setauthsize(tfm, TIPC_AES_GCM_TAG_SIZE);
fc1b6d6d
TL		 464 err |= crypto_aead_setkey(tfm, ukey->key, keylen);
465 if (unlikely(err)) {
466 crypto_free_aead(tfm);
467 break;
468 }
469
470 tfm_entry = kmalloc(sizeof(*tfm_entry), GFP_KERNEL);
471 if (unlikely(!tfm_entry)) {
472 crypto_free_aead(tfm);
473 err = -ENOMEM;
474 break;
475 }
476 INIT_LIST_HEAD(&tfm_entry->list);
477 tfm_entry->tfm = tfm;
478
479 /* First entry? */
480 if (!tfm_cnt) {
481 head = tfm_entry;
482 for_each_possible_cpu(cpu) {
483 *per_cpu_ptr(tmp->tfm_entry, cpu) = head;
484 }
485 } else {
486 list_add_tail(&tfm_entry->list, &head->list);
487 }
488
489 } while (++tfm_cnt < sysctl_tipc_max_tfms);
490
491 /* Not any TFM is allocated? */
492 if (!tfm_cnt) {
493 free_percpu(tmp->tfm_entry);
494 kzfree(tmp);
495 return err;
496 }
497
498 /* Copy some chars from the user key as a hint */
499 memcpy(tmp->hint, ukey->key, TIPC_AEAD_HINT_LEN);
500 tmp->hint[TIPC_AEAD_HINT_LEN] = '\0';
501
502 /* Initialize the other data */
503 tmp->mode = mode;
504 tmp->cloned = NULL;
505 tmp->authsize = TIPC_AES_GCM_TAG_SIZE;
506 memcpy(&tmp->salt, ukey->key + keylen, TIPC_AES_GCM_SALT_SIZE);
507 atomic_set(&tmp->users, 0);
508 atomic64_set(&tmp->seqno, 0);
509 refcount_set(&tmp->refcnt, 1);
510
511 *aead = tmp;
512 return 0;
513}
514
515/**
516 * tipc_aead_clone - Clone a TIPC AEAD key
517 * @dst: dest key for the cloning
518 * @src: source key to clone from
519 *
520 * Make a "copy" of the source AEAD key data to the dest, the TFMs list is
521 * common for the keys.
522 * A reference to the source is hold in the "cloned" pointer for the later
523 * freeing purposes.
524 *
525 * Note: this must be done in cluster-key mode only!
526 * Return: 0 in case of success, otherwise < 0
527 */
528static int tipc_aead_clone(struct tipc_aead **dst, struct tipc_aead *src)
529{
530 struct tipc_aead *aead;
531 int cpu;
532
533 if (!src)
534 return -ENOKEY;
535
536 if (src->mode != CLUSTER_KEY)
537 return -EINVAL;
538
539 if (unlikely(*dst))
540 return -EEXIST;
541
542 aead = kzalloc(sizeof(*aead), GFP_ATOMIC);
543 if (unlikely(!aead))
544 return -ENOMEM;
545
546 aead->tfm_entry = alloc_percpu_gfp(struct tipc_tfm *, GFP_ATOMIC);
547 if (unlikely(!aead->tfm_entry)) {
548 kzfree(aead);
549 return -ENOMEM;
550 }
551
552 for_each_possible_cpu(cpu) {
553 *per_cpu_ptr(aead->tfm_entry, cpu) =
554 *per_cpu_ptr(src->tfm_entry, cpu);
555 }
556
557 memcpy(aead->hint, src->hint, sizeof(src->hint));
558 aead->mode = src->mode;
559 aead->salt = src->salt;
560 aead->authsize = src->authsize;
561 atomic_set(&aead->users, 0);
562 atomic64_set(&aead->seqno, 0);
563 refcount_set(&aead->refcnt, 1);
564
565 WARN_ON(!refcount_inc_not_zero(&src->refcnt));
566 aead->cloned = src;
567
568 *dst = aead;
569 return 0;
570}
571
572/**
573 * tipc_aead_mem_alloc - Allocate memory for AEAD request operations
574 * @tfm: cipher handle to be registered with the request
575 * @crypto_ctx_size: size of crypto context for callback
576 * @iv: returned pointer to IV data
577 * @req: returned pointer to AEAD request data
578 * @sg: returned pointer to SG lists
579 * @nsg: number of SG lists to be allocated
580 *
581 * Allocate memory to store the crypto context data, AEAD request, IV and SG
582 * lists, the memory layout is as follows:
583 * crypto_ctx || iv || aead_req || sg[]
584 *
585 * Return: the pointer to the memory areas in case of success, otherwise NULL
586 */
587static void *tipc_aead_mem_alloc(struct crypto_aead *tfm,
588 unsigned int crypto_ctx_size,
589 u8 **iv, struct aead_request **req,
590 struct scatterlist **sg, int nsg)
591{
592 unsigned int iv_size, req_size;
593 unsigned int len;
594 u8 *mem;
595
596 iv_size = crypto_aead_ivsize(tfm);
597 req_size = sizeof(**req) + crypto_aead_reqsize(tfm);
598
599 len = crypto_ctx_size;
600 len += iv_size;
601 len += crypto_aead_alignmask(tfm) & ~(crypto_tfm_ctx_alignment() - 1);
602 len = ALIGN(len, crypto_tfm_ctx_alignment());
603 len += req_size;
604 len = ALIGN(len, __alignof__(struct scatterlist));
605 len += nsg * sizeof(**sg);
606
607 mem = kmalloc(len, GFP_ATOMIC);
608 if (!mem)
609 return NULL;
610
611 *iv = (u8 *)PTR_ALIGN(mem + crypto_ctx_size,
612 crypto_aead_alignmask(tfm) + 1);
613 *req = (struct aead_request *)PTR_ALIGN(*iv + iv_size,
614 crypto_tfm_ctx_alignment());
615 *sg = (struct scatterlist *)PTR_ALIGN((u8 *)*req + req_size,
616 __alignof__(struct scatterlist));
617
618 return (void *)mem;
619}
620
621/**
622 * tipc_aead_encrypt - Encrypt a message
623 * @aead: TIPC AEAD key for the message encryption
624 * @skb: the input/output skb
625 * @b: TIPC bearer where the message will be delivered after the encryption
626 * @dst: the destination media address
627 * @__dnode: TIPC dest node if "known"
628 *
629 * Return:
630 * 0 : if the encryption has completed
631 * -EINPROGRESS/-EBUSY : if a callback will be performed
632 * < 0 : the encryption has failed
633 */
634static int tipc_aead_encrypt(struct tipc_aead *aead, struct sk_buff *skb,
635 struct tipc_bearer *b,
636 struct tipc_media_addr *dst,
637 struct tipc_node *__dnode)
638{
639 struct crypto_aead *tfm = tipc_aead_tfm_next(aead);
640 struct tipc_crypto_tx_ctx *tx_ctx;
641 struct aead_request *req;
642 struct sk_buff *trailer;
643 struct scatterlist *sg;
644 struct tipc_ehdr *ehdr;
645 int ehsz, len, tailen, nsg, rc;
646 void *ctx;
647 u32 salt;
648 u8 *iv;
649
650 /* Make sure message len at least 4-byte aligned */
651 len = ALIGN(skb->len, 4);
652 tailen = len - skb->len + aead->authsize;
653
654 /* Expand skb tail for authentication tag:
655 * As for simplicity, we'd have made sure skb having enough tailroom
656 * for authentication tag @skb allocation. Even when skb is nonlinear
657 * but there is no frag_list, it should be still fine!
658 * Otherwise, we must cow it to be a writable buffer with the tailroom.
659 */
660#ifdef TIPC_CRYPTO_DEBUG
661 SKB_LINEAR_ASSERT(skb);
662 if (tailen > skb_tailroom(skb)) {
663 pr_warn("TX: skb tailroom is not enough: %d, requires: %d\n",
664 skb_tailroom(skb), tailen);
665 }
666#endif
667
668 if (unlikely(!skb_cloned(skb) && tailen <= skb_tailroom(skb))) {
669 nsg = 1;
670 trailer = skb;
671 } else {
672 /* TODO: We could avoid skb_cow_data() if skb has no frag_list
673 * e.g. by skb_fill_page_desc() to add another page to the skb
674 * with the wanted tailen... However, page skbs look not often,
675 * so take it easy now!
676 * Cloned skbs e.g. from link_xmit() seems no choice though :(
677 */
678 nsg = skb_cow_data(skb, tailen, &trailer);
679 if (unlikely(nsg < 0)) {
680 pr_err("TX: skb_cow_data() returned %d\n", nsg);
681 return nsg;
682 }
683 }
684
685 pskb_put(skb, trailer, tailen);
686
687 /* Allocate memory for the AEAD operation */
688 ctx = tipc_aead_mem_alloc(tfm, sizeof(*tx_ctx), &iv, &req, &sg, nsg);
689 if (unlikely(!ctx))
690 return -ENOMEM;
691 TIPC_SKB_CB(skb)->crypto_ctx = ctx;
692
693 /* Map skb to the sg lists */
694 sg_init_table(sg, nsg);
695 rc = skb_to_sgvec(skb, sg, 0, skb->len);
696 if (unlikely(rc < 0)) {
697 pr_err("TX: skb_to_sgvec() returned %d, nsg %d!\n", rc, nsg);
698 goto exit;
699 }
700
701 /* Prepare IV: [SALT (4 octets)][SEQNO (8 octets)]
702 * In case we're in cluster-key mode, SALT is varied by xor-ing with
703 * the source address (or w0 of id), otherwise with the dest address
704 * if dest is known.
705 */
706 ehdr = (struct tipc_ehdr *)skb->data;
707 salt = aead->salt;
708 if (aead->mode == CLUSTER_KEY)
709 salt ^= ehdr->addr; /* __be32 */
710 else if (__dnode)
711 salt ^= tipc_node_get_addr(__dnode);
712 memcpy(iv, &salt, 4);
713 memcpy(iv + 4, (u8 *)&ehdr->seqno, 8);
714
715 /* Prepare request */
716 ehsz = tipc_ehdr_size(ehdr);
717 aead_request_set_tfm(req, tfm);
718 aead_request_set_ad(req, ehsz);
719 aead_request_set_crypt(req, sg, sg, len - ehsz, iv);
720
721 /* Set callback function & data */
722 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
723 tipc_aead_encrypt_done, skb);
724 tx_ctx = (struct tipc_crypto_tx_ctx *)ctx;
725 tx_ctx->aead = aead;
726 tx_ctx->bearer = b;
727 memcpy(&tx_ctx->dst, dst, sizeof(*dst));
728
729 /* Hold bearer */
730 if (unlikely(!tipc_bearer_hold(b))) {
731 rc = -ENODEV;
732 goto exit;
733 }
734
735 /* Now, do encrypt */
736 rc = crypto_aead_encrypt(req);
737 if (rc == -EINPROGRESS || rc == -EBUSY)
738 return rc;
739
740 tipc_bearer_put(b);
741
742exit:
743 kfree(ctx);
744 TIPC_SKB_CB(skb)->crypto_ctx = NULL;
745 return rc;
746}
747
748static void tipc_aead_encrypt_done(struct crypto_async_request *base, int err)
749{
750 struct sk_buff *skb = base->data;
751 struct tipc_crypto_tx_ctx *tx_ctx = TIPC_SKB_CB(skb)->crypto_ctx;
752 struct tipc_bearer *b = tx_ctx->bearer;
753 struct tipc_aead *aead = tx_ctx->aead;
754 struct tipc_crypto *tx = aead->crypto;
755 struct net *net = tx->net;
756
757 switch (err) {
758 case 0:
759 this_cpu_inc(tx->stats->stat[STAT_ASYNC_OK]);
760 if (likely(test_bit(0, &b->up)))
761 b->media->send_msg(net, skb, b, &tx_ctx->dst);
762 else
763 kfree_skb(skb);
764 break;
765 case -EINPROGRESS:
766 return;
767 default:
768 this_cpu_inc(tx->stats->stat[STAT_ASYNC_NOK]);
769 kfree_skb(skb);
770 break;
771 }
772
773 kfree(tx_ctx);
774 tipc_bearer_put(b);
775 tipc_aead_put(aead);
776}
777
778/**
779 * tipc_aead_decrypt - Decrypt an encrypted message
780 * @net: struct net
781 * @aead: TIPC AEAD for the message decryption
782 * @skb: the input/output skb
783 * @b: TIPC bearer where the message has been received
784 *
785 * Return:
786 * 0 : if the decryption has completed
787 * -EINPROGRESS/-EBUSY : if a callback will be performed
788 * < 0 : the decryption has failed
789 */
790static int tipc_aead_decrypt(struct net *net, struct tipc_aead *aead,
791 struct sk_buff *skb, struct tipc_bearer *b)
792{
793 struct tipc_crypto_rx_ctx *rx_ctx;
794 struct aead_request *req;
795 struct crypto_aead *tfm;
796 struct sk_buff *unused;
797 struct scatterlist *sg;
798 struct tipc_ehdr *ehdr;
799 int ehsz, nsg, rc;
800 void *ctx;
801 u32 salt;
802 u8 *iv;
803
804 if (unlikely(!aead))
805 return -ENOKEY;
806
807 /* Cow skb data if needed */
808 if (likely(!skb_cloned(skb) &&
809 (!skb_is_nonlinear(skb) || !skb_has_frag_list(skb)))) {
810 nsg = 1 + skb_shinfo(skb)->nr_frags;
811 } else {
812 nsg = skb_cow_data(skb, 0, &unused);
813 if (unlikely(nsg < 0)) {
814 pr_err("RX: skb_cow_data() returned %d\n", nsg);
815 return nsg;
816 }
817 }
818
819 /* Allocate memory for the AEAD operation */
820 tfm = tipc_aead_tfm_next(aead);
821 ctx = tipc_aead_mem_alloc(tfm, sizeof(*rx_ctx), &iv, &req, &sg, nsg);
822 if (unlikely(!ctx))
823 return -ENOMEM;
824 TIPC_SKB_CB(skb)->crypto_ctx = ctx;
825
826 /* Map skb to the sg lists */
827 sg_init_table(sg, nsg);
828 rc = skb_to_sgvec(skb, sg, 0, skb->len);
829 if (unlikely(rc < 0)) {
830 pr_err("RX: skb_to_sgvec() returned %d, nsg %d\n", rc, nsg);
831 goto exit;
832 }
833
834 /* Reconstruct IV: */
835 ehdr = (struct tipc_ehdr *)skb->data;
836 salt = aead->salt;
837 if (aead->mode == CLUSTER_KEY)
838 salt ^= ehdr->addr; /* __be32 */
839 else if (ehdr->destined)
840 salt ^= tipc_own_addr(net);
841 memcpy(iv, &salt, 4);
842 memcpy(iv + 4, (u8 *)&ehdr->seqno, 8);
843
844 /* Prepare request */
845 ehsz = tipc_ehdr_size(ehdr);
846 aead_request_set_tfm(req, tfm);
847 aead_request_set_ad(req, ehsz);
848 aead_request_set_crypt(req, sg, sg, skb->len - ehsz, iv);
849
850 /* Set callback function & data */
851 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
852 tipc_aead_decrypt_done, skb);
853 rx_ctx = (struct tipc_crypto_rx_ctx *)ctx;
854 rx_ctx->aead = aead;
855 rx_ctx->bearer = b;
856
857 /* Hold bearer */
858 if (unlikely(!tipc_bearer_hold(b))) {
859 rc = -ENODEV;
860 goto exit;
861 }
862
863 /* Now, do decrypt */
864 rc = crypto_aead_decrypt(req);
865 if (rc == -EINPROGRESS || rc == -EBUSY)
866 return rc;
867
868 tipc_bearer_put(b);
869
870exit:
871 kfree(ctx);
872 TIPC_SKB_CB(skb)->crypto_ctx = NULL;
873 return rc;
874}
875
876static void tipc_aead_decrypt_done(struct crypto_async_request *base, int err)
877{
878 struct sk_buff *skb = base->data;
879 struct tipc_crypto_rx_ctx *rx_ctx = TIPC_SKB_CB(skb)->crypto_ctx;
880 struct tipc_bearer *b = rx_ctx->bearer;
881 struct tipc_aead *aead = rx_ctx->aead;
882 struct tipc_crypto_stats __percpu *stats = aead->crypto->stats;
883 struct net *net = aead->crypto->net;
884
885 switch (err) {
886 case 0:
887 this_cpu_inc(stats->stat[STAT_ASYNC_OK]);
888 break;
889 case -EINPROGRESS:
890 return;
891 default:
892 this_cpu_inc(stats->stat[STAT_ASYNC_NOK]);
893 break;
894 }
895
896 kfree(rx_ctx);
897 tipc_crypto_rcv_complete(net, aead, b, &skb, err);
898 if (likely(skb)) {
899 if (likely(test_bit(0, &b->up)))
900 tipc_rcv(net, skb, b);
901 else
902 kfree_skb(skb);
903 }
904
905 tipc_bearer_put(b);
906}
907
908static inline int tipc_ehdr_size(struct tipc_ehdr *ehdr)
909{
910 return (ehdr->user != LINK_CONFIG) ? EHDR_SIZE : EHDR_CFG_SIZE;
911}
912
913/**
914 * tipc_ehdr_validate - Validate an encryption message
915 * @skb: the message buffer
916 *
917 * Returns "true" if this is a valid encryption message, otherwise "false"
918 */
919bool tipc_ehdr_validate(struct sk_buff *skb)
920{
921 struct tipc_ehdr *ehdr;
922 int ehsz;
923
924 if (unlikely(!pskb_may_pull(skb, EHDR_MIN_SIZE)))
925 return false;
926
927 ehdr = (struct tipc_ehdr *)skb->data;
928 if (unlikely(ehdr->version != TIPC_EVERSION))
929 return false;
930 ehsz = tipc_ehdr_size(ehdr);
931 if (unlikely(!pskb_may_pull(skb, ehsz)))
932 return false;
933 if (unlikely(skb->len <= ehsz + TIPC_AES_GCM_TAG_SIZE))
934 return false;
935 if (unlikely(!ehdr->tx_key))
936 return false;
937
938 return true;
939}
940
941/**
942 * tipc_ehdr_build - Build TIPC encryption message header
943 * @net: struct net
944 * @aead: TX AEAD key to be used for the message encryption
945 * @tx_key: key id used for the message encryption
946 * @skb: input/output message skb
947 * @__rx: RX crypto handle if dest is "known"
948 *
949 * Return: the header size if the building is successful, otherwise < 0
950 */
951static int tipc_ehdr_build(struct net *net, struct tipc_aead *aead,
952 u8 tx_key, struct sk_buff *skb,
953 struct tipc_crypto *__rx)
954{
955 struct tipc_msg *hdr = buf_msg(skb);
956 struct tipc_ehdr *ehdr;
957 u32 user = msg_user(hdr);
958 u64 seqno;
959 int ehsz;
960
961 /* Make room for encryption header */
962 ehsz = (user != LINK_CONFIG) ? EHDR_SIZE : EHDR_CFG_SIZE;
963 WARN_ON(skb_headroom(skb) < ehsz);
964 ehdr = (struct tipc_ehdr *)skb_push(skb, ehsz);
965
966 /* Obtain a seqno first:
967 * Use the key seqno (= cluster wise) if dest is unknown or we're in
968 * cluster key mode, otherwise it's better for a per-peer seqno!
969 */
970 if (!__rx || aead->mode == CLUSTER_KEY)
971 seqno = atomic64_inc_return(&aead->seqno);
972 else
973 seqno = atomic64_inc_return(&__rx->sndnxt);
974
975 /* Revoke the key if seqno is wrapped around */
976 if (unlikely(!seqno))
977 return tipc_crypto_key_revoke(net, tx_key);
978
979 /* Word 1-2 */
980 ehdr->seqno = cpu_to_be64(seqno);
981
982 /* Words 0, 3- */
983 ehdr->version = TIPC_EVERSION;
984 ehdr->user = 0;
985 ehdr->keepalive = 0;
986 ehdr->tx_key = tx_key;
987 ehdr->destined = (__rx) ? 1 : 0;
988 ehdr->rx_key_active = (__rx) ? __rx->key.active : 0;
989 ehdr->reserved_1 = 0;
990 ehdr->reserved_2 = 0;
991
992 switch (user) {
993 case LINK_CONFIG:
994 ehdr->user = LINK_CONFIG;
995 memcpy(ehdr->id, tipc_own_id(net), NODE_ID_LEN);
996 break;
997 default:
998 if (user == LINK_PROTOCOL && msg_type(hdr) == STATE_MSG) {
999 ehdr->user = LINK_PROTOCOL;
1000 ehdr->keepalive = msg_is_keepalive(hdr);
1001 }
1002 ehdr->addr = hdr->hdr[3];
1003 break;
1004 }
1005
1006 return ehsz;
1007}
1008
1009static inline void tipc_crypto_key_set_state(struct tipc_crypto *c,
1010 u8 new_passive,
1011 u8 new_active,
1012 u8 new_pending)
1013{
1014#ifdef TIPC_CRYPTO_DEBUG
1015 struct tipc_key old = c->key;
1016 char buf[32];
1017#endif
1018
1019 c->key.keys = ((new_passive & KEY_MASK) << (KEY_BITS * 2)) |
1020 ((new_active & KEY_MASK) << (KEY_BITS)) |
1021 ((new_pending & KEY_MASK));
1022
1023#ifdef TIPC_CRYPTO_DEBUG
1024 pr_info("%s(%s): key changing %s ::%pS\n",
1025 (c->node) ? "RX" : "TX",
1026 (c->node) ? tipc_node_get_id_str(c->node) :
1027 tipc_own_id_string(c->net),
1028 tipc_key_change_dump(old, c->key, buf),
1029 __builtin_return_address(0));
1030#endif
1031}
1032
1033/**
1034 * tipc_crypto_key_init - Initiate a new user / AEAD key
1035 * @c: TIPC crypto to which new key is attached
1036 * @ukey: the user key
1037 * @mode: the key mode (CLUSTER_KEY or PER_NODE_KEY)
1038 *
1039 * A new TIPC AEAD key will be allocated and initiated with the specified user
1040 * key, then attached to the TIPC crypto.
1041 *
1042 * Return: new key id in case of success, otherwise: < 0
1043 */
1044int tipc_crypto_key_init(struct tipc_crypto *c, struct tipc_aead_key *ukey,
1045 u8 mode)
1046{
1047 struct tipc_aead *aead = NULL;
1048 int rc = 0;
1049
1050 /* Initiate with the new user key */
1051 rc = tipc_aead_init(&aead, ukey, mode);
1052
1053 /* Attach it to the crypto */
1054 if (likely(!rc)) {
1055 rc = tipc_crypto_key_attach(c, aead, 0);
1056 if (rc < 0)
1057 tipc_aead_free(&aead->rcu);
1058 }
1059
1060 pr_info("%s(%s): key initiating, rc %d!\n",
1061 (c->node) ? "RX" : "TX",
1062 (c->node) ? tipc_node_get_id_str(c->node) :
1063 tipc_own_id_string(c->net),
1064 rc);
1065
1066 return rc;
1067}
1068
1069/**
1070 * tipc_crypto_key_attach - Attach a new AEAD key to TIPC crypto
1071 * @c: TIPC crypto to which the new AEAD key is attached
1072 * @aead: the new AEAD key pointer
1073 * @pos: desired slot in the crypto key array, = 0 if any!
1074 *
1075 * Return: new key id in case of success, otherwise: -EBUSY
1076 */
1077static int tipc_crypto_key_attach(struct tipc_crypto *c,
1078 struct tipc_aead *aead, u8 pos)
1079{
1080 u8 new_pending, new_passive, new_key;
1081 struct tipc_key key;
1082 int rc = -EBUSY;
1083
1084 spin_lock_bh(&c->lock);
1085 key = c->key;
1086 if (key.active && key.passive)
1087 goto exit;
1088 if (key.passive && !tipc_aead_users(c->aead[key.passive]))
1089 goto exit;
1090 if (key.pending) {
1091 if (pos)
1092 goto exit;
1093 if (tipc_aead_users(c->aead[key.pending]) > 0)
1094 goto exit;
1095 /* Replace it */
1096 new_pending = key.pending;
1097 new_passive = key.passive;
1098 new_key = new_pending;
1099 } else {
1100 if (pos) {
1101 if (key.active && pos != key_next(key.active)) {
1102 new_pending = key.pending;
1103 new_passive = pos;
1104 new_key = new_passive;
1105 goto attach;
1106 } else if (!key.active && !key.passive) {
1107 new_pending = pos;
1108 new_passive = key.passive;
1109 new_key = new_pending;
1110 goto attach;
1111 }
1112 }
1113 new_pending = key_next(key.active ?: key.passive);
1114 new_passive = key.passive;
1115 new_key = new_pending;
1116 }
1117
1118attach:
1119 aead->crypto = c;
1120 tipc_crypto_key_set_state(c, new_passive, key.active, new_pending);
1121 tipc_aead_rcu_replace(c->aead[new_key], aead, &c->lock);
1122
1123 c->working = 1;
1124 c->timer1 = jiffies;
1125 c->timer2 = jiffies;
1126 rc = new_key;
1127
1128exit:
1129 spin_unlock_bh(&c->lock);
1130 return rc;
1131}
1132
1133void tipc_crypto_key_flush(struct tipc_crypto *c)
1134{
1135 int k;
1136
1137 spin_lock_bh(&c->lock);
1138 c->working = 0;
1139 tipc_crypto_key_set_state(c, 0, 0, 0);
1140 for (k = KEY_MIN; k <= KEY_MAX; k++)
1141 tipc_crypto_key_detach(c->aead[k], &c->lock);
1142 atomic_set(&c->peer_rx_active, 0);
1143 atomic64_set(&c->sndnxt, 0);
1144 spin_unlock_bh(&c->lock);
1145}
1146
1147/**
1148 * tipc_crypto_key_try_align - Align RX keys if possible
1149 * @rx: RX crypto handle
1150 * @new_pending: new pending slot if aligned (= TX key from peer)
1151 *
1152 * Peer has used an unknown key slot, this only happens when peer has left and
1153 * rejoned, or we are newcomer.
1154 * That means, there must be no active key but a pending key at unaligned slot.
1155 * If so, we try to move the pending key to the new slot.
1156 * Note: A potential passive key can exist, it will be shifted correspondingly!
1157 *
1158 * Return: "true" if key is successfully aligned, otherwise "false"
1159 */
1160static bool tipc_crypto_key_try_align(struct tipc_crypto *rx, u8 new_pending)
1161{
1162 struct tipc_aead *tmp1, *tmp2 = NULL;
1163 struct tipc_key key;
1164 bool aligned = false;
1165 u8 new_passive = 0;
1166 int x;
1167
1168 spin_lock(&rx->lock);
1169 key = rx->key;
1170 if (key.pending == new_pending) {
1171 aligned = true;
1172 goto exit;
1173 }
1174 if (key.active)
1175 goto exit;
1176 if (!key.pending)
1177 goto exit;
1178 if (tipc_aead_users(rx->aead[key.pending]) > 0)
1179 goto exit;
1180
1181 /* Try to "isolate" this pending key first */
1182 tmp1 = tipc_aead_rcu_ptr(rx->aead[key.pending], &rx->lock);
1183 if (!refcount_dec_if_one(&tmp1->refcnt))
1184 goto exit;
1185 rcu_assign_pointer(rx->aead[key.pending], NULL);
1186
1187 /* Move passive key if any */
1188 if (key.passive) {
1a271ebb 1189 tmp2 = rcu_replace_pointer(rx->aead[key.passive], tmp2, lockdep_is_held(&rx->lock));
fc1b6d6d
TL		 1190 x = (key.passive - key.pending + new_pending) % KEY_MAX;
1191 new_passive = (x <= 0) ? x + KEY_MAX : x;
1192 }
1193
1194 /* Re-allocate the key(s) */
1195 tipc_crypto_key_set_state(rx, new_passive, 0, new_pending);
1196 rcu_assign_pointer(rx->aead[new_pending], tmp1);
1197 if (new_passive)
1198 rcu_assign_pointer(rx->aead[new_passive], tmp2);
1199 refcount_set(&tmp1->refcnt, 1);
1200 aligned = true;
1201 pr_info("RX(%s): key is aligned!\n", tipc_node_get_id_str(rx->node));
1202
1203exit:
1204 spin_unlock(&rx->lock);
1205 return aligned;
1206}
1207
1208/**
1209 * tipc_crypto_key_pick_tx - Pick one TX key for message decryption
1210 * @tx: TX crypto handle
1211 * @rx: RX crypto handle (can be NULL)
1212 * @skb: the message skb which will be decrypted later
1213 *
1214 * This function looks up the existing TX keys and pick one which is suitable
1215 * for the message decryption, that must be a cluster key and not used before
1216 * on the same message (i.e. recursive).
1217 *
1218 * Return: the TX AEAD key handle in case of success, otherwise NULL
1219 */
1220static struct tipc_aead *tipc_crypto_key_pick_tx(struct tipc_crypto *tx,
1221 struct tipc_crypto *rx,
1222 struct sk_buff *skb)
1223{
1224 struct tipc_skb_cb *skb_cb = TIPC_SKB_CB(skb);
1225 struct tipc_aead *aead = NULL;
1226 struct tipc_key key = tx->key;
1227 u8 k, i = 0;
1228
1229 /* Initialize data if not yet */
1230 if (!skb_cb->tx_clone_deferred) {
1231 skb_cb->tx_clone_deferred = 1;
1232 memset(&skb_cb->tx_clone_ctx, 0, sizeof(skb_cb->tx_clone_ctx));
1233 }
1234
1235 skb_cb->tx_clone_ctx.rx = rx;
1236 if (++skb_cb->tx_clone_ctx.recurs > 2)
1237 return NULL;
1238
1239 /* Pick one TX key */
1240 spin_lock(&tx->lock);
1241 do {
1242 k = (i == 0) ? key.pending :
1243 ((i == 1) ? key.active : key.passive);
1244 if (!k)
1245 continue;
1246 aead = tipc_aead_rcu_ptr(tx->aead[k], &tx->lock);
1247 if (!aead)
1248 continue;
1249 if (aead->mode != CLUSTER_KEY ||
1250 aead == skb_cb->tx_clone_ctx.last) {
1251 aead = NULL;
1252 continue;
1253 }
1254 /* Ok, found one cluster key */
1255 skb_cb->tx_clone_ctx.last = aead;
1256 WARN_ON(skb->next);
1257 skb->next = skb_clone(skb, GFP_ATOMIC);
1258 if (unlikely(!skb->next))
1259 pr_warn("Failed to clone skb for next round if any\n");
1260 WARN_ON(!refcount_inc_not_zero(&aead->refcnt));
1261 break;
1262 } while (++i < 3);
1263 spin_unlock(&tx->lock);
1264
1265 return aead;
1266}
1267
1268/**
1269 * tipc_crypto_key_synch: Synch own key data according to peer key status
1270 * @rx: RX crypto handle
1271 * @new_rx_active: latest RX active key from peer
1272 * @hdr: TIPCv2 message
1273 *
1274 * This function updates the peer node related data as the peer RX active key
1275 * has changed, so the number of TX keys' users on this node are increased and
1276 * decreased correspondingly.
1277 *
1278 * The "per-peer" sndnxt is also reset when the peer key has switched.
1279 */
1280static void tipc_crypto_key_synch(struct tipc_crypto *rx, u8 new_rx_active,
1281 struct tipc_msg *hdr)
1282{
1283 struct net *net = rx->net;
1284 struct tipc_crypto *tx = tipc_net(net)->crypto_tx;
1285 u8 cur_rx_active;
1286
1287 /* TX might be even not ready yet */
1288 if (unlikely(!tx->key.active && !tx->key.pending))
1289 return;
1290
1291 cur_rx_active = atomic_read(&rx->peer_rx_active);
1292 if (likely(cur_rx_active == new_rx_active))
1293 return;
1294
1295 /* Make sure this message destined for this node */
1296 if (unlikely(msg_short(hdr) ||
1297 msg_destnode(hdr) != tipc_own_addr(net)))
1298 return;
1299
1300 /* Peer RX active key has changed, try to update owns' & TX users */
1301 if (atomic_cmpxchg(&rx->peer_rx_active,
1302 cur_rx_active,
1303 new_rx_active) == cur_rx_active) {
1304 if (new_rx_active)
1305 tipc_aead_users_inc(tx->aead[new_rx_active], INT_MAX);
1306 if (cur_rx_active)
1307 tipc_aead_users_dec(tx->aead[cur_rx_active], 0);
1308
1309 atomic64_set(&rx->sndnxt, 0);
1310 /* Mark the point TX key users changed */
1311 tx->timer1 = jiffies;
1312
1313#ifdef TIPC_CRYPTO_DEBUG
1314 pr_info("TX(%s): key users changed %d-- %d++, peer RX(%s)\n",
1315 tipc_own_id_string(net), cur_rx_active,
1316 new_rx_active, tipc_node_get_id_str(rx->node));
1317#endif
1318 }
1319}
1320
1321static int tipc_crypto_key_revoke(struct net *net, u8 tx_key)
1322{
1323 struct tipc_crypto *tx = tipc_net(net)->crypto_tx;
1324 struct tipc_key key;
1325
1326 spin_lock(&tx->lock);
1327 key = tx->key;
1328 WARN_ON(!key.active || tx_key != key.active);
1329
1330 /* Free the active key */
1331 tipc_crypto_key_set_state(tx, key.passive, 0, key.pending);
1332 tipc_crypto_key_detach(tx->aead[key.active], &tx->lock);
1333 spin_unlock(&tx->lock);
1334
1335 pr_warn("TX(%s): key is revoked!\n", tipc_own_id_string(net));
1336 return -EKEYREVOKED;
1337}
1338
1339int tipc_crypto_start(struct tipc_crypto **crypto, struct net *net,
1340 struct tipc_node *node)
1341{
1342 struct tipc_crypto *c;
1343
1344 if (*crypto)
1345 return -EEXIST;
1346
1347 /* Allocate crypto */
1348 c = kzalloc(sizeof(*c), GFP_ATOMIC);
1349 if (!c)
1350 return -ENOMEM;
1351
1352 /* Allocate statistic structure */
1353 c->stats = alloc_percpu_gfp(struct tipc_crypto_stats, GFP_ATOMIC);
1354 if (!c->stats) {
1355 kzfree(c);
1356 return -ENOMEM;
1357 }
1358
1359 c->working = 0;
1360 c->net = net;
1361 c->node = node;
1362 tipc_crypto_key_set_state(c, 0, 0, 0);
1363 atomic_set(&c->peer_rx_active, 0);
1364 atomic64_set(&c->sndnxt, 0);
1365 c->timer1 = jiffies;
1366 c->timer2 = jiffies;
1367 spin_lock_init(&c->lock);
1368 *crypto = c;
1369
1370 return 0;
1371}
1372
1373void tipc_crypto_stop(struct tipc_crypto **crypto)
1374{
1375 struct tipc_crypto *c, *tx, *rx;
1376 bool is_rx;
1377 u8 k;
1378
1379 if (!*crypto)
1380 return;
1381
1382 rcu_read_lock();
1383 /* RX stopping? => decrease TX key users if any */
1384 is_rx = !!((*crypto)->node);
1385 if (is_rx) {
1386 rx = *crypto;
1387 tx = tipc_net(rx->net)->crypto_tx;
1388 k = atomic_read(&rx->peer_rx_active);
1389 if (k) {
1390 tipc_aead_users_dec(tx->aead[k], 0);
1391 /* Mark the point TX key users changed */
1392 tx->timer1 = jiffies;
1393 }
1394 }
1395
1396 /* Release AEAD keys */
1397 c = *crypto;
1398 for (k = KEY_MIN; k <= KEY_MAX; k++)
1399 tipc_aead_put(rcu_dereference(c->aead[k]));
1400 rcu_read_unlock();
1401
1402 pr_warn("%s(%s) has been purged, node left!\n",
1403 (is_rx) ? "RX" : "TX",
1404 (is_rx) ? tipc_node_get_id_str((*crypto)->node) :
1405 tipc_own_id_string((*crypto)->net));
1406
1407 /* Free this crypto statistics */
1408 free_percpu(c->stats);
1409
1410 *crypto = NULL;
1411 kzfree(c);
1412}
1413
1414void tipc_crypto_timeout(struct tipc_crypto *rx)
1415{
1416 struct tipc_net *tn = tipc_net(rx->net);
1417 struct tipc_crypto *tx = tn->crypto_tx;
1418 struct tipc_key key;
1419 u8 new_pending, new_passive;
1420 int cmd;
1421
1422 /* TX key activating:
1423 * The pending key (users > 0) -> active
1424 * The active key if any (users == 0) -> free
1425 */
1426 spin_lock(&tx->lock);
1427 key = tx->key;
1428 if (key.active && tipc_aead_users(tx->aead[key.active]) > 0)
1429 goto s1;
1430 if (!key.pending || tipc_aead_users(tx->aead[key.pending]) <= 0)
1431 goto s1;
1432 if (time_before(jiffies, tx->timer1 + TIPC_TX_LASTING_LIM))
1433 goto s1;
1434
1435 tipc_crypto_key_set_state(tx, key.passive, key.pending, 0);
1436 if (key.active)
1437 tipc_crypto_key_detach(tx->aead[key.active], &tx->lock);
1438 this_cpu_inc(tx->stats->stat[STAT_SWITCHES]);
1439 pr_info("TX(%s): key %d is activated!\n", tipc_own_id_string(tx->net),
1440 key.pending);
1441
1442s1:
1443 spin_unlock(&tx->lock);
1444
1445 /* RX key activating:
1446 * The pending key (users > 0) -> active
1447 * The active key if any -> passive, freed later
1448 */
1449 spin_lock(&rx->lock);
1450 key = rx->key;
1451 if (!key.pending || tipc_aead_users(rx->aead[key.pending]) <= 0)
1452 goto s2;
1453
1454 new_pending = (key.passive &&
1455 !tipc_aead_users(rx->aead[key.passive])) ?
1456 key.passive : 0;
1457 new_passive = (key.active) ?: ((new_pending) ? 0 : key.passive);
1458 tipc_crypto_key_set_state(rx, new_passive, key.pending, new_pending);
1459 this_cpu_inc(rx->stats->stat[STAT_SWITCHES]);
1460 pr_info("RX(%s): key %d is activated!\n",
1461 tipc_node_get_id_str(rx->node), key.pending);
1462 goto s5;
1463
1464s2:
1465 /* RX key "faulty" switching:
1466 * The faulty pending key (users < -30) -> passive
1467 * The passive key (users = 0) -> pending
1468 * Note: This only happens after RX deactivated - s3!
1469 */
1470 key = rx->key;
1471 if (!key.pending || tipc_aead_users(rx->aead[key.pending]) > -30)
1472 goto s3;
1473 if (!key.passive || tipc_aead_users(rx->aead[key.passive]) != 0)
1474 goto s3;
1475
1476 new_pending = key.passive;
1477 new_passive = key.pending;
1478 tipc_crypto_key_set_state(rx, new_passive, key.active, new_pending);
1479 goto s5;
1480
1481s3:
1482 /* RX key deactivating:
1483 * The passive key if any -> pending
1484 * The active key -> passive (users = 0) / pending
1485 * The pending key if any -> passive (users = 0)
1486 */
1487 key = rx->key;
1488 if (!key.active)
1489 goto s4;
1490 if (time_before(jiffies, rx->timer1 + TIPC_RX_ACTIVE_LIM))
1491 goto s4;
1492
1493 new_pending = (key.passive) ?: key.active;
1494 new_passive = (key.passive) ? key.active : key.pending;
1495 tipc_aead_users_set(rx->aead[new_pending], 0);
1496 if (new_passive)
1497 tipc_aead_users_set(rx->aead[new_passive], 0);
1498 tipc_crypto_key_set_state(rx, new_passive, 0, new_pending);
1499 pr_info("RX(%s): key %d is deactivated!\n",
1500 tipc_node_get_id_str(rx->node), key.active);
1501 goto s5;
1502
1503s4:
1504 /* RX key passive -> freed: */
1505 key = rx->key;
1506 if (!key.passive || !tipc_aead_users(rx->aead[key.passive]))
1507 goto s5;
1508 if (time_before(jiffies, rx->timer2 + TIPC_RX_PASSIVE_LIM))
1509 goto s5;
1510
1511 tipc_crypto_key_set_state(rx, 0, key.active, key.pending);
1512 tipc_crypto_key_detach(rx->aead[key.passive], &rx->lock);
1513 pr_info("RX(%s): key %d is freed!\n", tipc_node_get_id_str(rx->node),
1514 key.passive);
1515
1516s5:
1517 spin_unlock(&rx->lock);
1518
1519 /* Limit max_tfms & do debug commands if needed */
1520 if (likely(sysctl_tipc_max_tfms <= TIPC_MAX_TFMS_LIM))
1521 return;
1522
1523 cmd = sysctl_tipc_max_tfms;
1524 sysctl_tipc_max_tfms = TIPC_MAX_TFMS_DEF;
1525 tipc_crypto_do_cmd(rx->net, cmd);
1526}
1527
1528/**
1529 * tipc_crypto_xmit - Build & encrypt TIPC message for xmit
1530 * @net: struct net
1531 * @skb: input/output message skb pointer
1532 * @b: bearer used for xmit later
1533 * @dst: destination media address
1534 * @__dnode: destination node for reference if any
1535 *
1536 * First, build an encryption message header on the top of the message, then
1537 * encrypt the original TIPC message by using the active or pending TX key.
1538 * If the encryption is successful, the encrypted skb is returned directly or
1539 * via the callback.
1540 * Otherwise, the skb is freed!
1541 *
1542 * Return:
1543 * 0 : the encryption has succeeded (or no encryption)
1544 * -EINPROGRESS/-EBUSY : the encryption is ongoing, a callback will be made
1545 * -ENOKEK : the encryption has failed due to no key
1546 * -EKEYREVOKED : the encryption has failed due to key revoked
1547 * -ENOMEM : the encryption has failed due to no memory
1548 * < 0 : the encryption has failed due to other reasons
1549 */
1550int tipc_crypto_xmit(struct net *net, struct sk_buff **skb,
1551 struct tipc_bearer *b, struct tipc_media_addr *dst,
1552 struct tipc_node *__dnode)
1553{
1554 struct tipc_crypto *__rx = tipc_node_crypto_rx(__dnode);
1555 struct tipc_crypto *tx = tipc_net(net)->crypto_tx;
1556 struct tipc_crypto_stats __percpu *stats = tx->stats;
1557 struct tipc_key key = tx->key;
1558 struct tipc_aead *aead = NULL;
1559 struct sk_buff *probe;
1560 int rc = -ENOKEY;
1561 u8 tx_key;
1562
1563 /* No encryption? */
1564 if (!tx->working)
1565 return 0;
1566
1567 /* Try with the pending key if available and:
1568 * 1) This is the only choice (i.e. no active key) or;
1569 * 2) Peer has switched to this key (unicast only) or;
1570 * 3) It is time to do a pending key probe;
1571 */
1572 if (unlikely(key.pending)) {
1573 tx_key = key.pending;
1574 if (!key.active)
1575 goto encrypt;
1576 if (__rx && atomic_read(&__rx->peer_rx_active) == tx_key)
1577 goto encrypt;
1578 if (TIPC_SKB_CB(*skb)->probe)
1579 goto encrypt;
1580 if (!__rx &&
1581 time_after(jiffies, tx->timer2 + TIPC_TX_PROBE_LIM)) {
1582 tx->timer2 = jiffies;
1583 probe = skb_clone(*skb, GFP_ATOMIC);
1584 if (probe) {
1585 TIPC_SKB_CB(probe)->probe = 1;
1586 tipc_crypto_xmit(net, &probe, b, dst, __dnode);
1587 if (probe)
1588 b->media->send_msg(net, probe, b, dst);
1589 }
1590 }
1591 }
1592 /* Else, use the active key if any */
1593 if (likely(key.active)) {
1594 tx_key = key.active;
1595 goto encrypt;
1596 }
1597 goto exit;
1598
1599encrypt:
1600 aead = tipc_aead_get(tx->aead[tx_key]);
1601 if (unlikely(!aead))
1602 goto exit;
1603 rc = tipc_ehdr_build(net, aead, tx_key, *skb, __rx);
1604 if (likely(rc > 0))
1605 rc = tipc_aead_encrypt(aead, *skb, b, dst, __dnode);
1606
1607exit:
1608 switch (rc) {
1609 case 0:
1610 this_cpu_inc(stats->stat[STAT_OK]);
1611 break;
1612 case -EINPROGRESS:
1613 case -EBUSY:
1614 this_cpu_inc(stats->stat[STAT_ASYNC]);
1615 *skb = NULL;
1616 return rc;
1617 default:
1618 this_cpu_inc(stats->stat[STAT_NOK]);
1619 if (rc == -ENOKEY)
1620 this_cpu_inc(stats->stat[STAT_NOKEYS]);
1621 else if (rc == -EKEYREVOKED)
1622 this_cpu_inc(stats->stat[STAT_BADKEYS]);
1623 kfree_skb(*skb);
1624 *skb = NULL;
1625 break;
1626 }
1627
1628 tipc_aead_put(aead);
1629 return rc;
1630}
1631
1632/**
1633 * tipc_crypto_rcv - Decrypt an encrypted TIPC message from peer
1634 * @net: struct net
1635 * @rx: RX crypto handle
1636 * @skb: input/output message skb pointer
1637 * @b: bearer where the message has been received
1638 *
1639 * If the decryption is successful, the decrypted skb is returned directly or
1640 * as the callback, the encryption header and auth tag will be trimed out
1641 * before forwarding to tipc_rcv() via the tipc_crypto_rcv_complete().
1642 * Otherwise, the skb will be freed!
1643 * Note: RX key(s) can be re-aligned, or in case of no key suitable, TX
1644 * cluster key(s) can be taken for decryption (- recursive).
1645 *
1646 * Return:
1647 * 0 : the decryption has successfully completed
1648 * -EINPROGRESS/-EBUSY : the decryption is ongoing, a callback will be made
1649 * -ENOKEY : the decryption has failed due to no key
1650 * -EBADMSG : the decryption has failed due to bad message
1651 * -ENOMEM : the decryption has failed due to no memory
1652 * < 0 : the decryption has failed due to other reasons
1653 */
1654int tipc_crypto_rcv(struct net *net, struct tipc_crypto *rx,
1655 struct sk_buff **skb, struct tipc_bearer *b)
1656{
1657 struct tipc_crypto *tx = tipc_net(net)->crypto_tx;
1658 struct tipc_crypto_stats __percpu *stats;
1659 struct tipc_aead *aead = NULL;
1660 struct tipc_key key;
1661 int rc = -ENOKEY;
1662 u8 tx_key = 0;
1663
1664 /* New peer?
1665 * Let's try with TX key (i.e. cluster mode) & verify the skb first!
1666 */
1667 if (unlikely(!rx))
1668 goto pick_tx;
1669
1670 /* Pick RX key according to TX key, three cases are possible:
1671 * 1) The current active key (likely) or;
1672 * 2) The pending (new or deactivated) key (if any) or;
1673 * 3) The passive or old active key (i.e. users > 0);
1674 */
1675 tx_key = ((struct tipc_ehdr *)(*skb)->data)->tx_key;
1676 key = rx->key;
1677 if (likely(tx_key == key.active))
1678 goto decrypt;
1679 if (tx_key == key.pending)
1680 goto decrypt;
1681 if (tx_key == key.passive) {
1682 rx->timer2 = jiffies;
1683 if (tipc_aead_users(rx->aead[key.passive]) > 0)
1684 goto decrypt;
1685 }
1686
1687 /* Unknown key, let's try to align RX key(s) */
1688 if (tipc_crypto_key_try_align(rx, tx_key))
1689 goto decrypt;
1690
1691pick_tx:
1692 /* No key suitable? Try to pick one from TX... */
1693 aead = tipc_crypto_key_pick_tx(tx, rx, *skb);
1694 if (aead)
1695 goto decrypt;
1696 goto exit;
1697
1698decrypt:
1699 rcu_read_lock();
1700 if (!aead)
1701 aead = tipc_aead_get(rx->aead[tx_key]);
1702 rc = tipc_aead_decrypt(net, aead, *skb, b);
1703 rcu_read_unlock();
1704
1705exit:
1706 stats = ((rx) ?: tx)->stats;
1707 switch (rc) {
1708 case 0:
1709 this_cpu_inc(stats->stat[STAT_OK]);
1710 break;
1711 case -EINPROGRESS:
1712 case -EBUSY:
1713 this_cpu_inc(stats->stat[STAT_ASYNC]);
1714 *skb = NULL;
441870ee 1715 tipc_aead_put(aead);
fc1b6d6d
TL		 1716 return rc;
1717 default:
1718 this_cpu_inc(stats->stat[STAT_NOK]);
1719 if (rc == -ENOKEY) {
1720 kfree_skb(*skb);
1721 *skb = NULL;
1722 if (rx)
1723 tipc_node_put(rx->node);
1724 this_cpu_inc(stats->stat[STAT_NOKEYS]);
1725 return rc;
1726 } else if (rc == -EBADMSG) {
1727 this_cpu_inc(stats->stat[STAT_BADMSGS]);
1728 }
1729 break;
1730 }
1731
1732 tipc_crypto_rcv_complete(net, aead, b, skb, rc);
1733 return rc;
1734}
1735
1736static void tipc_crypto_rcv_complete(struct net *net, struct tipc_aead *aead,
1737 struct tipc_bearer *b,
1738 struct sk_buff **skb, int err)
1739{
1740 struct tipc_skb_cb *skb_cb = TIPC_SKB_CB(*skb);
1741 struct tipc_crypto *rx = aead->crypto;
1742 struct tipc_aead *tmp = NULL;
1743 struct tipc_ehdr *ehdr;
1744 struct tipc_node *n;
1745 u8 rx_key_active;
1746 bool destined;
1747
1748 /* Is this completed by TX? */
1749 if (unlikely(!rx->node)) {
1750 rx = skb_cb->tx_clone_ctx.rx;
1751#ifdef TIPC_CRYPTO_DEBUG
1752 pr_info("TX->RX(%s): err %d, aead %p, skb->next %p, flags %x\n",
1753 (rx) ? tipc_node_get_id_str(rx->node) : "-", err, aead,
1754 (*skb)->next, skb_cb->flags);
1755 pr_info("skb_cb [recurs %d, last %p], tx->aead [%p %p %p]\n",
1756 skb_cb->tx_clone_ctx.recurs, skb_cb->tx_clone_ctx.last,
1757 aead->crypto->aead[1], aead->crypto->aead[2],
1758 aead->crypto->aead[3]);
1759#endif
1760 if (unlikely(err)) {
1761 if (err == -EBADMSG && (*skb)->next)
1762 tipc_rcv(net, (*skb)->next, b);
1763 goto free_skb;
1764 }
1765
1766 if (likely((*skb)->next)) {
1767 kfree_skb((*skb)->next);
1768 (*skb)->next = NULL;
1769 }
1770 ehdr = (struct tipc_ehdr *)(*skb)->data;
1771 if (!rx) {
1772 WARN_ON(ehdr->user != LINK_CONFIG);
1773 n = tipc_node_create(net, 0, ehdr->id, 0xffffu, 0,
1774 true);
1775 rx = tipc_node_crypto_rx(n);
1776 if (unlikely(!rx))
1777 goto free_skb;
1778 }
1779
1780 /* Skip cloning this time as we had a RX pending key */
1781 if (rx->key.pending)
1782 goto rcv;
1783 if (tipc_aead_clone(&tmp, aead) < 0)
1784 goto rcv;
1785 if (tipc_crypto_key_attach(rx, tmp, ehdr->tx_key) < 0) {
1786 tipc_aead_free(&tmp->rcu);
1787 goto rcv;
1788 }
1789 tipc_aead_put(aead);
1790 aead = tipc_aead_get(tmp);
1791 }
1792
1793 if (unlikely(err)) {
1794 tipc_aead_users_dec(aead, INT_MIN);
1795 goto free_skb;
1796 }
1797
1798 /* Set the RX key's user */
1799 tipc_aead_users_set(aead, 1);
1800
1801rcv:
1802 /* Mark this point, RX works */
1803 rx->timer1 = jiffies;
1804
1805 /* Remove ehdr & auth. tag prior to tipc_rcv() */
1806 ehdr = (struct tipc_ehdr *)(*skb)->data;
1807 destined = ehdr->destined;
1808 rx_key_active = ehdr->rx_key_active;
1809 skb_pull(*skb, tipc_ehdr_size(ehdr));
1810 pskb_trim(*skb, (*skb)->len - aead->authsize);
1811
1812 /* Validate TIPCv2 message */
1813 if (unlikely(!tipc_msg_validate(skb))) {
1814 pr_err_ratelimited("Packet dropped after decryption!\n");
1815 goto free_skb;
1816 }
1817
1818 /* Update peer RX active key & TX users */
1819 if (destined)
1820 tipc_crypto_key_synch(rx, rx_key_active, buf_msg(*skb));
1821
1822 /* Mark skb decrypted */
1823 skb_cb->decrypted = 1;
1824
1825 /* Clear clone cxt if any */
1826 if (likely(!skb_cb->tx_clone_deferred))
1827 goto exit;
1828 skb_cb->tx_clone_deferred = 0;
1829 memset(&skb_cb->tx_clone_ctx, 0, sizeof(skb_cb->tx_clone_ctx));
1830 goto exit;
1831
1832free_skb:
1833 kfree_skb(*skb);
1834 *skb = NULL;
1835
1836exit:
1837 tipc_aead_put(aead);
1838 if (rx)
1839 tipc_node_put(rx->node);
1840}
1841
1842static void tipc_crypto_do_cmd(struct net *net, int cmd)
1843{
1844 struct tipc_net *tn = tipc_net(net);
1845 struct tipc_crypto *tx = tn->crypto_tx, *rx;
1846 struct list_head *p;
1847 unsigned int stat;
1848 int i, j, cpu;
1849 char buf[200];
1850
1851 /* Currently only one command is supported */
1852 switch (cmd) {
1853 case 0xfff1:
1854 goto print_stats;
1855 default:
1856 return;
1857 }
1858
1859print_stats:
1860 /* Print a header */
1861 pr_info("\n=============== TIPC Crypto Statistics ===============\n\n");
1862
1863 /* Print key status */
1864 pr_info("Key status:\n");
1865 pr_info("TX(%7.7s)\n%s", tipc_own_id_string(net),
1866 tipc_crypto_key_dump(tx, buf));
1867
1868 rcu_read_lock();
1869 for (p = tn->node_list.next; p != &tn->node_list; p = p->next) {
1870 rx = tipc_node_crypto_rx_by_list(p);
1871 pr_info("RX(%7.7s)\n%s", tipc_node_get_id_str(rx->node),
1872 tipc_crypto_key_dump(rx, buf));
1873 }
1874 rcu_read_unlock();
1875
1876 /* Print crypto statistics */
1877 for (i = 0, j = 0; i < MAX_STATS; i++)
1878 j += scnprintf(buf + j, 200 - j, "|%11s ", hstats[i]);
1879 pr_info("\nCounter %s", buf);
1880
1881 memset(buf, '-', 115);
1882 buf[115] = '\0';
1883 pr_info("%s\n", buf);
1884
1885 j = scnprintf(buf, 200, "TX(%7.7s) ", tipc_own_id_string(net));
1886 for_each_possible_cpu(cpu) {
1887 for (i = 0; i < MAX_STATS; i++) {
1888 stat = per_cpu_ptr(tx->stats, cpu)->stat[i];
1889 j += scnprintf(buf + j, 200 - j, "|%11d ", stat);
1890 }
1891 pr_info("%s", buf);
1892 j = scnprintf(buf, 200, "%12s", " ");
1893 }
1894
1895 rcu_read_lock();
1896 for (p = tn->node_list.next; p != &tn->node_list; p = p->next) {
1897 rx = tipc_node_crypto_rx_by_list(p);
1898 j = scnprintf(buf, 200, "RX(%7.7s) ",
1899 tipc_node_get_id_str(rx->node));
1900 for_each_possible_cpu(cpu) {
1901 for (i = 0; i < MAX_STATS; i++) {
1902 stat = per_cpu_ptr(rx->stats, cpu)->stat[i];
1903 j += scnprintf(buf + j, 200 - j, "|%11d ",
1904 stat);
1905 }
1906 pr_info("%s", buf);
1907 j = scnprintf(buf, 200, "%12s", " ");
1908 }
1909 }
1910 rcu_read_unlock();
1911
1912 pr_info("\n======================== Done ========================\n");
1913}
1914
1915static char *tipc_crypto_key_dump(struct tipc_crypto *c, char *buf)
1916{
1917 struct tipc_key key = c->key;
1918 struct tipc_aead *aead;
1919 int k, i = 0;
1920 char *s;
1921
1922 for (k = KEY_MIN; k <= KEY_MAX; k++) {
1923 if (k == key.passive)
1924 s = "PAS";
1925 else if (k == key.active)
1926 s = "ACT";
1927 else if (k == key.pending)
1928 s = "PEN";
1929 else
1930 s = "-";
1931 i += scnprintf(buf + i, 200 - i, "\tKey%d: %s", k, s);
1932
1933 rcu_read_lock();
1934 aead = rcu_dereference(c->aead[k]);
1935 if (aead)
1936 i += scnprintf(buf + i, 200 - i,
1937 "{\"%s...\", \"%s\"}/%d:%d",
1938 aead->hint,
1939 (aead->mode == CLUSTER_KEY) ? "c" : "p",
1940 atomic_read(&aead->users),
1941 refcount_read(&aead->refcnt));
1942 rcu_read_unlock();
1943 i += scnprintf(buf + i, 200 - i, "\n");
1944 }
1945
1946 if (c->node)
1947 i += scnprintf(buf + i, 200 - i, "\tPeer RX active: %d\n",
1948 atomic_read(&c->peer_rx_active));
1949
1950 return buf;
1951}
1952
1953#ifdef TIPC_CRYPTO_DEBUG
1954static char *tipc_key_change_dump(struct tipc_key old, struct tipc_key new,
1955 char *buf)
1956{
1957 struct tipc_key *key = &old;
1958 int k, i = 0;
1959 char *s;
1960
1961 /* Output format: "[%s %s %s] -> [%s %s %s]", max len = 32 */
1962again:
1963 i += scnprintf(buf + i, 32 - i, "[");
1964 for (k = KEY_MIN; k <= KEY_MAX; k++) {
1965 if (k == key->passive)
1966 s = "pas";
1967 else if (k == key->active)
1968 s = "act";
1969 else if (k == key->pending)
1970 s = "pen";
1971 else
1972 s = "-";
1973 i += scnprintf(buf + i, 32 - i,
1974 (k != KEY_MAX) ? "%s " : "%s", s);
1975 }
1976 if (key != &new) {
1977 i += scnprintf(buf + i, 32 - i, "] -> ");
1978 key = &new;
1979 goto again;
1980 }
1981 i += scnprintf(buf + i, 32 - i, "]");
1982 return buf;
1983}
1984#endif
Empty description
This page took 0.404483 seconds and 4 git commands to generate.