ลงนามคําขอแบบดิจิทัลด้วยคีย์ API
อาจต้องใช้ลายเซ็นดิจิทัลนอกเหนือจากคีย์ API ทั้งนี้ขึ้นอยู่กับการใช้งานของคุณ เพื่อตรวจสอบสิทธิ์ของคําขอ ดูบทความต่อไปนี้
วิธีทํางานของลายเซ็นดิจิทัล
ลายเซ็นดิจิทัลสร้างขึ้นโดยใช้ข้อมูลลับในการลงทะเบียน URL ซึ่งเข้าถึงได้ใน Google Cloud Console ข้อมูลลับนี้เป็นคีย์ส่วนตัวที่แชร์ระหว่างคุณและ Google เท่านั้น และไม่ซ้ํากันสําหรับโปรเจ็กต์ของคุณ
กระบวนการลงนามจะใช้อัลกอริทึมการเข้ารหัสเพื่อรวม URL และข้อมูลลับที่คุณแชร์ ลายเซ็นที่ไม่ซ้ํากันที่ช่วยให้เซิร์ฟเวอร์ของเรายืนยันได้ว่าคําขอสร้างเว็บไซต์ที่มีคีย์ API ของคุณได้รับอนุญาต
จํากัดคําขอที่ไม่ได้ลงชื่อ
วิธีตรวจสอบว่าคีย์ API รับเฉพาะคําขอที่ลงชื่อเท่านั้น
- ไปที่หน้าโควต้า Google Maps Platform ใน Cloud Console
- คลิกเมนูแบบเลื่อนลงของโปรเจ็กต์ แล้วเลือกโปรเจ็กต์เดียวกับที่คุณใช้เมื่อสร้างคีย์ API สําหรับแอปพลิเคชันหรือเว็บไซต์
- เลือก Maps Static API หรือ Street View Static API จากเมนูแบบเลื่อนลง API
- ขยายส่วนคําขอที่ไม่มีการลงชื่อ
- ในตารางชื่อโควต้า ให้คลิกปุ่มแก้ไขข้างโควต้าที่ต้องการแก้ไข เช่น คําขอที่ไม่มีการลงชื่อต่อวัน
- อัปเดตขีดจํากัดโควต้าในแผงแก้ไขขีดจํากัดโควต้า
- เลือกบันทึก
การเซ็นชื่อคําขอ
การลงนามคําขอประกอบด้วยขั้นตอนต่อไปนี้
- ขั้นตอนที่ 1 รับข้อมูลลับในการลงทะเบียน URL
- ขั้นตอนที่ 2 สร้างคําขอที่ไม่มีการลงชื่อ
- ขั้นตอนที่ 3: สร้างคําขอที่ลงชื่อ
ขั้นตอนที่ 1: รับข้อมูลลับสําหรับการลงทะเบียน URL
วิธีรับข้อมูลลับในการลงนาม URL โครงการ
- ไปที่หน้าข้อมูลเข้าสู่ระบบของ Google Maps Platform ใน Cloud Console
- เลือกโปรเจ็กต์แบบเลื่อนลงและเลือกโปรเจ็กต์เดียวกับที่คุณใช้เมื่อสร้างคีย์ API สําหรับ Maps Static API หรือ Street View Static API
- เลื่อนลงไปที่การ์ดโปรแกรมสร้างข้อมูลลับ ช่องข้อมูลลับปัจจุบันมีข้อมูลลับสําหรับการลงนาม URL ปัจจุบัน
- นอกจากนี้ หน้ายังมีวิดเจ็ตลงนาม URL ทันทีซึ่งช่วยให้คุณลงนามคําขอ Maps Static API หรือ Street View Static API โดยอัตโนมัติได้โดยใช้ข้อมูลลับในการลงชื่อปัจจุบัน เลื่อนลงไปที่การ์ดลงนาม URL ทันทีเพื่อเข้าถึง
หากต้องการรับข้อมูลลับในการลงชื่อเข้าใช้ URL ใหม่ ให้เลือกสร้างข้อมูลลับอีกครั้ง ข้อมูลลับก่อนหน้าจะหมดอายุภายใน 24 ชั่วโมงหลังจากที่คุณสร้างข้อมูลลับใหม่ หลังจากผ่านไป 24 ชั่วโมง คําขอที่มีข้อมูลลับเก่าจะใช้ไม่ได้อีกต่อไป
ขั้นตอนที่ 2: สร้างคําขอที่ไม่มีการลงชื่อ
อักขระที่ไม่แสดงอยู่ในตารางด้านล่างนี้ต้องเข้ารหัส URL
ตั้งค่า | อักขระ | การใช้ URL |
---|---|---|
ตัวอักษรและตัวเลขคละกัน | ก า ร รั บ ข้ อ มู ล แ ล้ ว | สตริงข้อความ การใช้สคีม (http ), พอร์ต (8080 ) ฯลฯ |
ไม่ได้จอง | - _ ~ | สตริงข้อความ |
จองแล้ว | ! * ' ( ) ; : @ & = + $ , / ? % # [ ] | ควบคุมอักขระและ/หรือสตริงข้อความ |
การดําเนินการเช่นเดียวกันกับอักขระในชุดสงวน หากส่งผ่านอักขระเหล่านั้นในสตริงข้อความ ดูข้อมูลเพิ่มเติมได้ที่สัญลักษณ์พิเศษ
สร้าง URL คําขอที่ไม่มีการลงชื่อโดยไม่มีลายเซ็น สําหรับวิธีการ โปรดดูเอกสารสําหรับนักพัฒนาซอฟต์แวร์ต่อไปนี้
และอย่าลืมรวมคีย์ API ในพารามิเตอร์ key
เช่น
https://maps.googleapis.com/maps/api/staticmap?center=Z%C3%BCrich&size=400x400&key=YOUR_API_KEY
สร้างคําขอที่ลงชื่อ
สําหรับกรณีการใช้งานแบบครั้งเดียว เช่น การโฮสต์รูปภาพ Maps API แบบคงที่หรือ Street View Static API แบบง่ายในหน้าเว็บ หรือวัตถุประสงค์ในการแก้ปัญหา คุณจะสร้างลายเซ็นดิจิทัลโดยอัตโนมัติได้โดยใช้วิดเจ็ตลงนาม URL เลย
สําหรับคําขอที่สร้างแบบไดนามิก คุณต้องมีการลงนามฝั่งเซิร์ฟเวอร์ ซึ่งต้องใช้ขั้นตอนขั้นกลางเพิ่มเติม 2-3 ขั้นตอน
ไม่ว่าจะใช้วิธีใด คุณควรเพิ่ม URL คําขอที่มีพารามิเตอร์ signature
ต่อท้าย เช่น
https://maps.googleapis.com/maps/api/staticmap?center=Z%C3%BCrich&size=400x400&key=YOUR_API_KEY
&signature=BASE64_SIGNATURE
การใช้วิดเจ็ต "ลงนาม URL ทันที"
วิธีสร้างลายเซ็นดิจิทัลด้วยคีย์ API โดยใช้วิดเจ็ตลงนามใน URL ทันทีใน Google Cloud Console
- ค้นหาวิดเจ็ตลงนาม URL ทันที ตามที่อธิบายในขั้นตอนที่ 1: รับข้อมูลลับในการลงทะเบียน URL
- ในช่อง URL ให้วาง URL คําขอที่ไม่มีการลงชื่อจากขั้นตอนที่ 2: สร้างคําขอที่ไม่ได้ลงนาม
- ช่อง URL ที่ลงชื่อของคุณที่ปรากฏขึ้นจะมี URL ที่ลงชื่อแบบดิจิทัลของคุณ โปรดทําสําเนา
สร้างลายเซ็นดิจิทัลฝั่งเซิร์ฟเวอร์
เมื่อเทียบกับวิดเจ็ตลงนาม URL เลย คุณจะต้องดําเนินการเพิ่มเติมเล็กน้อยเมื่อสร้างลายเซ็นดิจิทัลฝั่งเซิร์ฟเวอร์ ดังนี้
-
ตัดรูปแบบโปรโตคอลและส่วนของโฮสต์ของ URL ให้เหลือเฉพาะเส้นทางและคําค้นหา
-
ข้อมูลลับในการลงทะเบียน URL ที่ปรากฏมีการเข้ารหัสใน Base64 ที่แก้ไขสําหรับ URL
เนื่องจากไลบรารีการเข้ารหัสลับส่วนใหญ่กําหนดให้คีย์ต้องอยู่ในรูปแบบไบต์แบบ Raw จึงต้องถอดรหัสลับการลงนาม URL ให้อยู่ในรูปแบบข้อมูลดิบดั้งเดิมก่อนลงนาม
- ลงนามคําขอที่ถูกตัดโดยด้านบนโดยใช้ HMAC-SHA1
-
เนื่องจากไลบรารีการเข้ารหัสลับส่วนใหญ่จะสร้างลายเซ็นในรูปแบบไบต์ดิบ คุณจะต้องแปลงลายเซ็นไบนารีผลลัพธ์โดยใช้ Base64 ที่แก้ไขสําหรับ URL เพื่อแปลงเป็นลายเซ็นที่ส่งผ่านภายใน URL ได้
-
เพิ่มลายเซ็นที่เข้ารหัสฐาน 64 ต่อท้าย URL คําขอที่ไม่มีการลงชื่อต้นฉบับในพารามิเตอร์
signature
เช่นhttps://maps.googleapis.com/maps/api/staticmap?center=Z%C3%BCrich&size=400x400&key=YOUR_API_KEY &signature=BASE64_SIGNATURE
/maps/api/staticmap?center=Z%C3%BCrich&size=400x400&key=YOUR_API_KEY
สําหรับตัวอย่างที่แสดงวิธีติดตั้งการลงนาม URL โดยใช้โค้ดฝั่งเซิร์ฟเวอร์ โปรดดูโค้ดตัวอย่างสําหรับการลงนาม URL ด้านล่าง
ตัวอย่างโค้ดสําหรับการลงชื่อ URL
ส่วนต่อไปนี้จะแสดงวิธีติดตั้งการลงนาม URL โดยใช้โค้ดฝั่งเซิร์ฟเวอร์ URL ควรมีลายเซ็นแบบฝั่งเซิร์ฟเวอร์เสมอ เพื่อหลีกเลี่ยงการเปิดเผยข้อมูลลับในการลงชื่อเข้าใช้ URL ต่อผู้ใช้
Python
ตัวอย่างด้านล่างใช้ไลบรารี Python มาตรฐานเพื่อลงนาม URL (ดาวน์โหลดโค้ด)
#!/usr/bin/python # -*- coding: utf-8 -*- """ Signs a URL using a URL signing secret """ import hashlib import hmac import base64 import urllib.parse as urlparse def sign_url(input_url=None, secret=None): """ Sign a request URL with a URL signing secret. Usage: from urlsigner import sign_url signed_url = sign_url(input_url=my_url, secret=SECRET) Args: input_url - The URL to sign secret - Your URL signing secret Returns: The signed request URL """ if not input_url or not secret: raise Exception("Both input_url and secret are required") url = urlparse.urlparse(input_url) # We only need to sign the path+query part of the string url_to_sign = url.path + "?" + url.query # Decode the private key into its binary format # We need to decode the URL-encoded private key decoded_key = base64.urlsafe_b64decode(secret) # Create a signature using the private key and the URL-encoded # string using HMAC SHA1. This signature will be binary. signature = hmac.new(decoded_key, str.encode(url_to_sign), hashlib.sha1) # Encode the binary signature into base64 for use within a URL encoded_signature = base64.urlsafe_b64encode(signature.digest()) original_url = url.scheme + "://" + url.netloc + url.path + "?" + url.query # Return signed URL return original_url + "&signature=" + encoded_signature.decode() if __name__ == "__main__": input_url = input("URL to Sign: ") secret = input("URL signing secret: ") print("Signed URL: " + sign_url(input_url, secret))
Java
ตัวอย่างด้านล่างใช้คลาส java.util.Base64
ที่พร้อมใช้งานตั้งแต่ JDK 1.8 - เวอร์ชันเก่าอาจต้องใช้ Apache Commons หรือเวอร์ชันที่คล้ายกัน
(ดาวน์โหลดโค้ด)
import java.io.IOException; import java.io.UnsupportedEncodingException; import java.net.URI; import java.net.URISyntaxException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.util.Base64; // JDK 1.8 only - older versions may need to use Apache Commons or similar. import javax.crypto.Mac; import javax.crypto.spec.SecretKeySpec; import java.net.URL; import java.io.BufferedReader; import java.io.InputStreamReader; public class UrlSigner { // Note: Generally, you should store your private key someplace safe // and read them into your code private static String keyString = "YOUR_PRIVATE_KEY"; // The URL shown in these examples is a static URL which should already // be URL-encoded. In practice, you will likely have code // which assembles your URL from user or web service input // and plugs those values into its parameters. private static String urlString = "YOUR_URL_TO_SIGN"; // This variable stores the binary key, which is computed from the string (Base64) key private static byte[] key; public static void main(String[] args) throws IOException, InvalidKeyException, NoSuchAlgorithmException, URISyntaxException { BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); String inputUrl, inputKey = null; // For testing purposes, allow user input for the URL. // If no input is entered, use the static URL defined above. System.out.println("Enter the URL (must be URL-encoded) to sign: "); inputUrl = input.readLine(); if (inputUrl.equals("")) { inputUrl = urlString; } // Convert the string to a URL so we can parse it URL url = new URL(inputUrl); // For testing purposes, allow user input for the private key. // If no input is entered, use the static key defined above. System.out.println("Enter the Private key to sign the URL: "); inputKey = input.readLine(); if (inputKey.equals("")) { inputKey = keyString; } UrlSigner signer = new UrlSigner(inputKey); String request = signer.signRequest(url.getPath(),url.getQuery()); System.out.println("Signed URL :" + url.getProtocol() + "://" + url.getHost() + request); } public UrlSigner(String keyString) throws IOException { // Convert the key from 'web safe' base 64 to binary keyString = keyString.replace('-', '+'); keyString = keyString.replace('_', '/'); System.out.println("Key: " + keyString); // Base64 is JDK 1.8 only - older versions may need to use Apache Commons or similar. this.key = Base64.getDecoder().decode(keyString); } public String signRequest(String path, String query) throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, URISyntaxException { // Retrieve the proper URL components to sign String resource = path + '?' + query; // Get an HMAC-SHA1 signing key from the raw key bytes SecretKeySpec sha1Key = new SecretKeySpec(key, "HmacSHA1"); // Get an HMAC-SHA1 Mac instance and initialize it with the HMAC-SHA1 key Mac mac = Mac.getInstance("HmacSHA1"); mac.init(sha1Key); // compute the binary signature for the request byte[] sigBytes = mac.doFinal(resource.getBytes()); // base 64 encode the binary signature // Base64 is JDK 1.8 only - older versions may need to use Apache Commons or similar. String signature = Base64.getEncoder().encodeToString(sigBytes); // convert the signature to 'web safe' base 64 signature = signature.replace('+', '-'); signature = signature.replace('/', '_'); return resource + "&signature=" + signature; } }
Node.js
ตัวอย่างด้านล่างใช้โมดูลโหนดดั้งเดิมเพื่อลงนาม URL (ดาวน์โหลดโค้ด)
'use strict' const crypto = require('crypto'); const url = require('url'); /** * Convert from 'web safe' base64 to true base64. * * @param {string} safeEncodedString The code you want to translate * from a web safe form. * @return {string} */ function removeWebSafe(safeEncodedString) { return safeEncodedString.replace(/-/g, '+').replace(/_/g, '/'); } /** * Convert from true base64 to 'web safe' base64 * * @param {string} encodedString The code you want to translate to a * web safe form. * @return {string} */ function makeWebSafe(encodedString) { return encodedString.replace(/\+/g, '-').replace(/\//g, '_'); } /** * Takes a base64 code and decodes it. * * @param {string} code The encoded data. * @return {string} */ function decodeBase64Hash(code) { // "new Buffer(...)" is deprecated. Use Buffer.from if it exists. return Buffer.from ? Buffer.from(code, 'base64') : new Buffer(code, 'base64'); } /** * Takes a key and signs the data with it. * * @param {string} key Your unique secret key. * @param {string} data The url to sign. * @return {string} */ function encodeBase64Hash(key, data) { return crypto.createHmac('sha1', key).update(data).digest('base64'); } /** * Sign a URL using a secret key. * * @param {string} path The url you want to sign. * @param {string} secret Your unique secret key. * @return {string} */ function sign(path, secret) { const uri = url.parse(path); const safeSecret = decodeBase64Hash(removeWebSafe(secret)); const hashedSignature = makeWebSafe(encodeBase64Hash(safeSecret, uri.path)); return url.format(uri) + '&signature=' + hashedSignature; }
C#
ตัวอย่างด้านล่างใช้ไลบรารี System.Security.Cryptography
เริ่มต้นในการลงนามคําขอ URL
เราจําเป็นต้องแปลงการเข้ารหัส Base64 เริ่มต้นเพื่อนําเวอร์ชันที่ปลอดภัยไปยัง URL ไปใช้
(ดาวน์โหลดโค้ด)
using System; using System.Collections.Generic; using System.Security.Cryptography; using System.Text; using System.Text.RegularExpressions; using System.Web; namespace SignUrl { public struct GoogleSignedUrl { public static string Sign(string url, string keyString) { ASCIIEncoding encoding = new ASCIIEncoding(); // converting key to bytes will throw an exception, need to replace '-' and '_' characters first. string usablePrivateKey = keyString.Replace("-", "+").Replace("_", "/"); byte[] privateKeyBytes = Convert.FromBase64String(usablePrivateKey); Uri uri = new Uri(url); byte[] encodedPathAndQueryBytes = encoding.GetBytes(uri.LocalPath + uri.Query); // compute the hash HMACSHA1 algorithm = new HMACSHA1(privateKeyBytes); byte[] hash = algorithm.ComputeHash(encodedPathAndQueryBytes); // convert the bytes to string and make url-safe by replacing '+' and '/' characters string signature = Convert.ToBase64String(hash).Replace("+", "-").Replace("/", "_"); // Add the signature to the existing URI. return uri.Scheme+"://"+uri.Host+uri.LocalPath + uri.Query +"&signature=" + signature; } } class Program { static void Main() { // Note: Generally, you should store your private key someplace safe // and read them into your code const string keyString = "YOUR_PRIVATE_KEY"; // The URL shown in these examples is a static URL which should already // be URL-encoded. In practice, you will likely have code // which assembles your URL from user or web service input // and plugs those values into its parameters. const string urlString = "YOUR_URL_TO_SIGN"; string inputUrl = null; string inputKey = null; Console.WriteLine("Enter the URL (must be URL-encoded) to sign: "); inputUrl = Console.ReadLine(); if (inputUrl.Length == 0) { inputUrl = urlString; } Console.WriteLine("Enter the Private key to sign the URL: "); inputKey = Console.ReadLine(); if (inputKey.Length == 0) { inputKey = keyString; } Console.WriteLine(GoogleSignedUrl.Sign(inputUrl,inputKey)); } } }
ตัวอย่างในภาษาอื่นๆ
ตัวอย่างที่ครอบคลุมภาษาอื่นๆ จะพร้อมใช้งานในโปรเจ็กต์การลงนาม URL
การแก้ปัญหา
หากคําขอมีลายเซ็นที่ไม่ถูกต้อง API จะแสดงข้อผิดพลาด HTTP 403 (Forbidden)
ข้อผิดพลาดนี้มักเกิดขึ้นในกรณีที่ข้อมูลลับที่ใช้ลงนามไม่ได้ลิงก์กับคีย์ API ที่ส่งผ่าน หรือหากอินพุตที่ไม่ใช่ ASCII ไม่ได้เข้ารหัส URL ก่อนลงนาม
ในการแก้ปัญหานี้ ให้คัดลอก URL คําขอ ตัดพารามิเตอร์การค้นหา signature
และสร้างลายเซ็นที่ถูกต้องอีกครั้งโดยทําตามวิธีการด้านล่างนี้
วิธีสร้างลายเซ็นดิจิทัลด้วยคีย์ API โดยใช้วิดเจ็ตลงนามใน URL ทันทีใน Google Cloud Console
- ค้นหาวิดเจ็ตลงนาม URL ทันที ตามที่อธิบายในขั้นตอนที่ 1: รับข้อมูลลับในการลงทะเบียน URL
- ในช่อง URL ให้วาง URL คําขอที่ไม่มีการลงชื่อจากขั้นตอนที่ 2: สร้างคําขอที่ไม่ได้ลงนาม
- ช่อง URL ที่ลงชื่อของคุณที่ปรากฏขึ้นจะมี URL ที่ลงชื่อแบบดิจิทัลของคุณ โปรดทําสําเนา