From patchwork Thu Jul 7 17:14:36 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nikhil Agarwal X-Patchwork-Id: 71574 Delivered-To: patch@linaro.org Received: by 10.140.28.4 with SMTP id 4csp1358829qgy; Thu, 7 Jul 2016 04:46:35 -0700 (PDT) X-Received: by 10.200.55.146 with SMTP id d18mr44877020qtc.19.1467891995381; Thu, 07 Jul 2016 04:46:35 -0700 (PDT) Return-Path: Received: from lists.linaro.org (lists.linaro.org. [54.225.227.206]) by mx.google.com with ESMTP id y144si2951261qkb.121.2016.07.07.04.46.35; Thu, 07 Jul 2016 04:46:35 -0700 (PDT) Received-SPF: pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) client-ip=54.225.227.206; Authentication-Results: mx.google.com; spf=pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) smtp.mailfrom=lng-odp-bounces@lists.linaro.org; dmarc=pass (p=NONE dis=NONE) header.from=linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id 172CD6855F; Thu, 7 Jul 2016 11:46:35 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on ip-10-142-244-252 X-Spam-Level: * X-Spam-Status: No, score=1.1 required=5.0 tests=BAD_ENC_HEADER,BAYES_00, DATE_IN_FUTURE_03_06,RCVD_IN_DNSWL_NONE,SPF_HELO_PASS,URIBL_BLOCKED autolearn=disabled version=3.4.0 Received: from [127.0.0.1] (localhost [127.0.0.1]) by lists.linaro.org (Postfix) with ESMTP id A59F268547; Thu, 7 Jul 2016 11:46:27 +0000 (UTC) X-Original-To: lng-odp@lists.linaro.org Delivered-To: lng-odp@lists.linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id 3392F68558; Thu, 7 Jul 2016 11:46:25 +0000 (UTC) Received: from NAM01-SN1-obe.outbound.protection.outlook.com (mail-sn1nam01on0052.outbound.protection.outlook.com [104.47.32.52]) by lists.linaro.org (Postfix) with ESMTPS id 5272168541 for ; Thu, 7 Jul 2016 11:45:38 +0000 (UTC) Received: from BN3PR0301CA0025.namprd03.prod.outlook.com (10.160.180.163) by BLUPR03MB1492.namprd03.prod.outlook.com (10.163.81.22) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.1.534.14; Thu, 7 Jul 2016 11:45:36 +0000 Received: from BN1BFFO11FD009.protection.gbl (2a01:111:f400:7c10::1:140) by BN3PR0301CA0025.outlook.office365.com (2a01:111:e400:4000::35) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.1.528.16 via Frontend Transport; Thu, 7 Jul 2016 11:45:37 +0000 Received-SPF: SoftFail (protection.outlook.com: domain of transitioning linaro.org discourages use of 192.88.158.2 as permitted sender) Received: from az84smr01.freescale.net (192.88.158.2) by BN1BFFO11FD009.mail.protection.outlook.com (10.58.144.72) with Microsoft SMTP Server (TLS) id 15.1.523.9 via Frontend Transport; Thu, 7 Jul 2016 11:45:36 +0000 Received: from netperf2.ap.freescale.net ([10.232.133.164]) by az84smr01.freescale.net (8.14.3/8.14.0) with ESMTP id u67BjYTp007967 for ; Thu, 7 Jul 2016 04:45:34 -0700 From: Nikhil Agarwal To: Date: Thu, 7 Jul 2016 22:44:36 +0530 Message-ID: <1467911676-7160-1-git-send-email-nikhil.agarwal@linaro.org> X-Mailer: git-send-email 2.8.2 X-EOPAttributedMessage: 0 X-Matching-Connectors: 131123655370147498; (91ab9b29-cfa4-454e-5278-08d120cd25b8); () X-Forefront-Antispam-Report: CIP:192.88.158.2; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(6009001)(7916002)(2980300002)(199003)(189002)(2906002)(586003)(305945005)(8676002)(81166006)(81156014)(356003)(50466002)(104016004)(7846002)(5003940100001)(50986999)(86362001)(50226002)(189998001)(87936001)(92566002)(110136002)(107886002)(68736007)(97736004)(47776003)(33646002)(77096005)(229853001)(2351001)(450100001)(8936002)(36756003)(15975445007)(106466001)(19580395003)(69596002)(105596002)(6806005)(48376002); DIR:OUT; SFP:1101; SCL:1; SRVR:BLUPR03MB1492; H:az84smr01.freescale.net; FPR:; SPF:SoftFail; PTR:InfoDomainNonexistent; A:1; MX:1; LANG:en; X-Microsoft-Exchange-Diagnostics: 1; BN1BFFO11FD009; 1:7WSyCYiM4Pd+CTOOR7hfhPC1dDqYT5W4YtqlCcv7gatSyJYoRKg9KJWLWE4Yx0nw8C7SchMyMSI/tG0PbqUBvVa2K93A/jZJftck6oWc3TqMWEi1aCyyBu8cZ4qUJf9feiw3zNBaZpjyfDdV6huKR+QlSX+yoHTS2GmgrRiSB+4LmPg+wTWyxIwQDUmVd9nIp3YHskaYrr0ov48LVvhUFeMUZA0fQ3yLVAhinLqSIAn+ti/ghv5nWcF5CUE1i9vkRK+2/1WvnFfGWvmrVvoAgpqJ+cOxqudtwCJnfSmrDG7S/lwnHqLzH04vWXL8LyoVSdR7qdXzzogXHIHIjtpDf+vvyrSZSDcKdB2B8RrHUJH3wTX24elbTEH36NvODFNpnpAZYb5x/ckebjO9iTOcXSQGNoejIyYT0SmaEvLf6UAIHyZ6MwVy6OoVES0gZ37RcXuzcxPbi232KqKmbahIRXp4Z/0ANVR+uiIctSORfSCwyrk2ld5djS0nmW2ongMA/ipZIuJZYURgVq6I0h1Av23ZCTLykuj4492TabamgtoqNwSMIdFAc0E8OJ9iyN5U MIME-Version: 1.0 X-MS-Office365-Filtering-Correlation-Id: 77c46d96-733f-4e3f-06aa-08d3a65c3674 X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB1492; 2:I7z+I8RfMzZgGGbVh/J4gxqdXF/lNbGwR7Pj3UtgeKSHWY+xHVzvWX1kjEDBwib5ysF+EHOkQljUkuT7MBUcftI5x5w1BpO7JrAbw6jjC34iz6Knt3qGfrvtPe2ihhVA8P/KQ6FZ0tJaSTckxWacjk7Uy1ld8xNxQipI7ALBV0A82yTRUsyVI5+AHZot7+tn; 3:9a72wRLBwnv9VCjgbv079HDBtxRnj/feDc5Yb/uOcKiXhUz4uEDDLN/PMX9tZp66V34k53TrNrqkyj4+8clOobgSKnApksG/PxgQZKrswC/zhK4GPyfAARFBrIV38Pq3+QDFbAbr/HOuMjLptElx1GhgkKFG7/2ZFFmcKSnzeI/MxzYbZX5/hsw3CCqJkONreob6ag8ZO03pTkY9BD/4lUwbMt9n9KNb0cH0QUVWX1k= X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BLUPR03MB1492; X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB1492; 25:nKquG6UFTzARK9+y5CYMBcvvNlyDj716xFvvkSpSTV0lZdwwX8xadum+jSndtj9FZFES+BLZnkVVE3+COUAx6LppeIuR3CwI29EpQsyeCLWAKAHa89gB70kqe6PFSdtbrXQjqa1kUS3sOFi8A6ecAkiMPH8mWyIsV1b6Zpz8/6+BOuqj2erp3a1+wOQWyN2rWAf7wL+YNVxSYBNo8AUVf1orqabLASRnx885vZSPCzxIA2eNU46FC1SrXohFKzpeJoq1z8WwEqxGXeFvPDVY1bg8SC87Txi6In4bzSOz6KGuje7Kn4DTMbpg8KD3nTSjrhzIdNOFUKJPJboUkYw5a42KM8PH+NZ6ahDJqpBmuDe4WTlr5Q5zCla19obgzuLGjZNCN51FQEB6v4UulVenQcmH7f3V4gvQfkTB3Mp7XbSWZmWcF8I040zIuMiZL6Oc8bG+v41+76O2E9ha3HlDn0sDCvV182YydDSFs1nfWs/1XBZji8Kva+0ee7MDnGGiiJau6hOgjypMNYWyHD2X/SnRdXgpo+d45L5V5+LTIME0FFofIERZ1AD5koYT7fu87qzeKVDIzj5zcgkJRS9+naBmm5McNDlLBsNgViiemyEzv/LMcwQAGiK/4qtrm6DBPLMUl8Hb14kjRY7fiYRjND7Guz8wFr2rV+I9N8UI2fMEaCC1n0DimoollMlYnjGmAaHIF1SF3eQAHXxQ+VAW6KhNAc2fWYAFR5RdkR0LDo8pfMkJisbur3On681wVQNyO5C9V+ptTed3bhsX7KXKQDCB+TJfqUI7JR73l5vjcMg= X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB1492; 31:p6cEbNcw6wxlKsXf7pD7UrAkkBfgYpM3OAG2TbqlSA/e/RUYDxt1MgBL0YwXkcrR1JZ/0exCW76oGzUeYbUo2uODE7gw4BqO3iDbsN+MAwCplrc2CcN5wpEBitrWZwD27eA/tjLNOJQFSUC8Qo3mc83V8N0r7+OmkpfoWyDNrroH1GbSeqbHjc8nrAeiXKd2IZV4+P/xKffVyQgZ1zU5IQ==; 4:3zHLdzeh1IziFPFXEgdkJpQkw34+riv8Ol70hP5b07g8IXjZOMGCnKyKepU6j6pat72AMT4ADCww2Q3WwWTcR3mPceWO3Epm2KbozwTzDIVxn/WbJ7Prkb7PDXriAMYoGsgiCkYQ4cMqvSMITXXvK5Lr5vZwdEEYvPDRboodcVLzC0PR/gcKgEbU8VkRqfmjYZKCKdHwHt2zu6Rn48jEhkv0glLgeNjlCIvUhI4VbHUp0ElkkOTo7GFCpwSkUeiAwMsXms6QyDABoKMfXyANYGmGMNcHmOh1La/Av/O6Ys71ZdjuqoTkjRC0GmO+KdPQgboYTD121+TGWsbVUowfVgsMevAqYnXdGd+eIN2u+JdiOrUGYAmfRMGmK4riOAECNhBM26W6oOEPgn/hb6+BIUwTv+/IFzMh38lCoAgZmLvW9eJ2DbitwzY1Pl6+WdzIq3781M+zq4YUD0e9sgaeZm0JuXJAHJtqOUBEawueE8s= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(601004)(2401047)(13024025)(13023025)(13017025)(13015025)(13018025)(5005006)(8121501046)(10201501046)(3002001)(6055026); SRVR:BLUPR03MB1492; BCL:0; PCL:0; RULEID:(400006); SRVR:BLUPR03MB1492; X-Forefront-PRVS: 0996D1900D X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BLUPR03MB1492; 23:gd6fPUKE+qipBkqeeSw9teZLaqtxWjLaod6Y+DweU?= =?us-ascii?Q?2X77dAVEpRIYZMgRM6K4Y4LpIE0OM9HJ7ZQIddlZuYM3psYc5TSHoBBsxhIR?= =?us-ascii?Q?NDX+RNTNgjREK37pLIHaj2ZqQeuct/t3OxyDOEkbhkZG448xPKGX0rxofjWM?= =?us-ascii?Q?8k0RElv6DeeC4/6/K8GKLIXSmmkrhcftCftJcVyyNnXBHcUCf3BBL+jPx0ic?= =?us-ascii?Q?wFBM+XFGyGj2U3yvigmdrPYcneuO3UvoSfFyv/YnNzOXFxaL8U4ap6fgQ2E1?= =?us-ascii?Q?0nlWuyCa5OGArCSrK32vx/115+PrkPNCBMZYw6BM+dk9cM7i318rMJwc1wwV?= =?us-ascii?Q?WY+1ldUj+k8kYAXHuzLCLUPRwRlSjM/Bjca43aoY4ZxXPTGHABRvDlokWsIa?= =?us-ascii?Q?4v+e3OSVrTLQ8plT2evrV1GpGqI0yfwkNod8ajxkY2oEQKYIl0F6Y2P2Eh2V?= =?us-ascii?Q?7ykAg/L2ximzHizeHehvAtpZVugiw18g8uPfPTaPznO+wAMZjFuTjQl+nSK9?= =?us-ascii?Q?BoSC50ya5Pz7iqjx2HdBYJob6klafFVuXMjGqaN5jAGGIPdtQxBpAXE26URC?= =?us-ascii?Q?9A+Ez+SbHAFHm1CPTkDL+l4QAa1Y4zhT3kAjAxMH32KR0ymmcaSiGgzfEK5F?= =?us-ascii?Q?fuf3h9DwuBd0G5k8Yyiu85eLBS3WI7K0yUlNQRkfV+z1R/Tvwff+UVAkwiln?= =?us-ascii?Q?upOh9Zf9Y7n7nWPE9Q5Z50ZncsP37W+dNb9kdQdJzyAIKNh6o36cP+AuRFPc?= =?us-ascii?Q?pqKR0Hx1RXlMlTAt/Jp6QQ6kccuFcyoYsmJe1quqRaH0B46kGcduY8o7EuyS?= =?us-ascii?Q?8CYB4AlGt9vmtKVwK8iCXu/VmRGUYp6Q1d18PBPMULXB4XudsjOrh+mBAeBq?= =?us-ascii?Q?WL4x+IJReHsp9YqRv7YFa5osEBVWLgNBzTROuYpZcoqBbKmWpWQIiXmFxCyt?= =?us-ascii?Q?lkn6+ZuIQQWLKiLOHtKU6pMwgGNcInpeuxt1SiNCSYspoDhRcAlotpy/jL9T?= =?us-ascii?Q?jiBTc4TvHqiFGarx/6u2dqd?= X-Microsoft-Exchange-Diagnostics: 1; BLUPR03MB1492; 6:0YVTy4AMtQx8umRNfyr4Z0UGQ2FIVwmdrU23KgPXrse81T83+s9IHEBgvFrSjR7cPvVNN22sTU8GQMughHzbXql8LvALXcOydKB1Le83coSdVAFzrXTANTnOHGDR3W/PIIgDiaFJdKN1i3k9VeQulDbgwj4/BEk15TQDOr9dpxgYsHB4qkLOWoMkR8tl78bx0z4iwxbMA0EpBD1Cx0Bz/kEn3AyCVA6+Zed45Nl/LDGEzlu0F09J3P55WMnM0JTs21zKtvH+NmGSGqOHxAlyZh2Rb47YFCA8mqaZ2YLS5Ao=; 5:tLWvBSELk5A3GPvaglVacKfXxliYTjOwT8jZGGBzcsd7sji3Aq44wjcDKXyNoqDJAX1iB1Okb/MyPONcKQcoLj9SsFj+XznLiAPDBYOIGe1nTFZ+tPsHcU8W/9IsddOqu+xsbI+v956rtIPIDuAI5l6x5u5A1Ge8klKwXdylF0E=; 24:DZs30x4CU+vdML8jG23WOyPgKLP5GgBbHEMUSl6PpOawC4klQOvvFLiwok3tG+VfYFYnVuojby1nSCb0kmVyYo9mEvt9WbCSpLu79mwZqUo=; 7:1ofYe9dtEoCUviz/WkRlT/AXKmqwcpHndY3jYFs1rXdO18z8DTm7YPdPsN/WagsKLoRbEaoSYKnkE5nyIGv5X9pEUX+TNdQt8yTafDq8cUIfRwihxMcp3+wRyQR1SCEBLYBYTAEPWhMEG9AhgMPkbxT7R9kf0I0Qu01l9Rsgeu+R+gBDSsEZfKI4Gg71gxaAEoPBlrWoa5ATnsarH0kxcQygvoOaQYce1w6VH5OUP7xTZqwTdL76ytrdL83wbgk3 SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-MS-Exchange-CrossTenant-OriginalArrivalTime: 07 Jul 2016 11:45:36.7807 (UTC) X-MS-Exchange-CrossTenant-Id: 5afe0b00-7697-4969-b663-5eab37d5f47e X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=5afe0b00-7697-4969-b663-5eab37d5f47e; Ip=[192.88.158.2]; Helo=[az84smr01.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BLUPR03MB1492 Subject: [lng-odp] [RFC OPNESSL-ODP 2/2] Adding Async ODP engine for AES cipher X-BeenThere: lng-odp@lists.linaro.org X-Mailman-Version: 2.1.16 Precedence: list List-Id: "The OpenDataPlane \(ODP\) List" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: lng-odp-bounces@lists.linaro.org Sender: "lng-odp" --- README | 21 +++ engine/eng_odp.c | 437 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 458 insertions(+) create mode 100644 README create mode 100644 engine/eng_odp.c -- 2.8.2 diff --git a/README b/README new file mode 100644 index 0000000..b13393a --- /dev/null +++ b/README @@ -0,0 +1,21 @@ +Copyright (c) 2013-2014, Linaro Limited +All rights reserved. + +SPDX-License-Identifier: BSD-3-Clause + +OpenDataPlane (ODP) project source code. + http://www.opendataplane.org/ + + How to build: + Following are the steep to build this object: + ./bootstrap + ./configure --with-openssl-path= --with-odp-path= + make + + How to run. + Copy the shared object engine/.libs/libsslodp.so to "opnessl path"/lib/engines/. + Execute any openssl application with arguments "-engine libsslodp". + + Currently, we have tested openssl speed application with NXP platform. + + diff --git a/engine/eng_odp.c b/engine/eng_odp.c new file mode 100644 index 0000000..91151ae --- /dev/null +++ b/engine/eng_odp.c @@ -0,0 +1,437 @@ + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +odp_pool_t pool; +int num_queue = 8; +odp_queue_t out_queue[8]; + +typedef struct ossl_odp_status { + bool is_complete; + bool is_successful; +} ossl_odp_status_t; + +/* Engine Id and Name */ +static const char *engine_odp_id = "libsslodp"; +static const char *engine_odp_name = "ODP based engine"; + +/* Engine Lifetime functions */ +static int ossl_odp_destroy(ENGINE *e); +static int ossl_odp_init(ENGINE *e); +static int ossl_odp_finish(ENGINE *e); + +/* Set up digests. Just SHA1 for now */ +static int ossl_odp_digests(ENGINE *e, const EVP_MD **digest, + const int **nids, int nid); + +/* + * Holds the EVP_MD object for sha1 in this engine. Set up once only during + * engine bind and can then be reused many times. + */ +static EVP_MD *_hidden_sha1_md = NULL; +static const EVP_MD *ossl_odp_sha1(void) +{ + return _hidden_sha1_md; +} +static void destroy_digests(void) +{ + EVP_MD_meth_free(_hidden_sha1_md); + _hidden_sha1_md = NULL; +} + + +static int ossl_odp_digest_nids(const int **nids) +{ + static int digest_nids[2] = { 0, 0 }; + static int pos = 0; + static int init = 0; + + if (!init) { + const EVP_MD *md; + if ((md = ossl_odp_sha1()) != NULL) + digest_nids[pos++] = EVP_MD_type(md); + digest_nids[pos] = 0; + init = 1; + } + *nids = digest_nids; + return pos; +} + +/* AES */ + +static int ossl_odp_aes128_init_key(EVP_CIPHER_CTX *ctx, + const unsigned char *key, const unsigned char *iv, int enc); +static int ossl_odp_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inl); +static int ossl_odp_aes128_cbc_cleanup(EVP_CIPHER_CTX *ctx); + +struct ossl_odp_ctx { + odp_crypto_session_t session; +}; + +/* + * Holds the EVP_CIPHER object for aes_128_cbc in this engine. Set up once only + * during engine bind and can then be reused many times. + */ +static EVP_CIPHER *_hidden_aes_128_cbc; +static const EVP_CIPHER *ossl_odp_aes_128_cbc(void) +{ + return _hidden_aes_128_cbc; +} + +static void destroy_ciphers(void) +{ + EVP_CIPHER_meth_free(_hidden_aes_128_cbc); + _hidden_aes_128_cbc = NULL; +} + +static int ossl_odp_ciphers(ENGINE *e, const EVP_CIPHER **cipher, + const int **nids, int nid); + +static int ossl_odp_cipher_nids[] = { + NID_aes_128_cbc, + 0 +}; + + +static int bind_odp(ENGINE *e) +{ + odp_queue_param_t qparam; + odp_pool_param_t params; + int i; + if (0 != odp_init_global(NULL, NULL)) { + printf("error: odp_init_global() failed.\n"); + return -1; + } + + if (0 != odp_init_local(ODP_THREAD_WORKER)) { + printf("error: odp_init_local() failed.\n"); + return -1; + } + + memset(¶ms, 0, sizeof(params)); + params.pkt.seg_len = 20480; + params.pkt.len = 20480; + params.pkt.num = 4096; + params.type = ODP_POOL_PACKET; + + pool = odp_pool_create("ossl_odp_pool", ¶ms); + + if (ODP_POOL_INVALID == pool) { + printf("Packet pool creation failed.\n"); + odp_term_local(); + odp_term_global(); + return -1; + } + odp_queue_param_init(&qparam); + qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST; + qparam.sched.sync = ODP_SCHED_SYNC_ATOMIC; + qparam.sched.group = ODP_SCHED_GROUP_ALL; + for (i = 0; i < num_queue; i++) { + char queue_name[256] = {0}; + sprintf(queue_name, "%s%d", "ossl_out_queue_", i); + out_queue[i] = odp_queue_create(queue_name, + ODP_QUEUE_TYPE_SCHED, &qparam); + printf("Created queue %s\n", queue_name); + if (ODP_QUEUE_INVALID == out_queue[i]) { + printf("Crypto outq creation failed.\n"); + for (; i >= 0; i--) + odp_queue_destroy(out_queue[i]); + odp_pool_destroy(pool); + odp_term_local(); + odp_term_global(); + return -1; + } + } + + if (!ENGINE_set_id(e, engine_odp_id) + || !ENGINE_set_name(e, engine_odp_name) + || !ENGINE_set_ciphers(e, ossl_odp_ciphers) + || !ENGINE_set_digests(e, ossl_odp_digests) + || !ENGINE_set_destroy_function(e, ossl_odp_destroy) + || !ENGINE_set_init_function(e, ossl_odp_init) + || !ENGINE_set_finish_function(e, ossl_odp_finish)) { + return 0; + } + + _hidden_aes_128_cbc = EVP_CIPHER_meth_new(NID_aes_128_cbc, + 16 /* block size */, + 16 /* key len */); + if (_hidden_aes_128_cbc == NULL + || !EVP_CIPHER_meth_set_iv_length(_hidden_aes_128_cbc, 16) + || !EVP_CIPHER_meth_set_flags(_hidden_aes_128_cbc, + EVP_CIPH_FLAG_DEFAULT_ASN1 + | EVP_CIPH_CBC_MODE) + || !EVP_CIPHER_meth_set_init(_hidden_aes_128_cbc, + ossl_odp_aes128_init_key) + || !EVP_CIPHER_meth_set_do_cipher(_hidden_aes_128_cbc, + ossl_odp_aes128_cbc_cipher) + || !EVP_CIPHER_meth_set_cleanup(_hidden_aes_128_cbc, + ossl_odp_aes128_cbc_cleanup) + || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_aes_128_cbc, + sizeof(struct ossl_odp_ctx))) { + EVP_CIPHER_meth_free(_hidden_aes_128_cbc); + _hidden_aes_128_cbc = NULL; + } + + return 1; +} + +static int bind_helper(ENGINE *e, const char *id) +{ + if (id && (strcmp(id, engine_odp_id) != 0)) + return 0; + if (!bind_odp(e)) + return 0; + return 1; +} + +IMPLEMENT_DYNAMIC_CHECK_FN() +IMPLEMENT_DYNAMIC_BIND_FN(bind_helper) + +static int ossl_odp_init(ENGINE *e) +{ + + if (0 != odp_init_local(ODP_THREAD_WORKER)) { + printf("error: odp_init_local() failed.\n"); + return -1; + } + + return 1; +} + + +static int ossl_odp_finish(ENGINE *e) +{ + int i; + + for (i = 0; i < num_queue; i++) + odp_queue_destroy(out_queue[i]); + + odp_pool_destroy(pool); + odp_term_local(); + odp_term_global(); + return 1; +} + + +static int ossl_odp_destroy(ENGINE *e) +{ + destroy_ciphers(); + return 1; +} + +static int ossl_odp_ciphers(ENGINE *e, const EVP_CIPHER **cipher, + const int **nids, int nid) +{ + int ok = 1; + + if (cipher == NULL) { + /* We are returning a list of supported nids */ + *nids = ossl_odp_cipher_nids; + return (sizeof(ossl_odp_cipher_nids) - + 1) / sizeof(ossl_odp_cipher_nids[0]); + } + /* We are being asked for a specific cipher */ + switch (nid) { + case NID_aes_128_cbc: + *cipher = ossl_odp_aes_128_cbc(); + break; + default: + ok = 0; + *cipher = NULL; + break; + } + return ok; +} + +static int ossl_odp_digests(ENGINE *e, const EVP_MD **digest, + const int **nids, int nid) +{ + int ok = 1; + if (!digest) { + /* We are returning a list of supported nids */ + return ossl_odp_digest_nids(nids); + } + /* We are being asked for a specific digest */ + switch (nid) { + case NID_sha1: + *digest = ossl_odp_sha1(); + break; + default: + ok = 0; + *digest = NULL; + break; + } + return ok; +} + + +static void wait_cleanup(ASYNC_WAIT_CTX *ctx, const void *key, + OSSL_ASYNC_FD readfd, void *pvwritefd) +{ + /*Nothing todo for now*/ +} + +/* Cipher helper functions */ +static int ossl_odp_cipher_init_key_helper(EVP_CIPHER_CTX *ctx, + const unsigned char *key, + const unsigned char *iv, int enc, + const EVP_CIPHER *cipher) +{ + int ret; + enum odp_crypto_ses_create_err status; + odp_crypto_session_params_t ses_params; + odp_crypto_key_t cipher_key = { .data = NULL, .length = 0 }, + auth_key = { .data = NULL, .length = 0 }; + odp_crypto_iv_t ses_iv; + static int next; + + if (next == num_queue) + next = 0; + + + struct ossl_odp_ctx *odp_ctx = + (struct ossl_odp_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + + /* Create a crypto session */ + memset(&ses_params, 0, sizeof(ses_params)); + ses_params.op = (enc == 1) ? ODP_CRYPTO_OP_ENCODE:ODP_CRYPTO_OP_DECODE; + ses_params.auth_cipher_text = false; + ses_params.pref_mode = ODP_CRYPTO_ASYNC; + ses_params.cipher_alg = ODP_CIPHER_ALG_AES128_CBC; + ses_params.auth_alg = ODP_AUTH_ALG_NULL; + cipher_key.data = (unsigned char *)key; + cipher_key.length = 16; + ses_iv.data = (unsigned char *)iv; + ses_iv.length = 16; + ses_params.cipher_key = cipher_key; + ses_params.iv = ses_iv; + ses_params.auth_key = auth_key; + ses_params.compl_queue = out_queue[next]; + ses_params.output_pool = pool; + + ret = odp_crypto_session_create(&ses_params, + &(odp_ctx->session), &status); + + next++; + if (ODP_CRYPTO_SES_CREATE_ERR_NONE != status) + return 0; + + return 1; +} + +static int ossl_odp_cipher_helper(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inl, + const EVP_CIPHER *cipher) +{ + odp_crypto_op_params_t params; + odp_packet_t pkt; + odp_bool_t posted; + odp_event_t event; + odp_crypto_compl_t compl_event; + ossl_odp_status_t compl, *dequeued; + ASYNC_WAIT_CTX *waitctx; + OSSL_ASYNC_FD *fd; + char completed = 0; + odp_crypto_op_result_t result; + ASYNC_JOB *job = ASYNC_get_current_job(); + struct ossl_odp_ctx *odp_ctx = + (struct ossl_odp_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + + if (job == NULL) { + printf("\nSYNC operation not yet supported\n"); + return 0; + } + compl.is_complete = 0; + + waitctx = ASYNC_get_wait_ctx(job); + + pkt = odp_packet_alloc(pool, inl); + + if (ODP_PACKET_INVALID == pkt) + return 0; + + odp_packet_copydata_in(pkt, 0, inl, in); + memset(¶ms, 0, sizeof(params)); + params.ctx = NULL; + params.session = odp_ctx->session; + params.pkt = pkt; + params.ctx = &compl; + params.out_pkt = pkt; + params.cipher_range.offset = 0; + params.cipher_range.length = inl; + params.override_iv_ptr = NULL; + if (odp_crypto_operation(¶ms, + &posted, + &result)) { + odp_packet_free(pkt); + return 0; + } + if (posted) { + while (!compl.is_complete) { + ASYNC_pause_job(); + /* Poll completion queue for results */ + event = odp_schedule(NULL, ODP_SCHED_NO_WAIT); + + while (event != ODP_EVENT_INVALID) { + compl_event = + odp_crypto_compl_from_event(event); + odp_crypto_compl_result(compl_event, &result); + odp_crypto_compl_free(compl_event); + dequeued = (ossl_odp_status_t *)result.ctx; + dequeued->is_complete = 1; + dequeued->is_successful = result.ok; + + event = odp_schedule(NULL, ODP_SCHED_NO_WAIT); + } + } + } + if(!compl.is_successful) { + odp_packet_free(pkt); + return 0; + } + odp_packet_copydata_out(pkt, 0, inl, out); + odp_packet_free(pkt); + return 1; +} + +/* + * AES128 CBC Implementation + */ + +static int ossl_odp_aes128_init_key(EVP_CIPHER_CTX *ctx, + const unsigned char *key, const unsigned char *iv, int enc) +{ + return ossl_odp_cipher_init_key_helper(ctx, key, iv, + enc, EVP_aes_128_cbc()); +} + +static int ossl_odp_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, + const unsigned char *in, size_t inl) +{ + return ossl_odp_cipher_helper(ctx, out, in, inl, EVP_aes_128_cbc()); +} + +static int ossl_odp_aes128_cbc_cleanup(EVP_CIPHER_CTX *ctx) +{ + struct ossl_odp_ctx *odp_ctx = + (struct ossl_odp_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); + + odp_crypto_session_destroy(odp_ctx->session); + + return 1; +} +