สร้างคำขอ API แบบคลาสสิก

หากคุณวางแผนที่จะสร้างเฉพาะคำขอ API มาตรฐานซึ่งเหมาะสำหรับนักพัฒนาแอปส่วนใหญ่ คุณสามารถข้ามไปยังคำตัดสินเกี่ยวกับความสมบูรณ์ได้เลย หน้านี้อธิบายการส่งคำขอ API แบบคลาสสิกสำหรับการตัดสินความสมบูรณ์ ซึ่งรองรับใน Android 4.4 (ระดับ API 19) ขึ้นไป

ข้อควรพิจารณา

เปรียบเทียบคำขอมาตรฐานและคำขอแบบคลาสสิก

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

ตารางต่อไปนี้จะไฮไลต์ความแตกต่างที่สําคัญระหว่างคําขอทั้ง 2 ประเภท

คําขอ API มาตรฐาน คำขอ API แบบคลาสสิก
ข้อกำหนดเบื้องต้น
Android SDK ขั้นต่ำที่จำเป็น* Android 6.0 (ระดับ API 23) ขึ้นไป Android 6.0 (ระดับ API 23) ขึ้นไป
ข้อกำหนดของ Google Play Google Play Store และบริการ Google Play Google Play Store และบริการ Google Play
รายละเอียดการผสานรวม
ต้องมีการเตรียม API ให้พร้อมใช้งาน ✔️ (ไม่กี่วินาที) ❌
เวลาในการตอบสนองต่อคำขอโดยทั่วไป ไม่กี่ร้อยมิลลิวินาที ไม่กี่วินาที
ความถี่ในการส่งคำขอที่เป็นไปได้ บ่อยครั้ง (ตรวจสอบการดำเนินการหรือคำขอตามต้องการ) ไม่บ่อย (การตรวจสอบแบบครั้งเดียวสำหรับการดำเนินการที่มีมูลค่าสูงสุดหรือคำขอที่มีความละเอียดอ่อนมากที่สุด)
หมดเวลา การเตรียมพร้อมส่วนใหญ่ใช้เวลาไม่ถึง 10 วินาที แต่เกี่ยวข้องกับการเรียกเซิร์ฟเวอร์ จึงขอแนะนำให้ใช้ระยะหมดเวลาที่นาน (เช่น 1 นาที) คำขอคำตัดสินจะเกิดขึ้นฝั่งไคลเอ็นต์ คำขอส่วนใหญ่ใช้เวลาไม่ถึง 10 วินาที แต่เกี่ยวข้องกับการเรียกเซิร์ฟเวอร์ ดังนั้นเราขอแนะนำให้ใช้ระยะหมดเวลาที่นาน (เช่น 1 นาที)
โทเค็นการตัดสินความสมบูรณ์
มีรายละเอียดอุปกรณ์ แอป และบัญชี ✔️ ✔️
การแคชโทเค็น การแคชในอุปกรณ์ที่ได้รับการปกป้องโดย Google Play ไม่แนะนำ
ถอดรหัสและยืนยันโทเค็นโดยใช้เซิร์ฟเวอร์ Google Play ✔️ ✔️
เวลาในการตอบสนองของคำขอแบบเซิร์ฟเวอร์ต่อเซิร์ฟเวอร์สำหรับการถอดรหัสทั่วไป 10 มิลลิวินาทีพร้อมความพร้อมใช้งาน 99.9% 10 มิลลิวินาทีพร้อมความพร้อมใช้งาน 99.9%
ถอดรหัสและยืนยันโทเค็นในเครื่องในสภาพแวดล้อมเซิร์ฟเวอร์ที่ปลอดภัย ❌ ✔️
ถอดรหัสและยืนยันโทเค็นฝั่งไคลเอ็นต์ ❌ ❌
ความใหม่ของการตัดสินความสมบูรณ์ การแคชและการรีเฟรชอัตโนมัติบางอย่างโดย Google Play ระบบจะคำนวณคำตัดสินทั้งหมดใหม่ในคำขอแต่ละรายการ
ขีดจำกัด
คำขอต่อแอปต่อวัน 10,000 รายการโดยค่าเริ่มต้น (ขอเพิ่มได้) 10,000 รายการโดยค่าเริ่มต้น (ขอเพิ่มได้)
คำขอต่ออินสแตนซ์แอปต่อนาที การเตรียมพร้อม: 5 ครั้งต่อนาที
โทเค็นความสมบูรณ์: ไม่มีขีดจำกัดสาธารณะ**
โทเค็นความสมบูรณ์: 5 รายการต่อนาที
การปกป้อง
ลดความเสี่ยงจากการปลอมแปลงและการโจมตีที่คล้ายกัน ใช้ช่อง requestHash ใช้ช่อง nonce กับการเชื่อมโยงเนื้อหาตามข้อมูลคำขอ
ลดความเสี่ยงจากการโจมตีแบบ Replay และการโจมตีที่คล้ายกัน การลดความเสี่ยงโดยอัตโนมัติโดย Google Play ใช้ช่อง nonce กับตรรกะฝั่งเซิร์ฟเวอร์

* สำหรับไลบรารี Play Integrity API v1.4.0 ขึ้นไป Android SDK ขั้นต่ำที่รองรับจะเหมือนกันสำหรับคำขอทั้ง 2 ประเภท และกำหนดโดย minSdkVersion ของไลบรารี สำหรับ v1.3.0 และรุ่นก่อนหน้า Android SDK ขั้นต่ำที่จำเป็นคือ Android 5.0 (ระดับ API 21) สำหรับคำขอ API มาตรฐาน และ Android 4.4 (ระดับ API 19) สำหรับคำขอ API แบบคลาสสิก

** คำขอทั้งหมด รวมถึงคำขอที่ไม่มีขีดจำกัดแบบสาธารณะ จะขึ้นอยู่กับขีดจำกัดการป้องกันที่ไม่ใช่แบบสาธารณะที่ค่าสูง

ส่งคำขอแบบคลาสสิกไม่บ่อยนัก

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

หลีกเลี่ยงการแคชคำตัดสิน

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

ใช้ช่อง Nonce เพื่อปกป้องคำขอแบบคลาสสิก

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

ลองส่งคำขอแบบคลาสสิกอีกครั้งโดยใช้ Exponential Backoff

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

ภาพรวม

รูปที่ 1 แผนภาพลำดับที่แสดงการออกแบบระดับสูงของ Play Integrity API

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

  1. แบ็กเอนด์ฝั่งเซิร์ฟเวอร์ของแอปจะสร้างและส่งค่าที่ไม่ซ้ำกันไปยังตรรกะฝั่งไคลเอ็นต์ ขั้นตอนที่เหลือจะอ้างอิงตรรกะนี้เป็น "แอป" ของคุณ
  2. แอปของคุณจะสร้าง nonce จากค่าที่ไม่ซ้ำกันและเนื้อหาของการกระทำที่มีคุณค่าสูง จากนั้นจะเรียกใช้ Play Integrity API โดยส่ง nonce เข้าไป
  3. แอปของคุณจะได้รับผลการตัดสินที่ลงนามและเข้ารหัสจาก Play Integrity API
  4. แอปของคุณจะส่งคำตัดสินที่ลงนามและเข้ารหัสแล้วไปยังแบ็กเอนด์ของแอป
  5. แบ็กเอนด์ของแอปจะส่งคำตัดสินไปยังเซิร์ฟเวอร์ Google Play เซิร์ฟเวอร์ Google Play จะถอดรหัสและยืนยันการตัดสิน แล้วส่งผลลัพธ์กลับไปยังแบ็กเอนด์ของแอป
  6. แบ็กเอนด์ของแอปจะกำหนดวิธีดำเนินการต่อโดยอิงตามสัญญาณที่อยู่ในเพย์โหลดของโทเค็น
  7. แบ็กเอนด์ของแอปจะส่งผลลัพธ์ของการตัดสินใจไปยังแอปของคุณ

สร้าง Nonce

เมื่อปกป้องการดำเนินการในแอปด้วย Play Integrity API คุณสามารถใช้ประโยชน์จากช่อง nonce เพื่อลดการโจมตีบางประเภท เช่น การโจมตีด้วยการปลอมแปลงแบบ Person-in-the-Middle (PITM) และการโจมตีแบบ Replay Play Integrity API จะแสดงค่าที่คุณตั้งไว้ในช่องนี้ภายในการตอบกลับความสมบูรณ์ที่ลงนามแล้ว

ค่าที่ตั้งไว้ในช่อง nonce ต้องจัดรูปแบบอย่างถูกต้อง ดังนี้

  • String
  • URL-safe
  • เข้ารหัสเป็น Base64 และไม่ตัดบรรทัด
  • มีอักขระอย่างน้อย 16 ตัว
  • มีอักขระได้สูงสุด 500 ตัว

ต่อไปนี้เป็นวิธีทั่วไปในการใช้ช่อง nonce ใน Play Integrity API หากต้องการรับการปกป้องที่รัดกุมที่สุดจาก nonce คุณสามารถรวมวิธีการด้านล่างเข้าด้วยกันได้

รวมแฮชคำขอเพื่อป้องกันการปลอมแปลง

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

เมื่อคุณขอการตัดสินความสมบูรณ์

  1. คำนวณไดเจสต์ของพารามิเตอร์คำขอที่สำคัญทั้งหมด (เช่น SHA256 ของการจัดเรียงข้อมูลคำขอที่เสถียร) จากการดำเนินการของผู้ใช้หรือคำขอของเซิร์ฟเวอร์ที่เกิดขึ้น
  2. ใช้ setNonce เพื่อตั้งค่าช่อง nonce เป็นค่าของไดเจสต์ที่คำนวณแล้ว

เมื่อได้รับการตัดสินความสมบูรณ์ ให้ทำดังนี้

  1. ถอดรหัสและยืนยันโทเค็นความสมบูรณ์ และรับไดเจสต์จากช่อง nonce
  2. คำนวณไดเจสต์ของคำขอในลักษณะเดียวกับในแอป (เช่น SHA256 ของการเรียงลำดับคำขอที่เสถียร)
  3. เปรียบเทียบไดเจสต์ฝั่งแอปและฝั่งเซิร์ฟเวอร์ หากไม่ตรงกัน แสดงว่าคำขอไม่น่าเชื่อถือ

รวมค่าที่ไม่ซ้ำกันเพื่อป้องกันการโจมตีแบบ Replay Attack

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

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

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

เมื่อได้รับการตัดสินความสมบูรณ์ ให้ทำดังนี้

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

รวมการป้องกันทั้ง 2 แบบเพื่อป้องกันการปลอมแปลงและการโจมตีแบบ Replay (แนะนำ)

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

เมื่อคุณขอการตัดสินความสมบูรณ์

  1. ผู้ใช้เริ่มดำเนินการที่มีมูลค่าสูง
  2. รับค่าที่ไม่ซ้ำกันสำหรับการดำเนินการนี้ตามที่อธิบายไว้ในส่วนรวมค่าที่ไม่ซ้ำกันเพื่อป้องกันการโจมตีแบบ Replay
  3. เตรียมข้อความที่ต้องการปกป้อง ใส่ค่าที่ไม่ซ้ำกันจากขั้นตอนที่ 2 ในข้อความ
  4. แอปของคุณจะคำนวณไดเจสต์ของข้อความที่ต้องการปกป้องตามที่อธิบายไว้ในส่วนรวมแฮชคำขอเพื่อป้องกันการปลอมแปลง เนื่องจากข้อความมีค่าที่ไม่ซ้ำกัน ค่าที่ไม่ซ้ำกันจึงเป็นส่วนหนึ่งของแฮช
  5. ใช้ setNonce() เพื่อตั้งค่าฟิลด์ nonce เป็นไดเจสต์ที่คำนวณจากขั้นตอนก่อนหน้า

เมื่อได้รับการตัดสินความสมบูรณ์ ให้ทำดังนี้

  1. รับค่าที่ไม่ซ้ำกันจากคำขอ
  2. ถอดรหัสและยืนยันโทเค็นความสมบูรณ์ และรับไดเจสต์จากช่อง nonce
  3. ตามที่อธิบายไว้ในส่วนรวมแฮชคำขอเพื่อป้องกันการปลอมแปลง ให้คำนวณไดเจสต์อีกครั้งฝั่งเซิร์ฟเวอร์ และตรวจสอบว่าตรงกับไดเจสต์ที่ได้จากโทเค็นความสมบูรณ์หรือไม่
  4. ตามที่อธิบายไว้ในส่วนรวมค่าที่ไม่ซ้ำกันเพื่อป้องกันการโจมตีแบบ Replay ให้ตรวจสอบความถูกต้องของค่าที่ไม่ซ้ำกัน

แผนภาพลำดับต่อไปนี้แสดงขั้นตอนเหล่านี้ด้วย nonce ฝั่งเซิร์ฟเวอร์

รูปที่ 2 แผนภาพลำดับที่แสดงวิธีป้องกันทั้งการปลอมแปลงและการโจมตีแบบ Replay

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

หลังจากสร้าง nonce แล้ว คุณสามารถขอผลการตัดสินความสมบูรณ์จาก Google Play ได้ โดยทำตามขั้นตอนต่อไปนี้

  1. สร้าง IntegrityManager ดังที่แสดงในตัวอย่างต่อไปนี้
  2. สร้าง IntegrityTokenRequest โดยระบุ nonce ผ่านเมธอด setNonce() ในเครื่องมือสร้างที่เกี่ยวข้อง แอปที่เผยแพร่นอก Google Play และ SDK เท่านั้นยังต้องระบุหมายเลขโปรเจ็กต์ Google Cloud ผ่านเมธอด setCloudProjectNumber() ด้วย แอปใน Google Play จะลิงก์กับโปรเจ็กต์ที่อยู่ในระบบคลาวด์ใน Play Console และไม่จำเป็นต้องตั้งค่าหมายเลขโปรเจ็กต์ที่อยู่ในระบบคลาวด์ในคำขอ
  3. ใช้ตัวจัดการเพื่อเรียก requestIntegrityToken() โดยระบุ IntegrityTokenRequest ข้อควรระวัง: ระบบจะส่งค่า nonce ไปยังระบบของ Google ตามที่เป็นอยู่ ดังนั้นคุณจึงไม่ควรใส่ข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้หรือข้อมูลที่ละเอียดอ่อนอื่นๆ ไว้ใน nonce โดยตรงหรือโดยอ้อม

Kotlin

// Receive the nonce from the secure server.
val nonce: String = ...

// Create an instance of a manager.
val integrityManager =
    IntegrityManagerFactory.create(applicationContext)

// Request the integrity token by providing a nonce.
val integrityTokenResponse: Task<IntegrityTokenResponse> =
    integrityManager.requestIntegrityToken(
        IntegrityTokenRequest.builder()
             .setNonce(nonce)
             .build())

Java

import com.google.android.gms.tasks.Task; ...

// Receive the nonce from the secure server.
String nonce = ...

// Create an instance of a manager.
IntegrityManager integrityManager =
    IntegrityManagerFactory.create(getApplicationContext());

// Request the integrity token by providing a nonce.
Task<IntegrityTokenResponse> integrityTokenResponse =
    integrityManager
        .requestIntegrityToken(
            IntegrityTokenRequest.builder().setNonce(nonce).build());

Unity

IEnumerator RequestIntegrityTokenCoroutine() {
  // Receive the nonce from the secure server.
  var nonce = ...

// Initialize the V2 manager. Requires Play Integrity Unity Plugin v2.0.0 // or higher. var integrityManager = new IntegrityManagerV2();

// Request the integrity token by providing a nonce. var tokenRequest = new IntegrityTokenRequest(nonce); var requestIntegrityTokenOperation = integrityManager.RequestIntegrityToken(tokenRequest);

// Wait for PlayAsyncOperation to complete. yield return requestIntegrityTokenOperation;

// Check the resulting error code. if (requestIntegrityTokenOperation.Error != null && requestIntegrityTokenOperation.Error.ErrorCode != IntegrityErrorCode.NoError) { AppendStatusLog("IntegrityAsyncOperation failed with error: " + requestIntegrityTokenOperation.Error.ErrorCode); yield break; }

// Get the response. var tokenResponse = requestIntegrityTokenOperation.GetResult(); }

Unreal Engine

// .h
void MyClass::OnRequestIntegrityTokenCompleted(
  EIntegrityErrorCode ErrorCode,
  UIntegrityTokenResponse* Response)
{
  // Check the resulting error code.
  if (ErrorCode == EIntegrityErrorCode::Integrity_NO_ERROR)
  {
    // Get the token.
    FString Token = Response->Token;
  }
}

// .cpp
void MyClass::RequestIntegrityToken()
{
  // Receive the nonce from the secure server.
  FString Nonce = ...

  // Create the Integrity Token Request.
  FIntegrityTokenRequest Request = { Nonce };

  // Create a delegate to bind the callback function.
  FIntegrityOperationCompletedDelegate Delegate;

  // Bind the completion handler (OnRequestIntegrityTokenCompleted) to the delegate.
  Delegate.BindDynamic(this, &MyClass::OnRequestIntegrityTokenCompleted);

  // Initiate the integrity token request, passing the delegate to handle the result.
  GetGameInstance()
    ->GetSubsystem<UIntegrityManager>()
    ->RequestIntegrityToken(Request, Delegate);
}

เนทีฟ

/// Create an IntegrityTokenRequest opaque object.
const char* nonce = RequestNonceFromServer();
IntegrityTokenRequest* request;
IntegrityTokenRequest_create(&request);
IntegrityTokenRequest_setNonce(request, nonce);

/// Prepare an IntegrityTokenResponse opaque type pointer and call /// IntegerityManager_requestIntegrityToken(). IntegrityTokenResponse* response; IntegrityErrorCode error_code = IntegrityManager_requestIntegrityToken(request, &response);

/// ... /// Proceed to polling iff error_code == INTEGRITY_NO_ERROR if (error_code != INTEGRITY_NO_ERROR) { /// Remember to call the *_destroy() functions. return; } /// ... /// Use polling to wait for the async operation to complete. /// Note, the polling shouldn't block the thread where the IntegrityManager /// is running.

IntegrityResponseStatus response_status;

/// Check for error codes. IntegrityErrorCode error_code = IntegrityTokenResponse_getStatus(response, &response_status); if (error_code == INTEGRITY_NO_ERROR && response_status == INTEGRITY_RESPONSE_COMPLETED) { const char* integrity_token = IntegrityTokenResponse_getToken(response); SendTokenToServer(integrity_token); } /// ... /// Remember to free up resources. IntegrityTokenRequest_destroy(request); IntegrityTokenResponse_destroy(response); IntegrityManager_destroy();

ถอดรหัสและยืนยันการตัดสินความสมบูรณ์

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

รูปแบบโทเค็น

โทเค็นเป็น JSON Web Token (JWT) ที่ซ้อนกัน ซึ่งก็คือ JSON Web Encryption (JWE) ของ JSON Web Signature (JWS) คอมโพเนนต์ JWE และ JWS จะแสดงโดยใช้การเรียงอันดับแบบกะทัดรัด

อัลกอริทึมการเข้ารหัส/การลงนามได้รับการรองรับอย่างดีในการใช้งาน JWT ต่างๆ ดังนี้

  • JWE ใช้ A256KW สำหรับ alg และ A256GCM สำหรับ enc

  • JWS ใช้ ES256

ถอดรหัสและยืนยันในเซิร์ฟเวอร์ของ Google (แนะนำ)

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

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

    playintegrity.googleapis.com/v1/PACKAGE_NAME:decodeIntegrityToken -d \
    '{ "integrity_token": "INTEGRITY_TOKEN" }'
  3. อ่านการตอบกลับ JSON

ถอดรหัสและยืนยันในเครื่อง

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

ตัวอย่างต่อไปนี้แสดงวิธีถอดรหัสคีย์ AES และคีย์ EC สาธารณะที่เข้ารหัส DER สำหรับการยืนยันลายเซ็นจาก Play Console เป็นคีย์เฉพาะภาษา (ในกรณีของเราคือภาษาโปรแกรม Java) ในแบ็กเอนด์ของแอป โปรดทราบว่าคีย์จะเข้ารหัส Base64 โดยใช้แฟล็กเริ่มต้น

Kotlin

// base64OfEncodedDecryptionKey is provided through Play Console.
var decryptionKeyBytes: ByteArray =
    Base64.decode(base64OfEncodedDecryptionKey, Base64.DEFAULT)

// Deserialized encryption (symmetric) key.
var decryptionKey: SecretKey = SecretKeySpec(
    decryptionKeyBytes,
    /* offset= */ 0,
    AES_KEY_SIZE_BYTES,
    AES_KEY_TYPE
)

// base64OfEncodedVerificationKey is provided through Play Console.
var encodedVerificationKey: ByteArray =
    Base64.decode(base64OfEncodedVerificationKey, Base64.DEFAULT)

// Deserialized verification (public) key.
var verificationKey: PublicKey = KeyFactory.getInstance(EC_KEY_TYPE)
    .generatePublic(X509EncodedKeySpec(encodedVerificationKey))

Java

// base64OfEncodedDecryptionKey is provided through Play Console.
byte[] decryptionKeyBytes =
    Base64.decode(base64OfEncodedDecryptionKey, Base64.DEFAULT);

// Deserialized encryption (symmetric) key.
SecretKey decryptionKey =
    new SecretKeySpec(
        decryptionKeyBytes,
        /* offset= */ 0,
        AES_KEY_SIZE_BYTES,
        AES_KEY_TYPE);

// base64OfEncodedVerificationKey is provided through Play Console.
byte[] encodedVerificationKey =
    Base64.decode(base64OfEncodedVerificationKey, Base64.DEFAULT);
// Deserialized verification (public) key.
PublicKey verificationKey =
    KeyFactory.getInstance(EC_KEY_TYPE)
        .generatePublic(new X509EncodedKeySpec(encodedVerificationKey));

จากนั้นใช้คีย์เหล่านี้เพื่อถอดรหัสโทเค็นความสมบูรณ์ (ส่วน JWE) ก่อน แล้วจึงยืนยันและดึงข้อมูลส่วน JWS ที่ฝังอยู่

Kotlin

val jwe: JsonWebEncryption =
    JsonWebStructure.fromCompactSerialization(integrityToken) as JsonWebEncryption
jwe.setKey(decryptionKey)

// This also decrypts the JWE token.
val compactJws: String = jwe.getPayload()

val jws: JsonWebSignature =
    JsonWebStructure.fromCompactSerialization(compactJws) as JsonWebSignature
jws.setKey(verificationKey)

// This also verifies the signature.
val payload: String = jws.getPayload()

Java

JsonWebEncryption jwe =
    (JsonWebEncryption)JsonWebStructure
        .fromCompactSerialization(integrityToken);
jwe.setKey(decryptionKey);

// This also decrypts the JWE token.
String compactJws = jwe.getPayload();

JsonWebSignature jws =
    (JsonWebSignature) JsonWebStructure.fromCompactSerialization(compactJws);
jws.setKey(verificationKey);

// This also verifies the signature.
String payload = jws.getPayload();

เพย์โหลดที่ได้คือโทเค็นข้อความธรรมดาที่มีคำตัดสินด้านความสมบูรณ์

แก้ไขปัญหาเกี่ยวกับคำตัดสินด้วยข้อความแจ้งของ Google Play (ไม่บังคับ)

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

Play Integrity API มีตัวเลือกในการแสดงกล่องโต้ตอบ Google Play ที่แจ้งให้ผู้ใช้ดำเนินการ เช่น ดาวน์โหลดแอปเวอร์ชันทางการจาก Google Play

ดูวิธีทริกเกอร์กล่องโต้ตอบเหล่านี้จากแอปตามการตอบกลับของเซิร์ฟเวอร์ได้ที่กล่องโต้ตอบการแก้ไข