ubifs: authentication: Authenticate LPT

The LPT needs to be authenticated aswell. Since the LPT is only written
during commit it is enough to authenticate the whole LPT with a single
hash which is stored in the master node. Only the leaf nodes (pnodes)
are hashed which makes the implementation much simpler than it would be
to hash the complete LPT.

Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
Signed-off-by: Richard Weinberger <richard@nod.at>

3 files changed, 134 insertions, 0 deletions

diff --git a/fs/ubifs/lpt.c b/fs/ubifs/lpt.c
index 5f57af224b8f..ee18305a6152 100644
--- a/fs/ubifs/lpt.c
+++ b/fs/ubifs/lpt.c
@@ -1636,6 +1636,131 @@ struct ubifs_lprops *ubifs_lpt_lookup_dirty(struct ubifs_info *c, int lnum)
 }
 
 /**
+ * ubifs_lpt_calc_hash - Calculate hash of the LPT pnodes
+ * @c: UBIFS file-system description object
+ * @hash: the returned hash of the LPT pnodes
+ *
+ * This function iterates over the LPT pnodes and creates a hash over them.
+ * Returns 0 for success or a negative error code otherwise.
+ */
+int ubifs_lpt_calc_hash(struct ubifs_info *c, u8 *hash)
+{
+        struct ubifs_nnode *nnode, *nn;
+        struct ubifs_cnode *cnode;
+        struct shash_desc *desc;
+        int iip = 0, i;
+        int bufsiz = max_t(int, c->nnode_sz, c->pnode_sz);
+        void *buf;
+        int err;
+
+        if (!ubifs_authenticated(c))
+                return 0;
+
+        desc = ubifs_hash_get_desc(c);
+        if (IS_ERR(desc))
+                return PTR_ERR(desc);
+
+        buf = kmalloc(bufsiz, GFP_NOFS);
+        if (!buf) {
+                err = -ENOMEM;
+                goto out;
+        }
+
+        if (!c->nroot) {
+                err = ubifs_read_nnode(c, NULL, 0);
+                if (err)
+                        return err;
+        }
+
+        cnode = (struct ubifs_cnode *)c->nroot;
+
+        while (cnode) {
+                nnode = cnode->parent;
+                nn = (struct ubifs_nnode *)cnode;
+                if (cnode->level > 1) {
+                        while (iip < UBIFS_LPT_FANOUT) {
+                                if (nn->nbranch[iip].lnum == 0) {
+                                        /* Go right */
+                                        iip++;
+                                        continue;
+                                }
+
+                                nnode = ubifs_get_nnode(c, nn, iip);
+                                if (IS_ERR(nnode)) {
+                                        err = PTR_ERR(nnode);
+                                        goto out;
+                                }
+
+                                /* Go down */
+                                iip = 0;
+                                cnode = (struct ubifs_cnode *)nnode;
+                                break;
+                        }
+                        if (iip < UBIFS_LPT_FANOUT)
+                                continue;
+                } else {
+                        struct ubifs_pnode *pnode;
+
+                        for (i = 0; i < UBIFS_LPT_FANOUT; i++) {
+                                if (nn->nbranch[i].lnum == 0)
+                                        continue;
+                                pnode = ubifs_get_pnode(c, nn, i);
+                                if (IS_ERR(pnode)) {
+                                        err = PTR_ERR(pnode);
+                                        goto out;
+                                }
+
+                                ubifs_pack_pnode(c, buf, pnode);
+                                err = ubifs_shash_update(c, desc, buf,
+                                                         c->pnode_sz);
+                                if (err)
+                                        goto out;
+                        }
+                }
+                /* Go up and to the right */
+                iip = cnode->iip + 1;
+                cnode = (struct ubifs_cnode *)nnode;
+        }
+
+        err = ubifs_shash_final(c, desc, hash);
+out:
+        kfree(desc);
+        kfree(buf);
+
+        return err;
+}
+
+/**
+ * lpt_check_hash - check the hash of the LPT.
+ * @c: UBIFS file-system description object
+ *
+ * This function calculates a hash over all pnodes in the LPT and compares it with
+ * the hash stored in the master node. Returns %0 on success and a negative error
+ * code on failure.
+ */
+static int lpt_check_hash(struct ubifs_info *c)
+{
+        int err;
+        u8 hash[UBIFS_HASH_ARR_SZ];
+
+        if (!ubifs_authenticated(c))
+                return 0;
+
+        err = ubifs_lpt_calc_hash(c, hash);
+        if (err)
+                return err;
+
+        if (ubifs_check_hash(c, c->mst_node->hash_lpt, hash)) {
+                err = -EPERM;
+                ubifs_err(c, "Failed to authenticate LPT");
+        } else {
+                err = 0;
+        }
+
+        return err;
+}
+
+/**
  * lpt_init_rd - initialize the LPT for reading.
  * @c: UBIFS file-system description object
  *
@@ -1676,6 +1801,10 @@ static int lpt_init_rd(struct ubifs_info *c)
         if (err)
                 return err;
 
+        err = lpt_check_hash(c);
+        if (err)
+                return err;
+
         dbg_lp("space_bits %d", c->space_bits);
         dbg_lp("lpt_lnum_bits %d", c->lpt_lnum_bits);
         dbg_lp("lpt_offs_bits %d", c->lpt_offs_bits);
diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c
index 62d6a87d4f5d..1f88caffdf2a 100644
--- a/fs/ubifs/lpt_commit.c
+++ b/fs/ubifs/lpt_commit.c
@@ -1247,6 +1247,10 @@ int ubifs_lpt_start_commit(struct ubifs_info *c)
         if (err)
                 goto out;
 
+        err = ubifs_lpt_calc_hash(c, c->mst_node->hash_lpt);
+        if (err)
+                goto out;
+
         /* Copy the LPT's own lprops for end commit to write */
         memcpy(c->ltab_cmt, c->ltab,
                sizeof(struct ubifs_lpt_lprops) * c->lpt_lebs);
diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h
index 600a25b93a80..7e519a4885a8 100644
--- a/fs/ubifs/ubifs.h
+++ b/fs/ubifs/ubifs.h
@@ -1961,6 +1961,7 @@ struct ubifs_nnode *ubifs_first_nnode(struct ubifs_info *c, int *hght);
 /* Needed only in debugging code in lpt_commit.c */
 int ubifs_unpack_nnode(const struct ubifs_info *c, void *buf,
                        struct ubifs_nnode *nnode);
+int ubifs_lpt_calc_hash(struct ubifs_info *c, u8 *hash);
 
 /* lpt_commit.c */
 int ubifs_lpt_start_commit(struct ubifs_info *c);