กลยุทธ์ในการเอาชนะ Editors ความจำสำหรับโกง - เกมบนเดสก์ท็อป [ปิด]

ฉันสมมติว่าเรากำลังพูดถึงเกมเดสก์ท็อปซึ่งเป็นสิ่งที่ผู้เล่นดาวน์โหลดและเล่นบนคอมพิวเตอร์ในพื้นที่ หลายคนเป็นบรรณาธิการหน่วยความจำที่ให้คุณตรวจจับและตรึงค่าเช่นสุขภาพของผู้เล่นของคุณ

คุณจะป้องกันการโกงผ่านการปรับเปลี่ยนหน่วยความจำได้อย่างไร กลวิธีใดที่มีประสิทธิภาพในการต่อสู้กับการโกงแบบนี้?

สำหรับการอ้างอิงฉันรู้ว่าผู้เล่นสามารถ: - ค้นหาบางสิ่งบางอย่างตามค่าหรือช่วง - ค้นหาสิ่งที่เปลี่ยนค่า - ตั้งค่าหน่วยความจำ - ตรึงค่าหน่วยความจำ

ฉันกำลังมองหาสิ่งที่ดี ฉันสองคนใช้นั่นคือปานกลางคือ:

• แสดงค่าเป็นเปอร์เซ็นต์แทนที่จะเป็นตัวเลข (เช่น 46/50 = ความสมบูรณ์ 92%)
• คลาสระดับต่ำที่เก็บค่าไว้ในอาร์เรย์และย้ายไปพร้อมกับการเปลี่ยนแปลงแต่ละครั้ง (ตัวอย่างเช่นแทนที่จะเป็น int ฉันมีคลาสที่เป็นอาร์เรย์ของ ints และเมื่อใดก็ตามที่การเปลี่ยนแปลงค่าฉันจะใช้รายการอาร์เรย์ที่แตกต่างกันที่สุ่มเลือกไว้เพื่อเก็บค่า)

เกมออฟไลน์ฟรีและเล่นคนเดียว

แก้ไข:สำหรับลูกหลานฉันแก้ไขปัญหานี้ (ใน C #) และโพสต์โซลูชันของฉันที่นี่ในบล็อกของฉัน

ความเป็นไปได้อีกอย่างหนึ่ง (สำหรับค่าจำนวนเต็ม) คือการมีสมาชิกตัวแปรที่สองซึ่งเก็บ bitwise ที่สมบูรณ์ของตัวแปรที่มีอยู่

ดังนั้นคิดว่าคุณได้คุณก็จะมีhealth healthComplementการใช้งานของคุณอาจมีลักษณะเช่นนี้:

// setter sets value and complement
void setHealth(int value){
    health = value;
    healthComplement = ~value;
}

// getter checks if value was changed outside of the setter
int getHealth(){
    if(value != ~healthComplement){
        // launch some cheat-counter-measure, like crashing the game?
        exit;
    }
    return health;
}

ใครบางคนที่ต้องการโกงจะต้องตั้งค่าสุขภาพและสุขภาพใช้งานอย่างถูกต้องมิฉะนั้นเกมจะผิดพลาด

ฉันคิดว่ามันไม่มีประโยชน์อะไรที่จะพยายามป้องกันสิ่งเช่นนี้ ผู้คนสร้างแฮ็ค / กลโกงได้สำเร็จสำหรับสิ่งที่ซับซ้อนมากขึ้นและมันไม่จำเป็นต้องทำให้รหัสของคุณยุ่งเหยิงหรือทำให้เกมของคุณแย่ลง

นี่คือหนึ่งในรูปแบบที่ฉันคิดขึ้นมาเมื่อมีคนถามหามันในบอร์ดนานแล้ว การใช้เปอร์เซ็นต์หรือตัวแปรสองเท่านั้นใช้งานไม่ได้จริง ๆ เพราะคุณสามารถค้นหาค่า "ใด ๆ " และตรึงไว้ได้

ให้ทำมอนสเตอร์ประเภทข้อมูลแทน

โดยพื้นฐานแล้วเก็บค่าสำคัญของคุณไว้เป็นโครงสร้างด้วย:

• 32 พอยน์เตอร์เป็นบิต
• สำหรับการอ่านอย่างรวดเร็วให้ struct ประกอบด้วยค่าปัจจุบันเป็น int ธรรมดาเช่นกัน

สำหรับการจัดการให้รวบรวมค่าปัจจุบันจากบิตที่จัดสรรแยกต่างหาก (ซึ่งอาจเป็นจริง / เท็จ ints) เปลี่ยนค่าแล้วเก็บไว้กลับ

นี่คือบิตที่น่ารังเกียจ: ทุกครั้งที่คุณจัดการค่าฟรีและจัดสรรบิตอีกครั้ง การจัดสรรควรเกิดขึ้นตามลำดับแบบสุ่มดังนั้นข้อมูลจึงกระโดดไปมาในหน่วยความจำและไม่สามารถถูกตรึงได้ง่าย

การป้องกันเพิ่มเติมคือการเก็บค่าเช็คซัมของค่า (รวมถึง "ธรรมดา" int) และเปรียบเทียบสิ่งเหล่านี้ระหว่างการเรียกใช้การจัดการ หากพบว่าไม่ตรงกันให้ทำสิ่งที่ละเอียดอ่อนเช่นลบคีย์สุ่มที่จำเป็นในการปลดล็อกประตูเพื่อความคืบหน้าในเกม

แก้ไข:สำหรับการเคลื่อนย้ายหน่วยความจำเพิ่มเติมตรวจสอบให้แน่ใจว่าคุณจัดสรร "บิต" ใหม่ก่อนที่จะเพิ่มหน่วยความจำเก่า

แก้ไข:สำหรับเกมที่มีผู้เล่นหลายคนอาจเป็นไปได้ที่จะจัดลำดับโครงสร้างข้อมูลบีบอัดและส่งผ่านเครือข่าย ไม่ใช่การใช้เครือข่ายที่มีประสิทธิภาพที่สุด แต่ก็ยากที่จะคิดออกโดยการสูดดมแพ็กเก็ต

วิธีการเกี่ยวกับคุณเก็บสุขภาพที่สมบูรณ์ด้วยค่าสุ่มที่สร้างขึ้นในแต่ละครั้งที่คุณเก็บไว้ อย่างน้อยที่สุดก็จะเอาชนะกลไกง่าย ๆ ของการค้นหาเพื่อเพิ่ม / ลดค่าในหน่วยความจำเพื่อค้นหาสุขภาพ

class Player
{
  int m_Health;
  int m_RandomHealth;
  Random m_Rnd = new Random();

  public int Health {
    get
    {
      return m_Health ^ m_RandomHealth;
    }

    set
    {
      m_RandomHealth = m_Rnd.Next();
      m_Health = value ^ m_RandomHealth;
    }
  }
}

นอกจากนี้คุณอาจต้องการรีเซ็ตค่าในแต่ละเฟรมแม้ว่าสุขภาพจะไม่เปลี่ยน วิธีนี้จะป้องกันไม่ให้ผู้คนค้นหาที่อยู่ที่ถูกเปลี่ยนแปลงเมื่อสุขภาพของพวกเขาเปลี่ยนแปลงและจะยังคงเหมือนเดิมเมื่อสุขภาพของพวกเขายังคงเหมือนเดิม

โบนัส: สร้างวัตถุใหม่ทุกครั้งที่มีการเปลี่ยนแปลงดังนั้นการเปลี่ยนแปลงหน่วยความจำและตั้งค่าสถานะเพื่อเปลี่ยนหมายเลขสุ่มค่า xored และที่อยู่ในหน่วยความจำทุกครั้งที่คุณอ่าน :

class Player
{
  int [] m_HealthArray; // [0] is random int, [1] is xored health
  Random m_Rnd = new Random();

  public Player() {
    this.Health = 100;
  }

  public int Health {
    get
    {
      int health = m_HealthArray[0] ^ m_HealthArray[1];
      Health = health; // reset to move in memory and change xor value
      return health;
    }

    set
    {
      m_HealthArray = new int[2];
      m_HealthArray[0] = m_Rnd.Next();
      m_HealthArray[1] = m_HealthArray[0] ^ value;
    }
  }
}

แม้ว่าฉันจะแสดงความคิดเห็นครั้งแรกซึ่งตั้งคำถามถึงจุดที่ลดระดับประสบการณ์ของผู้ชมของคุณบางส่วนโดยที่ไม่ได้รับความชัดเจน แต่ฉันก็ยังพบว่ามันเป็นคำถามที่น่าสนใจจากมุมมองทางเทคนิค

ฉันเพิ่งมีความคิดนี้: สิ่งที่คนขี้โกงทำคือค้นหาค่าที่เปลี่ยนแปลงและตรึงพวกเขา การค้นหาจะเกิดขึ้นเฉพาะระหว่างการเสียชีวิตหรือเหตุการณ์ที่เปลี่ยนสุขภาพของผู้เล่น ยิ่งไปกว่านั้นสิบแปดมงกุฎสามารถปรับแต่งการค้นหาโดยการกรองสิ่งที่เปลี่ยนแปลงเมื่อเขา "ไม่ตาย"

เกิดอะไรขึ้นถ้าตัวนับ "สุขภาพ" กำลังเปลี่ยนแปลงตลอดเวลา ทำให้เป็นตัวชี้และจัดสรรใหม่ทุกเฟรมหรือทุกเฟรม N หากประสิทธิภาพการทำงานใหญ่เกินไป หรือ XOR ด้วยค่าสุ่มที่เปลี่ยนทุกเฟรม (XORing อีกครั้งกับค่าเดียวกันสำหรับการถอดรหัสก่อนที่จะเข้ารหัสด้วยค่าสุ่มใหม่)

หากคุณมีข้อมูลในเกมอื่น ๆ ก็เปลี่ยนเวลาทั้งหมด (รวมถึงตำแหน่ง x และ y ของตัวละครของผู้เล่นหรือตัวนับเวลา) ซึ่งอาจทำให้ยากต่อการค้นหาว่าข้อมูลใดที่เปลี่ยนแปลงไปนั้นเป็นเรื่องที่ดี และการแช่แข็งสถานะของเกมทั้งหมดเป็นสิ่งที่ไม่ต้องทำสำหรับผู้ชนะ

สำหรับการเข้าใจผิดเพิ่มเติมคุณสามารถเก็บสุขภาพไว้ในตัวแปรเขียนอย่างเดียวซึ่งแปลว่าหม้อน้ำผึ้ง

แก้ไข :

อย่างไรก็ตามผู้โกงอาจลองค้นหาว่าตัวแปรใดบ้างที่เปลี่ยนแปลงตลอดเวลาคือตัวแปรที่จะหยุดการทดลองและข้อผิดพลาด ทางออกที่เป็นไปได้คือการจับคู่ตัวแปรเข้าด้วยกัน

ตัวอย่าง:

แทนที่จะเก็บสุขภาพ (h) และ position (x) คุณเก็บไว้ในสองตัวแปร a และ b ซึ่งคุณสามารถดึงค่าได้ในภายหลัง:

a = x+h; b = x-h
x = (a+b)/2; h = (a-b)/2

ด้วยวิธีนี้หากสิบแปดมงกุฎค้างเพียงหนึ่งในนั้นแล้วย้ายตัวละครตำแหน่งที่ได้รับผลกระทบและขึ้นอยู่กับว่าใครถูกแช่แข็ง, h ไปทางลบ (ตายทันที) คุณสามารถสลับระหว่างสูตรด้านบนและ:

a = x-h; b = x+h
x = (a+b)/2; h = (b-a)/2

ในเฟรมที่ต่อเนื่องกันและคุณรับประกันได้ว่ามากที่สุด 2 เฟรมหลังจากหนึ่งในตัวแปรที่ถูกตรึงไว้อย่างสมบูรณ์จะเปลี่ยนเป็น 0 ทันทีที่ x เปลี่ยน จำไว้ว่าคุณกำลังเก็บ a และ b เท่านั้น รวมสิ่งนี้เข้ากับ XOR อย่างต่อเนื่องตามที่กล่าวไว้ข้างต้น ผลที่ได้คือชุดของตัวแปรที่เปลี่ยนทุกเฟรมเป็นค่าสุ่มที่ดูเหมือนและการแช่แข็งหนึ่งเดียวหรือส่วนย่อยของพวกเขาเพียงสร้างผลข้างเคียงที่ไม่พึงประสงค์ในเกมตายทันทีเป็นหนึ่งในพวกเขา

ตัวเลือกหนึ่งที่เป็นไปได้ที่ฉันคิดว่าอาจใช้งานได้ (ฉันไม่คุ้นเคยกับเครื่องมือการโกงเหล่านี้): อย่าซ่อนมัน ดำเนินการของคุณและคาดหวังผลลัพธ์ที่แน่นอน หลังจากการดำเนินการ (อาจเป็นเฟรมถัดไป) ให้ตรวจสอบเพื่อให้แน่ใจว่าผลลัพธ์เป็นไปตามที่คุณต้องการ หากคุณลบสุขภาพแล้วตรวจสอบเพื่อค้นหาสุขภาพที่ไม่เคยเปลี่ยนคุณสามารถมั่นใจได้ (หากคุณไม่มีบั๊กที่คลุมเครือ) ที่ถูกล็อค

หากคุณตรวจพบการโกงตอนนี้คุณมีอิสระที่จะเปลี่ยนกฎของเกมตามที่คุณเห็นว่าเหมาะสมสำหรับความเศร้าโศกสูงสุดหากนั่นเป็นเจตนาของคุณ หากความตั้งใจของคุณคือการเพิกเฉยต่อการโกงและให้เกมทำงานต่อไปให้จัดสรรสุขภาพที่อื่นในหน่วยความจำและเปลี่ยนพอยน์เตอร์ของคุณเพื่อให้มีการใช้ค่าใหม่และไม่สนใจสิ่งเก่า ทำซ้ำ infinitum โฆษณา

ความพยายามใด ๆ ที่ทำให้งงงวยถูกผูกไว้กับความล้มเหลวในทางทฤษฎี แต่ในทางปฏิบัติคุณเพียงแค่ต้องทำให้มันยากพอที่จะทำลายความท้าทายที่จะกลายเป็นสนุกน้อยกว่าประสบความสำเร็จในเกม ฉันไม่รู้ว่าเกมของคุณคืออะไรดังนั้นฉันจะไม่เสี่ยงที่จะแนะนำวิธีการทำให้งงงวยข้อมูลแม้แต่น้อยเพราะฉันเชื่อว่าพวกเขาไม่มีจุดหมาย

ที่กล่าวมาและคุณอาจจะไม่ชอบมันฉันเชื่อว่าคุณกำลังมองหาหน่วยความจำที่หายไปซึ่งเป็นแนวคิดคอมพิวเตอร์ที่เชื่อถือได้

เทคนิคหนึ่งที่มีประสิทธิภาพมากที่ใช้โดย roguelikes (DoomRL, Brogue) คือการปกปิดตัวแปรที่แท้จริง สิ่งนี้หมายความว่าแทนที่จะแสดงสุขภาพเป็น "2/10" ให้แสดงเป็น "20%"

จำไว้ว่าตัวแก้ไขหน่วยความจำส่วนใหญ่ทำงานได้ดีกับการค้นหา / กรองค่าเฉพาะ หากคุณไม่ทราบค่าเฉพาะคุณยังสามารถติดตามได้ (เช่นค้นหาค่าที่เปลี่ยน / ลดลงหลังจากที่พลังชีวิตของผู้เล่นลดลง) แม้ว่าจะใช้เวลานานกว่านั้นในการทำเช่นนั้น

ฉันยังแนะนำให้ฟันเฟืองต่อต้านการโกง ตัวอย่างเช่นหากคุณมีเกมที่ผู้เล่นได้รับความเสียหายไม่เป็นบวกและสุขภาพของพวกเขาไม่ลดลงคุณสามารถตรวจสอบสิ่งนี้ได้อย่างง่ายดายและแม่นยำและรู้ว่าผู้เล่นโกง ทำสิ่งที่น่าสนใจเช่นวางไข่ศัตรูรอบตัวเขา :)

เขียนไดรเวอร์ ring 0 ที่ hooks SSDT และล็อก / บล็อกเมื่อมีการเรียก ReadProcessMemory / WriteProcessMemory ในแอปพลิเคชันของคุณ จะเป็นการดีกว่าถ้าคุณบันทึกไว้เพื่อให้คุณสามารถเปลี่ยนพฤติกรรมการเล่นเกมของพวกเขาในเวลาช้า ๆ แทนที่จะเป็นเพียงความผิดพลาด

ทำไมคุณถึงป้องกันไม่ให้ผู้เล่นโกงตัวเอง (ซึ่งการโกงในเกมที่มีผู้เล่นคนเดียว) ในสภาพแวดล้อมที่มีผู้เล่นหลายคนเป็นหน้าที่ของเซิร์ฟเวอร์ในการตรวจจับการเปลี่ยนแปลงที่ไม่เป็นธรรมชาติและตอบโต้ (โดยทั่วไปจะละเว้นการป้อนข้อมูลหรือบล็อกผู้ร้ายออกจากเซิร์ฟเวอร์อย่างสมบูรณ์) แต่ในสภาพแวดล้อมของผู้เล่นเดี่ยวไม่มีอะไรเกิดขึ้นยกเว้น การก่อความเสียหาย

IOW นอกจากว่าคุณกำลังสร้างเกมที่มีผู้เล่นหลายคนมันเป็นการเสียเงินและถ้าคุณกำลังคิดที่จะทำให้สถานที่แห่งนั้นยาก

วิจัยเครื่องมือการโกงที่รู้จักกัน - และตรวจสอบบ่อยๆว่ามีการตรวจพบเครื่องมือใดที่พบบ่อยที่สุดหรือไม่ (ตรวจสอบชื่อกระบวนการ)

หากมีการตรวจพบให้ผู้เล่นโกง (ถ้าออฟไลน์มันไม่เป็นอันตราย) แต่ให้แน่ใจว่าจะไม่มีการโพสต์คะแนน / ความสำเร็จลงในกระดานผู้นำ / ระบบการบรรลุผลออนไลน์ใด ๆ - เพียงแค่ทำให้มันล้มเหลวอย่างเงียบ ๆ ?

จะไม่หยุดแฮ็กเกอร์ที่ตั้งใจมากขึ้น แต่จะลดโอกาสของการโกงแบบไม่เป็นทางการที่ทำให้ลีดเดอร์บอร์ดของคุณยุ่งเหยิงยิ่งขึ้น

(อาจทำให้ผู้เขียนโค้ดรำคาญที่มีเครื่องมือ dev เปิดและย่อขนาดเพื่อวัตถุประสงค์ที่ถูกต้องและหยุดพักการเล่นเกมแม้ว่า ... )

ฉันคิดว่าวิธีแก้ปัญหาที่ง่ายที่สุดคือใช้ตัวเลือกโกง ปิดใช้งานการให้คะแนนขณะที่อยู่ในตัวเลือกโกง

อีกความคิดที่ดีที่ฉันไม่รู้ว่าคุณจะนำไปใช้อย่างไร คือการปิดเกมเมื่อมีตัวแปรหน่วยความจำแช่แข็งหรืออะไรทำนองนั้น :)

ขอให้โชคดี (Y)