rte_crypto_sym.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2016-2020 Intel Corporation
 */
 
#ifndef _RTE_CRYPTO_SYM_H_
#define _RTE_CRYPTO_SYM_H_
 
#include <string.h>
 
#include <rte_compat.h>
#include <rte_mbuf.h>
#include <rte_memory.h>
#include <rte_mempool.h>
#include <rte_common.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct rte_crypto_vec {
    void *base;
    rte_iova_t iova;
    uint32_t len;
    uint32_t tot_len;
};
 
struct rte_crypto_sgl {
    struct rte_crypto_vec *vec;
    uint32_t num;
};
 
struct rte_crypto_va_iova_ptr {
    void *va;
    rte_iova_t iova;
};
 
struct rte_crypto_sym_vec {
    uint32_t num;
    struct rte_crypto_sgl *src_sgl;
    struct rte_crypto_sgl *dest_sgl;
    struct rte_crypto_va_iova_ptr *iv;
    struct rte_crypto_va_iova_ptr *digest;
 
    __extension__
    union {
        struct rte_crypto_va_iova_ptr *auth_iv;
        struct rte_crypto_va_iova_ptr *aad;
    };
 
    int32_t *status;
};
 
union rte_crypto_sym_ofs {
    uint64_t raw;
    struct {
        struct {
            uint16_t head;
            uint16_t tail;
        } auth, cipher;
    } ofs;
};
 
enum rte_crypto_cipher_algorithm {
    RTE_CRYPTO_CIPHER_NULL = 1,
    RTE_CRYPTO_CIPHER_3DES_CBC,
    RTE_CRYPTO_CIPHER_3DES_CTR,
    RTE_CRYPTO_CIPHER_3DES_ECB,
    RTE_CRYPTO_CIPHER_AES_CBC,
    RTE_CRYPTO_CIPHER_AES_CTR,
    RTE_CRYPTO_CIPHER_AES_ECB,
    RTE_CRYPTO_CIPHER_AES_F8,
    RTE_CRYPTO_CIPHER_AES_XTS,
    RTE_CRYPTO_CIPHER_ARC4,
    RTE_CRYPTO_CIPHER_KASUMI_F8,
    RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
    RTE_CRYPTO_CIPHER_ZUC_EEA3,
    RTE_CRYPTO_CIPHER_DES_CBC,
    RTE_CRYPTO_CIPHER_AES_DOCSISBPI,
    RTE_CRYPTO_CIPHER_DES_DOCSISBPI,
    RTE_CRYPTO_CIPHER_SM4_ECB,
    RTE_CRYPTO_CIPHER_SM4_CBC,
    RTE_CRYPTO_CIPHER_SM4_CTR,
    RTE_CRYPTO_CIPHER_SM4_OFB,
    RTE_CRYPTO_CIPHER_SM4_CFB,
    RTE_CRYPTO_CIPHER_SM4_XTS
};
 
enum rte_crypto_cipher_operation {
    RTE_CRYPTO_CIPHER_OP_ENCRYPT,
    RTE_CRYPTO_CIPHER_OP_DECRYPT
};
 
extern const char *
rte_crypto_cipher_operation_strings[];
 
struct rte_crypto_cipher_xform {
    enum rte_crypto_cipher_operation op;
    enum rte_crypto_cipher_algorithm algo;
    struct {
        const uint8_t *data;    
        uint16_t length;    
    } key;
    struct {
        uint16_t offset;
        uint16_t length;
    } iv;   
    uint32_t dataunit_len;
};
 
enum rte_crypto_auth_algorithm {
    RTE_CRYPTO_AUTH_NULL = 1,
    RTE_CRYPTO_AUTH_AES_CBC_MAC,
    RTE_CRYPTO_AUTH_AES_CMAC,
    RTE_CRYPTO_AUTH_AES_GMAC,
    RTE_CRYPTO_AUTH_AES_XCBC_MAC,
    RTE_CRYPTO_AUTH_KASUMI_F9,
    RTE_CRYPTO_AUTH_MD5,
    RTE_CRYPTO_AUTH_MD5_HMAC,
    RTE_CRYPTO_AUTH_SHA1,
    RTE_CRYPTO_AUTH_SHA1_HMAC,
    RTE_CRYPTO_AUTH_SHA224,
    RTE_CRYPTO_AUTH_SHA224_HMAC,
    RTE_CRYPTO_AUTH_SHA256,
    RTE_CRYPTO_AUTH_SHA256_HMAC,
    RTE_CRYPTO_AUTH_SHA384,
    RTE_CRYPTO_AUTH_SHA384_HMAC,
    RTE_CRYPTO_AUTH_SHA512,
    RTE_CRYPTO_AUTH_SHA512_HMAC,
    RTE_CRYPTO_AUTH_SNOW3G_UIA2,
    RTE_CRYPTO_AUTH_ZUC_EIA3,
    RTE_CRYPTO_AUTH_SHA3_224,
    RTE_CRYPTO_AUTH_SHA3_224_HMAC,
    RTE_CRYPTO_AUTH_SHA3_256,
    RTE_CRYPTO_AUTH_SHA3_256_HMAC,
    RTE_CRYPTO_AUTH_SHA3_384,
    RTE_CRYPTO_AUTH_SHA3_384_HMAC,
    RTE_CRYPTO_AUTH_SHA3_512,
    RTE_CRYPTO_AUTH_SHA3_512_HMAC,
    RTE_CRYPTO_AUTH_SM3,
    RTE_CRYPTO_AUTH_SHAKE_128,
    RTE_CRYPTO_AUTH_SHAKE_256,
    RTE_CRYPTO_AUTH_SM3_HMAC,
};
 
enum rte_crypto_auth_operation {
    RTE_CRYPTO_AUTH_OP_VERIFY,  
    RTE_CRYPTO_AUTH_OP_GENERATE 
};
 
extern const char *
rte_crypto_auth_operation_strings[];
 
struct rte_crypto_auth_xform {
    enum rte_crypto_auth_operation op;
    enum rte_crypto_auth_algorithm algo;
    struct {
        const uint8_t *data;    
        uint16_t length;    
    } key;
    struct {
        uint16_t offset;
        uint16_t length;
    } iv;   
    uint16_t digest_length;
};
 
 
enum rte_crypto_aead_algorithm {
    RTE_CRYPTO_AEAD_AES_CCM = 1,
    RTE_CRYPTO_AEAD_AES_GCM,
    RTE_CRYPTO_AEAD_CHACHA20_POLY1305,
    RTE_CRYPTO_AEAD_SM4_GCM,
};
 
enum rte_crypto_aead_operation {
    RTE_CRYPTO_AEAD_OP_ENCRYPT,
    RTE_CRYPTO_AEAD_OP_DECRYPT
};
 
extern const char *
rte_crypto_aead_operation_strings[];
 
struct rte_crypto_aead_xform {
    enum rte_crypto_aead_operation op;
    enum rte_crypto_aead_algorithm algo;
    struct {
        const uint8_t *data;    
        uint16_t length;    
    } key;
 
    struct {
        uint16_t offset;
        uint16_t length;
    } iv;   
    uint16_t digest_length;
 
    uint16_t aad_length;
};
 
enum rte_crypto_sym_xform_type {
    RTE_CRYPTO_SYM_XFORM_NOT_SPECIFIED = 0, 
    RTE_CRYPTO_SYM_XFORM_AUTH,      
    RTE_CRYPTO_SYM_XFORM_CIPHER,        
    RTE_CRYPTO_SYM_XFORM_AEAD       
};
 
/* Structure rte_crypto_sym_xform 8< */
struct rte_crypto_sym_xform {
    struct rte_crypto_sym_xform *next;
    enum rte_crypto_sym_xform_type type
    ; 
    union {
        struct rte_crypto_auth_xform auth;
        struct rte_crypto_cipher_xform cipher;
        struct rte_crypto_aead_xform aead;
    };
};
/* >8 End of structure rte_crypto_sym_xform. */
 
/* Structure rte_crypto_sym_op 8< */
struct rte_crypto_sym_op {
    struct rte_mbuf *m_src; 
    struct rte_mbuf *m_dst; 
    union {
        void *session;
        struct rte_crypto_sym_xform *xform;
    };
 
    union {
        struct {
            struct {
                uint32_t offset;
                uint32_t length;
            } data; 
            struct {
                uint8_t *data;
                rte_iova_t phys_addr;
            } digest; 
            struct {
                uint8_t *data;
                rte_iova_t phys_addr;   
            } aad;
        } aead;
 
        struct {
            struct {
                struct {
                    uint32_t offset;
                    uint32_t length;
                } data; 
            } cipher;
 
            struct {
                struct {
                    uint32_t offset;
                    uint32_t length;
                } data;
                struct {
                    uint8_t *data;
                    rte_iova_t phys_addr;
                } digest; 
            } auth;
        };
    };
};
/* >8 End of structure rte_crypto_sym_op. */
 
 
static inline void
__rte_crypto_sym_op_reset(struct rte_crypto_sym_op *op)
{
    memset(op, 0, sizeof(*op));
}
 
 
static inline struct rte_crypto_sym_xform *
__rte_crypto_sym_op_sym_xforms_alloc(struct rte_crypto_sym_op *sym_op,
        void *priv_data, uint8_t nb_xforms)
{
    struct rte_crypto_sym_xform *xform;
 
    sym_op->xform = xform = (struct rte_crypto_sym_xform *)priv_data;
 
    do {
        xform->type = RTE_CRYPTO_SYM_XFORM_NOT_SPECIFIED;
        xform = xform->next = --nb_xforms > 0 ? xform + 1 : NULL;
    } while (xform);
 
    return sym_op->xform;
}
 
 
static inline int
__rte_crypto_sym_op_attach_sym_session(struct rte_crypto_sym_op *sym_op, void *sess)
{
    sym_op->session = sess;
 
    return 0;
}
 
__rte_experimental
static inline int
rte_crypto_mbuf_to_vec(const struct rte_mbuf *mb, uint32_t ofs, uint32_t len,
    struct rte_crypto_vec vec[], uint32_t num)
{
    uint32_t i;
    struct rte_mbuf *nseg;
    uint32_t left;
    uint32_t seglen;
 
    /* assuming that requested data starts in the first segment */
    RTE_ASSERT(mb->data_len > ofs);
 
    if (mb->nb_segs > num)
        return -mb->nb_segs;
 
    vec[0].base = rte_pktmbuf_mtod_offset(mb, void *, ofs);
    vec[0].iova = rte_pktmbuf_iova_offset(mb, ofs);
    vec[0].tot_len = mb->buf_len - rte_pktmbuf_headroom(mb) - ofs;
 
    /* whole data lies in the first segment */
    seglen = mb->data_len - ofs;
    if (len <= seglen) {
        vec[0].len = len;
        return 1;
    }
 
    /* data spread across segments */
    vec[0].len = seglen;
    left = len - seglen;
    for (i = 1, nseg = mb->next; nseg != NULL; nseg = nseg->next, i++) {
 
        vec[i].base = rte_pktmbuf_mtod(nseg, void *);
        vec[i].iova = rte_pktmbuf_iova(nseg);
        vec[i].tot_len = mb->buf_len - rte_pktmbuf_headroom(mb) - ofs;
 
        seglen = nseg->data_len;
        if (left <= seglen) {
            /* whole requested data is completed */
            vec[i].len = left;
            left = 0;
            i++;
            break;
        }
 
        /* use whole segment */
        vec[i].len = seglen;
        left -= seglen;
    }
 
    RTE_ASSERT(left == 0);
    return i;
}
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* _RTE_CRYPTO_SYM_H_ */