From nobody Fri May 3 14:28:29 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=bytedance.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1642732334518693.6193409830632; Thu, 20 Jan 2022 18:32:14 -0800 (PST) Received: from localhost ([::1]:54712 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1nAjim-0007lh-SN for importer@patchew.org; Thu, 20 Jan 2022 21:32:12 -0500 Received: from eggs.gnu.org ([209.51.188.92]:41520) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nAjf1-0005CB-Dh for qemu-devel@nongnu.org; Thu, 20 Jan 2022 21:28:19 -0500 Received: from [2607:f8b0:4864:20::1031] (port=43552 helo=mail-pj1-x1031.google.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1nAjey-0002B6-Em for qemu-devel@nongnu.org; Thu, 20 Jan 2022 21:28:17 -0500 Received: by mail-pj1-x1031.google.com with SMTP id d15-20020a17090a110f00b001b4e7d27474so7832113pja.2 for ; Thu, 20 Jan 2022 18:28:16 -0800 (PST) Received: from libai.bytedance.net ([61.120.150.72]) by smtp.gmail.com with ESMTPSA id d1sm4825404pfj.179.2022.01.20.18.28.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Jan 2022 18:28:14 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=kiWY+ES/f92QyNigpn3R6a5lLo4wAGB7X7aXsL6h8aM=; b=tvoOY0TcgODfHUJQskielmksDFpYalfcy6zMVBjMH/P1uv0esmqrXbeGGtB+0aLN9w 3twJmhVa8Y7WJlEjjxVy3CBwqZ8bQTF8j0zlsiLttIhF/VfOak9EFlNxB4BxhWFmd97y xlkQ5wYX2JEtJJTghKJdzMgv3c36kynf3wPINOU29OzfjGMPPlvvL5Bkl1U7EkSIw4kS yVb1TheosnlxT4HadSLEIMEWTROGsmSNEue33MVVEcr/tQ6F6Obj5Vwb645IyZkvnrh1 slJkz+vdXumRwAciHZvAawn9TVMmO7G0wlJzMwzzhnAvQFFBTg2YwD0GHLdHaqI3sPDz joYA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=kiWY+ES/f92QyNigpn3R6a5lLo4wAGB7X7aXsL6h8aM=; b=flOYdQlJsVFxErn5Bmdmbiy/jprI9m+/l2s1uqXNbjWVHAi2cB+YCw+g2nF7M9gkVr ilbNhTewDp82p/TkRwgCFkKZo9+LL0Y5fGnGZauwr2DG8I61ExaFAhQtiKUzbwWTY1Db Rf29Xdo0Eoa6lb2Q2B0pSET+6VOaUD1Tta06wu1/Qpbjy63huPuqumfGWCEEsuII2CUs ZB4TRjeshrCcek3xu5xp3VWb4AL8QvxfSD0Nh7+cXNJ6mMKGwTTJ1sIRjiYZ/czki8RM axIrYphVTLMLbfupAR8ADBNEvc6wAFUUtR5X9hPF0rkVSt4fLidBoqyl3XLAXCu7pw4J 4VvA== X-Gm-Message-State: AOAM532YlWJ+CDQhZ3msQUZwlIJa3Igsx6AhcYDfAfhOVWkgEpKuz8HA B+02LQyZhXhmwm9Exba/f3msJA== X-Google-Smtp-Source: ABdhPJz/IrczjDIUJewHxlMlapkJFGEGPgRTRTQyFalmymJcpNlMtUtuMLdx17kkPvUfbInbPTj/OA== X-Received: by 2002:a17:90a:4601:: with SMTP id w1mr14576152pjg.113.1642732095279; Thu, 20 Jan 2022 18:28:15 -0800 (PST) From: zhenwei pi To: arei.gonglei@huawei.com, mst@redhat.com, berrange@redhat.com Subject: [PATCH 1/3] virtio-crypto: header update Date: Fri, 21 Jan 2022 10:26:58 +0800 Message-Id: <20220121022700.1042649-2-pizhenwei@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220121022700.1042649-1-pizhenwei@bytedance.com> References: <20220121022700.1042649-1-pizhenwei@bytedance.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Host-Lookup-Failed: Reverse DNS lookup failed for 2607:f8b0:4864:20::1031 (failed) Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::1031; envelope-from=pizhenwei@bytedance.com; helo=mail-pj1-x1031.google.com X-Spam_score_int: -10 X-Spam_score: -1.1 X-Spam_bar: - X-Spam_report: (-1.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, PDS_HP_HELO_NORDNS=0.001, RCVD_IN_DNSWL_NONE=-0.0001, RDNS_NONE=0.793, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: qemu-devel@nongnu.org, zhenwei pi , helei.sig11@bytedance.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1642732336019100001 Content-Type: text/plain; charset="utf-8" Update header from linux, support akcipher service. Signed-off-by: lei he Signed-off-by: zhenwei pi --- .../standard-headers/linux/virtio_crypto.h | 98 +++++++++++++++++-- 1 file changed, 89 insertions(+), 9 deletions(-) diff --git a/include/standard-headers/linux/virtio_crypto.h b/include/stand= ard-headers/linux/virtio_crypto.h index 5ff0b4ee59..1dba57248d 100644 --- a/include/standard-headers/linux/virtio_crypto.h +++ b/include/standard-headers/linux/virtio_crypto.h @@ -33,10 +33,11 @@ #include "standard-headers/linux/virtio_config.h" =20 =20 -#define VIRTIO_CRYPTO_SERVICE_CIPHER 0 -#define VIRTIO_CRYPTO_SERVICE_HASH 1 -#define VIRTIO_CRYPTO_SERVICE_MAC 2 -#define VIRTIO_CRYPTO_SERVICE_AEAD 3 +#define VIRTIO_CRYPTO_SERVICE_CIPHER 0 +#define VIRTIO_CRYPTO_SERVICE_HASH 1 +#define VIRTIO_CRYPTO_SERVICE_MAC 2 +#define VIRTIO_CRYPTO_SERVICE_AEAD 3 +#define VIRTIO_CRYPTO_SERVICE_AKCIPHER 4 =20 #define VIRTIO_CRYPTO_OPCODE(service, op) (((service) << 8) | (op)) =20 @@ -57,6 +58,10 @@ struct virtio_crypto_ctrl_header { VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x02) #define VIRTIO_CRYPTO_AEAD_DESTROY_SESSION \ VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x03) +#define VIRTIO_CRYPTO_AKCIPHER_CREATE_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AKCIPHER, 0x04) +#define VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AKCIPHER, 0x05) uint32_t opcode; uint32_t algo; uint32_t flag; @@ -180,6 +185,57 @@ struct virtio_crypto_aead_create_session_req { uint8_t padding[32]; }; =20 +struct virtio_crypto_rsa_session_para { +#define VIRTIO_CRYPTO_RSA_RAW_PADDING 0 +#define VIRTIO_CRYPTO_RSA_PKCS1_PADDING 1 + uint32_t padding_algo; + +#define VIRTIO_CRYPTO_RSA_NO_HASH 0 +#define VIRTIO_CRYPTO_RSA_MD2 1 +#define VIRTIO_CRYPTO_RSA_MD3 2 +#define VIRTIO_CRYPTO_RSA_MD4 3 +#define VIRTIO_CRYPTO_RSA_MD5 4 +#define VIRTIO_CRYPTO_RSA_SHA1 5 +#define VIRTIO_CRYPTO_RSA_SHA256 6 +#define VIRTIO_CRYPTO_RSA_SHA384 7 +#define VIRTIO_CRYPTO_RSA_SHA512 8 +#define VIRTIO_CRYPTO_RSA_SHA224 9 + uint32_t hash_algo; +}; + +struct virtio_crypto_ecdsa_session_para { +#define VIRTIO_CRYPTO_CURVE_UNKNOWN 0 +#define VIRTIO_CRYPTO_CURVE_NIST_P192 1 +#define VIRTIO_CRYPTO_CURVE_NIST_P224 2 +#define VIRTIO_CRYPTO_CURVE_NIST_P256 3 +#define VIRTIO_CRYPTO_CURVE_NIST_P384 4 +#define VIRTIO_CRYPTO_CURVE_NIST_P521 5 + uint32_t curve_id; +}; + +struct virtio_crypto_akcipher_session_para { +#define VIRTIO_CRYPTO_NO_AKCIPHER 0 +#define VIRTIO_CRYPTO_AKCIPHER_RSA 1 +#define VIRTIO_CRYPTO_AKCIPHER_DSA 2 +#define VIRTIO_CRYPTO_AKCIPHER_ECDSA 3 + uint32_t algo; + +#define VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC 1 +#define VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE 2 + uint32_t keytype; + uint32_t keylen; + + union { + struct virtio_crypto_rsa_session_para rsa; + struct virtio_crypto_ecdsa_session_para ecdsa; + } u; +}; + +struct virtio_crypto_akcipher_create_session_req { + struct virtio_crypto_akcipher_session_para para; + uint8_t padding[36]; +}; + struct virtio_crypto_alg_chain_session_para { #define VIRTIO_CRYPTO_SYM_ALG_CHAIN_ORDER_HASH_THEN_CIPHER 1 #define VIRTIO_CRYPTO_SYM_ALG_CHAIN_ORDER_CIPHER_THEN_HASH 2 @@ -247,6 +303,8 @@ struct virtio_crypto_op_ctrl_req { mac_create_session; struct virtio_crypto_aead_create_session_req aead_create_session; + struct virtio_crypto_akcipher_create_session_req + akcipher_create_session; struct virtio_crypto_destroy_session_req destroy_session; uint8_t padding[56]; @@ -266,6 +324,14 @@ struct virtio_crypto_op_header { VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x00) #define VIRTIO_CRYPTO_AEAD_DECRYPT \ VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x01) +#define VIRTIO_CRYPTO_AKCIPHER_ENCRYPT \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AKCIPHER, 0x00) +#define VIRTIO_CRYPTO_AKCIPHER_DECRYPT \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AKCIPHER, 0x01) +#define VIRTIO_CRYPTO_AKCIPHER_SIGN \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AKCIPHER, 0x02) +#define VIRTIO_CRYPTO_AKCIPHER_VERIFY \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AKCIPHER, 0x03) uint32_t opcode; /* algo should be service-specific algorithms */ uint32_t algo; @@ -390,6 +456,16 @@ struct virtio_crypto_aead_data_req { uint8_t padding[32]; }; =20 +struct virtio_crypto_akcipher_para { + uint32_t src_data_len; + uint32_t dst_data_len; +}; + +struct virtio_crypto_akcipher_data_req { + struct virtio_crypto_akcipher_para para; + uint8_t padding[40]; +}; + /* The request of the data virtqueue's packet */ struct virtio_crypto_op_data_req { struct virtio_crypto_op_header header; @@ -399,15 +475,18 @@ struct virtio_crypto_op_data_req { struct virtio_crypto_hash_data_req hash_req; struct virtio_crypto_mac_data_req mac_req; struct virtio_crypto_aead_data_req aead_req; + struct virtio_crypto_akcipher_data_req akcipher_req; uint8_t padding[48]; } u; }; =20 -#define VIRTIO_CRYPTO_OK 0 -#define VIRTIO_CRYPTO_ERR 1 -#define VIRTIO_CRYPTO_BADMSG 2 -#define VIRTIO_CRYPTO_NOTSUPP 3 -#define VIRTIO_CRYPTO_INVSESS 4 /* Invalid session id */ +#define VIRTIO_CRYPTO_OK 0 +#define VIRTIO_CRYPTO_ERR 1 +#define VIRTIO_CRYPTO_BADMSG 2 +#define VIRTIO_CRYPTO_NOTSUPP 3 +#define VIRTIO_CRYPTO_INVSESS 4 /* Invalid session id */ +#define VIRTIO_CRYPTO_NOSPC 5 /* no free session ID */ +#define VIRTIO_CRYPTO_KEY_REJECTED 6 /* Signature verification failed */ =20 /* The accelerator hardware is ready */ #define VIRTIO_CRYPTO_S_HW_READY (1 << 0) @@ -441,6 +520,7 @@ struct virtio_crypto_config { uint32_t reserve; /* Maximum size of each crypto request's content */ uint64_t max_size; + uint32_t akcipher_algo; }; =20 struct virtio_crypto_inhdr { --=20 2.25.1 From nobody Fri May 3 14:28:29 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=bytedance.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1642732348788595.4621762916149; Thu, 20 Jan 2022 18:32:28 -0800 (PST) Received: from localhost ([::1]:55370 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1nAjj1-0008Cx-Ee for importer@patchew.org; Thu, 20 Jan 2022 21:32:27 -0500 Received: from eggs.gnu.org ([209.51.188.92]:41558) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nAjf9-0005HT-2h for qemu-devel@nongnu.org; Thu, 20 Jan 2022 21:28:27 -0500 Received: from [2607:f8b0:4864:20::629] (port=40465 helo=mail-pl1-x629.google.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1nAjf2-0002BQ-Br for qemu-devel@nongnu.org; Thu, 20 Jan 2022 21:28:24 -0500 Received: by mail-pl1-x629.google.com with SMTP id s9so5221870plg.7 for ; Thu, 20 Jan 2022 18:28:19 -0800 (PST) Received: from libai.bytedance.net ([61.120.150.72]) by smtp.gmail.com with ESMTPSA id d1sm4825404pfj.179.2022.01.20.18.28.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Jan 2022 18:28:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=4aTgCpVYl5DyTE26DcdQofPUczP+wvRBALyqTtiMPMU=; b=idpHbQELriWtIDlUzxm8lwkaYkw+XR3JUK9jMXFhnIubyHZEKg3h8lQjxsgB2mntqp DoNDTueXjaTAOVN8N9oYm0XEI9ae43rFShftCopcpPATxL/sI3VUTtSA6PKJ0ZEB8EZF Tfxe/Z3wE4IXpbUN5MDa3Tl+e7wabKlDCJGWv/zZ0Kqi8li2UPRQEpclHvU1tEl6dbkx t9tDqmuresV1j1JDLmm7fjH9RlNVJg5OZNFT/Z381IqEsChh5YqzdDG/khvqp7U3yc/X Ex845n5xRItbkd7IzMh05Xo+zgBscs8j0kTG+bqkCpBvcmdA3RKoe4PIC1J5ekbUJTrK ba6g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=4aTgCpVYl5DyTE26DcdQofPUczP+wvRBALyqTtiMPMU=; b=1yyRaM14SUUXFV80XhVSgZniRNvBaHnZFVJhYZK9zKg7p/S2RcoU24a4E5xLAHbuKw 3d1Bnoum0p3oOULvcNAuXH5PGM63Sntw32BFhC/xAN4x+tNNWkLvmWIyV/YuhVt0ZyT8 nHCtfr+KS0F8FXCupoDCwTITjJA2I7GDKFVOetavO/5RmqpInqb/R1IX5kYfUBv4kHJJ bGRzASpvpHKmNW1pMqgeYWNzM/CQJ28h4twYRDFIFSapc4z5oTE6fA3+44ZjxGG3NQHz fDd6cz+3HlHxi/JSzPcHbYHQ6hVV+bl0UM52/dtLRmmMPlJTx3TbmfLrOqBQf5wjmC9V aNtw== X-Gm-Message-State: AOAM530rOTWZhGyijYms9SfFeNbicya7crgKnUUVf92rPB1a3LN4MCQ9 HGg5XUQFIayHAcBBHzjMaRctTr0CTCTing== X-Google-Smtp-Source: ABdhPJwxDeDrISTjbgAZ7qYGtUTCsXBOU9DBP3aPXU7W0j7OGIfPE49f8m7Z1+JyA0BNz8XW+whL3w== X-Received: by 2002:a17:90b:3144:: with SMTP id ip4mr2293338pjb.19.1642732098618; Thu, 20 Jan 2022 18:28:18 -0800 (PST) From: zhenwei pi To: arei.gonglei@huawei.com, mst@redhat.com, berrange@redhat.com Subject: [PATCH 2/3] virtio_crypto: Support virtio crypto asym operation Date: Fri, 21 Jan 2022 10:26:59 +0800 Message-Id: <20220121022700.1042649-3-pizhenwei@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220121022700.1042649-1-pizhenwei@bytedance.com> References: <20220121022700.1042649-1-pizhenwei@bytedance.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Host-Lookup-Failed: Reverse DNS lookup failed for 2607:f8b0:4864:20::629 (failed) Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::629; envelope-from=pizhenwei@bytedance.com; helo=mail-pl1-x629.google.com X-Spam_score_int: -10 X-Spam_score: -1.1 X-Spam_bar: - X-Spam_report: (-1.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, PDS_HP_HELO_NORDNS=0.001, RCVD_IN_DNSWL_NONE=-0.0001, RDNS_NONE=0.793, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: qemu-devel@nongnu.org, zhenwei pi , helei.sig11@bytedance.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1642732349418100003 Content-Type: text/plain; charset="utf-8" Several changes in this patch: - Add support for virtio crypto asymmetric handling, include: create/close session encrypt/decrypt/sign/verify guest data - Modify crypto backend to compat sym&asym operation. - Introduce akcipher class without any implementation. Then QEMU can provide asymmetric support for guest, but the asymmetric request from guest shoule always fail until an available asymmetric backend gets supported. Co-developed-by: lei he Signed-off-by: lei he Signed-off-by: zhenwei pi --- backends/cryptodev-builtin.c | 201 ++++++++++++++---- backends/cryptodev-vhost-user.c | 34 +++- backends/cryptodev.c | 32 ++- crypto/akcipher.c | 78 +++++++ crypto/meson.build | 1 + hw/virtio/virtio-crypto.c | 328 ++++++++++++++++++++++++------ include/crypto/akcipher.h | 77 +++++++ include/hw/virtio/virtio-crypto.h | 5 +- include/sysemu/cryptodev.h | 88 ++++++-- 9 files changed, 697 insertions(+), 147 deletions(-) create mode 100644 crypto/akcipher.c create mode 100644 include/crypto/akcipher.h diff --git a/backends/cryptodev-builtin.c b/backends/cryptodev-builtin.c index 0671bf9f3e..b3344d230c 100644 --- a/backends/cryptodev-builtin.c +++ b/backends/cryptodev-builtin.c @@ -26,9 +26,9 @@ #include "qapi/error.h" #include "standard-headers/linux/virtio_crypto.h" #include "crypto/cipher.h" +#include "crypto/akcipher.h" #include "qom/object.h" =20 - /** * @TYPE_CRYPTODEV_BACKEND_BUILTIN: * name of backend that uses QEMU cipher API @@ -37,15 +37,15 @@ =20 OBJECT_DECLARE_SIMPLE_TYPE(CryptoDevBackendBuiltin, CRYPTODEV_BACKEND_BUIL= TIN) =20 - typedef struct CryptoDevBackendBuiltinSession { QCryptoCipher *cipher; uint8_t direction; /* encryption or decryption */ - uint8_t type; /* cipher? hash? aead? */ + uint8_t type; /* cipher? hash? aead? akcipher? */ + QCryptoAkcipher *akcipher; QTAILQ_ENTRY(CryptoDevBackendBuiltinSession) next; } CryptoDevBackendBuiltinSession; =20 -/* Max number of symmetric sessions */ +/* Max number of symmetric/asymmetric sessions */ #define MAX_NUM_SESSIONS 256 =20 #define CRYPTODEV_BUITLIN_MAX_AUTH_KEY_LEN 512 @@ -80,15 +80,17 @@ static void cryptodev_builtin_init( backend->conf.crypto_services =3D 1u << VIRTIO_CRYPTO_SERVICE_CIPHER | 1u << VIRTIO_CRYPTO_SERVICE_HASH | - 1u << VIRTIO_CRYPTO_SERVICE_MAC; + 1u << VIRTIO_CRYPTO_SERVICE_MAC | + 1u << VIRTIO_CRYPTO_SERVICE_AKCIPHER; backend->conf.cipher_algo_l =3D 1u << VIRTIO_CRYPTO_CIPHER_AES_CBC; backend->conf.hash_algo =3D 1u << VIRTIO_CRYPTO_HASH_SHA1; + backend->conf.akcipher_algo =3D 1u << VIRTIO_CRYPTO_AKCIPHER_RSA; /* * Set the Maximum length of crypto request. * Why this value? Just avoid to overflow when * memory allocation for each crypto request. */ - backend->conf.max_size =3D LONG_MAX - sizeof(CryptoDevBackendSymOpInfo= ); + backend->conf.max_size =3D LONG_MAX - sizeof(CryptoDevBackendOpInfo); backend->conf.max_cipher_key_len =3D CRYPTODEV_BUITLIN_MAX_CIPHER_KEY_= LEN; backend->conf.max_auth_key_len =3D CRYPTODEV_BUITLIN_MAX_AUTH_KEY_LEN; =20 @@ -167,7 +169,7 @@ static int cryptodev_builtin_create_cipher_session( index =3D cryptodev_builtin_get_unused_session_index(builtin); if (index < 0) { error_setg(errp, "Total number of sessions created exceeds %u", - MAX_NUM_SESSIONS); + MAX_NUM_SESSIONS); return -1; } =20 @@ -240,26 +242,82 @@ static int cryptodev_builtin_create_cipher_session( return index; } =20 -static int64_t cryptodev_builtin_sym_create_session( +static int cryptodev_builtin_create_akcipher_session( + CryptoDevBackendBuiltin *builtin, + CryptoDevBackendAsymSessionInfo *sess_info, + Error **errp) +{ + CryptoDevBackendBuiltinSession *sess; + QCryptoAkcipher *akcipher; + int index; + bool private; + + switch (sess_info->algo) { + case VIRTIO_CRYPTO_AKCIPHER_RSA: + break; + + default: + error_setg(errp, "Unsupported akcipher alg %u", sess_info->algo); + return -1; + } + + switch (sess_info->keytype) { + case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC: + private =3D false; + break; + + case VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE: + private =3D true; + break; + + default: + error_setg(errp, "Unsupported akcipher keytype %u", sess_info->key= type); + return -1; + } + + index =3D cryptodev_builtin_get_unused_session_index(builtin); + if (index < 0) { + error_setg(errp, "Total number of sessions created exceeds %u", + MAX_NUM_SESSIONS); + return -1; + } + + akcipher =3D qcrypto_akcipher_new(sess_info->algo, private, sess_info-= >key, + sess_info->keylen, (void *)&sess_info-= >u, + index, errp); + if (!akcipher) { + return -1; + } + + sess =3D g_new0(CryptoDevBackendBuiltinSession, 1); + sess->akcipher =3D akcipher; + + builtin->sessions[index] =3D sess; + + return index; +} + +static int64_t cryptodev_builtin_create_session( CryptoDevBackend *backend, - CryptoDevBackendSymSessionInfo *sess_info, + CryptoDevBackendSessionInfo *sess_info, uint32_t queue_index, Error **errp) { CryptoDevBackendBuiltin *builtin =3D CRYPTODEV_BACKEND_BUILTIN(backend); - int64_t session_id =3D -1; - int ret; + CryptoDevBackendSymSessionInfo *sym_sess_info; + CryptoDevBackendAsymSessionInfo *asym_sess_info; =20 switch (sess_info->op_code) { case VIRTIO_CRYPTO_CIPHER_CREATE_SESSION: - ret =3D cryptodev_builtin_create_cipher_session( - builtin, sess_info, errp); - if (ret < 0) { - return ret; - } else { - session_id =3D ret; - } - break; + sym_sess_info =3D &sess_info->u.sym_sess_info; + return cryptodev_builtin_create_cipher_session( + builtin, sym_sess_info, errp); + + case VIRTIO_CRYPTO_AKCIPHER_CREATE_SESSION: + asym_sess_info =3D &sess_info->u.asym_sess_info; + return cryptodev_builtin_create_akcipher_session( + builtin, asym_sess_info, errp); + case VIRTIO_CRYPTO_HASH_CREATE_SESSION: case VIRTIO_CRYPTO_MAC_CREATE_SESSION: default: @@ -268,10 +326,10 @@ static int64_t cryptodev_builtin_sym_create_session( return -1; } =20 - return session_id; + return -1; } =20 -static int cryptodev_builtin_sym_close_session( +static int cryptodev_builtin_close_session( CryptoDevBackend *backend, uint64_t session_id, uint32_t queue_index, Error **errp) @@ -288,30 +346,17 @@ static int cryptodev_builtin_sym_close_session( } =20 static int cryptodev_builtin_sym_operation( - CryptoDevBackend *backend, - CryptoDevBackendSymOpInfo *op_info, - uint32_t queue_index, Error **errp) + CryptoDevBackendBuiltinSession *sess, + CryptoDevBackendSymOpInfo *op_info, Error **errp) { - CryptoDevBackendBuiltin *builtin =3D - CRYPTODEV_BACKEND_BUILTIN(backend); - CryptoDevBackendBuiltinSession *sess; int ret; =20 - if (op_info->session_id >=3D MAX_NUM_SESSIONS || - builtin->sessions[op_info->session_id] =3D=3D NULL) { - error_setg(errp, "Cannot find a valid session id: %" PRIu64 "", - op_info->session_id); - return -VIRTIO_CRYPTO_INVSESS; - } - if (op_info->op_type =3D=3D VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) { error_setg(errp, "Algorithm chain is unsupported for cryptdoev-builtin"); return -VIRTIO_CRYPTO_NOTSUPP; } =20 - sess =3D builtin->sessions[op_info->session_id]; - if (op_info->iv_len > 0) { ret =3D qcrypto_cipher_setiv(sess->cipher, op_info->iv, op_info->iv_len, errp); @@ -333,9 +378,85 @@ static int cryptodev_builtin_sym_operation( return -VIRTIO_CRYPTO_ERR; } } + return VIRTIO_CRYPTO_OK; } =20 +static int cryptodev_builtin_asym_operation( + CryptoDevBackendBuiltinSession *sess, uint32_t op_code, + CryptoDevBackendAsymOpInfo *op_info, Error **errp) +{ + int ret; + + switch (op_code) { + case VIRTIO_CRYPTO_AKCIPHER_ENCRYPT: + ret =3D qcrypto_akcipher_encrypt(sess->akcipher, + op_info->src, op_info->src_len, + op_info->dst, op_info->dst_len, err= p); + break; + + case VIRTIO_CRYPTO_AKCIPHER_DECRYPT: + ret =3D qcrypto_akcipher_decrypt(sess->akcipher, + op_info->src, op_info->src_len, + op_info->dst, op_info->dst_len, err= p); + break; + + case VIRTIO_CRYPTO_AKCIPHER_SIGN: + ret =3D qcrypto_akcipher_sign(sess->akcipher, + op_info->src, op_info->src_len, + op_info->dst, op_info->dst_len, errp); + break; + + case VIRTIO_CRYPTO_AKCIPHER_VERIFY: + ret =3D qcrypto_akcipher_verify(sess->akcipher, + op_info->src, op_info->src_len, + op_info->dst, op_info->dst_len, errp); + break; + + default: + return -VIRTIO_CRYPTO_ERR; + } + + if (ret) { + return ret; + } + + return VIRTIO_CRYPTO_OK; +} + +static int cryptodev_builtin_operation( + CryptoDevBackend *backend, + CryptoDevBackendOpInfo *op_info, + uint32_t queue_index, Error **errp) +{ + CryptoDevBackendBuiltin *builtin =3D + CRYPTODEV_BACKEND_BUILTIN(backend); + CryptoDevBackendBuiltinSession *sess; + CryptoDevBackendSymOpInfo *sym_op_info; + CryptoDevBackendAsymOpInfo *asym_op_info; + enum CryptoDevBackendAlgType algtype =3D op_info->algtype; + int ret =3D -VIRTIO_CRYPTO_ERR; + + if (op_info->session_id >=3D MAX_NUM_SESSIONS || + builtin->sessions[op_info->session_id] =3D=3D NULL) { + error_setg(errp, "Cannot find a valid session id: %" PRIu64 "", + op_info->session_id); + return -VIRTIO_CRYPTO_INVSESS; + } + + sess =3D builtin->sessions[op_info->session_id]; + if (algtype =3D=3D CRYPTODEV_BACKEND_ALG_SYM) { + sym_op_info =3D op_info->u.sym_op_info; + ret =3D cryptodev_builtin_sym_operation(sess, sym_op_info, errp); + } else if (algtype =3D=3D CRYPTODEV_BACKEND_ALG_ASYM) { + asym_op_info =3D op_info->u.asym_op_info; + ret =3D cryptodev_builtin_asym_operation(sess, op_info->op_code, + asym_op_info, errp); + } + + return ret; +} + static void cryptodev_builtin_cleanup( CryptoDevBackend *backend, Error **errp) @@ -348,7 +469,7 @@ static void cryptodev_builtin_cleanup( =20 for (i =3D 0; i < MAX_NUM_SESSIONS; i++) { if (builtin->sessions[i] !=3D NULL) { - cryptodev_builtin_sym_close_session(backend, i, 0, &error_abor= t); + cryptodev_builtin_close_session(backend, i, 0, &error_abort); } } =20 @@ -370,9 +491,9 @@ cryptodev_builtin_class_init(ObjectClass *oc, void *dat= a) =20 bc->init =3D cryptodev_builtin_init; bc->cleanup =3D cryptodev_builtin_cleanup; - bc->create_session =3D cryptodev_builtin_sym_create_session; - bc->close_session =3D cryptodev_builtin_sym_close_session; - bc->do_sym_op =3D cryptodev_builtin_sym_operation; + bc->create_session =3D cryptodev_builtin_create_session; + bc->close_session =3D cryptodev_builtin_close_session; + bc->do_op =3D cryptodev_builtin_operation; } =20 static const TypeInfo cryptodev_builtin_info =3D { diff --git a/backends/cryptodev-vhost-user.c b/backends/cryptodev-vhost-use= r.c index bedb452474..5443a59153 100644 --- a/backends/cryptodev-vhost-user.c +++ b/backends/cryptodev-vhost-user.c @@ -259,7 +259,33 @@ static int64_t cryptodev_vhost_user_sym_create_session( return -1; } =20 -static int cryptodev_vhost_user_sym_close_session( +static int64_t cryptodev_vhost_user_create_session( + CryptoDevBackend *backend, + CryptoDevBackendSessionInfo *sess_info, + uint32_t queue_index, Error **errp) +{ + uint32_t op_code =3D sess_info->op_code; + CryptoDevBackendSymSessionInfo *sym_sess_info; + + switch (op_code) { + case VIRTIO_CRYPTO_CIPHER_CREATE_SESSION: + case VIRTIO_CRYPTO_HASH_CREATE_SESSION: + case VIRTIO_CRYPTO_MAC_CREATE_SESSION: + case VIRTIO_CRYPTO_AEAD_CREATE_SESSION: + sym_sess_info =3D &sess_info->u.sym_sess_info; + return cryptodev_vhost_user_sym_create_session(backend, sym_sess_i= nfo, + queue_index, errp); + default: + error_setg(errp, "Unsupported opcode :%" PRIu32 "", + sess_info->op_code); + return -1; + + } + + return -1; +} + +static int cryptodev_vhost_user_close_session( CryptoDevBackend *backend, uint64_t session_id, uint32_t queue_index, Error **errp) @@ -351,9 +377,9 @@ cryptodev_vhost_user_class_init(ObjectClass *oc, void *= data) =20 bc->init =3D cryptodev_vhost_user_init; bc->cleanup =3D cryptodev_vhost_user_cleanup; - bc->create_session =3D cryptodev_vhost_user_sym_create_session; - bc->close_session =3D cryptodev_vhost_user_sym_close_session; - bc->do_sym_op =3D NULL; + bc->create_session =3D cryptodev_vhost_user_create_session; + bc->close_session =3D cryptodev_vhost_user_close_session; + bc->do_op =3D NULL; =20 object_class_property_add_str(oc, "chardev", cryptodev_vhost_user_get_chardev, diff --git a/backends/cryptodev.c b/backends/cryptodev.c index bf52476166..f3d6e338c5 100644 --- a/backends/cryptodev.c +++ b/backends/cryptodev.c @@ -72,9 +72,9 @@ void cryptodev_backend_cleanup( } } =20 -int64_t cryptodev_backend_sym_create_session( +int64_t cryptodev_backend_create_session( CryptoDevBackend *backend, - CryptoDevBackendSymSessionInfo *sess_info, + CryptoDevBackendSessionInfo *sess_info, uint32_t queue_index, Error **errp) { CryptoDevBackendClass *bc =3D @@ -87,7 +87,7 @@ int64_t cryptodev_backend_sym_create_session( return -1; } =20 -int cryptodev_backend_sym_close_session( +int cryptodev_backend_close_session( CryptoDevBackend *backend, uint64_t session_id, uint32_t queue_index, Error **errp) @@ -102,16 +102,16 @@ int cryptodev_backend_sym_close_session( return -1; } =20 -static int cryptodev_backend_sym_operation( +static int cryptodev_backend_operation( CryptoDevBackend *backend, - CryptoDevBackendSymOpInfo *op_info, + CryptoDevBackendOpInfo *op_info, uint32_t queue_index, Error **errp) { CryptoDevBackendClass *bc =3D CRYPTODEV_BACKEND_GET_CLASS(backend); =20 - if (bc->do_sym_op) { - return bc->do_sym_op(backend, op_info, queue_index, errp); + if (bc->do_op) { + return bc->do_op(backend, op_info, queue_index, errp); } =20 return -VIRTIO_CRYPTO_ERR; @@ -123,20 +123,18 @@ int cryptodev_backend_crypto_operation( uint32_t queue_index, Error **errp) { VirtIOCryptoReq *req =3D opaque; + CryptoDevBackendOpInfo *op_info =3D &req->op_info; + enum CryptoDevBackendAlgType algtype =3D req->flags; =20 - if (req->flags =3D=3D CRYPTODEV_BACKEND_ALG_SYM) { - CryptoDevBackendSymOpInfo *op_info; - op_info =3D req->u.sym_op_info; - - return cryptodev_backend_sym_operation(backend, - op_info, queue_index, errp); - } else { + if ((algtype !=3D CRYPTODEV_BACKEND_ALG_SYM) + && (algtype !=3D CRYPTODEV_BACKEND_ALG_ASYM)) { error_setg(errp, "Unsupported cryptodev alg type: %" PRIu32 "", - req->flags); - return -VIRTIO_CRYPTO_NOTSUPP; + algtype); + + return -VIRTIO_CRYPTO_NOTSUPP; } =20 - return -VIRTIO_CRYPTO_ERR; + return cryptodev_backend_operation(backend, op_info, queue_index, errp= ); } =20 static void diff --git a/crypto/akcipher.c b/crypto/akcipher.c new file mode 100644 index 0000000000..ac8d1c9bf1 --- /dev/null +++ b/crypto/akcipher.c @@ -0,0 +1,78 @@ +/* + * QEMU Crypto akcipher algorithms + * + * Copyright (c) 2022 Bytedance + * Author: zhenwei pi + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + * + */ + +#include "qemu/osdep.h" +#include "qemu/host-utils.h" +#include "qapi/error.h" +#include "crypto/akcipher.h" + +QCryptoAkcipher *qcrypto_akcipher_new(uint32_t alg, bool private, + const uint8_t *key, size_t keylen, + void *para, + int index, Error **errp) +{ + QCryptoAkcipher *akcipher =3D NULL; + + return akcipher; +} + +int qcrypto_akcipher_encrypt(QCryptoAkcipher *akcipher, + const void *data, size_t data_len, + void *enc, size_t enc_len, Error **errp) +{ + const QCryptoAkcipherDriver *drv =3D akcipher->driver; + + return drv->encrypt(akcipher, data, data_len, enc, enc_len, errp); +} + +int qcrypto_akcipher_decrypt(struct QCryptoAkcipher *akcipher, + const void *enc, size_t enc_len, + void *data, size_t data_len, Error **errp) +{ + const QCryptoAkcipherDriver *drv =3D akcipher->driver; + + return drv->decrypt(akcipher, enc, enc_len, data, data_len, errp); +} + +int qcrypto_akcipher_sign(struct QCryptoAkcipher *akcipher, + const void *data, size_t data_len, + void *sig, size_t sig_len, Error **errp) +{ + const QCryptoAkcipherDriver *drv =3D akcipher->driver; + + return drv->sign(akcipher, data, data_len, sig, sig_len, errp); +} + +int qcrypto_akcipher_verify(struct QCryptoAkcipher *akcipher, + const void *sig, size_t sig_len, + const void *data, size_t data_len, Error **err= p) +{ + const QCryptoAkcipherDriver *drv =3D akcipher->driver; + + return drv->verify(akcipher, sig, sig_len, data, data_len, errp); +} + +int qcrypto_akcipher_free(struct QCryptoAkcipher *akcipher, Error **errp) +{ + const QCryptoAkcipherDriver *drv =3D akcipher->driver; + + return drv->free(akcipher, errp); +} diff --git a/crypto/meson.build b/crypto/meson.build index 95a6a83504..72b36f450a 100644 --- a/crypto/meson.build +++ b/crypto/meson.build @@ -19,6 +19,7 @@ crypto_ss.add(files( 'tlscredspsk.c', 'tlscredsx509.c', 'tlssession.c', + 'akcipher.c', )) =20 if nettle.found() diff --git a/hw/virtio/virtio-crypto.c b/hw/virtio/virtio-crypto.c index 54f9bbb789..3bb79a100b 100644 --- a/hw/virtio/virtio-crypto.c +++ b/hw/virtio/virtio-crypto.c @@ -83,7 +83,8 @@ virtio_crypto_create_sym_session(VirtIOCrypto *vcrypto, struct iovec *iov, unsigned int out_num) { VirtIODevice *vdev =3D VIRTIO_DEVICE(vcrypto); - CryptoDevBackendSymSessionInfo info; + CryptoDevBackendSessionInfo info; + CryptoDevBackendSymSessionInfo *sym_info; int64_t session_id; int queue_index; uint32_t op_type; @@ -92,11 +93,13 @@ virtio_crypto_create_sym_session(VirtIOCrypto *vcrypto, =20 memset(&info, 0, sizeof(info)); op_type =3D ldl_le_p(&sess_req->op_type); - info.op_type =3D op_type; info.op_code =3D opcode; =20 + sym_info =3D &info.u.sym_sess_info; + sym_info->op_type =3D op_type; + if (op_type =3D=3D VIRTIO_CRYPTO_SYM_OP_CIPHER) { - ret =3D virtio_crypto_cipher_session_helper(vdev, &info, + ret =3D virtio_crypto_cipher_session_helper(vdev, sym_info, &sess_req->u.cipher.para, &iov, &out_num); if (ret < 0) { @@ -105,47 +108,47 @@ virtio_crypto_create_sym_session(VirtIOCrypto *vcrypt= o, } else if (op_type =3D=3D VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) { size_t s; /* cipher part */ - ret =3D virtio_crypto_cipher_session_helper(vdev, &info, + ret =3D virtio_crypto_cipher_session_helper(vdev, sym_info, &sess_req->u.chain.para.cipher_param, &iov, &out_num); if (ret < 0) { goto err; } /* hash part */ - info.alg_chain_order =3D ldl_le_p( + sym_info->alg_chain_order =3D ldl_le_p( &sess_req->u.chain.para.alg_chain_ord= er); - info.add_len =3D ldl_le_p(&sess_req->u.chain.para.aad_len); - info.hash_mode =3D ldl_le_p(&sess_req->u.chain.para.hash_mode); - if (info.hash_mode =3D=3D VIRTIO_CRYPTO_SYM_HASH_MODE_AUTH) { - info.hash_alg =3D ldl_le_p(&sess_req->u.chain.para.u.mac_param= .algo); - info.auth_key_len =3D ldl_le_p( + sym_info->add_len =3D ldl_le_p(&sess_req->u.chain.para.aad_len); + sym_info->hash_mode =3D ldl_le_p(&sess_req->u.chain.para.hash_mode= ); + if (sym_info->hash_mode =3D=3D VIRTIO_CRYPTO_SYM_HASH_MODE_AUTH) { + sym_info->hash_alg =3D + ldl_le_p(&sess_req->u.chain.para.u.mac_param.algo); + sym_info->auth_key_len =3D ldl_le_p( &sess_req->u.chain.para.u.mac_param.auth_key_= len); - info.hash_result_len =3D ldl_le_p( + sym_info->hash_result_len =3D ldl_le_p( &sess_req->u.chain.para.u.mac_param.hash_result= _len); - if (info.auth_key_len > vcrypto->conf.max_auth_key_len) { + if (sym_info->auth_key_len > vcrypto->conf.max_auth_key_len) { error_report("virtio-crypto length of auth key is too big:= %u", - info.auth_key_len); + sym_info->auth_key_len); ret =3D -VIRTIO_CRYPTO_ERR; goto err; } /* get auth key */ - if (info.auth_key_len > 0) { - DPRINTF("auth_keylen=3D%" PRIu32 "\n", info.auth_key_len); - info.auth_key =3D g_malloc(info.auth_key_len); - s =3D iov_to_buf(iov, out_num, 0, info.auth_key, - info.auth_key_len); - if (unlikely(s !=3D info.auth_key_len)) { + if (sym_info->auth_key_len > 0) { + sym_info->auth_key =3D g_malloc(sym_info->auth_key_len); + s =3D iov_to_buf(iov, out_num, 0, sym_info->auth_key, + sym_info->auth_key_len); + if (unlikely(s !=3D sym_info->auth_key_len)) { virtio_error(vdev, "virtio-crypto authenticated key incorrect"); ret =3D -EFAULT; goto err; } - iov_discard_front(&iov, &out_num, info.auth_key_len); + iov_discard_front(&iov, &out_num, sym_info->auth_key_len); } - } else if (info.hash_mode =3D=3D VIRTIO_CRYPTO_SYM_HASH_MODE_PLAIN= ) { - info.hash_alg =3D ldl_le_p( + } else if (sym_info->hash_mode =3D=3D VIRTIO_CRYPTO_SYM_HASH_MODE_= PLAIN) { + sym_info->hash_alg =3D ldl_le_p( &sess_req->u.chain.para.u.hash_param.algo); - info.hash_result_len =3D ldl_le_p( + sym_info->hash_result_len =3D ldl_le_p( &sess_req->u.chain.para.u.hash_param.hash_result_l= en); } else { /* VIRTIO_CRYPTO_SYM_HASH_MODE_NESTED */ @@ -161,13 +164,10 @@ virtio_crypto_create_sym_session(VirtIOCrypto *vcrypt= o, } =20 queue_index =3D virtio_crypto_vq2q(queue_id); - session_id =3D cryptodev_backend_sym_create_session( + session_id =3D cryptodev_backend_create_session( vcrypto->cryptodev, &info, queue_index, &local_err); if (session_id >=3D 0) { - DPRINTF("create session_id=3D%" PRIu64 " successfully\n", - session_id); - ret =3D session_id; } else { if (local_err) { @@ -177,11 +177,82 @@ virtio_crypto_create_sym_session(VirtIOCrypto *vcrypt= o, } =20 err: - g_free(info.cipher_key); - g_free(info.auth_key); + g_free(sym_info->cipher_key); + g_free(sym_info->auth_key); return ret; } =20 +static int64_t +virtio_crypto_create_asym_session(VirtIOCrypto *vcrypto, + struct virtio_crypto_akcipher_create_session_req *sess_req, + uint32_t queue_id, uint32_t opcode, + struct iovec *iov, unsigned int out_num) +{ + VirtIODevice *vdev =3D VIRTIO_DEVICE(vcrypto); + CryptoDevBackendSessionInfo info =3D {0}; + CryptoDevBackendAsymSessionInfo *asym_info; + int64_t session_id; + int queue_index; + uint32_t algo, keytype, keylen; + uint8_t *key =3D NULL; + Error *local_err =3D NULL; + + algo =3D ldl_le_p(&sess_req->para.algo); + keytype =3D ldl_le_p(&sess_req->para.keytype); + keylen =3D ldl_le_p(&sess_req->para.keylen); + + if ((keytype !=3D VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PUBLIC) + && (keytype !=3D VIRTIO_CRYPTO_AKCIPHER_KEY_TYPE_PRIVATE)) { + error_report("unsupported asym keytype: %d", keytype); + return -VIRTIO_CRYPTO_NOTSUPP; + } + + if (keylen) { + key =3D g_malloc(keylen); + if (iov_to_buf(iov, out_num, 0, key, keylen) !=3D keylen) { + virtio_error(vdev, "virtio-crypto asym key incorrect"); + g_free(key); + return -EFAULT; + } + iov_discard_front(&iov, &out_num, keylen); + } + + info.op_code =3D opcode; + asym_info =3D &info.u.asym_sess_info; + asym_info->algo =3D algo; + asym_info->keytype =3D keytype; + asym_info->keylen =3D keylen; + asym_info->key =3D key; + switch (asym_info->algo) { + case VIRTIO_CRYPTO_AKCIPHER_RSA: + asym_info->u.rsa.padding_algo =3D + ldl_le_p(&sess_req->para.u.rsa.padding_algo); + asym_info->u.rsa.hash_algo =3D + ldl_le_p(&sess_req->para.u.rsa.hash_algo); + break; + + case VIRTIO_CRYPTO_AKCIPHER_ECDSA: + asym_info->u.ecdsa.curve_id =3D + ldl_le_p(&sess_req->para.u.ecdsa.curve_id); + break; + + default: + return -VIRTIO_CRYPTO_ERR; + } + + queue_index =3D virtio_crypto_vq2q(queue_id); + session_id =3D cryptodev_backend_create_session(vcrypto->cryptodev, &i= nfo, + queue_index, &local_err); + if (session_id < 0) { + if (local_err) { + error_report_err(local_err); + } + return -VIRTIO_CRYPTO_ERR; + } + + return session_id; +} + static uint8_t virtio_crypto_handle_close_session(VirtIOCrypto *vcrypto, struct virtio_crypto_destroy_session_req *close_sess_req, @@ -193,9 +264,8 @@ virtio_crypto_handle_close_session(VirtIOCrypto *vcrypt= o, Error *local_err =3D NULL; =20 session_id =3D ldq_le_p(&close_sess_req->session_id); - DPRINTF("close session, id=3D%" PRIu64 "\n", session_id); =20 - ret =3D cryptodev_backend_sym_close_session( + ret =3D cryptodev_backend_close_session( vcrypto->cryptodev, session_id, queue_id, &local_err); if (ret =3D=3D 0) { status =3D VIRTIO_CRYPTO_OK; @@ -260,13 +330,22 @@ static void virtio_crypto_handle_ctrl(VirtIODevice *v= dev, VirtQueue *vq) opcode =3D ldl_le_p(&ctrl.header.opcode); queue_id =3D ldl_le_p(&ctrl.header.queue_id); =20 + memset(&input, 0, sizeof(input)); switch (opcode) { case VIRTIO_CRYPTO_CIPHER_CREATE_SESSION: - memset(&input, 0, sizeof(input)); session_id =3D virtio_crypto_create_sym_session(vcrypto, &ctrl.u.sym_create_session, queue_id, opcode, out_iov, out_num); + goto check_session; + + case VIRTIO_CRYPTO_AKCIPHER_CREATE_SESSION: + session_id =3D virtio_crypto_create_asym_session(vcrypto, + &ctrl.u.akcipher_create_session, + queue_id, opcode, + out_iov, out_num); + +check_session: /* Serious errors, need to reset virtio crypto device */ if (session_id =3D=3D -EFAULT) { virtqueue_detach_element(vq, elem, 0); @@ -290,10 +369,12 @@ static void virtio_crypto_handle_ctrl(VirtIODevice *v= dev, VirtQueue *vq) virtqueue_push(vq, elem, sizeof(input)); virtio_notify(vdev, vq); break; + case VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION: case VIRTIO_CRYPTO_HASH_DESTROY_SESSION: case VIRTIO_CRYPTO_MAC_DESTROY_SESSION: case VIRTIO_CRYPTO_AEAD_DESTROY_SESSION: + case VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION: status =3D virtio_crypto_handle_close_session(vcrypto, &ctrl.u.destroy_session, queue_id); /* The status only occupy one byte, we can directly use it */ @@ -311,7 +392,6 @@ static void virtio_crypto_handle_ctrl(VirtIODevice *vde= v, VirtQueue *vq) case VIRTIO_CRYPTO_AEAD_CREATE_SESSION: default: error_report("virtio-crypto unsupported ctrl opcode: %d", opco= de); - memset(&input, 0, sizeof(input)); stl_le_p(&input.status, VIRTIO_CRYPTO_NOTSUPP); s =3D iov_from_buf(in_iov, in_num, 0, &input, sizeof(input)); if (unlikely(s !=3D sizeof(input))) { @@ -339,28 +419,37 @@ static void virtio_crypto_init_request(VirtIOCrypto *= vcrypto, VirtQueue *vq, req->in_num =3D 0; req->in_len =3D 0; req->flags =3D CRYPTODEV_BACKEND_ALG__MAX; - req->u.sym_op_info =3D NULL; + memset(&req->op_info, 0x00, sizeof(req->op_info)); } =20 static void virtio_crypto_free_request(VirtIOCryptoReq *req) { - if (req) { - if (req->flags =3D=3D CRYPTODEV_BACKEND_ALG_SYM) { - size_t max_len; - CryptoDevBackendSymOpInfo *op_info =3D req->u.sym_op_info; - - max_len =3D op_info->iv_len + - op_info->aad_len + - op_info->src_len + - op_info->dst_len + - op_info->digest_result_len; - - /* Zeroize and free request data structure */ - memset(op_info, 0, sizeof(*op_info) + max_len); + if (!req) { + return; + } + + if (req->flags =3D=3D CRYPTODEV_BACKEND_ALG_SYM) { + size_t max_len; + CryptoDevBackendSymOpInfo *op_info =3D req->op_info.u.sym_op_info; + + max_len =3D op_info->iv_len + + op_info->aad_len + + op_info->src_len + + op_info->dst_len + + op_info->digest_result_len; + + /* Zeroize and free request data structure */ + memset(op_info, 0, sizeof(*op_info) + max_len); + g_free(op_info); + } else if (req->flags =3D=3D CRYPTODEV_BACKEND_ALG_ASYM) { + CryptoDevBackendAsymOpInfo *op_info =3D req->op_info.u.asym_op_inf= o; + if (op_info) { + memset(op_info, 0, sizeof(*op_info)); g_free(op_info); } - g_free(req); } + + g_free(req); } =20 static void @@ -397,6 +486,37 @@ virtio_crypto_sym_input_data_helper(VirtIODevice *vdev, } } =20 +static void +virtio_crypto_akcipher_input_data_helper(VirtIODevice *vdev, + VirtIOCryptoReq *req, int32_t status, + CryptoDevBackendAsymOpInfo *asym_op_info) +{ + size_t s, len; + + if (status !=3D VIRTIO_CRYPTO_OK) { + return; + } + + /* For verify, we don't need write anything back */ + if (req->op_info.op_code =3D=3D VIRTIO_CRYPTO_AKCIPHER_VERIFY) { + return; + } + + len =3D asym_op_info->dst_len; + if (!len) { + return; + } + + s =3D iov_from_buf(req->in_iov, req->in_num, 0, asym_op_info->dst, len= ); + if (s !=3D len) { + virtio_error(vdev, "virtio-crypto asym dest data incorrect"); + return; + } + + iov_discard_front(&req->in_iov, &req->in_num, len); +} + + static void virtio_crypto_req_complete(VirtIOCryptoReq *req, uint8_t statu= s) { VirtIOCrypto *vcrypto =3D req->vcrypto; @@ -404,7 +524,10 @@ static void virtio_crypto_req_complete(VirtIOCryptoReq= *req, uint8_t status) =20 if (req->flags =3D=3D CRYPTODEV_BACKEND_ALG_SYM) { virtio_crypto_sym_input_data_helper(vdev, req, status, - req->u.sym_op_info); + req->op_info.u.sym_op_info); + } else if (req->flags =3D=3D CRYPTODEV_BACKEND_ALG_ASYM) { + virtio_crypto_akcipher_input_data_helper(vdev, req, status, + req->op_info.u.asym_op_info); } stb_p(&req->in->status, status); virtqueue_push(req->vq, &req->elem, req->in_len); @@ -543,39 +666,98 @@ err: static int virtio_crypto_handle_sym_req(VirtIOCrypto *vcrypto, struct virtio_crypto_sym_data_req *req, - CryptoDevBackendSymOpInfo **sym_op_info, + CryptoDevBackendOpInfo *op_info, struct iovec *iov, unsigned int out_num) { VirtIODevice *vdev =3D VIRTIO_DEVICE(vcrypto); + CryptoDevBackendSymOpInfo *sym_op_info; uint32_t op_type; - CryptoDevBackendSymOpInfo *op_info; =20 op_type =3D ldl_le_p(&req->op_type); - if (op_type =3D=3D VIRTIO_CRYPTO_SYM_OP_CIPHER) { - op_info =3D virtio_crypto_sym_op_helper(vdev, &req->u.cipher.para, + sym_op_info =3D virtio_crypto_sym_op_helper(vdev, &req->u.cipher.p= ara, NULL, iov, out_num); - if (!op_info) { + if (!sym_op_info) { return -EFAULT; } - op_info->op_type =3D op_type; } else if (op_type =3D=3D VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING) { - op_info =3D virtio_crypto_sym_op_helper(vdev, NULL, + sym_op_info =3D virtio_crypto_sym_op_helper(vdev, NULL, &req->u.chain.para, iov, out_num); - if (!op_info) { + if (!sym_op_info) { return -EFAULT; } - op_info->op_type =3D op_type; } else { /* VIRTIO_CRYPTO_SYM_OP_NONE */ error_report("virtio-crypto unsupported cipher type"); return -VIRTIO_CRYPTO_NOTSUPP; } =20 - *sym_op_info =3D op_info; + sym_op_info->op_type =3D op_type; + op_info->u.sym_op_info =3D sym_op_info; + + return 0; +} + +static int +virtio_crypto_handle_asym_req(VirtIOCrypto *vcrypto, + struct virtio_crypto_akcipher_data_req *req, + CryptoDevBackendOpInfo *op_info, + struct iovec *iov, unsigned int out_num) +{ + VirtIODevice *vdev =3D VIRTIO_DEVICE(vcrypto); + CryptoDevBackendAsymOpInfo *asym_op_info; + uint32_t src_len; + uint32_t dst_len; + uint32_t len; + uint8_t *src =3D NULL; + uint8_t *dst =3D NULL; + + asym_op_info =3D g_malloc0(sizeof(CryptoDevBackendAsymOpInfo)); + src_len =3D ldl_le_p(&req->para.src_data_len); + dst_len =3D ldl_le_p(&req->para.dst_data_len); + + if (src_len > 0) { + src =3D g_malloc0(src_len); + len =3D iov_to_buf(iov, out_num, 0, src, src_len); + if (unlikely(len !=3D src_len)) { + virtio_error(vdev, "virtio-crypto asym src data incorrect" + "expected %u, actual %u", src_len, len); + goto err; + } + + iov_discard_front(&iov, &out_num, src_len); + } + + if (dst_len > 0) { + dst =3D g_malloc0(dst_len); + + if (op_info->op_code =3D=3D VIRTIO_CRYPTO_AKCIPHER_VERIFY) { + len =3D iov_to_buf(iov, out_num, 0, dst, dst_len); + if (unlikely(len !=3D dst_len)) { + virtio_error(vdev, "virtio-crypto asym dst data incorrect" + "expected %u, actual %u", dst_len, len); + goto err; + } + + iov_discard_front(&iov, &out_num, dst_len); + } + } + + asym_op_info->src_len =3D src_len; + asym_op_info->dst_len =3D dst_len; + asym_op_info->src =3D src; + asym_op_info->dst =3D dst; + op_info->u.asym_op_info =3D asym_op_info; =20 return 0; + + err: + g_free(asym_op_info); + g_free(src); + g_free(dst); + + return -EFAULT; } =20 static int @@ -595,8 +777,7 @@ virtio_crypto_handle_request(VirtIOCryptoReq *request) unsigned out_num; uint32_t opcode; uint8_t status =3D VIRTIO_CRYPTO_ERR; - uint64_t session_id; - CryptoDevBackendSymOpInfo *sym_op_info =3D NULL; + CryptoDevBackendOpInfo *op_info =3D &request->op_info; Error *local_err =3D NULL; =20 if (elem->out_num < 1 || elem->in_num < 1) { @@ -639,15 +820,28 @@ virtio_crypto_handle_request(VirtIOCryptoReq *request) request->in_iov =3D in_iov; =20 opcode =3D ldl_le_p(&req.header.opcode); - session_id =3D ldq_le_p(&req.header.session_id); + op_info->session_id =3D ldq_le_p(&req.header.session_id); + op_info->op_code =3D opcode; =20 switch (opcode) { case VIRTIO_CRYPTO_CIPHER_ENCRYPT: case VIRTIO_CRYPTO_CIPHER_DECRYPT: + op_info->algtype =3D request->flags =3D CRYPTODEV_BACKEND_ALG_SYM; ret =3D virtio_crypto_handle_sym_req(vcrypto, - &req.u.sym_req, - &sym_op_info, + &req.u.sym_req, op_info, out_iov, out_num); + goto check_result; + + case VIRTIO_CRYPTO_AKCIPHER_ENCRYPT: + case VIRTIO_CRYPTO_AKCIPHER_DECRYPT: + case VIRTIO_CRYPTO_AKCIPHER_SIGN: + case VIRTIO_CRYPTO_AKCIPHER_VERIFY: + op_info->algtype =3D request->flags =3D CRYPTODEV_BACKEND_ALG_ASYM; + ret =3D virtio_crypto_handle_asym_req(vcrypto, + &req.u.akcipher_req, op_info, + out_iov, out_num); + +check_result: /* Serious errors, need to reset virtio crypto device */ if (ret =3D=3D -EFAULT) { return -1; @@ -655,11 +849,8 @@ virtio_crypto_handle_request(VirtIOCryptoReq *request) virtio_crypto_req_complete(request, VIRTIO_CRYPTO_NOTSUPP); virtio_crypto_free_request(request); } else { - sym_op_info->session_id =3D session_id; =20 /* Set request's parameter */ - request->flags =3D CRYPTODEV_BACKEND_ALG_SYM; - request->u.sym_op_info =3D sym_op_info; ret =3D cryptodev_backend_crypto_operation(vcrypto->cryptodev, request, queue_index, &local_err); if (ret < 0) { @@ -674,6 +865,7 @@ virtio_crypto_handle_request(VirtIOCryptoReq *request) virtio_crypto_free_request(request); } break; + case VIRTIO_CRYPTO_HASH: case VIRTIO_CRYPTO_MAC: case VIRTIO_CRYPTO_AEAD_ENCRYPT: @@ -779,6 +971,7 @@ static void virtio_crypto_init_config(VirtIODevice *vde= v) vcrypto->conf.mac_algo_l =3D vcrypto->conf.cryptodev->conf.mac_algo_l; vcrypto->conf.mac_algo_h =3D vcrypto->conf.cryptodev->conf.mac_algo_h; vcrypto->conf.aead_algo =3D vcrypto->conf.cryptodev->conf.aead_algo; + vcrypto->conf.akcipher_algo =3D vcrypto->conf.cryptodev->conf.akcipher= _algo; vcrypto->conf.max_cipher_key_len =3D vcrypto->conf.cryptodev->conf.max_cipher_key_len; vcrypto->conf.max_auth_key_len =3D @@ -891,6 +1084,7 @@ static void virtio_crypto_get_config(VirtIODevice *vde= v, uint8_t *config) stl_le_p(&crypto_cfg.max_cipher_key_len, c->conf.max_cipher_key_len); stl_le_p(&crypto_cfg.max_auth_key_len, c->conf.max_auth_key_len); stq_le_p(&crypto_cfg.max_size, c->conf.max_size); + stl_le_p(&crypto_cfg.akcipher_algo, c->conf.akcipher_algo); =20 memcpy(config, &crypto_cfg, c->config_size); } diff --git a/include/crypto/akcipher.h b/include/crypto/akcipher.h new file mode 100644 index 0000000000..8c3aae9b6c --- /dev/null +++ b/include/crypto/akcipher.h @@ -0,0 +1,77 @@ +/* + * QEMU Crypto asymmetric algorithms + * + * Copyright (c) 2022 Bytedance + * Author: zhenwei pi + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + * + */ + +#ifndef QCRYPTO_AKCIPHER_H +#define QCRYPTO_AKCIPHER_H + +#include "qemu/typedefs.h" + +typedef struct QCryptoAkcipher QCryptoAkcipher; +typedef struct QCryptoAkcipherDriver QCryptoAkcipherDriver; + +struct QCryptoAkcipherDriver { + int (*encrypt)(struct QCryptoAkcipher *akcipher, + const void *data, size_t data_len, + void *enc, size_t enc_len, Error **errp); + int (*decrypt)(struct QCryptoAkcipher *akcipher, + const void *enc, size_t enc_len, + void *data, size_t data_len, Error **errp); + int (*sign)(struct QCryptoAkcipher *akcipher, + const void *data, size_t data_len, + void *sig, size_t sig_len, Error **errp); + int (*verify)(struct QCryptoAkcipher *akcipher, + const void *sig, size_t sig_len, + const void *data, size_t data_len, Error **errp); + int (*free)(struct QCryptoAkcipher *akcipher, Error **errp); +}; + +struct QCryptoAkcipher { + uint32_t alg; + bool private; + uint8_t *key; + size_t keylen; + QCryptoAkcipherDriver *driver; +}; + +QCryptoAkcipher *qcrypto_akcipher_new(uint32_t alg, bool private, + const uint8_t *key, size_t keylen, + void *para, int index, Error **errp); + +int qcrypto_akcipher_encrypt(QCryptoAkcipher *akcipher, + const void *data, size_t data_len, + void *enc, size_t enc_len, Error **errp); + +int qcrypto_akcipher_decrypt(struct QCryptoAkcipher *akcipher, + const void *enc, size_t enc_len, + void *data, size_t data_len, Error **errp); + +int qcrypto_akcipher_sign(struct QCryptoAkcipher *akcipher, + const void *data, size_t data_len, + void *sig, size_t sig_len, Error **errp); + +int qcrypto_akcipher_verify(struct QCryptoAkcipher *akcipher, + const void *sig, size_t sig_len, + const void *data, size_t data_len, Error **err= p); + +int qcrypto_akcipher_free(struct QCryptoAkcipher *akcipher, Error **errp); + + +#endif /* QCRYPTO_AKCIPHER_H */ diff --git a/include/hw/virtio/virtio-crypto.h b/include/hw/virtio/virtio-c= rypto.h index a2228d7b2e..348749f5d5 100644 --- a/include/hw/virtio/virtio-crypto.h +++ b/include/hw/virtio/virtio-crypto.h @@ -50,6 +50,7 @@ typedef struct VirtIOCryptoConf { uint32_t mac_algo_l; uint32_t mac_algo_h; uint32_t aead_algo; + uint32_t akcipher_algo; =20 /* Maximum length of cipher key */ uint32_t max_cipher_key_len; @@ -71,9 +72,7 @@ typedef struct VirtIOCryptoReq { size_t in_len; VirtQueue *vq; struct VirtIOCrypto *vcrypto; - union { - CryptoDevBackendSymOpInfo *sym_op_info; - } u; + CryptoDevBackendOpInfo op_info; } VirtIOCryptoReq; =20 typedef struct VirtIOCryptoQueue { diff --git a/include/sysemu/cryptodev.h b/include/sysemu/cryptodev.h index f4d4057d4d..b306775849 100644 --- a/include/sysemu/cryptodev.h +++ b/include/sysemu/cryptodev.h @@ -50,13 +50,13 @@ typedef struct CryptoDevBackendClient =20 enum CryptoDevBackendAlgType { CRYPTODEV_BACKEND_ALG_SYM, + CRYPTODEV_BACKEND_ALG_ASYM, CRYPTODEV_BACKEND_ALG__MAX, }; =20 /** * CryptoDevBackendSymSessionInfo: * - * @op_code: operation code (refer to virtio_crypto.h) * @cipher_alg: algorithm type of CIPHER * @key_len: byte length of cipher key * @hash_alg: algorithm type of HASH/MAC @@ -74,7 +74,6 @@ enum CryptoDevBackendAlgType { */ typedef struct CryptoDevBackendSymSessionInfo { /* corresponding with virtio crypto spec */ - uint32_t op_code; uint32_t cipher_alg; uint32_t key_len; uint32_t hash_alg; @@ -89,11 +88,41 @@ typedef struct CryptoDevBackendSymSessionInfo { uint8_t *auth_key; } CryptoDevBackendSymSessionInfo; =20 +/** + * CryptoDevBackendAsymSessionInfo: + */ +typedef struct CryptoDevBackendRsaPara { + uint32_t padding_algo; + uint32_t hash_algo; +} CryptoDevBackendRsaPara; + +typedef struct CryptoDevBackendEcdsaPara { + uint32_t curve_id; +} CryptoDevBackendEcdsaPara; + +typedef struct CryptoDevBackendAsymSessionInfo { + /* corresponding with virtio crypto spec */ + uint32_t algo; + uint32_t keytype; + uint32_t keylen; + uint8_t *key; + union { + CryptoDevBackendRsaPara rsa; + CryptoDevBackendEcdsaPara ecdsa; + } u; +} CryptoDevBackendAsymSessionInfo; + +typedef struct CryptoDevBackendSessionInfo { + uint32_t op_code; + union { + CryptoDevBackendSymSessionInfo sym_sess_info; + CryptoDevBackendAsymSessionInfo asym_sess_info; + } u; +} CryptoDevBackendSessionInfo; + /** * CryptoDevBackendSymOpInfo: * - * @session_id: session index which was previously - * created by cryptodev_backend_sym_create_session() * @aad_len: byte length of additional authenticated data * @iv_len: byte length of initialization vector or counter * @src_len: byte length of source data @@ -119,7 +148,6 @@ typedef struct CryptoDevBackendSymSessionInfo { * */ typedef struct CryptoDevBackendSymOpInfo { - uint64_t session_id; uint32_t aad_len; uint32_t iv_len; uint32_t src_len; @@ -138,6 +166,33 @@ typedef struct CryptoDevBackendSymOpInfo { uint8_t data[]; } CryptoDevBackendSymOpInfo; =20 + +/** + * CryptoDevBackendAsymOpInfo: + * + * @src_len: byte length of source data + * @dst_len: byte length of destination data + * @src: point to the source data + * @dst: point to the destination data + * + */ +typedef struct CryptoDevBackendAsymOpInfo { + uint32_t src_len; + uint32_t dst_len; + uint8_t *src; + uint8_t *dst; +} CryptoDevBackendAsymOpInfo; + +typedef struct CryptoDevBackendOpInfo { + enum CryptoDevBackendAlgType algtype; + uint32_t op_code; + uint64_t session_id; + union { + CryptoDevBackendSymOpInfo *sym_op_info; + CryptoDevBackendAsymOpInfo *asym_op_info; + } u; +} CryptoDevBackendOpInfo; + struct CryptoDevBackendClass { ObjectClass parent_class; =20 @@ -145,13 +200,13 @@ struct CryptoDevBackendClass { void (*cleanup)(CryptoDevBackend *backend, Error **errp); =20 int64_t (*create_session)(CryptoDevBackend *backend, - CryptoDevBackendSymSessionInfo *sess_info, + CryptoDevBackendSessionInfo *sess_info, uint32_t queue_index, Error **errp); int (*close_session)(CryptoDevBackend *backend, uint64_t session_id, uint32_t queue_index, Error **errp); - int (*do_sym_op)(CryptoDevBackend *backend, - CryptoDevBackendSymOpInfo *op_info, + int (*do_op)(CryptoDevBackend *backend, + CryptoDevBackendOpInfo *op_info, uint32_t queue_index, Error **errp); }; =20 @@ -190,6 +245,7 @@ struct CryptoDevBackendConf { uint32_t mac_algo_l; uint32_t mac_algo_h; uint32_t aead_algo; + uint32_t akcipher_algo; /* Maximum length of cipher key */ uint32_t max_cipher_key_len; /* Maximum length of authenticated key */ @@ -247,34 +303,34 @@ void cryptodev_backend_cleanup( Error **errp); =20 /** - * cryptodev_backend_sym_create_session: + * cryptodev_backend_create_session: * @backend: the cryptodev backend object * @sess_info: parameters needed by session creating * @queue_index: queue index of cryptodev backend client * @errp: pointer to a NULL-initialized error object * - * Create a session for symmetric algorithms + * Create a session for symmetric/symmetric algorithms * * Returns: session id on success, or -1 on error */ -int64_t cryptodev_backend_sym_create_session( +int64_t cryptodev_backend_create_session( CryptoDevBackend *backend, - CryptoDevBackendSymSessionInfo *sess_info, + CryptoDevBackendSessionInfo *sess_info, uint32_t queue_index, Error **errp); =20 /** - * cryptodev_backend_sym_close_session: + * cryptodev_backend_close_session: * @backend: the cryptodev backend object * @session_id: the session id * @queue_index: queue index of cryptodev backend client * @errp: pointer to a NULL-initialized error object * - * Close a session for symmetric algorithms which was previously - * created by cryptodev_backend_sym_create_session() + * Close a session for which was previously + * created by cryptodev_backend_create_session() * * Returns: 0 on success, or Negative on error */ -int cryptodev_backend_sym_close_session( +int cryptodev_backend_close_session( CryptoDevBackend *backend, uint64_t session_id, uint32_t queue_index, Error **errp); --=20 2.25.1 From nobody Fri May 3 14:28:29 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=bytedance.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1642732452150934.4569854090521; Thu, 20 Jan 2022 18:34:12 -0800 (PST) Received: from localhost ([::1]:59654 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1nAjkg-0002ho-Gv for importer@patchew.org; Thu, 20 Jan 2022 21:34:10 -0500 Received: from eggs.gnu.org ([209.51.188.92]:41582) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1nAjf8-0005MY-VY for qemu-devel@nongnu.org; Thu, 20 Jan 2022 21:28:26 -0500 Received: from [2607:f8b0:4864:20::634] (port=38702 helo=mail-pl1-x634.google.com) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1nAjf5-0002Ba-1q for qemu-devel@nongnu.org; Thu, 20 Jan 2022 21:28:26 -0500 Received: by mail-pl1-x634.google.com with SMTP id c3so7089398pls.5 for ; Thu, 20 Jan 2022 18:28:22 -0800 (PST) Received: from libai.bytedance.net ([61.120.150.72]) by smtp.gmail.com with ESMTPSA id d1sm4825404pfj.179.2022.01.20.18.28.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Jan 2022 18:28:21 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=wkDys05u50jgSoEr6OQi7r95A4PzmOy/cRNz0+7Vqbw=; b=q5BMZris2TsBw/FWQ9D4YlCvKvUT+rvRbWaniwGRHwvzvKcQJqqUuyG41ZonTYiSss 1sfR5qid+oJbOdk5GYN6tHllpVpLjiO8BcnS1MvLdUU/myvLn8FumzLRsElPNHSUO8yX fPAI8f1kOa1pot7jpABh5F+BZbs/SD5Zy7QgBuWYgsgbDtrdDW/jDAG8E6J9SXLlDCEi 3UktsCGms2ewHGqWKwXPiqAUkHm+qLIb78LMp++9DqfXEkViXzKvF0ufxf1ANpFbNpmb aRdgtbCmwory/J43vfmuIKbhpIjgseqLa/gb43NhTAddPu/2vDuNOV4LX0KSe762b5yE 8iHg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=wkDys05u50jgSoEr6OQi7r95A4PzmOy/cRNz0+7Vqbw=; b=Nb4o17wSXSn8FbP5tEl7ItKNOi5haNGqCrXblTcW3cfefS4mVaKR1rH/KO/h+FQHL6 J41e3C2PV4verIA9f2OxAsTmdhbsMPab8cyJdIVH+j2fVbCDhYacozj9wHWsiU3rBKn3 OFxAZasut6oBD3+gWVDvdHxK0pyNw96T3hEPvTVtvyFiZbciVV2V9zrd487wmHIKeay8 rWLo9y6GpOYuqWRjDAuUGfpWuPeyVXfbrRO6SC+zjygSNR7qa8mHL6Bxn+1ebj259tud eB2y04IqOrx5R/xKKtZXI4m9J7zRBCTshn+Dl9Lg8KQmt6DzQwXD9mbQyIrUhbgNXmYq ACOA== X-Gm-Message-State: AOAM530qs97X/ya6/IFPM6jll1DfdtpUXh/XB+SDvTM6VAHImoGo3+NW i8VYcsuJLP4oOKe7hg2BwKFnRaHLLfSGqQ== X-Google-Smtp-Source: ABdhPJyLEsrMIjWX9d/YtkNvpSqlYifA3ftZ6amj4s7TjJweEblnbO6opYy5ZoVBVnfAawwJy1Uysw== X-Received: by 2002:a17:903:228c:b0:14a:fe2b:aeba with SMTP id b12-20020a170903228c00b0014afe2baebamr1700280plh.127.1642732101703; Thu, 20 Jan 2022 18:28:21 -0800 (PST) From: zhenwei pi To: arei.gonglei@huawei.com, mst@redhat.com, berrange@redhat.com Subject: [PATCH 3/3] crypto: Introduce RSA algorithm Date: Fri, 21 Jan 2022 10:27:00 +0800 Message-Id: <20220121022700.1042649-4-pizhenwei@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220121022700.1042649-1-pizhenwei@bytedance.com> References: <20220121022700.1042649-1-pizhenwei@bytedance.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Host-Lookup-Failed: Reverse DNS lookup failed for 2607:f8b0:4864:20::634 (failed) Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::634; envelope-from=pizhenwei@bytedance.com; helo=mail-pl1-x634.google.com X-Spam_score_int: -10 X-Spam_score: -1.1 X-Spam_bar: - X-Spam_report: (-1.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, PDS_HP_HELO_NORDNS=0.001, RCVD_IN_DNSWL_NONE=-0.0001, RDNS_NONE=0.793, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: qemu-devel@nongnu.org, zhenwei pi , helei.sig11@bytedance.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZM-MESSAGEID: 1642732454696100001 Content-Type: text/plain; charset="utf-8" From: Lei He Implement RSA algorithm by nettle hogweed, and apply it for virtio-crypto akcipher backend. 1, The self-test framework of crypto layer works fine in guest kernel 2, Test with Linux guest(with asym support), the following script test(note that pkey_XXX is supported only in a newer version of keyutils): - both public key & private key - create/close session - encrypt/decrypt/sign/verify basic driver operation - also test with kernel crypto layer(pkey add/query) All the cases work fine. rm -rf *.der *.pem *.pfx modprobe pkcs8_key_parser # if CONFIG_PKCS8_PRIVATE_KEY_PARSER=3Dm rm -rf /tmp/data dd if=3D/dev/random of=3D/tmp/data count=3D1 bs=3D226 openssl req -nodes -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -su= bj "/C=3DCN/ST=3DBJ/L=3DHD/O=3Dqemu/OU=3Ddev/CN=3Dqemu/emailAddress=3Dqemu@= qemu.org" openssl pkcs8 -in key.pem -topk8 -nocrypt -outform DER -out key.der openssl x509 -in cert.pem -inform PEM -outform DER -out cert.der PRIV_KEY_ID=3D`cat key.der | keyctl padd asymmetric test_priv_key @s` echo "priv key id =3D "$PRIV_KEY_ID PUB_KEY_ID=3D`cat cert.der | keyctl padd asymmetric test_pub_key @s` echo "pub key id =3D "$PUB_KEY_ID keyctl pkey_query $PRIV_KEY_ID 0 keyctl pkey_query $PUB_KEY_ID 0 echo "Enc with priv key..." keyctl pkey_encrypt $PRIV_KEY_ID 0 /tmp/data enc=3Dpkcs1 >/tmp/enc.priv echo "Dec with pub key..." keyctl pkey_decrypt $PRIV_KEY_ID 0 /tmp/enc.priv enc=3Dpkcs1 >/tmp/dec cmp /tmp/data /tmp/dec echo "Sign with priv key..." keyctl pkey_sign $PRIV_KEY_ID 0 /tmp/data enc=3Dpkcs1 hash=3Dsha1 > /tmp/sig echo "Verify with pub key..." keyctl pkey_verify $PRIV_KEY_ID 0 /tmp/data /tmp/sig enc=3Dpkcs1 hash=3Dsha1 echo "Enc with pub key..." keyctl pkey_encrypt $PUB_KEY_ID 0 /tmp/data enc=3Dpkcs1 >/tmp/enc.pub echo "Dec with priv key..." keyctl pkey_decrypt $PRIV_KEY_ID 0 /tmp/enc.pub enc=3Dpkcs1 >/tmp/dec cmp /tmp/data /tmp/dec echo "Verify with pub key..." keyctl pkey_verify $PUB_KEY_ID 0 /tmp/data /tmp/sig enc=3Dpkcs1 hash=3Dsha1 Signed-off-by: zhenwei pi Signed-off-by: lei he --- crypto/akcipher-nettle.c | 486 +++++++++++++++++++++++++++++++++++++++ crypto/akcipher.c | 13 ++ crypto/asn1_decoder.c | 185 +++++++++++++++ crypto/asn1_decoder.h | 42 ++++ crypto/meson.build | 3 + meson.build | 11 + 6 files changed, 740 insertions(+) create mode 100644 crypto/akcipher-nettle.c create mode 100644 crypto/asn1_decoder.c create mode 100644 crypto/asn1_decoder.h diff --git a/crypto/akcipher-nettle.c b/crypto/akcipher-nettle.c new file mode 100644 index 0000000000..6ac39e7abc --- /dev/null +++ b/crypto/akcipher-nettle.c @@ -0,0 +1,486 @@ +/* + * QEMU Crypto akcipher algorithms + * + * Copyright (c) 2022 Bytedance + * Author: lei he + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + * + */ + +#include + +#include + +#include "asn1_decoder.h" +#include "crypto/akcipher.h" +#include "crypto/random.h" +#include "qemu/osdep.h" +#include "qapi/error.h" +#include "sysemu/cryptodev.h" +#include "standard-headers/linux/virtio_crypto.h" + +typedef struct QCryptoNettleRsa { + QCryptoAkcipher akcipher; + struct rsa_public_key pub; + struct rsa_private_key priv; + int padding_algo; + int hash_algo; +} QCryptoNettleRsa; + +struct asn1_parse_ctx { + const uint8_t *data; + size_t dlen; +}; + +static int extract_value(void *p, const uint8_t *data, size_t dlen) +{ + struct asn1_parse_ctx *ctx =3D (struct asn1_parse_ctx *)p; + ctx->data =3D (uint8_t *)data; + ctx->dlen =3D dlen; + + return 0; +} + +static int extract_mpi(void *p, const uint8_t *data, size_t dlen) +{ + mpz_t *target =3D (mpz_t *)p; + nettle_mpz_set_str_256_u(*target, dlen, data); + + return 0; +} + +static QCryptoNettleRsa *qcrypto_nettle_rsa_malloc(void); + +static void qcrypto_nettle_rsa_destroy(void *ptr) +{ + QCryptoNettleRsa *rsa =3D (QCryptoNettleRsa *)ptr; + if (!rsa) { + return; + } + + rsa_public_key_clear(&rsa->pub); + rsa_private_key_clear(&rsa->priv); + g_free(rsa); +} + +static QCryptoAkcipher *qcrypto_nettle_new_rsa(bool private, const uint8_t= *key, + size_t keylen, void *para, + int index, Error **errp); + +QCryptoAkcipher *qcrypto_akcipher_nettle_new(uint32_t alg, bool private, + const uint8_t *key, + size_t keylen, void *para, + int index, Error **errp); + +QCryptoAkcipher *qcrypto_akcipher_nettle_new(uint32_t alg, bool private, + const uint8_t *key, + size_t keylen, void *para, + int index, Error **errp) +{ + switch (alg) { + case VIRTIO_CRYPTO_AKCIPHER_RSA: + return qcrypto_nettle_new_rsa(private, key, keylen, para, index, e= rrp); + default: + error_setg(errp, "Unsupported algorithm: %u", alg); + return NULL; + } + + return NULL; +} + +/* + * Parse ber encoded rsa private key, asn1 schema: + * RsaPrivKey ::=3D SEQUENCE { + * version INTEGER + * n INTEGER + * e INTEGER + * d INTEGER + * p INTEGER + * q INTEGER + * e1 INTEGER + * e2 INTEGER + * u INTEGER + * } + */ +static int parse_rsa_private_key(QCryptoNettleRsa *rsa, + const uint8_t *key, size_t keylen) +{ + struct asn1_parse_ctx ctx; + + if (ber_decode_seq(&key, &keylen, extract_value, &ctx) !=3D 0 || + keylen !=3D 0) { + return -1; + } + + if (ber_decode_int(&ctx.data, &ctx.dlen, NULL, NULL) !=3D 0 || + ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->pub.n) != =3D 0 || + ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->pub.e) != =3D 0 || + ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->priv.d) != =3D 0 || + ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->priv.p) != =3D 0 || + ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->priv.q) != =3D 0 || + ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->priv.a) != =3D 0 || + ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->priv.b) != =3D 0 || + ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->priv.c) != =3D 0 || + ctx.dlen !=3D 0) { + return -1; + } + + if (!rsa_public_key_prepare(&rsa->pub)) { + return -1; + } + + /* + * Since in the kernel's unit test, the p, q, a, b, c of some + * private keys is 0, only the simplest length check is done here + */ + rsa->priv.size =3D rsa->pub.size; + + return 0; +} + +/* + * Parse ber encoded rsa pubkey, asn1 schema: + * RsaPrivKey ::=3D SEQUENCE { + * n INTEGER + * e INTEGER + * } + */ +static int parse_rsa_public_key(QCryptoNettleRsa *rsa, + const uint8_t *key, + size_t keylen) +{ + struct asn1_parse_ctx ctx; + + if (ber_decode_seq(&key, &keylen, extract_value, &ctx) !=3D 0 || + keylen !=3D 0) { + return -1; + } + + if (ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->pub.n) != =3D 0 || + ber_decode_int(&ctx.data, &ctx.dlen, extract_mpi, &rsa->pub.e) != =3D 0 || + ctx.dlen !=3D 0) { + return -1; + } + + if (!rsa_public_key_prepare(&rsa->pub)) { + return -1; + } + + return 0; +} + +static QCryptoAkcipher *qcrypto_nettle_new_rsa(bool private, const uint8_t= *key, + size_t keylen, void *para, + int index, Error **errp) +{ + QCryptoNettleRsa *rsa =3D qcrypto_nettle_rsa_malloc(); + CryptoDevBackendRsaPara *p =3D (CryptoDevBackendRsaPara *)para; + rsa->padding_algo =3D p->padding_algo; + rsa->hash_algo =3D p->hash_algo; + + if (private && parse_rsa_private_key(rsa, key, keylen) =3D=3D 0) { + return (QCryptoAkcipher *)rsa; + } else if (!private && parse_rsa_public_key(rsa, key, keylen) =3D=3D 0= ) { + return (QCryptoAkcipher *)rsa; + } + + qcrypto_nettle_rsa_destroy(rsa); + error_setg(errp, "Failed to parse %s key", private ? "private" : "publ= ic"); + + return NULL; +} + + +/* + * nettle does not provide RSA interfaces without padding, + * here we implemented rsa algorithm with nettle/mpz. + */ +static int _rsa_enc_raw(QCryptoNettleRsa *rsa, const void *data, + size_t data_len, void *enc, + size_t enc_len, Error **errp) +{ + mpz_t m; + + nettle_mpz_init_set_str_256_u(m, data_len, data); + /* (1) Validate 0 <=3D m < n */ + if (mpz_cmp_ui(m, 0) < 0 || mpz_cmp(m, rsa->pub.n) >=3D 0) { + error_setg(errp, "Failed to validate input data"); + return -VIRTIO_CRYPTO_BADMSG; + } + + /* (2) c =3D m ^ e mod n */ + mpz_powm(m, m, rsa->pub.e, rsa->pub.n); + nettle_mpz_get_str_256(enc_len, (uint8_t *)enc, m); + + mpz_clear(m); + + return 0; +} + +static int _rsa_dec_raw(QCryptoNettleRsa *rsa, + const void *enc, + size_t enc_len, + void *data, + size_t data_len, + Error **errp) +{ + mpz_t c; + nettle_mpz_init_set_str_256_u(c, enc_len, enc); + + /* (1) Validate 0 <=3D c < n */ + if (mpz_cmp_ui(c, 0) < 0 || mpz_cmp(c, rsa->pub.n) >=3D 0) { + error_setg(errp, "Failed to validate input data"); + return -VIRTIO_CRYPTO_BADMSG; + } + + /* (2) m =3D c ^ d mod n */ + mpz_powm(c, c, rsa->priv.d, rsa->pub.n); + nettle_mpz_get_str_256(data_len, (uint8_t *)data, c); + mpz_clear(c); + + return 0; +} + +static void wrap_nettle_random_func(void *ctx, size_t len, uint8_t *out) +{ + /* TODO: check result */ + qcrypto_random_bytes(out, len, NULL); +} + +static int qcrypto_nettle_rsa_encrypt(QCryptoAkcipher *akcipher_driver, + const void *data, size_t data_len, + void *enc, size_t enc_len, + Error **errp) +{ + + QCryptoNettleRsa *rsa =3D + container_of(akcipher_driver, QCryptoNettleRsa, akcipher); + mpz_t c; + int enc_ret; + + if (data_len > rsa->pub.size || enc_len < rsa->pub.size) { + error_setg(errp, "Invalid buffer size"); + return -VIRTIO_CRYPTO_BADMSG; + } + + switch (rsa->padding_algo) { + case VIRTIO_CRYPTO_RSA_RAW_PADDING: + return _rsa_enc_raw(rsa, data, data_len, enc, enc_len, errp); + + case VIRTIO_CRYPTO_RSA_PKCS1_PADDING: + mpz_init(c); + enc_ret =3D rsa_encrypt(&rsa->pub, NULL, wrap_nettle_random_func, + data_len, (uint8_t *)data, c); + if (enc_ret !=3D 1) { + error_setg(errp, "Failed to encrypt"); + } else { + nettle_mpz_get_str_256(enc_len, (uint8_t *)enc, c); + } + mpz_clear(c); + return enc_ret =3D=3D 1 ? 0 : -1; + + default: + error_setg(errp, "Unknown padding"); + return -VIRTIO_CRYPTO_NOTSUPP; + } + + return -1; +} + +static int qcrypto_nettle_rsa_decrypt(QCryptoAkcipher *akcipher, + const void *enc, size_t enc_len, + void *data, size_t data_len, + Error **errp) +{ + QCryptoNettleRsa *rsa =3D container_of(akcipher, QCryptoNettleRsa, akc= ipher); + mpz_t m; + int dec_ret; + + if (enc_len > rsa->priv.size || data_len < rsa->priv.size) { + error_setg(errp, "Invalid buffer size"); + return -VIRTIO_CRYPTO_BADMSG; + } + + switch (rsa->padding_algo) { + case VIRTIO_CRYPTO_RSA_RAW_PADDING: + return _rsa_dec_raw(rsa, enc, enc_len, data, data_len, errp); + + case VIRTIO_CRYPTO_RSA_PKCS1_PADDING: + mpz_init(m); + dec_ret =3D rsa_encrypt(&rsa->pub, NULL, wrap_nettle_random_func, + data_len, (uint8_t *)data, m); + if (dec_ret !=3D 1) { + error_setg(errp, "Failed to encrypt"); + } else { + nettle_mpz_get_str_256(data_len, (uint8_t *)data_len, m); + } + mpz_clear(m); + return dec_ret =3D=3D 1 ? 0 : -1; + + default: + error_setg(errp, "Unknown padding"); + return -VIRTIO_CRYPTO_NOTSUPP; + } + + return -1; +} + + +static int qcrypto_nettle_rsa_sign(QCryptoAkcipher *akcipher, + const void *data, size_t data_len, + void *sig, size_t sig_len, Error **errp) +{ + QCryptoNettleRsa *rsa =3D container_of(akcipher, QCryptoNettleRsa, akc= ipher); + int ret; + mpz_t s; + + /* + * The RSA algorithm cannot be used for signature/verification + * without padding. + */ + if (rsa->padding_algo =3D=3D VIRTIO_CRYPTO_RSA_RAW_PADDING) { + error_setg(errp, "Try to make signature without padding"); + return -VIRTIO_CRYPTO_NOTSUPP; + } + + if (data_len > rsa->priv.size || sig_len < rsa->priv.size) { + error_setg(errp, "Invalid buffer size"); + return -VIRTIO_CRYPTO_BADMSG; + } + + mpz_init(s); + switch (rsa->hash_algo) { + case VIRTIO_CRYPTO_RSA_MD5: + ret =3D rsa_md5_sign_digest(&rsa->priv, data, s); + break; + + case VIRTIO_CRYPTO_RSA_SHA1: + ret =3D rsa_sha1_sign_digest(&rsa->priv, data, s); + break; + + case VIRTIO_CRYPTO_RSA_SHA256: + ret =3D rsa_sha256_sign_digest(&rsa->priv, data, s); + break; + + case VIRTIO_CRYPTO_RSA_SHA512: + ret =3D rsa_sha512_sign_digest(&rsa->priv, data, s); + break; + + default: + error_setg(errp, "Unknown hash algorithm"); + ret =3D -VIRTIO_CRYPTO_NOTSUPP; + goto clear; + } + + if (ret !=3D 1) { + error_setg(errp, "Failed to make signature"); + ret =3D -VIRTIO_CRYPTO_BADMSG; + goto clear; + } + nettle_mpz_get_str_256(sig_len, (uint8_t *)sig, s); + ret =3D 0; + +clear: + mpz_clear(s); + + return ret; +} + +static int qcrypto_nettle_rsa_verify(QCryptoAkcipher *akcipher, + const void *sig, size_t sig_len, + const void *data, size_t data_len, + Error **errp) +{ + QCryptoNettleRsa *rsa =3D container_of(akcipher, QCryptoNettleRsa, akc= ipher); + + int ret; + mpz_t s; + + /* + * The RSA algorithm cannot be used for signature/verification + * without padding. + */ + if (rsa->padding_algo =3D=3D VIRTIO_CRYPTO_RSA_RAW_PADDING) { + error_setg(errp, "Operation not supported"); + return -1; + } + if (data_len > rsa->pub.size || sig_len < rsa->pub.size) { + error_setg(errp, "Invalid buffer size"); + return -1; + } + + nettle_mpz_init_set_str_256_u(s, sig_len, sig); + switch (rsa->hash_algo) { + case VIRTIO_CRYPTO_RSA_MD5: + ret =3D rsa_md5_verify_digest(&rsa->pub, data, s); + break; + + case VIRTIO_CRYPTO_RSA_SHA1: + ret =3D rsa_sha1_verify_digest(&rsa->pub, data, s); + break; + + case VIRTIO_CRYPTO_RSA_SHA256: + ret =3D rsa_sha256_verify_digest(&rsa->pub, data, s); + break; + + case VIRTIO_CRYPTO_RSA_SHA512: + ret =3D rsa_sha512_verify_digest(&rsa->pub, data, s); + break; + + default: + error_setg(errp, "Unknown hash algorithm"); + ret =3D -VIRTIO_CRYPTO_NOTSUPP; + goto clear; + } + + if (ret !=3D 1) { + error_setg(errp, "Failed to verify"); + ret =3D -VIRTIO_CRYPTO_KEY_REJECTED; + goto clear; + } + ret =3D 0; + +clear: + mpz_clear(s); + + return ret; +} + +static int qcrypto_nettle_rsa_free(struct QCryptoAkcipher *akcipher, + Error **errp) +{ + qcrypto_nettle_rsa_destroy(akcipher); + + return 0; +} + +QCryptoAkcipherDriver nettle_rsa =3D { + .encrypt =3D qcrypto_nettle_rsa_encrypt, + .decrypt =3D qcrypto_nettle_rsa_decrypt, + .sign =3D qcrypto_nettle_rsa_sign, + .verify =3D qcrypto_nettle_rsa_verify, + .free =3D qcrypto_nettle_rsa_free, +}; + +static QCryptoNettleRsa *qcrypto_nettle_rsa_malloc(void) +{ + QCryptoNettleRsa *rsa =3D g_malloc0(sizeof(QCryptoNettleRsa)); + memset(rsa, 0, sizeof(QCryptoNettleRsa)); + rsa->akcipher.driver =3D &nettle_rsa; + rsa_public_key_init(&rsa->pub); + rsa_private_key_init(&rsa->priv); + + return rsa; +} diff --git a/crypto/akcipher.c b/crypto/akcipher.c index ac8d1c9bf1..f5bdc35e18 100644 --- a/crypto/akcipher.c +++ b/crypto/akcipher.c @@ -24,6 +24,12 @@ #include "qapi/error.h" #include "crypto/akcipher.h" =20 +QCryptoAkcipher *qcrypto_akcipher_nettle_new(uint32_t alg, bool private, + const uint8_t *key, + size_t keylen, + void *para, + int index, Error **errp); + QCryptoAkcipher *qcrypto_akcipher_new(uint32_t alg, bool private, const uint8_t *key, size_t keylen, void *para, @@ -31,6 +37,13 @@ QCryptoAkcipher *qcrypto_akcipher_new(uint32_t alg, bool= private, { QCryptoAkcipher *akcipher =3D NULL; =20 +#ifdef CONFIG_HOGWEED + akcipher =3D qcrypto_akcipher_nettle_new(alg, private, key, keylen, + para, index, errp); +#else + error_setg(errp, "qcrypto akcipher has no nettle/hogweed support"); +#endif + return akcipher; } =20 diff --git a/crypto/asn1_decoder.c b/crypto/asn1_decoder.c new file mode 100644 index 0000000000..bfb145e84e --- /dev/null +++ b/crypto/asn1_decoder.c @@ -0,0 +1,185 @@ +/* + * QEMU Crypto akcipher algorithms + * + * Copyright (c) 2022 Bytedance + * Author: lei he + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + * + */ + +#include +#include + +#include "crypto/asn1_decoder.h" + +enum ber_type_tag { + ber_type_tag_bool =3D 0x1, + ber_type_tag_int =3D 0x2, + ber_type_tag_bit_str =3D 0x3, + ber_type_tag_oct_str =3D 0x4, + ber_type_tag_oct_null =3D 0x5, + ber_type_tag_oct_oid =3D 0x6, + ber_type_tag_seq =3D 0x10, + ber_type_tag_set =3D 0x11, +}; + +#define BER_CONSTRUCTED_MASK 0x20 +#define BER_SHORT_LEN_MASK 0x80 + +static uint8_t ber_peek_byte(const uint8_t **data, size_t *dlen) +{ + return **data; +} + +static int invoke_callback(BerDecodeCb cb, void *ctx, + const uint8_t *value, size_t vlen) +{ + if (!cb) { + return 0; + } + + return cb(ctx, value, vlen); +} + +static void ber_cut_nbytes(const uint8_t **data, size_t *dlen, + size_t nbytes) +{ + *data +=3D nbytes; + *dlen -=3D nbytes; +} + +static uint8_t ber_cut_byte(const uint8_t **data, size_t *dlen) +{ + uint8_t val =3D ber_peek_byte(data, dlen); + + ber_cut_nbytes(data, dlen, 1); + + return val; +} + +static int ber_extract_definite_data(const uint8_t **data, size_t *dlen, + BerDecodeCb cb, void *ctx) +{ + const uint8_t *value; + size_t vlen =3D 0; + uint8_t byte_count =3D ber_cut_byte(data, dlen); + + /* short format of definite-length */ + if (!(byte_count & BER_SHORT_LEN_MASK)) { + if (byte_count > *dlen) { + return -1; + } + + value =3D *data; + vlen =3D byte_count; + ber_cut_nbytes(data, dlen, vlen); + + return invoke_callback(cb, ctx, value, vlen); + } + + /* Ignore highest bit */ + byte_count &=3D ~BER_SHORT_LEN_MASK; + + /* + * size_t is enough to express the length, although the ber encoding + * standard supports larger length. + */ + if (byte_count > sizeof(size_t)) { + return -1; + } + + while (byte_count--) { + vlen <<=3D 8; + vlen +=3D ber_cut_byte(data, dlen); + } + + if (vlen > *dlen) { + return -1; + } + + value =3D *data; + ber_cut_nbytes(data, dlen, vlen); + + return invoke_callback(cb, ctx, value, vlen); +} + +static int ber_extract_undefinite_data(const uint8_t **data, size_t *dlen, + BerDecodeCb cb, void *ctx) +{ + size_t vlen =3D 0; + const uint8_t *value; + + if (*dlen < 3) { + return -1; + } + + /* skip undefinite-length-mask 0x80 */ + ber_cut_nbytes(data, dlen, 1); + + value =3D *data; + while (vlen < *dlen) { + if ((*data)[vlen] !=3D 0) { + vlen++; + continue; + } + + if (vlen + 1 < *dlen && (*data[vlen + 1] =3D=3D 0)) { + ber_cut_nbytes(data, dlen, vlen + 2); + return invoke_callback(cb, ctx, value, vlen); + } + + vlen +=3D 2; + } + + return -1; +} + +static int ber_extract_data(const uint8_t **data, size_t *dlen, + BerDecodeCb cb, void *ctx) +{ + uint8_t val =3D ber_peek_byte(data, dlen); + + if (val =3D=3D BER_SHORT_LEN_MASK) { + return ber_extract_undefinite_data(data, dlen, cb, ctx); + } + + return ber_extract_definite_data(data, dlen, cb, ctx); +} + +int ber_decode_int(const uint8_t **data, size_t *dlen, + BerDecodeCb cb, void *ctx) +{ + uint8_t tag =3D ber_cut_byte(data, dlen); + + /* INTEGER must encoded in primitive-form */ + if (tag !=3D ber_type_tag_int) { + return -1; + } + + return ber_extract_data(data, dlen, cb, ctx); +} + +int ber_decode_seq(const uint8_t **data, size_t *dlen, + BerDecodeCb cb, void *ctx) +{ + uint8_t val =3D ber_cut_byte(data, dlen); + + /* SEQUENCE must use constructed form */ + if (val !=3D (ber_type_tag_seq | BER_CONSTRUCTED_MASK)) { + return -1; + } + + return ber_extract_data(data, dlen, cb, ctx); +} diff --git a/crypto/asn1_decoder.h b/crypto/asn1_decoder.h new file mode 100644 index 0000000000..d33a7c81c4 --- /dev/null +++ b/crypto/asn1_decoder.h @@ -0,0 +1,42 @@ +/* + * QEMU Crypto akcipher algorithms + * + * Copyright (c) 2022 Bytedance + * Author: lei he + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + * + */ + +#ifndef QCRYPTO_ASN1_DECODER_H +#define QCRYPTO_ASN1_DECODER_H + +/* + * ctx: user content. + * value: the starting address of |value| part of 'Tag-Length-Value' patt= ern. + * vlen: length of the |value|. + */ +typedef int (*BerDecodeCb) (void *ctx, const uint8_t *value, size_t vlen); + +int ber_decode_int(const uint8_t **data, + size_t *dlen, + BerDecodeCb cb, + void *ctx); + +int ber_decode_seq(const uint8_t **data, + size_t *dlen, + BerDecodeCb cb, + void *ctx); + +#endif /* QCRYPTO_ASN1_DECODER_H */ diff --git a/crypto/meson.build b/crypto/meson.build index 72b36f450a..28d14cb153 100644 --- a/crypto/meson.build +++ b/crypto/meson.build @@ -27,6 +27,9 @@ if nettle.found() if xts =3D=3D 'private' crypto_ss.add(files('xts.c')) endif + if hogweed.found() + crypto_ss.add(gmp, hogweed, files('akcipher-nettle.c', 'asn1_decoder.c= ')) + endif elif gcrypt.found() crypto_ss.add(gcrypt, files('hash-gcrypt.c', 'hmac-gcrypt.c', 'pbkdf-gcr= ypt.c')) elif gnutls_crypto.found() diff --git a/meson.build b/meson.build index 333c61deba..373c04fecb 100644 --- a/meson.build +++ b/meson.build @@ -1023,6 +1023,7 @@ endif # gcrypt over nettle for performance reasons. gcrypt =3D not_found nettle =3D not_found +hogweed =3D not_found xts =3D 'none' =20 if get_option('nettle').enabled() and get_option('gcrypt').enabled() @@ -1060,6 +1061,14 @@ if not gnutls_crypto.found() endif endif =20 +gmp =3D dependency('gmp', required: false, method: 'pkg-config', kwargs: s= tatic_kwargs) +if nettle.found() and gmp.found() + hogweed =3D dependency('hogweed', version: '>=3D3.4', + method: 'pkg-config', + required: get_option('nettle'), + kwargs: static_kwargs) +endif + gtk =3D not_found gtkx11 =3D not_found vte =3D not_found @@ -1512,6 +1521,7 @@ config_host_data.set('CONFIG_GNUTLS', gnutls.found()) config_host_data.set('CONFIG_GNUTLS_CRYPTO', gnutls_crypto.found()) config_host_data.set('CONFIG_GCRYPT', gcrypt.found()) config_host_data.set('CONFIG_NETTLE', nettle.found()) +config_host_data.set('CONFIG_HOGWEED', hogweed.found()) config_host_data.set('CONFIG_QEMU_PRIVATE_XTS', xts =3D=3D 'private') config_host_data.set('CONFIG_MALLOC_TRIM', has_malloc_trim) config_host_data.set('CONFIG_STATX', has_statx) @@ -3406,6 +3416,7 @@ summary_info +=3D {'libgcrypt': gcrypt} summary_info +=3D {'nettle': nettle} if nettle.found() summary_info +=3D {' XTS': xts !=3D 'private'} + summary_info +=3D {' hogweed': hogweed.found()} endif summary_info +=3D {'crypto afalg': config_host.has_key('CONFIG_AF_ALG= ')} summary_info +=3D {'rng-none': config_host.has_key('CONFIG_RNG_NO= NE')} --=20 2.25.1