ผสานรวม Play Integrity สำหรับ PC เข้ากับแอป

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

สิ่งที่ต้องดำเนินการก่อน

• ตั้งค่า SDK ให้เสร็จสมบูรณ์
• ตรวจสอบข้อควรพิจารณาด้านความปลอดภัยของ Integrity API security considerations
• อ่านและทำความเข้าใจข้อกำหนดในการให้บริการและ ข้อมูลการจัดการข้อมูลของ Integrity API
• สร้างโปรเจ็กต์ที่อยู่ในระบบคลาวด์ในคอนโซล Google Cloud หรือ เลือกโปรเจ็กต์ที่อยู่ในระบบคลาวด์ที่มีอยู่ซึ่งคุณต้องการใช้กับ Play Integrity สำหรับ PC ไปที่ API และบริการ และ เปิดใช้ Google Play Integrity API
• หากคาดว่าจะส่งคำขอ Play Integrity สำหรับ PC มากกว่า 10, 000 รายการต่อวัน คุณ ควรขอเพิ่มคำขอสูงสุดต่อวัน

ขั้นตอนที่ 1: ตัดสินใจว่าจะใช้ Play Integrity สำหรับ PC ในเกมอย่างไร

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

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

ขั้นตอนที่ 2: ขอโทเค็นความสมบูรณ์ในเกม

เตรียมความพร้อม Play Integrity สำหรับ PC

เตรียมความพร้อม (หรือ "วอร์มอัป") Play Integrity สำหรับ PC ซึ่งจะช่วยให้ Google Play แคชข้อมูลการรับรองบางส่วนในอุปกรณ์ได้อย่างชาญฉลาดเพื่อลดเวลาในการตอบสนองในเส้นทางวิกฤตเมื่อคุณส่งคำขอผลการตัดสินความสมบูรณ์ คุณสามารถดำเนินการนี้แบบไม่พร้อมกันทันทีที่เกมเปิดขึ้นเพื่อให้ส่งคำขอความสมบูรณ์ตามความต้องการได้ทุกเมื่อที่ต้องการ

void PrepareIntegrityToken(
  const PrepareIntegrityTokenParams & params,
  PrepareIntegrityTokenContinuation continuation
)

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

ควรเรียกใช้ PrepareIntegrityToken ก็ต่อเมื่อแอปพลิเคชันพิจารณาว่าจำเป็นต้องประเมินผลการตัดสินความสมบูรณ์ใหม่อีกครั้งทั้งหมด

ข้อมูลโค้ดที่แสดงวิธีเรียกใช้การดำเนินการ PrepareIntegrityToken มีดังนี้

google::play::integrity::IntegrityClient client_;

google::play::integrity::PrepareIntegrityTokenResult
IntegrityInterface::PrepareIntegrityToken(int64_t cloud_project_number) {
  google::play::integrity::PrepareIntegrityTokenParams params;
  params.cloud_project_number = cloud_project_number;

  auto promise = std::make_shared<
      std::promise<google::play::integrity::PrepareIntegrityTokenResult>>();
  client_.PrepareIntegrityToken(
      params,
      [promise](
          google::play::integrity::PrepareIntegrityTokenResult result) {
        promise->set_value(std::move(result));
      });

  return promise->get_future().get();
}

ขอโทเค็นความสมบูรณ์

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

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

void RequestIntegrityToken(
  const RequestIntegrityTokenParams & params,
  RequestIntegrityTokenContinuation continuation
)

หากต้องการลดโอกาสที่จะเกิดการโจมตี เมื่อคุณขอผลการตัดสินความสมบูรณ์ ให้ทำดังนี้

• คำนวณค่าสรุปของพารามิเตอร์คำขอที่เกี่ยวข้องทั้งหมด (เช่น SHA256 ของการซีเรียลไลซ์คำขอที่เสถียร) จากการดำเนินการของผู้ใช้หรือคำขอของเซิร์ฟเวอร์ที่เกิดขึ้น
• ตั้งค่าฟิลด์ RequestIntegrityTokenParams::request_hash เป็นค่า สรุป

ข้อมูลโค้ดที่แสดงวิธีเรียกใช้การดำเนินการ RequestIntegrityToken มีดังนี้

absl::StatusOr<google::play::integrity::RequestIntegrityTokenResult>
IntegrityInterface::RequestIntegrityToken(
    const google::play::integrity::PrepareIntegrityTokenResult&
        prepare_integrity_token_result,
    const std::string& request_hash) {
  // Check if the prepare_integrity_token_result is OK
  if (!prepare_integrity_token_result.ok()) {
    return absl::FailedPreconditionError(
        absl::StrCat("PrepareIntegrityTokenResult is not OK. Error code: ",
                     prepare_integrity_token_result.error_code));
  }

  google::play::integrity::RequestIntegrityTokenParams params{
      .request_token_data =
          prepare_integrity_token_result.request_token_data,
      .request_hash = request_hash};

  auto promise = std::make_shared<std::promise<
      google::play::integrity::RequestIntegrityTokenResult>>();
  client_.RequestIntegrityToken(
      params,
      [promise](google::play::integrity::RequestIntegrityTokenResult result) {
        promise->set_value(std::move(result));
      });

  return promise->get_future().get();
}

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

ถอดรหัสโทเค็นความสมบูรณ์

หลังจากที่คุณขอผลการตัดสินความสมบูรณ์แล้ว Play Integrity API จะแสดงผลโทเค็นการตอบกลับที่เข้ารหัส หากต้องการรับผลการตัดสินความสมบูรณ์ของอุปกรณ์ คุณต้องถอดรหัสโทเค็นความสมบูรณ์ในเซิร์ฟเวอร์ของ Google โดยทำดังนี้

1. สร้างบัญชีบริการภายในโปรเจ็กต์ Google Cloud ที่ลิงก์กับแอป

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

   playintegrity.googleapis.com/v1/<var>PACKAGE_NAME</var>:decodePcIntegrityToken -d \
    '{ "integrity_token": "<var>INTEGRITY_TOKEN</var>" }'
   

3. อ่านการตอบกลับ JSON

เพย์โหลดที่ได้จะเป็นโทเค็นข้อความธรรมดาที่มีผลการตัดสินความสมบูรณ์และรายละเอียดต่างๆ พร้อมกับข้อมูลที่นักพัฒนาแอปให้ไว้ โทเค็นความสมบูรณ์ที่ถอดรหัสแล้วจะมีลักษณะดังนี้

{
  "requestDetails": {
    "requestPackageName": "com.your.package.name",
    "requestTime": "2025-08-29T13:10:37.285Z",
    "requestHash": "your_request_hash_string"
  },
  "deviceIntegrity": {
    "deviceRecognitionVerdict": [
      "MEETS_PC_INTEGRITY"
    ]
  },
  "accountDetails": {
    "appLicensingVerdict": "LICENSED"
  }
}

ยืนยันโทเค็นความสมบูรณ์

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

ฟิลด์ requestHash และ packageName ควรตรงกับฟิลด์ของคำขอเดิม ดังนั้น ให้ยืนยันส่วน requestDetails ของเพย์โหลด JSON โดยตรวจสอบว่า requestPackageName และ requestHash ตรงกับสิ่งที่ส่งในคำขอเดิม ดังที่แสดงในข้อมูลโค้ดต่อไปนี้

const auto& request_details = json_payload["requestDetails"];

if (request_details.value("requestPackageName", "") != <YOUR_PACKAGE_NAME>) {
  // Don't trust the verdicts.
}

// Check for the existence of the request_hash.
// If you set a request hash in the request and it's not present, you shouldn't
// trust the verdicts.
if (!request_details.contains("requestHash")) {
    // Don't trust the verdicts.
}


// The requestHash from request_details needs to match the request hash your
// app provided.
if (request_details.value("requestHash", "") != <PROVIDED_REQUEST_HASH>) {
    // Don't trust the verdicts.
}

// You can read the rest of payload's fields.

ขั้นตอนที่ 4: ตัดสินใจว่าจะดำเนินการใดบ้างตามผลการตัดสินความสมบูรณ์

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

"deviceIntegrity": {
  "deviceRecognitionVerdict": ["MEETS_PC_INTEGRITY"]
}
"accountDetails": {
  "appLicensingVerdict": "LICENSED"
}

การตัดสินความสมบูรณ์ของอุปกรณ์

deviceRecognitionVerdict อาจมีค่าต่อไปนี้

MEETS_PC_INTEGRITY

เกมกำลังทำงานในสภาพแวดล้อม PC ของแท้ ซึ่งระบบไม่พบการเปลี่ยนแก้วิธีการทำงานในอุปกรณ์

ค่าว่าง

เกมกำลังทำงานในอุปกรณ์ที่มีสัญญาณการโจมตี (เช่น การฮุก API) หรือการบุกรุกระบบ (เช่น อุปกรณ์ที่ใช้บริการ Google Desktop เวอร์ชันที่มีการเปลี่ยนแก้วิธีการทำงาน) หรือแอปไม่ทำงานในอุปกรณ์จริง (เช่น โปรแกรมจำลองที่ไม่ผ่านการตรวจสอบความน่าเชื่อถือของ Google Play)

การตัดสินเกี่ยวกับรายละเอียดบัญชี

appLicensingVerdict อาจมีค่าต่อไปนี้

LICENSED

ผู้ใช้มีสิทธิ์ในการใช้แอป กล่าวคือ ผู้ใช้ได้ติดตั้งหรืออัปเดตแอปของคุณจาก Google Play ในอุปกรณ์

UNLICENSED

ผู้ใช้ไม่มีสิทธิ์ในการใช้แอป กรณีเช่นนี้เกิดขึ้นเมื่อผู้ใช้โหลดแอปของคุณจากแหล่งที่ไม่รู้จัก หรือไม่ได้ดาวน์โหลดแอปจาก Google Play เป็นต้น

UNEVALUATED

ระบบไม่ได้ประเมินรายละเอียดการอนุญาตให้ใช้สิทธิ เนื่องจากไม่เป็นไปตามข้อกําหนดที่จําเป็น ซึ่งอาจเกิดขึ้นได้จากหลายสาเหตุ รวมถึงสาเหตุต่อไปนี้

• อุปกรณ์ไม่น่าเชื่อถือพอ
• Google Play ไม่รู้จักเวอร์ชันของแอปที่ติดตั้งในอุปกรณ์
• ผู้ใช้ไม่ได้ลงชื่อเข้าใช้ Google Play

ขั้นตอนที่ 5: จัดการรหัสข้อผิดพลาด

หากเกมส่งคำขอ Play Integrity สำหรับ PC และการเรียกใช้ล้มเหลว เกมจะได้รับรหัสข้อผิดพลาด ข้อผิดพลาดเหล่านี้อาจเกิดขึ้นได้จากหลายสาเหตุ เช่น ปัญหาด้านสภาพแวดล้อมอย่างการเชื่อมต่อเครือข่ายไม่ดี ปัญหาเกี่ยวกับการผสานรวม API หรือกิจกรรมที่เป็นอันตรายและการโจมตีที่เกิดขึ้น

รหัสข้อผิดพลาดที่ลองอีกครั้งได้

บางครั้งสาเหตุของข้อผิดพลาดเหล่านี้เกิดจากสภาวะชั่วคราว ดังนั้นคุณควรลองเรียกใช้อีกครั้งด้วยกลยุทธ์การรอแบบทวีคูณ

ดูคำแนะนำเพิ่มเติมเกี่ยวกับกลยุทธ์การลองอีกครั้งที่นี่

รหัสข้อผิดพลาดที่ลองอีกครั้งไม่ได้

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

ทดสอบการตอบกลับต่างๆ จาก Play Integrity API ภายในแอป

คุณสามารถสร้างการทดสอบเพื่อประเมินวิธีที่ Play Integrity API โต้ตอบกับแอป

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

2. สร้างตั๋วที่นี่ และรายงานว่ากลุ่ม Google กลุ่มใดจะ ได้รับการตอบกลับจาก API ใด ระบบจะกำหนดให้แต่ละกลุ่มได้รับการเลือกอย่างใดอย่างหนึ่งต่อไปนี้

   	ผลการตัดสินการอนุญาตให้ใช้สิทธิผ่าน	ผลการตัดสินการอนุญาตให้ใช้สิทธิไม่ผ่าน	ประเมินผลการตัดสินการอนุญาตให้ใช้สิทธิไม่ได้
   ความสมบูรณ์ของอุปกรณ์ผ่าน	ALLOWLIST_CONFIG_MEETS_PC_INTEGRITY_LICENSED	ALLOWLIST_CONFIG_MEETS_PC_INTEGRITY_UNLICENSED	ALLOWLIST_CONFIG_MEETS_PC_INTEGRITY_LICENSING_UNEVALUATED
   ความสมบูรณ์ของอุปกรณ์ไม่ผ่าน	ไม่มี	ไม่มี	ALLOWLIST_CONFIG_NO_PC_INTEGRITY_LICENSING_UNEVALUATED

   หากผลการตัดสินความสมบูรณ์ของอุปกรณ์ไม่ผ่าน ระบบจะแสดงผลการตัดสินการอนุญาตให้ใช้สิทธิเป็น UNEVALUATED เสมอ

3. คุณจะได้รับการแจ้งเตือนเมื่อคำขอได้รับการประมวลผลแล้วและผู้ใช้ทดสอบอยู่ในรายการที่อนุญาตให้รับผลการตัดสินความสมบูรณ์ที่กำหนดไว้ล่วงหน้าสำหรับการทดสอบ