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