srs/trunk/3rdparty/libsrtp-2-fit/fuzzer/fuzzer.h

#define MAX_KEY_LEN 46
#define EXTRACT(dest, src, srcsize, copysize)                                  \
    {                                                                          \
        memcpy((dest), (src), (copysize));                                     \
        (src) += (copysize);                                                   \
        (srcsize) -= (copysize);                                               \
    }

/* Extract data if src contains sufficient bytes, otherwise go to end */
#define EXTRACT_IF(dest, src, srcsize, copysize)                               \
    {                                                                          \
        if ((srcsize) < (copysize)) {                                          \
            goto end;                                                          \
        } else {                                                               \
            EXTRACT((dest), (src), (srcsize), (copysize));                     \
        }                                                                      \
    }
#include <stdint.h>
#if UINTPTR_MAX == 0xffffffff
#define FUZZ_32BIT
#elif UINTPTR_MAX == 0xffffffffffffffff
#else
#error "Cannot detect word size"
#endif

typedef srtp_err_status_t (
    *fuzz_srtp_func)(srtp_t, void *, int *, uint8_t, unsigned int);
typedef void (*fuzz_srtp_crypto_policy_func)(srtp_crypto_policy_t *);
typedef srtp_err_status_t (*fuzz_srtp_get_length_func)(const srtp_t,
                                                       uint8_t,
                                                       unsigned int,
                                                       uint32_t *);

struct fuzz_srtp_params {
    uint8_t srtp_func;
    uint8_t srtp_crypto_policy_func;
    uint16_t window_size;
    uint8_t allow_repeat_tx;
    uint8_t ssrc_type;
    unsigned int ssrc_value;
    uint8_t key[MAX_KEY_LEN];
    uint8_t mki;
};

static srtp_err_status_t fuzz_srtp_protect(srtp_t srtp_sender,
                                           void *hdr,
                                           int *len,
                                           uint8_t use_mki,
                                           unsigned int mki);
static srtp_err_status_t fuzz_srtp_unprotect(srtp_t srtp_sender,
                                             void *hdr,
                                             int *len,
                                             uint8_t use_mki,
                                             unsigned int mki);
static srtp_err_status_t fuzz_srtp_protect_rtcp(srtp_t srtp_sender,
                                                void *hdr,
                                                int *len,
                                                uint8_t use_mki,
                                                unsigned int mki);
static srtp_err_status_t fuzz_srtp_unprotect_rtcp(srtp_t srtp_sender,
                                                  void *hdr,
                                                  int *len,
                                                  uint8_t use_mki,
                                                  unsigned int mki);
static srtp_err_status_t fuzz_srtp_protect_mki(srtp_t srtp_sender,
                                               void *hdr,
                                               int *len,
                                               uint8_t use_mki,
                                               unsigned int mki);
static srtp_err_status_t fuzz_srtp_protect_rtcp_mki(srtp_t srtp_sender,
                                                    void *hdr,
                                                    int *len,
                                                    uint8_t use_mki,
                                                    unsigned int mki);
static srtp_err_status_t fuzz_srtp_unprotect_mki(srtp_t srtp_sender,
                                                 void *hdr,
                                                 int *len,
                                                 uint8_t use_mki,
                                                 unsigned int mki);
static srtp_err_status_t fuzz_srtp_unprotect_rtcp_mki(srtp_t srtp_sender,
                                                      void *hdr,
                                                      int *len,
                                                      uint8_t use_mki,
                                                      unsigned int mki);

static srtp_err_status_t fuzz_srtp_get_protect_length(const srtp_t srtp_ctx,
                                                      uint8_t use_mki,
                                                      unsigned int mki,
                                                      uint32_t *length);
static srtp_err_status_t fuzz_srtp_get_protect_mki_length(const srtp_t srtp_ctx,
                                                          uint8_t use_mki,
                                                          unsigned int mki,
                                                          uint32_t *length);
static srtp_err_status_t fuzz_srtp_get_protect_rtcp_length(
    const srtp_t srtp_ctx,
    uint8_t use_mki,
    unsigned int mki,
    uint32_t *length);
static srtp_err_status_t fuzz_srtp_get_protect_rtcp_mki_length(
    const srtp_t srtp_ctx,
    uint8_t use_mki,
    unsigned int mki,
    uint32_t *length);

struct fuzz_srtp_func_ext {
    fuzz_srtp_func srtp_func;
    bool protect;
    fuzz_srtp_get_length_func get_length;
};

const struct fuzz_srtp_func_ext srtp_funcs[] = {
    { fuzz_srtp_protect, true, fuzz_srtp_get_protect_length },
    { fuzz_srtp_unprotect, false, NULL },
    { fuzz_srtp_protect_rtcp, true, fuzz_srtp_get_protect_rtcp_length },
    { fuzz_srtp_unprotect_rtcp, false, NULL },
    { fuzz_srtp_protect_mki, true, fuzz_srtp_get_protect_mki_length },
    { fuzz_srtp_unprotect_mki, false, NULL },
    { fuzz_srtp_protect_rtcp_mki, true, fuzz_srtp_get_protect_rtcp_mki_length },
    { fuzz_srtp_unprotect_rtcp_mki, false, NULL }
};

struct fuzz_srtp_crypto_policy_func_ext {
    fuzz_srtp_crypto_policy_func crypto_policy_func;
    const char *name;
};

const struct fuzz_srtp_crypto_policy_func_ext fuzz_srtp_crypto_policies[] = {
    { srtp_crypto_policy_set_rtp_default, "" },
    { srtp_crypto_policy_set_rtcp_default, "" },
    { srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32,
      "srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32" },
    { srtp_crypto_policy_set_aes_cm_128_null_auth,
      "srtp_crypto_policy_set_aes_cm_128_null_auth" },
    { srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32,
      "srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32" },
    { srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80,
      "srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80" },
    { srtp_crypto_policy_set_aes_cm_256_null_auth,
      "srtp_crypto_policy_set_aes_cm_256_null_auth" },
    { srtp_crypto_policy_set_null_cipher_hmac_null,
      "srtp_crypto_policy_set_null_cipher_hmac_null" },
    { srtp_crypto_policy_set_null_cipher_hmac_sha1_80,
      "srtp_crypto_policy_set_null_cipher_hmac_sha1_80" },
#ifdef OPENSSL
    { srtp_crypto_policy_set_aes_cm_192_hmac_sha1_32,
      "srtp_crypto_policy_set_aes_cm_192_hmac_sha1_32" },
    { srtp_crypto_policy_set_aes_cm_192_hmac_sha1_80,
      "srtp_crypto_policy_set_aes_cm_192_hmac_sha1_80" },
    { srtp_crypto_policy_set_aes_cm_192_null_auth,
      "srtp_crypto_policy_set_aes_cm_192_null_auth" },
    { srtp_crypto_policy_set_aes_gcm_128_16_auth,
      "srtp_crypto_policy_set_aes_gcm_128_16_auth" },
    { srtp_crypto_policy_set_aes_gcm_128_8_auth,
      "srtp_crypto_policy_set_aes_gcm_128_8_auth" },
    { srtp_crypto_policy_set_aes_gcm_128_8_only_auth,
      "srtp_crypto_policy_set_aes_gcm_128_8_only_auth" },
    { srtp_crypto_policy_set_aes_gcm_256_16_auth,
      "srtp_crypto_policy_set_aes_gcm_256_16_auth" },
    { srtp_crypto_policy_set_aes_gcm_256_8_auth,
      "srtp_crypto_policy_set_aes_gcm_256_8_auth" },
    { srtp_crypto_policy_set_aes_gcm_256_8_only_auth,
      "srtp_crypto_policy_set_aes_gcm_256_8_only_auth" },
#endif
};

struct fuzz_srtp_ssrc_type_ext {
    srtp_ssrc_type_t srtp_ssrc_type;
    const char *name;
};

const struct fuzz_srtp_ssrc_type_ext fuzz_ssrc_type_map[] = {
    { ssrc_undefined, "ssrc_undefined" },
    { ssrc_specific, "ssrc_specific" },
    { ssrc_any_inbound, "ssrc_any_inbound" },
    { ssrc_any_outbound, "ssrc_any_outbound" },
};