static int p8_aes_cbc_init(struct crypto_tfm *tfm)
{
const char *alg;
struct crypto_blkcipher *fallback;
struct p8_aes_cbc_ctx *ctx = crypto_tfm_ctx(tfm);
if (!(alg = crypto_tfm_alg_name(tfm))) {
printk(KERN_ERR "Failed to get algorithm name.\n");
return -ENOENT;
}
fallback =
crypto_alloc_blkcipher(alg, 0, CRYPTO_ALG_NEED_FALLBACK);
if (IS_ERR(fallback)) {
printk(KERN_ERR
"Failed to allocate transformation for '%s': %ld\n",
alg, PTR_ERR(fallback));
return PTR_ERR(fallback);
}
printk(KERN_INFO "Using '%s' as fallback implementation.\n",
crypto_tfm_alg_driver_name((struct crypto_tfm *) fallback));
crypto_blkcipher_set_flags(
fallback,
crypto_blkcipher_get_flags((struct crypto_blkcipher *)tfm));
ctx->fallback = fallback;
return 0;
}
int rtl_cipher_init_ctx(struct crypto_tfm *tfm,
struct rtl_cipher_ctx *ctx)
{
const char *algname = crypto_tfm_alg_name(tfm);
memset(ctx, 0, sizeof(*ctx));
if (strcmp(algname, "cbc(des)") == 0)
ctx->mode = 0x00;
else if (strcmp(algname, "cbc(des3_ede)") == 0)
ctx->mode = 0x01;
else if (strcmp(algname, "ecb(des)") == 0)
ctx->mode = 0x02;
else if (strcmp(algname, "ecb(des3_ede)") == 0)
ctx->mode = 0x03;
else if (strcmp(algname, "cbc(aes)") == 0)
ctx->mode = 0x20;
else if (strcmp(algname, "ecb(aes)") == 0)
ctx->mode = 0x22;
else if (strcmp(algname, "ctr(aes)") == 0)
ctx->mode = 0x23;
else
ctx->mode = -1;
#ifdef CONFIG_RTK_VOIP_DBG
printk("%s: alg=%s, driver=%s, mode=%x\n", __FUNCTION__,
crypto_tfm_alg_name(tfm),
crypto_tfm_alg_driver_name(tfm),
ctx->mode
);
#endif
ctx->aes_dekey = &ctx->__aes_dekey[32]; // cache align issue
return 0;
}
static int p8_ghash_init_tfm(struct crypto_tfm *tfm)
{
const char *alg;
struct crypto_shash *fallback;
struct crypto_shash *shash_tfm = __crypto_shash_cast(tfm);
struct p8_ghash_ctx *ctx = crypto_tfm_ctx(tfm);
if (!(alg = crypto_tfm_alg_name(tfm))) {
printk(KERN_ERR "Failed to get algorithm name.\n");
return -ENOENT;
}
fallback = crypto_alloc_shash(alg, 0 ,CRYPTO_ALG_NEED_FALLBACK);
if (IS_ERR(fallback)) {
printk(KERN_ERR "Failed to allocate transformation for '%s': %ld\n",
alg, PTR_ERR(fallback));
return PTR_ERR(fallback);
}
printk(KERN_INFO "Using '%s' as fallback implementation.\n",
crypto_tfm_alg_driver_name(crypto_shash_tfm(fallback)));
crypto_shash_set_flags(fallback,
crypto_shash_get_flags((struct crypto_shash *) tfm));
ctx->fallback = fallback;
shash_tfm->descsize = sizeof(struct p8_ghash_desc_ctx)
+ crypto_shash_descsize(fallback);
return 0;
}
int ablk_init(struct crypto_tfm *tfm)
{
char drv_name[CRYPTO_MAX_ALG_NAME];
snprintf(drv_name, sizeof(drv_name), "__driver-%s",
crypto_tfm_alg_driver_name(tfm));
return ablk_init_common(tfm, drv_name);
}
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_perform_blkcipher(
const char *alg_name,
const struct blkcipher_test_vector *tv,
bool decrypt)
{
struct blkcipher_desc desc = {0};
struct scatterlist sg_in, sg_out;
unsigned char *in = NULL;
unsigned char *out = NULL;
unsigned in_size, out_size;
int error;
desc.tfm = crypto_alloc_blkcipher(alg_name, 0, 0);
if (IS_ERR_OR_NULL(desc.tfm)) {
ERROR("crypto_alloc_blkcipher(%s) failed", alg_name);
error = (desc.tfm == NULL ? -ENOMEM : (int)desc.tfm);
goto abort;
}
INFO("%s alg_name=%s driver_name=%s key_size=%u block_size=%u",
decrypt ? "decrypt" : "encrypt", alg_name,
crypto_tfm_alg_driver_name(crypto_blkcipher_tfm(desc.tfm)),
tv->key_length * 8,
crypto_blkcipher_blocksize(desc.tfm));
in_size = tv->length;
in = kmalloc(in_size, GFP_KERNEL);
if (IS_ERR_OR_NULL(in)) {
ERROR("kmalloc(%u) failed: %d", in_size, (int)in);
error = (in == NULL ? -ENOMEM : (int)in);
goto abort;
}
memcpy(in, decrypt ? tv->ciphertext : tv->plaintext,
tv->length);
out_size = tv->length + crypto_blkcipher_blocksize(desc.tfm);
out = kmalloc(out_size, GFP_KERNEL);
if (IS_ERR_OR_NULL(out)) {
ERROR("kmalloc(%u) failed: %d", out_size, (int)out);
error = (out == NULL ? -ENOMEM : (int)out);
goto abort;
}
error = crypto_blkcipher_setkey(desc.tfm, tv->key, tv->key_length);
if (error) {
ERROR("crypto_alloc_setkey(%s) failed", alg_name);
goto abort;
}
TF_TRACE_ARRAY(tv->key, tv->key_length);
if (tv->iv != NULL) {
unsigned iv_length = crypto_blkcipher_ivsize(desc.tfm);
crypto_blkcipher_set_iv(desc.tfm, tv->iv, iv_length);
TF_TRACE_ARRAY(tv->iv, iv_length);
}
sg_init_one(&sg_in, in, tv->length);
sg_init_one(&sg_out, out, tv->length);
TF_TRACE_ARRAY(in, tv->length);
(decrypt ? crypto_blkcipher_decrypt : crypto_blkcipher_encrypt)
(&desc, &sg_out, &sg_in, tv->length);
if (error) {
ERROR("crypto_blkcipher_%s(%s) failed",
decrypt ? "decrypt" : "encrypt", alg_name);
goto abort;
}
TF_TRACE_ARRAY(out, tv->length);
crypto_free_blkcipher(desc.tfm);
if (memcmp((decrypt ? tv->plaintext : tv->ciphertext),
out, tv->length)) {
ERROR("Wrong %s/%u %s result", alg_name, tv->key_length * 8,
decrypt ? "decryption" : "encryption");
error = -EINVAL;
} else {
INFO("%s/%u: %s successful", alg_name, tv->key_length * 8,
decrypt ? "decryption" : "encryption");
error = 0;
}
kfree(in);
kfree(out);
return error;
abort:
if (!IS_ERR_OR_NULL(desc.tfm))
crypto_free_blkcipher(desc.tfm);
if (!IS_ERR_OR_NULL(out))
kfree(out);
if (!IS_ERR_OR_NULL(in))
kfree(in);
return error;
}
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;
}
static void tcrypt_complete(struct crypto_async_request *req, int err)
{
struct tcrypt_result *res = req->data;
if (err == -EINPROGRESS)
return;
res->err = err;
complete(&res->completion);
}
static int test_hash(struct crypto_ahash *tfm, struct hash_testvec *template,
unsigned int tcount)
{
const char *algo = crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
unsigned int i, j, k, temp;
struct scatterlist sg[8];
char result[64];
struct ahash_request *req;
struct tcrypt_result tresult;
int ret;
void *hash_buff;
init_completion(&tresult.completion);
req = ahash_request_alloc(tfm, GFP_KERNEL);
if (!req) {
printk(KERN_ERR "alg: hash: Failed to allocate request for "
"%s\n", algo);
ret = -ENOMEM;
static inline const char *crypto_ahash_driver_name(struct crypto_ahash *tfm)
{
return crypto_tfm_alg_driver_name(crypto_ahash_tfm(tfm));
}
