/////////////////////////////////////////////////////////////////////////////
/// \file   HexFile.cpp
/// \brief  Read .hex file in "Intel HEX" format.
/// \author JD Gascuel.
///
/// \copyright (c) 2012-2016, JD Gascuel. All rights reserved.
/// $Id$
//////////////////////////////////////////////////////////////////////////////
//
// BSD 2-Clause License:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////

#include "HexFile.h"

#include "Utils/Log.h"
#include "Utils/ProgressEvent.h"

#include <QCoreApplication>
#include <QTextStream>
#include <QtDebug>

//////////////////////////////////////////////////////////////////////////////
// Crypto++ objects needed:

typedef unsigned char byte;

#include "AES/rijndael.h"

///////////////////////////////////////////////////////////////////////////////

HexFile::HexFile()
: _memSize(0),
#ifdef FROG_MASTER
  _baseAddress(0),
#endif
  _buffer(0)
{}

HexFile::~HexFile()
{
    delete[] _buffer; _buffer = 0;
}

///////////////////////////////////////////////////////////////////////////////

bool HexFile::allocate(size_t memSize, unsigned char fill)
{
    delete[] _buffer;
    _buffer = new unsigned char[_memSize = memSize];
    Q_CHECK_PTR(_buffer);

    memset(_buffer, fill, memSize);
    return true;
}

bool HexFile::sqwiz(size_t newMemSize)
{
    if( newMemSize >= _memSize ) {
        LOG_THROW( "Squiz failed" );
    }
    _memSize = newMemSize;
    return true;
}

///////////////////////////////////////////////////////////////////////////////

static size_t bytes = 0;

void HexFile::readLine()
{
    QByteArray line = _file.readLine();
    if( line[0] != ':' )
        LOG_THROW( "Bad HEX format" );

    unsigned char checksum = 0;
    bool ok = true;
    for(int i=1; ok && i<line.length(); i+=2) {
        if( line[i]=='\r' || line[i]=='\n' )
            break;
        checksum += line.mid(i,2).toInt(&ok,16);
    }
    if( ! ok )
        LOG_THROW( "Bad HEX header" );
    if( checksum != 0 )
        LOG_THROW( "Bad HEX checksum" );

    int len  = line.mid(1,2).toInt(0, 16);
    int addr = line.mid(3,2).toInt(0, 16) << 8
             | line.mid(5,2).toInt(0, 16);
    int type = line.mid(7,2).toInt(0, 16);

    switch( type )
    {
    case 00: //---- Data record ----------------------------------------------
        if( _baseAddress == 0x300000 )  // Skip configuration bits.
            return;
        if( _baseAddress == 0xF00000 )  // Skip internal prom reset.
            return;

        for(int i=0; i<len; i++, ++addr)
        {
            size_t a = _baseAddress + addr;
            if( a >= _memSize )
                LOG_THROW( "BAD HEX address" );

            if( _buffer[a] != 0xFF )
                LOG_THROW( "Double write" );

            _buffer[a] = line.mid(9+i*2,2).toInt(&ok,16);
            if( !ok )
                LOG_THROW( "Bad HEX byte" );
            bytes++;
        }
        break;

    case 01: //---- END OF FILE record ---------------------------------------
        _file.seek(-1); // Force to end of file.
        break;

    case 02: //---- Segment address record -----------------------------------
        if( len != 2 || addr != 0 )
            LOG_THROW( "Bad HEX Segment Address record" );
        _baseAddress = line.mid(9,4).toInt(0,16) << 4;
        break;

    case 04: //---- Extended Linear Address Record ---------------------------
        if( len != 2 || addr != 0 )
            LOG_THROW( "Bad HEX Extended Linear Address Record" );
        _baseAddress = line.mid( 9,2).toInt(0,16) << 20
                     | line.mid(11,2).toInt(0,16) << 16;
        break;

    default:
        LOG_THROW("Bad HEX subtype");
    }
}

///////////////////////////////////////////////////////////////////////////////

void HexFile::load(const QString& fileName)
{
    Q_ASSERT(_buffer);

    _file.setFileName(fileName);
    if( ! _file.open(QIODevice::ReadOnly) )
        LOG_THROW("Can't open HEX file");

    bytes = 0;
    while( ! _file.atEnd() )
    {
        PROGRESS(_file.pos(), _file.size());
        readLine();
    }
    PROGRESS_RESET();

    _file.close();

    LOG_TRACE( int(bytes/1024.0f) << "KB loaded ("
            << int(bytes * 100.0f / _memSize) << "% of firmware area).");
}

///////////////////////////////////////////////////////////////////////////////

const unsigned char* HexFile::data() const
{
    Q_ASSERT(_buffer);
    return _buffer;
}

///////////////////////////////////////////////////////////////////////////////

unsigned int HexFile::checksum() const
{
    Q_ASSERT(_buffer);

    unsigned short low = 0;
    unsigned short high = 0;
    for(size_t i=0; i < _memSize; ++i)
    {
        low  += _buffer[i];
        high += low;
    }
    return (((unsigned int)high) << 16) + low;
}

///////////////////////////////////////////////////////////////////////////////

#ifndef FROG_MASTER
void HexFile::saveEncrypted(const QString&, byte [16])
{
    LOG_THROW( "No encryption" );
}
#else
void HexFile::saveEncrypted(const QString& fileName, byte secretKey[16])
{
    _file.setFileName(fileName);
    if( ! _file.open(QIODevice::WriteOnly|QIODevice::Truncate) )
        LOG_THROW( "Can't save to encrypted file" );

    QTextStream out(&_file);
    out.setIntegerBase(16);
    out.setPadChar('0');

    //---- Generates 128 bits of random initialization vector ----------------
    Rijndael::CFB<128>::IV iv = {0};
    Rijndael::ECB<128> PRNG; PRNG.setupEncrypt(secretKey);
    for(int i=0; i<sizeof iv; ++i)
        iv[i] = PRNG.get_random() % 256;

    size_t bytes = 0;   // encrypted fake address
    for(int i0 = 0; i0 < sizeof iv; i0+=0x10)
    {
        out << qSetFieldWidth(1) << ":"
            << qSetFieldWidth(6) << bytes
            << qSetFieldWidth(2);
        for(int i=0; i<0x10; i++)
            out << iv[i0+i];
        out << qSetFieldWidth(1) << "\n";
        bytes += 0x10;
    }

    //---- Create stream encryptor -------------------------------------------
    Rijndael::CFB<128> enc(secretKey, iv);

    //---- Process data ------------------------------------------------------
    PROGRESS(0, _memSize);

    byte encrypted[32];
    for(size_t addr = 0; addr < _memSize; addr += 0x10)
    {
        PROGRESS(addr, _memSize);

        enc.encrypt(_buffer + addr, encrypted);
        out << qSetFieldWidth(1) << ":"
            << qSetFieldWidth(6) << bytes
            << qSetFieldWidth(2);
        for(int i=0; i<16; i++)
            out << encrypted[i];
        out << qSetFieldWidth(1) << "\n";
        bytes += 16;
    }

    //---- Process data ------------------------------------------------------
    unsigned int sum = checksum(); // 33.29.BD.1D
    out << qSetFieldWidth(1) << ":"
        << qSetFieldWidth(6) << bytes
        << qSetFieldWidth(2)
        << ((sum    ) & 0xff)
        << ((sum>> 8) & 0xff)
        << ((sum>>16) & 0xff)
        << ((sum>>24) & 0xff)
        << qSetFieldWidth(1) << "\n"
        ;

    qDebug().nospace() << int( bytes/1024.0f) << "KB saved into "
                       << fileName.section('/', -1);

    PROGRESS_RESET();
}
#endif

///////////////////////////////////////////////////////////////////////////////

void HexFile::loadEncrypted(const QString& fileName, unsigned char secretKey[16])
{
    Q_ASSERT(_buffer);

    _file.setFileName(fileName);
    if( ! _file.open(QIODevice::ReadOnly) )
        LOG_THROW( "Cannot open HEX file "  << fileName );

    //---- Read 128 bits of initialization vector ----------------------------
    Rijndael::CFB<128>::IV iv = {0};

    unsigned int bytes = 0;
    bool ok = true;
    for(size_t i0 = 0; i0 < sizeof iv; i0+=0x10)
    {
        QByteArray line = _file.readLine();
        if( line[0] != ':' )
            LOG_THROW( "Bad HEX line" );

        unsigned int readAddr = line.mid(1,6).toInt(&ok, 16);
        if( !ok || readAddr != bytes )
            LOG_THROW( "Bad HEX address" );

        for(int i=0; i<0x10; i++)
            iv[i0+i] = line.mid(2*i+7,2).toInt(&ok, 16);
        if( !ok )
            LOG_THROW( "Bad HEX file format" );

        bytes += 0x10;
    }

    //---- Create stream decryptor -------------------------------------------
    Rijndael::CFB<128> dec(secretKey, iv);

    //---- Process data ------------------------------------------------------
    PROGRESS(0, (int)_memSize);

    Rijndael::Block encrypted;
    for(size_t addr = 0; addr < _memSize; addr += 0x10)
    {
        PROGRESS((int)addr, (int)_memSize);

        QByteArray line = _file.readLine();
        if( line[0] != ':' )
            LOG_THROW( "Bad HEX line" );

        unsigned int readAddr = line.mid(1,6).toInt(&ok, 16);
        if( !ok || readAddr != bytes )
            LOG_THROW( "Bad HEX address" );

        for(int i=0; i<0x10; i++)
            encrypted[i] = line.mid(2*i+7,2).toInt(&ok, 16);
        if( !ok )
            LOG_THROW( "Bad HEX file format" );
        bytes += 0x10;

        dec.decrypt(encrypted, *(Rijndael::Block*)(_buffer+addr));
    }
    QByteArray line = _file.readLine();
    if( bytes != (unsigned int)line.mid(1,6).toInt(&ok, 16) || !ok )
        LOG_THROW( "Bad HEX address" );

    unsigned int sum =  line.mid( 7,2).toInt(&ok, 16)
                     + (line.mid( 9,2).toInt(&ok, 16) << 8 )
                     + (line.mid(11,2).toInt(&ok, 16) << 16)
                     + (line.mid(13,2).toInt(&ok, 16) << 24);
    if( sum != checksum() )
        LOG_THROW( "Bad HEX checksum" );

    PROGRESS_RESET();
}