mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 11:19:37 +00:00
![Harald Freudenberger](/assets/img/avatar_default.png)
The zcrypt api provides a new function to wait until the zcrypt api is operational: int zcrypt_wait_api_operational(void); The AP bus scan and the binding of ap devices to device drivers is an asynchronous job. This function waits until these initial jobs are done and so the zcrypt api should be ready to serve crypto requests - if there are resources available. The function uses an internal timeout of 60s. The very first caller will either wait for ap bus bindings complete or the timeout happens. This state will be remembered for further callers which will only be blocked until a decision is made (timeout or bindings complete). Reviewed-by: Ingo Franzki <ifranzki@linux.ibm.com> Signed-off-by: Harald Freudenberger <freude@linux.ibm.com> Signed-off-by: Heiko Carstens <hca@linux.ibm.com>
2112 lines
54 KiB
C
2112 lines
54 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* pkey device driver
|
|
*
|
|
* Copyright IBM Corp. 2017,2019
|
|
* Author(s): Harald Freudenberger
|
|
*/
|
|
|
|
#define KMSG_COMPONENT "pkey"
|
|
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/init.h>
|
|
#include <linux/miscdevice.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/kallsyms.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/random.h>
|
|
#include <linux/cpufeature.h>
|
|
#include <asm/zcrypt.h>
|
|
#include <asm/cpacf.h>
|
|
#include <asm/pkey.h>
|
|
#include <crypto/aes.h>
|
|
|
|
#include "zcrypt_api.h"
|
|
#include "zcrypt_ccamisc.h"
|
|
#include "zcrypt_ep11misc.h"
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("IBM Corporation");
|
|
MODULE_DESCRIPTION("s390 protected key interface");
|
|
|
|
#define KEYBLOBBUFSIZE 8192 /* key buffer size used for internal processing */
|
|
#define PROTKEYBLOBBUFSIZE 256 /* protected key buffer size used internal */
|
|
#define MAXAPQNSINLIST 64 /* max 64 apqns within a apqn list */
|
|
|
|
/*
|
|
* debug feature data and functions
|
|
*/
|
|
|
|
static debug_info_t *debug_info;
|
|
|
|
#define DEBUG_DBG(...) debug_sprintf_event(debug_info, 6, ##__VA_ARGS__)
|
|
#define DEBUG_INFO(...) debug_sprintf_event(debug_info, 5, ##__VA_ARGS__)
|
|
#define DEBUG_WARN(...) debug_sprintf_event(debug_info, 4, ##__VA_ARGS__)
|
|
#define DEBUG_ERR(...) debug_sprintf_event(debug_info, 3, ##__VA_ARGS__)
|
|
|
|
static void __init pkey_debug_init(void)
|
|
{
|
|
/* 5 arguments per dbf entry (including the format string ptr) */
|
|
debug_info = debug_register("pkey", 1, 1, 5 * sizeof(long));
|
|
debug_register_view(debug_info, &debug_sprintf_view);
|
|
debug_set_level(debug_info, 3);
|
|
}
|
|
|
|
static void __exit pkey_debug_exit(void)
|
|
{
|
|
debug_unregister(debug_info);
|
|
}
|
|
|
|
/* inside view of a protected key token (only type 0x00 version 0x01) */
|
|
struct protaeskeytoken {
|
|
u8 type; /* 0x00 for PAES specific key tokens */
|
|
u8 res0[3];
|
|
u8 version; /* should be 0x01 for protected AES 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 clearaeskeytoken {
|
|
u8 type; /* 0x00 for PAES specific key tokens */
|
|
u8 res0[3];
|
|
u8 version; /* 0x02 for clear AES 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;
|
|
|
|
/*
|
|
* Create a protected key from a clear key value.
|
|
*/
|
|
static int pkey_clr2protkey(u32 keytype,
|
|
const struct pkey_clrkey *clrkey,
|
|
struct pkey_protkey *protkey)
|
|
{
|
|
/* mask of available pckmo subfunctions */
|
|
static cpacf_mask_t pckmo_functions;
|
|
|
|
long fc;
|
|
int keysize;
|
|
u8 paramblock[64];
|
|
|
|
switch (keytype) {
|
|
case PKEY_KEYTYPE_AES_128:
|
|
keysize = 16;
|
|
fc = CPACF_PCKMO_ENC_AES_128_KEY;
|
|
break;
|
|
case PKEY_KEYTYPE_AES_192:
|
|
keysize = 24;
|
|
fc = CPACF_PCKMO_ENC_AES_192_KEY;
|
|
break;
|
|
case PKEY_KEYTYPE_AES_256:
|
|
keysize = 32;
|
|
fc = CPACF_PCKMO_ENC_AES_256_KEY;
|
|
break;
|
|
default:
|
|
DEBUG_ERR("%s unknown/unsupported keytype %d\n",
|
|
__func__, keytype);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Did we already check for PCKMO ? */
|
|
if (!pckmo_functions.bytes[0]) {
|
|
/* no, so check now */
|
|
if (!cpacf_query(CPACF_PCKMO, &pckmo_functions))
|
|
return -ENODEV;
|
|
}
|
|
/* check for the pckmo subfunction we need now */
|
|
if (!cpacf_test_func(&pckmo_functions, fc)) {
|
|
DEBUG_ERR("%s pckmo functions not available\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
/* prepare param block */
|
|
memset(paramblock, 0, sizeof(paramblock));
|
|
memcpy(paramblock, clrkey->clrkey, keysize);
|
|
|
|
/* call the pckmo instruction */
|
|
cpacf_pckmo(fc, paramblock);
|
|
|
|
/* copy created protected key */
|
|
protkey->type = keytype;
|
|
protkey->len = keysize + 32;
|
|
memcpy(protkey->protkey, paramblock, keysize + 32);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Find card and transform secure key into protected key.
|
|
*/
|
|
static int pkey_skey2pkey(const u8 *key, struct pkey_protkey *pkey)
|
|
{
|
|
int rc, verify;
|
|
u16 cardnr, domain;
|
|
struct keytoken_header *hdr = (struct keytoken_header *)key;
|
|
|
|
zcrypt_wait_api_operational();
|
|
|
|
/*
|
|
* The cca_xxx2protkey call may fail when a card has been
|
|
* addressed where the master key was changed after last fetch
|
|
* of the mkvp into the cache. Try 3 times: First witout verify
|
|
* then with verify and last round with verify and old master
|
|
* key verification pattern match not ignored.
|
|
*/
|
|
for (verify = 0; verify < 3; verify++) {
|
|
rc = cca_findcard(key, &cardnr, &domain, verify);
|
|
if (rc < 0)
|
|
continue;
|
|
if (rc > 0 && verify < 2)
|
|
continue;
|
|
switch (hdr->version) {
|
|
case TOKVER_CCA_AES:
|
|
rc = cca_sec2protkey(cardnr, domain,
|
|
key, pkey->protkey,
|
|
&pkey->len, &pkey->type);
|
|
break;
|
|
case TOKVER_CCA_VLSC:
|
|
rc = cca_cipher2protkey(cardnr, domain,
|
|
key, pkey->protkey,
|
|
&pkey->len, &pkey->type);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
if (rc == 0)
|
|
break;
|
|
}
|
|
|
|
if (rc)
|
|
DEBUG_DBG("%s failed rc=%d\n", __func__, rc);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Construct EP11 key with given clear key value.
|
|
*/
|
|
static int pkey_clr2ep11key(const u8 *clrkey, size_t clrkeylen,
|
|
u8 *keybuf, size_t *keybuflen)
|
|
{
|
|
int i, rc;
|
|
u16 card, dom;
|
|
u32 nr_apqns, *apqns = NULL;
|
|
|
|
zcrypt_wait_api_operational();
|
|
|
|
/* build a list of apqns suitable for ep11 keys with cpacf support */
|
|
rc = ep11_findcard2(&apqns, &nr_apqns, 0xFFFF, 0xFFFF,
|
|
ZCRYPT_CEX7, EP11_API_V, NULL);
|
|
if (rc)
|
|
goto out;
|
|
|
|
/* go through the list of apqns and try to bild an ep11 key */
|
|
for (rc = -ENODEV, i = 0; i < nr_apqns; i++) {
|
|
card = apqns[i] >> 16;
|
|
dom = apqns[i] & 0xFFFF;
|
|
rc = ep11_clr2keyblob(card, dom, clrkeylen * 8,
|
|
0, clrkey, keybuf, keybuflen);
|
|
if (rc == 0)
|
|
break;
|
|
}
|
|
|
|
out:
|
|
kfree(apqns);
|
|
if (rc)
|
|
DEBUG_DBG("%s failed rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Find card and transform EP11 secure key into protected key.
|
|
*/
|
|
static int pkey_ep11key2pkey(const u8 *key, struct pkey_protkey *pkey)
|
|
{
|
|
int i, rc;
|
|
u16 card, dom;
|
|
u32 nr_apqns, *apqns = NULL;
|
|
struct ep11keyblob *kb = (struct ep11keyblob *) key;
|
|
|
|
zcrypt_wait_api_operational();
|
|
|
|
/* build a list of apqns suitable for this key */
|
|
rc = ep11_findcard2(&apqns, &nr_apqns, 0xFFFF, 0xFFFF,
|
|
ZCRYPT_CEX7, EP11_API_V, kb->wkvp);
|
|
if (rc)
|
|
goto out;
|
|
|
|
/* go through the list of apqns and try to derive an pkey */
|
|
for (rc = -ENODEV, i = 0; i < nr_apqns; i++) {
|
|
card = apqns[i] >> 16;
|
|
dom = apqns[i] & 0xFFFF;
|
|
pkey->len = sizeof(pkey->protkey);
|
|
rc = ep11_kblob2protkey(card, dom, key, kb->head.len,
|
|
pkey->protkey, &pkey->len, &pkey->type);
|
|
if (rc == 0)
|
|
break;
|
|
}
|
|
|
|
out:
|
|
kfree(apqns);
|
|
if (rc)
|
|
DEBUG_DBG("%s failed rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Verify key and give back some info about the key.
|
|
*/
|
|
static int pkey_verifykey(const struct pkey_seckey *seckey,
|
|
u16 *pcardnr, u16 *pdomain,
|
|
u16 *pkeysize, u32 *pattributes)
|
|
{
|
|
struct secaeskeytoken *t = (struct secaeskeytoken *) seckey;
|
|
u16 cardnr, domain;
|
|
int rc;
|
|
|
|
/* check the secure key for valid AES secure key */
|
|
rc = cca_check_secaeskeytoken(debug_info, 3, (u8 *) seckey, 0);
|
|
if (rc)
|
|
goto out;
|
|
if (pattributes)
|
|
*pattributes = PKEY_VERIFY_ATTR_AES;
|
|
if (pkeysize)
|
|
*pkeysize = t->bitsize;
|
|
|
|
/* try to find a card which can handle this key */
|
|
rc = cca_findcard(seckey->seckey, &cardnr, &domain, 1);
|
|
if (rc < 0)
|
|
goto out;
|
|
|
|
if (rc > 0) {
|
|
/* key mkvp matches to old master key mkvp */
|
|
DEBUG_DBG("%s secure key has old mkvp\n", __func__);
|
|
if (pattributes)
|
|
*pattributes |= PKEY_VERIFY_ATTR_OLD_MKVP;
|
|
rc = 0;
|
|
}
|
|
|
|
if (pcardnr)
|
|
*pcardnr = cardnr;
|
|
if (pdomain)
|
|
*pdomain = domain;
|
|
|
|
out:
|
|
DEBUG_DBG("%s rc=%d\n", __func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Generate a random protected key
|
|
*/
|
|
static int pkey_genprotkey(u32 keytype, struct pkey_protkey *protkey)
|
|
{
|
|
struct pkey_clrkey clrkey;
|
|
int keysize;
|
|
int rc;
|
|
|
|
switch (keytype) {
|
|
case PKEY_KEYTYPE_AES_128:
|
|
keysize = 16;
|
|
break;
|
|
case PKEY_KEYTYPE_AES_192:
|
|
keysize = 24;
|
|
break;
|
|
case PKEY_KEYTYPE_AES_256:
|
|
keysize = 32;
|
|
break;
|
|
default:
|
|
DEBUG_ERR("%s unknown/unsupported keytype %d\n", __func__,
|
|
keytype);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* generate a dummy random clear key */
|
|
get_random_bytes(clrkey.clrkey, keysize);
|
|
|
|
/* convert it to a dummy protected key */
|
|
rc = pkey_clr2protkey(keytype, &clrkey, protkey);
|
|
if (rc)
|
|
return rc;
|
|
|
|
/* replace the key part of the protected key with random bytes */
|
|
get_random_bytes(protkey->protkey, keysize);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Verify if a protected key is still valid
|
|
*/
|
|
static int pkey_verifyprotkey(const struct pkey_protkey *protkey)
|
|
{
|
|
unsigned long fc;
|
|
struct {
|
|
u8 iv[AES_BLOCK_SIZE];
|
|
u8 key[MAXPROTKEYSIZE];
|
|
} param;
|
|
u8 null_msg[AES_BLOCK_SIZE];
|
|
u8 dest_buf[AES_BLOCK_SIZE];
|
|
unsigned int k;
|
|
|
|
switch (protkey->type) {
|
|
case PKEY_KEYTYPE_AES_128:
|
|
fc = CPACF_KMC_PAES_128;
|
|
break;
|
|
case PKEY_KEYTYPE_AES_192:
|
|
fc = CPACF_KMC_PAES_192;
|
|
break;
|
|
case PKEY_KEYTYPE_AES_256:
|
|
fc = CPACF_KMC_PAES_256;
|
|
break;
|
|
default:
|
|
DEBUG_ERR("%s unknown/unsupported keytype %d\n", __func__,
|
|
protkey->type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
memset(null_msg, 0, sizeof(null_msg));
|
|
|
|
memset(param.iv, 0, sizeof(param.iv));
|
|
memcpy(param.key, protkey->protkey, sizeof(param.key));
|
|
|
|
k = cpacf_kmc(fc | CPACF_ENCRYPT, ¶m, null_msg, dest_buf,
|
|
sizeof(null_msg));
|
|
if (k != sizeof(null_msg)) {
|
|
DEBUG_ERR("%s protected key is not valid\n", __func__);
|
|
return -EKEYREJECTED;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Transform a non-CCA key token into a protected key
|
|
*/
|
|
static int pkey_nonccatok2pkey(const u8 *key, u32 keylen,
|
|
struct pkey_protkey *protkey)
|
|
{
|
|
int rc = -EINVAL;
|
|
u8 *tmpbuf = NULL;
|
|
struct keytoken_header *hdr = (struct keytoken_header *)key;
|
|
|
|
switch (hdr->version) {
|
|
case TOKVER_PROTECTED_KEY: {
|
|
struct protaeskeytoken *t;
|
|
|
|
if (keylen != sizeof(struct protaeskeytoken))
|
|
goto out;
|
|
t = (struct protaeskeytoken *)key;
|
|
protkey->len = t->len;
|
|
protkey->type = t->keytype;
|
|
memcpy(protkey->protkey, t->protkey,
|
|
sizeof(protkey->protkey));
|
|
rc = pkey_verifyprotkey(protkey);
|
|
break;
|
|
}
|
|
case TOKVER_CLEAR_KEY: {
|
|
struct clearaeskeytoken *t;
|
|
struct pkey_clrkey ckey;
|
|
union u_tmpbuf {
|
|
u8 skey[SECKEYBLOBSIZE];
|
|
u8 ep11key[MAXEP11AESKEYBLOBSIZE];
|
|
};
|
|
size_t tmpbuflen = sizeof(union u_tmpbuf);
|
|
|
|
if (keylen < sizeof(struct clearaeskeytoken))
|
|
goto out;
|
|
t = (struct clearaeskeytoken *)key;
|
|
if (keylen != sizeof(*t) + t->len)
|
|
goto out;
|
|
if ((t->keytype == PKEY_KEYTYPE_AES_128 && t->len == 16)
|
|
|| (t->keytype == PKEY_KEYTYPE_AES_192 && t->len == 24)
|
|
|| (t->keytype == PKEY_KEYTYPE_AES_256 && t->len == 32))
|
|
memcpy(ckey.clrkey, t->clearkey, t->len);
|
|
else
|
|
goto out;
|
|
/* alloc temp key buffer space */
|
|
tmpbuf = kmalloc(tmpbuflen, GFP_ATOMIC);
|
|
if (!tmpbuf) {
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
/* try direct way with the PCKMO instruction */
|
|
rc = pkey_clr2protkey(t->keytype, &ckey, protkey);
|
|
if (rc == 0)
|
|
break;
|
|
/* PCKMO failed, so try the CCA secure key way */
|
|
zcrypt_wait_api_operational();
|
|
rc = cca_clr2seckey(0xFFFF, 0xFFFF, t->keytype,
|
|
ckey.clrkey, tmpbuf);
|
|
if (rc == 0)
|
|
rc = pkey_skey2pkey(tmpbuf, protkey);
|
|
if (rc == 0)
|
|
break;
|
|
/* if the CCA way also failed, let's try via EP11 */
|
|
rc = pkey_clr2ep11key(ckey.clrkey, t->len,
|
|
tmpbuf, &tmpbuflen);
|
|
if (rc == 0)
|
|
rc = pkey_ep11key2pkey(tmpbuf, protkey);
|
|
/* now we should really have an protected key */
|
|
DEBUG_ERR("%s unable to build protected key from clear",
|
|
__func__);
|
|
break;
|
|
}
|
|
case TOKVER_EP11_AES: {
|
|
/* check ep11 key for exportable as protected key */
|
|
rc = ep11_check_aes_key(debug_info, 3, key, keylen, 1);
|
|
if (rc)
|
|
goto out;
|
|
rc = pkey_ep11key2pkey(key, protkey);
|
|
break;
|
|
}
|
|
case TOKVER_EP11_AES_WITH_HEADER:
|
|
/* check ep11 key with header for exportable as protected key */
|
|
rc = ep11_check_aes_key_with_hdr(debug_info, 3, key, keylen, 1);
|
|
if (rc)
|
|
goto out;
|
|
rc = pkey_ep11key2pkey(key + sizeof(struct ep11kblob_header),
|
|
protkey);
|
|
break;
|
|
default:
|
|
DEBUG_ERR("%s unknown/unsupported non-CCA token version %d\n",
|
|
__func__, hdr->version);
|
|
rc = -EINVAL;
|
|
}
|
|
|
|
out:
|
|
kfree(tmpbuf);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Transform a CCA internal key token into a protected key
|
|
*/
|
|
static int pkey_ccainttok2pkey(const u8 *key, u32 keylen,
|
|
struct pkey_protkey *protkey)
|
|
{
|
|
struct keytoken_header *hdr = (struct keytoken_header *)key;
|
|
|
|
switch (hdr->version) {
|
|
case TOKVER_CCA_AES:
|
|
if (keylen != sizeof(struct secaeskeytoken))
|
|
return -EINVAL;
|
|
break;
|
|
case TOKVER_CCA_VLSC:
|
|
if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE)
|
|
return -EINVAL;
|
|
break;
|
|
default:
|
|
DEBUG_ERR("%s unknown/unsupported CCA internal token version %d\n",
|
|
__func__, hdr->version);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return pkey_skey2pkey(key, protkey);
|
|
}
|
|
|
|
/*
|
|
* Transform a key blob (of any type) into a protected key
|
|
*/
|
|
int pkey_keyblob2pkey(const u8 *key, u32 keylen,
|
|
struct pkey_protkey *protkey)
|
|
{
|
|
int rc;
|
|
struct keytoken_header *hdr = (struct keytoken_header *)key;
|
|
|
|
if (keylen < sizeof(struct keytoken_header)) {
|
|
DEBUG_ERR("%s invalid keylen %d\n", __func__, keylen);
|
|
return -EINVAL;
|
|
}
|
|
|
|
switch (hdr->type) {
|
|
case TOKTYPE_NON_CCA:
|
|
rc = pkey_nonccatok2pkey(key, keylen, protkey);
|
|
break;
|
|
case TOKTYPE_CCA_INTERNAL:
|
|
rc = pkey_ccainttok2pkey(key, keylen, protkey);
|
|
break;
|
|
default:
|
|
DEBUG_ERR("%s unknown/unsupported blob type %d\n",
|
|
__func__, hdr->type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
DEBUG_DBG("%s rc=%d\n", __func__, rc);
|
|
return rc;
|
|
|
|
}
|
|
EXPORT_SYMBOL(pkey_keyblob2pkey);
|
|
|
|
static int pkey_genseckey2(const struct pkey_apqn *apqns, size_t nr_apqns,
|
|
enum pkey_key_type ktype, enum pkey_key_size ksize,
|
|
u32 kflags, u8 *keybuf, size_t *keybufsize)
|
|
{
|
|
int i, card, dom, rc;
|
|
|
|
/* check for at least one apqn given */
|
|
if (!apqns || !nr_apqns)
|
|
return -EINVAL;
|
|
|
|
/* check key type and size */
|
|
switch (ktype) {
|
|
case PKEY_TYPE_CCA_DATA:
|
|
case PKEY_TYPE_CCA_CIPHER:
|
|
if (*keybufsize < SECKEYBLOBSIZE)
|
|
return -EINVAL;
|
|
break;
|
|
case PKEY_TYPE_EP11:
|
|
if (*keybufsize < MINEP11AESKEYBLOBSIZE)
|
|
return -EINVAL;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
switch (ksize) {
|
|
case PKEY_SIZE_AES_128:
|
|
case PKEY_SIZE_AES_192:
|
|
case PKEY_SIZE_AES_256:
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* simple try all apqns from the list */
|
|
for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
|
|
card = apqns[i].card;
|
|
dom = apqns[i].domain;
|
|
if (ktype == PKEY_TYPE_EP11) {
|
|
rc = ep11_genaeskey(card, dom, ksize, kflags,
|
|
keybuf, keybufsize);
|
|
} else if (ktype == PKEY_TYPE_CCA_DATA) {
|
|
rc = cca_genseckey(card, dom, ksize, keybuf);
|
|
*keybufsize = (rc ? 0 : SECKEYBLOBSIZE);
|
|
} else /* TOKVER_CCA_VLSC */
|
|
rc = cca_gencipherkey(card, dom, ksize, kflags,
|
|
keybuf, keybufsize);
|
|
if (rc == 0)
|
|
break;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int pkey_clr2seckey2(const struct pkey_apqn *apqns, size_t nr_apqns,
|
|
enum pkey_key_type ktype, enum pkey_key_size ksize,
|
|
u32 kflags, const u8 *clrkey,
|
|
u8 *keybuf, size_t *keybufsize)
|
|
{
|
|
int i, card, dom, rc;
|
|
|
|
/* check for at least one apqn given */
|
|
if (!apqns || !nr_apqns)
|
|
return -EINVAL;
|
|
|
|
/* check key type and size */
|
|
switch (ktype) {
|
|
case PKEY_TYPE_CCA_DATA:
|
|
case PKEY_TYPE_CCA_CIPHER:
|
|
if (*keybufsize < SECKEYBLOBSIZE)
|
|
return -EINVAL;
|
|
break;
|
|
case PKEY_TYPE_EP11:
|
|
if (*keybufsize < MINEP11AESKEYBLOBSIZE)
|
|
return -EINVAL;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
switch (ksize) {
|
|
case PKEY_SIZE_AES_128:
|
|
case PKEY_SIZE_AES_192:
|
|
case PKEY_SIZE_AES_256:
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
zcrypt_wait_api_operational();
|
|
|
|
/* simple try all apqns from the list */
|
|
for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
|
|
card = apqns[i].card;
|
|
dom = apqns[i].domain;
|
|
if (ktype == PKEY_TYPE_EP11) {
|
|
rc = ep11_clr2keyblob(card, dom, ksize, kflags,
|
|
clrkey, keybuf, keybufsize);
|
|
} else if (ktype == PKEY_TYPE_CCA_DATA) {
|
|
rc = cca_clr2seckey(card, dom, ksize,
|
|
clrkey, keybuf);
|
|
*keybufsize = (rc ? 0 : SECKEYBLOBSIZE);
|
|
} else /* TOKVER_CCA_VLSC */
|
|
rc = cca_clr2cipherkey(card, dom, ksize, kflags,
|
|
clrkey, keybuf, keybufsize);
|
|
if (rc == 0)
|
|
break;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int pkey_verifykey2(const u8 *key, size_t keylen,
|
|
u16 *cardnr, u16 *domain,
|
|
enum pkey_key_type *ktype,
|
|
enum pkey_key_size *ksize, u32 *flags)
|
|
{
|
|
int rc;
|
|
u32 _nr_apqns, *_apqns = NULL;
|
|
struct keytoken_header *hdr = (struct keytoken_header *)key;
|
|
|
|
if (keylen < sizeof(struct keytoken_header))
|
|
return -EINVAL;
|
|
|
|
if (hdr->type == TOKTYPE_CCA_INTERNAL
|
|
&& hdr->version == TOKVER_CCA_AES) {
|
|
struct secaeskeytoken *t = (struct secaeskeytoken *)key;
|
|
|
|
rc = cca_check_secaeskeytoken(debug_info, 3, key, 0);
|
|
if (rc)
|
|
goto out;
|
|
if (ktype)
|
|
*ktype = PKEY_TYPE_CCA_DATA;
|
|
if (ksize)
|
|
*ksize = (enum pkey_key_size) t->bitsize;
|
|
|
|
rc = cca_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain,
|
|
ZCRYPT_CEX3C, AES_MK_SET, t->mkvp, 0, 1);
|
|
if (rc == 0 && flags)
|
|
*flags = PKEY_FLAGS_MATCH_CUR_MKVP;
|
|
if (rc == -ENODEV) {
|
|
rc = cca_findcard2(&_apqns, &_nr_apqns,
|
|
*cardnr, *domain,
|
|
ZCRYPT_CEX3C, AES_MK_SET,
|
|
0, t->mkvp, 1);
|
|
if (rc == 0 && flags)
|
|
*flags = PKEY_FLAGS_MATCH_ALT_MKVP;
|
|
}
|
|
if (rc)
|
|
goto out;
|
|
|
|
*cardnr = ((struct pkey_apqn *)_apqns)->card;
|
|
*domain = ((struct pkey_apqn *)_apqns)->domain;
|
|
|
|
} else if (hdr->type == TOKTYPE_CCA_INTERNAL
|
|
&& hdr->version == TOKVER_CCA_VLSC) {
|
|
struct cipherkeytoken *t = (struct cipherkeytoken *)key;
|
|
|
|
rc = cca_check_secaescipherkey(debug_info, 3, key, 0, 1);
|
|
if (rc)
|
|
goto out;
|
|
if (ktype)
|
|
*ktype = PKEY_TYPE_CCA_CIPHER;
|
|
if (ksize) {
|
|
*ksize = PKEY_SIZE_UNKNOWN;
|
|
if (!t->plfver && t->wpllen == 512)
|
|
*ksize = PKEY_SIZE_AES_128;
|
|
else if (!t->plfver && t->wpllen == 576)
|
|
*ksize = PKEY_SIZE_AES_192;
|
|
else if (!t->plfver && t->wpllen == 640)
|
|
*ksize = PKEY_SIZE_AES_256;
|
|
}
|
|
|
|
rc = cca_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain,
|
|
ZCRYPT_CEX6, AES_MK_SET, t->mkvp0, 0, 1);
|
|
if (rc == 0 && flags)
|
|
*flags = PKEY_FLAGS_MATCH_CUR_MKVP;
|
|
if (rc == -ENODEV) {
|
|
rc = cca_findcard2(&_apqns, &_nr_apqns,
|
|
*cardnr, *domain,
|
|
ZCRYPT_CEX6, AES_MK_SET,
|
|
0, t->mkvp0, 1);
|
|
if (rc == 0 && flags)
|
|
*flags = PKEY_FLAGS_MATCH_ALT_MKVP;
|
|
}
|
|
if (rc)
|
|
goto out;
|
|
|
|
*cardnr = ((struct pkey_apqn *)_apqns)->card;
|
|
*domain = ((struct pkey_apqn *)_apqns)->domain;
|
|
|
|
} else if (hdr->type == TOKTYPE_NON_CCA
|
|
&& hdr->version == TOKVER_EP11_AES) {
|
|
struct ep11keyblob *kb = (struct ep11keyblob *)key;
|
|
|
|
rc = ep11_check_aes_key(debug_info, 3, key, keylen, 1);
|
|
if (rc)
|
|
goto out;
|
|
if (ktype)
|
|
*ktype = PKEY_TYPE_EP11;
|
|
if (ksize)
|
|
*ksize = kb->head.keybitlen;
|
|
|
|
rc = ep11_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain,
|
|
ZCRYPT_CEX7, EP11_API_V, kb->wkvp);
|
|
if (rc)
|
|
goto out;
|
|
|
|
if (flags)
|
|
*flags = PKEY_FLAGS_MATCH_CUR_MKVP;
|
|
|
|
*cardnr = ((struct pkey_apqn *)_apqns)->card;
|
|
*domain = ((struct pkey_apqn *)_apqns)->domain;
|
|
|
|
} else
|
|
rc = -EINVAL;
|
|
|
|
out:
|
|
kfree(_apqns);
|
|
return rc;
|
|
}
|
|
|
|
static int pkey_keyblob2pkey2(const struct pkey_apqn *apqns, size_t nr_apqns,
|
|
const u8 *key, size_t keylen,
|
|
struct pkey_protkey *pkey)
|
|
{
|
|
int i, card, dom, rc;
|
|
struct keytoken_header *hdr = (struct keytoken_header *)key;
|
|
|
|
/* check for at least one apqn given */
|
|
if (!apqns || !nr_apqns)
|
|
return -EINVAL;
|
|
|
|
if (keylen < sizeof(struct keytoken_header))
|
|
return -EINVAL;
|
|
|
|
if (hdr->type == TOKTYPE_CCA_INTERNAL) {
|
|
if (hdr->version == TOKVER_CCA_AES) {
|
|
if (keylen != sizeof(struct secaeskeytoken))
|
|
return -EINVAL;
|
|
if (cca_check_secaeskeytoken(debug_info, 3, key, 0))
|
|
return -EINVAL;
|
|
} else if (hdr->version == TOKVER_CCA_VLSC) {
|
|
if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE)
|
|
return -EINVAL;
|
|
if (cca_check_secaescipherkey(debug_info, 3, key, 0, 1))
|
|
return -EINVAL;
|
|
} else {
|
|
DEBUG_ERR("%s unknown CCA internal token version %d\n",
|
|
__func__, hdr->version);
|
|
return -EINVAL;
|
|
}
|
|
} else if (hdr->type == TOKTYPE_NON_CCA) {
|
|
if (hdr->version == TOKVER_EP11_AES) {
|
|
if (keylen < sizeof(struct ep11keyblob))
|
|
return -EINVAL;
|
|
if (ep11_check_aes_key(debug_info, 3, key, keylen, 1))
|
|
return -EINVAL;
|
|
} else {
|
|
return pkey_nonccatok2pkey(key, keylen, pkey);
|
|
}
|
|
} else {
|
|
DEBUG_ERR("%s unknown/unsupported blob type %d\n",
|
|
__func__, hdr->type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
zcrypt_wait_api_operational();
|
|
|
|
/* simple try all apqns from the list */
|
|
for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
|
|
card = apqns[i].card;
|
|
dom = apqns[i].domain;
|
|
if (hdr->type == TOKTYPE_CCA_INTERNAL
|
|
&& hdr->version == TOKVER_CCA_AES)
|
|
rc = cca_sec2protkey(card, dom, key, pkey->protkey,
|
|
&pkey->len, &pkey->type);
|
|
else if (hdr->type == TOKTYPE_CCA_INTERNAL
|
|
&& hdr->version == TOKVER_CCA_VLSC)
|
|
rc = cca_cipher2protkey(card, dom, key, pkey->protkey,
|
|
&pkey->len, &pkey->type);
|
|
else { /* EP11 AES secure key blob */
|
|
struct ep11keyblob *kb = (struct ep11keyblob *) key;
|
|
|
|
pkey->len = sizeof(pkey->protkey);
|
|
rc = ep11_kblob2protkey(card, dom, key, kb->head.len,
|
|
pkey->protkey, &pkey->len,
|
|
&pkey->type);
|
|
}
|
|
if (rc == 0)
|
|
break;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int pkey_apqns4key(const u8 *key, size_t keylen, u32 flags,
|
|
struct pkey_apqn *apqns, size_t *nr_apqns)
|
|
{
|
|
int rc;
|
|
u32 _nr_apqns, *_apqns = NULL;
|
|
struct keytoken_header *hdr = (struct keytoken_header *)key;
|
|
|
|
if (keylen < sizeof(struct keytoken_header) || flags == 0)
|
|
return -EINVAL;
|
|
|
|
zcrypt_wait_api_operational();
|
|
|
|
if (hdr->type == TOKTYPE_NON_CCA
|
|
&& (hdr->version == TOKVER_EP11_AES_WITH_HEADER
|
|
|| hdr->version == TOKVER_EP11_ECC_WITH_HEADER)
|
|
&& is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
|
|
int minhwtype = 0, api = 0;
|
|
struct ep11keyblob *kb = (struct ep11keyblob *)
|
|
(key + sizeof(struct ep11kblob_header));
|
|
|
|
if (flags != PKEY_FLAGS_MATCH_CUR_MKVP)
|
|
return -EINVAL;
|
|
if (kb->attr & EP11_BLOB_PKEY_EXTRACTABLE) {
|
|
minhwtype = ZCRYPT_CEX7;
|
|
api = EP11_API_V;
|
|
}
|
|
rc = ep11_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
|
|
minhwtype, api, kb->wkvp);
|
|
if (rc)
|
|
goto out;
|
|
} else if (hdr->type == TOKTYPE_NON_CCA
|
|
&& hdr->version == TOKVER_EP11_AES
|
|
&& is_ep11_keyblob(key)) {
|
|
int minhwtype = 0, api = 0;
|
|
struct ep11keyblob *kb = (struct ep11keyblob *) key;
|
|
|
|
if (flags != PKEY_FLAGS_MATCH_CUR_MKVP)
|
|
return -EINVAL;
|
|
if (kb->attr & EP11_BLOB_PKEY_EXTRACTABLE) {
|
|
minhwtype = ZCRYPT_CEX7;
|
|
api = EP11_API_V;
|
|
}
|
|
rc = ep11_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
|
|
minhwtype, api, kb->wkvp);
|
|
if (rc)
|
|
goto out;
|
|
} else if (hdr->type == TOKTYPE_CCA_INTERNAL) {
|
|
int minhwtype = ZCRYPT_CEX3C;
|
|
u64 cur_mkvp = 0, old_mkvp = 0;
|
|
|
|
if (hdr->version == TOKVER_CCA_AES) {
|
|
struct secaeskeytoken *t = (struct secaeskeytoken *)key;
|
|
|
|
if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
|
|
cur_mkvp = t->mkvp;
|
|
if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
|
|
old_mkvp = t->mkvp;
|
|
} else if (hdr->version == TOKVER_CCA_VLSC) {
|
|
struct cipherkeytoken *t = (struct cipherkeytoken *)key;
|
|
|
|
minhwtype = ZCRYPT_CEX6;
|
|
if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
|
|
cur_mkvp = t->mkvp0;
|
|
if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
|
|
old_mkvp = t->mkvp0;
|
|
} else {
|
|
/* unknown cca internal token type */
|
|
return -EINVAL;
|
|
}
|
|
rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
|
|
minhwtype, AES_MK_SET,
|
|
cur_mkvp, old_mkvp, 1);
|
|
if (rc)
|
|
goto out;
|
|
} else if (hdr->type == TOKTYPE_CCA_INTERNAL_PKA) {
|
|
u64 cur_mkvp = 0, old_mkvp = 0;
|
|
struct eccprivkeytoken *t = (struct eccprivkeytoken *)key;
|
|
|
|
if (t->secid == 0x20) {
|
|
if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
|
|
cur_mkvp = t->mkvp;
|
|
if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
|
|
old_mkvp = t->mkvp;
|
|
} else {
|
|
/* unknown cca internal 2 token type */
|
|
return -EINVAL;
|
|
}
|
|
rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
|
|
ZCRYPT_CEX7, APKA_MK_SET,
|
|
cur_mkvp, old_mkvp, 1);
|
|
if (rc)
|
|
goto out;
|
|
} else
|
|
return -EINVAL;
|
|
|
|
if (apqns) {
|
|
if (*nr_apqns < _nr_apqns)
|
|
rc = -ENOSPC;
|
|
else
|
|
memcpy(apqns, _apqns, _nr_apqns * sizeof(u32));
|
|
}
|
|
*nr_apqns = _nr_apqns;
|
|
|
|
out:
|
|
kfree(_apqns);
|
|
return rc;
|
|
}
|
|
|
|
static int pkey_apqns4keytype(enum pkey_key_type ktype,
|
|
u8 cur_mkvp[32], u8 alt_mkvp[32], u32 flags,
|
|
struct pkey_apqn *apqns, size_t *nr_apqns)
|
|
{
|
|
int rc;
|
|
u32 _nr_apqns, *_apqns = NULL;
|
|
|
|
zcrypt_wait_api_operational();
|
|
|
|
if (ktype == PKEY_TYPE_CCA_DATA || ktype == PKEY_TYPE_CCA_CIPHER) {
|
|
u64 cur_mkvp = 0, old_mkvp = 0;
|
|
int minhwtype = ZCRYPT_CEX3C;
|
|
|
|
if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
|
|
cur_mkvp = *((u64 *) cur_mkvp);
|
|
if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
|
|
old_mkvp = *((u64 *) alt_mkvp);
|
|
if (ktype == PKEY_TYPE_CCA_CIPHER)
|
|
minhwtype = ZCRYPT_CEX6;
|
|
rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
|
|
minhwtype, AES_MK_SET,
|
|
cur_mkvp, old_mkvp, 1);
|
|
if (rc)
|
|
goto out;
|
|
} else if (ktype == PKEY_TYPE_CCA_ECC) {
|
|
u64 cur_mkvp = 0, old_mkvp = 0;
|
|
|
|
if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
|
|
cur_mkvp = *((u64 *) cur_mkvp);
|
|
if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
|
|
old_mkvp = *((u64 *) alt_mkvp);
|
|
rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
|
|
ZCRYPT_CEX7, APKA_MK_SET,
|
|
cur_mkvp, old_mkvp, 1);
|
|
if (rc)
|
|
goto out;
|
|
|
|
} else if (ktype == PKEY_TYPE_EP11 ||
|
|
ktype == PKEY_TYPE_EP11_AES ||
|
|
ktype == PKEY_TYPE_EP11_ECC) {
|
|
u8 *wkvp = NULL;
|
|
|
|
if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
|
|
wkvp = cur_mkvp;
|
|
rc = ep11_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
|
|
ZCRYPT_CEX7, EP11_API_V, wkvp);
|
|
if (rc)
|
|
goto out;
|
|
|
|
} else
|
|
return -EINVAL;
|
|
|
|
if (apqns) {
|
|
if (*nr_apqns < _nr_apqns)
|
|
rc = -ENOSPC;
|
|
else
|
|
memcpy(apqns, _apqns, _nr_apqns * sizeof(u32));
|
|
}
|
|
*nr_apqns = _nr_apqns;
|
|
|
|
out:
|
|
kfree(_apqns);
|
|
return rc;
|
|
}
|
|
|
|
static int pkey_keyblob2pkey3(const struct pkey_apqn *apqns, size_t nr_apqns,
|
|
const u8 *key, size_t keylen, u32 *protkeytype,
|
|
u8 *protkey, u32 *protkeylen)
|
|
{
|
|
int i, card, dom, rc;
|
|
struct keytoken_header *hdr = (struct keytoken_header *)key;
|
|
|
|
/* check for at least one apqn given */
|
|
if (!apqns || !nr_apqns)
|
|
return -EINVAL;
|
|
|
|
if (keylen < sizeof(struct keytoken_header))
|
|
return -EINVAL;
|
|
|
|
if (hdr->type == TOKTYPE_NON_CCA
|
|
&& hdr->version == TOKVER_EP11_AES_WITH_HEADER
|
|
&& is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
|
|
/* EP11 AES key blob with header */
|
|
if (ep11_check_aes_key_with_hdr(debug_info, 3, key, keylen, 1))
|
|
return -EINVAL;
|
|
} else if (hdr->type == TOKTYPE_NON_CCA
|
|
&& hdr->version == TOKVER_EP11_ECC_WITH_HEADER
|
|
&& is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
|
|
/* EP11 ECC key blob with header */
|
|
if (ep11_check_ecc_key_with_hdr(debug_info, 3, key, keylen, 1))
|
|
return -EINVAL;
|
|
} else if (hdr->type == TOKTYPE_NON_CCA
|
|
&& hdr->version == TOKVER_EP11_AES
|
|
&& is_ep11_keyblob(key)) {
|
|
/* EP11 AES key blob with header in session field */
|
|
if (ep11_check_aes_key(debug_info, 3, key, keylen, 1))
|
|
return -EINVAL;
|
|
} else if (hdr->type == TOKTYPE_CCA_INTERNAL) {
|
|
if (hdr->version == TOKVER_CCA_AES) {
|
|
/* CCA AES data key */
|
|
if (keylen != sizeof(struct secaeskeytoken))
|
|
return -EINVAL;
|
|
if (cca_check_secaeskeytoken(debug_info, 3, key, 0))
|
|
return -EINVAL;
|
|
} else if (hdr->version == TOKVER_CCA_VLSC) {
|
|
/* CCA AES cipher key */
|
|
if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE)
|
|
return -EINVAL;
|
|
if (cca_check_secaescipherkey(debug_info, 3, key, 0, 1))
|
|
return -EINVAL;
|
|
} else {
|
|
DEBUG_ERR("%s unknown CCA internal token version %d\n",
|
|
__func__, hdr->version);
|
|
return -EINVAL;
|
|
}
|
|
} else if (hdr->type == TOKTYPE_CCA_INTERNAL_PKA) {
|
|
/* CCA ECC (private) key */
|
|
if (keylen < sizeof(struct eccprivkeytoken))
|
|
return -EINVAL;
|
|
if (cca_check_sececckeytoken(debug_info, 3, key, keylen, 1))
|
|
return -EINVAL;
|
|
} else if (hdr->type == TOKTYPE_NON_CCA) {
|
|
struct pkey_protkey pkey;
|
|
|
|
rc = pkey_nonccatok2pkey(key, keylen, &pkey);
|
|
if (rc)
|
|
return rc;
|
|
memcpy(protkey, pkey.protkey, pkey.len);
|
|
*protkeylen = pkey.len;
|
|
*protkeytype = pkey.type;
|
|
return 0;
|
|
} else {
|
|
DEBUG_ERR("%s unknown/unsupported blob type %d\n",
|
|
__func__, hdr->type);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* simple try all apqns from the list */
|
|
for (rc = -ENODEV, i = 0; rc && i < nr_apqns; i++) {
|
|
card = apqns[i].card;
|
|
dom = apqns[i].domain;
|
|
if (hdr->type == TOKTYPE_NON_CCA
|
|
&& (hdr->version == TOKVER_EP11_AES_WITH_HEADER
|
|
|| hdr->version == TOKVER_EP11_ECC_WITH_HEADER)
|
|
&& is_ep11_keyblob(key + sizeof(struct ep11kblob_header)))
|
|
rc = ep11_kblob2protkey(card, dom, key, hdr->len,
|
|
protkey, protkeylen, protkeytype);
|
|
else if (hdr->type == TOKTYPE_NON_CCA
|
|
&& hdr->version == TOKVER_EP11_AES
|
|
&& is_ep11_keyblob(key))
|
|
rc = ep11_kblob2protkey(card, dom, key, hdr->len,
|
|
protkey, protkeylen, protkeytype);
|
|
else if (hdr->type == TOKTYPE_CCA_INTERNAL &&
|
|
hdr->version == TOKVER_CCA_AES)
|
|
rc = cca_sec2protkey(card, dom, key, protkey,
|
|
protkeylen, protkeytype);
|
|
else if (hdr->type == TOKTYPE_CCA_INTERNAL &&
|
|
hdr->version == TOKVER_CCA_VLSC)
|
|
rc = cca_cipher2protkey(card, dom, key, protkey,
|
|
protkeylen, protkeytype);
|
|
else if (hdr->type == TOKTYPE_CCA_INTERNAL_PKA)
|
|
rc = cca_ecc2protkey(card, dom, key, protkey,
|
|
protkeylen, protkeytype);
|
|
else
|
|
return -EINVAL;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* File io functions
|
|
*/
|
|
|
|
static void *_copy_key_from_user(void __user *ukey, size_t keylen)
|
|
{
|
|
if (!ukey || keylen < MINKEYBLOBSIZE || keylen > KEYBLOBBUFSIZE)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
return memdup_user(ukey, keylen);
|
|
}
|
|
|
|
static void *_copy_apqns_from_user(void __user *uapqns, size_t nr_apqns)
|
|
{
|
|
if (!uapqns || nr_apqns == 0)
|
|
return NULL;
|
|
|
|
return memdup_user(uapqns, nr_apqns * sizeof(struct pkey_apqn));
|
|
}
|
|
|
|
static long pkey_unlocked_ioctl(struct file *filp, unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
int rc;
|
|
|
|
switch (cmd) {
|
|
case PKEY_GENSECK: {
|
|
struct pkey_genseck __user *ugs = (void __user *) arg;
|
|
struct pkey_genseck kgs;
|
|
|
|
if (copy_from_user(&kgs, ugs, sizeof(kgs)))
|
|
return -EFAULT;
|
|
rc = cca_genseckey(kgs.cardnr, kgs.domain,
|
|
kgs.keytype, kgs.seckey.seckey);
|
|
DEBUG_DBG("%s cca_genseckey()=%d\n", __func__, rc);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(ugs, &kgs, sizeof(kgs)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
case PKEY_CLR2SECK: {
|
|
struct pkey_clr2seck __user *ucs = (void __user *) arg;
|
|
struct pkey_clr2seck kcs;
|
|
|
|
if (copy_from_user(&kcs, ucs, sizeof(kcs)))
|
|
return -EFAULT;
|
|
rc = cca_clr2seckey(kcs.cardnr, kcs.domain, kcs.keytype,
|
|
kcs.clrkey.clrkey, kcs.seckey.seckey);
|
|
DEBUG_DBG("%s cca_clr2seckey()=%d\n", __func__, rc);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(ucs, &kcs, sizeof(kcs)))
|
|
return -EFAULT;
|
|
memzero_explicit(&kcs, sizeof(kcs));
|
|
break;
|
|
}
|
|
case PKEY_SEC2PROTK: {
|
|
struct pkey_sec2protk __user *usp = (void __user *) arg;
|
|
struct pkey_sec2protk ksp;
|
|
|
|
if (copy_from_user(&ksp, usp, sizeof(ksp)))
|
|
return -EFAULT;
|
|
rc = cca_sec2protkey(ksp.cardnr, ksp.domain,
|
|
ksp.seckey.seckey, ksp.protkey.protkey,
|
|
&ksp.protkey.len, &ksp.protkey.type);
|
|
DEBUG_DBG("%s cca_sec2protkey()=%d\n", __func__, rc);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(usp, &ksp, sizeof(ksp)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
case PKEY_CLR2PROTK: {
|
|
struct pkey_clr2protk __user *ucp = (void __user *) arg;
|
|
struct pkey_clr2protk kcp;
|
|
|
|
if (copy_from_user(&kcp, ucp, sizeof(kcp)))
|
|
return -EFAULT;
|
|
rc = pkey_clr2protkey(kcp.keytype,
|
|
&kcp.clrkey, &kcp.protkey);
|
|
DEBUG_DBG("%s pkey_clr2protkey()=%d\n", __func__, rc);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(ucp, &kcp, sizeof(kcp)))
|
|
return -EFAULT;
|
|
memzero_explicit(&kcp, sizeof(kcp));
|
|
break;
|
|
}
|
|
case PKEY_FINDCARD: {
|
|
struct pkey_findcard __user *ufc = (void __user *) arg;
|
|
struct pkey_findcard kfc;
|
|
|
|
if (copy_from_user(&kfc, ufc, sizeof(kfc)))
|
|
return -EFAULT;
|
|
rc = cca_findcard(kfc.seckey.seckey,
|
|
&kfc.cardnr, &kfc.domain, 1);
|
|
DEBUG_DBG("%s cca_findcard()=%d\n", __func__, rc);
|
|
if (rc < 0)
|
|
break;
|
|
if (copy_to_user(ufc, &kfc, sizeof(kfc)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
case PKEY_SKEY2PKEY: {
|
|
struct pkey_skey2pkey __user *usp = (void __user *) arg;
|
|
struct pkey_skey2pkey ksp;
|
|
|
|
if (copy_from_user(&ksp, usp, sizeof(ksp)))
|
|
return -EFAULT;
|
|
rc = pkey_skey2pkey(ksp.seckey.seckey, &ksp.protkey);
|
|
DEBUG_DBG("%s pkey_skey2pkey()=%d\n", __func__, rc);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(usp, &ksp, sizeof(ksp)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
case PKEY_VERIFYKEY: {
|
|
struct pkey_verifykey __user *uvk = (void __user *) arg;
|
|
struct pkey_verifykey kvk;
|
|
|
|
if (copy_from_user(&kvk, uvk, sizeof(kvk)))
|
|
return -EFAULT;
|
|
rc = pkey_verifykey(&kvk.seckey, &kvk.cardnr, &kvk.domain,
|
|
&kvk.keysize, &kvk.attributes);
|
|
DEBUG_DBG("%s pkey_verifykey()=%d\n", __func__, rc);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(uvk, &kvk, sizeof(kvk)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
case PKEY_GENPROTK: {
|
|
struct pkey_genprotk __user *ugp = (void __user *) arg;
|
|
struct pkey_genprotk kgp;
|
|
|
|
if (copy_from_user(&kgp, ugp, sizeof(kgp)))
|
|
return -EFAULT;
|
|
rc = pkey_genprotkey(kgp.keytype, &kgp.protkey);
|
|
DEBUG_DBG("%s pkey_genprotkey()=%d\n", __func__, rc);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(ugp, &kgp, sizeof(kgp)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
case PKEY_VERIFYPROTK: {
|
|
struct pkey_verifyprotk __user *uvp = (void __user *) arg;
|
|
struct pkey_verifyprotk kvp;
|
|
|
|
if (copy_from_user(&kvp, uvp, sizeof(kvp)))
|
|
return -EFAULT;
|
|
rc = pkey_verifyprotkey(&kvp.protkey);
|
|
DEBUG_DBG("%s pkey_verifyprotkey()=%d\n", __func__, rc);
|
|
break;
|
|
}
|
|
case PKEY_KBLOB2PROTK: {
|
|
struct pkey_kblob2pkey __user *utp = (void __user *) arg;
|
|
struct pkey_kblob2pkey ktp;
|
|
u8 *kkey;
|
|
|
|
if (copy_from_user(&ktp, utp, sizeof(ktp)))
|
|
return -EFAULT;
|
|
kkey = _copy_key_from_user(ktp.key, ktp.keylen);
|
|
if (IS_ERR(kkey))
|
|
return PTR_ERR(kkey);
|
|
rc = pkey_keyblob2pkey(kkey, ktp.keylen, &ktp.protkey);
|
|
DEBUG_DBG("%s pkey_keyblob2pkey()=%d\n", __func__, rc);
|
|
kfree(kkey);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(utp, &ktp, sizeof(ktp)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
case PKEY_GENSECK2: {
|
|
struct pkey_genseck2 __user *ugs = (void __user *) arg;
|
|
struct pkey_genseck2 kgs;
|
|
struct pkey_apqn *apqns;
|
|
size_t klen = KEYBLOBBUFSIZE;
|
|
u8 *kkey;
|
|
|
|
if (copy_from_user(&kgs, ugs, sizeof(kgs)))
|
|
return -EFAULT;
|
|
apqns = _copy_apqns_from_user(kgs.apqns, kgs.apqn_entries);
|
|
if (IS_ERR(apqns))
|
|
return PTR_ERR(apqns);
|
|
kkey = kmalloc(klen, GFP_KERNEL);
|
|
if (!kkey) {
|
|
kfree(apqns);
|
|
return -ENOMEM;
|
|
}
|
|
rc = pkey_genseckey2(apqns, kgs.apqn_entries,
|
|
kgs.type, kgs.size, kgs.keygenflags,
|
|
kkey, &klen);
|
|
DEBUG_DBG("%s pkey_genseckey2()=%d\n", __func__, rc);
|
|
kfree(apqns);
|
|
if (rc) {
|
|
kfree(kkey);
|
|
break;
|
|
}
|
|
if (kgs.key) {
|
|
if (kgs.keylen < klen) {
|
|
kfree(kkey);
|
|
return -EINVAL;
|
|
}
|
|
if (copy_to_user(kgs.key, kkey, klen)) {
|
|
kfree(kkey);
|
|
return -EFAULT;
|
|
}
|
|
}
|
|
kgs.keylen = klen;
|
|
if (copy_to_user(ugs, &kgs, sizeof(kgs)))
|
|
rc = -EFAULT;
|
|
kfree(kkey);
|
|
break;
|
|
}
|
|
case PKEY_CLR2SECK2: {
|
|
struct pkey_clr2seck2 __user *ucs = (void __user *) arg;
|
|
struct pkey_clr2seck2 kcs;
|
|
struct pkey_apqn *apqns;
|
|
size_t klen = KEYBLOBBUFSIZE;
|
|
u8 *kkey;
|
|
|
|
if (copy_from_user(&kcs, ucs, sizeof(kcs)))
|
|
return -EFAULT;
|
|
apqns = _copy_apqns_from_user(kcs.apqns, kcs.apqn_entries);
|
|
if (IS_ERR(apqns))
|
|
return PTR_ERR(apqns);
|
|
kkey = kmalloc(klen, GFP_KERNEL);
|
|
if (!kkey) {
|
|
kfree(apqns);
|
|
return -ENOMEM;
|
|
}
|
|
rc = pkey_clr2seckey2(apqns, kcs.apqn_entries,
|
|
kcs.type, kcs.size, kcs.keygenflags,
|
|
kcs.clrkey.clrkey, kkey, &klen);
|
|
DEBUG_DBG("%s pkey_clr2seckey2()=%d\n", __func__, rc);
|
|
kfree(apqns);
|
|
if (rc) {
|
|
kfree(kkey);
|
|
break;
|
|
}
|
|
if (kcs.key) {
|
|
if (kcs.keylen < klen) {
|
|
kfree(kkey);
|
|
return -EINVAL;
|
|
}
|
|
if (copy_to_user(kcs.key, kkey, klen)) {
|
|
kfree(kkey);
|
|
return -EFAULT;
|
|
}
|
|
}
|
|
kcs.keylen = klen;
|
|
if (copy_to_user(ucs, &kcs, sizeof(kcs)))
|
|
rc = -EFAULT;
|
|
memzero_explicit(&kcs, sizeof(kcs));
|
|
kfree(kkey);
|
|
break;
|
|
}
|
|
case PKEY_VERIFYKEY2: {
|
|
struct pkey_verifykey2 __user *uvk = (void __user *) arg;
|
|
struct pkey_verifykey2 kvk;
|
|
u8 *kkey;
|
|
|
|
if (copy_from_user(&kvk, uvk, sizeof(kvk)))
|
|
return -EFAULT;
|
|
kkey = _copy_key_from_user(kvk.key, kvk.keylen);
|
|
if (IS_ERR(kkey))
|
|
return PTR_ERR(kkey);
|
|
rc = pkey_verifykey2(kkey, kvk.keylen,
|
|
&kvk.cardnr, &kvk.domain,
|
|
&kvk.type, &kvk.size, &kvk.flags);
|
|
DEBUG_DBG("%s pkey_verifykey2()=%d\n", __func__, rc);
|
|
kfree(kkey);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(uvk, &kvk, sizeof(kvk)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
case PKEY_KBLOB2PROTK2: {
|
|
struct pkey_kblob2pkey2 __user *utp = (void __user *) arg;
|
|
struct pkey_kblob2pkey2 ktp;
|
|
struct pkey_apqn *apqns = NULL;
|
|
u8 *kkey;
|
|
|
|
if (copy_from_user(&ktp, utp, sizeof(ktp)))
|
|
return -EFAULT;
|
|
apqns = _copy_apqns_from_user(ktp.apqns, ktp.apqn_entries);
|
|
if (IS_ERR(apqns))
|
|
return PTR_ERR(apqns);
|
|
kkey = _copy_key_from_user(ktp.key, ktp.keylen);
|
|
if (IS_ERR(kkey)) {
|
|
kfree(apqns);
|
|
return PTR_ERR(kkey);
|
|
}
|
|
rc = pkey_keyblob2pkey2(apqns, ktp.apqn_entries,
|
|
kkey, ktp.keylen, &ktp.protkey);
|
|
DEBUG_DBG("%s pkey_keyblob2pkey2()=%d\n", __func__, rc);
|
|
kfree(apqns);
|
|
kfree(kkey);
|
|
if (rc)
|
|
break;
|
|
if (copy_to_user(utp, &ktp, sizeof(ktp)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
case PKEY_APQNS4K: {
|
|
struct pkey_apqns4key __user *uak = (void __user *) arg;
|
|
struct pkey_apqns4key kak;
|
|
struct pkey_apqn *apqns = NULL;
|
|
size_t nr_apqns, len;
|
|
u8 *kkey;
|
|
|
|
if (copy_from_user(&kak, uak, sizeof(kak)))
|
|
return -EFAULT;
|
|
nr_apqns = kak.apqn_entries;
|
|
if (nr_apqns) {
|
|
apqns = kmalloc_array(nr_apqns,
|
|
sizeof(struct pkey_apqn),
|
|
GFP_KERNEL);
|
|
if (!apqns)
|
|
return -ENOMEM;
|
|
}
|
|
kkey = _copy_key_from_user(kak.key, kak.keylen);
|
|
if (IS_ERR(kkey)) {
|
|
kfree(apqns);
|
|
return PTR_ERR(kkey);
|
|
}
|
|
rc = pkey_apqns4key(kkey, kak.keylen, kak.flags,
|
|
apqns, &nr_apqns);
|
|
DEBUG_DBG("%s pkey_apqns4key()=%d\n", __func__, rc);
|
|
kfree(kkey);
|
|
if (rc && rc != -ENOSPC) {
|
|
kfree(apqns);
|
|
break;
|
|
}
|
|
if (!rc && kak.apqns) {
|
|
if (nr_apqns > kak.apqn_entries) {
|
|
kfree(apqns);
|
|
return -EINVAL;
|
|
}
|
|
len = nr_apqns * sizeof(struct pkey_apqn);
|
|
if (len) {
|
|
if (copy_to_user(kak.apqns, apqns, len)) {
|
|
kfree(apqns);
|
|
return -EFAULT;
|
|
}
|
|
}
|
|
}
|
|
kak.apqn_entries = nr_apqns;
|
|
if (copy_to_user(uak, &kak, sizeof(kak)))
|
|
rc = -EFAULT;
|
|
kfree(apqns);
|
|
break;
|
|
}
|
|
case PKEY_APQNS4KT: {
|
|
struct pkey_apqns4keytype __user *uat = (void __user *) arg;
|
|
struct pkey_apqns4keytype kat;
|
|
struct pkey_apqn *apqns = NULL;
|
|
size_t nr_apqns, len;
|
|
|
|
if (copy_from_user(&kat, uat, sizeof(kat)))
|
|
return -EFAULT;
|
|
nr_apqns = kat.apqn_entries;
|
|
if (nr_apqns) {
|
|
apqns = kmalloc_array(nr_apqns,
|
|
sizeof(struct pkey_apqn),
|
|
GFP_KERNEL);
|
|
if (!apqns)
|
|
return -ENOMEM;
|
|
}
|
|
rc = pkey_apqns4keytype(kat.type, kat.cur_mkvp, kat.alt_mkvp,
|
|
kat.flags, apqns, &nr_apqns);
|
|
DEBUG_DBG("%s pkey_apqns4keytype()=%d\n", __func__, rc);
|
|
if (rc && rc != -ENOSPC) {
|
|
kfree(apqns);
|
|
break;
|
|
}
|
|
if (!rc && kat.apqns) {
|
|
if (nr_apqns > kat.apqn_entries) {
|
|
kfree(apqns);
|
|
return -EINVAL;
|
|
}
|
|
len = nr_apqns * sizeof(struct pkey_apqn);
|
|
if (len) {
|
|
if (copy_to_user(kat.apqns, apqns, len)) {
|
|
kfree(apqns);
|
|
return -EFAULT;
|
|
}
|
|
}
|
|
}
|
|
kat.apqn_entries = nr_apqns;
|
|
if (copy_to_user(uat, &kat, sizeof(kat)))
|
|
rc = -EFAULT;
|
|
kfree(apqns);
|
|
break;
|
|
}
|
|
case PKEY_KBLOB2PROTK3: {
|
|
struct pkey_kblob2pkey3 __user *utp = (void __user *) arg;
|
|
struct pkey_kblob2pkey3 ktp;
|
|
struct pkey_apqn *apqns = NULL;
|
|
u32 protkeylen = PROTKEYBLOBBUFSIZE;
|
|
u8 *kkey, *protkey;
|
|
|
|
if (copy_from_user(&ktp, utp, sizeof(ktp)))
|
|
return -EFAULT;
|
|
apqns = _copy_apqns_from_user(ktp.apqns, ktp.apqn_entries);
|
|
if (IS_ERR(apqns))
|
|
return PTR_ERR(apqns);
|
|
kkey = _copy_key_from_user(ktp.key, ktp.keylen);
|
|
if (IS_ERR(kkey)) {
|
|
kfree(apqns);
|
|
return PTR_ERR(kkey);
|
|
}
|
|
protkey = kmalloc(protkeylen, GFP_KERNEL);
|
|
if (!protkey) {
|
|
kfree(apqns);
|
|
kfree(kkey);
|
|
return -ENOMEM;
|
|
}
|
|
rc = pkey_keyblob2pkey3(apqns, ktp.apqn_entries, kkey,
|
|
ktp.keylen, &ktp.pkeytype,
|
|
protkey, &protkeylen);
|
|
DEBUG_DBG("%s pkey_keyblob2pkey3()=%d\n", __func__, rc);
|
|
kfree(apqns);
|
|
kfree(kkey);
|
|
if (rc) {
|
|
kfree(protkey);
|
|
break;
|
|
}
|
|
if (ktp.pkey && ktp.pkeylen) {
|
|
if (protkeylen > ktp.pkeylen) {
|
|
kfree(protkey);
|
|
return -EINVAL;
|
|
}
|
|
if (copy_to_user(ktp.pkey, protkey, protkeylen)) {
|
|
kfree(protkey);
|
|
return -EFAULT;
|
|
}
|
|
}
|
|
kfree(protkey);
|
|
ktp.pkeylen = protkeylen;
|
|
if (copy_to_user(utp, &ktp, sizeof(ktp)))
|
|
return -EFAULT;
|
|
break;
|
|
}
|
|
default:
|
|
/* unknown/unsupported ioctl cmd */
|
|
return -ENOTTY;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Sysfs and file io operations
|
|
*/
|
|
|
|
/*
|
|
* Sysfs attribute read function for all protected key binary attributes.
|
|
* The implementation can not deal with partial reads, because a new random
|
|
* protected key blob is generated with each read. In case of partial reads
|
|
* (i.e. off != 0 or count < key blob size) -EINVAL is returned.
|
|
*/
|
|
static ssize_t pkey_protkey_aes_attr_read(u32 keytype, bool is_xts, char *buf,
|
|
loff_t off, size_t count)
|
|
{
|
|
struct protaeskeytoken protkeytoken;
|
|
struct pkey_protkey protkey;
|
|
int rc;
|
|
|
|
if (off != 0 || count < sizeof(protkeytoken))
|
|
return -EINVAL;
|
|
if (is_xts)
|
|
if (count < 2 * sizeof(protkeytoken))
|
|
return -EINVAL;
|
|
|
|
memset(&protkeytoken, 0, sizeof(protkeytoken));
|
|
protkeytoken.type = TOKTYPE_NON_CCA;
|
|
protkeytoken.version = TOKVER_PROTECTED_KEY;
|
|
protkeytoken.keytype = keytype;
|
|
|
|
rc = pkey_genprotkey(protkeytoken.keytype, &protkey);
|
|
if (rc)
|
|
return rc;
|
|
|
|
protkeytoken.len = protkey.len;
|
|
memcpy(&protkeytoken.protkey, &protkey.protkey, protkey.len);
|
|
|
|
memcpy(buf, &protkeytoken, sizeof(protkeytoken));
|
|
|
|
if (is_xts) {
|
|
rc = pkey_genprotkey(protkeytoken.keytype, &protkey);
|
|
if (rc)
|
|
return rc;
|
|
|
|
protkeytoken.len = protkey.len;
|
|
memcpy(&protkeytoken.protkey, &protkey.protkey, protkey.len);
|
|
|
|
memcpy(buf + sizeof(protkeytoken), &protkeytoken,
|
|
sizeof(protkeytoken));
|
|
|
|
return 2 * sizeof(protkeytoken);
|
|
}
|
|
|
|
return sizeof(protkeytoken);
|
|
}
|
|
|
|
static ssize_t protkey_aes_128_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_128, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t protkey_aes_192_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_192, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t protkey_aes_256_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_256, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t protkey_aes_128_xts_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_128, true, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t protkey_aes_256_xts_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_protkey_aes_attr_read(PKEY_KEYTYPE_AES_256, true, buf,
|
|
off, count);
|
|
}
|
|
|
|
static BIN_ATTR_RO(protkey_aes_128, sizeof(struct protaeskeytoken));
|
|
static BIN_ATTR_RO(protkey_aes_192, sizeof(struct protaeskeytoken));
|
|
static BIN_ATTR_RO(protkey_aes_256, sizeof(struct protaeskeytoken));
|
|
static BIN_ATTR_RO(protkey_aes_128_xts, 2 * sizeof(struct protaeskeytoken));
|
|
static BIN_ATTR_RO(protkey_aes_256_xts, 2 * sizeof(struct protaeskeytoken));
|
|
|
|
static struct bin_attribute *protkey_attrs[] = {
|
|
&bin_attr_protkey_aes_128,
|
|
&bin_attr_protkey_aes_192,
|
|
&bin_attr_protkey_aes_256,
|
|
&bin_attr_protkey_aes_128_xts,
|
|
&bin_attr_protkey_aes_256_xts,
|
|
NULL
|
|
};
|
|
|
|
static struct attribute_group protkey_attr_group = {
|
|
.name = "protkey",
|
|
.bin_attrs = protkey_attrs,
|
|
};
|
|
|
|
/*
|
|
* Sysfs attribute read function for all secure key ccadata binary attributes.
|
|
* The implementation can not deal with partial reads, because a new random
|
|
* protected key blob is generated with each read. In case of partial reads
|
|
* (i.e. off != 0 or count < key blob size) -EINVAL is returned.
|
|
*/
|
|
static ssize_t pkey_ccadata_aes_attr_read(u32 keytype, bool is_xts, char *buf,
|
|
loff_t off, size_t count)
|
|
{
|
|
int rc;
|
|
struct pkey_seckey *seckey = (struct pkey_seckey *) buf;
|
|
|
|
if (off != 0 || count < sizeof(struct secaeskeytoken))
|
|
return -EINVAL;
|
|
if (is_xts)
|
|
if (count < 2 * sizeof(struct secaeskeytoken))
|
|
return -EINVAL;
|
|
|
|
rc = cca_genseckey(-1, -1, keytype, seckey->seckey);
|
|
if (rc)
|
|
return rc;
|
|
|
|
if (is_xts) {
|
|
seckey++;
|
|
rc = cca_genseckey(-1, -1, keytype, seckey->seckey);
|
|
if (rc)
|
|
return rc;
|
|
|
|
return 2 * sizeof(struct secaeskeytoken);
|
|
}
|
|
|
|
return sizeof(struct secaeskeytoken);
|
|
}
|
|
|
|
static ssize_t ccadata_aes_128_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_128, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ccadata_aes_192_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_192, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ccadata_aes_256_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_256, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ccadata_aes_128_xts_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_128, true, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ccadata_aes_256_xts_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccadata_aes_attr_read(PKEY_KEYTYPE_AES_256, true, buf,
|
|
off, count);
|
|
}
|
|
|
|
static BIN_ATTR_RO(ccadata_aes_128, sizeof(struct secaeskeytoken));
|
|
static BIN_ATTR_RO(ccadata_aes_192, sizeof(struct secaeskeytoken));
|
|
static BIN_ATTR_RO(ccadata_aes_256, sizeof(struct secaeskeytoken));
|
|
static BIN_ATTR_RO(ccadata_aes_128_xts, 2 * sizeof(struct secaeskeytoken));
|
|
static BIN_ATTR_RO(ccadata_aes_256_xts, 2 * sizeof(struct secaeskeytoken));
|
|
|
|
static struct bin_attribute *ccadata_attrs[] = {
|
|
&bin_attr_ccadata_aes_128,
|
|
&bin_attr_ccadata_aes_192,
|
|
&bin_attr_ccadata_aes_256,
|
|
&bin_attr_ccadata_aes_128_xts,
|
|
&bin_attr_ccadata_aes_256_xts,
|
|
NULL
|
|
};
|
|
|
|
static struct attribute_group ccadata_attr_group = {
|
|
.name = "ccadata",
|
|
.bin_attrs = ccadata_attrs,
|
|
};
|
|
|
|
#define CCACIPHERTOKENSIZE (sizeof(struct cipherkeytoken) + 80)
|
|
|
|
/*
|
|
* Sysfs attribute read function for all secure key ccacipher binary attributes.
|
|
* The implementation can not deal with partial reads, because a new random
|
|
* secure key blob is generated with each read. In case of partial reads
|
|
* (i.e. off != 0 or count < key blob size) -EINVAL is returned.
|
|
*/
|
|
static ssize_t pkey_ccacipher_aes_attr_read(enum pkey_key_size keybits,
|
|
bool is_xts, char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
int i, rc, card, dom;
|
|
u32 nr_apqns, *apqns = NULL;
|
|
size_t keysize = CCACIPHERTOKENSIZE;
|
|
|
|
if (off != 0 || count < CCACIPHERTOKENSIZE)
|
|
return -EINVAL;
|
|
if (is_xts)
|
|
if (count < 2 * CCACIPHERTOKENSIZE)
|
|
return -EINVAL;
|
|
|
|
/* build a list of apqns able to generate an cipher key */
|
|
rc = cca_findcard2(&apqns, &nr_apqns, 0xFFFF, 0xFFFF,
|
|
ZCRYPT_CEX6, 0, 0, 0, 0);
|
|
if (rc)
|
|
return rc;
|
|
|
|
memset(buf, 0, is_xts ? 2 * keysize : keysize);
|
|
|
|
/* simple try all apqns from the list */
|
|
for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
|
|
card = apqns[i] >> 16;
|
|
dom = apqns[i] & 0xFFFF;
|
|
rc = cca_gencipherkey(card, dom, keybits, 0, buf, &keysize);
|
|
if (rc == 0)
|
|
break;
|
|
}
|
|
if (rc)
|
|
return rc;
|
|
|
|
if (is_xts) {
|
|
keysize = CCACIPHERTOKENSIZE;
|
|
buf += CCACIPHERTOKENSIZE;
|
|
rc = cca_gencipherkey(card, dom, keybits, 0, buf, &keysize);
|
|
if (rc == 0)
|
|
return 2 * CCACIPHERTOKENSIZE;
|
|
}
|
|
|
|
return CCACIPHERTOKENSIZE;
|
|
}
|
|
|
|
static ssize_t ccacipher_aes_128_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_128, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ccacipher_aes_192_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_192, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ccacipher_aes_256_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_256, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ccacipher_aes_128_xts_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_128, true, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ccacipher_aes_256_xts_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ccacipher_aes_attr_read(PKEY_SIZE_AES_256, true, buf,
|
|
off, count);
|
|
}
|
|
|
|
static BIN_ATTR_RO(ccacipher_aes_128, CCACIPHERTOKENSIZE);
|
|
static BIN_ATTR_RO(ccacipher_aes_192, CCACIPHERTOKENSIZE);
|
|
static BIN_ATTR_RO(ccacipher_aes_256, CCACIPHERTOKENSIZE);
|
|
static BIN_ATTR_RO(ccacipher_aes_128_xts, 2 * CCACIPHERTOKENSIZE);
|
|
static BIN_ATTR_RO(ccacipher_aes_256_xts, 2 * CCACIPHERTOKENSIZE);
|
|
|
|
static struct bin_attribute *ccacipher_attrs[] = {
|
|
&bin_attr_ccacipher_aes_128,
|
|
&bin_attr_ccacipher_aes_192,
|
|
&bin_attr_ccacipher_aes_256,
|
|
&bin_attr_ccacipher_aes_128_xts,
|
|
&bin_attr_ccacipher_aes_256_xts,
|
|
NULL
|
|
};
|
|
|
|
static struct attribute_group ccacipher_attr_group = {
|
|
.name = "ccacipher",
|
|
.bin_attrs = ccacipher_attrs,
|
|
};
|
|
|
|
/*
|
|
* Sysfs attribute read function for all ep11 aes key binary attributes.
|
|
* The implementation can not deal with partial reads, because a new random
|
|
* secure key blob is generated with each read. In case of partial reads
|
|
* (i.e. off != 0 or count < key blob size) -EINVAL is returned.
|
|
* This function and the sysfs attributes using it provide EP11 key blobs
|
|
* padded to the upper limit of MAXEP11AESKEYBLOBSIZE which is currently
|
|
* 320 bytes.
|
|
*/
|
|
static ssize_t pkey_ep11_aes_attr_read(enum pkey_key_size keybits,
|
|
bool is_xts, char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
int i, rc, card, dom;
|
|
u32 nr_apqns, *apqns = NULL;
|
|
size_t keysize = MAXEP11AESKEYBLOBSIZE;
|
|
|
|
if (off != 0 || count < MAXEP11AESKEYBLOBSIZE)
|
|
return -EINVAL;
|
|
if (is_xts)
|
|
if (count < 2 * MAXEP11AESKEYBLOBSIZE)
|
|
return -EINVAL;
|
|
|
|
/* build a list of apqns able to generate an cipher key */
|
|
rc = ep11_findcard2(&apqns, &nr_apqns, 0xFFFF, 0xFFFF,
|
|
ZCRYPT_CEX7, EP11_API_V, NULL);
|
|
if (rc)
|
|
return rc;
|
|
|
|
memset(buf, 0, is_xts ? 2 * keysize : keysize);
|
|
|
|
/* simple try all apqns from the list */
|
|
for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
|
|
card = apqns[i] >> 16;
|
|
dom = apqns[i] & 0xFFFF;
|
|
rc = ep11_genaeskey(card, dom, keybits, 0, buf, &keysize);
|
|
if (rc == 0)
|
|
break;
|
|
}
|
|
if (rc)
|
|
return rc;
|
|
|
|
if (is_xts) {
|
|
keysize = MAXEP11AESKEYBLOBSIZE;
|
|
buf += MAXEP11AESKEYBLOBSIZE;
|
|
rc = ep11_genaeskey(card, dom, keybits, 0, buf, &keysize);
|
|
if (rc == 0)
|
|
return 2 * MAXEP11AESKEYBLOBSIZE;
|
|
}
|
|
|
|
return MAXEP11AESKEYBLOBSIZE;
|
|
}
|
|
|
|
static ssize_t ep11_aes_128_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_128, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ep11_aes_192_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_192, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ep11_aes_256_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_256, false, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ep11_aes_128_xts_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_128, true, buf,
|
|
off, count);
|
|
}
|
|
|
|
static ssize_t ep11_aes_256_xts_read(struct file *filp,
|
|
struct kobject *kobj,
|
|
struct bin_attribute *attr,
|
|
char *buf, loff_t off,
|
|
size_t count)
|
|
{
|
|
return pkey_ep11_aes_attr_read(PKEY_SIZE_AES_256, true, buf,
|
|
off, count);
|
|
}
|
|
|
|
static BIN_ATTR_RO(ep11_aes_128, MAXEP11AESKEYBLOBSIZE);
|
|
static BIN_ATTR_RO(ep11_aes_192, MAXEP11AESKEYBLOBSIZE);
|
|
static BIN_ATTR_RO(ep11_aes_256, MAXEP11AESKEYBLOBSIZE);
|
|
static BIN_ATTR_RO(ep11_aes_128_xts, 2 * MAXEP11AESKEYBLOBSIZE);
|
|
static BIN_ATTR_RO(ep11_aes_256_xts, 2 * MAXEP11AESKEYBLOBSIZE);
|
|
|
|
static struct bin_attribute *ep11_attrs[] = {
|
|
&bin_attr_ep11_aes_128,
|
|
&bin_attr_ep11_aes_192,
|
|
&bin_attr_ep11_aes_256,
|
|
&bin_attr_ep11_aes_128_xts,
|
|
&bin_attr_ep11_aes_256_xts,
|
|
NULL
|
|
};
|
|
|
|
static struct attribute_group ep11_attr_group = {
|
|
.name = "ep11",
|
|
.bin_attrs = ep11_attrs,
|
|
};
|
|
|
|
static const struct attribute_group *pkey_attr_groups[] = {
|
|
&protkey_attr_group,
|
|
&ccadata_attr_group,
|
|
&ccacipher_attr_group,
|
|
&ep11_attr_group,
|
|
NULL,
|
|
};
|
|
|
|
static const struct file_operations pkey_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = nonseekable_open,
|
|
.llseek = no_llseek,
|
|
.unlocked_ioctl = pkey_unlocked_ioctl,
|
|
};
|
|
|
|
static struct miscdevice pkey_dev = {
|
|
.name = "pkey",
|
|
.minor = MISC_DYNAMIC_MINOR,
|
|
.mode = 0666,
|
|
.fops = &pkey_fops,
|
|
.groups = pkey_attr_groups,
|
|
};
|
|
|
|
/*
|
|
* Module init
|
|
*/
|
|
static int __init pkey_init(void)
|
|
{
|
|
cpacf_mask_t func_mask;
|
|
|
|
/*
|
|
* The pckmo instruction should be available - even if we don't
|
|
* actually invoke it. This instruction comes with MSA 3 which
|
|
* is also the minimum level for the kmc instructions which
|
|
* are able to work with protected keys.
|
|
*/
|
|
if (!cpacf_query(CPACF_PCKMO, &func_mask))
|
|
return -ENODEV;
|
|
|
|
/* check for kmc instructions available */
|
|
if (!cpacf_query(CPACF_KMC, &func_mask))
|
|
return -ENODEV;
|
|
if (!cpacf_test_func(&func_mask, CPACF_KMC_PAES_128) ||
|
|
!cpacf_test_func(&func_mask, CPACF_KMC_PAES_192) ||
|
|
!cpacf_test_func(&func_mask, CPACF_KMC_PAES_256))
|
|
return -ENODEV;
|
|
|
|
pkey_debug_init();
|
|
|
|
return misc_register(&pkey_dev);
|
|
}
|
|
|
|
/*
|
|
* Module exit
|
|
*/
|
|
static void __exit pkey_exit(void)
|
|
{
|
|
misc_deregister(&pkey_dev);
|
|
pkey_debug_exit();
|
|
}
|
|
|
|
module_cpu_feature_match(MSA, pkey_init);
|
|
module_exit(pkey_exit);
|