lzma2enc_fuzzer.cc

/**
 *
 * @copyright Copyright (c) 2019 Joachim Bauch <mail@joachim-bauch.de>
 *
 * @license GNU GPL version 3 or any later version
 *
 * 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 3 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, see <https://www.gnu.org/licenses/>.
 *
 */

#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include "Lzma2Enc.h"
#include "Lzma2Dec.h"

#include "common-alloc.h"
#include "common-buffer.h"

// Limit maximum size to avoid running into timeouts with too large data.
static const size_t kMaxInputSize = 100 * 1024;

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
  if (size <= 10 || size > kMaxInputSize) {
    return 0;
  }

  CLzma2EncProps props;
  Byte props_data;

  memset(&props, 0, sizeof(props));
  Lzma2EncProps_Init(&props);
  props.lzmaProps.level = data[0] <= 9 ? data[0] : 9;
  props.lzmaProps.lc = data[1] <= 8 ? data[1] : 8;
  props.lzmaProps.lp = data[2] <= 4 ? data[2] : 4;
  props.lzmaProps.pb = data[3] <= 4 ? data[3] : 4;
  props.lzmaProps.algo = data[4] ? 1 : 0;
  props.lzmaProps.fb = 5 + data[5];
  props.lzmaProps.btMode = data[6] ? 1 : 0;
  props.lzmaProps.numHashBytes = 2 + (data[7] % 3);
  props.lzmaProps.mc = 1 + data[8];
  props.lzmaProps.writeEndMark = data[9] ? 1 : 0;
  props.lzmaProps.dictSize = 1 << 24;
  data += 10;
  size -= 10;
  Lzma2EncProps_Normalize(&props);

  CLzma2EncHandle enc = Lzma2Enc_Create(&CommonAlloc, &CommonAlloc);
  if (!enc) {
    return 0;
  }

  OutputBuffer out_buffer;
  InputBuffer in_buffer(data, size);
  Byte *dest = nullptr;
  SizeT srcLen;
  SizeT destLen;
  ELzmaStatus status;

  SRes res = Lzma2Enc_SetProps(enc, &props);
  if (res != SZ_OK) {
    goto exit;
  }

  Lzma2Enc_SetDataSize(enc, size);
  props_data = Lzma2Enc_WriteProperties(enc);

  res = Lzma2Enc_Encode2(enc, out_buffer.stream(), nullptr, 0,
      in_buffer.stream(), nullptr, 0, nullptr);
  assert(res == SZ_OK);
  assert(out_buffer.size() > 0);

  // Decompress and compare with input data.
  dest = static_cast<Byte*>(malloc(size));
  assert(dest);
  destLen = size;
  srcLen = out_buffer.size();

  res = Lzma2Decode(dest, &destLen, out_buffer.data(), &srcLen, props_data,
      LZMA_FINISH_END, &status, &CommonAlloc);
  assert(res == SZ_OK);
  assert(status == LZMA_STATUS_FINISHED_WITH_MARK ||
      status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK);
  assert(srcLen == out_buffer.size());
  assert(memcmp(dest, data, size) == 0);

exit:
  Lzma2Enc_Destroy(enc);
  free(dest);
  return 0;
}