1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (c) 2014-2019, Linaro Limited 4 */ 5 6 #include <assert.h> 7 #include <crypto/crypto.h> 8 #include <crypto/crypto_impl.h> 9 #include <stdlib.h> 10 #include <string.h> 11 #include <tee_api_types.h> 12 #include <tomcrypt_private.h> 13 #include <utee_defines.h> 14 #include <util.h> 15 16 /****************************************************************************** 17 * Message digest functions 18 ******************************************************************************/ 19 20 struct ltc_hash_ctx { 21 struct crypto_hash_ctx ctx; 22 const struct ltc_hash_descriptor *descr; 23 hash_state state; 24 }; 25 26 static const struct crypto_hash_ops ltc_hash_ops; 27 28 static struct ltc_hash_ctx *to_hash_ctx(struct crypto_hash_ctx *ctx) 29 { 30 assert(ctx && ctx->ops == <c_hash_ops); 31 32 return container_of(ctx, struct ltc_hash_ctx, ctx); 33 } 34 35 static TEE_Result ltc_hash_init(struct crypto_hash_ctx *ctx) 36 { 37 struct ltc_hash_ctx *hc = to_hash_ctx(ctx); 38 39 if (hc->descr->init(&hc->state) == CRYPT_OK) 40 return TEE_SUCCESS; 41 else 42 return TEE_ERROR_BAD_STATE; 43 } 44 45 static TEE_Result ltc_hash_update(struct crypto_hash_ctx *ctx, 46 const uint8_t *data, size_t len) 47 { 48 struct ltc_hash_ctx *hc = to_hash_ctx(ctx); 49 50 if (hc->descr->process(&hc->state, data, len) == CRYPT_OK) 51 return TEE_SUCCESS; 52 else 53 return TEE_ERROR_BAD_STATE; 54 } 55 56 static TEE_Result ltc_hash_final(struct crypto_hash_ctx *ctx, uint8_t *digest, 57 size_t len) 58 { 59 struct ltc_hash_ctx *hc = to_hash_ctx(ctx); 60 size_t hash_size = hc->descr->hashsize; 61 uint8_t block_digest[TEE_MAX_HASH_SIZE] = { 0 }; 62 uint8_t *tmp_digest = NULL; 63 64 if (len == 0) 65 return TEE_ERROR_BAD_PARAMETERS; 66 67 if (hash_size > len) { 68 if (hash_size > sizeof(block_digest)) 69 return TEE_ERROR_BAD_STATE; 70 tmp_digest = block_digest; /* use a tempory buffer */ 71 } else { 72 tmp_digest = digest; 73 } 74 75 if (hc->descr->done(&hc->state, tmp_digest) == CRYPT_OK) { 76 if (hash_size > len) 77 memcpy(digest, tmp_digest, len); 78 } else { 79 return TEE_ERROR_BAD_STATE; 80 } 81 82 return TEE_SUCCESS; 83 } 84 85 static void ltc_hash_free_ctx(struct crypto_hash_ctx *ctx) 86 { 87 free(to_hash_ctx(ctx)); 88 } 89 90 static void ltc_hash_copy_state(struct crypto_hash_ctx *dst_ctx, 91 struct crypto_hash_ctx *src_ctx) 92 { 93 struct ltc_hash_ctx *src = to_hash_ctx(src_ctx); 94 struct ltc_hash_ctx *dst = to_hash_ctx(dst_ctx); 95 96 assert(src->descr == dst->descr); 97 dst->state = src->state; 98 } 99 100 static const struct crypto_hash_ops ltc_hash_ops = { 101 .init = ltc_hash_init, 102 .update = ltc_hash_update, 103 .final = ltc_hash_final, 104 .free_ctx = ltc_hash_free_ctx, 105 .copy_state = ltc_hash_copy_state, 106 }; 107 108 static TEE_Result ltc_hash_alloc_ctx(struct crypto_hash_ctx **ctx_ret, 109 int ltc_hash_idx) 110 { 111 struct ltc_hash_ctx *ctx = NULL; 112 113 if (ltc_hash_idx < 0) 114 return TEE_ERROR_NOT_SUPPORTED; 115 116 ctx = calloc(1, sizeof(*ctx)); 117 if (!ctx) 118 return TEE_ERROR_OUT_OF_MEMORY; 119 120 ctx->ctx.ops = <c_hash_ops; 121 ctx->descr = hash_descriptor[ltc_hash_idx]; 122 123 *ctx_ret = &ctx->ctx; 124 125 return TEE_SUCCESS; 126 } 127 128 #if defined(_CFG_CORE_LTC_MD5) 129 TEE_Result crypto_md5_alloc_ctx(struct crypto_hash_ctx **ctx) 130 { 131 return ltc_hash_alloc_ctx(ctx, find_hash("md5")); 132 } 133 #endif 134 135 #if defined(_CFG_CORE_LTC_SHA1) 136 TEE_Result crypto_sha1_alloc_ctx(struct crypto_hash_ctx **ctx) 137 { 138 return ltc_hash_alloc_ctx(ctx, find_hash("sha1")); 139 } 140 #endif 141 142 #if defined(_CFG_CORE_LTC_SHA224) 143 TEE_Result crypto_sha224_alloc_ctx(struct crypto_hash_ctx **ctx) 144 { 145 return ltc_hash_alloc_ctx(ctx, find_hash("sha224")); 146 } 147 #endif 148 149 #if defined(_CFG_CORE_LTC_SHA256) 150 TEE_Result crypto_sha256_alloc_ctx(struct crypto_hash_ctx **ctx) 151 { 152 return ltc_hash_alloc_ctx(ctx, find_hash("sha256")); 153 } 154 #endif 155 156 #if defined(_CFG_CORE_LTC_SHA384) 157 TEE_Result crypto_sha384_alloc_ctx(struct crypto_hash_ctx **ctx) 158 { 159 return ltc_hash_alloc_ctx(ctx, find_hash("sha384")); 160 } 161 #endif 162 163 #if defined(_CFG_CORE_LTC_SHA512) 164 TEE_Result crypto_sha512_alloc_ctx(struct crypto_hash_ctx **ctx) 165 { 166 return ltc_hash_alloc_ctx(ctx, find_hash("sha512")); 167 } 168 #endif 169 170 #if defined(_CFG_CORE_LTC_SHA256) 171 TEE_Result hash_sha256_check(const uint8_t *hash, const uint8_t *data, 172 size_t data_size) 173 { 174 hash_state hs; 175 uint8_t digest[TEE_SHA256_HASH_SIZE]; 176 177 if (sha256_init(&hs) != CRYPT_OK) 178 return TEE_ERROR_GENERIC; 179 if (sha256_process(&hs, data, data_size) != CRYPT_OK) 180 return TEE_ERROR_GENERIC; 181 if (sha256_done(&hs, digest) != CRYPT_OK) 182 return TEE_ERROR_GENERIC; 183 if (consttime_memcmp(digest, hash, sizeof(digest)) != 0) 184 return TEE_ERROR_SECURITY; 185 return TEE_SUCCESS; 186 } 187 #endif 188 189 #if defined(_CFG_CORE_LTC_SHA512_256) 190 TEE_Result hash_sha512_256_compute(uint8_t *digest, const uint8_t *data, 191 size_t data_size) 192 { 193 hash_state hs; 194 195 if (sha512_256_init(&hs) != CRYPT_OK) 196 return TEE_ERROR_GENERIC; 197 if (sha512_256_process(&hs, data, data_size) != CRYPT_OK) 198 return TEE_ERROR_GENERIC; 199 if (sha512_256_done(&hs, digest) != CRYPT_OK) 200 return TEE_ERROR_GENERIC; 201 202 return TEE_SUCCESS; 203 } 204 #endif 205 206