Quelle  eval.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2020-2024 Microsoft Corporation. All rights reserved.
 */

#include <linux/fs.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/file.h>
#include <linux/sched.h>
#include <linux/rcupdate.h>
#include <linux/moduleparam.h>
#include <linux/fsverity.h>

#include "ipe.h"
#include "eval.h"
#include "policy.h"
#include "audit.h"
#include "digest.h"

struct ipe_policy __rcu *ipe_active_policy;
bool success_audit;
bool enforce = true;
#define INO_BLOCK_DEV(ino) ((ino)->i_sb->s_bdev)

#define FILE_SUPERBLOCK(f) ((f)->f_path.mnt->mnt_sb)

/**
 * build_ipe_sb_ctx() - Build initramfs field of an ipe evaluation context.
 * @ctx: Supplies a pointer to the context to be populated.
 * @file: Supplies the file struct of the file triggered IPE event.
 */
static void build_ipe_sb_ctx(struct ipe_eval_ctx *ctx, const struct file *const file)
{
 ctx->initramfs = ipe_sb(FILE_SUPERBLOCK(file))->initramfs;
}

#ifdef CONFIG_IPE_PROP_DM_VERITY
/**
 * build_ipe_bdev_ctx() - Build ipe_bdev field of an evaluation context.
 * @ctx: Supplies a pointer to the context to be populated.
 * @ino: Supplies the inode struct of the file triggered IPE event.
 */
static void build_ipe_bdev_ctx(struct ipe_eval_ctx *ctx, const struct inode *const ino)
{
 if (INO_BLOCK_DEV(ino))
  ctx->ipe_bdev = ipe_bdev(INO_BLOCK_DEV(ino));
}
#else
static void build_ipe_bdev_ctx(struct ipe_eval_ctx *ctx, const struct inode *const ino)
{
}
#endif /* CONFIG_IPE_PROP_DM_VERITY */

#ifdef CONFIG_IPE_PROP_FS_VERITY
#ifdef CONFIG_IPE_PROP_FS_VERITY_BUILTIN_SIG
static void build_ipe_inode_blob_ctx(struct ipe_eval_ctx *ctx,
         const struct inode *const ino)
{
 ctx->ipe_inode = ipe_inode(ctx->ino);
}
#else
static inline void build_ipe_inode_blob_ctx(struct ipe_eval_ctx *ctx,
         const struct inode *const ino)
{
}
#endif /* CONFIG_IPE_PROP_FS_VERITY_BUILTIN_SIG */

/**
 * build_ipe_inode_ctx() - Build inode fields of an evaluation context.
 * @ctx: Supplies a pointer to the context to be populated.
 * @ino: Supplies the inode struct of the file triggered IPE event.
 */
static void build_ipe_inode_ctx(struct ipe_eval_ctx *ctx, const struct inode *const ino)
{
 ctx->ino = ino;
 build_ipe_inode_blob_ctx(ctx, ino);
}
#else
static void build_ipe_inode_ctx(struct ipe_eval_ctx *ctx, const struct inode *const ino)
{
}
#endif /* CONFIG_IPE_PROP_FS_VERITY */

/**
 * ipe_build_eval_ctx() - Build an ipe evaluation context.
 * @ctx: Supplies a pointer to the context to be populated.
 * @file: Supplies a pointer to the file to associated with the evaluation.
 * @op: Supplies the IPE policy operation associated with the evaluation.
 * @hook: Supplies the LSM hook associated with the evaluation.
 */
void ipe_build_eval_ctx(struct ipe_eval_ctx *ctx,
   const struct file *file,
   enum ipe_op_type op,
   enum ipe_hook_type hook)
{
 struct inode *ino;

 ctx->file = file;
 ctx->op = op;
 ctx->hook = hook;

 if (file) {
  build_ipe_sb_ctx(ctx, file);
  ino = d_real_inode(file->f_path.dentry);
  build_ipe_bdev_ctx(ctx, ino);
  build_ipe_inode_ctx(ctx, ino);
 }
}

/**
 * evaluate_boot_verified() - Evaluate @ctx for the boot verified property.
 * @ctx: Supplies a pointer to the context being evaluated.
 *
 * Return:
 * * %true - The current @ctx match the @p
 * * %false - The current @ctx doesn't match the @p
 */
static bool evaluate_boot_verified(const struct ipe_eval_ctx *const ctx)
{
 return ctx->initramfs;
}

#ifdef CONFIG_IPE_PROP_DM_VERITY
/**
 * evaluate_dmv_roothash() - Evaluate @ctx against a dmv roothash property.
 * @ctx: Supplies a pointer to the context being evaluated.
 * @p: Supplies a pointer to the property being evaluated.
 *
 * Return:
 * * %true - The current @ctx match the @p
 * * %false - The current @ctx doesn't match the @p
 */
static bool evaluate_dmv_roothash(const struct ipe_eval_ctx *const ctx,
      struct ipe_prop *p)
{
 return !!ctx->ipe_bdev &&
        !!ctx->ipe_bdev->root_hash &&
        ipe_digest_eval(p->value,
          ctx->ipe_bdev->root_hash);
}
#else
static bool evaluate_dmv_roothash(const struct ipe_eval_ctx *const ctx,
      struct ipe_prop *p)
{
 return false;
}
#endif /* CONFIG_IPE_PROP_DM_VERITY */

#ifdef CONFIG_IPE_PROP_DM_VERITY_SIGNATURE
/**
 * evaluate_dmv_sig_false() - Evaluate @ctx against a dmv sig false property.
 * @ctx: Supplies a pointer to the context being evaluated.
 *
 * Return:
 * * %true - The current @ctx match the property
 * * %false - The current @ctx doesn't match the property
 */
static bool evaluate_dmv_sig_false(const struct ipe_eval_ctx *const ctx)
{
 return !ctx->ipe_bdev || (!ctx->ipe_bdev->dm_verity_signed);
}

/**
 * evaluate_dmv_sig_true() - Evaluate @ctx against a dmv sig true property.
 * @ctx: Supplies a pointer to the context being evaluated.
 *
 * Return:
 * * %true - The current @ctx match the property
 * * %false - The current @ctx doesn't match the property
 */
static bool evaluate_dmv_sig_true(const struct ipe_eval_ctx *const ctx)
{
 return !evaluate_dmv_sig_false(ctx);
}
#else
static bool evaluate_dmv_sig_false(const struct ipe_eval_ctx *const ctx)
{
 return false;
}

static bool evaluate_dmv_sig_true(const struct ipe_eval_ctx *const ctx)
{
 return false;
}
#endif /* CONFIG_IPE_PROP_DM_VERITY_SIGNATURE */

#ifdef CONFIG_IPE_PROP_FS_VERITY
/**
 * evaluate_fsv_digest() - Evaluate @ctx against a fsv digest property.
 * @ctx: Supplies a pointer to the context being evaluated.
 * @p: Supplies a pointer to the property being evaluated.
 *
 * Return:
 * * %true - The current @ctx match the @p
 * * %false - The current @ctx doesn't match the @p
 */
static bool evaluate_fsv_digest(const struct ipe_eval_ctx *const ctx,
    struct ipe_prop *p)
{
 enum hash_algo alg;
 u8 digest[FS_VERITY_MAX_DIGEST_SIZE];
 struct digest_info info;

 if (!ctx->ino)
  return false;
 if (!fsverity_get_digest((struct inode *)ctx->ino,
     digest,
     NULL,
     &alg))
  return false;

 info.alg = hash_algo_name[alg];
 info.digest = digest;
 info.digest_len = hash_digest_size[alg];

 return ipe_digest_eval(p->value, &info);
}
#else
static bool evaluate_fsv_digest(const struct ipe_eval_ctx *const ctx,
    struct ipe_prop *p)
{
 return false;
}
#endif /* CONFIG_IPE_PROP_FS_VERITY */

#ifdef CONFIG_IPE_PROP_FS_VERITY_BUILTIN_SIG
/**
 * evaluate_fsv_sig_false() - Evaluate @ctx against a fsv sig false property.
 * @ctx: Supplies a pointer to the context being evaluated.
 *
 * Return:
 * * %true - The current @ctx match the property
 * * %false - The current @ctx doesn't match the property
 */
static bool evaluate_fsv_sig_false(const struct ipe_eval_ctx *const ctx)
{
 return !ctx->ino ||
        !IS_VERITY(ctx->ino) ||
        !ctx->ipe_inode ||
        !ctx->ipe_inode->fs_verity_signed;
}

/**
 * evaluate_fsv_sig_true() - Evaluate @ctx against a fsv sig true property.
 * @ctx: Supplies a pointer to the context being evaluated.
 *
 * Return:
 * * %true - The current @ctx match the property
 * * %false - The current @ctx doesn't match the property
 */
static bool evaluate_fsv_sig_true(const struct ipe_eval_ctx *const ctx)
{
 return !evaluate_fsv_sig_false(ctx);
}
#else
static bool evaluate_fsv_sig_false(const struct ipe_eval_ctx *const ctx)
{
 return false;
}

static bool evaluate_fsv_sig_true(const struct ipe_eval_ctx *const ctx)
{
 return false;
}
#endif /* CONFIG_IPE_PROP_FS_VERITY_BUILTIN_SIG */

/**
 * evaluate_property() - Analyze @ctx against a rule property.
 * @ctx: Supplies a pointer to the context to be evaluated.
 * @p: Supplies a pointer to the property to be evaluated.
 *
 * This function Determines whether the specified @ctx
 * matches the conditions defined by a rule property @p.
 *
 * Return:
 * * %true - The current @ctx match the @p
 * * %false - The current @ctx doesn't match the @p
 */
static bool evaluate_property(const struct ipe_eval_ctx *const ctx,
         struct ipe_prop *p)
{
 switch (p->type) {
 case IPE_PROP_BOOT_VERIFIED_FALSE:
  return !evaluate_boot_verified(ctx);
 case IPE_PROP_BOOT_VERIFIED_TRUE:
  return evaluate_boot_verified(ctx);
 case IPE_PROP_DMV_ROOTHASH:
  return evaluate_dmv_roothash(ctx, p);
 case IPE_PROP_DMV_SIG_FALSE:
  return evaluate_dmv_sig_false(ctx);
 case IPE_PROP_DMV_SIG_TRUE:
  return evaluate_dmv_sig_true(ctx);
 case IPE_PROP_FSV_DIGEST:
  return evaluate_fsv_digest(ctx, p);
 case IPE_PROP_FSV_SIG_FALSE:
  return evaluate_fsv_sig_false(ctx);
 case IPE_PROP_FSV_SIG_TRUE:
  return evaluate_fsv_sig_true(ctx);
 default:
  return false;
 }
}

/**
 * ipe_evaluate_event() - Analyze @ctx against the current active policy.
 * @ctx: Supplies a pointer to the context to be evaluated.
 *
 * This is the loop where all policy evaluations happen against the IPE policy.
 *
 * Return:
 * * %0 - Success
 * * %-EACCES - @ctx did not pass evaluation
 */
int ipe_evaluate_event(const struct ipe_eval_ctx *const ctx)
{
 const struct ipe_op_table *rules = NULL;
 const struct ipe_rule *rule = NULL;
 struct ipe_policy *pol = NULL;
 struct ipe_prop *prop = NULL;
 enum ipe_action_type action;
 enum ipe_match match_type;
 bool match = false;
 int rc = 0;

 rcu_read_lock();

 pol = rcu_dereference(ipe_active_policy);
 if (!pol) {
  rcu_read_unlock();
  return 0;
 }

 if (ctx->op == IPE_OP_INVALID) {
  if (pol->parsed->global_default_action == IPE_ACTION_INVALID) {
   WARN(1, "no default rule set for unknown op, ALLOW it");
   action = IPE_ACTION_ALLOW;
  } else {
   action = pol->parsed->global_default_action;
  }
  match_type = IPE_MATCH_GLOBAL;
  goto eval;
 }

 rules = &pol->parsed->rules[ctx->op];

 list_for_each_entry(rule, &rules->rules, next) {
  match = true;

  list_for_each_entry(prop, &rule->props, next) {
   match = evaluate_property(ctx, prop);
   if (!match)
    break;
  }

  if (match)
   break;
 }

 if (match) {
  action = rule->action;
  match_type = IPE_MATCH_RULE;
 } else if (rules->default_action != IPE_ACTION_INVALID) {
  action = rules->default_action;
  match_type = IPE_MATCH_TABLE;
 } else {
  action = pol->parsed->global_default_action;
  match_type = IPE_MATCH_GLOBAL;
 }

eval:
 ipe_audit_match(ctx, match_type, action, rule);
 rcu_read_unlock();

 if (action == IPE_ACTION_DENY)
  rc = -EACCES;

 if (!READ_ONCE(enforce))
  rc = 0;

 return rc;
}

/* Set the right module name */
#ifdef KBUILD_MODNAME
#undef KBUILD_MODNAME
#define KBUILD_MODNAME "ipe"
#endif

module_param(success_audit, bool, 0400);
MODULE_PARM_DESC(success_audit, "Start IPE with success auditing enabled");
module_param(enforce, bool, 0400);
MODULE_PARM_DESC(enforce, "Start IPE in enforce or permissive mode");