Quelle  pkey_base.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * Copyright IBM Corp. 2024
 *
 * Pkey base: debug feature, defines and structs
 * common to all pkey code.
 */

#ifndef _PKEY_BASE_H_
#define _PKEY_BASE_H_

#include <linux/types.h>
#include <asm/debug.h>
#include <asm/pkey.h>

/*
 * pkey debug feature
 */

extern debug_info_t *pkey_dbf_info;

#define PKEY_DBF_INFO(...) debug_sprintf_event(pkey_dbf_info, 5, ##__VA_ARGS__)
#define PKEY_DBF_WARN(...) debug_sprintf_event(pkey_dbf_info, 4, ##__VA_ARGS__)
#define PKEY_DBF_ERR(...)  debug_sprintf_event(pkey_dbf_info, 3, ##__VA_ARGS__)

/*
 * common defines and common structs
 */

#define KEYBLOBBUFSIZE 8192 /* key buffer size used for internal processing */
#define MINKEYBLOBBUFSIZE (sizeof(struct keytoken_header))
#define PROTKEYBLOBBUFSIZE 256 /* protected key buffer size used internal */
#define MAXAPQNSINLIST 64 /* max 64 apqns within a apqn list */
#define AES_WK_VP_SIZE 32 /* Size of WK VP block appended to a prot key */

/* inside view of a generic protected key token */
struct protkeytoken {
 u8  type;     /* 0x00 for PAES specific key tokens */
 u8  res0[3];
 u8  version;  /* should be 0x01 for protected key token */
 u8  res1[3];
 u32 keytype;  /* key type, one of the PKEY_KEYTYPE values */
 u32 len;      /* bytes actually stored in protkey[] */
 u8  protkey[]; /* the protected key blob */
} __packed;

/* inside view of a protected AES key token */
struct protaeskeytoken {
 u8  type;     /* 0x00 for PAES specific key tokens */
 u8  res0[3];
 u8  version;  /* should be 0x01 for protected key token */
 u8  res1[3];
 u32 keytype;  /* key type, one of the PKEY_KEYTYPE values */
 u32 len;      /* bytes actually stored in protkey[] */
 u8  protkey[MAXPROTKEYSIZE]; /* the protected key blob */
} __packed;

/* inside view of a clear key token (type 0x00 version 0x02) */
struct clearkeytoken {
 u8  type; /* 0x00 for PAES specific key tokens */
 u8  res0[3];
 u8  version; /* 0x02 for clear key token */
 u8  res1[3];
 u32 keytype; /* key type, one of the PKEY_KEYTYPE_* values */
 u32 len; /* bytes actually stored in clearkey[] */
 u8  clearkey[]; /* clear key value */
} __packed;

/* helper function which translates the PKEY_KEYTYPE_AES_* to their keysize */
static inline u32 pkey_keytype_aes_to_size(u32 keytype)
{
 switch (keytype) {
 case PKEY_KEYTYPE_AES_128:
  return 16;
 case PKEY_KEYTYPE_AES_192:
  return 24;
 case PKEY_KEYTYPE_AES_256:
  return 32;
 default:
  return 0;
 }
}

/* helper function which translates AES key bit size into PKEY_KEYTYPE_AES_* */
static inline u32 pkey_aes_bitsize_to_keytype(u32 keybitsize)
{
 switch (keybitsize) {
 case 128:
  return PKEY_KEYTYPE_AES_128;
 case 192:
  return PKEY_KEYTYPE_AES_192;
 case 256:
  return PKEY_KEYTYPE_AES_256;
 default:
  return 0;
 }
}

/*
 * helper function which translates the PKEY_KEYTYPE_*
 * to the protected key size minus the WK VP length
 */
static inline u32 pkey_keytype_to_size(u32 keytype)
{
 switch (keytype) {
 case PKEY_KEYTYPE_AES_128:
  return 16;
 case PKEY_KEYTYPE_AES_192:
  return 24;
 case PKEY_KEYTYPE_AES_256:
  return 32;
 case PKEY_KEYTYPE_ECC_P256:
  return 32;
 case PKEY_KEYTYPE_ECC_P384:
  return 48;
 case PKEY_KEYTYPE_ECC_P521:
  return 80;
 case PKEY_KEYTYPE_ECC_ED25519:
  return 32;
 case PKEY_KEYTYPE_ECC_ED448:
  return 54;
 case PKEY_KEYTYPE_AES_XTS_128:
  return 32;
 case PKEY_KEYTYPE_AES_XTS_256:
  return 64;
 case PKEY_KEYTYPE_HMAC_512:
  return 64;
 case PKEY_KEYTYPE_HMAC_1024:
  return 128;
 default:
  return 0;
 }
}

/*
 * pkey_api.c:
 */
int __init pkey_api_init(void);
void __exit pkey_api_exit(void);

/*
 * pkey_sysfs.c:
 */

extern const struct attribute_group *pkey_attr_groups[];

/*
 * pkey handler registry
 */

struct pkey_handler {
 struct module *module;
 const char *name;
 /*
 * is_supported_key() and is_supported_keytype() are called
 * within an rcu_read_lock() scope and thus must not sleep!
 */
 bool (*is_supported_key)(const u8 *key, u32 keylen);
 bool (*is_supported_keytype)(enum pkey_key_type);
 int (*key_to_protkey)(const struct pkey_apqn *apqns, size_t nr_apqns,
         const u8 *key, u32 keylen,
         u8 *protkey, u32 *protkeylen, u32 *protkeytype,
         u32 xflags);
 int (*slowpath_key_to_protkey)(const struct pkey_apqn *apqns,
           size_t nr_apqns,
           const u8 *key, u32 keylen,
           u8 *protkey, u32 *protkeylen,
           u32 *protkeytype, u32 xflags);
 int (*gen_key)(const struct pkey_apqn *apqns, size_t nr_apqns,
         u32 keytype, u32 keysubtype,
         u32 keybitsize, u32 flags,
         u8 *keybuf, u32 *keybuflen, u32 *keyinfo, u32 xflags);
 int (*clr_to_key)(const struct pkey_apqn *apqns, size_t nr_apqns,
     u32 keytype, u32 keysubtype,
     u32 keybitsize, u32 flags,
     const u8 *clrkey, u32 clrkeylen,
     u8 *keybuf, u32 *keybuflen, u32 *keyinfo, u32 xflags);
 int (*verify_key)(const u8 *key, u32 keylen,
     u16 *card, u16 *dom,
     u32 *keytype, u32 *keybitsize, u32 *flags,
     u32 xflags);
 int (*apqns_for_key)(const u8 *key, u32 keylen, u32 flags,
        struct pkey_apqn *apqns, size_t *nr_apqns,
        u32 xflags);
 int (*apqns_for_keytype)(enum pkey_key_type ktype,
     u8 cur_mkvp[32], u8 alt_mkvp[32], u32 flags,
     struct pkey_apqn *apqns, size_t *nr_apqns,
     u32 xflags);
 /* used internal by pkey base */
 struct list_head list;
};

int pkey_handler_register(struct pkey_handler *handler);
int pkey_handler_unregister(struct pkey_handler *handler);

/*
 * invocation function for the registered pkey handlers
 */

const struct pkey_handler *pkey_handler_get_keybased(const u8 *key, u32 keylen);
const struct pkey_handler *pkey_handler_get_keytypebased(enum pkey_key_type kt);
void pkey_handler_put(const struct pkey_handler *handler);

int pkey_handler_key_to_protkey(const struct pkey_apqn *apqns, size_t nr_apqns,
    const u8 *key, u32 keylen,
    u8 *protkey, u32 *protkeylen, u32 *protkeytype,
    u32 xflags);
int pkey_handler_slowpath_key_to_protkey(const struct pkey_apqn *apqns,
      size_t nr_apqns,
      const u8 *key, u32 keylen,
      u8 *protkey, u32 *protkeylen,
      u32 *protkeytype, u32 xflags);
int pkey_handler_gen_key(const struct pkey_apqn *apqns, size_t nr_apqns,
    u32 keytype, u32 keysubtype,
    u32 keybitsize, u32 flags,
    u8 *keybuf, u32 *keybuflen, u32 *keyinfo, u32 xflags);
int pkey_handler_clr_to_key(const struct pkey_apqn *apqns, size_t nr_apqns,
       u32 keytype, u32 keysubtype,
       u32 keybitsize, u32 flags,
       const u8 *clrkey, u32 clrkeylen,
       u8 *keybuf, u32 *keybuflen, u32 *keyinfo,
       u32 xflags);
int pkey_handler_verify_key(const u8 *key, u32 keylen,
       u16 *card, u16 *dom,
       u32 *keytype, u32 *keybitsize, u32 *flags,
       u32 xflags);
int pkey_handler_apqns_for_key(const u8 *key, u32 keylen, u32 flags,
          struct pkey_apqn *apqns, size_t *nr_apqns,
          u32 xflags);
int pkey_handler_apqns_for_keytype(enum pkey_key_type ktype,
       u8 cur_mkvp[32], u8 alt_mkvp[32], u32 flags,
       struct pkey_apqn *apqns, size_t *nr_apqns,
       u32 xflags);

/*
 * Unconditional try to load all handler modules
 */
void pkey_handler_request_modules(void);

#endif /* _PKEY_BASE_H_ */