Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 49525e5e authored by Sascha Hauer's avatar Sascha Hauer Committed by Richard Weinberger
Browse files

ubifs: Add helper functions for authentication support 



This patch adds the various helper functions needed for authentication
support. We need functions to hash nodes, to embed HMACs into a node and
to compare hashes and HMACs. Most functions first check if this
filesystem is authenticated and bail out early if not, which makes the
functions safe to be called with disabled authentication.

Signed-off-by: default avatarSascha Hauer <s.hauer@pengutronix.de>
Signed-off-by: default avatarRichard Weinberger <richard@nod.at>
parent dead9726

fs/ubifs/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ config UBIFS_FS 
	select CRYPTO if UBIFS_FS_ZLIB

	select CRYPTO_LZO if UBIFS_FS_LZO

	select CRYPTO_DEFLATE if UBIFS_FS_ZLIB

	select CRYPTO_HASH_INFO

	depends on MTD_UBI

	help

	  UBIFS is a file system for flash devices which works on top of UBI.

fs/ubifs/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -8,3 +8,4 @@ ubifs-y += recovery.o ioctl.o lpt_commit.o tnc_misc.o debug.o 
ubifs-y += misc.o

ubifs-$(CONFIG_UBIFS_FS_ENCRYPTION) += crypto.o

ubifs-$(CONFIG_UBIFS_FS_XATTR) += xattr.o

ubifs-$(CONFIG_UBIFS_FS_AUTHENTICATION) += auth.o

fs/ubifs/auth.c

0 → 100644
+502 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * This file is part of UBIFS.

 *

 * Copyright (C) 2018 Pengutronix, Sascha Hauer <s.hauer@pengutronix.de>

 */



/*

 * This file implements various helper functions for UBIFS authentication support

 */



#include <linux/crypto.h>

#include <crypto/hash.h>

#include <crypto/sha.h>

#include <crypto/algapi.h>

#include <keys/user-type.h>



#include "ubifs.h"



/**

 * ubifs_node_calc_hash - calculate the hash of a UBIFS node

 * @c: UBIFS file-system description object

 * @node: the node to calculate a hash for

 * @hash: the returned hash

 *

 * Returns 0 for success or a negative error code otherwise.

 */

int __ubifs_node_calc_hash(const struct ubifs_info *c, const void *node,

			    u8 *hash)

{

	const struct ubifs_ch *ch = node;

	SHASH_DESC_ON_STACK(shash, c->hash_tfm);

	int err;



	shash->tfm = c->hash_tfm;

	shash->flags = CRYPTO_TFM_REQ_MAY_SLEEP;



	err = crypto_shash_digest(shash, node, le32_to_cpu(ch->len), hash);

	if (err < 0)

		return err;

	return 0;

}



/**

 * ubifs_hash_calc_hmac - calculate a HMAC from a hash

 * @c: UBIFS file-system description object

 * @hash: the node to calculate a HMAC for

 * @hmac: the returned HMAC

 *

 * Returns 0 for success or a negative error code otherwise.

 */

static int ubifs_hash_calc_hmac(const struct ubifs_info *c, const u8 *hash,

				 u8 *hmac)

{

	SHASH_DESC_ON_STACK(shash, c->hmac_tfm);

	int err;



	shash->tfm = c->hmac_tfm;

	shash->flags = CRYPTO_TFM_REQ_MAY_SLEEP;



	err = crypto_shash_digest(shash, hash, c->hash_len, hmac);

	if (err < 0)

		return err;

	return 0;

}



/**

 * ubifs_prepare_auth_node - Prepare an authentication node

 * @c: UBIFS file-system description object

 * @node: the node to calculate a hash for

 * @hash: input hash of previous nodes

 *

 * This function prepares an authentication node for writing onto flash.

 * It creates a HMAC from the given input hash and writes it to the node.

 *

 * Returns 0 for success or a negative error code otherwise.

 */

int ubifs_prepare_auth_node(struct ubifs_info *c, void *node,

			     struct shash_desc *inhash)

{

	SHASH_DESC_ON_STACK(hash_desc, c->hash_tfm);

	struct ubifs_auth_node *auth = node;

	u8 *hash;

	int err;



	hash = kmalloc(crypto_shash_descsize(c->hash_tfm), GFP_NOFS);

	if (!hash)

		return -ENOMEM;



	hash_desc->tfm = c->hash_tfm;

	hash_desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;

	ubifs_shash_copy_state(c, inhash, hash_desc);



	err = crypto_shash_final(hash_desc, hash);

	if (err)

		goto out;



	err = ubifs_hash_calc_hmac(c, hash, auth->hmac);

	if (err)

		goto out;



	auth->ch.node_type = UBIFS_AUTH_NODE;

	ubifs_prepare_node(c, auth, ubifs_auth_node_sz(c), 0);



	err = 0;

out:

	kfree(hash);



	return err;

}



static struct shash_desc *ubifs_get_desc(const struct ubifs_info *c,

					 struct crypto_shash *tfm)

{

	struct shash_desc *desc;

	int err;



	if (!ubifs_authenticated(c))

		return NULL;



	desc = kmalloc(sizeof(*desc) + crypto_shash_descsize(tfm), GFP_KERNEL);

	if (!desc)

		return ERR_PTR(-ENOMEM);



	desc->tfm = tfm;

	desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;



	err = crypto_shash_init(desc);

	if (err) {

		kfree(desc);

		return ERR_PTR(err);

	}



	return desc;

}



/**

 * __ubifs_hash_get_desc - get a descriptor suitable for hashing a node

 * @c: UBIFS file-system description object

 *

 * This function returns a descriptor suitable for hashing a node. Free after use

 * with kfree.

 */

struct shash_desc *__ubifs_hash_get_desc(const struct ubifs_info *c)

{

	return ubifs_get_desc(c, c->hash_tfm);

}



/**

 * __ubifs_shash_final - finalize shash

 * @c: UBIFS file-system description object

 * @desc: the descriptor

 * @out: the output hash

 *

 * Simple wrapper around crypto_shash_final(), safe to be called with

 * disabled authentication.

 */

int __ubifs_shash_final(const struct ubifs_info *c, struct shash_desc *desc,

			u8 *out)

{

	if (ubifs_authenticated(c))

		return crypto_shash_final(desc, out);



	return 0;

}



/**

 * ubifs_bad_hash - Report hash mismatches

 * @c: UBIFS file-system description object

 * @node: the node

 * @hash: the expected hash

 * @lnum: the LEB @node was read from

 * @offs: offset in LEB @node was read from

 *

 * This function reports a hash mismatch when a node has a different hash than

 * expected.

 */

void ubifs_bad_hash(const struct ubifs_info *c, const void *node, const u8 *hash,

		    int lnum, int offs)

{

	int len = min(c->hash_len, 20);

	int cropped = len != c->hash_len;

	const char *cont = cropped ? "..." : "";



	u8 calc[UBIFS_HASH_ARR_SZ];



	__ubifs_node_calc_hash(c, node, calc);



	ubifs_err(c, "hash mismatch on node at LEB %d:%d", lnum, offs);

	ubifs_err(c, "hash expected:   %*ph%s", len, hash, cont);

	ubifs_err(c, "hash calculated: %*ph%s", len, calc, cont);

}



/**

 * __ubifs_node_check_hash - check the hash of a node against given hash

 * @c: UBIFS file-system description object

 * @node: the node

 * @expected: the expected hash

 *

 * This function calculates a hash over a node and compares it to the given hash.

 * Returns 0 if both hashes are equal or authentication is disabled, otherwise a

 * negative error code is returned.

 */

int __ubifs_node_check_hash(const struct ubifs_info *c, const void *node,

			    const u8 *expected)

{

	u8 calc[UBIFS_HASH_ARR_SZ];

	int err;



	err = __ubifs_node_calc_hash(c, node, calc);

	if (err)

		return err;



	if (ubifs_check_hash(c, expected, calc))

		return -EPERM;



	return 0;

}



/**

 * ubifs_init_authentication - initialize UBIFS authentication support

 * @c: UBIFS file-system description object

 *

 * This function returns 0 for success or a negative error code otherwise.

 */

int ubifs_init_authentication(struct ubifs_info *c)

{

	struct key *keyring_key;

	const struct user_key_payload *ukp;

	int err;

	char hmac_name[CRYPTO_MAX_ALG_NAME];



	if (!c->auth_hash_name) {

		ubifs_err(c, "authentication hash name needed with authentication");

		return -EINVAL;

	}



	c->auth_hash_algo = match_string(hash_algo_name, HASH_ALGO__LAST,

					 c->auth_hash_name);

	if ((int)c->auth_hash_algo < 0) {

		ubifs_err(c, "Unknown hash algo %s specified",

			  c->auth_hash_name);

		return -EINVAL;

	}



	snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)",

		 c->auth_hash_name);



	keyring_key = request_key(&key_type_logon, c->auth_key_name, NULL);



	if (IS_ERR(keyring_key)) {

		ubifs_err(c, "Failed to request key: %ld",

			  PTR_ERR(keyring_key));

		return PTR_ERR(keyring_key);

	}



	down_read(&keyring_key->sem);



	if (keyring_key->type != &key_type_logon) {

		ubifs_err(c, "key type must be logon");

		err = -ENOKEY;

		goto out;

	}



	ukp = user_key_payload_locked(keyring_key);

	if (!ukp) {

		/* key was revoked before we acquired its semaphore */

		err = -EKEYREVOKED;

		goto out;

	}



	c->hash_tfm = crypto_alloc_shash(c->auth_hash_name, 0,

					 CRYPTO_ALG_ASYNC);

	if (IS_ERR(c->hash_tfm)) {

		err = PTR_ERR(c->hash_tfm);

		ubifs_err(c, "Can not allocate %s: %d",

			  c->auth_hash_name, err);

		goto out;

	}



	c->hash_len = crypto_shash_digestsize(c->hash_tfm);

	if (c->hash_len > UBIFS_HASH_ARR_SZ) {

		ubifs_err(c, "hash %s is bigger than maximum allowed hash size (%d > %d)",

			  c->auth_hash_name, c->hash_len, UBIFS_HASH_ARR_SZ);

		err = -EINVAL;

		goto out_free_hash;

	}



	c->hmac_tfm = crypto_alloc_shash(hmac_name, 0, CRYPTO_ALG_ASYNC);

	if (IS_ERR(c->hmac_tfm)) {

		err = PTR_ERR(c->hmac_tfm);

		ubifs_err(c, "Can not allocate %s: %d", hmac_name, err);

		goto out_free_hash;

	}



	c->hmac_desc_len = crypto_shash_digestsize(c->hmac_tfm);

	if (c->hmac_desc_len > UBIFS_HMAC_ARR_SZ) {

		ubifs_err(c, "hmac %s is bigger than maximum allowed hmac size (%d > %d)",

			  hmac_name, c->hmac_desc_len, UBIFS_HMAC_ARR_SZ);

		err = -EINVAL;

		goto out_free_hash;

	}



	err = crypto_shash_setkey(c->hmac_tfm, ukp->data, ukp->datalen);

	if (err)

		goto out_free_hmac;



	c->authenticated = true;



	c->log_hash = ubifs_hash_get_desc(c);

	if (IS_ERR(c->log_hash))

		goto out_free_hmac;



	err = 0;



out_free_hmac:

	if (err)

		crypto_free_shash(c->hmac_tfm);

out_free_hash:

	if (err)

		crypto_free_shash(c->hash_tfm);

out:

	up_read(&keyring_key->sem);

	key_put(keyring_key);



	return err;

}



/**

 * __ubifs_exit_authentication - release resource

 * @c: UBIFS file-system description object

 *

 * This function releases the authentication related resources.

 */

void __ubifs_exit_authentication(struct ubifs_info *c)

{

	if (!ubifs_authenticated(c))

		return;



	crypto_free_shash(c->hmac_tfm);

	crypto_free_shash(c->hash_tfm);

	kfree(c->log_hash);

}



/**

 * ubifs_node_calc_hmac - calculate the HMAC of a UBIFS node

 * @c: UBIFS file-system description object

 * @node: the node to insert a HMAC into.

 * @len: the length of the node

 * @ofs_hmac: the offset in the node where the HMAC is inserted

 * @hmac: returned HMAC

 *

 * This function calculates a HMAC of a UBIFS node. The HMAC is expected to be

 * embedded into the node, so this area is not covered by the HMAC. Also not

 * covered is the UBIFS_NODE_MAGIC and the CRC of the node.

 */

static int ubifs_node_calc_hmac(const struct ubifs_info *c, const void *node,

				int len, int ofs_hmac, void *hmac)

{

	SHASH_DESC_ON_STACK(shash, c->hmac_tfm);

	int hmac_len = c->hmac_desc_len;

	int err;



	ubifs_assert(c, ofs_hmac > 8);

	ubifs_assert(c, ofs_hmac + hmac_len < len);



	shash->tfm = c->hmac_tfm;

	shash->flags = CRYPTO_TFM_REQ_MAY_SLEEP;



	err = crypto_shash_init(shash);

	if (err)

		return err;



	/* behind common node header CRC up to HMAC begin */

	err = crypto_shash_update(shash, node + 8, ofs_hmac - 8);

	if (err < 0)

		return err;



	/* behind HMAC, if any */

	if (len - ofs_hmac - hmac_len > 0) {

		err = crypto_shash_update(shash, node + ofs_hmac + hmac_len,

			    len - ofs_hmac - hmac_len);

		if (err < 0)

			return err;

	}



	return crypto_shash_final(shash, hmac);

}



/**

 * __ubifs_node_insert_hmac - insert a HMAC into a UBIFS node

 * @c: UBIFS file-system description object

 * @node: the node to insert a HMAC into.

 * @len: the length of the node

 * @ofs_hmac: the offset in the node where the HMAC is inserted

 *

 * This function inserts a HMAC at offset @ofs_hmac into the node given in

 * @node.

 *

 * This function returns 0 for success or a negative error code otherwise.

 */

int __ubifs_node_insert_hmac(const struct ubifs_info *c, void *node, int len,

			    int ofs_hmac)

{

	return ubifs_node_calc_hmac(c, node, len, ofs_hmac, node + ofs_hmac);

}



/**

 * __ubifs_node_verify_hmac - verify the HMAC of UBIFS node

 * @c: UBIFS file-system description object

 * @node: the node to insert a HMAC into.

 * @len: the length of the node

 * @ofs_hmac: the offset in the node where the HMAC is inserted

 *

 * This function verifies the HMAC at offset @ofs_hmac of the node given in

 * @node. Returns 0 if successful or a negative error code otherwise.

 */

int __ubifs_node_verify_hmac(const struct ubifs_info *c, const void *node,

			     int len, int ofs_hmac)

{

	int hmac_len = c->hmac_desc_len;

	u8 *hmac;

	int err;



	hmac = kmalloc(hmac_len, GFP_NOFS);

	if (!hmac)

		return -ENOMEM;



	err = ubifs_node_calc_hmac(c, node, len, ofs_hmac, hmac);

	if (err)

		return err;



	err = crypto_memneq(hmac, node + ofs_hmac, hmac_len);



	kfree(hmac);



	if (!err)

		return 0;



	return -EPERM;

}



int __ubifs_shash_copy_state(const struct ubifs_info *c, struct shash_desc *src,

			     struct shash_desc *target)

{

	u8 *state;

	int err;



	state = kmalloc(crypto_shash_descsize(src->tfm), GFP_NOFS);

	if (!state)

		return -ENOMEM;



	err = crypto_shash_export(src, state);

	if (err)

		goto out;



	err = crypto_shash_import(target, state);



out:

	kfree(state);



	return err;

}



/**

 * ubifs_hmac_wkm - Create a HMAC of the well known message

 * @c: UBIFS file-system description object

 * @hmac: The HMAC of the well known message

 *

 * This function creates a HMAC of a well known message. This is used

 * to check if the provided key is suitable to authenticate a UBIFS

 * image. This is only a convenience to the user to provide a better

 * error message when the wrong key is provided.

 *

 * This function returns 0 for success or a negative error code otherwise.

 */

int ubifs_hmac_wkm(struct ubifs_info *c, u8 *hmac)

{

	SHASH_DESC_ON_STACK(shash, c->hmac_tfm);

	int err;

	const char well_known_message[] = "UBIFS";



	if (!ubifs_authenticated(c))

		return 0;



	shash->tfm = c->hmac_tfm;

	shash->flags = CRYPTO_TFM_REQ_MAY_SLEEP;



	err = crypto_shash_init(shash);

	if (err)

		return err;



	err = crypto_shash_update(shash, well_known_message,

				  sizeof(well_known_message) - 1);

	if (err < 0)

		return err;



	err = crypto_shash_final(shash, hmac);

	if (err)

		return err;

	return 0;

}

fs/ubifs/ubifs.h

+218 −0
Original line number Diff line number Diff line
@@ -39,6 +39,9 @@ 
#include <linux/security.h>

#include <linux/xattr.h>

#include <linux/random.h>

#include <crypto/hash_info.h>

#include <crypto/hash.h>

#include <crypto/algapi.h>



#define __FS_HAS_ENCRYPTION IS_ENABLED(CONFIG_UBIFS_FS_ENCRYPTION)

#include <linux/fscrypt.h>
@@ -157,6 +160,14 @@ 
/* Maximum number of data nodes to bulk-read */

#define UBIFS_MAX_BULK_READ 32



#ifdef CONFIG_UBIFS_FS_AUTHENTICATION

#define UBIFS_HASH_ARR_SZ UBIFS_MAX_HASH_LEN

#define UBIFS_HMAC_ARR_SZ UBIFS_MAX_HMAC_LEN

#else

#define UBIFS_HASH_ARR_SZ 0

#define UBIFS_HMAC_ARR_SZ 0

#endif



/*

 * Lockdep classes for UBIFS inode @ui_mutex.

 */
@@ -1029,6 +1040,7 @@ struct ubifs_debug_info; 
 * @default_compr: default compression algorithm (%UBIFS_COMPR_LZO, etc)

 * @rw_incompat: the media is not R/W compatible

 * @assert_action: action to take when a ubifs_assert() fails

 * @authenticated: flag indigating the FS is mounted in authenticated mode

 *

 * @tnc_mutex: protects the Tree Node Cache (TNC), @zroot, @cnext, @enext, and

 *             @calc_idx_sz
@@ -1076,6 +1088,7 @@ struct ubifs_debug_info; 
 * @key_hash: direntry key hash function

 * @key_fmt: key format

 * @key_len: key length

 * @hash_len: The length of the index node hashes

 * @fanout: fanout of the index tree (number of links per indexing node)

 *

 * @min_io_size: minimal input/output unit size
@@ -1211,6 +1224,13 @@ struct ubifs_debug_info; 
 * @rp_uid: reserved pool user ID

 * @rp_gid: reserved pool group ID

 *

 * @hash_tfm: the hash transformation used for hashing nodes

 * @hmac_tfm: the HMAC transformation for this filesystem

 * @hmac_desc_len: length of the HMAC used for authentication

 * @auth_key_name: the authentication key name

 * @auth_hash_name: the name of the hash algorithm used for authentication

 * @auth_hash_algo: the authentication hash used for this fs

 *

 * @empty: %1 if the UBI device is empty

 * @need_recovery: %1 if the file-system needs recovery

 * @replaying: %1 during journal replay
@@ -1272,6 +1292,7 @@ struct ubifs_info { 
	unsigned int default_compr:2;

	unsigned int rw_incompat:1;

	unsigned int assert_action:2;

	unsigned int authenticated:1;



	struct mutex tnc_mutex;

	struct ubifs_zbranch zroot;
@@ -1316,6 +1337,7 @@ struct ubifs_info { 
	uint32_t (*key_hash)(const char *str, int len);

	int key_fmt;

	int key_len;

	int hash_len;

	int fanout;



	int min_io_size;
@@ -1443,6 +1465,13 @@ struct ubifs_info { 
	kuid_t rp_uid;

	kgid_t rp_gid;



	struct crypto_shash *hash_tfm;

	struct crypto_shash *hmac_tfm;

	int hmac_desc_len;

	char *auth_key_name;

	char *auth_hash_name;

	enum hash_algo auth_hash_algo;



	/* The below fields are used only during mounting and re-mounting */

	unsigned int empty:1;

	unsigned int need_recovery:1;
@@ -1473,6 +1502,195 @@ extern const struct inode_operations ubifs_dir_inode_operations; 
extern const struct inode_operations ubifs_symlink_inode_operations;

extern struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];



/* auth.c */

static inline int ubifs_authenticated(const struct ubifs_info *c)

{

	return (IS_ENABLED(CONFIG_UBIFS_FS_AUTHENTICATION)) && c->authenticated;

}



struct shash_desc *__ubifs_hash_get_desc(const struct ubifs_info *c);

static inline struct shash_desc *ubifs_hash_get_desc(const struct ubifs_info *c)

{

	return ubifs_authenticated(c) ? __ubifs_hash_get_desc(c) : NULL;

}



static inline int ubifs_shash_init(const struct ubifs_info *c,

				   struct shash_desc *desc)

{

	if (ubifs_authenticated(c))

		return crypto_shash_init(desc);

	else

		return 0;

}



static inline int ubifs_shash_update(const struct ubifs_info *c,

				      struct shash_desc *desc, const void *buf,

				      unsigned int len)

{

	int err = 0;



	if (ubifs_authenticated(c)) {

		err = crypto_shash_update(desc, buf, len);

		if (err < 0)

			return err;

	}



	return 0;

}



static inline int ubifs_shash_final(const struct ubifs_info *c,

				    struct shash_desc *desc, u8 *out)

{

	return ubifs_authenticated(c) ? crypto_shash_final(desc, out) : 0;

}



int __ubifs_node_calc_hash(const struct ubifs_info *c, const void *buf,

			  u8 *hash);

static inline int ubifs_node_calc_hash(const struct ubifs_info *c,

					const void *buf, u8 *hash)

{

	if (ubifs_authenticated(c))

		return __ubifs_node_calc_hash(c, buf, hash);

	else

		return 0;

}



int ubifs_prepare_auth_node(struct ubifs_info *c, void *node,

			     struct shash_desc *inhash);



/**

 * ubifs_check_hash - compare two hashes

 * @c: UBIFS file-system description object

 * @expected: first hash

 * @got: second hash

 *

 * Compare two hashes @expected and @got. Returns 0 when they are equal, a

 * negative error code otherwise.

 */

static inline int ubifs_check_hash(const struct ubifs_info *c,

				   const u8 *expected, const u8 *got)

{

	return crypto_memneq(expected, got, c->hash_len);

}



/**

 * ubifs_check_hmac - compare two HMACs

 * @c: UBIFS file-system description object

 * @expected: first HMAC

 * @got: second HMAC

 *

 * Compare two hashes @expected and @got. Returns 0 when they are equal, a

 * negative error code otherwise.

 */

static inline int ubifs_check_hmac(const struct ubifs_info *c,

				   const u8 *expected, const u8 *got)

{

	return crypto_memneq(expected, got, c->hmac_desc_len);

}



void ubifs_bad_hash(const struct ubifs_info *c, const void *node,

		    const u8 *hash, int lnum, int offs);



int __ubifs_node_check_hash(const struct ubifs_info *c, const void *buf,

			  const u8 *expected);

static inline int ubifs_node_check_hash(const struct ubifs_info *c,

					const void *buf, const u8 *expected)

{

	if (ubifs_authenticated(c))

		return __ubifs_node_check_hash(c, buf, expected);

	else

		return 0;

}



int ubifs_init_authentication(struct ubifs_info *c);

void __ubifs_exit_authentication(struct ubifs_info *c);

static inline void ubifs_exit_authentication(struct ubifs_info *c)

{

	if (ubifs_authenticated(c))

		__ubifs_exit_authentication(c);

}



/**

 * ubifs_branch_hash - returns a pointer to the hash of a branch

 * @c: UBIFS file-system description object

 * @br: branch to get the hash from

 *

 * This returns a pointer to the hash of a branch. Since the key already is a

 * dynamically sized object we cannot use a struct member here.

 */

static inline u8 *ubifs_branch_hash(struct ubifs_info *c,

				    struct ubifs_branch *br)

{

	return (void *)br + sizeof(*br) + c->key_len;

}



/**

 * ubifs_copy_hash - copy a hash

 * @c: UBIFS file-system description object

 * @from: source hash

 * @to: destination hash

 *

 * With authentication this copies a hash, otherwise does nothing.

 */

static inline void ubifs_copy_hash(const struct ubifs_info *c, const u8 *from,

				   u8 *to)

{

	if (ubifs_authenticated(c))

		memcpy(to, from, c->hash_len);

}



int __ubifs_node_insert_hmac(const struct ubifs_info *c, void *buf,

			      int len, int ofs_hmac);

static inline int ubifs_node_insert_hmac(const struct ubifs_info *c, void *buf,

					  int len, int ofs_hmac)

{

	if (ubifs_authenticated(c))

		return __ubifs_node_insert_hmac(c, buf, len, ofs_hmac);

	else

		return 0;

}



int __ubifs_node_verify_hmac(const struct ubifs_info *c, const void *buf,

			     int len, int ofs_hmac);

static inline int ubifs_node_verify_hmac(const struct ubifs_info *c,

					 const void *buf, int len, int ofs_hmac)

{

	if (ubifs_authenticated(c))

		return __ubifs_node_verify_hmac(c, buf, len, ofs_hmac);

	else

		return 0;

}



/**

 * ubifs_auth_node_sz - returns the size of an authentication node

 * @c: UBIFS file-system description object

 *

 * This function returns the size of an authentication node which can

 * be 0 for unauthenticated filesystems or the real size of an auth node

 * authentication is enabled.

 */

static inline int ubifs_auth_node_sz(const struct ubifs_info *c)

{

	if (ubifs_authenticated(c))

		return sizeof(struct ubifs_auth_node) + c->hmac_desc_len;

	else

		return 0;

}



int ubifs_hmac_wkm(struct ubifs_info *c, u8 *hmac);



int __ubifs_shash_copy_state(const struct ubifs_info *c, struct shash_desc *src,

			     struct shash_desc *target);

static inline int ubifs_shash_copy_state(const struct ubifs_info *c,

					   struct shash_desc *src,

					   struct shash_desc *target)

{

	if (ubifs_authenticated(c))

		return __ubifs_shash_copy_state(c, src, target);

	else

		return 0;

}



/* io.c */

void ubifs_ro_mode(struct ubifs_info *c, int err);

int ubifs_leb_read(const struct ubifs_info *c, int lnum, void *buf, int offs,