rsa-sign.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2013, Google Inc.
  4. */
  5. #define OPENSSL_API_COMPAT 0x10101000L
  6. #include "mkimage.h"
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <image.h>
  11. #include <time.h>
  12. #include <u-boot/fdt-libcrypto.h>
  13. #include <openssl/bn.h>
  14. #include <openssl/ec.h>
  15. #include <openssl/rsa.h>
  16. #include <openssl/pem.h>
  17. #include <openssl/err.h>
  18. #include <openssl/ssl.h>
  19. #include <openssl/evp.h>
  20. #include <openssl/engine.h>
  21. static int rsa_err(const char *msg)
  22. {
  23. unsigned long sslErr = ERR_get_error();
  24. fprintf(stderr, "%s", msg);
  25. fprintf(stderr, ": %s\n",
  26. ERR_error_string(sslErr, 0));
  27. return -1;
  28. }
  29. /**
  30. * rsa_pem_get_pub_key() - read a public key from a .crt file
  31. *
  32. * @keydir: Directory containins the key
  33. * @name Name of key file (will have a .crt extension)
  34. * @evpp Returns EVP_PKEY object, or NULL on failure
  35. * @return 0 if ok, -ve on error (in which case *evpp will be set to NULL)
  36. */
  37. static int rsa_pem_get_pub_key(const char *keydir, const char *name, EVP_PKEY **evpp)
  38. {
  39. char path[1024];
  40. EVP_PKEY *key = NULL;
  41. X509 *cert;
  42. FILE *f;
  43. int ret;
  44. if (!evpp)
  45. return -EINVAL;
  46. *evpp = NULL;
  47. snprintf(path, sizeof(path), "%s/%s.crt", keydir, name);
  48. f = fopen(path, "r");
  49. if (!f) {
  50. fprintf(stderr, "Couldn't open RSA certificate: '%s': %s\n",
  51. path, strerror(errno));
  52. return -EACCES;
  53. }
  54. /* Read the certificate */
  55. cert = NULL;
  56. if (!PEM_read_X509(f, &cert, NULL, NULL)) {
  57. rsa_err("Couldn't read certificate");
  58. ret = -EINVAL;
  59. goto err_cert;
  60. }
  61. /* Get the public key from the certificate. */
  62. key = X509_get_pubkey(cert);
  63. if (!key) {
  64. rsa_err("Couldn't read public key\n");
  65. ret = -EINVAL;
  66. goto err_pubkey;
  67. }
  68. fclose(f);
  69. *evpp = key;
  70. X509_free(cert);
  71. return 0;
  72. err_pubkey:
  73. X509_free(cert);
  74. err_cert:
  75. fclose(f);
  76. return ret;
  77. }
  78. /**
  79. * rsa_engine_get_pub_key() - read a public key from given engine
  80. *
  81. * @keydir: Key prefix
  82. * @name Name of key
  83. * @engine Engine to use
  84. * @evpp Returns EVP_PKEY object, or NULL on failure
  85. * @return 0 if ok, -ve on error (in which case *evpp will be set to NULL)
  86. */
  87. static int rsa_engine_get_pub_key(const char *keydir, const char *name,
  88. ENGINE *engine, EVP_PKEY **evpp)
  89. {
  90. const char *engine_id;
  91. char key_id[1024];
  92. EVP_PKEY *key = NULL;
  93. if (!evpp)
  94. return -EINVAL;
  95. *evpp = NULL;
  96. engine_id = ENGINE_get_id(engine);
  97. if (engine_id && !strcmp(engine_id, "pkcs11")) {
  98. if (keydir)
  99. if (strstr(keydir, "object="))
  100. snprintf(key_id, sizeof(key_id),
  101. "pkcs11:%s;type=public",
  102. keydir);
  103. else
  104. snprintf(key_id, sizeof(key_id),
  105. "pkcs11:%s;object=%s;type=public",
  106. keydir, name);
  107. else
  108. snprintf(key_id, sizeof(key_id),
  109. "pkcs11:object=%s;type=public",
  110. name);
  111. } else if (engine_id) {
  112. if (keydir)
  113. snprintf(key_id, sizeof(key_id),
  114. "%s%s",
  115. keydir, name);
  116. else
  117. snprintf(key_id, sizeof(key_id),
  118. "%s",
  119. name);
  120. } else {
  121. fprintf(stderr, "Engine not supported\n");
  122. return -ENOTSUP;
  123. }
  124. key = ENGINE_load_public_key(engine, key_id, NULL, NULL);
  125. if (!key)
  126. return rsa_err("Failure loading public key from engine");
  127. *evpp = key;
  128. return 0;
  129. }
  130. /**
  131. * rsa_get_pub_key() - read a public key
  132. *
  133. * @keydir: Directory containing the key (PEM file) or key prefix (engine)
  134. * @name Name of key file (will have a .crt extension)
  135. * @engine Engine to use
  136. * @evpp Returns EVP_PKEY object, or NULL on failure
  137. * @return 0 if ok, -ve on error (in which case *evpp will be set to NULL)
  138. */
  139. static int rsa_get_pub_key(const char *keydir, const char *name,
  140. ENGINE *engine, EVP_PKEY **evpp)
  141. {
  142. if (engine)
  143. return rsa_engine_get_pub_key(keydir, name, engine, evpp);
  144. return rsa_pem_get_pub_key(keydir, name, evpp);
  145. }
  146. /**
  147. * rsa_pem_get_priv_key() - read a private key from a .key file
  148. *
  149. * @keydir: Directory containing the key
  150. * @name Name of key file (will have a .key extension)
  151. * @evpp Returns EVP_PKEY object, or NULL on failure
  152. * @return 0 if ok, -ve on error (in which case *evpp will be set to NULL)
  153. */
  154. static int rsa_pem_get_priv_key(const char *keydir, const char *name,
  155. const char *keyfile, EVP_PKEY **evpp)
  156. {
  157. char path[1024] = {0};
  158. FILE *f = NULL;
  159. if (!evpp)
  160. return -EINVAL;
  161. *evpp = NULL;
  162. if (keydir && name)
  163. snprintf(path, sizeof(path), "%s/%s.key", keydir, name);
  164. else if (keyfile)
  165. snprintf(path, sizeof(path), "%s", keyfile);
  166. else
  167. return -EINVAL;
  168. f = fopen(path, "r");
  169. if (!f) {
  170. fprintf(stderr, "Couldn't open RSA private key: '%s': %s\n",
  171. path, strerror(errno));
  172. return -ENOENT;
  173. }
  174. if (!PEM_read_PrivateKey(f, evpp, NULL, path)) {
  175. rsa_err("Failure reading private key");
  176. fclose(f);
  177. return -EPROTO;
  178. }
  179. fclose(f);
  180. return 0;
  181. }
  182. /**
  183. * rsa_engine_get_priv_key() - read a private key from given engine
  184. *
  185. * @keydir: Key prefix
  186. * @name Name of key
  187. * @engine Engine to use
  188. * @evpp Returns EVP_PKEY object, or NULL on failure
  189. * @return 0 if ok, -ve on error (in which case *evpp will be set to NULL)
  190. */
  191. static int rsa_engine_get_priv_key(const char *keydir, const char *name,
  192. const char *keyfile,
  193. ENGINE *engine, EVP_PKEY **evpp)
  194. {
  195. const char *engine_id;
  196. char key_id[1024];
  197. EVP_PKEY *key = NULL;
  198. if (!evpp)
  199. return -EINVAL;
  200. engine_id = ENGINE_get_id(engine);
  201. if (engine_id && !strcmp(engine_id, "pkcs11")) {
  202. if (!keydir && !name) {
  203. fprintf(stderr, "Please use 'keydir' with PKCS11\n");
  204. return -EINVAL;
  205. }
  206. if (keydir)
  207. if (strstr(keydir, "object="))
  208. snprintf(key_id, sizeof(key_id),
  209. "pkcs11:%s;type=private",
  210. keydir);
  211. else
  212. snprintf(key_id, sizeof(key_id),
  213. "pkcs11:%s;object=%s;type=private",
  214. keydir, name);
  215. else
  216. snprintf(key_id, sizeof(key_id),
  217. "pkcs11:object=%s;type=private",
  218. name);
  219. } else if (engine_id) {
  220. if (keydir && name)
  221. snprintf(key_id, sizeof(key_id),
  222. "%s%s",
  223. keydir, name);
  224. else if (name)
  225. snprintf(key_id, sizeof(key_id),
  226. "%s",
  227. name ? name : "");
  228. else if (keyfile)
  229. snprintf(key_id, sizeof(key_id), "%s", keyfile);
  230. else
  231. return -EINVAL;
  232. } else {
  233. fprintf(stderr, "Engine not supported\n");
  234. return -ENOTSUP;
  235. }
  236. key = ENGINE_load_private_key(engine, key_id, NULL, NULL);
  237. if (!key)
  238. return rsa_err("Failure loading private key from engine");
  239. *evpp = key;
  240. return 0;
  241. }
  242. /**
  243. * rsa_get_priv_key() - read a private key
  244. *
  245. * @keydir: Directory containing the key (PEM file) or key prefix (engine)
  246. * @name Name of key
  247. * @engine Engine to use for signing
  248. * @evpp Returns EVP_PKEY object, or NULL on failure
  249. * @return 0 if ok, -ve on error (in which case *evpp will be set to NULL)
  250. */
  251. static int rsa_get_priv_key(const char *keydir, const char *name,
  252. const char *keyfile, ENGINE *engine, EVP_PKEY **evpp)
  253. {
  254. if (engine)
  255. return rsa_engine_get_priv_key(keydir, name, keyfile, engine,
  256. evpp);
  257. return rsa_pem_get_priv_key(keydir, name, keyfile, evpp);
  258. }
  259. static int rsa_init(void)
  260. {
  261. int ret;
  262. ret = OPENSSL_init_ssl(0, NULL);
  263. if (!ret) {
  264. fprintf(stderr, "Failure to init SSL library\n");
  265. return -1;
  266. }
  267. return 0;
  268. }
  269. static int rsa_engine_init(const char *engine_id, ENGINE **pe)
  270. {
  271. const char *key_pass;
  272. ENGINE *e;
  273. int ret;
  274. ENGINE_load_builtin_engines();
  275. e = ENGINE_by_id(engine_id);
  276. if (!e) {
  277. fprintf(stderr, "Engine isn't available\n");
  278. return -1;
  279. }
  280. if (!ENGINE_init(e)) {
  281. fprintf(stderr, "Couldn't initialize engine\n");
  282. ret = -1;
  283. goto err_engine_init;
  284. }
  285. if (!ENGINE_set_default_RSA(e)) {
  286. fprintf(stderr, "Couldn't set engine as default for RSA\n");
  287. ret = -1;
  288. goto err_set_rsa;
  289. }
  290. key_pass = getenv("MKIMAGE_SIGN_PIN");
  291. if (key_pass) {
  292. if (!ENGINE_ctrl_cmd_string(e, "PIN", key_pass, 0)) {
  293. fprintf(stderr, "Couldn't set PIN\n");
  294. ret = -1;
  295. goto err_set_pin;
  296. }
  297. }
  298. *pe = e;
  299. return 0;
  300. err_set_pin:
  301. err_set_rsa:
  302. ENGINE_finish(e);
  303. err_engine_init:
  304. ENGINE_free(e);
  305. return ret;
  306. }
  307. static void rsa_engine_remove(ENGINE *e)
  308. {
  309. if (e) {
  310. ENGINE_finish(e);
  311. ENGINE_free(e);
  312. }
  313. }
  314. static int rsa_sign_with_key(EVP_PKEY *pkey, struct padding_algo *padding_algo,
  315. struct checksum_algo *checksum_algo,
  316. const struct image_region region[], int region_count,
  317. uint8_t **sigp, uint *sig_size)
  318. {
  319. EVP_PKEY_CTX *ckey;
  320. EVP_MD_CTX *context;
  321. int ret = 0;
  322. size_t size;
  323. uint8_t *sig;
  324. int i;
  325. size = EVP_PKEY_size(pkey);
  326. sig = malloc(size);
  327. if (!sig) {
  328. fprintf(stderr, "Out of memory for signature (%zu bytes)\n",
  329. size);
  330. ret = -ENOMEM;
  331. goto err_alloc;
  332. }
  333. context = EVP_MD_CTX_create();
  334. if (!context) {
  335. ret = rsa_err("EVP context creation failed");
  336. goto err_create;
  337. }
  338. EVP_MD_CTX_init(context);
  339. ckey = EVP_PKEY_CTX_new(pkey, NULL);
  340. if (!ckey) {
  341. ret = rsa_err("EVP key context creation failed");
  342. goto err_create;
  343. }
  344. if (EVP_DigestSignInit(context, &ckey,
  345. checksum_algo->calculate_sign(),
  346. NULL, pkey) <= 0) {
  347. ret = rsa_err("Signer setup failed");
  348. goto err_sign;
  349. }
  350. if (CONFIG_IS_ENABLED(FIT_RSASSA_PSS) && padding_algo &&
  351. !strcmp(padding_algo->name, "pss")) {
  352. if (EVP_PKEY_CTX_set_rsa_padding(ckey,
  353. RSA_PKCS1_PSS_PADDING) <= 0) {
  354. ret = rsa_err("Signer padding setup failed");
  355. goto err_sign;
  356. }
  357. }
  358. for (i = 0; i < region_count; i++) {
  359. if (!EVP_DigestSignUpdate(context, region[i].data,
  360. region[i].size)) {
  361. ret = rsa_err("Signing data failed");
  362. goto err_sign;
  363. }
  364. }
  365. if (!EVP_DigestSignFinal(context, sig, &size)) {
  366. ret = rsa_err("Could not obtain signature");
  367. goto err_sign;
  368. }
  369. EVP_MD_CTX_reset(context);
  370. EVP_MD_CTX_destroy(context);
  371. debug("Got signature: %zu bytes, expected %d\n", size, EVP_PKEY_size(pkey));
  372. *sigp = sig;
  373. *sig_size = size;
  374. return 0;
  375. err_sign:
  376. EVP_MD_CTX_destroy(context);
  377. err_create:
  378. free(sig);
  379. err_alloc:
  380. return ret;
  381. }
  382. int rsa_sign(struct image_sign_info *info,
  383. const struct image_region region[], int region_count,
  384. uint8_t **sigp, uint *sig_len)
  385. {
  386. EVP_PKEY *pkey = NULL;
  387. ENGINE *e = NULL;
  388. int ret;
  389. ret = rsa_init();
  390. if (ret)
  391. return ret;
  392. if (info->engine_id) {
  393. ret = rsa_engine_init(info->engine_id, &e);
  394. if (ret)
  395. return ret;
  396. }
  397. ret = rsa_get_priv_key(info->keydir, info->keyname, info->keyfile,
  398. e, &pkey);
  399. if (ret)
  400. goto err_priv;
  401. ret = rsa_sign_with_key(pkey, info->padding, info->checksum, region,
  402. region_count, sigp, sig_len);
  403. if (ret)
  404. goto err_sign;
  405. EVP_PKEY_free(pkey);
  406. if (info->engine_id)
  407. rsa_engine_remove(e);
  408. return ret;
  409. err_sign:
  410. EVP_PKEY_free(pkey);
  411. err_priv:
  412. if (info->engine_id)
  413. rsa_engine_remove(e);
  414. return ret;
  415. }
  416. /*
  417. * rsa_get_exponent(): - Get the public exponent from an RSA key
  418. */
  419. static int rsa_get_exponent(RSA *key, uint64_t *e)
  420. {
  421. int ret;
  422. BIGNUM *bn_te;
  423. const BIGNUM *key_e;
  424. uint64_t te;
  425. ret = -EINVAL;
  426. bn_te = NULL;
  427. if (!e)
  428. goto cleanup;
  429. RSA_get0_key(key, NULL, &key_e, NULL);
  430. if (BN_num_bits(key_e) > 64)
  431. goto cleanup;
  432. *e = BN_get_word(key_e);
  433. if (BN_num_bits(key_e) < 33) {
  434. ret = 0;
  435. goto cleanup;
  436. }
  437. bn_te = BN_dup(key_e);
  438. if (!bn_te)
  439. goto cleanup;
  440. if (!BN_rshift(bn_te, bn_te, 32))
  441. goto cleanup;
  442. if (!BN_mask_bits(bn_te, 32))
  443. goto cleanup;
  444. te = BN_get_word(bn_te);
  445. te <<= 32;
  446. *e |= te;
  447. ret = 0;
  448. cleanup:
  449. if (bn_te)
  450. BN_free(bn_te);
  451. return ret;
  452. }
  453. /*
  454. * rsa_get_params(): - Get the important parameters of an RSA public key
  455. */
  456. int rsa_get_params(RSA *key, uint64_t *exponent, uint32_t *n0_invp,
  457. BIGNUM **modulusp, BIGNUM **r_squaredp)
  458. {
  459. BIGNUM *big1, *big2, *big32, *big2_32;
  460. BIGNUM *n, *r, *r_squared, *tmp;
  461. const BIGNUM *key_n;
  462. BN_CTX *bn_ctx = BN_CTX_new();
  463. int ret = 0;
  464. /* Initialize BIGNUMs */
  465. big1 = BN_new();
  466. big2 = BN_new();
  467. big32 = BN_new();
  468. r = BN_new();
  469. r_squared = BN_new();
  470. tmp = BN_new();
  471. big2_32 = BN_new();
  472. n = BN_new();
  473. if (!big1 || !big2 || !big32 || !r || !r_squared || !tmp || !big2_32 ||
  474. !n) {
  475. fprintf(stderr, "Out of memory (bignum)\n");
  476. return -ENOMEM;
  477. }
  478. if (0 != rsa_get_exponent(key, exponent))
  479. ret = -1;
  480. RSA_get0_key(key, &key_n, NULL, NULL);
  481. if (!BN_copy(n, key_n) || !BN_set_word(big1, 1L) ||
  482. !BN_set_word(big2, 2L) || !BN_set_word(big32, 32L))
  483. ret = -1;
  484. /* big2_32 = 2^32 */
  485. if (!BN_exp(big2_32, big2, big32, bn_ctx))
  486. ret = -1;
  487. /* Calculate n0_inv = -1 / n[0] mod 2^32 */
  488. if (!BN_mod_inverse(tmp, n, big2_32, bn_ctx) ||
  489. !BN_sub(tmp, big2_32, tmp))
  490. ret = -1;
  491. *n0_invp = BN_get_word(tmp);
  492. /* Calculate R = 2^(# of key bits) */
  493. if (!BN_set_word(tmp, BN_num_bits(n)) ||
  494. !BN_exp(r, big2, tmp, bn_ctx))
  495. ret = -1;
  496. /* Calculate r_squared = R^2 mod n */
  497. if (!BN_copy(r_squared, r) ||
  498. !BN_mul(tmp, r_squared, r, bn_ctx) ||
  499. !BN_mod(r_squared, tmp, n, bn_ctx))
  500. ret = -1;
  501. *modulusp = n;
  502. *r_squaredp = r_squared;
  503. BN_free(big1);
  504. BN_free(big2);
  505. BN_free(big32);
  506. BN_free(r);
  507. BN_free(tmp);
  508. BN_free(big2_32);
  509. if (ret) {
  510. fprintf(stderr, "Bignum operations failed\n");
  511. return -ENOMEM;
  512. }
  513. return ret;
  514. }
  515. int rsa_add_verify_data(struct image_sign_info *info, void *keydest)
  516. {
  517. BIGNUM *modulus, *r_squared;
  518. uint64_t exponent;
  519. uint32_t n0_inv;
  520. int parent, node;
  521. char name[100];
  522. int ret;
  523. int bits;
  524. RSA *rsa;
  525. EVP_PKEY *pkey = NULL;
  526. ENGINE *e = NULL;
  527. debug("%s: Getting verification data\n", __func__);
  528. if (info->engine_id) {
  529. ret = rsa_engine_init(info->engine_id, &e);
  530. if (ret)
  531. return ret;
  532. }
  533. ret = rsa_get_pub_key(info->keydir, info->keyname, e, &pkey);
  534. if (ret)
  535. goto err_get_pub_key;
  536. rsa = EVP_PKEY_get0_RSA(pkey);
  537. ret = rsa_get_params(rsa, &exponent, &n0_inv, &modulus, &r_squared);
  538. if (ret)
  539. goto err_get_params;
  540. bits = BN_num_bits(modulus);
  541. parent = fdt_subnode_offset(keydest, 0, FIT_SIG_NODENAME);
  542. if (parent == -FDT_ERR_NOTFOUND) {
  543. parent = fdt_add_subnode(keydest, 0, FIT_SIG_NODENAME);
  544. if (parent < 0) {
  545. ret = parent;
  546. if (ret != -FDT_ERR_NOSPACE) {
  547. fprintf(stderr, "Couldn't create signature node: %s\n",
  548. fdt_strerror(parent));
  549. }
  550. }
  551. }
  552. if (ret)
  553. goto done;
  554. /* Either create or overwrite the named key node */
  555. snprintf(name, sizeof(name), "key-%s", info->keyname);
  556. node = fdt_subnode_offset(keydest, parent, name);
  557. if (node == -FDT_ERR_NOTFOUND) {
  558. node = fdt_add_subnode(keydest, parent, name);
  559. if (node < 0) {
  560. ret = node;
  561. if (ret != -FDT_ERR_NOSPACE) {
  562. fprintf(stderr, "Could not create key subnode: %s\n",
  563. fdt_strerror(node));
  564. }
  565. }
  566. } else if (node < 0) {
  567. fprintf(stderr, "Cannot select keys parent: %s\n",
  568. fdt_strerror(node));
  569. ret = node;
  570. }
  571. if (!ret) {
  572. ret = fdt_setprop_string(keydest, node, FIT_KEY_HINT,
  573. info->keyname);
  574. }
  575. if (!ret)
  576. ret = fdt_setprop_u32(keydest, node, "rsa,num-bits", bits);
  577. if (!ret)
  578. ret = fdt_setprop_u32(keydest, node, "rsa,n0-inverse", n0_inv);
  579. if (!ret) {
  580. ret = fdt_setprop_u64(keydest, node, "rsa,exponent", exponent);
  581. }
  582. if (!ret) {
  583. ret = fdt_add_bignum(keydest, node, "rsa,modulus", modulus,
  584. bits);
  585. }
  586. if (!ret) {
  587. ret = fdt_add_bignum(keydest, node, "rsa,r-squared", r_squared,
  588. bits);
  589. }
  590. if (!ret) {
  591. ret = fdt_setprop_string(keydest, node, FIT_ALGO_PROP,
  592. info->name);
  593. }
  594. if (!ret && info->require_keys) {
  595. ret = fdt_setprop_string(keydest, node, FIT_KEY_REQUIRED,
  596. info->require_keys);
  597. }
  598. done:
  599. BN_free(modulus);
  600. BN_free(r_squared);
  601. if (ret)
  602. ret = ret == -FDT_ERR_NOSPACE ? -ENOSPC : -EIO;
  603. err_get_params:
  604. EVP_PKEY_free(pkey);
  605. err_get_pub_key:
  606. if (info->engine_id)
  607. rsa_engine_remove(e);
  608. return ret;
  609. }