Example #1
0
            public override byte[] GetMethodsData(EmbeddedResource resource)
            {
                var reader = resource.Data;

                reader.Position = startOffset;
                var  decrypted = new byte[reader.Read7BitEncodedUInt32()];
                uint origCrc32 = reader.ReadUInt32();
                long pos       = reader.Position;

                var keys = new byte[][] { decryptionKey, decryptionKey6, decryptionKey7 };

                foreach (var key in keys)
                {
                    try {
                        reader.Position = pos;
                        Decompress(decrypted, reader, key, decryptionKeyMod);
                        uint crc32 = CRC32.CheckSum(decrypted);
                        if (crc32 == origCrc32)
                        {
                            return(decrypted);
                        }
                    }
                    catch (OutOfMemoryException) {
                    }
                    catch (IOException) {
                    }
                }

                throw new ApplicationException("Could not decrypt methods data");
            }
Example #2
0
            public static DecrypterV106 Create(IBinaryReader reader)
            {
                try {
                    int keyXorOffs7 = (ReadByteAt(reader, 0) ^ ReadByteAt(reader, 2)) + 2;
                    reader.Position = keyXorOffs7 + (ReadByteAt(reader, 1) ^ ReadByteAt(reader, keyXorOffs7));

                    int  sha1DataLen   = reader.Read7BitEncodedInt32() + 0x80;
                    int  keyXorOffs6   = (int)reader.Position;
                    int  encryptedOffs = (int)reader.Position + sha1DataLen;
                    var  sha1Data      = reader.ReadBytes(sha1DataLen);
                    uint crc32         = CRC32.CheckSum(sha1Data);

                    reader.Position = reader.Length - 0x18;
                    uint origCrc32 = reader.ReadUInt32();
                    if (crc32 != origCrc32)
                    {
                        return(null);
                    }

                    var key0 = DeobUtils.Sha1Sum(sha1Data);                             // 1.0.6.0
                    var key6 = GetKey(reader, key0, keyXorOffs6);                       // 1.0.6.6
                    var key7 = GetKey(reader, key0, keyXorOffs7);                       // 1.0.6.7
                    return(new DecrypterV106(key0, key6, key7, encryptedOffs));
                }
                catch (IOException) {
                    return(null);
                }
            }
Example #3
0
        private bool CheckSumOK(ByteArrayBuffer buffer, int offset)
        {
            var initialOffSet = buffer.Offset();
            var length        = OwnLength();

            length -= ChecksumLength;
            buffer.Seek(offset);
            var readCheckSum        = buffer.ReadLong();
            var checkSumBeginOffset = buffer.Offset();
            var bytes = buffer._buffer;
            var calculatedCheckSum = CRC32.CheckSum(bytes, checkSumBeginOffset, length);

            buffer.Seek(initialOffSet);
            return(calculatedCheckSum == readCheckSum);
        }
Example #4
0
        private void Marshall(ByteArrayBuffer buffer, bool shuttingDown)
        {
            var checkSumOffset = buffer.Offset();

            buffer.IncrementOffset(ChecksumLength);
            var checkSumBeginOffset = buffer.Offset();

            WriteBuffer(buffer, shuttingDown);
            var checkSumEndOffSet = buffer.Offset();
            var bytes             = buffer._buffer;
            var length            = checkSumEndOffSet - checkSumBeginOffset;
            var checkSum          = CRC32.CheckSum(bytes, checkSumBeginOffset, length);

            buffer.Seek(checkSumOffset);
            buffer.WriteLong(checkSum);
            buffer.Seek(checkSumEndOffSet);
        }
Example #5
0
        public void Test()
        {
            int[] ints = new int[] {
                int.MinValue,
                -1,
                0,
                1,
                int.MaxValue
            };
            int             bufferLength = Const4.IntLength * ints.Length;
            ByteArrayBuffer buffer       = new ByteArrayBuffer(bufferLength);

            for (int i = 0; i < ints.Length; i++)
            {
                buffer.WriteInt(ints[i]);
            }
            long checkSum = CRC32.CheckSum(buffer._buffer, 0, buffer._buffer.Length);

            _expectedJavaOutput = checkSum.ToString();
            RunTest();
        }