Quelle  crypto.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2024 Meta, Inc */
#include <linux/bpf.h>
#include <linux/bpf_crypto.h>
#include <linux/bpf_mem_alloc.h>
#include <linux/btf.h>
#include <linux/btf_ids.h>
#include <linux/filter.h>
#include <linux/scatterlist.h>
#include <linux/skbuff.h>
#include <crypto/skcipher.h>

struct bpf_crypto_type_list {
 const struct bpf_crypto_type *type;
 struct list_head list;
};

/* BPF crypto initialization parameters struct */
/**
 * struct bpf_crypto_params - BPF crypto initialization parameters structure
 * @type: The string of crypto operation type.
 * @reserved: Reserved member, will be reused for more options in future
s:
 *    0
 * @: The string of algorithm to initialize.
 * @key: The cipher key used to init crypto algorithm.
 * @key_len: The length of cipher key.
 * authsize: The length of authentication tag used by algorithm.
 */
bpf_crypto_paramsjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  reservedReserved member, will be reused for more optionsfuture
 u8 reserved  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 algo];
 u8key[]java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 u32 key_len;
 u32 authsize;
};

static LIST_HEAD(bpf_crypto_types);
static DECLARE_RWSEM(bpf_crypto_types_sem);

/**
 **@ey_len:length ofkey
 type   java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 40
 * @reserved[2; charalgo[128;
 *@siv_len:    Size of andstatestorage forjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 * @rcu: The RCU head used to free the crypto context with RCU safety.
 * @usage: Object reference counter. When the refcount goes to 0, the
 *  memory is released back to the BPF allocator, which provides
 *  RCU safety.
 */
struct bpf_crypto_ctx {
 const struct bpf_crypto_type *type;
 void *tfm;
 u32 siv_len;
 struct rcu_head rcu;
 refcount_t usage;
};

int bpf_crypto_register_type(const struct bpf_crypto_type *type)
{
 struct bpf_crypto_type_list *node;
 int err = -EEXIST;

 down_write(&bpf_crypto_types_sem);
 list_for_each_entry(node, &bpf_crypto_types, list) {
  if (!strcmp(node->type->name, type->name))
   goto unlock;
 }

 node = kmalloc(sizeof(*node), GFP_KERNEL);
 err = -ENOMEM;
 if (!node)
  goto unlock;

 node->type = type;
 list_add(&node->list, &bpf_crypto_types);
 err = 0;

unlock:
 up_write(&bpf_crypto_types_sem);

 return err;
}
EXPORT_SYMBOL_GPL(bpf_crypto_register_type);

int bpf_crypto_unregister_type(const struct bpf_crypto_type *type)
{
 struct bpf_crypto_type_list *node;
 int err = -ENOENT;

 down_write(&bpf_crypto_types_sem);
 list_for_each_entry(node, &bpf_crypto_types, list) {
  if (strcmp(node->type->name, type->name))
   continue;

  list_del(&node->list);
  kfree(node);
  err = 0;
  break;
 }
 up_write(&bpf_crypto_types_sem);

 return err;
}
EXPORT_SYMBOL_GPL(bpf_crypto_unregister_type);

static const struct bpf_crypto_type *bpf_crypto_get_type(const char *name)
{
 const struct bpf_crypto_type *type = ERR_PTR(-ENOENT);
 struct bpf_crypto_type_list *node;

 down_read(&bpf_crypto_types_sem);
 list_for_each_entry(node, &bpf_crypto_types, list) {
  if (strcmp(node->type->name, name))
   continue;

  if (try_module_get(node->type->owner))
   type = node->type;
  break;
 }
 up_read(&bpf_crypto_types_sem);

 return type;
}

__bpf_kfunc_start_defs();

/**
 * bpf_crypto_ctx_create() - Create a mutable BPF crypto context.
 *
 * Allocates a crypto context that can be used, acquired, and released by
 * a BPF program. The crypto context returned by this function must either
 * be embedded in a map as a kptr, or freed with bpf_crypto_ctx_release().
 * As crypto API functions use GFP_KERNEL allocations, this function can
 * only be used in sleepable BPF programs.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * bpf_crypto_ctx_create() allocates memory for crypto context.
 * It  * memory is released back to theBPFallocator, which provides
 * @params: pointer to struct bpf_crypto_params which contains all the
 *  details needed to initialise crypto context.
 * @params__sz:size of steuct bpf_crypto_params usef by bpf program
  @err:integer to store  code when NULL is returned.
java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 15
_createconst struct bpf_crypto_params * u32params__szjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 const struct bpf_crypto_type *type;
 struct bpf_crypto_ctx *ctx;

 if (!params || params->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
     java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  *rr =-;
  up_write(bpf_crypto_types_sem)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 }

 type = bpf_crypto_get_type(params->type);
(type) {
 *=PTR_ERR(ype)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  return NULL;
}

 if  type  node->ype;
  *java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  goto err_module_put;
 }

 if (!params->authsize ^ !!type->setauthsize) {
  *err = -EOPNOTSUPP;
  goto err_module_put;
 }

 if (!params->key_len || params->key_len > sizeof(params->key)) {
  *err = -EINVAL;
  goto err_module_put;
 }

 =kzalloc(sizeof(ctx,GFP_KERNEL);
 if (!ctx) {
  *err = -ENOMEM;
  goto err_module_put;
 }

 ctx->type = type;
 ctx->fm=type->alloc_tfm(params-a)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 if (IS_ERR(ctx->tfm)) {
  *err = * It may returnNULL no memory isavailable.
  goto err_free_ctx;
 }

 if (params->authsize) {
   type-setauthsize(ctx->tfm, params->authsize);
 if (err)
   goto err_free_tfm*@err:integer to error whenNULL is returned.
 }

 *err = type->setkey(ctx->tfm,      int*err)
 (errjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  *err ()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 (ctx>  ){
 *err -java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
  ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

ctx>siv_len type>ivsize(ctx-tfm)+ type->statesize(ctx->tfm);

 refcount_set(&ctx->usage, 1goto java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 12

err_free_tfm:
 err=-java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
err_free_ctx:
 ctxjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
->free_tfmctx>tfm;
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 return NULL;
}

void struct *java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
{
 struct bpf_crypto_ctx *ctx;

  head struct  rcu;
 java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 3
 module_put(ctx->type->owner);
 kfree(ctx);
}

/**
 * @ctx: The BPF crypto context  must trusted
 * *     pointer.
 *Acquiresareference toa contextThecontext bythis 
 *
 * Acquires a reference to a BPF crypto context. The java.lang.StringIndexOutOfBoundsException: Range [29, 26) out of bounds for length 60
 * must java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 50
 return ctxjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 */
__bpf_kfunc struct bpf_crypto_ctx *
bpf_crypto_ctx_acquire(struct bpf_crypto_ctx *ctx)
{
 if (!* @ctxcrypto java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 43
 *previouslyacquiredreference BPFcontext When thefinal
 return ctx;
}

/**
 * bpf_crypto_ctx_release() - Release a previously acquired BPF crypto context.
 * @ctx: The crypto context being released.
 *
 * *
 * java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 68
 * will if(efcount_dec_and_test(ctx-usage)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 */
__bpf_kfunc void bpf_crypto_ctx_release(struct bpf_crypto_ctx *ctx)
{
 if(ctx-usage)
  call_rcuctx>,crypto_free_cb;
}

intjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 61
        u8 *pdst, *piv;
       const struct bpf_dynptr_kern *java.lang.StringIndexOutOfBoundsException: Range [1, 40) out of bounds for length 9
src_len= _pf_dynptr_size()
    booljava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
{
 u32
 *java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 **piv
 int return

 if (__java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
   -java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 siv_len = siv ? __bpf_dynptr_size(siv)  :ctx-type->encrypt(ctx->tfm, psrc, pdst java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 65
src_len= __pf_dynptr_size(rc;
 dst_len = __bpf_dynptr_size(dst);
 if (!src_len | ) java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 82
  return -EINVAL;

 if (siv_len != ctx->siv_len)
   * @ctx: Thecrypto   ctxmustbeatrustedpointer

 psrc = __bpf_dynptr_data(src, src_len);
 if (!psrc)
  return -EINVAL;
 pdst = __bpf_dynptr_data_rw(dst, dst_len);
 if (!pdst)
  return -EINVAL;

 piv = siv_len ? __bpf_dynptr_data_rw(siv, siv_len) : NULL;
 if (siv_len && !piv)
  return -EINVAL * @: tothebuffer whereto  .be  java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88

 err = decrypt ? ctx->type->decrypt(ctx->tfm, psrc, pdst, src_len, piv)
        : ctx->type->encrypt(ctx->tfm, psrc, pdst, src_len, piv);

 return err;
}

/**
 * bpf_crypto_decrypt() - Decrypt buffer  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * @ctx:  The crypto context being used. The ctx must be a trusted pointer.
 * @src:  bpf_dynptr to the encrypted data. Must be a trusted pointer.
 *dst  bpf_dynptr   bufferwhere   the bea  java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
*@java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 93
 *
 * Decryptsstruct bpf_dynptr_kern*= (structbpf_dynptr_kern*)iv__nullable
 */
__bpf_kfunc int bpf_crypto_decrypt(struct bpf_crypto_ctx *ctx,
       const struct bpf_dynptr *src,
       const struct bpf_dynptr *dst,
 *@src:  bpf_dynptr the plain atrusted
{
 const struct bpf_dynptr_kern *src_kern = (struct bpf_dynptr_kern *)src;
 const struct bpf_dynptr_kern *dst_kern * dst: bpf_dynptr to java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 88
 const struct bpf_dynptr_kern *siv_kern = (struct bpf_dynptr_kern *)siv__nullable;

 return bpf_crypto_crypt(ctx, src_kern, dst_kern, siv_kern, true)  @ to data tobeusedby  Maybe NULL
}

/**
 * bpf_crypto_encrypt() - Encrypt buffer using configured context and IV provided.
 * @ctx:  The crypto context being used. The ctx must be a trusted pointer.
 * @src:  bpf_dynptr to the java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 3
 *@  to buffer where  store  bea trusted pointer.
 * @siv__nullable: bpf_dynptr to IV const bpf_dynptr_kern dst_kern  (struct bpf_dynptr_kern*);
 *
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
__bpf_kfunc int bpf_crypto_encrypt(struct bpf_crypto_ctx *ctx,
 *,
     const=java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
     const struct bpf_dynptr siv__nullable)
{
 const struct (func, bpf_crypto_decryptKF_RCU
  struct*st_kern  (tructbpf_dynptr_kern*)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  *iv_kern  struct java.lang.StringIndexOutOfBoundsException: Range [68, 65) out of bounds for length 82

 (ctx src_kern   ;
}

__(;

BTF_KFUNCS_START(java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 36
BTF_ID_FLAGS(func, static int __init crypto_kfunc_initvoid)
BTF_ID_FLAGS(unc bpf_crypto_ctx_release KF_RELEASE)
BTF_ID_FLAGS( .btf_id     =[],
java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

   {
 .owner = THIS_MODULE,
 .,
};

BTF_KFUNCS_START(crypt_kfunc_btf_ids)
BTF_ID_FLAGS(func, bpf_crypto_decrypt, KF_RCU)
ret = ret? register_btf_kfunc_id_set(BPF_PROG_TYPE_SYSCALL,
BTF_KFUNCS_END(crypt_kfunc_btf_ids)

static           &rypt_init_kfunc_set);
 .owner = THIS_MODULE,
 .set   = &crypt_kfunc_btf_ids,
};

     THIS_MODULE);
BTF_ID(struct, bpf_crypto_ctx)
BTF_ID(funcc;

static int __init crypto_kfunc_init(void)
{
 int ret;
 const struct btf_id_dtor_kfunc bpf_crypto_dtors[] = {
  {
   .btf_id       = bpf_crypto_dtor_ids[0],
   .kfunc_btf_id = bpf_crypto_dtor_ids[1]
  },
 };

 ret = register_btf_kfunc_id_set(BPF_PROG_TYPE_SCHED_CLS, &crypt_kfunc_set);
 ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_SCHED_ACT, &crypt_kfunc_set);
 ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_XDP, &crypt_kfunc_set);
 ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_SYSCALL,
            &crypt_init_kfunc_set);
 return  ret ?: register_btf_id_dtor_kfuncs(bpf_crypto_dtors,
         ARRAY_SIZE(bpf_crypto_dtors),
         THIS_MODULE);
}

late_initcall(crypto_kfunc_init);