#include "rar.hpp" RarVM::RarVM() { Mem=NULL; } RarVM::~RarVM() { delete[] Mem; } void RarVM::Init() { if (Mem==NULL) Mem=new byte[VM_MEMSIZE+4]; } void RarVM::Execute(VM_PreparedProgram *Prg) { memcpy(R,Prg->InitR,sizeof(Prg->InitR)); Prg->FilteredData=NULL; if (Prg->Type!=VMSF_NONE) { bool Success=ExecuteStandardFilter(Prg->Type); uint BlockSize=Prg->InitR[4] & VM_MEMMASK; Prg->FilteredDataSize=BlockSize; if (Prg->Type==VMSF_DELTA || Prg->Type==VMSF_RGB || Prg->Type==VMSF_AUDIO) Prg->FilteredData=2*BlockSize>VM_MEMSIZE || !Success ? Mem:Mem+BlockSize; else Prg->FilteredData=Mem; } } void RarVM::Prepare(byte *Code,uint CodeSize,VM_PreparedProgram *Prg) { // Calculate the single byte XOR checksum to check validity of VM code. byte XorSum=0; for (uint I=1;I<CodeSize;I++) XorSum^=Code[I]; if (XorSum!=Code[0]) return; struct StandardFilters { uint Length; uint CRC; VM_StandardFilters Type; } static StdList[]={ 53, 0xad576887, VMSF_E8, 57, 0x3cd7e57e, VMSF_E8E9, 120, 0x3769893f, VMSF_ITANIUM, 29, 0x0e06077d, VMSF_DELTA, 149, 0x1c2c5dc8, VMSF_RGB, 216, 0xbc85e701, VMSF_AUDIO }; uint CodeCRC=CRC32(0xffffffff,Code,CodeSize)^0xffffffff; for (uint I=0;I<ASIZE(StdList);I++) if (StdList[I].CRC==CodeCRC && StdList[I].Length==CodeSize) { Prg->Type=StdList[I].Type; break; } } uint RarVM::ReadData(BitInput &Inp) { uint Data=Inp.fgetbits(); switch(Data&0xc000) { case 0: Inp.faddbits(6); return (Data>>10)&0xf; case 0x4000: if ((Data&0x3c00)==0) { Data=0xffffff00|((Data>>2)&0xff); Inp.faddbits(14); } else { Data=(Data>>6)&0xff; Inp.faddbits(10); } return Data; case 0x8000: Inp.faddbits(2); Data=Inp.fgetbits(); Inp.faddbits(16); return Data; default: Inp.faddbits(2); Data=(Inp.fgetbits()<<16); Inp.faddbits(16); Data|=Inp.fgetbits(); Inp.faddbits(16); return Data; } } void RarVM::SetMemory(size_t Pos,byte *Data,size_t DataSize) { if (Pos<VM_MEMSIZE && Data!=Mem+Pos) { // We can have NULL Data for invalid filters with DataSize==0. While most // sensible memmove implementations do not care about data if size is 0, // let's follow the standard and check the size first. size_t CopySize=Min(DataSize,VM_MEMSIZE-Pos); if (CopySize!=0) memmove(Mem+Pos,Data,CopySize); } } bool RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType) { switch(FilterType) { case VMSF_E8: case VMSF_E8E9: { byte *Data=Mem; uint DataSize=R[4],FileOffset=R[6]; if (DataSize>VM_MEMSIZE || DataSize<4) return false; const uint FileSize=0x1000000; byte CmpByte2=FilterType==VMSF_E8E9 ? 0xe9:0xe8; for (uint CurPos=0;CurPos<DataSize-4;) { byte CurByte=*(Data++); CurPos++; if (CurByte==0xe8 || CurByte==CmpByte2) { uint Offset=CurPos+FileOffset; uint Addr=RawGet4(Data); // We check 0x80000000 bit instead of '< 0' comparison // not assuming int32 presence or uint size and endianness. if ((Addr & 0x80000000)!=0) // Addr<0 { if (((Addr+Offset) & 0x80000000)==0) // Addr+Offset>=0 RawPut4(Addr+FileSize,Data); } else if (((Addr-FileSize) & 0x80000000)!=0) // Addr<FileSize RawPut4(Addr-Offset,Data); Data+=4; CurPos+=4; } } } break; case VMSF_ITANIUM: { byte *Data=Mem; uint DataSize=R[4],FileOffset=R[6]; if (DataSize>VM_MEMSIZE || DataSize<21) return false; uint CurPos=0; FileOffset>>=4; while (CurPos<DataSize-21) { int Byte=(Data[0]&0x1f)-0x10; if (Byte>=0) { static byte Masks[16]={4,4,6,6,0,0,7,7,4,4,0,0,4,4,0,0}; byte CmdMask=Masks[Byte]; if (CmdMask!=0) for (uint I=0;I<=2;I++) if (CmdMask & (1<<I)) { uint StartPos=I*41+5; uint OpType=FilterItanium_GetBits(Data,StartPos+37,4); if (OpType==5) { uint Offset=FilterItanium_GetBits(Data,StartPos+13,20); FilterItanium_SetBits(Data,(Offset-FileOffset)&0xfffff,StartPos+13,20); } } } Data+=16; CurPos+=16; FileOffset++; } } break; case VMSF_DELTA: { uint DataSize=R[4],Channels=R[0],SrcPos=0,Border=DataSize*2; if (DataSize>VM_MEMSIZE/2 || Channels>MAX3_UNPACK_CHANNELS || Channels==0) return false; // Bytes from same channels are grouped to continual data blocks, // so we need to place them back to their interleaving positions. for (uint CurChannel=0;CurChannel<Channels;CurChannel++) { byte PrevByte=0; for (uint DestPos=DataSize+CurChannel;DestPos<Border;DestPos+=Channels) Mem[DestPos]=(PrevByte-=Mem[SrcPos++]); } } break; case VMSF_RGB: { uint DataSize=R[4],Width=R[0]-3,PosR=R[1]; if (DataSize>VM_MEMSIZE/2 || DataSize<3 || Width>DataSize || PosR>2) return false; byte *SrcData=Mem,*DestData=SrcData+DataSize; const uint Channels=3; for (uint CurChannel=0;CurChannel<Channels;CurChannel++) { uint PrevByte=0; for (uint I=CurChannel;I<DataSize;I+=Channels) { uint Predicted; if (I>=Width+3) { byte *UpperData=DestData+I-Width; uint UpperByte=*UpperData; uint UpperLeftByte=*(UpperData-3); Predicted=PrevByte+UpperByte-UpperLeftByte; int pa=abs((int)(Predicted-PrevByte)); int pb=abs((int)(Predicted-UpperByte)); int pc=abs((int)(Predicted-UpperLeftByte)); if (pa<=pb && pa<=pc) Predicted=PrevByte; else if (pb<=pc) Predicted=UpperByte; else Predicted=UpperLeftByte; } else Predicted=PrevByte; DestData[I]=PrevByte=(byte)(Predicted-*(SrcData++)); } } for (uint I=PosR,Border=DataSize-2;I<Border;I+=3) { byte G=DestData[I+1]; DestData[I]+=G; DestData[I+2]+=G; } } break; case VMSF_AUDIO: { uint DataSize=R[4],Channels=R[0]; byte *SrcData=Mem,*DestData=SrcData+DataSize; // In fact, audio channels never exceed 4. if (DataSize>VM_MEMSIZE/2 || Channels>128 || Channels==0) return false; for (uint CurChannel=0;CurChannel<Channels;CurChannel++) { uint PrevByte=0,PrevDelta=0,Dif[7]; int D1=0,D2=0,D3; int K1=0,K2=0,K3=0; memset(Dif,0,sizeof(Dif)); for (uint I=CurChannel,ByteCount=0;I<DataSize;I+=Channels,ByteCount++) { D3=D2; D2=PrevDelta-D1; D1=PrevDelta; uint Predicted=8*PrevByte+K1*D1+K2*D2+K3*D3; Predicted=(Predicted>>3) & 0xff; uint CurByte=*(SrcData++); Predicted-=CurByte; DestData[I]=Predicted; PrevDelta=(signed char)(Predicted-PrevByte); PrevByte=Predicted; int D=(signed char)CurByte; // Left shift of negative value is undefined behavior in C++, // so we cast it to unsigned to follow the standard. D=(uint)D<<3; Dif[0]+=abs(D); Dif[1]+=abs(D-D1); Dif[2]+=abs(D+D1); Dif[3]+=abs(D-D2); Dif[4]+=abs(D+D2); Dif[5]+=abs(D-D3); Dif[6]+=abs(D+D3); if ((ByteCount & 0x1f)==0) { uint MinDif=Dif[0],NumMinDif=0; Dif[0]=0; for (uint J=1;J<ASIZE(Dif);J++) { if (Dif[J]<MinDif) { MinDif=Dif[J]; NumMinDif=J; } Dif[J]=0; } switch(NumMinDif) { case 1: if (K1>=-16) K1--; break; case 2: if (K1 < 16) K1++; break; case 3: if (K2>=-16) K2--; break; case 4: if (K2 < 16) K2++; break; case 5: if (K3>=-16) K3--; break; case 6: if (K3 < 16) K3++; break; } } } } } break; } return true; } uint RarVM::FilterItanium_GetBits(byte *Data,uint BitPos,uint BitCount) { uint InAddr=BitPos/8; uint InBit=BitPos&7; uint BitField=(uint)Data[InAddr++]; BitField|=(uint)Data[InAddr++] << 8; BitField|=(uint)Data[InAddr++] << 16; BitField|=(uint)Data[InAddr] << 24; BitField >>= InBit; return BitField & (0xffffffff>>(32-BitCount)); } void RarVM::FilterItanium_SetBits(byte *Data,uint BitField,uint BitPos,uint BitCount) { uint InAddr=BitPos/8; uint InBit=BitPos&7; uint AndMask=0xffffffff>>(32-BitCount); AndMask=~(AndMask<<InBit); BitField<<=InBit; for (uint I=0;I<4;I++) { Data[InAddr+I]&=AndMask; Data[InAddr+I]|=BitField; AndMask=(AndMask>>8)|0xff000000; BitField>>=8; } }