1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Microchip / Atmel ECC (I2C) driver. 4 * 5 * Copyright (c) 2017, Microchip Technology Inc. 6 * Author: Tudor Ambarus 7 */ 8 9 #include <linux/delay.h> 10 #include <linux/device.h> 11 #include <linux/err.h> 12 #include <linux/errno.h> 13 #include <linux/i2c.h> 14 #include <linux/init.h> 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/of.h> 18 #include <linux/scatterlist.h> 19 #include <linux/slab.h> 20 #include <linux/workqueue.h> 21 #include <crypto/internal/kpp.h> 22 #include <crypto/ecdh.h> 23 #include <crypto/kpp.h> 24 #include "atmel-i2c.h" 25 26 static struct atmel_ecc_driver_data driver_data; 27 28 /** 29 * struct atmel_ecdh_ctx - transformation context 30 * @client: I2C client device 31 * @fallback: ECDH fallback used for caller-provided private keys 32 * @public_key: cached public key for the device-generated private key 33 * @do_fallback: true when ECDH operations should use @fallback 34 * 35 * The caller must not invoke set_secret() while generate_public_key() 36 * or compute_shared_secret() are in flight. 37 */ 38 struct atmel_ecdh_ctx { 39 struct i2c_client *client; 40 struct crypto_kpp *fallback; 41 const u8 *public_key; 42 bool do_fallback; 43 }; 44 45 static void atmel_ecdh_done(struct atmel_i2c_work_data *work_data, void *areq, 46 int status) 47 { 48 struct kpp_request *req = areq; 49 struct atmel_i2c_cmd *cmd = &work_data->cmd; 50 size_t copied, n_sz; 51 52 if (status) 53 goto free_work_data; 54 55 /* copy only as much as requested, capped at 32 bytes */ 56 n_sz = min(ATMEL_ECC_NIST_P256_N_SIZE, req->dst_len); 57 58 /* copy the shared secret */ 59 copied = sg_copy_from_buffer(req->dst, sg_nents_for_len(req->dst, n_sz), 60 &cmd->data[RSP_DATA_IDX], n_sz); 61 if (copied != n_sz) 62 status = -EINVAL; 63 64 free_work_data: 65 kfree_sensitive(work_data); 66 kpp_request_complete(req, status); 67 } 68 69 /* 70 * If no private key is provided, generate one in the device and cache 71 * the corresponding public key. The generated private key never leaves 72 * the device. 73 */ 74 static int atmel_ecdh_set_secret(struct crypto_kpp *tfm, const void *buf, 75 unsigned int len) 76 { 77 struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm); 78 struct atmel_i2c_cmd *cmd; 79 void *public_key; 80 struct ecdh params; 81 int ret = -ENOMEM; 82 83 kfree(ctx->public_key); 84 ctx->public_key = NULL; 85 ctx->do_fallback = false; 86 87 if (crypto_ecdh_decode_key(buf, len, ¶ms) < 0) { 88 dev_err(&ctx->client->dev, "crypto_ecdh_decode_key failed\n"); 89 return -EINVAL; 90 } 91 92 if (params.key_size) { 93 ret = crypto_kpp_set_secret(ctx->fallback, buf, len); 94 ctx->do_fallback = !ret; 95 return ret; 96 } 97 98 cmd = kmalloc_obj(*cmd); 99 if (!cmd) 100 return -ENOMEM; 101 102 public_key = kmalloc(ATMEL_ECC_PUBKEY_SIZE, GFP_KERNEL); 103 if (!public_key) 104 goto free_cmd; 105 106 atmel_i2c_init_genkey_cmd(cmd, DATA_SLOT_2); 107 108 ret = atmel_i2c_send_receive(ctx->client, cmd); 109 if (ret) 110 goto free_public_key; 111 112 memcpy(public_key, &cmd->data[RSP_DATA_IDX], ATMEL_ECC_PUBKEY_SIZE); 113 ctx->public_key = public_key; 114 115 kfree(cmd); 116 return 0; 117 118 free_public_key: 119 kfree(public_key); 120 free_cmd: 121 kfree(cmd); 122 return ret; 123 } 124 125 static int atmel_ecdh_generate_public_key(struct kpp_request *req) 126 { 127 struct crypto_kpp *tfm = crypto_kpp_reqtfm(req); 128 struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm); 129 size_t copied, nbytes; 130 int ret = 0; 131 132 if (ctx->do_fallback) { 133 kpp_request_set_tfm(req, ctx->fallback); 134 return crypto_kpp_generate_public_key(req); 135 } 136 137 if (!ctx->public_key) 138 return -EINVAL; 139 140 /* copy only as much as requested, capped at 64 bytes */ 141 nbytes = min(ATMEL_ECC_PUBKEY_SIZE, req->dst_len); 142 143 /* public key was saved at private key generation */ 144 copied = sg_copy_from_buffer(req->dst, 145 sg_nents_for_len(req->dst, nbytes), 146 ctx->public_key, nbytes); 147 if (copied != nbytes) 148 ret = -EINVAL; 149 150 return ret; 151 } 152 153 static int atmel_ecdh_compute_shared_secret(struct kpp_request *req) 154 { 155 struct crypto_kpp *tfm = crypto_kpp_reqtfm(req); 156 struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm); 157 struct atmel_i2c_work_data *work_data; 158 gfp_t gfp; 159 int ret; 160 161 if (ctx->do_fallback) { 162 kpp_request_set_tfm(req, ctx->fallback); 163 return crypto_kpp_compute_shared_secret(req); 164 } 165 166 if (!ctx->public_key) 167 return -EINVAL; 168 169 /* A P-256 public key must contain two 32-byte coordinates */ 170 if (req->src_len != ATMEL_ECC_PUBKEY_SIZE) 171 return -EINVAL; 172 173 gfp = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? GFP_KERNEL : 174 GFP_ATOMIC; 175 176 work_data = kmalloc_obj(*work_data, gfp); 177 if (!work_data) 178 return -ENOMEM; 179 180 work_data->ctx = ctx; 181 work_data->client = ctx->client; 182 183 ret = atmel_i2c_init_ecdh_cmd(&work_data->cmd, req->src); 184 if (ret) 185 goto free_work_data; 186 187 atmel_i2c_enqueue(work_data, atmel_ecdh_done, req); 188 189 return -EINPROGRESS; 190 191 free_work_data: 192 kfree(work_data); 193 return ret; 194 } 195 196 static struct i2c_client *atmel_ecc_i2c_client_alloc(void) 197 { 198 struct atmel_i2c_client_priv *i2c_priv, *min_i2c_priv = NULL; 199 struct i2c_client *client = ERR_PTR(-ENODEV); 200 int min_tfm_cnt = INT_MAX; 201 int tfm_cnt; 202 203 spin_lock(&driver_data.i2c_list_lock); 204 205 if (list_empty(&driver_data.i2c_client_list)) { 206 spin_unlock(&driver_data.i2c_list_lock); 207 return ERR_PTR(-ENODEV); 208 } 209 210 list_for_each_entry(i2c_priv, &driver_data.i2c_client_list, 211 i2c_client_list_node) { 212 tfm_cnt = atomic_read(&i2c_priv->tfm_count); 213 if (tfm_cnt < min_tfm_cnt) { 214 min_tfm_cnt = tfm_cnt; 215 min_i2c_priv = i2c_priv; 216 } 217 if (!min_tfm_cnt) 218 break; 219 } 220 221 if (min_i2c_priv) { 222 atomic_inc(&min_i2c_priv->tfm_count); 223 client = min_i2c_priv->client; 224 } 225 226 spin_unlock(&driver_data.i2c_list_lock); 227 228 return client; 229 } 230 231 static void atmel_ecc_i2c_client_free(struct i2c_client *client) 232 { 233 struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client); 234 235 atomic_dec(&i2c_priv->tfm_count); 236 } 237 238 static int atmel_ecdh_init_tfm(struct crypto_kpp *tfm) 239 { 240 const char *alg = kpp_alg_name(tfm); 241 struct crypto_kpp *fallback; 242 struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm); 243 244 ctx->client = atmel_ecc_i2c_client_alloc(); 245 if (IS_ERR(ctx->client)) { 246 pr_err("tfm - i2c_client binding failed\n"); 247 return PTR_ERR(ctx->client); 248 } 249 250 fallback = crypto_alloc_kpp(alg, 0, CRYPTO_ALG_NEED_FALLBACK); 251 if (IS_ERR(fallback)) { 252 dev_err(&ctx->client->dev, "Failed to allocate transformation for '%s': %ld\n", 253 alg, PTR_ERR(fallback)); 254 atmel_ecc_i2c_client_free(ctx->client); 255 return PTR_ERR(fallback); 256 } 257 258 crypto_kpp_set_flags(fallback, crypto_kpp_get_flags(tfm)); 259 ctx->fallback = fallback; 260 261 return 0; 262 } 263 264 static void atmel_ecdh_exit_tfm(struct crypto_kpp *tfm) 265 { 266 struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm); 267 268 kfree(ctx->public_key); 269 crypto_free_kpp(ctx->fallback); 270 atmel_ecc_i2c_client_free(ctx->client); 271 } 272 273 static unsigned int atmel_ecdh_max_size(struct crypto_kpp *tfm) 274 { 275 struct atmel_ecdh_ctx *ctx = kpp_tfm_ctx(tfm); 276 277 return crypto_kpp_maxsize(ctx->fallback); 278 } 279 280 static struct kpp_alg atmel_ecdh_nist_p256 = { 281 .set_secret = atmel_ecdh_set_secret, 282 .generate_public_key = atmel_ecdh_generate_public_key, 283 .compute_shared_secret = atmel_ecdh_compute_shared_secret, 284 .init = atmel_ecdh_init_tfm, 285 .exit = atmel_ecdh_exit_tfm, 286 .max_size = atmel_ecdh_max_size, 287 .base = { 288 .cra_flags = CRYPTO_ALG_NEED_FALLBACK, 289 .cra_name = "ecdh-nist-p256", 290 .cra_driver_name = "atmel-ecdh", 291 .cra_priority = ATMEL_ECC_PRIORITY, 292 .cra_module = THIS_MODULE, 293 .cra_ctxsize = sizeof(struct atmel_ecdh_ctx), 294 }, 295 }; 296 297 static int atmel_ecc_probe(struct i2c_client *client) 298 { 299 struct atmel_i2c_client_priv *i2c_priv; 300 int ret; 301 302 ret = atmel_i2c_probe(client); 303 if (ret) 304 return ret; 305 306 i2c_priv = i2c_get_clientdata(client); 307 308 spin_lock(&driver_data.i2c_list_lock); 309 list_add_tail(&i2c_priv->i2c_client_list_node, 310 &driver_data.i2c_client_list); 311 spin_unlock(&driver_data.i2c_list_lock); 312 313 ret = crypto_register_kpp(&atmel_ecdh_nist_p256); 314 if (ret) { 315 spin_lock(&driver_data.i2c_list_lock); 316 list_del(&i2c_priv->i2c_client_list_node); 317 spin_unlock(&driver_data.i2c_list_lock); 318 319 dev_err(&client->dev, "%s alg registration failed\n", 320 atmel_ecdh_nist_p256.base.cra_driver_name); 321 } else { 322 dev_info(&client->dev, "atmel ecc algorithms registered in /proc/crypto\n"); 323 } 324 325 return ret; 326 } 327 328 static void atmel_ecc_remove(struct i2c_client *client) 329 { 330 struct atmel_i2c_client_priv *i2c_priv = i2c_get_clientdata(client); 331 332 /* Return EBUSY if i2c client already allocated. */ 333 if (atomic_read(&i2c_priv->tfm_count)) { 334 /* 335 * After we return here, the memory backing the device is freed. 336 * That happens no matter what the return value of this function 337 * is because in the Linux device model there is no error 338 * handling for unbinding a driver. 339 * If there is still some action pending, it probably involves 340 * accessing the freed memory. 341 */ 342 dev_emerg(&client->dev, "Device is busy, expect memory corruption.\n"); 343 return; 344 } 345 346 crypto_unregister_kpp(&atmel_ecdh_nist_p256); 347 348 spin_lock(&driver_data.i2c_list_lock); 349 list_del(&i2c_priv->i2c_client_list_node); 350 spin_unlock(&driver_data.i2c_list_lock); 351 } 352 353 static const struct of_device_id atmel_ecc_dt_ids[] = { 354 { .compatible = "atmel,atecc508a", }, 355 { .compatible = "atmel,atecc608b", }, 356 { } 357 }; 358 MODULE_DEVICE_TABLE(of, atmel_ecc_dt_ids); 359 360 static const struct i2c_device_id atmel_ecc_id[] = { 361 { .name = "atecc508a" }, 362 { .name = "atecc608b" }, 363 { } 364 }; 365 MODULE_DEVICE_TABLE(i2c, atmel_ecc_id); 366 367 static struct i2c_driver atmel_ecc_driver = { 368 .driver = { 369 .name = "atmel-ecc", 370 .of_match_table = atmel_ecc_dt_ids, 371 }, 372 .probe = atmel_ecc_probe, 373 .remove = atmel_ecc_remove, 374 .id_table = atmel_ecc_id, 375 }; 376 377 static int __init atmel_ecc_init(void) 378 { 379 spin_lock_init(&driver_data.i2c_list_lock); 380 INIT_LIST_HEAD(&driver_data.i2c_client_list); 381 return i2c_add_driver(&atmel_ecc_driver); 382 } 383 384 static void __exit atmel_ecc_exit(void) 385 { 386 atmel_i2c_flush_queue(); 387 i2c_del_driver(&atmel_ecc_driver); 388 } 389 390 module_init(atmel_ecc_init); 391 module_exit(atmel_ecc_exit); 392 393 MODULE_AUTHOR("Tudor Ambarus"); 394 MODULE_DESCRIPTION("Microchip / Atmel ECC (I2C) driver"); 395 MODULE_LICENSE("GPL v2"); 396