hashcat/deps/unrar/rawread.cpp

#include "rar.hpp"

RawRead::RawRead()
{
  RawRead::SrcFile=NULL;
  Reset();
}


RawRead::RawRead(File *SrcFile)
{
  RawRead::SrcFile=SrcFile;
  Reset();
}


void RawRead::Reset()
{
  Data.SoftReset();
  ReadPos=0;
  DataSize=0;
  Crypt=NULL;
}


size_t RawRead::Read(size_t Size)
{
  size_t ReadSize=0;
#if !defined(RAR_NOCRYPT)
  if (Crypt!=NULL)
  {
    // Full size of buffer with already read data including data read 
    // for encryption block alignment.
    size_t FullSize=Data.Size();

    // Data read for alignment and not processed yet.
    size_t DataLeft=FullSize-DataSize;

    if (Size>DataLeft) // Need to read more than we already have.
    {
      size_t SizeToRead=Size-DataLeft;
      size_t AlignedReadSize=SizeToRead+((~SizeToRead+1) & CRYPT_BLOCK_MASK);
      Data.Add(AlignedReadSize);
      ReadSize=SrcFile->Read(&Data[FullSize],AlignedReadSize);
      Crypt->DecryptBlock(&Data[FullSize],AlignedReadSize);
      DataSize+=ReadSize==0 ? 0:Size;
    }
    else // Use buffered data, no real read.
    {
      ReadSize=Size;
      DataSize+=Size;
    }
  }
  else
#endif
    if (Size!=0)
    {
      Data.Add(Size);
      ReadSize=SrcFile->Read(&Data[DataSize],Size);
      DataSize+=ReadSize;
    }
  return ReadSize;
}


void RawRead::Read(byte *SrcData,size_t Size)
{
  if (Size!=0)
  {
    Data.Add(Size);
    memcpy(&Data[DataSize],SrcData,Size);
    DataSize+=Size;
  }
}


byte RawRead::Get1()
{
  return ReadPos<DataSize ? Data[ReadPos++]:0;
}


ushort RawRead::Get2()
{
  if (ReadPos+1<DataSize)
  {
    ushort Result=Data[ReadPos]+(Data[ReadPos+1]<<8);
    ReadPos+=2;
    return Result;
  }
  return 0;
}


uint RawRead::Get4()
{
  if (ReadPos+3<DataSize)
  {
    uint Result=Data[ReadPos]+(Data[ReadPos+1]<<8)+(Data[ReadPos+2]<<16)+
                (Data[ReadPos+3]<<24);
    ReadPos+=4;
    return Result;
  }
  return 0;
}


uint64 RawRead::Get8()
{
  uint Low=Get4(),High=Get4();
  return INT32TO64(High,Low);
}


uint64 RawRead::GetV()
{
  uint64 Result=0;
  // Need to check Shift<64, because for shift greater than or equal to
  // the width of the promoted left operand, the behavior is undefined.
  for (uint Shift=0;ReadPos<DataSize && Shift<64;Shift+=7)
  {
    byte CurByte=Data[ReadPos++];
    Result+=uint64(CurByte & 0x7f)<<Shift;
    if ((CurByte & 0x80)==0)
      return Result; // Decoded successfully.
  }
  return 0; // Out of buffer border.
}


// Return a number of bytes in current variable length integer.
uint RawRead::GetVSize(size_t Pos)
{
  for (size_t CurPos=Pos;CurPos<DataSize;CurPos++)
    if ((Data[CurPos] & 0x80)==0)
      return int(CurPos-Pos+1);
  return 0; // Buffer overflow.
}


size_t RawRead::GetB(void *Field,size_t Size)
{
  byte *F=(byte *)Field;
  size_t CopySize=Min(DataSize-ReadPos,Size);
  if (CopySize>0)
    memcpy(F,&Data[ReadPos],CopySize);
  if (Size>CopySize)
    memset(F+CopySize,0,Size-CopySize);
  ReadPos+=CopySize;
  return CopySize;
}


void RawRead::GetW(wchar *Field,size_t Size)
{
  if (ReadPos+2*Size-1<DataSize)
  {
    RawToWide(&Data[ReadPos],Field,Size);
    ReadPos+=sizeof(wchar)*Size;
  }
  else
    memset(Field,0,sizeof(wchar)*Size);
}


uint RawRead::GetCRC15(bool ProcessedOnly) // RAR 1.5 block CRC.
{
  if (DataSize<=2)
    return 0;
  uint HeaderCRC=CRC32(0xffffffff,&Data[2],(ProcessedOnly ? ReadPos:DataSize)-2);
  return ~HeaderCRC & 0xffff;
}


uint RawRead::GetCRC50() // RAR 5.0 block CRC.
{
  if (DataSize<=4)
    return 0xffffffff;
  return CRC32(0xffffffff,&Data[4],DataSize-4) ^ 0xffffffff;
}


// Read vint from arbitrary byte array.
uint64 RawGetV(const byte *Data,uint &ReadPos,uint DataSize,bool &Overflow)
{
  Overflow=false;
  uint64 Result=0;
  for (uint Shift=0;ReadPos<DataSize;Shift+=7)
  {
    byte CurByte=Data[ReadPos++];
    Result+=uint64(CurByte & 0x7f)<<Shift;
    if ((CurByte & 0x80)==0)
      return Result; // Decoded successfully.
  }
  Overflow=true;
  return 0; // Out of buffer border.
}