หากคุณวางแผนที่จะสร้างเฉพาะคำขอ 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
ภาพรวม
เมื่อผู้ใช้ดำเนินการที่มีมูลค่าสูงในแอปซึ่งคุณต้องการปกป้องด้วยการตรวจสอบความสมบูรณ์ ให้ทำตามขั้นตอนต่อไปนี้
- แบ็กเอนด์ฝั่งเซิร์ฟเวอร์ของแอปจะสร้างและส่งค่าที่ไม่ซ้ำกันไปยังตรรกะฝั่งไคลเอ็นต์ ขั้นตอนที่เหลือจะอ้างอิงตรรกะนี้เป็น "แอป" ของคุณ
- แอปของคุณจะสร้าง
nonceจากค่าที่ไม่ซ้ำกันและเนื้อหาของการกระทำที่มีคุณค่าสูง จากนั้นจะเรียกใช้ Play Integrity API โดยส่งnonceเข้าไป - แอปของคุณจะได้รับผลการตัดสินที่ลงนามและเข้ารหัสจาก Play Integrity API
- แอปของคุณจะส่งคำตัดสินที่ลงนามและเข้ารหัสแล้วไปยังแบ็กเอนด์ของแอป
- แบ็กเอนด์ของแอปจะส่งคำตัดสินไปยังเซิร์ฟเวอร์ Google Play เซิร์ฟเวอร์ Google Play จะถอดรหัสและยืนยันการตัดสิน แล้วส่งผลลัพธ์กลับไปยังแบ็กเอนด์ของแอป
- แบ็กเอนด์ของแอปจะกำหนดวิธีดำเนินการต่อโดยอิงตามสัญญาณที่อยู่ในเพย์โหลดของโทเค็น
- แบ็กเอนด์ของแอปจะส่งผลลัพธ์ของการตัดสินใจไปยังแอปของคุณ
สร้าง 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 มาตรฐานเพื่อปกป้องเนื้อหาของคำขอจากการถูกแทรกแซง
เมื่อคุณขอการตัดสินความสมบูรณ์
- คำนวณไดเจสต์ของพารามิเตอร์คำขอที่สำคัญทั้งหมด (เช่น SHA256 ของการจัดเรียงข้อมูลคำขอที่เสถียร) จากการดำเนินการของผู้ใช้หรือคำขอของเซิร์ฟเวอร์ที่เกิดขึ้น
- ใช้
setNonceเพื่อตั้งค่าช่องnonceเป็นค่าของไดเจสต์ที่คำนวณแล้ว
เมื่อได้รับการตัดสินความสมบูรณ์ ให้ทำดังนี้
- ถอดรหัสและยืนยันโทเค็นความสมบูรณ์ และรับไดเจสต์จากช่อง
nonce - คำนวณไดเจสต์ของคำขอในลักษณะเดียวกับในแอป (เช่น SHA256 ของการเรียงลำดับคำขอที่เสถียร)
- เปรียบเทียบไดเจสต์ฝั่งแอปและฝั่งเซิร์ฟเวอร์ หากไม่ตรงกัน แสดงว่าคำขอไม่น่าเชื่อถือ
รวมค่าที่ไม่ซ้ำกันเพื่อป้องกันการโจมตีแบบ Replay Attack
เพื่อป้องกันไม่ให้ผู้ใช้ที่เป็นอันตรายนำการตอบกลับก่อนหน้าจาก Play Integrity API มาใช้ซ้ำ คุณสามารถใช้ช่อง nonce เพื่อระบุข้อความแต่ละรายการโดยไม่ซ้ำกัน
เมื่อคุณขอการตัดสินความสมบูรณ์ ระบบจะดำเนินการดังนี้
- รับค่าที่ไม่ซ้ำกันทั่วโลกในลักษณะที่ผู้ใช้ที่เป็นอันตรายไม่สามารถคาดเดาได้ ตัวอย่างเช่น ตัวเลขสุ่มที่ปลอดภัยจากการเข้ารหัสซึ่งสร้างขึ้นฝั่งเซิร์ฟเวอร์อาจเป็นค่าดังกล่าว หรือรหัสที่มีอยู่แล้ว เช่น รหัสเซสชันหรือรหัสธุรกรรม ตัวแปรที่ง่ายกว่าและปลอดภัยน้อยกว่าคือการสร้างตัวเลขสุ่มบนอุปกรณ์ เราขอแนะนำให้สร้างค่าที่มีขนาด 128 บิตขึ้นไป
- เรียกใช้
setNonce()เพื่อตั้งค่าช่องnonceเป็นค่าที่ไม่ซ้ำกันจากขั้นตอนที่ 1
เมื่อได้รับการตัดสินความสมบูรณ์ ให้ทำดังนี้
- ถอดรหัสและยืนยันโทเค็นความสมบูรณ์ แล้วรับค่าที่ไม่ซ้ำกันจากช่อง
nonce - หากค่าจากขั้นตอนที่ 1 สร้างขึ้นบนเซิร์ฟเวอร์ ให้ตรวจสอบว่าค่าที่ไม่ซ้ำกันที่ได้รับเป็นค่าใดค่าหนึ่งที่สร้างขึ้น และมีการใช้ค่าดังกล่าวเป็นครั้งแรก (เซิร์ฟเวอร์จะต้องเก็บบันทึกค่าที่สร้างขึ้นเป็นระยะเวลาที่เหมาะสม) หากมีการใช้ค่าที่ไม่ซ้ำกันที่ได้รับแล้วหรือค่าดังกล่าวไม่ปรากฏในระเบียน ให้ปฏิเสธคำขอ
- หรือหากมีการสร้างค่าที่ไม่ซ้ำกันในอุปกรณ์ ให้ตรวจสอบว่ามีการใช้ค่าที่ได้รับเป็นครั้งแรก (เซิร์ฟเวอร์ของคุณต้องเก็บบันทึกค่าที่เห็นแล้วเป็นระยะเวลาที่เหมาะสม) หากมีการใช้ค่าที่ไม่ซ้ำกันที่ได้รับแล้ว ให้ปฏิเสธคำขอ
รวมการป้องกันทั้ง 2 แบบเพื่อป้องกันการปลอมแปลงและการโจมตีแบบ Replay (แนะนำ)
คุณสามารถใช้ช่อง nonce เพื่อป้องกันทั้งการปลอมแปลงและการโจมตีแบบ Replay Attack ได้พร้อมกัน โดยสร้างค่าที่ไม่ซ้ำกันตามที่อธิบายไว้ข้างต้น และรวมค่าดังกล่าวไว้เป็นส่วนหนึ่งของคำขอ จากนั้นคำนวณแฮชคำขอ โดยตรวจสอบว่าได้รวมค่าที่ไม่ซ้ำกันเป็นส่วนหนึ่งของแฮช การใช้งานที่รวมทั้ง 2 แนวทางเข้าด้วยกันมีดังนี้
เมื่อคุณขอการตัดสินความสมบูรณ์
- ผู้ใช้เริ่มดำเนินการที่มีมูลค่าสูง
- รับค่าที่ไม่ซ้ำกันสำหรับการดำเนินการนี้ตามที่อธิบายไว้ในส่วนรวมค่าที่ไม่ซ้ำกันเพื่อป้องกันการโจมตีแบบ Replay
- เตรียมข้อความที่ต้องการปกป้อง ใส่ค่าที่ไม่ซ้ำกันจากขั้นตอนที่ 2 ในข้อความ
- แอปของคุณจะคำนวณไดเจสต์ของข้อความที่ต้องการปกป้องตามที่อธิบายไว้ในส่วนรวมแฮชคำขอเพื่อป้องกันการปลอมแปลง เนื่องจากข้อความมีค่าที่ไม่ซ้ำกัน ค่าที่ไม่ซ้ำกันจึงเป็นส่วนหนึ่งของแฮช
- ใช้
setNonce()เพื่อตั้งค่าฟิลด์nonceเป็นไดเจสต์ที่คำนวณจากขั้นตอนก่อนหน้า
เมื่อได้รับการตัดสินความสมบูรณ์ ให้ทำดังนี้
- รับค่าที่ไม่ซ้ำกันจากคำขอ
- ถอดรหัสและยืนยันโทเค็นความสมบูรณ์ และรับไดเจสต์จากช่อง
nonce - ตามที่อธิบายไว้ในส่วนรวมแฮชคำขอเพื่อป้องกันการปลอมแปลง ให้คำนวณไดเจสต์อีกครั้งฝั่งเซิร์ฟเวอร์ และตรวจสอบว่าตรงกับไดเจสต์ที่ได้จากโทเค็นความสมบูรณ์หรือไม่
- ตามที่อธิบายไว้ในส่วนรวมค่าที่ไม่ซ้ำกันเพื่อป้องกันการโจมตีแบบ Replay ให้ตรวจสอบความถูกต้องของค่าที่ไม่ซ้ำกัน
แผนภาพลำดับต่อไปนี้แสดงขั้นตอนเหล่านี้ด้วย nonce ฝั่งเซิร์ฟเวอร์
ขอการตัดสินความสมบูรณ์
หลังจากสร้าง nonce แล้ว คุณสามารถขอผลการตัดสินความสมบูรณ์จาก Google Play ได้ โดยทำตามขั้นตอนต่อไปนี้
- สร้าง
IntegrityManagerดังที่แสดงในตัวอย่างต่อไปนี้ - สร้าง
IntegrityTokenRequestโดยระบุnonceผ่านเมธอดsetNonce()ในเครื่องมือสร้างที่เกี่ยวข้อง แอปที่เผยแพร่นอก Google Play และ SDK เท่านั้นยังต้องระบุหมายเลขโปรเจ็กต์ Google Cloud ผ่านเมธอดsetCloudProjectNumber()ด้วย แอปใน Google Play จะลิงก์กับโปรเจ็กต์ที่อยู่ในระบบคลาวด์ใน Play Console และไม่จำเป็นต้องตั้งค่าหมายเลขโปรเจ็กต์ที่อยู่ในระบบคลาวด์ในคำขอ - ใช้ตัวจัดการเพื่อเรียก
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 ต่างๆ ดังนี้
ถอดรหัสและยืนยันในเซิร์ฟเวอร์ของ Google (แนะนำ)
Play Integrity API ช่วยให้คุณถอดรหัสและยืนยันคำตัดสินความสมบูรณ์ในเซิร์ฟเวอร์ของ Google ได้ ซึ่งจะช่วยเพิ่มความปลอดภัยให้แอปของคุณ โดยทำตามขั้นตอนต่อไปนี้
- สร้างบัญชีบริการภายในโปรเจ็กต์ที่อยู่ในระบบคลาวด์ของ Google ที่ลิงก์กับแอปของคุณ
ในเซิร์ฟเวอร์ของแอป ให้ดึงข้อมูลโทเค็นเพื่อการเข้าถึงจากข้อมูลเข้าสู่ระบบของบัญชีบริการโดยใช้ขอบเขต
playintegrityและส่งคำขอต่อไปนี้playintegrity.googleapis.com/v1/PACKAGE_NAME:decodeIntegrityToken -d \ '{ "integrity_token": "INTEGRITY_TOKEN" }'อ่านการตอบกลับ 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
ดูวิธีทริกเกอร์กล่องโต้ตอบเหล่านี้จากแอปตามการตอบกลับของเซิร์ฟเวอร์ได้ที่กล่องโต้ตอบการแก้ไข