From nobody Sat May 4 10:48:24 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zoho.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 1492074945829125.60396360737604; Thu, 13 Apr 2017 02:15:45 -0700 (PDT) Received: from localhost ([::1]:48140 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cyaqu-00021C-DZ for importer@patchew.org; Thu, 13 Apr 2017 05:15:44 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:33369) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cyaoi-0000h5-7Y for qemu-devel@nongnu.org; Thu, 13 Apr 2017 05:13:33 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1cyaoc-0000GA-Bh for qemu-devel@nongnu.org; Thu, 13 Apr 2017 05:13:28 -0400 Received: from szxga01-in.huawei.com ([45.249.212.187]:3035 helo=dggrg01-dlp.huawei.com) by eggs.gnu.org with esmtps (TLS1.0:RSA_ARCFOUR_SHA1:16) (Exim 4.71) (envelope-from ) id 1cyaoa-0000FA-DX for qemu-devel@nongnu.org; Thu, 13 Apr 2017 05:13:22 -0400 Received: from 172.30.72.55 (EHLO DGGEML402-HUB.china.huawei.com) ([172.30.72.55]) by dggrg01-dlp.huawei.com (MOS 4.4.6-GA FastPath queued) with ESMTP id AMN07995; Thu, 13 Apr 2017 17:11:35 +0800 (CST) Received: from localhost (10.177.18.62) by DGGEML402-HUB.china.huawei.com (10.3.17.38) with Microsoft SMTP Server id 14.3.301.0; Thu, 13 Apr 2017 17:11:23 +0800 From: Gonglei To: , Date: Thu, 13 Apr 2017 17:11:13 +0800 Message-ID: <1492074674-124192-2-git-send-email-arei.gonglei@huawei.com> X-Mailer: git-send-email 2.8.2.windows.1 In-Reply-To: <1492074674-124192-1-git-send-email-arei.gonglei@huawei.com> References: <1492074674-124192-1-git-send-email-arei.gonglei@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.177.18.62] X-CFilter-Loop: Reflected X-Mirapoint-Virus-RAPID-Raw: score=unknown(0), refid=str=0001.0A090206.58EF40C8.008A, ss=1, re=0.000, recu=0.000, reip=0.000, cl=1, cld=1, fgs=0, ip=0.0.0.0, so=2014-11-16 11:51:01, dmn=2013-03-21 17:37:32 X-Mirapoint-Loop-Id: e70ab12ce281f516d7671b64ceac4698 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.4.x-2.6.x [generic] [fuzzy] X-Received-From: 45.249.212.187 Subject: [Qemu-devel] [PATCH v17 1/2] virtio-crypto: Add virtio crypto device specification X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: weidong.huang@huawei.com, mst@redhat.com, jasowang@redhat.com, john.griffin@intel.com, amy.zhanghuimin@huawei.com, Varun.Sethi@freescale.com, denglingli@chinamobile.com, arei.gonglei@hotmail.com, agraf@suse.de, Gonglei , nmorey@kalray.eu, vincent.jardin@6wind.com, Ola.Liljedahl@arm.com, zhbzg@huawei.com, luonengjun@huawei.com, xin.zeng@intel.com, liang.j.ma@intel.com, stefanha@redhat.com, cornelia.huck@de.ibm.com, Jani.Kokkonen@huawei.com, eety.chen@huawei.com, pasic@linux.vnet.ibm.com, brian.a.keating@intel.com, mike.caraman@nxp.com, maoningning@huawei.com, wu.wubin@huawei.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The virtio crypto device is a virtual crypto device (ie. hardware crypto accelerator card). Currently, the virtio crypto device provides the following crypto services: CIPHER, MAC, HASH, and AEAD. In this patch, CIPHER, MAC, HASH, AEAD services are introduced. VIRTIO-153 Signed-off-by: Gonglei CC: Michael S. Tsirkin CC: Cornelia Huck CC: Stefan Hajnoczi CC: Lingli Deng CC: Jani Kokkonen CC: Ola Liljedahl CC: Varun Sethi CC: Zeng Xin CC: Keating Brian CC: Ma Liang J CC: Griffin John CC: Mihai Claudiu Caraman CC: Halil Pasic --- acknowledgements.tex | 1 + content.tex | 2 + virtio-crypto.tex | 1305 ++++++++++++++++++++++++++++++++++++++++++++++= ++++ 3 files changed, 1308 insertions(+) create mode 100644 virtio-crypto.tex diff --git a/acknowledgements.tex b/acknowledgements.tex index 53942b0..6714544 100644 --- a/acknowledgements.tex +++ b/acknowledgements.tex @@ -44,4 +44,5 @@ Patrick Durusau, Technical Advisory Board, OASIS \newline Thomas Huth, Red Hat \newline Yan Vugenfirer, Red Hat / Daynix \newline Kevin Lo, MSI \newline +Halil Pasic, IBM \newline \end{oasistitlesection} diff --git a/content.tex b/content.tex index 4b45678..ab75f78 100644 --- a/content.tex +++ b/content.tex @@ -5750,6 +5750,8 @@ descriptor for the \field{sense_len}, \field{residual= }, \field{status_qualifier}, \field{status}, \field{response} and \field{sense} fields. =20 +\input{virtio-crypto.tex} + \chapter{Reserved Feature Bits}\label{sec:Reserved Feature Bits} =20 Currently there are three device-independent feature bits defined: diff --git a/virtio-crypto.tex b/virtio-crypto.tex new file mode 100644 index 0000000..c73a1ef --- /dev/null +++ b/virtio-crypto.tex @@ -0,0 +1,1305 @@ +\section{Crypto Device}\label{sec:Device Types / Crypto Device} + +The virtio crypto device is a virtual cryptography device as well as a kin= d of +virtual hardware accelerator for virtual machines. The encryption and +decryption requests are placed in any of the data queues and are ultimatel= y handled by the +backend crypto accelerators. The second kind of queue is the control queue= used to create=20 +or destroy sessions for symmetric algorithms and will control some advanced +features in the future. The virtio crypto device provides the following cr= ypto +services: CIPHER, MAC, HASH, and AEAD. + + +\subsection{Device ID}\label{sec:Device Types / Crypto Device / Device ID} + +20 + +\subsection{Virtqueues}\label{sec:Device Types / Crypto Device / Virtqueue= s} + +\begin{description} +\item[0] dataq1 +\item[\ldots] +\item[N-1] dataqN +\item[N] controlq +\end{description} + +N is set by \field{max_dataqueues}. + +\subsection{Feature bits}\label{sec:Device Types / Crypto Device / Feature= bits} + +VIRTIO_CRYPTO_F_STATELESS_MODE (0) stateless mode is available. +VIRTIO_CRYPTO_F_CIPHER_STATELESS_MODE (1) stateless mode is available for = CIPHER service. +VIRTIO_CRYPTO_F_HASH_STATELESS_MODE (2) stateless mode is available for HA= SH service. +VIRTIO_CRYPTO_F_MAC_STATELESS_MODE (3) stateless mode is available for MAC= service. +VIRTIO_CRYPTO_F_AEAD_STATELESS_MODE (4) stateless mode is available for AE= AD service. + +\subsubsection{Feature bit requirements}\label{sec:Device Types / Crypto D= evice / Feature bits} + +Some crypto feature bits require other crypto feature bits +(see \ref{drivernormative:Basic Facilities of a Virtio Device / Feature Bi= ts}): + +\begin{description} +\item[VIRTIO_CRYPTO_F_CIPHER_STATELESS_MODE] Requires VIRTIO_CRYPTO_F_STAT= ELESS_MODE. +\item[VIRTIO_CRYPTO_F_HASH_STATELESS_MODE] Requires VIRTIO_CRYPTO_F_STATEL= ESS_MODE. +\item[VIRTIO_CRYPTO_F_MAC_STATELESS_MODE] Requires VIRTIO_CRYPTO_F_STATELE= SS_MODE. +\item[VIRTIO_CRYPTO_F_AEAD_STATELESS_MODE] Requires VIRTIO_CRYPTO_F_STATEL= ESS_MODE. +\end{description} + +\subsection{Supported crypto services}\label{sec:Device Types / Crypto Dev= ice / Supported crypto services} + +The virtio crypto device provides the following crypto services: CIPHER, M= AC, HASH, and AEAD. + +\begin{lstlisting} +/* CIPHER service */ +#define VIRTIO_CRYPTO_SERVICE_CIPHER 0 +/* HASH service */ +#define VIRTIO_CRYPTO_SERVICE_HASH 1 +/* MAC (Message Authentication Codes) service */ +#define VIRTIO_CRYPTO_SERVICE_MAC 2 +/* AEAD (Authenticated Encryption with Associated Data) service */ +#define VIRTIO_CRYPTO_SERVICE_AEAD 3 +\end{lstlisting} + +The above constants are bit numbers, which used to tell the driver which c= rypto services +are supported by the device, see \ref{sec:Device Types / Crypto Device / D= evice configuration layout}. + +\subsubsection{CIPHER services}\label{sec:Device Types / Crypto Device / S= upported crypto services / CIPHER services} + +The following CIPHER algorithms are defined: + +\begin{lstlisting} +#define VIRTIO_CRYPTO_NO_CIPHER 0 +#define VIRTIO_CRYPTO_CIPHER_ARC4 1 +#define VIRTIO_CRYPTO_CIPHER_AES_ECB 2 +#define VIRTIO_CRYPTO_CIPHER_AES_CBC 3 +#define VIRTIO_CRYPTO_CIPHER_AES_CTR 4 +#define VIRTIO_CRYPTO_CIPHER_DES_ECB 5 +#define VIRTIO_CRYPTO_CIPHER_DES_CBC 6 +#define VIRTIO_CRYPTO_CIPHER_3DES_ECB 7 +#define VIRTIO_CRYPTO_CIPHER_3DES_CBC 8 +#define VIRTIO_CRYPTO_CIPHER_3DES_CTR 9 +#define VIRTIO_CRYPTO_CIPHER_KASUMI_F8 10 +#define VIRTIO_CRYPTO_CIPHER_SNOW3G_UEA2 11 +#define VIRTIO_CRYPTO_CIPHER_AES_F8 12 +#define VIRTIO_CRYPTO_CIPHER_AES_XTS 13 +#define VIRTIO_CRYPTO_CIPHER_ZUC_EEA3 14 +\end{lstlisting} + +The above constants have two usages: +\begin{enumerate} +\item As bit numbers, which used to tell the driver which CIPHER algorithms +are supported by the device, see \ref{sec:Device Types / Crypto Device / D= evice configuration layout}. +\item As values, which used to tell the device which CIPHER algorithm +a crypto request require by the driver, see \ref{sec:Device Types / Crypto= Device / Device Operation / Control Virtqueue / Session operation}. +\end{enumerate} + +\subsubsection{HASH services}\label{sec:Device Types / Crypto Device / Sup= ported crypto services / HASH services} + +The following HASH algorithms are defined: + +\begin{lstlisting} +#define VIRTIO_CRYPTO_NO_HASH 0 +#define VIRTIO_CRYPTO_HASH_MD5 1 +#define VIRTIO_CRYPTO_HASH_SHA1 2 +#define VIRTIO_CRYPTO_HASH_SHA_224 3 +#define VIRTIO_CRYPTO_HASH_SHA_256 4 +#define VIRTIO_CRYPTO_HASH_SHA_384 5 +#define VIRTIO_CRYPTO_HASH_SHA_512 6 +#define VIRTIO_CRYPTO_HASH_SHA3_224 7 +#define VIRTIO_CRYPTO_HASH_SHA3_256 8 +#define VIRTIO_CRYPTO_HASH_SHA3_384 9 +#define VIRTIO_CRYPTO_HASH_SHA3_512 10 +#define VIRTIO_CRYPTO_HASH_SHA3_SHAKE128 11 +#define VIRTIO_CRYPTO_HASH_SHA3_SHAKE256 12 +\end{lstlisting} + +The above constants have two usages: +\begin{enumerate} +\item As bit numbers, which used to tell the driver which HASH algorithms +are supported by the device, see \ref{sec:Device Types / Crypto Device / D= evice configuration layout}. +\item As values, which used to tell the device which HASH algorithm +a crypto request require by the driver, see \ref{sec:Device Types / Crypto= Device / Device Operation / Control Virtqueue / Session operation}. +\end{enumerate} + +\subsubsection{MAC services}\label{sec:Device Types / Crypto Device / Supp= orted crypto services / MAC services} + +The following MAC algorithms are defined: + +\begin{lstlisting} +#define VIRTIO_CRYPTO_NO_MAC 0 +#define VIRTIO_CRYPTO_MAC_HMAC_MD5 1 +#define VIRTIO_CRYPTO_MAC_HMAC_SHA1 2 +#define VIRTIO_CRYPTO_MAC_HMAC_SHA_224 3 +#define VIRTIO_CRYPTO_MAC_HMAC_SHA_256 4 +#define VIRTIO_CRYPTO_MAC_HMAC_SHA_384 5 +#define VIRTIO_CRYPTO_MAC_HMAC_SHA_512 6 +#define VIRTIO_CRYPTO_MAC_CMAC_3DES 25 +#define VIRTIO_CRYPTO_MAC_CMAC_AES 26 +#define VIRTIO_CRYPTO_MAC_KASUMI_F9 27 +#define VIRTIO_CRYPTO_MAC_SNOW3G_UIA2 28 +#define VIRTIO_CRYPTO_MAC_GMAC_AES 41 +#define VIRTIO_CRYPTO_MAC_GMAC_TWOFISH 42 +#define VIRTIO_CRYPTO_MAC_CBCMAC_AES 49 +#define VIRTIO_CRYPTO_MAC_CBCMAC_KASUMI_F9 50 +#define VIRTIO_CRYPTO_MAC_XCBC_AES 53 +#define VIRTIO_CRYPTO_MAC_ZUC_EIA3 54 +\end{lstlisting} + +The above constants have two usages: +\begin{enumerate} +\item As bit numbers, which used to tell the driver which MAC algorithms +are supported by the device, see \ref{sec:Device Types / Crypto Device / D= evice configuration layout}. +\item As values, which used to tell the device which MAC algorithm +a crypto request require by the driver, see \ref{sec:Device Types / Crypto= Device / Device Operation / Control Virtqueue / Session operation}. +\end{enumerate} + +\subsubsection{AEAD services}\label{sec:Device Types / Crypto Device / Sup= ported crypto services / AEAD services} + +The following AEAD algorithms are defined: + +\begin{lstlisting} +#define VIRTIO_CRYPTO_NO_AEAD 0 +#define VIRTIO_CRYPTO_AEAD_GCM 1 +#define VIRTIO_CRYPTO_AEAD_CCM 2 +#define VIRTIO_CRYPTO_AEAD_CHACHA20_POLY1305 3 +\end{lstlisting} + +The above constants have two usages: +\begin{enumerate} +\item As bit numbers, which used to tell the driver which AEAD algorithms +are supported by the device, see \ref{sec:Device Types / Crypto Device / D= evice configuration layout}. +\item As values, which used to tell the device what AEAD algorithm +a crypto request require by the driver, see \ref{sec:Device Types / Crypto= Device / Device Operation / Control Virtqueue / Session operation}. +\end{enumerate} + +\subsection{Device configuration layout}\label{sec:Device Types / Crypto D= evice / Device configuration layout} + +\begin{lstlisting} +struct virtio_crypto_config { + le32 status; + le32 max_dataqueues; + le32 crypto_services; + /* Detailed algorithms mask */ + le32 cipher_algo_l; + le32 cipher_algo_h; + le32 hash_algo; + le32 mac_algo_l; + le32 mac_algo_h; + le32 aead_algo; + /* Maximum length of cipher key in bytes */ + le32 max_cipher_key_len; + /* Maximum length of authenticated key in bytes */ + le32 max_auth_key_len; + le32 reserved; + /* Maximum size of each crypto request's content in bytes */ + le64 max_size; +}; +\end{lstlisting} + +\begin{description} +\item[\field{status}] is used to show whether the device is ready to work = or not, it can be either zero or have one or more flags + Only one read-only bit (for the driver) is currently defined for the \= field{status} field: VIRTIO_CRYPTO_S_HW_READY: +\begin{lstlisting} +#define VIRTIO_CRYPTO_S_HW_READY (1 << 0) +\end{lstlisting} + +\item[\field{max_dataqueues}] is the maximum number of data virtqueues exp= osed by + the device. The driver MAY use only one data queue, + or it can use more to achieve better performance. + +\item[\field{crypto_services}] is a 32-bit mask which indicates the crypto= services supported by + the device, see \ref{sec:Device Types / Crypto Device / Supported cryp= to services}. + +\item[\field{cipher_algo_l}] is the low 32-bit mask wihich indicates the C= IPHER algorithms supported by + the device, see \ref{sec:Device Types / Crypto Device / Supported cryp= to services / CIPHER services}. + +\item[\field{cipher_algo_h}] is the high 32-bit mask wihich indicates the = CIPHER algorithms supported by + the device, see \ref{sec:Device Types / Crypto Device / Supported cryp= to services / CIPHER services}. + +\item[\field{hash_algo}] is a 32-bit mask wihich indicates the HASH algori= thms supported by + the device, see \ref{sec:Device Types / Crypto Device / Supported cryp= to services / HASH services}. + +\item[\field{mac_algo_l}] is the low 32-bit mask wihich indicates the MAC = algorithms supported by + the device, see \ref{sec:Device Types / Crypto Device / Supported cryp= to services / MAC services}. + +\item[\field{mac_algo_h}] is the high 32-bit mask wihich indicates the MAC= algorithms supported by + the device, see \ref{sec:Device Types / Crypto Device / Supported cryp= to services / MAC services}. + +\item[\field{aead_algo}] is a 32-bit mask wihich indicates the AEAD algori= thms supported by + the device, see \ref{sec:Device Types / Crypto Device / Supported cryp= to services / AEAD services}. + +\item[\field{max_cipher_key_len}] is the maximum length of cipher key supp= orted by the device. + +\item[\field{max_auth_key_len}] is the maximum length of authenticated key= supported by the device. + +\item[\field{reserved}] is reserved for future use. + +\item[\field{max_size}] is the maximum size of each crypto request's conte= nt supported by the device +\end{description} + +\begin{note} +Unless explicitly stated otherwise all lengths and sizes are in bytes. +\end{note} + +\devicenormative{\subsubsection}{Device configuration layout}{Device Types= / Crypto Device / Device configuration layout} + +\begin{itemize*} +\item The device MUST set \field{max_dataqueues} to between 1 and 65535 in= clusive. +\item The device MUST set \field{status} based on the status of the backen= d crypto accelerator.=20 +\item The device MUST accept and handle requests after \field{status} is s= et to VIRTIO_CRYPTO_S_HW_READY. +\item The device MUST set \field{crypto_services} based on the crypto serv= ices the device offers. +\item The device MUST set detailed algorithms masks based on the \field{cr= ypto_services} field. +\item The device MUST set \field{max_size} to show the maximum size of cry= pto request the device supports. +\item The device MUST set \field{max_cipher_key_len} to show the maximum l= ength of cipher key if the device supports CIPHER service. +\item The device MUST set \field{max_auth_key_len} to show the maximum len= gth of authenticated key if the device supports MAC service. +\end{itemize*} + +\drivernormative{\subsubsection}{Device configuration layout}{Device Types= / Crypto Device / Device configuration layout} + +\begin{itemize*} +\item The driver MUST read the ready \field{status} from the bottom bit of= status to check whether the backend crypto accelerator + is ready or not, and the driver MUST reread it after the device rese= t.=20 +\item The driver MUST NOT transmit any requests to the device if the ready= \field{status} is not set. +\item The driver MUST read \field{max_dataqueues} field to discover the nu= mber of data queues the device supports. +\item The driver MUST read \field{crypto_services} field to discover which= services the device is able to offer. +\item The driver MUST read the detailed algorithms fields based on \field{= crypto_services} field. +\item The driver SHOULD read \field{max_size} to discover the maximum size= of crypto request the device supports. +\item The driver SHOULD read \field{max_cipher_key_len} to discover the ma= ximum length of cipher key the device supports. +\item The driver SHOULD read \field{max_auth_key_len} to discover the maxi= mum length of authenticated key the device supports. +\end{itemize*} + +\subsection{Device Initialization}\label{sec:Device Types / Crypto Device = / Device Initialization} + +\drivernormative{\subsubsection}{Device Initialization}{Device Types / Cry= pto Device / Device Initialization} + +\begin{itemize*} +\item The driver MUST identify and initialize all virtqueues. +\item The driver MUST read the supported crypto services from bits of \fie= ld{crypto_services}.=20 +\item The driver MUST read the supported algorithms based on \field{crypto= _services} field. +\end{itemize*} + +\subsection{Device Operation}\label{sec:Device Types / Crypto Device / Dev= ice Operation} + +Requests can be transmitted by placing them in both the controlq and dataq. +Requests consist of a queue-type specific header specifying among +others the operation, and an operation specific payload. +Where the payload are composed of operation parameter + output data + inpu= t data in general. +Operation parameters are algorithm-specific parameters, output data is the +data that should be utilized in operations, and input data is equal to +"operation result + result data". + +The device can support both session mode (See \ref{sec:Device Types / Cryp= to Device / Device Operation / Control Virtqueue / Session operation}) and = stateless mode. +As VIRTIO_CRYPTO_F_CIPHER_STATELESS_MODE feature bit is negotiated, the dr= iver can use stateless mode for CIPHER service, otherwise it can only use s= ession mode. + +The header for controlq is as follows: + +\begin{lstlisting} +#define VIRTIO_CRYPTO_OPCODE(service, op) (((service) << 8) | (op)) + +struct virtio_crypto_ctrl_header { +#define VIRTIO_CRYPTO_CIPHER_CREATE_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x02) +#define VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x03) +#define VIRTIO_CRYPTO_HASH_CREATE_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x02) +#define VIRTIO_CRYPTO_HASH_DESTROY_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x03) +#define VIRTIO_CRYPTO_MAC_CREATE_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x02) +#define VIRTIO_CRYPTO_MAC_DESTROY_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x03) +#define VIRTIO_CRYPTO_AEAD_CREATE_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x02) +#define VIRTIO_CRYPTO_AEAD_DESTROY_SESSION \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x03) + le32 opcode; + /* algo should be service-specific algorithms */ + le32 algo; + le32 flag; + /* data virtqueue id */ + le32 queue_id; +}; +\end{lstlisting} + +The header of dataq is as follows: + +\begin{lstlisting} +struct virtio_crypto_op_header { +#define VIRTIO_CRYPTO_CIPHER_ENCRYPT \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x00) +#define VIRTIO_CRYPTO_CIPHER_DECRYPT \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x01) +#define VIRTIO_CRYPTO_HASH \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x00) +#define VIRTIO_CRYPTO_MAC \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x00) +#define VIRTIO_CRYPTO_AEAD_ENCRYPT \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x00) +#define VIRTIO_CRYPTO_AEAD_DECRYPT \ + VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x01) + le32 opcode; + /* algo should be service-specific algorithms */ + le32 algo; + /* session_id should be service-specific algorithms */ + le64 session_id;VIRTIO_CRYPTO_F_STATELESS_MODE +#define VIRTIO_CRYPTO_FLAG_STATE_MODE 1 +#define VIRTIO_CRYPTO_FLAG_STATELESS_MODE 2 + /* control flag to control the request */ + le32 flag; + le32 padding; +}; +\end{lstlisting} + +The device can set the operation status as follows: VIRTIO_CRYPTO_OK: succ= ess; +VIRTIO_CRYPTO_ERR: failure or device error; VIRTIO_CRYPTO_NOTSUPP: not sup= ported; +VIRTIO_CRYPTO_INVSESS: invalid session ID when executing crypto operations. + +\begin{lstlisting} +enum VIRITO_CRYPTO_STATUS { + VIRTIO_CRYPTO_OK =3D 0, + VIRTIO_CRYPTO_ERR =3D 1, + VIRTIO_CRYPTO_BADMSG =3D 2, + VIRTIO_CRYPTO_NOTSUPP =3D 3, + VIRTIO_CRYPTO_INVSESS =3D 4, + VIRTIO_CRYPTO_MAX +}; +\end{lstlisting} + +\subsubsection{Control Virtqueue}\label{sec:Device Types / Crypto Device /= Device Operation / Control Virtqueue} + +The driver uses the control virtqueue to send control commands to the +device, such as session operations (See \ref{sec:Device Types / Crypto Dev= ice / Device Operation / Control Virtqueue / Session operation}). + +The request of controlq is as below: + +\begin{lstlisting} +struct virtio_crypto_op_ctrl_req { + struct virtio_crypto_ctrl_header header; + + union { + struct virtio_crypto_sym_create_session_req sym_create_session; + struct virtio_crypto_hash_create_session_req hash_create_session; + struct virtio_crypto_mac_create_session_req mac_create_session; + struct virtio_crypto_aead_create_session_req aead_create_session; + struct virtio_crypto_destroy_session_req destroy_session; + } u; +}; +\end{lstlisting} + +struct virtio_crypto_op_ctrl_req is the only loading form of controlq requ= ests. +The header is the general header, and the union is of the algorithm-specif= ic type, +which is set by the driver. All the properties in the union are shown as f= ollows. + +\paragraph{Session operation}\label{sec:Device Types / Crypto Device / Dev= ice Operation / Control Virtqueue / Session operation} + +The symmetric algorithms involve the concept of sessions. A session is a +handle which describes the cryptographic parameters to be applied to +a number of buffers. The data within a session handle includes: + +\begin{enumerate} +\item The operation (CIPHER, HASH/MAC or both, and if both, the order in + which the algorithms should be applied). +\item The CIPHER set data, including the CIPHER algorithm and mode, + the key and its length, and the direction (encryption or decryption). +\item The HASH/MAC set data, including the HASH algorithm or MAC algorithm, + and hash result length (to allow for truncation). +\begin{itemize*} +\item Authenticated mode can refer to MAC, which requires that the key and + its length are also specified. +\item For nested mode, the inner and outer prefix data and length are spec= ified, + as well as the outer HASH algorithm. +\end{itemize*} +\end{enumerate} + +The following structure stores the result of session creation set by the d= evice: + +\begin{lstlisting} +struct virtio_crypto_session_input { + /* Device-writable part */ + le64 session_id; + le32 status; + le32 padding; +}; +\end{lstlisting} + +A request to destroy a session includes the following information: + +\begin{lstlisting} +struct virtio_crypto_destroy_session_req { + /* Device-readable part */ + le64 session_id; + /* Device-writable part */ + le32 status; + le32 padding; +}; +\end{lstlisting} + +\subparagraph{Session operation: HASH session}\label{sec:Device Types / Cr= ypto Device / Device +Operation / Control Virtqueue / Session operation / Session operation: HAS= H session} + +The request of HASH session is as follows: + +\begin{lstlisting} +struct virtio_crypto_hash_session_para { + /* See VIRTIO_CRYPTO_HASH_* above */ + le32 algo; + /* hash result length */ + le32 hash_result_len; +}; +struct virtio_crypto_hash_create_session_req { + /* Device-readable part */ + struct virtio_crypto_hash_session_para para; + /* Device-writable part */ + struct virtio_crypto_session_input input; +}; +\end{lstlisting} + +\subparagraph{Session operation: MAC session}\label{sec:Device Types / Cry= pto Device / Device +Operation / Control Virtqueue / Session operation / Session operation: MAC= session} + +The request of MAC session is as follows: + +\begin{lstlisting} +struct virtio_crypto_mac_session_para { + /* See VIRTIO_CRYPTO_MAC_* above */ + le32 algo; + /* hash result length */ + le32 hash_result_len; + /* length of authenticated key */ + le32 auth_key_len; + le32 padding; +}; + +struct virtio_crypto_mac_create_session_req { + /* Device-readable part */ + struct virtio_crypto_mac_session_para para; + /* The authenticated key */ + u8 auth_key[auth_key_len]; + + /* Device-writable part */ + struct virtio_crypto_session_input input; +}; +\end{lstlisting} + +\subparagraph{Session operation: Symmetric algorithms session}\label{sec:D= evice Types / Crypto Device / Device +Operation / Control Virtqueue / Session operation / Session operation: Sym= metric algorithms session} + +The request of symmetric session includes two parts, CIPHER algorithms and= chain +algorithms (chaining CIPHER and HASH/MAC). The request for CIPHER session = is as follows: + +\begin{lstlisting} +struct virtio_crypto_cipher_session_para { + /* See VIRTIO_CRYPTO_CIPHER* above */ + le32 algo; + /* length of key */ + le32 keylen; +#define VIRTIO_CRYPTO_OP_ENCRYPT 1 +#define VIRTIO_CRYPTO_OP_DECRYPT 2 + /* encryption or decryption */ + le32 op; + le32 padding; +}; + +struct virtio_crypto_cipher_session_req { + /* Device-readable part */ + struct virtio_crypto_cipher_session_para para; + /* The cipher key */ + u8 cipher_key[keylen]; + + /* Device-writable part */ + struct virtio_crypto_session_input input; +}; +\end{lstlisting} + +The request for algorithm chaining is as follows: + +\begin{lstlisting} +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 + le32 alg_chain_order; +/* Plain hash */ +#define VIRTIO_CRYPTO_SYM_HASH_MODE_PLAIN 1 +/* Authenticated hash (mac) */ +#define VIRTIO_CRYPTO_SYM_HASH_MODE_AUTH 2 +/* Nested hash */ +#define VIRTIO_CRYPTO_SYM_HASH_MODE_NESTED 3 + le32 hash_mode; + struct virtio_crypto_cipher_session_para cipher_param; + union { + struct virtio_crypto_hash_session_para hash_param; + struct virtio_crypto_mac_session_para mac_param; + } u; + /* length of the additional authenticated data (AAD) in bytes */ + le32 aad_len; + le32 padding; +}; + +struct virtio_crypto_alg_chain_session_req { + /* Device-readable part */ + struct virtio_crypto_alg_chain_session_para para; + /* The cipher key */ + u8 cipher_key[keylen]; + /* The authenticated key */ + u8 auth_key[auth_key_len]; + + /* Device-writable part */ + struct virtio_crypto_session_input input; +}; +\end{lstlisting} + +The request for symmetric algorithm is as follows: + +\begin{lstlisting} +struct virtio_crypto_sym_create_session_req { + union { + struct virtio_crypto_cipher_session_req cipher; + struct virtio_crypto_alg_chain_session_req chain; + } u; + + /* Device-readable part */ + +/* No operation */ +#define VIRTIO_CRYPTO_SYM_OP_NONE 0 +/* Cipher only operation on the data */ +#define VIRTIO_CRYPTO_SYM_OP_CIPHER 1 +/* Chain any cipher with any hash or mac operation. The order + depends on the value of alg_chain_order param */ +#define VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING 2 + le32 op_type; + le32 padding; +}; +\end{lstlisting} + +\subparagraph{Session operation: AEAD session}\label{sec:Device Types / Cr= ypto Device / Device +Operation / Control Virtqueue / Session operation / Session operation: AEA= D session} + +The request for AEAD session is as follows: + +\begin{lstlisting} +struct virtio_crypto_aead_session_para { + /* See VIRTIO_CRYPTO_AEAD_* above */ + le32 algo; + /* length of key */ + le32 key_len; + /* Authentication tag length */ + le32 tag_len; + /* The length of the additional authenticated data (AAD) in bytes */ + le32 aad_len; + /* encryption or decryption, See above VIRTIO_CRYPTO_OP_* */ + le32 op; + le32 padding; +}; + +struct virtio_crypto_aead_create_session_req { + /* Device-readable part */ + struct virtio_crypto_aead_session_para para; + u8 key[key_len]; + + /* Device-writeable part */ + struct virtio_crypto_session_input input; +}; +\end{lstlisting} + +\drivernormative{\subparagraph}{Session operation: create session}{Device = Types / Crypto Device / Device Operation / Control Virtqueue / Session oper= ation / Session operation: create session} + +\begin{itemize*} +\item The driver MUST set the control general header and corresponding pro= perties of the union in structure virtio_crypto_op_ctrl_req. See \ref{sec:D= evice Types / Crypto Device / Device Operation / Control Virtqueue}. +\item The driver MUST set \field{opcode} field based on service type: CIPH= ER, HASH, MAC, or AEAD. +\item The driver MUST set \field{queue_id} field to show used dataq. +\end{itemize*} + +\devicenormative{\subparagraph}{Session operation: create session}{Device = Types / Crypto Device / Device +Operation / Control Virtqueue / Session operation / Session operation: cre= ate session} + +\begin{itemize*} +\item The device MUST set \field{session_id} field as a session identifier= return to the driver when the device finishes processing session creation. +\item The device MUST set \field{status} field to one of the values of enu= m VIRITO_CRYPTO_STATUS. +\end{itemize*} + +\drivernormative{\subparagraph}{Session operation: destroy session}{Device= Types / Crypto Device / Device +Operation / Control Virtqueue / Session operation / Session operation: des= troy session} + +\begin{itemize*} +\item The driver MUST set \field{opcode} field based on service type: CIPH= ER, HASH, MAC, or AEAD. +\item The driver MUST set the \field{session_id} to a valid value which as= signed by the device when a session is created. +\end{itemize*} + +\devicenormative{\subparagraph}{Session operation: destroy session}{Device= Types / Crypto Device / Device +Operation / Control Virtqueue / Session operation / Session operation: des= troy session} + +\begin{itemize*} +\item The device MUST set \field{status} field to one of the values of enu= m VIRITO_CRYPTO_STATUS. +\end{itemize*} + +\subsubsection{Data Virtqueue}\label{sec:Device Types / Crypto Device / De= vice Operation / Data Virtqueue} + +The driver uses the data virtqueue to transmit the requests of crypto oper= ation to the device, +and completes the data plane operations (such as crypto operation). + +The session mode request of dataq is as follows: + +\begin{lstlisting} +struct virtio_crypto_op_data_req { + struct virtio_crypto_op_header header; + + union { + struct virtio_crypto_sym_data_req sym_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; + } u; +}; +\end{lstlisting} + +The request of dataq, mixing both session and stateless mode is as follows: + +\begin{lstlisting} +struct virtio_crypto_op_data_req_mux { + struct virtio_crypto_op_header header; + + union { + struct virtio_crypto_sym_data_req sym_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_sym_data_req_stateless sym_stateless_req; + struct virtio_crypto_hash_data_req_stateless hash_stateless_req; + struct virtio_crypto_mac_data_req_stateless mac_stateless_req; + struct virtio_crypto_aead_data_req_stateless aead_stateless_req; + } u; +}; +\end{lstlisting} + +The header is the general header and the union is of the algorithm-specifi= c type, +which is set by the driver. All properties in the union are shown as follo= ws. + +There is a unified input header structure for all crypto services. + +The structure is defined as follows: + +\begin{lstlisting} +struct virtio_crypto_inhdr { + u8 status; +}; +\end{lstlisting} + +\subsubsection{HASH Service Operation}\label{sec:Device Types / Crypto Dev= ice / Device Operation / HASH Service Operation} + +The session mode request of HASH service: + +\begin{lstlisting} +struct virtio_crypto_hash_para { + /* length of source data */ + le32 src_data_len; + /* hash result length */ + le32 hash_result_len; +}; + +struct virtio_crypto_hash_data_req { + /* Device-readable part */ + struct virtio_crypto_hash_para para; + /* Source data */ + u8 src_data[src_data_len]; + + /* Device-writable part */ + /* Hash result data */ + u8 hash_result[hash_result_len]; + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +Each data request uses virtio_crypto_hash_data_req structure to store info= rmation +used to run the HASH operations.=20 + +The information includes the hash parameters stored by \field{para}, outpu= t data and input data. +The output data here includes the source data and the input data includes = the hash result data used to save the results of the HASH operations. +\field{inhdr} stores status of executing the HASH operations. + +The stateless mode request of HASH service is as follows: + +\begin{lstlisting} +struct virtio_crypto_hash_para_statelesss { + struct { + /* See VIRTIO_CRYPTO_HASH_* above */ + le32 algo; + } sess_para; + + /* length of source data */ + le32 src_data_len; + /* hash result length */ + le32 hash_result_len; + le32 reserved; +}; +struct virtio_crypto_hash_data_req_stateless { + /* Device-readable part */ + struct virtio_crypto_hash_para_stateless para; + /* Source data */ + u8 src_data[src_data_len]; + + /* Device-writable part */ + /* Hash result data */ + u8 hash_result[hash_result_len]; + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +\drivernormative{\paragraph}{HASH Service Operation}{Device Types / Crypto= Device / Device Operation / HASH Service Operation} + +\begin{itemize*} +\item If the driver uses the session mode, then the driver MUST set the \f= ield{session_id} in struct virtio_crypto_op_header + to a valid value which assigned by the device when a session is crea= ted. +\item If the VIRTIO_CRYPTO_F_STATELESS_MODE feature bit is negotiated, the= driver MUST use the struct virtio_crypto_op_data_req_mux to wrap crypto re= quests. Otherwise, the driver MUST use the struct virtio_crypto_op_data_req. +\item If the VIRTIO_CRYPTO_F_HASH_STATELESS_MODE feature bit is negotiated= , 1) if the driver use the stateless mode, then the driver MUST set \field{= flag} field in struct virtio_crypto_op_header + to VIRTIO_CRYPTO_FLAG_STATELESS_MODE and MUST set fields in struct v= irtio_crypto_hash_para_statelession.sess_para, 2) if the driver still uses = the session mode, then the driver MUST set \field{flag} field in struct vir= tio_crypto_op_header to VIRTIO_CRYPTO_FLAG_STATE_MODE. +\item The driver MUST set \field{opcode} in struct virtio_crypto_op_header= to VIRTIO_CRYPTO_HASH. +\end{itemize*} + +\devicenormative{\paragraph}{HASH Service Operation}{Device Types / Crypto= Device / Device Operation / HASH Service Operation} + +\begin{itemize*} +\item If the VIRTIO_CRYPTO_F_STATELESS_MODE feature bit is negotiated, the= device MUST parse the struct virtio_crypto_op_data_req_mux for crypto requ= ests. Otherwise, the device MUST parse the struct virtio_crypto_op_data_req. +\item If the VIRTIO_CRYPTO_F_HASH_STATELESS_MODE feature bit is negotiated= , the device MUST parse \field{flag} field in struct virtio_crypto_op_heade= r in order to decide which mode the driver uses. +\item The device MUST copy the results of HASH operations to the hash_resu= lt[] if HASH operations success. +\item The device MUST set \field{status} in struct virtio_crypto_inhdr to = one of the values of enum VIRITO_CRYPTO_STATUS. +\end{itemize*} + +\subsubsection{MAC Service Operation}\label{sec:Device Types / Crypto Devi= ce / Device Operation / MAC Service Operation} + +The session mode request of MAC service is as follows: + +\begin{lstlisting} +struct virtio_crypto_mac_para { + struct virtio_crypto_hash_para hash; +}; + +struct virtio_crypto_mac_data_req { + /* Device-readable part */ + struct virtio_crypto_mac_para para; + /* Source data */ + u8 src_data[src_data_len]; + + /* Device-writable part */ + /* Hash result data */ + u8 hash_result[hash_result_len]; + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +Each data request uses virtio_crypto_mac_data_req structure to store infor= mation +used to run the MAC operations.=20 + +The information includes the hash parameters stored by \field{para}, outpu= t data and input data. +The output data here includes the source data and the input data includes = the hash result data used to save the results of the MAC operations. +\field{inhdr} stores status of executing the MAC operations. + +The stateless mode request of MAC service: + +\begin{lstlisting} +struct virtio_crypto_mac_para_stateless { + struct { + /* See VIRTIO_CRYPTO_MAC_* above */ + le32 algo; + /* length of authenticated key */ + le32 auth_key_len; + } sess_para; + + /* length of source data */ + le32 src_data_len; + /* hash result length */ + le32 hash_result_len; +}; + +struct virtio_crypto_mac_data_req_stateless { + /* Device-readable part */ + struct virtio_crypto_mac_para_stateless para; + /* The authenticated key */ + u8 auth_key[auth_key_len]; + /* Source data */ + u8 src_data[src_data_len]; + + /* Device-writable part */ + /* Hash result data */ + u8 hash_result[hash_result_len]; + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +\drivernormative{\paragraph}{MAC Service Operation}{Device Types / Crypto = Device / Device Operation / MAC Service Operation} + +\begin{itemize*} +\item If the driver uses the session mode, then the driver MUST set the \f= ield{session_id} in struct virtio_crypto_op_header + to a valid value which assigned by the device when a session is crea= ted. +\item If the VIRTIO_CRYPTO_F_STATELESS_MODE feature bit is negotiated, the= driver MUST use the struct virtio_crypto_op_data_req_mux to wrap crypto re= quests. Otherwise, the driver MUST use the struct virtio_crypto_op_data_req. +\item If the VIRTIO_CRYPTO_F_MAC_STATELESS_MODE feature bit is negotiated,= 1) if the driver use the stateless mode, then the driver MUST set \field{f= lag} field in struct virtio_crypto_op_header + to VIRTIO_CRYPTO_FLAG_STATELESS_MODE and MUST set fields in struct v= irtio_crypto_mac_para_statelession.sess_para, 2) if the driver still uses t= he session mode, then the driver MUST set \field{flag} field in struct virt= io_crypto_op_header to VIRTIO_CRYPTO_FLAG_STATE_MODE. +\item The driver MUST set \field{opcode} in struct virtio_crypto_op_header= to VIRTIO_CRYPTO_MAC. +\end{itemize*} + +\devicenormative{\paragraph}{MAC Service Operation}{Device Types / Crypto = Device / Device Operation / MAC Service Operation} + +\begin{itemize*} +\item If the VIRTIO_CRYPTO_F_STATELESS_MODE feature bit is negotiated, the= device MUST parse the struct virtio_crypto_op_data_req_mux for crypto requ= ests. Otherwise, the device MUST parse the struct virtio_crypto_op_data_req. +\item If the VIRTIO_CRYPTO_F_MAC_STATELESS_MODE feature bit is negotiated,= the device MUST parse \field{flag} field in struct virtio_crypto_op_header= in order to decide which mode the driver uses. +\item The device MUST copy the results of MAC operations to the hash_resul= t[] if HASH operations success. +\item The device MUST set \field{status} in struct virtio_crypto_inhdr to = one of the values of enum VIRITO_CRYPTO_STATUS. +\end{itemize*} + +\subsubsection{Symmetric algorithms Operation}\label{sec:Device Types / Cr= ypto Device / Device Operation / Symmetric algorithms Operation} + +The session mode request of plain CIPHER service is as follows: + +\begin{lstlisting} +struct virtio_crypto_cipher_para { + /* + * Byte Length of valid IV/Counter data pointed to by the below iv dat= a. + * + * For block ciphers in CBC or F8 mode, or for Kasumi in F8 mode, or f= or + * SNOW3G in UEA2 mode, this is the length of the IV (which + * must be the same as the block length of the cipher). + * For block ciphers in CTR mode, this is the length of the counter + * (which must be the same as the block length of the cipher). + */ + le32 iv_len; + /* length of source data */ + le32 src_data_len; + /* length of destination data */ + le32 dst_data_len; + le32 padding; +}; + +struct virtio_crypto_cipher_data_req { + /* Device-readable part */ + struct virtio_crypto_cipher_para para; + /* + * Initialization Vector or Counter data. + * + * For block ciphers in CBC or F8 mode, or for Kasumi in F8 mode, or f= or + * SNOW3G in UEA2 mode, this is the Initialization Vector (IV) + * value. + * For block ciphers in CTR mode, this is the counter. + * For AES-XTS, this is the 128bit tweak, i, from IEEE Std 1619-2007. + * + * The IV/Counter will be updated after every partial cryptographic + * operation. + */ + u8 iv[iv_len]; + /* Source data */ + u8 src_data[src_data_len]; + + /* Device-writable part */ + /* Destination data */ + u8 dst_data[dst_data_len]; + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +The session mode request of algorithm chaining is as follows: + +\begin{lstlisting} +struct virtio_crypto_alg_chain_data_para { + le32 iv_len; + /* Length of source data */ + le32 src_data_len; + /* Length of destination data */ + le32 dst_data_len; + /* Starting point for cipher processing in source data */ + le32 cipher_start_src_offset; + /* Length of the source data that the cipher will be computed on */ + le32 len_to_cipher; + /* Starting point for hash processing in source data */ + le32 hash_start_src_offset; + /* Length of the source data that the hash will be computed on */ + le32 len_to_hash; + /* Length of the additional auth data */ + le32 aad_len; + /* Length of the hash result */ + le32 hash_result_len; + le32 reserved; +}; + +struct virtio_crypto_alg_chain_data_req { + /* Device-readable part */ + struct virtio_crypto_alg_chain_data_para para; + /* Initialization Vector or Counter data */ + u8 iv[iv_len]; + /* Source data */ + u8 src_data[src_data_len]; + /* Additional authenticated data if exists */ + u8 aad[aad_len]; + + /* Device-writable part */ + /* Destination data */ + u8 dst_data[dst_data_len]; + /* Hash result data */ + u8 hash_result[hash_result_len]; + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +The session mode request of symmetric algorithm is as follows: + +\begin{lstlisting} +struct virtio_crypto_sym_data_req { + union { + struct virtio_crypto_cipher_data_req cipher; + struct virtio_crypto_alg_chain_data_req chain; + } u; + + /* Device-readable part */ + + /* See above VIRTIO_CRYPTO_SYM_OP_* */ + le32 op_type; + le32 padding; +}; +\end{lstlisting} + +Each data request uses virtio_crypto_sym_data_req structure to store infor= mation +used to run the CIPHER operations.=20 + +The information includes the cipher parameters stored by \field{para}, out= put data and input data. +In the first virtio_crypto_cipher_para structure, \field{iv_len} specifies= the length of the initialization vector or counter, +\field{src_data_len} specifies the length of the source data, and \field{d= st_data_len} specifies the +length of the destination data.=20 +For plain CIPHER operations, the output data here includes the IV/Counter = data and source data, and the input data includes the destination data used= to save the results of the CIPHER operations.=20 + +For algorithms chain, the output data here includes the IV/Counter data, s= ource data and additional authenticated data if exists. +The input data includes both destination data and hash result data used to= store the results of the HASH/MAC operations. +\field{inhdr} stores status of executing the crypto operations. + +The stateless mode request of plain CIPHER service is as follows: + +\begin{lstlisting} +struct virtio_crypto_cipher_para_stateless { + struct { + /* See VIRTIO_CRYPTO_CIPHER* above */ + le32 algo; + /* length of key */ + le32 keylen; + + /* See VIRTIO_CRYPTO_OP_* above */ + le32 op; + } sess_para; + + /* + * Byte Length of valid IV/Counter data pointed to by the below iv dat= a. + */ + le32 iv_len; + /* length of source data */ + le32 src_data_len; + /* length of destination data */ + le32 dst_data_len; +}; + +struct virtio_crypto_cipher_data_req_stateless { + /* Device-readable part */ + struct virtio_crypto_cipher_para_stateless para; + /* The cipher key */ + u8 cipher_key[keylen]; + + /* Initialization Vector or Counter data. */ + u8 iv[iv_len]; + /* Source data */ + u8 src_data[src_data_len]; + + /* Device-writable part */ + /* Destination data */ + u8 dst_data[dst_data_len]; + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +The stateless mode request of algorithm chaining is as follows: + +\begin{lstlisting} +struct virtio_crypto_alg_chain_data_para_stateless { + struct { + /* See VIRTIO_CRYPTO_SYM_ALG_CHAIN_ORDER_* above */ + le32 alg_chain_order; + /* length of the additional authenticated data in bytes */ + le32 aad_len; + + struct { + /* See VIRTIO_CRYPTO_CIPHER* above */ + le32 algo; + /* length of key */ + le32 keylen; + /* See VIRTIO_CRYPTO_OP_* above */ + le32 op; + } cipher; + + struct { + /* See VIRTIO_CRYPTO_HASH_* or VIRTIO_CRYPTO_MAC_* above */ + le32 algo; + /* length of authenticated key */ + le32 auth_key_len; + /* See VIRTIO_CRYPTO_SYM_HASH_MODE_* above */ + le32 hash_mode; + } hash; + } sess_para; + + le32 iv_len; + /* Length of source data */ + le32 src_data_len; + /* Length of destination data */ + le32 dst_data_len; + /* Starting point for cipher processing in source data */ + le32 cipher_start_src_offset; + /* Length of the source data that the cipher will be computed on */ + le32 len_to_cipher; + /* Starting point for hash processing in source data */ + le32 hash_start_src_offset; + /* Length of the source data that the hash will be computed on */ + le32 len_to_hash; + /* Length of the additional auth data */ + le32 aad_len; + /* Length of the hash result */ + le32 hash_result_len; + le32 reserved; +}; + +struct virtio_crypto_alg_chain_data_req_stateless { + /* Device-readable part */ + struct virtio_crypto_alg_chain_data_para_stateless para; + /* The cipher key */ + u8 cipher_key[keylen]; + /* The auth key */ + u8 auth_key[auth_key_len]; + /* Initialization Vector or Counter data */ + u8 iv[iv_len]; + /* Source data */ + u8 src_data[src_data_len]; + /* Additional authenticated data if exists */ + u8 aad[aad_len]; + + /* Device-writable part */ + /* Destination data */ + u8 dst_data[dst_data_len]; + /* Hash result data */ + u8 hash_result[hash_result_len]; + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +The stateless mode request of symmetric algorithm is as follows: + +\begin{lstlisting} +struct virtio_crypto_sym_data_req_stateless { + union { + struct virtio_crypto_cipher_data_req_stateless cipher; + struct virtio_crypto_alg_chain_data_req_stateless chain; + } u; + + /* Device-readable part */ + + /* See above VIRTIO_CRYPTO_SYM_OP_* */ + le32 op_type; + le32 padding; +}; +\end{lstlisting} + +\drivernormative{\paragraph}{Symmetric algorithms Operation}{Device Types = / Crypto Device / Device Operation / Symmetric algorithms Operation} + +\begin{itemize*} +\item If the driver uses the session mode, then the driver MUST set the \f= ield{session_id} in struct virtio_crypto_op_header + to a valid value which assigned by the device when a session is crea= ted. +\item If the VIRTIO_CRYPTO_F_STATELESS_MODE feature bit is negotiated, the= driver MUST use the struct virtio_crypto_op_data_req_mux to wrap crypto re= quests. Otherwise, the driver MUST use the struct virtio_crypto_op_data_req. +\item If the VIRTIO_CRYPTO_F_CIPHER_STATELESS_MODE feature bit is negotiat= ed, 1) if the driver use the stateless mode, then the driver MUST set \fiel= d{flag} field in struct virtio_crypto_op_header + to VIRTIO_CRYPTO_FLAG_STATELESS_MODE and MUST set fields in struct v= irtio_crypto_cipher_para_statelession.sess_para or struct virtio_crypto_alg= _chain_data_para_stateless.sess_para, 2) if the driver still uses the sessi= on mode, then the driver MUST set \field{flag} field in struct virtio_crypt= o_op_header to VIRTIO_CRYPTO_FLAG_STATE_MODE. +\item The driver MUST set \field{opcode} in struct virtio_crypto_op_header= to VIRTIO_CRYPTO_CIPHER_ENCRYPT or VIRTIO_CRYPTO_CIPHER_DECRYPT. +\item The driver MUST specify the fields of struct virtio_crypto_cipher_da= ta_req in struct virtio_crypto_sym_data_req if the request is based on VIRT= IO_CRYPTO_SYM_OP_CIPHER. +\item The driver MUST specify the fields of both struct virtio_crypto_ciph= er_data_req and struct virtio_crypto_mac_data_req in struct virtio_crypto_s= ym_data_req if the request + is of the VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING type and in the VI= RTIO_CRYPTO_SYM_HASH_MODE_AUTH mode. +\end{itemize*} + +\devicenormative{\paragraph}{Symmetric algorithms Operation}{Device Types = / Crypto Device / Device Operation / Symmetric algorithms Operation} + +\begin{itemize*} +\item If the VIRTIO_CRYPTO_F_STATELESS_MODE feature bit is negotiated, the= device MUST parse the struct virtio_crypto_op_data_req_mux for crypto requ= ests. Otherwise, the device MUST parse the struct virtio_crypto_op_data_req. +\item If the VIRTIO_CRYPTO_F_CIPHER_STATELESS_MODE feature bit is negotiat= ed, the device MUST parse \field{flag} field in struct virtio_crypto_op_hea= der in order to decide which mode the driver uses. +\item The device MUST parse the virtio_crypto_sym_data_req based on the \f= ield{opcode} in general header. +\item The device SHOULD only parse fields of struct virtio_crypto_cipher_d= ata_req in struct virtio_crypto_sym_data_req if the request is VIRTIO_CRYPT= O_SYM_OP_CIPHER type. +\item The device MUST parse fields of both struct virtio_crypto_cipher_dat= a_req and struct virtio_crypto_mac_data_req in struct virtio_crypto_sym_dat= a_req if the request + is of the VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING operation type and= in the VIRTIO_CRYPTO_SYM_HASH_MODE_AUTH mode. +\item The device MUST copy the result of cryptographic operation to the ds= t_data[] in both plain CIPHER mode and algorithms chain mode. +\item The device MUST check the \field{para}.\field{add_len} is bigger tha= n 0 before parse the additional authenticated data in plain algorithms chai= n mode. +\item The device MUST copy the result of HASH/MAC operation to the hash_re= sult[] is of the VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING type. +\item The device MUST set the \field{status} field in struct virtio_crypto= _inhdr to one of the values of enum VIRITO_CRYPTO_STATUS. +\end{itemize*} + +\paragraph{Steps of Operation}\label{sec:Device Types / Crypto Device / De= vice Operation / Symmetric algorithms Operation / Steps of Operation} + +\subparagraph{Step1: Create session}\label{sec:Device Types / Crypto Devic= e / Device Operation / Symmetric algorithms Operation / Steps of Operation = / Step1: Create session on session mode} + +\begin{enumerate} +\item The driver specifies information in struct virtio_crypto_op_ctrl_req= , including the algorithm name, key, keylen etc; +\item The driver adds the request of session creation into the controlq's = Vring Descriptor Table; +\item The driver kicks the device; +\item The device receives the request from controlq; +\item The device parses information about the request, and determines the = information concerning the backend crypto accelerator; +\item The device packs information based on the APIs of the backend crypto= accelerator; +\item The device invokes the session creation APIs of the backend crypto a= ccelerator to create a session; +\item The device returns the session id to the driver. +\end{enumerate} + +\subparagraph{Step2: Execute cryptographic operation}\label{sec:Device Typ= es / Crypto Device / Device Operation / Symmetric algorithms Operation / St= eps of Operation / Step2: Execute cryptographic operation} + +\begin{enumerate} +\item The driver specifies information in struct virtio_crypto_op_data_req= , including struct virtio_crypto_op_header and struct virtio_crypto_sym_dat= a_req, see \ref{sec:Device Types / Crypto Device / Device + Operation / Symmetric algorithms Operation}; +\item The driver adds the request for cryptographic operation into the dat= aq's Vring Descriptor Table; +\item The driver kicks the device (Or the device actively polls the dataq'= s Vring Descriptor Table); +\item The device receives the request from dataq; +\item The device parses information about the request, and determines the = identification information for the backend crypto accelerator. For example,= converting guest physical addresses to host physical addresses; +\item The device packs identification information based on the API of the = backend crypto accelerator; +\item The device invokes the cryptographic APIs of the backend crypto acce= lerator; +\item The backend crypto accelerator executes the cryptographic operation = implicitly; +\item The device receives the cryptographic results from the backend crypt= o accelerator (synchronous or asynchronous); +\item The device sets the \field{status} in struct virtio_crypto_inhdr; +\item The device updates and flushes the Used Ring to return the cryptogra= phic results to the driver; +\item The device notifies the driver (Or the driver actively polls the dat= aq's Used Ring); +\item The driver saves the cryptographic results. +\end{enumerate} + +\begin{note} +\begin{itemize*} +\item For better performance, the device should by preference use vhost sc= heme (user space or kernel space) + as the backend crypto accelerator in the real production environment. +\end{itemize*} +\end{note} + +\subsubsection{AEAD Service Operation}\label{sec:Device Types / Crypto Dev= ice / Device Operation / AEAD Service Operation} + +The session mode request of symmetric algorithm is as follows: + +\begin{lstlisting} +struct virtio_crypto_aead_para { + /* + * Byte Length of valid IV data. + * + * For GCM mode, this is either 12 (for 96-bit IVs) or 16, in which + * case iv points to J0. + * For CCM mode, this is the length of the nonce, which can be in the + * range 7 to 13 inclusive. + */ + le32 iv_len; + /* length of additional auth data */ + le32 aad_len; + /* length of source data */ + le32 src_data_len; + /* length of dst data, this should be at least src_data_len + tag_len = */ + le32 dst_data_len; + /* Authentication tag length */ + le32 tag_len; + le32 reserved; +}; + +struct virtio_crypto_aead_data_req { + /* Device-readable part */ + struct virtio_crypto_aead_para para; + /* + * Initialization Vector data. + * + * For GCM mode, this is either the IV (if the length is 96 bits) or J0 + * (for other sizes), where J0 is as defined by NIST SP800-38D. + * Regardless of the IV length, a full 16 bytes needs to be allocate= d. + * For CCM mode, the first byte is reserved, and the nonce should be + * written starting at &iv[1] (to allow space for the implementation + * to write in the flags in the first byte). Note that a full 16 by= tes + * should be allocated, even though the iv_len field will have + * a value less than this. + * + * The IV will be updated after every partial cryptographic operation. + */ + u8 iv[iv_len]; + /* Source data */ + u8 src_data[src_data_len]; + /* Additional authenticated data if exists */ + u8 aad[aad_len]; + + /* Device-writable part */ + /* Pointer to output data */ + u8 dst_data[dst_data_len]; + + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +Each data request uses virtio_crypto_aead_data_req structure to store info= rmation +used to run the AEAD operations.=20 + +The information includes the hash parameters stored by \field{para}, outpu= t data and input data. +In the first virtio_crypto_aead_para structure, \field{iv_len} specifies t= he length of the initialization vector. \field{tag_len} specifies the lengt= h of the authentication tag; +\field{aad_len} specifies the length of additional authentication data, \f= ield{src_data_len} specifies the +length of the source data; \field{dst_data_len} specifies the length of th= e destination data, which is at least \field{src_data_len} + \field{tag_len= }. + +The output data here includes the IV/Counter data, source data and additio= nal authenticated data if exists. +The input data includes both destination data used to save the results of = the AEAD operations. +\field{inhdr} stores status of executing the AEAD operations. + +The stateless mode request of AEAD service is as follows: + +\begin{lstlisting} +struct virtio_crypto_aead_para_stateless { + struct { + /* See VIRTIO_CRYPTO_AEAD_* above */ + le32 algo; + /* length of key */ + le32 key_len; + /* encrypt or decrypt, See above VIRTIO_CRYPTO_OP_* */ + le32 op; + } sess_para; + + /* Byte Length of valid IV data. */ + le32 iv_len; + /* Authentication tag length */ + le32 tag_len; + /* length of additional auth data */ + le32 aad_len; + /* length of source data */ + le32 src_data_len; + /* length of dst data, this should be at least src_data_len + tag_len = */ + le32 dst_data_len; +}; + +struct virtio_crypto_aead_data_req_stateless { + /* Device-readable part */ + struct virtio_crypto_aead_para_stateless para; + /* The cipher key */ + u8 key[key_len]; + /* Initialization Vector data. */ + u8 iv[iv_len]; + /* Source data */ + u8 src_data[src_data_len]; + /* Additional authenticated data if exists */ + u8 aad[aad_len]; + + /* Device-writable part */ + /* Pointer to output data */ + u8 dst_data[dst_data_len]; + + struct virtio_crypto_inhdr inhdr; +}; +\end{lstlisting} + +\drivernormative{\paragraph}{AEAD Service Operation}{Device Types / Crypto= Device / Device Operation / AEAD Service Operation} + +\begin{itemize*} +\item If the driver uses the session mode, then the driver MUST set the \f= ield{session_id} in struct virtio_crypto_op_header + to a valid value which assigned by the device when a session is crea= ted. +\item If the VIRTIO_CRYPTO_F_STATELESS_MODE feature bit is negotiated, the= driver MUST use the struct virtio_crypto_op_data_req_mux to wrap crypto re= quests. Otherwise, the driver MUST use the struct virtio_crypto_op_data_req. +\item If the VIRTIO_CRYPTO_F_AEAD_STATELESS_MODE feature bit is negotiated= , 1) if the driver use the stateless mode, then the driver MUST set \field{= flag} field in struct virtio_crypto_op_header + to VIRTIO_CRYPTO_FLAG_STATELESS_MODE and MUST set fields in struct v= irtio_crypto_aead_para_statelession.sess_para, 2) if the driver still uses = the session mode, then the driver MUST set \field{flag} field in struct vir= tio_crypto_op_header to VIRTIO_CRYPTO_FLAG_STATE_MODE. +\item The driver MUST set \field{opcode} in struct virtio_crypto_op_header= to VIRTIO_CRYPTO_AEAD_ENCRYPT or VIRTIO_CRYPTO_AEAD_DECRYPT. +\end{itemize*} + +\devicenormative{\paragraph}{AEAD Service Operation}{Device Types / Crypto= Device / Device Operation / AEAD Service Operation} + +\begin{itemize*} +\item If the VIRTIO_CRYPTO_F_STATELESS_MODE feature bit is negotiated, the= device MUST parse the struct virtio_crypto_op_data_req_mux for crypto requ= ests. Otherwise, the device MUST parse the struct virtio_crypto_op_data_req. +\item If the VIRTIO_CRYPTO_F_AEAD_STATELESS_MODE feature bit is negotiated= , the device MUST parse the virtio_crypto_aead_data_req based on the \field= {opcode} in general header. +\item The device MUST copy the result of cryptographic operation to the ds= t_data[]. +\item The device MUST copy the authentication tag to the dst_data[] offset= the cipher result. +\item The device MUST set the \field{status} field in struct virtio_crypto= _inhdr to one of the values of enum VIRITO_CRYPTO_STATUS. +\item When the \field{opcode} is VIRTIO_CRYPTO_AEAD_DECRYPT, the device MU= ST verify and return the verification result to the driver, and if the veri= fication result is incorrect, VIRTIO_CRYPTO_BADMSG (bad message) MUST be re= turned to the driver. +\end{itemize*} \ No newline at end of file --=20 1.7.12.4 From nobody Sat May 4 10:48:24 2024 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zoho.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 1492074868424741.3035403727356; Thu, 13 Apr 2017 02:14:28 -0700 (PDT) Received: from localhost ([::1]:48131 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cyapf-0001Da-33 for importer@patchew.org; Thu, 13 Apr 2017 05:14:27 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:33325) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cyaoU-0000Xz-S3 for qemu-devel@nongnu.org; Thu, 13 Apr 2017 05:13:16 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1cyaoS-0000Dg-NL for qemu-devel@nongnu.org; Thu, 13 Apr 2017 05:13:14 -0400 Received: from szxga01-in.huawei.com ([45.249.212.187]:3034 helo=dggrg01-dlp.huawei.com) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cyaoS-0000DF-3z for qemu-devel@nongnu.org; Thu, 13 Apr 2017 05:13:12 -0400 Received: from 172.30.72.55 (EHLO DGGEML402-HUB.china.huawei.com) ([172.30.72.55]) by dggrg01-dlp.huawei.com (MOS 4.4.6-GA FastPath queued) with ESMTP id AMN07988; Thu, 13 Apr 2017 17:11:35 +0800 (CST) Received: from localhost (10.177.18.62) by DGGEML402-HUB.china.huawei.com (10.3.17.38) with Microsoft SMTP Server id 14.3.301.0; Thu, 13 Apr 2017 17:11:23 +0800 From: Gonglei To: , Date: Thu, 13 Apr 2017 17:11:14 +0800 Message-ID: <1492074674-124192-3-git-send-email-arei.gonglei@huawei.com> X-Mailer: git-send-email 2.8.2.windows.1 In-Reply-To: <1492074674-124192-1-git-send-email-arei.gonglei@huawei.com> References: <1492074674-124192-1-git-send-email-arei.gonglei@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.177.18.62] X-CFilter-Loop: Reflected X-Mirapoint-Virus-RAPID-Raw: score=unknown(0), refid=str=0001.0A020203.58EF40C8.008B, ss=1, re=0.000, recu=0.000, reip=0.000, cl=1, cld=1, fgs=0, ip=0.0.0.0, so=2014-11-16 11:51:01, dmn=2013-03-21 17:37:32 X-Mirapoint-Loop-Id: ace5dc476c444cd624147dc55015dbb0 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.4.x-2.6.x [generic] [fuzzy] X-Received-From: 45.249.212.187 Subject: [Qemu-devel] [PATCH v17 2/2] virtio-crypto: Add conformance clauses X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: weidong.huang@huawei.com, mst@redhat.com, jasowang@redhat.com, john.griffin@intel.com, amy.zhanghuimin@huawei.com, Varun.Sethi@freescale.com, denglingli@chinamobile.com, arei.gonglei@hotmail.com, agraf@suse.de, Gonglei , nmorey@kalray.eu, vincent.jardin@6wind.com, Ola.Liljedahl@arm.com, zhbzg@huawei.com, luonengjun@huawei.com, xin.zeng@intel.com, liang.j.ma@intel.com, stefanha@redhat.com, cornelia.huck@de.ibm.com, Jani.Kokkonen@huawei.com, eety.chen@huawei.com, pasic@linux.vnet.ibm.com, brian.a.keating@intel.com, mike.caraman@nxp.com, maoningning@huawei.com, wu.wubin@huawei.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add the conformance targets and clauses for virtio-crypto device. Signed-off-by: Gonglei --- conformance.tex | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/conformance.tex b/conformance.tex index f59e360..7c7a55c 100644 --- a/conformance.tex +++ b/conformance.tex @@ -146,6 +146,21 @@ An SCSI host driver MUST conform to the following norm= ative statements: \item \ref{drivernormative:Device Types / SCSI Host Device / Device Operat= ion / Device Operation: eventq} \end{itemize} =20 +\subsection{Crypto Driver Conformance}\label{sec:Conformance / Driver Conf= ormance / Crypto Driver Conformance} + +An Crypto driver MUST conform to the following normative statements: + +\begin{itemize} +\item \ref{drivernormative:Device Types / Crypto Device / Device configura= tion layout} +\item \ref{drivernormative:Device Types / Crypto Device / Device Initializ= ation} +\item \ref{drivernormative:Device Types / Crypto Device / Device Operation= / Control Virtqueue / Session operation / Session operation: create sessio= n} +\item \ref{drivernormative:Device Types / Crypto Device / Device Operation= / Control Virtqueue / Session operation / Session operation: destroy sessi= on} +\item \ref{drivernormative:Device Types / Crypto Device / Device Operation= / HASH Service operation} +\item \ref{drivernormative:Device Types / Crypto Device / Device Operation= / MAC Service operation} +\item \ref{drivernormative:Device Types / Crypto Device / Device Operation= / Symmetric algorithms Operation} +\item \ref{drivernormative:Device Types / Crypto Device / Device Operation= / AEAD Service operation} +\end{itemize} + \section{Device Conformance}\label{sec:Conformance / Device Conformance} =20 A device MUST conform to the following normative statements: @@ -267,6 +282,20 @@ An SCSI host device MUST conform to the following norm= ative statements: \item \ref{devicenormative:Device Types / SCSI Host Device / Device Operat= ion / Device Operation: eventq} \end{itemize} =20 +\subsection{Crypto Device Conformance}\label{sec:Conformance / Device Conf= ormance / Crypto Device Conformance} + +An Crypto device MUST conform to the following normative statements: + +\begin{itemize} +\item \ref{devicenormative:Device Types / Crypto Device / Device configura= tion layout} +\item \ref{devicenormative:Device Types / Crypto Device / Device Operation= / Control Virtqueue / Session operation / Session operation: create sessio= n} +\item \ref{devicenormative:Device Types / Crypto Device / Device Operation= / Control Virtqueue / Session operation / Session operation: destroy sessi= on} +\item \ref{devicenormative:Device Types / Crypto Device / Device Operation= / HASH Service operation} +\item \ref{devicenormative:Device Types / Crypto Device / Device Operation= / MAC Service operation} +\item \ref{devicenormative:Device Types / Crypto Device / Device Operation= / Symmetric algorithms Operation} +\item \ref{devicenormative:Device Types / Crypto Device / Device Operation= / AEAD Service operation} +\end{itemize} + \section{Legacy Interface: Transitional Device and Transitional Driver Conformance}\label{sec:Conformance / Legacy Interface: Transitional Device and=20 --=20 1.7.12.4