1 // SPDX-License-Identifier: GPL-2.0
3 * net/tipc/crypto.c: TIPC crypto for key handling & packet en/decryption
5 * Copyright (c) 2019, Ericsson AB
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
37 #include <crypto/aead.h>
38 #include <crypto/aes.h>
39 #include <crypto/rng.h>
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 */
49 #define TIPC_MAX_TFMS_DEF 10
50 #define TIPC_MAX_TFMS_LIM 1000
52 #define TIPC_REKEYING_INTV_DEF (60 * 24) /* default: 1 day */
67 * TIPC Crypto statistics
75 STAT_BADKEYS
, /* tx only */
76 STAT_BADMSGS
= STAT_BADKEYS
, /* rx only */
83 /* TIPC crypto statistics' header */
84 static const char *hstats
[MAX_STATS
] = {"ok", "nok", "async", "async_ok",
85 "async_nok", "badmsgs", "nokeys",
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;
94 * struct tipc_key - TIPC keys' status indicator
97 * +-----+-----+-----+-----+-----+-----+-----+-----+
98 * key: | (reserved)|passive idx| active idx|pending idx|
99 * +-----+-----+-----+-----+-----+-----+-----+-----+
103 #define KEY_MASK ((1 << KEY_BITS) - 1)
106 #if defined(__LITTLE_ENDIAN_BITFIELD)
109 passive
:2, /* rx only */
111 #elif defined(__BIG_ENDIAN_BITFIELD)
113 passive
:2, /* rx only */
117 #error "Please fix <asm/byteorder.h>"
125 * struct tipc_tfm - TIPC TFM structure to form a list of TFMs
126 * @tfm: cipher handle/key
127 * @list: linked list of TFMs
130 struct crypto_aead
*tfm
;
131 struct list_head list
;
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
146 * @gen: the key's generation
147 * @seqno: the key seqno (cluster scope)
148 * @refcnt: the key reference counter
151 #define TIPC_AEAD_HINT_LEN (5)
152 struct tipc_tfm
* __percpu
*tfm_entry
;
153 struct tipc_crypto
*crypto
;
154 struct tipc_aead
*cloned
;
159 char hint
[2 * TIPC_AEAD_HINT_LEN
+ 1];
161 struct tipc_aead_key
*key
;
164 atomic64_t seqno ____cacheline_aligned
;
165 refcount_t refcnt ____cacheline_aligned
;
167 } ____cacheline_aligned
;
170 * struct tipc_crypto_stats - TIPC Crypto statistics
171 * @stat: array of crypto statistics
173 struct tipc_crypto_stats
{
174 unsigned int stat
[MAX_STATS
];
178 * struct tipc_crypto - TIPC TX/RX crypto structure
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
205 struct tipc_node
*node
;
206 struct tipc_aead __rcu
*aead
[KEY_MAX
+ 1];
207 atomic_t peer_rx_active
;
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
219 struct tipc_crypto_stats __percpu
*stats
;
222 atomic64_t sndnxt ____cacheline_aligned
;
223 unsigned long timer1
;
224 unsigned long timer2
;
234 spinlock_t lock
; /* crypto lock */
236 } ____cacheline_aligned
;
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
;
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
;
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
,
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
,
282 static int tipc_crypto_key_attach(struct tipc_crypto
*c
,
283 struct tipc_aead
*aead
, u8 pos
,
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
,
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,
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
);
310 #define is_tx(crypto) (!(crypto)->node)
311 #define is_rx(crypto) (!is_tx(crypto))
313 #define key_next(cur) ((cur) % KEY_MAX + 1)
315 #define tipc_aead_rcu_ptr(rcu_ptr, lock) \
316 rcu_dereference_protected((rcu_ptr), lockdep_is_held(lock))
318 #define tipc_aead_rcu_replace(rcu_ptr, ptr, lock) \
320 struct tipc_aead *__tmp = rcu_dereference_protected((rcu_ptr), \
321 lockdep_is_held(lock)); \
322 rcu_assign_pointer((rcu_ptr), (ptr)); \
323 tipc_aead_put(__tmp); \
326 #define tipc_crypto_key_detach(rcu_ptr, lock) \
327 tipc_aead_rcu_replace((rcu_ptr), NULL, lock)
330 * tipc_aead_key_validate - Validate a AEAD user key
331 * @ukey: pointer to user key data
332 * @info: netlink info pointer
334 int tipc_aead_key_validate(struct tipc_aead_key
*ukey
, struct genl_info
*info
)
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?)");
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");
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
;
363 * tipc_aead_key_generate - Generate new session key
364 * @skey: input/output key with new content
366 * Return: 0 in case of success, otherwise < 0
368 static int tipc_aead_key_generate(struct tipc_aead_key
*skey
)
372 /* Fill the key's content with a random value via RNG cipher */
373 rc
= crypto_get_default_rng();
375 rc
= crypto_rng_get_bytes(crypto_default_rng
, skey
->key
,
377 crypto_put_default_rng();
383 static struct tipc_aead
*tipc_aead_get(struct tipc_aead __rcu
*aead
)
385 struct tipc_aead
*tmp
;
388 tmp
= rcu_dereference(aead
);
389 if (unlikely(!tmp
|| !refcount_inc_not_zero(&tmp
->refcnt
)))
396 static inline void tipc_aead_put(struct tipc_aead
*aead
)
398 if (aead
&& refcount_dec_and_test(&aead
->refcnt
))
399 call_rcu(&aead
->rcu
, tipc_aead_free
);
403 * tipc_aead_free - Release AEAD key incl. all the TFMs in the list
404 * @rp: rcu head pointer
406 static void tipc_aead_free(struct rcu_head
*rp
)
408 struct tipc_aead
*aead
= container_of(rp
, struct tipc_aead
, rcu
);
409 struct tipc_tfm
*tfm_entry
, *head
, *tmp
;
412 tipc_aead_put(aead
->cloned
);
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
);
422 crypto_free_aead(head
->tfm
);
423 list_del(&head
->list
);
426 free_percpu(aead
->tfm_entry
);
427 kfree_sensitive(aead
->key
);
431 static int tipc_aead_users(struct tipc_aead __rcu
*aead
)
433 struct tipc_aead
*tmp
;
437 tmp
= rcu_dereference(aead
);
439 users
= atomic_read(&tmp
->users
);
445 static void tipc_aead_users_inc(struct tipc_aead __rcu
*aead
, int lim
)
447 struct tipc_aead
*tmp
;
450 tmp
= rcu_dereference(aead
);
452 atomic_add_unless(&tmp
->users
, 1, lim
);
456 static void tipc_aead_users_dec(struct tipc_aead __rcu
*aead
, int lim
)
458 struct tipc_aead
*tmp
;
461 tmp
= rcu_dereference(aead
);
463 atomic_add_unless(&rcu_dereference(aead
)->users
, -1, lim
);
467 static void tipc_aead_users_set(struct tipc_aead __rcu
*aead
, int val
)
469 struct tipc_aead
*tmp
;
473 tmp
= rcu_dereference(aead
);
476 cur
= atomic_read(&tmp
->users
);
479 } while (atomic_cmpxchg(&tmp
->users
, cur
, val
) != cur
);
485 * tipc_aead_tfm_next - Move TFM entry to the next one in list and return it
486 * @aead: the AEAD key pointer
488 static struct crypto_aead
*tipc_aead_tfm_next(struct tipc_aead
*aead
)
490 struct tipc_tfm
**tfm_entry
;
491 struct crypto_aead
*tfm
;
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
);
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
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.
512 * Return: 0 if the initiation is successful, otherwise: < 0
514 static int tipc_aead_init(struct tipc_aead
**aead
, struct tipc_aead_key
*ukey
,
517 struct tipc_tfm
*tfm_entry
, *head
;
518 struct crypto_aead
*tfm
;
519 struct tipc_aead
*tmp
;
520 int keylen
, err
, cpu
;
526 /* Allocate a new AEAD */
527 tmp
= kzalloc(sizeof(*tmp
), GFP_ATOMIC
);
531 /* The key consists of two parts: [AES-KEY][SALT] */
532 keylen
= ukey
->keylen
- TIPC_AES_GCM_SALT_SIZE
;
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
);
541 /* Make a list of TFMs with the user key data */
543 tfm
= crypto_alloc_aead(ukey
->alg_name
, 0, 0);
549 if (unlikely(!tfm_cnt
&&
550 crypto_aead_ivsize(tfm
) != TIPC_AES_GCM_IV_SIZE
)) {
551 crypto_free_aead(tfm
);
556 err
= crypto_aead_setauthsize(tfm
, TIPC_AES_GCM_TAG_SIZE
);
557 err
|= crypto_aead_setkey(tfm
, ukey
->key
, keylen
);
559 crypto_free_aead(tfm
);
563 tfm_entry
= kmalloc(sizeof(*tfm_entry
), GFP_KERNEL
);
564 if (unlikely(!tfm_entry
)) {
565 crypto_free_aead(tfm
);
569 INIT_LIST_HEAD(&tfm_entry
->list
);
570 tfm_entry
->tfm
= tfm
;
575 for_each_possible_cpu(cpu
) {
576 *per_cpu_ptr(tmp
->tfm_entry
, cpu
) = head
;
579 list_add_tail(&tfm_entry
->list
, &head
->list
);
582 } while (++tfm_cnt
< sysctl_tipc_max_tfms
);
584 /* Not any TFM is allocated? */
586 free_percpu(tmp
->tfm_entry
);
587 kfree_sensitive(tmp
);
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
,
595 /* Initialize the other data */
598 tmp
->authsize
= TIPC_AES_GCM_TAG_SIZE
;
599 tmp
->key
= kmemdup(ukey
, tipc_aead_key_size(ukey
), GFP_KERNEL
);
601 tipc_aead_free(&tmp
->rcu
);
604 memcpy(&tmp
->salt
, ukey
->key
+ keylen
, TIPC_AES_GCM_SALT_SIZE
);
605 atomic_set(&tmp
->users
, 0);
606 atomic64_set(&tmp
->seqno
, 0);
607 refcount_set(&tmp
->refcnt
, 1);
614 * tipc_aead_clone - Clone a TIPC AEAD key
615 * @dst: dest key for the cloning
616 * @src: source key to clone from
618 * Make a "copy" of the source AEAD key data to the dest, the TFMs list is
619 * common for the keys.
620 * A reference to the source is hold in the "cloned" pointer for the later
623 * Note: this must be done in cluster-key mode only!
624 * Return: 0 in case of success, otherwise < 0
626 static int tipc_aead_clone(struct tipc_aead
**dst
, struct tipc_aead
*src
)
628 struct tipc_aead
*aead
;
634 if (src
->mode
!= CLUSTER_KEY
)
640 aead
= kzalloc(sizeof(*aead
), GFP_ATOMIC
);
644 aead
->tfm_entry
= alloc_percpu_gfp(struct tipc_tfm
*, GFP_ATOMIC
);
645 if (unlikely(!aead
->tfm_entry
)) {
646 kfree_sensitive(aead
);
650 for_each_possible_cpu(cpu
) {
651 *per_cpu_ptr(aead
->tfm_entry
, cpu
) =
652 *per_cpu_ptr(src
->tfm_entry
, cpu
);
655 memcpy(aead
->hint
, src
->hint
, sizeof(src
->hint
));
656 aead
->mode
= src
->mode
;
657 aead
->salt
= src
->salt
;
658 aead
->authsize
= src
->authsize
;
659 atomic_set(&aead
->users
, 0);
660 atomic64_set(&aead
->seqno
, 0);
661 refcount_set(&aead
->refcnt
, 1);
663 WARN_ON(!refcount_inc_not_zero(&src
->refcnt
));
671 * tipc_aead_mem_alloc - Allocate memory for AEAD request operations
672 * @tfm: cipher handle to be registered with the request
673 * @crypto_ctx_size: size of crypto context for callback
674 * @iv: returned pointer to IV data
675 * @req: returned pointer to AEAD request data
676 * @sg: returned pointer to SG lists
677 * @nsg: number of SG lists to be allocated
679 * Allocate memory to store the crypto context data, AEAD request, IV and SG
680 * lists, the memory layout is as follows:
681 * crypto_ctx || iv || aead_req || sg[]
683 * Return: the pointer to the memory areas in case of success, otherwise NULL
685 static void *tipc_aead_mem_alloc(struct crypto_aead
*tfm
,
686 unsigned int crypto_ctx_size
,
687 u8
**iv
, struct aead_request
**req
,
688 struct scatterlist
**sg
, int nsg
)
690 unsigned int iv_size
, req_size
;
694 iv_size
= crypto_aead_ivsize(tfm
);
695 req_size
= sizeof(**req
) + crypto_aead_reqsize(tfm
);
697 len
= crypto_ctx_size
;
699 len
+= crypto_aead_alignmask(tfm
) & ~(crypto_tfm_ctx_alignment() - 1);
700 len
= ALIGN(len
, crypto_tfm_ctx_alignment());
702 len
= ALIGN(len
, __alignof__(struct scatterlist
));
703 len
+= nsg
* sizeof(**sg
);
705 mem
= kmalloc(len
, GFP_ATOMIC
);
709 *iv
= (u8
*)PTR_ALIGN(mem
+ crypto_ctx_size
,
710 crypto_aead_alignmask(tfm
) + 1);
711 *req
= (struct aead_request
*)PTR_ALIGN(*iv
+ iv_size
,
712 crypto_tfm_ctx_alignment());
713 *sg
= (struct scatterlist
*)PTR_ALIGN((u8
*)*req
+ req_size
,
714 __alignof__(struct scatterlist
));
720 * tipc_aead_encrypt - Encrypt a message
721 * @aead: TIPC AEAD key for the message encryption
722 * @skb: the input/output skb
723 * @b: TIPC bearer where the message will be delivered after the encryption
724 * @dst: the destination media address
725 * @__dnode: TIPC dest node if "known"
728 * * 0 : if the encryption has completed
729 * * -EINPROGRESS/-EBUSY : if a callback will be performed
730 * * < 0 : the encryption has failed
732 static int tipc_aead_encrypt(struct tipc_aead
*aead
, struct sk_buff
*skb
,
733 struct tipc_bearer
*b
,
734 struct tipc_media_addr
*dst
,
735 struct tipc_node
*__dnode
)
737 struct crypto_aead
*tfm
= tipc_aead_tfm_next(aead
);
738 struct tipc_crypto_tx_ctx
*tx_ctx
;
739 struct aead_request
*req
;
740 struct sk_buff
*trailer
;
741 struct scatterlist
*sg
;
742 struct tipc_ehdr
*ehdr
;
743 int ehsz
, len
, tailen
, nsg
, rc
;
748 /* Make sure message len at least 4-byte aligned */
749 len
= ALIGN(skb
->len
, 4);
750 tailen
= len
- skb
->len
+ aead
->authsize
;
752 /* Expand skb tail for authentication tag:
753 * As for simplicity, we'd have made sure skb having enough tailroom
754 * for authentication tag @skb allocation. Even when skb is nonlinear
755 * but there is no frag_list, it should be still fine!
756 * Otherwise, we must cow it to be a writable buffer with the tailroom.
758 SKB_LINEAR_ASSERT(skb
);
759 if (tailen
> skb_tailroom(skb
)) {
760 pr_debug("TX(): skb tailroom is not enough: %d, requires: %d\n",
761 skb_tailroom(skb
), tailen
);
764 if (unlikely(!skb_cloned(skb
) && tailen
<= skb_tailroom(skb
))) {
768 /* TODO: We could avoid skb_cow_data() if skb has no frag_list
769 * e.g. by skb_fill_page_desc() to add another page to the skb
770 * with the wanted tailen... However, page skbs look not often,
771 * so take it easy now!
772 * Cloned skbs e.g. from link_xmit() seems no choice though :(
774 nsg
= skb_cow_data(skb
, tailen
, &trailer
);
775 if (unlikely(nsg
< 0)) {
776 pr_err("TX: skb_cow_data() returned %d\n", nsg
);
781 pskb_put(skb
, trailer
, tailen
);
783 /* Allocate memory for the AEAD operation */
784 ctx
= tipc_aead_mem_alloc(tfm
, sizeof(*tx_ctx
), &iv
, &req
, &sg
, nsg
);
787 TIPC_SKB_CB(skb
)->crypto_ctx
= ctx
;
789 /* Map skb to the sg lists */
790 sg_init_table(sg
, nsg
);
791 rc
= skb_to_sgvec(skb
, sg
, 0, skb
->len
);
792 if (unlikely(rc
< 0)) {
793 pr_err("TX: skb_to_sgvec() returned %d, nsg %d!\n", rc
, nsg
);
797 /* Prepare IV: [SALT (4 octets)][SEQNO (8 octets)]
798 * In case we're in cluster-key mode, SALT is varied by xor-ing with
799 * the source address (or w0 of id), otherwise with the dest address
802 ehdr
= (struct tipc_ehdr
*)skb
->data
;
804 if (aead
->mode
== CLUSTER_KEY
)
805 salt
^= __be32_to_cpu(ehdr
->addr
);
807 salt
^= tipc_node_get_addr(__dnode
);
808 memcpy(iv
, &salt
, 4);
809 memcpy(iv
+ 4, (u8
*)&ehdr
->seqno
, 8);
811 /* Prepare request */
812 ehsz
= tipc_ehdr_size(ehdr
);
813 aead_request_set_tfm(req
, tfm
);
814 aead_request_set_ad(req
, ehsz
);
815 aead_request_set_crypt(req
, sg
, sg
, len
- ehsz
, iv
);
817 /* Set callback function & data */
818 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
819 tipc_aead_encrypt_done
, skb
);
820 tx_ctx
= (struct tipc_crypto_tx_ctx
*)ctx
;
823 memcpy(&tx_ctx
->dst
, dst
, sizeof(*dst
));
826 if (unlikely(!tipc_bearer_hold(b
))) {
831 /* Now, do encrypt */
832 rc
= crypto_aead_encrypt(req
);
833 if (rc
== -EINPROGRESS
|| rc
== -EBUSY
)
840 TIPC_SKB_CB(skb
)->crypto_ctx
= NULL
;
844 static void tipc_aead_encrypt_done(struct crypto_async_request
*base
, int err
)
846 struct sk_buff
*skb
= base
->data
;
847 struct tipc_crypto_tx_ctx
*tx_ctx
= TIPC_SKB_CB(skb
)->crypto_ctx
;
848 struct tipc_bearer
*b
= tx_ctx
->bearer
;
849 struct tipc_aead
*aead
= tx_ctx
->aead
;
850 struct tipc_crypto
*tx
= aead
->crypto
;
851 struct net
*net
= tx
->net
;
855 this_cpu_inc(tx
->stats
->stat
[STAT_ASYNC_OK
]);
857 if (likely(test_bit(0, &b
->up
)))
858 b
->media
->send_msg(net
, skb
, b
, &tx_ctx
->dst
);
866 this_cpu_inc(tx
->stats
->stat
[STAT_ASYNC_NOK
]);
877 * tipc_aead_decrypt - Decrypt an encrypted message
879 * @aead: TIPC AEAD for the message decryption
880 * @skb: the input/output skb
881 * @b: TIPC bearer where the message has been received
884 * * 0 : if the decryption has completed
885 * * -EINPROGRESS/-EBUSY : if a callback will be performed
886 * * < 0 : the decryption has failed
888 static int tipc_aead_decrypt(struct net
*net
, struct tipc_aead
*aead
,
889 struct sk_buff
*skb
, struct tipc_bearer
*b
)
891 struct tipc_crypto_rx_ctx
*rx_ctx
;
892 struct aead_request
*req
;
893 struct crypto_aead
*tfm
;
894 struct sk_buff
*unused
;
895 struct scatterlist
*sg
;
896 struct tipc_ehdr
*ehdr
;
905 nsg
= skb_cow_data(skb
, 0, &unused
);
906 if (unlikely(nsg
< 0)) {
907 pr_err("RX: skb_cow_data() returned %d\n", nsg
);
911 /* Allocate memory for the AEAD operation */
912 tfm
= tipc_aead_tfm_next(aead
);
913 ctx
= tipc_aead_mem_alloc(tfm
, sizeof(*rx_ctx
), &iv
, &req
, &sg
, nsg
);
916 TIPC_SKB_CB(skb
)->crypto_ctx
= ctx
;
918 /* Map skb to the sg lists */
919 sg_init_table(sg
, nsg
);
920 rc
= skb_to_sgvec(skb
, sg
, 0, skb
->len
);
921 if (unlikely(rc
< 0)) {
922 pr_err("RX: skb_to_sgvec() returned %d, nsg %d\n", rc
, nsg
);
926 /* Reconstruct IV: */
927 ehdr
= (struct tipc_ehdr
*)skb
->data
;
929 if (aead
->mode
== CLUSTER_KEY
)
930 salt
^= __be32_to_cpu(ehdr
->addr
);
931 else if (ehdr
->destined
)
932 salt
^= tipc_own_addr(net
);
933 memcpy(iv
, &salt
, 4);
934 memcpy(iv
+ 4, (u8
*)&ehdr
->seqno
, 8);
936 /* Prepare request */
937 ehsz
= tipc_ehdr_size(ehdr
);
938 aead_request_set_tfm(req
, tfm
);
939 aead_request_set_ad(req
, ehsz
);
940 aead_request_set_crypt(req
, sg
, sg
, skb
->len
- ehsz
, iv
);
942 /* Set callback function & data */
943 aead_request_set_callback(req
, CRYPTO_TFM_REQ_MAY_BACKLOG
,
944 tipc_aead_decrypt_done
, skb
);
945 rx_ctx
= (struct tipc_crypto_rx_ctx
*)ctx
;
950 if (unlikely(!tipc_bearer_hold(b
))) {
955 /* Now, do decrypt */
956 rc
= crypto_aead_decrypt(req
);
957 if (rc
== -EINPROGRESS
|| rc
== -EBUSY
)
964 TIPC_SKB_CB(skb
)->crypto_ctx
= NULL
;
968 static void tipc_aead_decrypt_done(struct crypto_async_request
*base
, int err
)
970 struct sk_buff
*skb
= base
->data
;
971 struct tipc_crypto_rx_ctx
*rx_ctx
= TIPC_SKB_CB(skb
)->crypto_ctx
;
972 struct tipc_bearer
*b
= rx_ctx
->bearer
;
973 struct tipc_aead
*aead
= rx_ctx
->aead
;
974 struct tipc_crypto_stats __percpu
*stats
= aead
->crypto
->stats
;
975 struct net
*net
= aead
->crypto
->net
;
979 this_cpu_inc(stats
->stat
[STAT_ASYNC_OK
]);
984 this_cpu_inc(stats
->stat
[STAT_ASYNC_NOK
]);
989 tipc_crypto_rcv_complete(net
, aead
, b
, &skb
, err
);
991 if (likely(test_bit(0, &b
->up
)))
992 tipc_rcv(net
, skb
, b
);
1000 static inline int tipc_ehdr_size(struct tipc_ehdr
*ehdr
)
1002 return (ehdr
->user
!= LINK_CONFIG
) ? EHDR_SIZE
: EHDR_CFG_SIZE
;
1006 * tipc_ehdr_validate - Validate an encryption message
1007 * @skb: the message buffer
1009 * Return: "true" if this is a valid encryption message, otherwise "false"
1011 bool tipc_ehdr_validate(struct sk_buff
*skb
)
1013 struct tipc_ehdr
*ehdr
;
1016 if (unlikely(!pskb_may_pull(skb
, EHDR_MIN_SIZE
)))
1019 ehdr
= (struct tipc_ehdr
*)skb
->data
;
1020 if (unlikely(ehdr
->version
!= TIPC_EVERSION
))
1022 ehsz
= tipc_ehdr_size(ehdr
);
1023 if (unlikely(!pskb_may_pull(skb
, ehsz
)))
1025 if (unlikely(skb
->len
<= ehsz
+ TIPC_AES_GCM_TAG_SIZE
))
1032 * tipc_ehdr_build - Build TIPC encryption message header
1034 * @aead: TX AEAD key to be used for the message encryption
1035 * @tx_key: key id used for the message encryption
1036 * @skb: input/output message skb
1037 * @__rx: RX crypto handle if dest is "known"
1039 * Return: the header size if the building is successful, otherwise < 0
1041 static int tipc_ehdr_build(struct net
*net
, struct tipc_aead
*aead
,
1042 u8 tx_key
, struct sk_buff
*skb
,
1043 struct tipc_crypto
*__rx
)
1045 struct tipc_msg
*hdr
= buf_msg(skb
);
1046 struct tipc_ehdr
*ehdr
;
1047 u32 user
= msg_user(hdr
);
1051 /* Make room for encryption header */
1052 ehsz
= (user
!= LINK_CONFIG
) ? EHDR_SIZE
: EHDR_CFG_SIZE
;
1053 WARN_ON(skb_headroom(skb
) < ehsz
);
1054 ehdr
= (struct tipc_ehdr
*)skb_push(skb
, ehsz
);
1056 /* Obtain a seqno first:
1057 * Use the key seqno (= cluster wise) if dest is unknown or we're in
1058 * cluster key mode, otherwise it's better for a per-peer seqno!
1060 if (!__rx
|| aead
->mode
== CLUSTER_KEY
)
1061 seqno
= atomic64_inc_return(&aead
->seqno
);
1063 seqno
= atomic64_inc_return(&__rx
->sndnxt
);
1065 /* Revoke the key if seqno is wrapped around */
1066 if (unlikely(!seqno
))
1067 return tipc_crypto_key_revoke(net
, tx_key
);
1070 ehdr
->seqno
= cpu_to_be64(seqno
);
1073 ehdr
->version
= TIPC_EVERSION
;
1075 ehdr
->keepalive
= 0;
1076 ehdr
->tx_key
= tx_key
;
1077 ehdr
->destined
= (__rx
) ? 1 : 0;
1078 ehdr
->rx_key_active
= (__rx
) ? __rx
->key
.active
: 0;
1079 ehdr
->rx_nokey
= (__rx
) ? __rx
->nokey
: 0;
1080 ehdr
->master_key
= aead
->crypto
->key_master
;
1081 ehdr
->reserved_1
= 0;
1082 ehdr
->reserved_2
= 0;
1086 ehdr
->user
= LINK_CONFIG
;
1087 memcpy(ehdr
->id
, tipc_own_id(net
), NODE_ID_LEN
);
1090 if (user
== LINK_PROTOCOL
&& msg_type(hdr
) == STATE_MSG
) {
1091 ehdr
->user
= LINK_PROTOCOL
;
1092 ehdr
->keepalive
= msg_is_keepalive(hdr
);
1094 ehdr
->addr
= hdr
->hdr
[3];
1101 static inline void tipc_crypto_key_set_state(struct tipc_crypto
*c
,
1106 struct tipc_key old
= c
->key
;
1109 c
->key
.keys
= ((new_passive
& KEY_MASK
) << (KEY_BITS
* 2)) |
1110 ((new_active
& KEY_MASK
) << (KEY_BITS
)) |
1111 ((new_pending
& KEY_MASK
));
1113 pr_debug("%s: key changing %s ::%pS\n", c
->name
,
1114 tipc_key_change_dump(old
, c
->key
, buf
),
1115 __builtin_return_address(0));
1119 * tipc_crypto_key_init - Initiate a new user / AEAD key
1120 * @c: TIPC crypto to which new key is attached
1121 * @ukey: the user key
1122 * @mode: the key mode (CLUSTER_KEY or PER_NODE_KEY)
1123 * @master_key: specify this is a cluster master key
1125 * A new TIPC AEAD key will be allocated and initiated with the specified user
1126 * key, then attached to the TIPC crypto.
1128 * Return: new key id in case of success, otherwise: < 0
1130 int tipc_crypto_key_init(struct tipc_crypto
*c
, struct tipc_aead_key
*ukey
,
1131 u8 mode
, bool master_key
)
1133 struct tipc_aead
*aead
= NULL
;
1136 /* Initiate with the new user key */
1137 rc
= tipc_aead_init(&aead
, ukey
, mode
);
1139 /* Attach it to the crypto */
1141 rc
= tipc_crypto_key_attach(c
, aead
, 0, master_key
);
1143 tipc_aead_free(&aead
->rcu
);
1150 * tipc_crypto_key_attach - Attach a new AEAD key to TIPC crypto
1151 * @c: TIPC crypto to which the new AEAD key is attached
1152 * @aead: the new AEAD key pointer
1153 * @pos: desired slot in the crypto key array, = 0 if any!
1154 * @master_key: specify this is a cluster master key
1156 * Return: new key id in case of success, otherwise: -EBUSY
1158 static int tipc_crypto_key_attach(struct tipc_crypto
*c
,
1159 struct tipc_aead
*aead
, u8 pos
,
1162 struct tipc_key key
;
1166 spin_lock_bh(&c
->lock
);
1169 new_key
= KEY_MASTER
;
1172 if (key
.active
&& key
.passive
)
1175 if (tipc_aead_users(c
->aead
[key
.pending
]) > 0)
1177 /* if (pos): ok with replacing, will be aligned when needed */
1179 new_key
= key
.pending
;
1182 if (key
.active
&& pos
!= key_next(key
.active
)) {
1186 } else if (!key
.active
&& !key
.passive
) {
1192 key
.pending
= key_next(key
.active
?: key
.passive
);
1193 new_key
= key
.pending
;
1198 aead
->gen
= (is_tx(c
)) ? ++c
->key_gen
: c
->key_gen
;
1199 tipc_aead_rcu_replace(c
->aead
[new_key
], aead
, &c
->lock
);
1200 if (likely(c
->key
.keys
!= key
.keys
))
1201 tipc_crypto_key_set_state(c
, key
.passive
, key
.active
,
1205 c
->key_master
|= master_key
;
1209 spin_unlock_bh(&c
->lock
);
1213 void tipc_crypto_key_flush(struct tipc_crypto
*c
)
1215 struct tipc_crypto
*tx
, *rx
;
1218 spin_lock_bh(&c
->lock
);
1220 /* Try to cancel pending work */
1222 tx
= tipc_net(rx
->net
)->crypto_tx
;
1223 if (cancel_delayed_work(&rx
->work
)) {
1226 atomic_xchg(&rx
->key_distr
, 0);
1227 tipc_node_put(rx
->node
);
1229 /* RX stopping => decrease TX key users if any */
1230 k
= atomic_xchg(&rx
->peer_rx_active
, 0);
1232 tipc_aead_users_dec(tx
->aead
[k
], 0);
1233 /* Mark the point TX key users changed */
1234 tx
->timer1
= jiffies
;
1239 tipc_crypto_key_set_state(c
, 0, 0, 0);
1240 for (k
= KEY_MIN
; k
<= KEY_MAX
; k
++)
1241 tipc_crypto_key_detach(c
->aead
[k
], &c
->lock
);
1242 atomic64_set(&c
->sndnxt
, 0);
1243 spin_unlock_bh(&c
->lock
);
1247 * tipc_crypto_key_try_align - Align RX keys if possible
1248 * @rx: RX crypto handle
1249 * @new_pending: new pending slot if aligned (= TX key from peer)
1251 * Peer has used an unknown key slot, this only happens when peer has left and
1252 * rejoned, or we are newcomer.
1253 * That means, there must be no active key but a pending key at unaligned slot.
1254 * If so, we try to move the pending key to the new slot.
1255 * Note: A potential passive key can exist, it will be shifted correspondingly!
1257 * Return: "true" if key is successfully aligned, otherwise "false"
1259 static bool tipc_crypto_key_try_align(struct tipc_crypto
*rx
, u8 new_pending
)
1261 struct tipc_aead
*tmp1
, *tmp2
= NULL
;
1262 struct tipc_key key
;
1263 bool aligned
= false;
1267 spin_lock(&rx
->lock
);
1269 if (key
.pending
== new_pending
) {
1277 if (tipc_aead_users(rx
->aead
[key
.pending
]) > 0)
1280 /* Try to "isolate" this pending key first */
1281 tmp1
= tipc_aead_rcu_ptr(rx
->aead
[key
.pending
], &rx
->lock
);
1282 if (!refcount_dec_if_one(&tmp1
->refcnt
))
1284 rcu_assign_pointer(rx
->aead
[key
.pending
], NULL
);
1286 /* Move passive key if any */
1288 tmp2
= rcu_replace_pointer(rx
->aead
[key
.passive
], tmp2
, lockdep_is_held(&rx
->lock
));
1289 x
= (key
.passive
- key
.pending
+ new_pending
) % KEY_MAX
;
1290 new_passive
= (x
<= 0) ? x
+ KEY_MAX
: x
;
1293 /* Re-allocate the key(s) */
1294 tipc_crypto_key_set_state(rx
, new_passive
, 0, new_pending
);
1295 rcu_assign_pointer(rx
->aead
[new_pending
], tmp1
);
1297 rcu_assign_pointer(rx
->aead
[new_passive
], tmp2
);
1298 refcount_set(&tmp1
->refcnt
, 1);
1300 pr_info_ratelimited("%s: key[%d] -> key[%d]\n", rx
->name
, key
.pending
,
1304 spin_unlock(&rx
->lock
);
1309 * tipc_crypto_key_pick_tx - Pick one TX key for message decryption
1310 * @tx: TX crypto handle
1311 * @rx: RX crypto handle (can be NULL)
1312 * @skb: the message skb which will be decrypted later
1313 * @tx_key: peer TX key id
1315 * This function looks up the existing TX keys and pick one which is suitable
1316 * for the message decryption, that must be a cluster key and not used before
1317 * on the same message (i.e. recursive).
1319 * Return: the TX AEAD key handle in case of success, otherwise NULL
1321 static struct tipc_aead
*tipc_crypto_key_pick_tx(struct tipc_crypto
*tx
,
1322 struct tipc_crypto
*rx
,
1323 struct sk_buff
*skb
,
1326 struct tipc_skb_cb
*skb_cb
= TIPC_SKB_CB(skb
);
1327 struct tipc_aead
*aead
= NULL
;
1328 struct tipc_key key
= tx
->key
;
1331 /* Initialize data if not yet */
1332 if (!skb_cb
->tx_clone_deferred
) {
1333 skb_cb
->tx_clone_deferred
= 1;
1334 memset(&skb_cb
->tx_clone_ctx
, 0, sizeof(skb_cb
->tx_clone_ctx
));
1337 skb_cb
->tx_clone_ctx
.rx
= rx
;
1338 if (++skb_cb
->tx_clone_ctx
.recurs
> 2)
1341 /* Pick one TX key */
1342 spin_lock(&tx
->lock
);
1343 if (tx_key
== KEY_MASTER
) {
1344 aead
= tipc_aead_rcu_ptr(tx
->aead
[KEY_MASTER
], &tx
->lock
);
1348 k
= (i
== 0) ? key
.pending
:
1349 ((i
== 1) ? key
.active
: key
.passive
);
1352 aead
= tipc_aead_rcu_ptr(tx
->aead
[k
], &tx
->lock
);
1355 if (aead
->mode
!= CLUSTER_KEY
||
1356 aead
== skb_cb
->tx_clone_ctx
.last
) {
1360 /* Ok, found one cluster key */
1361 skb_cb
->tx_clone_ctx
.last
= aead
;
1363 skb
->next
= skb_clone(skb
, GFP_ATOMIC
);
1364 if (unlikely(!skb
->next
))
1365 pr_warn("Failed to clone skb for next round if any\n");
1371 WARN_ON(!refcount_inc_not_zero(&aead
->refcnt
));
1372 spin_unlock(&tx
->lock
);
1378 * tipc_crypto_key_synch: Synch own key data according to peer key status
1379 * @rx: RX crypto handle
1380 * @skb: TIPCv2 message buffer (incl. the ehdr from peer)
1382 * This function updates the peer node related data as the peer RX active key
1383 * has changed, so the number of TX keys' users on this node are increased and
1384 * decreased correspondingly.
1386 * It also considers if peer has no key, then we need to make own master key
1387 * (if any) taking over i.e. starting grace period and also trigger key
1388 * distributing process.
1390 * The "per-peer" sndnxt is also reset when the peer key has switched.
1392 static void tipc_crypto_key_synch(struct tipc_crypto
*rx
, struct sk_buff
*skb
)
1394 struct tipc_ehdr
*ehdr
= (struct tipc_ehdr
*)skb_network_header(skb
);
1395 struct tipc_crypto
*tx
= tipc_net(rx
->net
)->crypto_tx
;
1396 struct tipc_msg
*hdr
= buf_msg(skb
);
1397 u32 self
= tipc_own_addr(rx
->net
);
1399 unsigned long delay
;
1401 /* Update RX 'key_master' flag according to peer, also mark "legacy" if
1402 * a peer has no master key.
1404 rx
->key_master
= ehdr
->master_key
;
1405 if (!rx
->key_master
)
1406 tx
->legacy_user
= 1;
1408 /* For later cases, apply only if message is destined to this node */
1409 if (!ehdr
->destined
|| msg_short(hdr
) || msg_destnode(hdr
) != self
)
1412 /* Case 1: Peer has no keys, let's make master key take over */
1413 if (ehdr
->rx_nokey
) {
1414 /* Set or extend grace period */
1415 tx
->timer2
= jiffies
;
1416 /* Schedule key distributing for the peer if not yet */
1418 !atomic_cmpxchg(&rx
->key_distr
, 0, KEY_DISTR_SCHED
)) {
1419 get_random_bytes(&delay
, 2);
1421 delay
= msecs_to_jiffies(500 * ++delay
);
1422 if (queue_delayed_work(tx
->wq
, &rx
->work
, delay
))
1423 tipc_node_get(rx
->node
);
1426 /* Cancel a pending key distributing if any */
1427 atomic_xchg(&rx
->key_distr
, 0);
1430 /* Case 2: Peer RX active key has changed, let's update own TX users */
1431 cur
= atomic_read(&rx
->peer_rx_active
);
1432 new = ehdr
->rx_key_active
;
1435 atomic_cmpxchg(&rx
->peer_rx_active
, cur
, new) == cur
) {
1437 tipc_aead_users_inc(tx
->aead
[new], INT_MAX
);
1439 tipc_aead_users_dec(tx
->aead
[cur
], 0);
1441 atomic64_set(&rx
->sndnxt
, 0);
1442 /* Mark the point TX key users changed */
1443 tx
->timer1
= jiffies
;
1445 pr_debug("%s: key users changed %d-- %d++, peer %s\n",
1446 tx
->name
, cur
, new, rx
->name
);
1450 static int tipc_crypto_key_revoke(struct net
*net
, u8 tx_key
)
1452 struct tipc_crypto
*tx
= tipc_net(net
)->crypto_tx
;
1453 struct tipc_key key
;
1455 spin_lock(&tx
->lock
);
1457 WARN_ON(!key
.active
|| tx_key
!= key
.active
);
1459 /* Free the active key */
1460 tipc_crypto_key_set_state(tx
, key
.passive
, 0, key
.pending
);
1461 tipc_crypto_key_detach(tx
->aead
[key
.active
], &tx
->lock
);
1462 spin_unlock(&tx
->lock
);
1464 pr_warn("%s: key is revoked\n", tx
->name
);
1465 return -EKEYREVOKED
;
1468 int tipc_crypto_start(struct tipc_crypto
**crypto
, struct net
*net
,
1469 struct tipc_node
*node
)
1471 struct tipc_crypto
*c
;
1476 /* Allocate crypto */
1477 c
= kzalloc(sizeof(*c
), GFP_ATOMIC
);
1481 /* Allocate workqueue on TX */
1483 c
->wq
= alloc_ordered_workqueue("tipc_crypto", 0);
1490 /* Allocate statistic structure */
1491 c
->stats
= alloc_percpu_gfp(struct tipc_crypto_stats
, GFP_ATOMIC
);
1494 destroy_workqueue(c
->wq
);
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
));
1516 INIT_DELAYED_WORK(&c
->work
, tipc_crypto_work_rx
);
1518 INIT_DELAYED_WORK(&c
->work
, tipc_crypto_work_tx
);
1524 void tipc_crypto_stop(struct tipc_crypto
**crypto
)
1526 struct tipc_crypto
*c
= *crypto
;
1532 /* Flush any queued works & destroy wq */
1534 c
->rekeying_intv
= 0;
1535 cancel_delayed_work_sync(&c
->work
);
1536 destroy_workqueue(c
->wq
);
1539 /* Release AEAD keys */
1541 for (k
= KEY_MIN
; k
<= KEY_MAX
; k
++)
1542 tipc_aead_put(rcu_dereference(c
->aead
[k
]));
1544 pr_debug("%s: has been stopped\n", c
->name
);
1546 /* Free this crypto statistics */
1547 free_percpu(c
->stats
);
1553 void tipc_crypto_timeout(struct tipc_crypto
*rx
)
1555 struct tipc_net
*tn
= tipc_net(rx
->net
);
1556 struct tipc_crypto
*tx
= tn
->crypto_tx
;
1557 struct tipc_key key
;
1560 /* TX pending: taking all users & stable -> active */
1561 spin_lock(&tx
->lock
);
1563 if (key
.active
&& tipc_aead_users(tx
->aead
[key
.active
]) > 0)
1565 if (!key
.pending
|| tipc_aead_users(tx
->aead
[key
.pending
]) <= 0)
1567 if (time_before(jiffies
, tx
->timer1
+ TIPC_TX_LASTING_TIME
))
1570 tipc_crypto_key_set_state(tx
, key
.passive
, key
.pending
, 0);
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
);
1577 spin_unlock(&tx
->lock
);
1579 /* RX pending: having user -> active */
1580 spin_lock(&rx
->lock
);
1582 if (!key
.pending
|| tipc_aead_users(rx
->aead
[key
.pending
]) <= 0)
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
);
1595 /* RX pending: not working -> remove */
1596 if (!key
.pending
|| tipc_aead_users(rx
->aead
[key
.pending
]) > -10)
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
);
1605 /* RX active: timed out or no user -> pending */
1608 if (time_before(jiffies
, rx
->timer1
+ TIPC_RX_ACTIVE_LIM
) &&
1609 tipc_aead_users(rx
->aead
[key
.active
]) > 0)
1613 key
.passive
= key
.active
;
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
);
1623 /* RX passive: outdated or not working -> free */
1626 if (time_before(jiffies
, rx
->timer2
+ TIPC_RX_PASSIVE_LIM
) &&
1627 tipc_aead_users(rx
->aead
[key
.passive
]) > -10)
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
);
1635 spin_unlock(&rx
->lock
);
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!
1640 if (time_after(jiffies
, tx
->timer2
+ TIPC_TX_GRACE_PERIOD
))
1641 tx
->legacy_user
= 0;
1643 /* Limit max_tfms & do debug commands if needed */
1644 if (likely(sysctl_tipc_max_tfms
<= TIPC_MAX_TFMS_LIM
))
1647 cmd
= sysctl_tipc_max_tfms
;
1648 sysctl_tipc_max_tfms
= TIPC_MAX_TFMS_DEF
;
1649 tipc_crypto_do_cmd(rx
->net
, cmd
);
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
)
1657 struct sk_buff
*skb
;
1659 skb
= skb_clone(_skb
, GFP_ATOMIC
);
1661 TIPC_SKB_CB(skb
)->xmit_type
= type
;
1662 tipc_crypto_xmit(net
, &skb
, b
, dst
, __dnode
);
1664 b
->media
->send_msg(net
, skb
, b
, dst
);
1669 * tipc_crypto_xmit - Build & encrypt TIPC message for xmit
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
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
1681 * Otherwise, the skb is freed!
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
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
)
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
);
1706 /* No encryption? */
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
)
1715 if (__rx
&& atomic_read(&__rx
->peer_rx_active
) == tx_key
)
1717 if (TIPC_SKB_CB(*skb
)->xmit_type
== SKB_PROBING
) {
1718 pr_debug("%s: probing for key[%d]\n", tx
->name
,
1722 if (user
== LINK_CONFIG
|| user
== LINK_PROTOCOL
)
1723 tipc_crypto_clone_msg(net
, *skb
, b
, dst
, __dnode
,
1727 /* Master key if this is a *vital* message or in grace period */
1728 if (tx
->key_master
) {
1729 tx_key
= KEY_MASTER
;
1732 if (TIPC_SKB_CB(*skb
)->xmit_type
== SKB_GRACING
) {
1733 pr_debug("%s: gracing for msg (%d %d)\n", tx
->name
,
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
))
1745 if (likely(!tx
->legacy_user
))
1747 tipc_crypto_clone_msg(net
, *skb
, b
, dst
,
1748 __dnode
, SKB_GRACING
);
1753 /* Else, use the active key if any */
1754 if (likely(key
.active
)) {
1755 tx_key
= key
.active
;
1762 aead
= tipc_aead_get(tx
->aead
[tx_key
]);
1763 if (unlikely(!aead
))
1765 rc
= tipc_ehdr_build(net
, aead
, tx_key
, *skb
, __rx
);
1767 rc
= tipc_aead_encrypt(aead
, *skb
, b
, dst
, __dnode
);
1772 this_cpu_inc(stats
->stat
[STAT_OK
]);
1776 this_cpu_inc(stats
->stat
[STAT_ASYNC
]);
1780 this_cpu_inc(stats
->stat
[STAT_NOK
]);
1782 this_cpu_inc(stats
->stat
[STAT_NOKEYS
]);
1783 else if (rc
== -EKEYREVOKED
)
1784 this_cpu_inc(stats
->stat
[STAT_BADKEYS
]);
1790 tipc_aead_put(aead
);
1795 * tipc_crypto_rcv - Decrypt an encrypted TIPC message from peer
1797 * @rx: RX crypto handle
1798 * @skb: input/output message skb pointer
1799 * @b: bearer where the message has been received
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).
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
1816 int tipc_crypto_rcv(struct net
*net
, struct tipc_crypto
*rx
,
1817 struct sk_buff
**skb
, struct tipc_bearer
*b
)
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
;
1826 tx_key
= ((struct tipc_ehdr
*)(*skb
)->data
)->tx_key
;
1829 * Let's try with TX key (i.e. cluster mode) & verify the skb first!
1831 if (unlikely(!rx
|| tx_key
== KEY_MASTER
))
1834 /* Pick RX key according to TX key if any */
1836 if (tx_key
== key
.active
|| tx_key
== key
.pending
||
1837 tx_key
== key
.passive
)
1840 /* Unknown key, let's try to align RX key(s) */
1841 if (tipc_crypto_key_try_align(rx
, tx_key
))
1845 /* No key suitable? Try to pick one from TX... */
1846 aead
= tipc_crypto_key_pick_tx(tx
, rx
, *skb
, tx_key
);
1854 aead
= tipc_aead_get(rx
->aead
[tx_key
]);
1855 rc
= tipc_aead_decrypt(net
, aead
, *skb
, b
);
1859 stats
= ((rx
) ?: tx
)->stats
;
1862 this_cpu_inc(stats
->stat
[STAT_OK
]);
1866 this_cpu_inc(stats
->stat
[STAT_ASYNC
]);
1870 this_cpu_inc(stats
->stat
[STAT_NOK
]);
1871 if (rc
== -ENOKEY
) {
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.
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
);
1887 this_cpu_inc(stats
->stat
[STAT_NOKEYS
]);
1889 } else if (rc
== -EBADMSG
) {
1890 this_cpu_inc(stats
->stat
[STAT_BADMSGS
]);
1895 tipc_crypto_rcv_complete(net
, aead
, b
, skb
, rc
);
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
)
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
;
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
);
1925 if (likely((*skb
)->next
)) {
1926 kfree_skb((*skb
)->next
);
1927 (*skb
)->next
= NULL
;
1929 ehdr
= (struct tipc_ehdr
*)(*skb
)->data
;
1931 WARN_ON(ehdr
->user
!= LINK_CONFIG
);
1932 n
= tipc_node_create(net
, 0, ehdr
->id
, 0xffffu
, 0,
1934 rx
= tipc_node_crypto_rx(n
);
1939 /* Ignore cloning if it was TX master key */
1940 if (ehdr
->tx_key
== KEY_MASTER
)
1942 if (tipc_aead_clone(&tmp
, aead
) < 0)
1944 WARN_ON(!refcount_inc_not_zero(&tmp
->refcnt
));
1945 if (tipc_crypto_key_attach(rx
, tmp
, ehdr
->tx_key
, false) < 0) {
1946 tipc_aead_free(&tmp
->rcu
);
1949 tipc_aead_put(aead
);
1953 if (unlikely(err
)) {
1954 tipc_aead_users_dec((struct tipc_aead __force __rcu
*)aead
, INT_MIN
);
1958 /* Set the RX key's user */
1959 tipc_aead_users_set((struct tipc_aead __force __rcu
*)aead
, 1);
1961 /* Mark this point, RX works */
1962 rx
->timer1
= jiffies
;
1965 /* Remove ehdr & auth. tag prior to tipc_rcv() */
1966 ehdr
= (struct tipc_ehdr
*)(*skb
)->data
;
1968 /* Mark this point, RX passive still works */
1969 if (rx
->key
.passive
&& ehdr
->tx_key
== rx
->key
.passive
)
1970 rx
->timer2
= jiffies
;
1972 skb_reset_network_header(*skb
);
1973 skb_pull(*skb
, tipc_ehdr_size(ehdr
));
1974 pskb_trim(*skb
, (*skb
)->len
- aead
->authsize
);
1976 /* Validate TIPCv2 message */
1977 if (unlikely(!tipc_msg_validate(skb
))) {
1978 pr_err_ratelimited("Packet dropped after decryption!\n");
1982 /* Ok, everything's fine, try to synch own keys according to peers' */
1983 tipc_crypto_key_synch(rx
, *skb
);
1985 /* Mark skb decrypted */
1986 skb_cb
->decrypted
= 1;
1988 /* Clear clone cxt if any */
1989 if (likely(!skb_cb
->tx_clone_deferred
))
1991 skb_cb
->tx_clone_deferred
= 0;
1992 memset(&skb_cb
->tx_clone_ctx
, 0, sizeof(skb_cb
->tx_clone_ctx
));
2000 tipc_aead_put(aead
);
2002 tipc_node_put(rx
->node
);
2005 static void tipc_crypto_do_cmd(struct net
*net
, int cmd
)
2007 struct tipc_net
*tn
= tipc_net(net
);
2008 struct tipc_crypto
*tx
= tn
->crypto_tx
, *rx
;
2009 struct list_head
*p
;
2014 /* Currently only one command is supported */
2023 /* Print a header */
2024 pr_info("\n=============== TIPC Crypto Statistics ===============\n\n");
2026 /* Print key status */
2027 pr_info("Key status:\n");
2028 pr_info("TX(%7.7s)\n%s", tipc_own_id_string(net
),
2029 tipc_crypto_key_dump(tx
, buf
));
2032 for (p
= tn
->node_list
.next
; p
!= &tn
->node_list
; p
= p
->next
) {
2033 rx
= tipc_node_crypto_rx_by_list(p
);
2034 pr_info("RX(%7.7s)\n%s", tipc_node_get_id_str(rx
->node
),
2035 tipc_crypto_key_dump(rx
, buf
));
2039 /* Print crypto statistics */
2040 for (i
= 0, j
= 0; i
< MAX_STATS
; i
++)
2041 j
+= scnprintf(buf
+ j
, 200 - j
, "|%11s ", hstats
[i
]);
2042 pr_info("Counter %s", buf
);
2044 memset(buf
, '-', 115);
2046 pr_info("%s\n", buf
);
2048 j
= scnprintf(buf
, 200, "TX(%7.7s) ", tipc_own_id_string(net
));
2049 for_each_possible_cpu(cpu
) {
2050 for (i
= 0; i
< MAX_STATS
; i
++) {
2051 stat
= per_cpu_ptr(tx
->stats
, cpu
)->stat
[i
];
2052 j
+= scnprintf(buf
+ j
, 200 - j
, "|%11d ", stat
);
2055 j
= scnprintf(buf
, 200, "%12s", " ");
2059 for (p
= tn
->node_list
.next
; p
!= &tn
->node_list
; p
= p
->next
) {
2060 rx
= tipc_node_crypto_rx_by_list(p
);
2061 j
= scnprintf(buf
, 200, "RX(%7.7s) ",
2062 tipc_node_get_id_str(rx
->node
));
2063 for_each_possible_cpu(cpu
) {
2064 for (i
= 0; i
< MAX_STATS
; i
++) {
2065 stat
= per_cpu_ptr(rx
->stats
, cpu
)->stat
[i
];
2066 j
+= scnprintf(buf
+ j
, 200 - j
, "|%11d ",
2070 j
= scnprintf(buf
, 200, "%12s", " ");
2075 pr_info("\n======================== Done ========================\n");
2078 static char *tipc_crypto_key_dump(struct tipc_crypto
*c
, char *buf
)
2080 struct tipc_key key
= c
->key
;
2081 struct tipc_aead
*aead
;
2085 for (k
= KEY_MIN
; k
<= KEY_MAX
; k
++) {
2086 if (k
== KEY_MASTER
) {
2089 if (time_before(jiffies
,
2090 c
->timer2
+ TIPC_TX_GRACE_PERIOD
))
2095 if (k
== key
.passive
)
2097 else if (k
== key
.active
)
2099 else if (k
== key
.pending
)
2104 i
+= scnprintf(buf
+ i
, 200 - i
, "\tKey%d: %s", k
, s
);
2107 aead
= rcu_dereference(c
->aead
[k
]);
2109 i
+= scnprintf(buf
+ i
, 200 - i
,
2110 "{\"0x...%s\", \"%s\"}/%d:%d",
2112 (aead
->mode
== CLUSTER_KEY
) ? "c" : "p",
2113 atomic_read(&aead
->users
),
2114 refcount_read(&aead
->refcnt
));
2116 i
+= scnprintf(buf
+ i
, 200 - i
, "\n");
2120 i
+= scnprintf(buf
+ i
, 200 - i
, "\tPeer RX active: %d\n",
2121 atomic_read(&c
->peer_rx_active
));
2126 static char *tipc_key_change_dump(struct tipc_key old
, struct tipc_key
new,
2129 struct tipc_key
*key
= &old
;
2133 /* Output format: "[%s %s %s] -> [%s %s %s]", max len = 32 */
2135 i
+= scnprintf(buf
+ i
, 32 - i
, "[");
2136 for (k
= KEY_1
; k
<= KEY_3
; k
++) {
2137 if (k
== key
->passive
)
2139 else if (k
== key
->active
)
2141 else if (k
== key
->pending
)
2145 i
+= scnprintf(buf
+ i
, 32 - i
,
2146 (k
!= KEY_3
) ? "%s " : "%s", s
);
2149 i
+= scnprintf(buf
+ i
, 32 - i
, "] -> ");
2153 i
+= scnprintf(buf
+ i
, 32 - i
, "]");
2158 * tipc_crypto_msg_rcv - Common 'MSG_CRYPTO' processing point
2159 * @net: the struct net
2160 * @skb: the receiving message buffer
2162 void tipc_crypto_msg_rcv(struct net
*net
, struct sk_buff
*skb
)
2164 struct tipc_crypto
*rx
;
2165 struct tipc_msg
*hdr
;
2167 if (unlikely(skb_linearize(skb
)))
2171 rx
= tipc_node_crypto_rx_by_addr(net
, msg_prevnode(hdr
));
2175 switch (msg_type(hdr
)) {
2177 if (tipc_crypto_key_rcv(rx
, hdr
))
2184 tipc_node_put(rx
->node
);
2191 * tipc_crypto_key_distr - Distribute a TX key
2192 * @tx: the TX crypto
2193 * @key: the key's index
2194 * @dest: the destination tipc node, = NULL if distributing to all nodes
2196 * Return: 0 in case of success, otherwise < 0
2198 int tipc_crypto_key_distr(struct tipc_crypto
*tx
, u8 key
,
2199 struct tipc_node
*dest
)
2201 struct tipc_aead
*aead
;
2202 u32 dnode
= tipc_node_get_addr(dest
);
2205 if (!sysctl_tipc_key_exchange_enabled
)
2210 aead
= tipc_aead_get(tx
->aead
[key
]);
2212 rc
= tipc_crypto_key_xmit(tx
->net
, aead
->key
,
2213 aead
->gen
, aead
->mode
,
2215 tipc_aead_put(aead
);
2224 * tipc_crypto_key_xmit - Send a session key
2225 * @net: the struct net
2226 * @skey: the session key to be sent
2227 * @gen: the key's generation
2228 * @mode: the key's mode
2229 * @dnode: the destination node address, = 0 if broadcasting to all nodes
2231 * The session key 'skey' is packed in a TIPC v2 'MSG_CRYPTO/KEY_DISTR_MSG'
2232 * as its data section, then xmit-ed through the uc/bc link.
2234 * Return: 0 in case of success, otherwise < 0
2236 static int tipc_crypto_key_xmit(struct net
*net
, struct tipc_aead_key
*skey
,
2237 u16 gen
, u8 mode
, u32 dnode
)
2239 struct sk_buff_head pkts
;
2240 struct tipc_msg
*hdr
;
2241 struct sk_buff
*skb
;
2242 u16 size
, cong_link_cnt
;
2246 size
= tipc_aead_key_size(skey
);
2247 skb
= tipc_buf_acquire(INT_H_SIZE
+ size
, GFP_ATOMIC
);
2252 tipc_msg_init(tipc_own_addr(net
), hdr
, MSG_CRYPTO
, KEY_DISTR_MSG
,
2254 msg_set_size(hdr
, INT_H_SIZE
+ size
);
2255 msg_set_key_gen(hdr
, gen
);
2256 msg_set_key_mode(hdr
, mode
);
2258 data
= msg_data(hdr
);
2259 *((__be32
*)(data
+ TIPC_AEAD_ALG_NAME
)) = htonl(skey
->keylen
);
2260 memcpy(data
, skey
->alg_name
, TIPC_AEAD_ALG_NAME
);
2261 memcpy(data
+ TIPC_AEAD_ALG_NAME
+ sizeof(__be32
), skey
->key
,
2264 __skb_queue_head_init(&pkts
);
2265 __skb_queue_tail(&pkts
, skb
);
2267 rc
= tipc_node_xmit(net
, &pkts
, dnode
, 0);
2269 rc
= tipc_bcast_xmit(net
, &pkts
, &cong_link_cnt
);
2275 * tipc_crypto_key_rcv - Receive a session key
2276 * @rx: the RX crypto
2277 * @hdr: the TIPC v2 message incl. the receiving session key in its data
2279 * This function retrieves the session key in the message from peer, then
2280 * schedules a RX work to attach the key to the corresponding RX crypto.
2282 * Return: "true" if the key has been scheduled for attaching, otherwise
2285 static bool tipc_crypto_key_rcv(struct tipc_crypto
*rx
, struct tipc_msg
*hdr
)
2287 struct tipc_crypto
*tx
= tipc_net(rx
->net
)->crypto_tx
;
2288 struct tipc_aead_key
*skey
= NULL
;
2289 u16 key_gen
= msg_key_gen(hdr
);
2290 u32 size
= msg_data_sz(hdr
);
2291 u8
*data
= msg_data(hdr
);
2292 unsigned int keylen
;
2294 /* Verify whether the size can exist in the packet */
2295 if (unlikely(size
< sizeof(struct tipc_aead_key
) + TIPC_AEAD_KEYLEN_MIN
)) {
2296 pr_debug("%s: message data size is too small\n", rx
->name
);
2300 keylen
= ntohl(*((__be32
*)(data
+ TIPC_AEAD_ALG_NAME
)));
2302 /* Verify the supplied size values */
2303 if (unlikely(size
!= keylen
+ sizeof(struct tipc_aead_key
) ||
2304 keylen
> TIPC_AEAD_KEY_SIZE_MAX
)) {
2305 pr_debug("%s: invalid MSG_CRYPTO key size\n", rx
->name
);
2309 spin_lock(&rx
->lock
);
2310 if (unlikely(rx
->skey
|| (key_gen
== rx
->key_gen
&& rx
->key
.keys
))) {
2311 pr_err("%s: key existed <%p>, gen %d vs %d\n", rx
->name
,
2312 rx
->skey
, key_gen
, rx
->key_gen
);
2316 /* Allocate memory for the key */
2317 skey
= kmalloc(size
, GFP_ATOMIC
);
2318 if (unlikely(!skey
)) {
2319 pr_err("%s: unable to allocate memory for skey\n", rx
->name
);
2323 /* Copy key from msg data */
2324 skey
->keylen
= keylen
;
2325 memcpy(skey
->alg_name
, data
, TIPC_AEAD_ALG_NAME
);
2326 memcpy(skey
->key
, data
+ TIPC_AEAD_ALG_NAME
+ sizeof(__be32
),
2329 rx
->key_gen
= key_gen
;
2330 rx
->skey_mode
= msg_key_mode(hdr
);
2333 mb(); /* for nokey flag */
2336 spin_unlock(&rx
->lock
);
2339 /* Schedule the key attaching on this crypto */
2340 if (likely(skey
&& queue_delayed_work(tx
->wq
, &rx
->work
, 0)))
2347 * tipc_crypto_work_rx - Scheduled RX works handler
2348 * @work: the struct RX work
2350 * The function processes the previous scheduled works i.e. distributing TX key
2351 * or attaching a received session key on RX crypto.
2353 static void tipc_crypto_work_rx(struct work_struct
*work
)
2355 struct delayed_work
*dwork
= to_delayed_work(work
);
2356 struct tipc_crypto
*rx
= container_of(dwork
, struct tipc_crypto
, work
);
2357 struct tipc_crypto
*tx
= tipc_net(rx
->net
)->crypto_tx
;
2358 unsigned long delay
= msecs_to_jiffies(5000);
2359 bool resched
= false;
2363 /* Case 1: Distribute TX key to peer if scheduled */
2364 if (atomic_cmpxchg(&rx
->key_distr
,
2366 KEY_DISTR_COMPL
) == KEY_DISTR_SCHED
) {
2367 /* Always pick the newest one for distributing */
2368 key
= tx
->key
.pending
?: tx
->key
.active
;
2369 rc
= tipc_crypto_key_distr(tx
, key
, rx
->node
);
2371 pr_warn("%s: unable to distr key[%d] to %s, err %d\n",
2372 tx
->name
, key
, tipc_node_get_id_str(rx
->node
),
2375 /* Sched for key_distr releasing */
2378 atomic_cmpxchg(&rx
->key_distr
, KEY_DISTR_COMPL
, 0);
2381 /* Case 2: Attach a pending received session key from peer if any */
2383 rc
= tipc_crypto_key_init(rx
, rx
->skey
, rx
->skey_mode
, false);
2384 if (unlikely(rc
< 0))
2385 pr_warn("%s: unable to attach received skey, err %d\n",
2390 /* Resched the key attaching */
2401 if (resched
&& queue_delayed_work(tx
->wq
, &rx
->work
, delay
))
2404 tipc_node_put(rx
->node
);
2408 * tipc_crypto_rekeying_sched - (Re)schedule rekeying w/o new interval
2410 * @changed: if the rekeying needs to be rescheduled with new interval
2411 * @new_intv: new rekeying interval (when "changed" = true)
2413 void tipc_crypto_rekeying_sched(struct tipc_crypto
*tx
, bool changed
,
2416 unsigned long delay
;
2420 if (new_intv
== TIPC_REKEYING_NOW
)
2423 tx
->rekeying_intv
= new_intv
;
2424 cancel_delayed_work_sync(&tx
->work
);
2427 if (tx
->rekeying_intv
|| now
) {
2428 delay
= (now
) ? 0 : tx
->rekeying_intv
* 60 * 1000;
2429 queue_delayed_work(tx
->wq
, &tx
->work
, msecs_to_jiffies(delay
));
2434 * tipc_crypto_work_tx - Scheduled TX works handler
2435 * @work: the struct TX work
2437 * The function processes the previous scheduled work, i.e. key rekeying, by
2438 * generating a new session key based on current one, then attaching it to the
2439 * TX crypto and finally distributing it to peers. It also re-schedules the
2440 * rekeying if needed.
2442 static void tipc_crypto_work_tx(struct work_struct
*work
)
2444 struct delayed_work
*dwork
= to_delayed_work(work
);
2445 struct tipc_crypto
*tx
= container_of(dwork
, struct tipc_crypto
, work
);
2446 struct tipc_aead_key
*skey
= NULL
;
2447 struct tipc_key key
= tx
->key
;
2448 struct tipc_aead
*aead
;
2451 if (unlikely(key
.pending
))
2454 /* Take current key as a template */
2456 aead
= rcu_dereference(tx
->aead
[key
.active
?: KEY_MASTER
]);
2457 if (unlikely(!aead
)) {
2459 /* At least one key should exist for securing */
2463 /* Lets duplicate it first */
2464 skey
= kmemdup(aead
->key
, tipc_aead_key_size(aead
->key
), GFP_ATOMIC
);
2467 /* Now, generate new key, initiate & distribute it */
2469 rc
= tipc_aead_key_generate(skey
) ?:
2470 tipc_crypto_key_init(tx
, skey
, PER_NODE_KEY
, false);
2472 rc
= tipc_crypto_key_distr(tx
, rc
, NULL
);
2473 kfree_sensitive(skey
);
2477 pr_warn_ratelimited("%s: rekeying returns %d\n", tx
->name
, rc
);
2480 /* Re-schedule rekeying if any */
2481 tipc_crypto_rekeying_sched(tx
, false, 0);