Exemple #1
0
        public bool Patch(BytePatchPattern.WriteToLog log)
        {
            FileInfo dllFile = new FileInfo(DllPath);

            if (!dllFile.Exists)
            {
                throw new IOException("File not found");
            }

            byte[] raw = File.ReadAllBytes(dllFile.FullName);
            log("Patching " + dllFile.FullName + "...");

            FileInfo dllFileBackup = new FileInfo(dllFile.FullName + ".bck");

            if (!dllFileBackup.Exists)
            {
                File.WriteAllBytes(dllFileBackup.FullName, raw);
                log("Backupped to " + dllFileBackup.FullName);
            }

            if (Program.bytePatchManager.PatchBytes(ref raw, IsImageX64(dllFile.FullName), log))
            {
                File.WriteAllBytes(dllFile.FullName, raw);
                log("Patched and saved successfully " + dllFile.FullName);
                return(true);
            }
            else
            {
                log("Error trying to patch " + dllFile.FullName);
            }

            return(false);
        }
Exemple #2
0
        public bool PatchBytes(ref byte[] raw, bool x64, BytePatchPattern.WriteToLog log)
        {
            int patches = 0;

            foreach (BytePatch patch in BytePatches)
            {
                if (DisabledGroups.Contains(patch.group))
                {
                    patches++;
                    continue;
                }
                Tuple <long, byte[]> addrPattern = patch.pattern.FindAddress(raw, x64, log);
                long   addr          = addrPattern.Item1;
                byte[] searchPattern = addrPattern.Item2;

                int  patchOffset    = x64 ? patch.offsetX64 : patch.offsetX86;
                byte patchOrigByte  = x64 ? patch.origByteX64 : patch.origByteX86;
                byte patchPatchByte = x64 ? patch.patchByteX64 : patch.patchByteX86;

                if (addr != -1)
                {
                    if (patchOffset < searchPattern.Length && searchPattern[patchOffset] != 0xFF)
                    {
                        patchOrigByte = searchPattern[patchOffset];                         // The patterns can sometimes start at different places (yes, I'm looking at you, Edge), so the byte in the pattern should be always preferred
                    }
REDO_CHECKS:
                    long index = addr + patchOffset;
                    byte sourceByte = raw[index];

                    log("Source byte of patch at " + patchOffset + ": " + sourceByte);
                    if (sourceByte == patchOrigByte)
                    {
                        raw[index] = patchPatchByte;
                        log(index + " => " + patchPatchByte);
                        patches++;
                    }
                    else
                    {
                        int patchAlternativeOffset = x64 ? patch.aoffsetX64 : patch.aoffsetX86;
                        if (patchOffset != patchAlternativeOffset && patchAlternativeOffset != -1)                           // if the first offset didn't work, try the next one
                        {
                            patchOffset = patchAlternativeOffset;
                            goto REDO_CHECKS;
                        }

                        log("Source byte unexpected, should be " + patchOrigByte + "!");
                    }
                }
                else
                {
                    log("Couldn't find offset for a patch " + patch.pattern.Name);
                }
            }

            return(patches == BytePatches.Count);
        }
        public bool PatchBytes(ref byte[] raw, bool x64, BytePatchPattern.WriteToLog log)
        {
            int patches = 0;

            foreach (BytePatch patch in BytePatches)
            {
                if (DisabledGroups.Contains(patch.group))
                {
                    patches++;
                    continue;
                }
                long addr           = patch.pattern.FindAddress(raw, x64, log);
                int  patchOffset    = x64 ? patch.offsetX64 : patch.offsetX86;
                byte patchOrigByte  = x64 ? patch.origByteX64 : patch.origByteX86;
                byte patchPatchByte = x64 ? patch.patchByteX64 : patch.patchByteX86;

                if (addr != -1)
                {
REDO_CHECKS:
                    long index = addr + patchOffset;
                    byte sourceByte = raw[index];

                    log("Source byte of patch at " + patchOffset + ": " + sourceByte);
                    if (sourceByte == patchOrigByte)
                    {
                        raw[index] = patchPatchByte;
                        log(index + " => " + patchPatchByte);
                        patches++;
                    }
                    else
                    {
                        int patchAlternativeOffset = x64 ? patch.aoffsetX64 : patch.aoffsetX86;
                        if (patchOffset != patchAlternativeOffset && patchAlternativeOffset != -1)  // if the first offset didn't work, try the next one
                        {
                            patchOffset = patchAlternativeOffset;
                            goto REDO_CHECKS;
                        }

                        log("Source byte unexpected, should be " + patchOrigByte + "!");
                    }
                }
                else
                {
                    log("Couldn't find offset for a patch " + patch.pattern.Name);
                }
            }

            return(patches == BytePatches.Count);
        }
        public bool PatchBytes(ref byte[] raw, bool x64, BytePatchPattern.WriteToLog log)
        {
            int patches = 0;

            foreach (BytePatch patch in BytePatches)
            {
                if (disabledTypes.Contains(patch.GetType()))
                {
                    patches++;
                    continue;
                }
                long addr           = patch.pattern.FindAddress(raw, x64, log);
                int  patchOffset    = x64 ? patch.offsetX64 : patch.offsetX86;
                byte patchOrigByte  = x64 ? patch.origByteX64 : patch.origByteX86;
                byte patchPatchByte = x64 ? patch.patchByteX64 : patch.patchByteX86;

                if (addr != -1)
                {
                    long index      = addr + patchOffset;
                    byte sourceByte = raw[index];

                    log("Source byte of patch at " + patchOffset + ": " + sourceByte);
                    if (sourceByte == patchOrigByte)
                    {
                        raw[index] = patchPatchByte;
                        log(index + " => " + patchPatchByte);
                        patches++;
                    }
                    else
                    {
                        log("Source byte unexpected, should be " + patchOrigByte + "!");
                    }
                }
                else
                {
                    log("Couldn't find offset for a patch " + patch.pattern.Name);
                }
            }

            return(patches == BytePatches.Count);
        }
        public void Patch(BytePatchPattern.WriteToLog log)
        {
            FileInfo dllFile = new FileInfo(DllPath);

            if (!dllFile.Exists)
            {
                throw new IOException("File not found");
            }

            byte[] raw = File.ReadAllBytes(dllFile.FullName);

            if (Program.bytePatchManager.PatchBytes(ref raw, IsImageX64(dllFile.FullName), log))
            {
                File.WriteAllBytes(dllFile.FullName, raw);
                log("Patched and saved successfully " + dllFile.FullName);
            }
            else
            {
                log("Error trying to patch " + dllFile.FullName);
            }
        }