static int cfs_crypto_hash_alloc(unsigned char alg_id,
const struct cfs_crypto_hash_type **type,
struct hash_desc *desc, unsigned char *key,
unsigned int key_len)
{
int err = 0;
*type = cfs_crypto_hash_type(alg_id);
if (*type == NULL) {
CWARN("Unsupported hash algorithm id = %d, max id is %d\n",
alg_id, CFS_HASH_ALG_MAX);
return -EINVAL;
}
desc->tfm = crypto_alloc_hash((*type)->cht_name, 0, 0);
if (desc->tfm == NULL)
return -EINVAL;
if (IS_ERR(desc->tfm)) {
CDEBUG(D_INFO, "Failed to alloc crypto hash %s\n",
(*type)->cht_name);
return PTR_ERR(desc->tfm);
}
desc->flags = 0;
/** Shash have different logic for initialization then digest
* shash: crypto_hash_setkey, crypto_hash_init
* digest: crypto_digest_init, crypto_digest_setkey
* Skip this function for digest, because we use shash logic at
* cfs_crypto_hash_alloc.
*/
if (key != NULL) {
err = crypto_hash_setkey(desc->tfm, key, key_len);
} else if ((*type)->cht_key != 0) {
err = crypto_hash_setkey(desc->tfm,
(unsigned char *)&((*type)->cht_key),
(*type)->cht_size);
}
if (err != 0) {
crypto_free_hash(desc->tfm);
return err;
}
CDEBUG(D_INFO, "Using crypto hash: %s (%s) speed %d MB/s\n",
(crypto_hash_tfm(desc->tfm))->__crt_alg->cra_name,
(crypto_hash_tfm(desc->tfm))->__crt_alg->cra_driver_name,
cfs_crypto_hash_speeds[alg_id]);
return crypto_hash_init(desc);
}
static int init(struct hash_desc *desc)
{
struct crypto_tfm *tfm = crypto_hash_tfm(desc->tfm);
tfm->__crt_alg->cra_digest.dia_init(tfm);
return 0;
}
/**
* Initialize the state descriptor for the specified hash algorithm.
*
* An internal routine to allocate the hash-specific state in \a hdesc for
* use with cfs_crypto_hash_digest() to compute the hash of a single message,
* though possibly in multiple chunks. The descriptor internal state should
* be freed with cfs_crypto_hash_final().
*
* \param[in] hash_alg hash algorithm id (CFS_HASH_ALG_*)
* \param[out] type pointer to the hash description in hash_types[] array
* \param[in,out] hdesc hash state descriptor to be initialized
* \param[in] key initial hash value/state, NULL to use default value
* \param[in] key_len length of \a key
*
* \retval 0 on success
* \retval negative errno on failure
*/
static int cfs_crypto_hash_alloc(enum cfs_crypto_hash_alg hash_alg,
const struct cfs_crypto_hash_type **type,
struct hash_desc *hdesc, unsigned char *key,
unsigned int key_len)
{
int err = 0;
*type = cfs_crypto_hash_type(hash_alg);
if (*type == NULL) {
CWARN("Unsupported hash algorithm id = %d, max id is %d\n",
hash_alg, CFS_HASH_ALG_MAX);
return -EINVAL;
}
hdesc->tfm = crypto_alloc_hash((*type)->cht_name, 0, 0);
if (hdesc->tfm == NULL)
return -EINVAL;
if (IS_ERR(hdesc->tfm)) {
CDEBUG(D_INFO, "Failed to alloc crypto hash %s\n",
(*type)->cht_name);
return PTR_ERR(hdesc->tfm);
}
hdesc->flags = 0;
if (key != NULL)
err = crypto_hash_setkey(hdesc->tfm, key, key_len);
else if ((*type)->cht_key != 0)
err = crypto_hash_setkey(hdesc->tfm,
(unsigned char *)&((*type)->cht_key),
(*type)->cht_size);
if (err != 0) {
crypto_free_hash(hdesc->tfm);
return err;
}
CDEBUG(D_INFO, "Using crypto hash: %s (%s) speed %d MB/s\n",
(crypto_hash_tfm(hdesc->tfm))->__crt_alg->cra_name,
(crypto_hash_tfm(hdesc->tfm))->__crt_alg->cra_driver_name,
cfs_crypto_hash_speeds[hash_alg]);
return crypto_hash_init(hdesc);
}
static int update2(struct hash_desc *desc,
struct scatterlist *sg, unsigned int nbytes)
{
struct crypto_tfm *tfm = crypto_hash_tfm(desc->tfm);
unsigned int alignmask = crypto_tfm_alg_alignmask(tfm);
if (!nbytes)
return 0;
for (;;) {
struct page *pg = sg_page(sg);
unsigned int offset = sg->offset;
unsigned int l = sg->length;
if (unlikely(l > nbytes))
l = nbytes;
nbytes -= l;
do {
unsigned int bytes_from_page = min(l, ((unsigned int)
(PAGE_SIZE)) -
offset);
char *src = crypto_kmap(pg, 0);
char *p = src + offset;
if (unlikely(offset & alignmask)) {
unsigned int bytes =
alignmask + 1 - (offset & alignmask);
bytes = min(bytes, bytes_from_page);
tfm->__crt_alg->cra_digest.dia_update(tfm, p,
bytes);
p += bytes;
bytes_from_page -= bytes;
l -= bytes;
}
tfm->__crt_alg->cra_digest.dia_update(tfm, p,
bytes_from_page);
crypto_kunmap(src, 0);
crypto_yield(desc->flags);
offset = 0;
pg++;
l -= bytes_from_page;
} while (l > 0);
if (!nbytes)
break;
sg = scatterwalk_sg_next(sg);
}
return 0;
}
int __init init_mars(void)
{
MARS_INF("init_mars()\n");
set_fake();
#ifdef MARS_TRACING
{
int flags = O_CREAT | O_TRUNC | O_RDWR | O_LARGEFILE;
int prot = 0600;
mm_segment_t oldfs;
oldfs = get_fs();
set_fs(get_ds());
mars_log_file = filp_open("/mars/trace.csv", flags, prot);
set_fs(oldfs);
if (IS_ERR(mars_log_file)) {
MARS_ERR("cannot create trace logfile, status = %ld\n", PTR_ERR(mars_log_file));
mars_log_file = NULL;
}
}
#endif
mars_tfm = crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC);
if (!mars_tfm) {
MARS_ERR("cannot alloc crypto hash\n");
return -ENOMEM;
}
if (IS_ERR(mars_tfm)) {
MARS_ERR("alloc crypto hash failed, status = %d\n", (int)PTR_ERR(mars_tfm));
return PTR_ERR(mars_tfm);
}
#if 0
if (crypto_tfm_alg_type(crypto_hash_tfm(mars_tfm)) != CRYPTO_ALG_TYPE_DIGEST) {
MARS_ERR("bad crypto hash type\n");
return -EINVAL;
}
#endif
mars_digest_size = crypto_hash_digestsize(mars_tfm);
MARS_INF("digest_size = %d\n", mars_digest_size);
return 0;
}
static int tf_self_test_integrity(const char *alg_name, struct module *mod)
{
unsigned char expected[32];
unsigned char actual[32];
struct scatterlist *sg = NULL;
struct hash_desc desc = {NULL, 0};
size_t digest_length;
unsigned char *const key = tf_integrity_hmac_sha256_key;
size_t const key_length = sizeof(tf_integrity_hmac_sha256_key);
int error;
if (mod->raw_binary_ptr == NULL)
return -ENXIO;
if (tf_integrity_hmac_sha256_expected_value == NULL)
return -ENOENT;
INFO("expected=%s", tf_integrity_hmac_sha256_expected_value);
error = scan_hex(expected, sizeof(expected),
tf_integrity_hmac_sha256_expected_value);
if (error < 0) {
pr_err("tf_driver: Badly formatted hmac_sha256 parameter "
"(should be a hex string)\n");
return -EIO;
};
desc.tfm = crypto_alloc_hash(alg_name, 0, 0);
if (IS_ERR_OR_NULL(desc.tfm)) {
ERROR("crypto_alloc_hash(%s) failed", alg_name);
error = (desc.tfm == NULL ? -ENOMEM : (int)desc.tfm);
goto abort;
}
digest_length = crypto_hash_digestsize(desc.tfm);
INFO("alg_name=%s driver_name=%s digest_length=%u",
alg_name,
crypto_tfm_alg_driver_name(crypto_hash_tfm(desc.tfm)),
digest_length);
error = crypto_hash_setkey(desc.tfm, key, key_length);
if (error) {
ERROR("crypto_hash_setkey(%s) failed: %d",
alg_name, error);
goto abort;
}
sg = vmalloc_to_sg(mod->raw_binary_ptr, mod->raw_binary_size);
if (IS_ERR_OR_NULL(sg)) {
ERROR("vmalloc_to_sg(%lu) failed: %d",
mod->raw_binary_size, (int)sg);
error = (sg == NULL ? -ENOMEM : (int)sg);
goto abort;
}
error = crypto_hash_digest(&desc, sg, mod->raw_binary_size, actual);
if (error) {
ERROR("crypto_hash_digest(%s) failed: %d",
alg_name, error);
goto abort;
}
kfree(sg);
crypto_free_hash(desc.tfm);
#ifdef CONFIG_TF_DRIVER_FAULT_INJECTION
if (tf_fault_injection_mask & TF_CRYPTO_ALG_INTEGRITY) {
pr_warning("TF: injecting fault in integrity check!\n");
actual[0] = 0xff;
actual[1] ^= 0xff;
}
#endif
TF_TRACE_ARRAY(expected, digest_length);
TF_TRACE_ARRAY(actual, digest_length);
if (memcmp(expected, actual, digest_length)) {
ERROR("wrong %s digest value", alg_name);
error = -EINVAL;
} else {
INFO("%s: digest successful", alg_name);
error = 0;
}
return error;
abort:
if (!IS_ERR_OR_NULL(sg))
kfree(sg);
if (!IS_ERR_OR_NULL(desc.tfm))
crypto_free_hash(desc.tfm);
return error == -ENOMEM ? error : -EIO;
}
static int tf_self_test_digest(const char *alg_name,
const struct digest_test_vector *tv)
{
unsigned char digest[64];
unsigned char input[256];
struct scatterlist sg;
struct hash_desc desc = {NULL, 0};
int error;
size_t digest_length;
desc.tfm = crypto_alloc_hash(alg_name, 0, 0);
if (IS_ERR_OR_NULL(desc.tfm)) {
ERROR("crypto_alloc_hash(%s) failed", alg_name);
error = (desc.tfm == NULL ? -ENOMEM : (int)desc.tfm);
goto abort;
}
digest_length = crypto_hash_digestsize(desc.tfm);
INFO("alg_name=%s driver_name=%s digest_length=%u",
alg_name,
crypto_tfm_alg_driver_name(crypto_hash_tfm(desc.tfm)),
digest_length);
if (digest_length > sizeof(digest)) {
ERROR("digest length too large (%zu > %zu)",
digest_length, sizeof(digest));
error = -ENOMEM;
goto abort;
}
if (tv->key != NULL) {
error = crypto_hash_setkey(desc.tfm, tv->key, tv->key_length);
if (error) {
ERROR("crypto_hash_setkey(%s) failed: %d",
alg_name, error);
goto abort;
}
TF_TRACE_ARRAY(tv->key, tv->key_length);
}
error = crypto_hash_init(&desc);
if (error) {
ERROR("crypto_hash_init(%s) failed: %d", alg_name, error);
goto abort;
}
/* The test vector data is in vmalloc'ed memory since it's a module
global. Copy it to the stack, since the crypto API doesn't support
vmalloc'ed memory. */
if (tv->length > sizeof(input)) {
ERROR("data too large (%zu > %zu)",
tv->length, sizeof(input));
error = -ENOMEM;
goto abort;
}
memcpy(input, tv->text, tv->length);
INFO("sg_init_one(%p, %p, %u)", &sg, input, tv->length);
sg_init_one(&sg, input, tv->length);
TF_TRACE_ARRAY(input, tv->length);
error = crypto_hash_update(&desc, &sg, tv->length);
if (error) {
ERROR("crypto_hash_update(%s) failed: %d",
alg_name, error);
goto abort;
}
error = crypto_hash_final(&desc, digest);
if (error) {
ERROR("crypto_hash_final(%s) failed: %d", alg_name, error);
goto abort;
}
crypto_free_hash(desc.tfm);
desc.tfm = NULL;
if (memcmp(digest, tv->digest, digest_length)) {
TF_TRACE_ARRAY(digest, digest_length);
ERROR("wrong %s digest value", alg_name);
pr_err("[SMC Driver] error: SMC Driver POST FAILURE (%s)\n",
alg_name);
error = -EINVAL;
} else {
INFO("%s: digest successful", alg_name);
error = 0;
}
return error;
abort:
if (!IS_ERR_OR_NULL(desc.tfm))
crypto_free_hash(desc.tfm);
pr_err("[SMC Driver] error: SMC Driver POST FAILURE (%s)\n", alg_name);
return error;
}
}
return 0;
}
static int update(struct hash_desc *desc,
struct scatterlist *sg, unsigned int nbytes)
{
if (WARN_ON_ONCE(in_irq()))
return -EDEADLK;
return update2(desc, sg, nbytes);
}
static int final(struct hash_desc *desc, u8 *out)
{
struct crypto_tfm *tfm = crypto_hash_tfm(desc->tfm);
unsigned long alignmask = crypto_tfm_alg_alignmask(tfm);
struct digest_alg *digest = &tfm->__crt_alg->cra_digest;
if (unlikely((unsigned long)out & alignmask)) {
unsigned long align = alignmask + 1;
unsigned long addr = (unsigned long)crypto_tfm_ctx(tfm);
u8 *dst = (u8 *)ALIGN(addr, align) +
ALIGN(tfm->__crt_alg->cra_ctxsize, align);
digest->dia_final(tfm, dst);
memcpy(out, dst, digest->dia_digestsize);
} else
digest->dia_final(tfm, out);
return 0;
