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 <[email protected]>
Signed-off-by: Richard Weinberger <[email protected]>

diff --git a/fs/ubifs/lpt.c b/fs/ubifs/lpt.c
index 5f57af224b8f9aca7cb09f42dac51bb4d0fa8ec4..ee18305a6152d18e0cbf52b663745b5db034f00f 100644 (file)
--- a/fs/ubifs/lpt.c
+++ b/fs/ubifs/lpt.c
@@ -1635,6 +1635,131 @@ struct ubifs_lprops *ubifs_lpt_lookup_dirty(struct ubifs_info *c, int lnum)
        return &pnode->lprops[iip];
 }
 
+/**
+ * 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 62d6a87d4f5d03ae6263f77d29d2d928ce5e3c38..1f88caffdf2acfae85113a064c68f0e3fbefb9a5 100644 (file)
--- 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 600a25b93a80914d6b1f93df01d0eaf2fa30e984..7e519a4885a8cebb1f87d5bbfe943529b660e307 100644 (file)
--- 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);