pjsip-pjproject/tests/fuzz/fuzz-crypto.c

/* 
 * Copyright (C) 2023 Teluu Inc. (http://www.teluu.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

#include <pjlib.h>
#include <pjlib-util.h>

#define OPENSSL_SUPPRESS_DEPRECATED 1
#include <openssl/bio.h>
#include <openssl/evp.h>
#include <openssl/sha.h>
#include <openssl/md5.h>
#include <zlib.h>

#define kMinInputLength 10
#define kMaxInputLength 1024

#define MAXSIZE 5120

void encode_base64_differential(const uint8_t *Data, size_t Size) {

    //PJSIP
    char pj_output[MAXSIZE];
    int  pj_output_len = MAXSIZE;

    memset(pj_output, 0, MAXSIZE);
    pj_base64_encode(Data, Size, pj_output, &pj_output_len);

    //OPENSSL
    BIO *bio, *bio_mem;
    char *ssl_output = NULL;
    int  ssl_output_len;

    bio = BIO_new(BIO_f_base64());
    BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);

    bio_mem = BIO_new(BIO_s_mem());
    BIO_push(bio, bio_mem);

    BIO_write(bio, Data, Size);
    BIO_flush(bio);

    ssl_output_len = BIO_get_mem_data(bio_mem, &ssl_output);
    if (ssl_output_len <= 0) {
        abort();
    }

    //Differential
    int result = memcmp(pj_output, ssl_output, ssl_output_len);
    if(result != 0){
        abort();
    }
    BIO_free_all(bio);

    //PJSIP Decode After encode.
    pj_str_t pj_input;
    uint8_t pj_output_dec[MAXSIZE];
    int     pj_output_dec_len = MAXSIZE;

    pj_input.ptr = pj_output;
    pj_input.slen = ssl_output_len;

    memset(pj_output_dec, 0, MAXSIZE);
    pj_base64_decode(&pj_input, pj_output_dec, &pj_output_dec_len);

    //Differential
    int result_dec = memcmp(pj_output_dec, Data, Size);
    if(result_dec != 0) {
        abort();
    }
}

void decode_base64_differential(const uint8_t *Data, size_t Size) {

    //PJSIP
    pj_str_t pj_input;
    uint8_t pj_output[MAXSIZE];
    int  pj_output_len = MAXSIZE;

    pj_input.ptr = (char *)Data;
    pj_input.slen = Size;

    memset(pj_output, 0, MAXSIZE);
    pj_base64_decode(&pj_input, pj_output, &pj_output_len);
}

void md5_differential(const uint8_t *Data, size_t Size) {

    //PJSIP
    pj_md5_context ctx;
    pj_uint8_t pj_md5_hash[MD5_DIGEST_LENGTH];

    pj_md5_init(&ctx);
    pj_md5_update(&ctx, Data,Size);
    pj_md5_final(&ctx, pj_md5_hash);

    //OPENSSL
    uint8_t ssl_md5_hash[MD5_DIGEST_LENGTH] = {};
    MD5(Data, Size, ssl_md5_hash);

    //Differential
    int result = memcmp(pj_md5_hash, ssl_md5_hash, MD5_DIGEST_LENGTH);
    if(result != 0){
        abort();
    }
}

void sha1_differential(const uint8_t *Data, size_t Size) {

    //PJSIP
    pj_sha1_context pj_sha;
    pj_uint8_t pj_sha_hash[SHA_DIGEST_LENGTH];

    pj_sha1_init(&pj_sha);
    pj_sha1_update(&pj_sha,Data,Size);
    pj_sha1_final(&pj_sha,pj_sha_hash);

    //OPENSSL
    uint8_t ssl_sha_hash[SHA_DIGEST_LENGTH] = {};

    SHA_CTX ctx;
    SHA1_Init(&ctx);
    SHA1_Update(&ctx,Data,Size);
    SHA1_Final(ssl_sha_hash, &ctx);

    //Differential
    int result = memcmp(pj_sha_hash, ssl_sha_hash, SHA_DIGEST_LENGTH);
    if(result != 0){
        abort();
    }
}

void crc32_differential(const uint8_t *Data, size_t Size) {

    //PJSIP
    pj_uint32_t pj_crc;
    pj_crc = pj_crc32_calc(Data, Size);

    //zlib
    uint32_t    zlib_crc;
    zlib_crc = crc32(0L, Data, Size);

    //Differential
    if (pj_crc != zlib_crc) {
        abort();
    }
}

extern int
LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size)
{

    if (Size < kMinInputLength || Size > kMaxInputLength) {
        return 1;
    }

    encode_base64_differential(Data, Size);
    decode_base64_differential(Data, Size);
    md5_differential(Data, Size);
    sha1_differential(Data, Size);
    crc32_differential(Data, Size);

    return 0;
}