openssl_importer.cpp

#include <cryptofuzz/openssl_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 {

OpenSSL_Importer::OpenSSL_Importer(const std::string filename, const std::string outDir, const enum type t) :
    filename(filename), outDir(outDir), t(t) {
}

void OpenSSL_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);
}

void OpenSSL_Importer::LoadInput(const std::vector<uint8_t> data) {

    nlohmann::json parameters;
    parameters["modifier"] = "";
    parameters["bn4"] = "";

    if ( t == ExpMod ) {
        if ( data.size() < 3 ) {
            return;
        }

        const uint8_t* ptr = data.data();
        const size_t size = data.size() - 3;
        const size_t l1 = (ptr[0] * size) / 255;
        ptr++;
        const size_t l2 = (ptr[0] * (size - l1)) / 255;
        ptr++;
        const size_t l3 = size - l1 - l2;
        const bool bn1_neg = ptr[0] & 1;
        const bool bn3_neg = ptr[0] & 4;
        ptr++;

        auto bn1 = util::BinToDec(ptr, l1);
        if ( bn1_neg ) {
            bn1 = "-" + bn1;
        }
        const auto bn2 = util::BinToDec(ptr + l1, l2);
        auto bn3 = util::BinToDec(ptr + l1 + l2, l3);
        if ( bn3_neg ) {
            bn3 = "-" + bn3;
        }

        if ( bn1.size() > cryptofuzz::config::kMaxBignumSize ) {
            return;
        }
        if ( bn2.size() > cryptofuzz::config::kMaxBignumSize ) {
            return;
        }
        if ( bn3.size() > cryptofuzz::config::kMaxBignumSize ) {
            return;
        }

        parameters["calcOp"] = CF_CALCOP("ExpMod(A,B,C)");
        parameters["bn1"] = bn1;
        parameters["bn2"] = bn2;
        parameters["bn3"] = bn3;
    } else {
        CF_UNREACHABLE();
    }

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

}

void OpenSSL_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 */