tipc: add automatic rekeying for encryption key

Rekeying is required for security since a key is less secure when using
for a long time. Also, key will be detached when its nonce value (or
seqno ...) is exhausted. We now make the rekeying process automatic and
configurable by user.

Basically, TIPC will at a specific interval generate a new key by using
the kernel 'Random Number Generator' cipher, then attach it as the node
TX key and securely distribute to others in the cluster as RX keys (-
the key exchange). The automatic key switching will then take over, and
make the new key active shortly. Afterwards, the traffic from this node
will be encrypted with the new session key. The same can happen in peer
nodes but not necessarily at the same time.

For simplicity, the automatically generated key will be initiated as a
per node key. It is not too hard to also support a cluster key rekeying
(e.g. a given node will generate a unique cluster key and update to the
others in the cluster...), but that doesn't bring much benefit, while a
per-node key is even more secure.

We also enable user to force a rekeying or change the rekeying interval
via netlink, the new 'set key' command option: 'TIPC_NLA_NODE_REKEYING'
is added for these purposes as follows:
- A value >= 1 will be set as the rekeying interval (in minutes);
- A value of 0 will disable the rekeying;
- A value of 'TIPC_REKEYING_NOW' (~0) will force an immediate rekeying;

The default rekeying interval is (60 * 24) minutes i.e. done every day.
There isn't any restriction for the value but user shouldn't set it too
small or too large which results in an "ineffective" rekeying (thats ok
for testing though).

Acked-by: Jon Maloy <jmaloy@redhat.com>
Signed-off-by: Tuong Lien <tuong.t.lien@dektech.com.au>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/uapi/linux/tipc.h b/include/uapi/linux/tipc.h
index add01db1daeffbe6c2226babf807b86ca0ff8264..80ea15e12113df5c5f0870832c45ebea3b26e53f 100644 (file)
--- a/include/uapi/linux/tipc.h
+++ b/include/uapi/linux/tipc.h
@@ -254,6 +254,8 @@ static inline int tipc_aead_key_size(struct tipc_aead_key *key)
        return sizeof(*key) + key->keylen;
 }
 
+#define TIPC_REKEYING_NOW              (~0U)
+
 /* The macros and functions below are deprecated:
  */
 

diff --git a/include/uapi/linux/tipc_netlink.h b/include/uapi/linux/tipc_netlink.h
index d484baa9d36515c5a3eb207f22f83dfba5ddd53e..d847dd671d79c29c6ebdab0cb8f0140401b689b2 100644 (file)
--- a/include/uapi/linux/tipc_netlink.h
+++ b/include/uapi/linux/tipc_netlink.h
@@ -166,6 +166,7 @@ enum {
        TIPC_NLA_NODE_ID,               /* data */
        TIPC_NLA_NODE_KEY,              /* data */
        TIPC_NLA_NODE_KEY_MASTER,       /* flag */
+       TIPC_NLA_NODE_REKEYING,         /* u32 */
 
        __TIPC_NLA_NODE_MAX,
        TIPC_NLA_NODE_MAX = __TIPC_NLA_NODE_MAX - 1

diff --git a/net/tipc/crypto.c b/net/tipc/crypto.c
index 91d8b268cae09ee3787d870a798fbb659a47a12d..40c44101fe8e70de41fd419fbd13c015c388259f 100644 (file)
--- a/net/tipc/crypto.c
+++ b/net/tipc/crypto.c
@@ -36,6 +36,7 @@
 
 #include <crypto/aead.h>
 #include <crypto/aes.h>
+#include <crypto/rng.h>
 #include "crypto.h"
 #include "msg.h"
 #include "bcast.h"
@@ -48,6 +49,8 @@
 #define TIPC_MAX_TFMS_DEF      10
 #define TIPC_MAX_TFMS_LIM      1000
 
+#define TIPC_REKEYING_INTV_DEF (60 * 24) /* default: 1 day */
+
 /**
  * TIPC Key ids
  */
@@ -181,6 +184,7 @@ struct tipc_crypto_stats {
  * @wq: common workqueue on TX crypto
  * @work: delayed work sched for TX/RX
  * @key_distr: key distributing state
+ * @rekeying_intv: rekeying interval (in minutes)
  * @stats: the crypto statistics
  * @name: the crypto name
  * @sndnxt: the per-peer sndnxt (TX)
@@ -206,6 +210,7 @@ struct tipc_crypto {
 #define KEY_DISTR_SCHED                1
 #define KEY_DISTR_COMPL                2
        atomic_t key_distr;
+       u32 rekeying_intv;
 
        struct tipc_crypto_stats __percpu *stats;
        char name[48];
@@ -294,7 +299,9 @@ static char *tipc_key_change_dump(struct tipc_key old, struct tipc_key new,
 static int tipc_crypto_key_xmit(struct net *net, struct tipc_aead_key *skey,
                                u16 gen, u8 mode, u32 dnode);
 static bool tipc_crypto_key_rcv(struct tipc_crypto *rx, struct tipc_msg *hdr);
+static void tipc_crypto_work_tx(struct work_struct *work);
 static void tipc_crypto_work_rx(struct work_struct *work);
+static int tipc_aead_key_generate(struct tipc_aead_key *skey);
 
 #define is_tx(crypto) (!(crypto)->node)
 #define is_rx(crypto) (!is_tx(crypto))
@@ -346,6 +353,27 @@ int tipc_aead_key_validate(struct tipc_aead_key *ukey, struct genl_info *info)
        return 0;
 }
 
+/**
+ * tipc_aead_key_generate - Generate new session key
+ * @skey: input/output key with new content
+ *
+ * Return: 0 in case of success, otherwise < 0
+ */
+static int tipc_aead_key_generate(struct tipc_aead_key *skey)
+{
+       int rc = 0;
+
+       /* Fill the key's content with a random value via RNG cipher */
+       rc = crypto_get_default_rng();
+       if (likely(!rc)) {
+               rc = crypto_rng_get_bytes(crypto_default_rng, skey->key,
+                                         skey->keylen);
+               crypto_put_default_rng();
+       }
+
+       return rc;
+}
+
 static struct tipc_aead *tipc_aead_get(struct tipc_aead __rcu *aead)
 {
        struct tipc_aead *tmp;
@@ -1471,6 +1499,7 @@ int tipc_crypto_start(struct tipc_crypto **crypto, struct net *net,
        atomic64_set(&c->sndnxt, 0);
        c->timer1 = jiffies;
        c->timer2 = jiffies;
+       c->rekeying_intv = TIPC_REKEYING_INTV_DEF;
        spin_lock_init(&c->lock);
        scnprintf(c->name, 48, "%s(%s)", (is_rx(c)) ? "RX" : "TX",
                  (is_rx(c)) ? tipc_node_get_id_str(c->node) :
@@ -1478,6 +1507,8 @@ int tipc_crypto_start(struct tipc_crypto **crypto, struct net *net,
 
        if (is_rx(c))
                INIT_DELAYED_WORK(&c->work, tipc_crypto_work_rx);
+       else
+               INIT_DELAYED_WORK(&c->work, tipc_crypto_work_tx);
 
        *crypto = c;
        return 0;
@@ -1492,8 +1523,11 @@ void tipc_crypto_stop(struct tipc_crypto **crypto)
                return;
 
        /* Flush any queued works & destroy wq */
-       if (is_tx(c))
+       if (is_tx(c)) {
+               c->rekeying_intv = 0;
+               cancel_delayed_work_sync(&c->work);
                destroy_workqueue(c->wq);
+       }
 
        /* Release AEAD keys */
        rcu_read_lock();
@@ -2351,3 +2385,80 @@ static void tipc_crypto_work_rx(struct work_struct *work)
 
        tipc_node_put(rx->node);
 }
+
+/**
+ * tipc_crypto_rekeying_sched - (Re)schedule rekeying w/o new interval
+ * @tx: TX crypto
+ * @changed: if the rekeying needs to be rescheduled with new interval
+ * @new_intv: new rekeying interval (when "changed" = true)
+ */
+void tipc_crypto_rekeying_sched(struct tipc_crypto *tx, bool changed,
+                               u32 new_intv)
+{
+       unsigned long delay;
+       bool now = false;
+
+       if (changed) {
+               if (new_intv == TIPC_REKEYING_NOW)
+                       now = true;
+               else
+                       tx->rekeying_intv = new_intv;
+               cancel_delayed_work_sync(&tx->work);
+       }
+
+       if (tx->rekeying_intv || now) {
+               delay = (now) ? 0 : tx->rekeying_intv * 60 * 1000;
+               queue_delayed_work(tx->wq, &tx->work, msecs_to_jiffies(delay));
+       }
+}
+
+/**
+ * tipc_crypto_work_tx - Scheduled TX works handler
+ * @work: the struct TX work
+ *
+ * The function processes the previous scheduled work, i.e. key rekeying, by
+ * generating a new session key based on current one, then attaching it to the
+ * TX crypto and finally distributing it to peers. It also re-schedules the
+ * rekeying if needed.
+ */
+static void tipc_crypto_work_tx(struct work_struct *work)
+{
+       struct delayed_work *dwork = to_delayed_work(work);
+       struct tipc_crypto *tx = container_of(dwork, struct tipc_crypto, work);
+       struct tipc_aead_key *skey = NULL;
+       struct tipc_key key = tx->key;
+       struct tipc_aead *aead;
+       int rc = -ENOMEM;
+
+       if (unlikely(key.pending))
+               goto resched;
+
+       /* Take current key as a template */
+       rcu_read_lock();
+       aead = rcu_dereference(tx->aead[key.active ?: KEY_MASTER]);
+       if (unlikely(!aead)) {
+               rcu_read_unlock();
+               /* At least one key should exist for securing */
+               return;
+       }
+
+       /* Lets duplicate it first */
+       skey = kmemdup(aead->key, tipc_aead_key_size(aead->key), GFP_ATOMIC);
+       rcu_read_unlock();
+
+       /* Now, generate new key, initiate & distribute it */
+       if (likely(skey)) {
+               rc = tipc_aead_key_generate(skey) ?:
+                    tipc_crypto_key_init(tx, skey, PER_NODE_KEY, false);
+               if (likely(rc > 0))
+                       rc = tipc_crypto_key_distr(tx, rc, NULL);
+               kzfree(skey);
+       }
+
+       if (unlikely(rc))
+               pr_warn_ratelimited("%s: rekeying returns %d\n", tx->name, rc);
+
+resched:
+       /* Re-schedule rekeying if any */
+       tipc_crypto_rekeying_sched(tx, false, 0);
+}

diff --git a/net/tipc/crypto.h b/net/tipc/crypto.h
index b2a9c9b90684db9c4e6b1b566efa85d785071bbb..e71193bd5e3699795a7f7bf8810a47666a0b8512 100644 (file)
--- a/net/tipc/crypto.h
+++ b/net/tipc/crypto.h
@@ -171,6 +171,8 @@ void tipc_crypto_key_flush(struct tipc_crypto *c);
 int tipc_crypto_key_distr(struct tipc_crypto *tx, u8 key,
                          struct tipc_node *dest);
 void tipc_crypto_msg_rcv(struct net *net, struct sk_buff *skb);
+void tipc_crypto_rekeying_sched(struct tipc_crypto *tx, bool changed,
+                               u32 new_intv);
 int tipc_aead_key_validate(struct tipc_aead_key *ukey, struct genl_info *info);
 bool tipc_ehdr_validate(struct sk_buff *skb);
 

diff --git a/net/tipc/netlink.c b/net/tipc/netlink.c
index 1ec00fcc26ee0c657a68dd8cb893bfc6fd3d710d..c447cb5f879e70bbce4feca8822292f2600e648b 100644 (file)
--- a/net/tipc/netlink.c
+++ b/net/tipc/netlink.c
@@ -109,6 +109,7 @@ const struct nla_policy tipc_nl_node_policy[TIPC_NLA_NODE_MAX + 1] = {
        [TIPC_NLA_NODE_KEY]             = { .type = NLA_BINARY,
                                            .len = TIPC_AEAD_KEY_SIZE_MAX},
        [TIPC_NLA_NODE_KEY_MASTER]      = { .type = NLA_FLAG },
+       [TIPC_NLA_NODE_REKEYING]        = { .type = NLA_U32 },
 };
 
 /* Properties valid for media, bearer and link */

diff --git a/net/tipc/node.c b/net/tipc/node.c
index c9b6042e32b58ecd746e5278eaa681da3a18efc8..cf4b239fc569a4da176e6d1e14486494c042dcd0 100644 (file)
--- a/net/tipc/node.c
+++ b/net/tipc/node.c
@@ -2879,6 +2879,17 @@ static int tipc_nl_retrieve_nodeid(struct nlattr **attrs, u8 **node_id)
        return 0;
 }
 
+static int tipc_nl_retrieve_rekeying(struct nlattr **attrs, u32 *intv)
+{
+       struct nlattr *attr = attrs[TIPC_NLA_NODE_REKEYING];
+
+       if (!attr)
+               return -ENODATA;
+
+       *intv = nla_get_u32(attr);
+       return 0;
+}
+
 static int __tipc_nl_node_set_key(struct sk_buff *skb, struct genl_info *info)
 {
        struct nlattr *attrs[TIPC_NLA_NODE_MAX + 1];
@@ -2886,8 +2897,9 @@ static int __tipc_nl_node_set_key(struct sk_buff *skb, struct genl_info *info)
        struct tipc_crypto *tx = tipc_net(net)->crypto_tx, *c = tx;
        struct tipc_node *n = NULL;
        struct tipc_aead_key *ukey;
-       bool master_key = false;
+       bool rekeying = true, master_key = false;
        u8 *id, *own_id, mode;
+       u32 intv = 0;
        int rc = 0;
 
        if (!info->attrs[TIPC_NLA_NODE])
@@ -2905,8 +2917,14 @@ static int __tipc_nl_node_set_key(struct sk_buff *skb, struct genl_info *info)
                return -EPERM;
        }
 
+       rc = tipc_nl_retrieve_rekeying(attrs, &intv);
+       if (rc == -ENODATA)
+               rekeying = false;
+
        rc = tipc_nl_retrieve_key(attrs, &ukey);
-       if (rc)
+       if (rc == -ENODATA && rekeying)
+               goto rekeying;
+       else if (rc)
                return rc;
 
        rc = tipc_aead_key_validate(ukey, info);
@@ -2945,6 +2963,9 @@ static int __tipc_nl_node_set_key(struct sk_buff *skb, struct genl_info *info)
                /* Distribute TX key but not master one */
                if (!master_key && tipc_crypto_key_distr(tx, rc, NULL))
                        GENL_SET_ERR_MSG(info, "failed to replicate new key");
+rekeying:
+               /* Schedule TX rekeying if needed */
+               tipc_crypto_rekeying_sched(tx, rekeying, intv);
        }
 
        return 0;