bignum_fuzzer_importer.cpp

#include <cryptofuzz/bignum_fuzzer_importer.h>
#include <cryptofuzz/repository.h>
#include <cryptofuzz/operations.h>
#include <cryptofuzz/util.h>
#include <cryptofuzz/crypto.h>
#include <stdio.h>
#include <fstream>
#include "config.h"

namespace cryptofuzz {

Bignum_Fuzzer_Importer::Bignum_Fuzzer_Importer(const std::string filename, const std::string outDir) :
    filename(filename), outDir(outDir) {
}

void Bignum_Fuzzer_Importer::Run(void) {
    std::ifstream instream(filename, std::ios::in | std::ios::binary);
    std::vector<uint8_t> data((std::istreambuf_iterator<char>(instream)), std::istreambuf_iterator<char>());

    LoadInput(data);
}

static std::string bignum_from_bin(const uint8_t* data, size_t size) {
    std::string ret;
    for (size_t i = 0; i < size; i++) {
        ret += data[i] % 10 + '0';
    }

    return ret;
}

void Bignum_Fuzzer_Importer::LoadInput(const std::vector<uint8_t> data) {
    uint8_t bignums[4][1200];

    if ( data.size() < sizeof(bignums) ) {
        return;
    }

    memcpy(bignums, data.data(), sizeof(bignums));

    const auto bn1 = bignum_from_bin(bignums[0], 1200);
    const auto bn2 = bignum_from_bin(bignums[1], 1200);
    const auto bn3 = bignum_from_bin(bignums[2], 1200);
    const auto bn4 = bignum_from_bin(bignums[3], 1200);

    const std::vector<uint64_t> calcops = {
        CF_CALCOP("Add(A,B)"),
        CF_CALCOP("Sub(A,B)"),
        CF_CALCOP("Mul(A,B)"),
        CF_CALCOP("Div(A,B)"),
        CF_CALCOP("Mod(A,B)"),
        CF_CALCOP("ExpMod(A,B,C)"),
        CF_CALCOP("LShift1(A)"),
        CF_CALCOP("RShift(A,B)"),
        CF_CALCOP("RShift(A,B)"),
        CF_CALCOP("GCD(A,B)"),
        CF_CALCOP("AddMod(A,B,C)"),
        CF_CALCOP("Exp(A,B)"),
        CF_CALCOP("Cmp(A,B)"),
        CF_CALCOP("Sqr(A)"),
        CF_CALCOP("Neg(A)"),
        CF_CALCOP("Abs(A)"),
        CF_CALCOP("IsPrime(A)"),
        CF_CALCOP("SubMod(A,B,C)"),
        CF_CALCOP("MulMod(A,B,C)"),
        CF_CALCOP("SetBit(A,B)"),
    };

    for (const auto& calcop : calcops) {
        nlohmann::json parameters;

        parameters["modifier"] = "";
        parameters["calcOp"] = calcop;
        parameters["bn1"] = bn1;
        parameters["bn2"] = bn2;
        parameters["bn3"] = bn3;
        parameters["bn4"] = bn4;

        fuzzing::datasource::Datasource dsOut2(nullptr, 0);
        cryptofuzz::operation::BignumCalc op(parameters);
        op.Serialize(dsOut2);
        write(CF_OPERATION("BignumCalc"), dsOut2);
    }
}

void Bignum_Fuzzer_Importer::write(const uint64_t operation, fuzzing::datasource::Datasource& dsOut2) {
    fuzzing::datasource::Datasource dsOut(nullptr, 0);

    /* Operation ID */
    dsOut.Put<uint64_t>(operation);

    dsOut.PutData(dsOut2.GetOut());

    /* Modifier */
    dsOut.PutData(std::vector<uint8_t>(0));

    /* Module ID */
    dsOut.Put<uint64_t>(CF_MODULE("OpenSSL"));

    /* Terminator */
    dsOut.Put<bool>(false);

    {
        std::string filename = outDir + std::string("/") + util::SHA1(dsOut.GetOut());
        FILE* fp = fopen(filename.c_str(), "wb");
        fwrite(dsOut.GetOut().data(), dsOut.GetOut().size(), 1, fp);
        fclose(fp);
    }
}

} /* namespace cryptofuzz */