botan_importer.cpp

#include <cryptofuzz/botan_importer.h>
#include <cryptofuzz/repository.h>
#include <cryptofuzz/operations.h>
#include <cryptofuzz/util.h>
#include <cryptofuzz/crypto.h>
#include <stdio.h>
#include <fstream>

namespace cryptofuzz {

Botan_Importer::Botan_Importer(const std::string filename, const std::string outDir, const uint64_t curveId) :
    filename(filename), outDir(outDir), curveId(curveId) {
}

void Botan_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 Botan_Importer::LoadInput(const std::vector<uint8_t> data) {

   switch ( curveId ) {
       case CF_ECC_CURVE("brainpool256r1"):
           if ( data.size() > 2*256/8 ) {
               return;
           }
           break;
       case CF_ECC_CURVE("secp256r1"):
           if ( data.size() > 2*256/8 ) {
               return;
           }
           break;
       case CF_ECC_CURVE("secp384r1"):
           if ( data.size() > 2*384/8 ) {
               return;
           }
           break;
       case CF_ECC_CURVE("secp521r1"):
           if ( data.size() > 2*(521+7)/8 ) {
               return;
           }
           break;
       default:
           CF_ASSERT(0, "Curve not supported");
   }

   const auto a_x = *repository::ECC_CurveToX(curveId);
   const auto a_y = *repository::ECC_CurveToY(curveId);

   const size_t half = data.size() / 2;
   const std::array<std::string, 2> multipliers = {
       cryptofuzz::util::BinToDec(data.data(), half),
       cryptofuzz::util::BinToDec(data.data() + half, half)
   };

   for (const auto& multiplier : multipliers) {
       nlohmann::json parameters;
       parameters["modifier"] = "";
       parameters["curveType"] = curveId;
       parameters["a_x"] = a_x;
       parameters["a_y"] = a_y;
       parameters["b"] = multiplier;
       fuzzing::datasource::Datasource dsOut2(nullptr, 0);
       cryptofuzz::operation::ECC_Point_Mul op(parameters);
       op.Serialize(dsOut2);
       write(CF_OPERATION("ECC_Point_Mul"), dsOut2);
   }
}

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