1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2018 Netronome Systems, Inc */ 3 /* Copyright (C) 2021 Corigine, Inc */ 4 5 #include <linux/module.h> 6 #include <linux/kernel.h> 7 #include <linux/init.h> 8 #include <linux/netdevice.h> 9 #include <asm/unaligned.h> 10 #include <linux/ktime.h> 11 #include <net/xfrm.h> 12 13 #include "../nfp_net_ctrl.h" 14 #include "../nfp_net.h" 15 #include "crypto.h" 16 17 #define NFP_NET_IPSEC_MAX_SA_CNT (16 * 1024) /* Firmware support a maximum of 16K SA offload */ 18 19 /* IPsec config message cmd codes */ 20 enum nfp_ipsec_cfg_mssg_cmd_codes { 21 NFP_IPSEC_CFG_MSSG_ADD_SA, /* Add a new SA */ 22 NFP_IPSEC_CFG_MSSG_INV_SA /* Invalidate an existing SA */ 23 }; 24 25 /* IPsec config message response codes */ 26 enum nfp_ipsec_cfg_mssg_rsp_codes { 27 NFP_IPSEC_CFG_MSSG_OK, 28 NFP_IPSEC_CFG_MSSG_FAILED, 29 NFP_IPSEC_CFG_MSSG_SA_VALID, 30 NFP_IPSEC_CFG_MSSG_SA_HASH_ADD_FAILED, 31 NFP_IPSEC_CFG_MSSG_SA_HASH_DEL_FAILED, 32 NFP_IPSEC_CFG_MSSG_SA_INVALID_CMD 33 }; 34 35 /* Protocol */ 36 enum nfp_ipsec_sa_prot { 37 NFP_IPSEC_PROTOCOL_AH = 0, 38 NFP_IPSEC_PROTOCOL_ESP = 1 39 }; 40 41 /* Mode */ 42 enum nfp_ipsec_sa_mode { 43 NFP_IPSEC_PROTMODE_TRANSPORT = 0, 44 NFP_IPSEC_PROTMODE_TUNNEL = 1 45 }; 46 47 /* Cipher types */ 48 enum nfp_ipsec_sa_cipher { 49 NFP_IPSEC_CIPHER_NULL, 50 NFP_IPSEC_CIPHER_3DES, 51 NFP_IPSEC_CIPHER_AES128, 52 NFP_IPSEC_CIPHER_AES192, 53 NFP_IPSEC_CIPHER_AES256, 54 NFP_IPSEC_CIPHER_AES128_NULL, 55 NFP_IPSEC_CIPHER_AES192_NULL, 56 NFP_IPSEC_CIPHER_AES256_NULL, 57 NFP_IPSEC_CIPHER_CHACHA20 58 }; 59 60 /* Cipher modes */ 61 enum nfp_ipsec_sa_cipher_mode { 62 NFP_IPSEC_CIMODE_ECB, 63 NFP_IPSEC_CIMODE_CBC, 64 NFP_IPSEC_CIMODE_CFB, 65 NFP_IPSEC_CIMODE_OFB, 66 NFP_IPSEC_CIMODE_CTR 67 }; 68 69 /* Hash types */ 70 enum nfp_ipsec_sa_hash_type { 71 NFP_IPSEC_HASH_NONE, 72 NFP_IPSEC_HASH_MD5_96, 73 NFP_IPSEC_HASH_SHA1_96, 74 NFP_IPSEC_HASH_SHA256_96, 75 NFP_IPSEC_HASH_SHA384_96, 76 NFP_IPSEC_HASH_SHA512_96, 77 NFP_IPSEC_HASH_MD5_128, 78 NFP_IPSEC_HASH_SHA1_80, 79 NFP_IPSEC_HASH_SHA256_128, 80 NFP_IPSEC_HASH_SHA384_192, 81 NFP_IPSEC_HASH_SHA512_256, 82 NFP_IPSEC_HASH_GF128_128, 83 NFP_IPSEC_HASH_POLY1305_128 84 }; 85 86 /* IPSEC_CFG_MSSG_ADD_SA */ 87 struct nfp_ipsec_cfg_add_sa { 88 u32 ciph_key[8]; /* Cipher Key */ 89 union { 90 u32 auth_key[16]; /* Authentication Key */ 91 struct nfp_ipsec_aesgcm { /* AES-GCM-ESP fields */ 92 u32 salt; /* Initialized with SA */ 93 u32 resv[15]; 94 } aesgcm_fields; 95 }; 96 struct sa_ctrl_word { 97 uint32_t hash :4; /* From nfp_ipsec_sa_hash_type */ 98 uint32_t cimode :4; /* From nfp_ipsec_sa_cipher_mode */ 99 uint32_t cipher :4; /* From nfp_ipsec_sa_cipher */ 100 uint32_t mode :2; /* From nfp_ipsec_sa_mode */ 101 uint32_t proto :2; /* From nfp_ipsec_sa_prot */ 102 uint32_t dir :1; /* SA direction */ 103 uint32_t resv0 :12; 104 uint32_t encap_dsbl:1; /* Encap/Decap disable */ 105 uint32_t resv1 :2; /* Must be set to 0 */ 106 } ctrl_word; 107 u32 spi; /* SPI Value */ 108 uint32_t pmtu_limit :16; /* PMTU Limit */ 109 uint32_t resv0 :5; 110 uint32_t ipv6 :1; /* Outbound IPv6 addr format */ 111 uint32_t resv1 :10; 112 u32 resv2[2]; 113 u32 src_ip[4]; /* Src IP addr */ 114 u32 dst_ip[4]; /* Dst IP addr */ 115 u32 resv3[6]; 116 }; 117 118 /* IPSEC_CFG_MSSG */ 119 struct nfp_ipsec_cfg_mssg { 120 union { 121 struct{ 122 uint32_t cmd:16; /* One of nfp_ipsec_cfg_mssg_cmd_codes */ 123 uint32_t rsp:16; /* One of nfp_ipsec_cfg_mssg_rsp_codes */ 124 uint32_t sa_idx:16; /* SA table index */ 125 uint32_t spare0:16; 126 struct nfp_ipsec_cfg_add_sa cfg_add_sa; 127 }; 128 u32 raw[64]; 129 }; 130 }; 131 132 static int nfp_net_ipsec_cfg(struct nfp_net *nn, struct nfp_mbox_amsg_entry *entry) 133 { 134 unsigned int offset = nn->tlv_caps.mbox_off + NFP_NET_CFG_MBOX_SIMPLE_VAL; 135 struct nfp_ipsec_cfg_mssg *msg = (struct nfp_ipsec_cfg_mssg *)entry->msg; 136 int i, msg_size, ret; 137 138 ret = nfp_net_mbox_lock(nn, sizeof(*msg)); 139 if (ret) 140 return ret; 141 142 msg_size = ARRAY_SIZE(msg->raw); 143 for (i = 0; i < msg_size; i++) 144 nn_writel(nn, offset + 4 * i, msg->raw[i]); 145 146 ret = nfp_net_mbox_reconfig(nn, entry->cmd); 147 if (ret < 0) { 148 nn_ctrl_bar_unlock(nn); 149 return ret; 150 } 151 152 /* For now we always read the whole message response back */ 153 for (i = 0; i < msg_size; i++) 154 msg->raw[i] = nn_readl(nn, offset + 4 * i); 155 156 nn_ctrl_bar_unlock(nn); 157 158 switch (msg->rsp) { 159 case NFP_IPSEC_CFG_MSSG_OK: 160 return 0; 161 case NFP_IPSEC_CFG_MSSG_SA_INVALID_CMD: 162 return -EINVAL; 163 case NFP_IPSEC_CFG_MSSG_SA_VALID: 164 return -EEXIST; 165 case NFP_IPSEC_CFG_MSSG_FAILED: 166 case NFP_IPSEC_CFG_MSSG_SA_HASH_ADD_FAILED: 167 case NFP_IPSEC_CFG_MSSG_SA_HASH_DEL_FAILED: 168 return -EIO; 169 default: 170 return -EINVAL; 171 } 172 } 173 174 static int set_aes_keylen(struct nfp_ipsec_cfg_add_sa *cfg, int alg, int keylen) 175 { 176 bool aes_gmac = (alg == SADB_X_EALG_NULL_AES_GMAC); 177 178 switch (keylen) { 179 case 128: 180 cfg->ctrl_word.cipher = aes_gmac ? NFP_IPSEC_CIPHER_AES128_NULL : 181 NFP_IPSEC_CIPHER_AES128; 182 break; 183 case 192: 184 cfg->ctrl_word.cipher = aes_gmac ? NFP_IPSEC_CIPHER_AES192_NULL : 185 NFP_IPSEC_CIPHER_AES192; 186 break; 187 case 256: 188 cfg->ctrl_word.cipher = aes_gmac ? NFP_IPSEC_CIPHER_AES256_NULL : 189 NFP_IPSEC_CIPHER_AES256; 190 break; 191 default: 192 return -EINVAL; 193 } 194 195 return 0; 196 } 197 198 static void set_md5hmac(struct nfp_ipsec_cfg_add_sa *cfg, int *trunc_len) 199 { 200 switch (*trunc_len) { 201 case 96: 202 cfg->ctrl_word.hash = NFP_IPSEC_HASH_MD5_96; 203 break; 204 case 128: 205 cfg->ctrl_word.hash = NFP_IPSEC_HASH_MD5_128; 206 break; 207 default: 208 *trunc_len = 0; 209 } 210 } 211 212 static void set_sha1hmac(struct nfp_ipsec_cfg_add_sa *cfg, int *trunc_len) 213 { 214 switch (*trunc_len) { 215 case 96: 216 cfg->ctrl_word.hash = NFP_IPSEC_HASH_SHA1_96; 217 break; 218 case 80: 219 cfg->ctrl_word.hash = NFP_IPSEC_HASH_SHA1_80; 220 break; 221 default: 222 *trunc_len = 0; 223 } 224 } 225 226 static void set_sha2_256hmac(struct nfp_ipsec_cfg_add_sa *cfg, int *trunc_len) 227 { 228 switch (*trunc_len) { 229 case 96: 230 cfg->ctrl_word.hash = NFP_IPSEC_HASH_SHA256_96; 231 break; 232 case 128: 233 cfg->ctrl_word.hash = NFP_IPSEC_HASH_SHA256_128; 234 break; 235 default: 236 *trunc_len = 0; 237 } 238 } 239 240 static void set_sha2_384hmac(struct nfp_ipsec_cfg_add_sa *cfg, int *trunc_len) 241 { 242 switch (*trunc_len) { 243 case 96: 244 cfg->ctrl_word.hash = NFP_IPSEC_HASH_SHA384_96; 245 break; 246 case 192: 247 cfg->ctrl_word.hash = NFP_IPSEC_HASH_SHA384_192; 248 break; 249 default: 250 *trunc_len = 0; 251 } 252 } 253 254 static void set_sha2_512hmac(struct nfp_ipsec_cfg_add_sa *cfg, int *trunc_len) 255 { 256 switch (*trunc_len) { 257 case 96: 258 cfg->ctrl_word.hash = NFP_IPSEC_HASH_SHA512_96; 259 break; 260 case 256: 261 cfg->ctrl_word.hash = NFP_IPSEC_HASH_SHA512_256; 262 break; 263 default: 264 *trunc_len = 0; 265 } 266 } 267 268 static int nfp_net_xfrm_add_state(struct xfrm_state *x) 269 { 270 struct net_device *netdev = x->xso.dev; 271 struct nfp_ipsec_cfg_mssg msg = {}; 272 int i, key_len, trunc_len, err = 0; 273 struct nfp_ipsec_cfg_add_sa *cfg; 274 struct nfp_net *nn; 275 unsigned int saidx; 276 277 nn = netdev_priv(netdev); 278 cfg = &msg.cfg_add_sa; 279 280 /* General */ 281 switch (x->props.mode) { 282 case XFRM_MODE_TUNNEL: 283 cfg->ctrl_word.mode = NFP_IPSEC_PROTMODE_TUNNEL; 284 break; 285 case XFRM_MODE_TRANSPORT: 286 cfg->ctrl_word.mode = NFP_IPSEC_PROTMODE_TRANSPORT; 287 break; 288 default: 289 nn_err(nn, "Unsupported mode for xfrm offload\n"); 290 return -EINVAL; 291 } 292 293 switch (x->id.proto) { 294 case IPPROTO_ESP: 295 cfg->ctrl_word.proto = NFP_IPSEC_PROTOCOL_ESP; 296 break; 297 case IPPROTO_AH: 298 cfg->ctrl_word.proto = NFP_IPSEC_PROTOCOL_AH; 299 break; 300 default: 301 nn_err(nn, "Unsupported protocol for xfrm offload\n"); 302 return -EINVAL; 303 } 304 305 if (x->props.flags & XFRM_STATE_ESN) { 306 nn_err(nn, "Unsupported XFRM_REPLAY_MODE_ESN for xfrm offload\n"); 307 return -EINVAL; 308 } 309 310 if (x->xso.type != XFRM_DEV_OFFLOAD_CRYPTO) { 311 nn_err(nn, "Unsupported xfrm offload tyoe\n"); 312 return -EINVAL; 313 } 314 315 cfg->spi = ntohl(x->id.spi); 316 317 /* Hash/Authentication */ 318 if (x->aalg) 319 trunc_len = x->aalg->alg_trunc_len; 320 else 321 trunc_len = 0; 322 323 switch (x->props.aalgo) { 324 case SADB_AALG_NONE: 325 if (x->aead) { 326 trunc_len = -1; 327 } else { 328 nn_err(nn, "Unsupported authentication algorithm\n"); 329 return -EINVAL; 330 } 331 break; 332 case SADB_X_AALG_NULL: 333 cfg->ctrl_word.hash = NFP_IPSEC_HASH_NONE; 334 trunc_len = -1; 335 break; 336 case SADB_AALG_MD5HMAC: 337 set_md5hmac(cfg, &trunc_len); 338 break; 339 case SADB_AALG_SHA1HMAC: 340 set_sha1hmac(cfg, &trunc_len); 341 break; 342 case SADB_X_AALG_SHA2_256HMAC: 343 set_sha2_256hmac(cfg, &trunc_len); 344 break; 345 case SADB_X_AALG_SHA2_384HMAC: 346 set_sha2_384hmac(cfg, &trunc_len); 347 break; 348 case SADB_X_AALG_SHA2_512HMAC: 349 set_sha2_512hmac(cfg, &trunc_len); 350 break; 351 default: 352 nn_err(nn, "Unsupported authentication algorithm\n"); 353 return -EINVAL; 354 } 355 356 if (!trunc_len) { 357 nn_err(nn, "Unsupported authentication algorithm trunc length\n"); 358 return -EINVAL; 359 } 360 361 if (x->aalg) { 362 key_len = DIV_ROUND_UP(x->aalg->alg_key_len, BITS_PER_BYTE); 363 if (key_len > sizeof(cfg->auth_key)) { 364 nn_err(nn, "Insufficient space for offloaded auth key\n"); 365 return -EINVAL; 366 } 367 for (i = 0; i < key_len / sizeof(cfg->auth_key[0]) ; i++) 368 cfg->auth_key[i] = get_unaligned_be32(x->aalg->alg_key + 369 sizeof(cfg->auth_key[0]) * i); 370 } 371 372 /* Encryption */ 373 switch (x->props.ealgo) { 374 case SADB_EALG_NONE: 375 case SADB_EALG_NULL: 376 cfg->ctrl_word.cimode = NFP_IPSEC_CIMODE_CBC; 377 cfg->ctrl_word.cipher = NFP_IPSEC_CIPHER_NULL; 378 break; 379 case SADB_EALG_3DESCBC: 380 cfg->ctrl_word.cimode = NFP_IPSEC_CIMODE_CBC; 381 cfg->ctrl_word.cipher = NFP_IPSEC_CIPHER_3DES; 382 break; 383 case SADB_X_EALG_AES_GCM_ICV16: 384 case SADB_X_EALG_NULL_AES_GMAC: 385 if (!x->aead) { 386 nn_err(nn, "Invalid AES key data\n"); 387 return -EINVAL; 388 } 389 390 if (x->aead->alg_icv_len != 128) { 391 nn_err(nn, "ICV must be 128bit with SADB_X_EALG_AES_GCM_ICV16\n"); 392 return -EINVAL; 393 } 394 cfg->ctrl_word.cimode = NFP_IPSEC_CIMODE_CTR; 395 cfg->ctrl_word.hash = NFP_IPSEC_HASH_GF128_128; 396 397 /* Aead->alg_key_len includes 32-bit salt */ 398 if (set_aes_keylen(cfg, x->props.ealgo, x->aead->alg_key_len - 32)) { 399 nn_err(nn, "Unsupported AES key length %d\n", x->aead->alg_key_len); 400 return -EINVAL; 401 } 402 break; 403 case SADB_X_EALG_AESCBC: 404 cfg->ctrl_word.cimode = NFP_IPSEC_CIMODE_CBC; 405 if (!x->ealg) { 406 nn_err(nn, "Invalid AES key data\n"); 407 return -EINVAL; 408 } 409 if (set_aes_keylen(cfg, x->props.ealgo, x->ealg->alg_key_len) < 0) { 410 nn_err(nn, "Unsupported AES key length %d\n", x->ealg->alg_key_len); 411 return -EINVAL; 412 } 413 break; 414 default: 415 nn_err(nn, "Unsupported encryption algorithm for offload\n"); 416 return -EINVAL; 417 } 418 419 if (x->aead) { 420 int salt_len = 4; 421 422 key_len = DIV_ROUND_UP(x->aead->alg_key_len, BITS_PER_BYTE); 423 key_len -= salt_len; 424 425 if (key_len > sizeof(cfg->ciph_key)) { 426 nn_err(nn, "aead: Insufficient space for offloaded key\n"); 427 return -EINVAL; 428 } 429 430 for (i = 0; i < key_len / sizeof(cfg->ciph_key[0]) ; i++) 431 cfg->ciph_key[i] = get_unaligned_be32(x->aead->alg_key + 432 sizeof(cfg->ciph_key[0]) * i); 433 434 /* Load up the salt */ 435 cfg->aesgcm_fields.salt = get_unaligned_be32(x->aead->alg_key + key_len); 436 } 437 438 if (x->ealg) { 439 key_len = DIV_ROUND_UP(x->ealg->alg_key_len, BITS_PER_BYTE); 440 441 if (key_len > sizeof(cfg->ciph_key)) { 442 nn_err(nn, "ealg: Insufficient space for offloaded key\n"); 443 return -EINVAL; 444 } 445 for (i = 0; i < key_len / sizeof(cfg->ciph_key[0]) ; i++) 446 cfg->ciph_key[i] = get_unaligned_be32(x->ealg->alg_key + 447 sizeof(cfg->ciph_key[0]) * i); 448 } 449 450 /* IP related info */ 451 switch (x->props.family) { 452 case AF_INET: 453 cfg->ipv6 = 0; 454 cfg->src_ip[0] = ntohl(x->props.saddr.a4); 455 cfg->dst_ip[0] = ntohl(x->id.daddr.a4); 456 break; 457 case AF_INET6: 458 cfg->ipv6 = 1; 459 for (i = 0; i < 4; i++) { 460 cfg->src_ip[i] = ntohl(x->props.saddr.a6[i]); 461 cfg->dst_ip[i] = ntohl(x->id.daddr.a6[i]); 462 } 463 break; 464 default: 465 nn_err(nn, "Unsupported address family\n"); 466 return -EINVAL; 467 } 468 469 /* Maximum nic IPsec code could handle. Other limits may apply. */ 470 cfg->pmtu_limit = 0xffff; 471 cfg->ctrl_word.encap_dsbl = 1; 472 473 /* SA direction */ 474 cfg->ctrl_word.dir = x->xso.dir; 475 476 /* Find unused SA data*/ 477 err = xa_alloc(&nn->xa_ipsec, &saidx, x, 478 XA_LIMIT(0, NFP_NET_IPSEC_MAX_SA_CNT - 1), GFP_KERNEL); 479 if (err < 0) { 480 nn_err(nn, "Unable to get sa_data number for IPsec\n"); 481 return err; 482 } 483 484 /* Allocate saidx and commit the SA */ 485 msg.cmd = NFP_IPSEC_CFG_MSSG_ADD_SA; 486 msg.sa_idx = saidx; 487 err = nfp_net_sched_mbox_amsg_work(nn, NFP_NET_CFG_MBOX_CMD_IPSEC, &msg, 488 sizeof(msg), nfp_net_ipsec_cfg); 489 if (err) { 490 xa_erase(&nn->xa_ipsec, saidx); 491 nn_err(nn, "Failed to issue IPsec command err ret=%d\n", err); 492 return err; 493 } 494 495 /* 0 is invalid offload_handle for kernel */ 496 x->xso.offload_handle = saidx + 1; 497 return 0; 498 } 499 500 static void nfp_net_xfrm_del_state(struct xfrm_state *x) 501 { 502 struct nfp_ipsec_cfg_mssg msg = { 503 .cmd = NFP_IPSEC_CFG_MSSG_INV_SA, 504 .sa_idx = x->xso.offload_handle - 1, 505 }; 506 struct net_device *netdev = x->xso.dev; 507 struct nfp_net *nn; 508 int err; 509 510 nn = netdev_priv(netdev); 511 err = nfp_net_sched_mbox_amsg_work(nn, NFP_NET_CFG_MBOX_CMD_IPSEC, &msg, 512 sizeof(msg), nfp_net_ipsec_cfg); 513 if (err) 514 nn_warn(nn, "Failed to invalidate SA in hardware\n"); 515 516 xa_erase(&nn->xa_ipsec, x->xso.offload_handle - 1); 517 } 518 519 static bool nfp_net_ipsec_offload_ok(struct sk_buff *skb, struct xfrm_state *x) 520 { 521 if (x->props.family == AF_INET) 522 /* Offload with IPv4 options is not supported yet */ 523 return ip_hdr(skb)->ihl == 5; 524 525 /* Offload with IPv6 extension headers is not support yet */ 526 return !(ipv6_ext_hdr(ipv6_hdr(skb)->nexthdr)); 527 } 528 529 static const struct xfrmdev_ops nfp_net_ipsec_xfrmdev_ops = { 530 .xdo_dev_state_add = nfp_net_xfrm_add_state, 531 .xdo_dev_state_delete = nfp_net_xfrm_del_state, 532 .xdo_dev_offload_ok = nfp_net_ipsec_offload_ok, 533 }; 534 535 void nfp_net_ipsec_init(struct nfp_net *nn) 536 { 537 if (!(nn->cap_w1 & NFP_NET_CFG_CTRL_IPSEC)) 538 return; 539 540 xa_init_flags(&nn->xa_ipsec, XA_FLAGS_ALLOC); 541 nn->dp.netdev->xfrmdev_ops = &nfp_net_ipsec_xfrmdev_ops; 542 } 543 544 void nfp_net_ipsec_clean(struct nfp_net *nn) 545 { 546 if (!(nn->cap_w1 & NFP_NET_CFG_CTRL_IPSEC)) 547 return; 548 549 WARN_ON(!xa_empty(&nn->xa_ipsec)); 550 xa_destroy(&nn->xa_ipsec); 551 } 552 553 bool nfp_net_ipsec_tx_prep(struct nfp_net_dp *dp, struct sk_buff *skb, 554 struct nfp_ipsec_offload *offload_info) 555 { 556 struct xfrm_offload *xo = xfrm_offload(skb); 557 struct xfrm_state *x; 558 559 x = xfrm_input_state(skb); 560 if (!x) 561 return false; 562 563 offload_info->seq_hi = xo->seq.hi; 564 offload_info->seq_low = xo->seq.low; 565 offload_info->handle = x->xso.offload_handle; 566 567 return true; 568 } 569 570 int nfp_net_ipsec_rx(struct nfp_meta_parsed *meta, struct sk_buff *skb) 571 { 572 struct net_device *netdev = skb->dev; 573 struct xfrm_offload *xo; 574 struct xfrm_state *x; 575 struct sec_path *sp; 576 struct nfp_net *nn; 577 u32 saidx; 578 579 nn = netdev_priv(netdev); 580 581 saidx = meta->ipsec_saidx - 1; 582 if (saidx >= NFP_NET_IPSEC_MAX_SA_CNT) 583 return -EINVAL; 584 585 sp = secpath_set(skb); 586 if (unlikely(!sp)) 587 return -ENOMEM; 588 589 xa_lock(&nn->xa_ipsec); 590 x = xa_load(&nn->xa_ipsec, saidx); 591 xa_unlock(&nn->xa_ipsec); 592 if (!x) 593 return -EINVAL; 594 595 xfrm_state_hold(x); 596 sp->xvec[sp->len++] = x; 597 sp->olen++; 598 xo = xfrm_offload(skb); 599 xo->flags = CRYPTO_DONE; 600 xo->status = CRYPTO_SUCCESS; 601 602 return 0; 603 } 604