इस पेज का अनुवाद Cloud Translation API से किया गया है.

Chrome वेरिफ़ाइड ऐक्सेस डेवलपर की गाइड

इस गाइड के बारे में जानकारी

Chrome Verified Access API, नेटवर्क सेवाओं की अनुमति देता है, जैसे कि VPN, इंट्रानेट किए जा सकते हैं और इसी तरह क्रिप्टोग्राफ़िक तरीके से पुष्टि की जाती है कि उनके क्लाइंट असली हैं और कॉर्पोरेट नीति का पालन करना चाहिए. ज़्यादातर बड़े एंटरप्राइज़ को सिर्फ़ एंटरप्राइज़ से मैनेज किए जाने वाले डिवाइसों को उनके WPA2 EAN-TLS नेटवर्क पर ऐक्सेस करने की अनुमति देता है, वीपीएन और म्यूचुअल-टीएलएस इंट्रानेट पेजों के लिए, सबसे ऊंचे लेवल का ऐक्सेस मिलता है. कई मौजूदा समाधान डिवाइस हैक हो गया है. इससे वह चुनौती सामने आती है जिसके लिए सिग्नल पर भरोसा किया जाता है डिवाइस की वैध स्थिति के सबूत के तौर पर खुद प्रमाणित किया हो धोखाधड़ी करना. यह गाइड हार्डवेयर आधारित क्रिप्टोग्राफ़िक गारंटी देती है, जो डिवाइस की पहचान और उसकी स्थिति में कोई बदलाव नहीं किया गया था और यह नीति के मुताबिक है बूट पर; जिसे 'पुष्टि किया गया ऐक्सेस' कहते हैं.

प्राइमरी ऑडियंस	एंटरप्राइज़ आईटी डोमेन एडमिन
तकनीकी कॉम्पोनेंट	ChromeOS, Google से पुष्टि किया हुआ ऐक्सेस एपीआई

पुष्टि किए गए ऐक्सेस के लिए ज़रूरी शर्तें

पुष्टि किए गए ऐक्सेस की प्रक्रिया लागू करने से पहले नीचे दिए गए सेटअप को पूरा करें.

इस एपीआई को चालू करें

Google API कंसोल प्रोजेक्ट सेटअप करें और API चालू करें:

इसमें कोई मौजूदा प्रोजेक्ट बनाएं या मौजूदा प्रोजेक्ट का इस्तेमाल करें: Google API कंसोल.
YouTube Studio के चालू एपीआई और सेवाएं पेज पर जाकर देख सकते हैं.
Chrome Verified Access API चालू करें.
Google Cloud API दस्तावेज़ में दिए गए निर्देशों का पालन करके, अपने ऐप्लिकेशन के लिए API (एपीआई) कुंजी बनाएं.

सेवा खाता बनाना

नेटवर्क सेवा के लिए, Chrome Verified Access API को ऐक्सेस करने के लिए, ताकि चुनौतियों का जवाब, सेवा खाता और सेवा खाते की कुंजी बनाना (आपको नया Cloud प्रोजेक्ट बनाने की ज़रूरत नहीं है. आपके पास इसका इस्तेमाल करने का विकल्प है).

सेवा खाता कुंजी बनाने के बाद, आपके पास सेवा खाता होना चाहिए निजी कुंजी फ़ाइल डाउनलोड की गई. यह निजी कुंजी की एकमात्र प्रति है, इसलिए और उसे सुरक्षित तरीके से सेव करें.

मैनेज किए जा रहे Chromebook डिवाइस को रजिस्टर करें

आपको अपने Chrome के साथ, एक सही तरीके से मैनेज किए गए Chromebook डिवाइस का सेटअप करना होगा पुष्टि किए गए ऐक्सेस के लिए एक्सटेंशन.

Chromebook डिवाइस को एंटरप्राइज़ या एजुकेशन मैनेजमेंट के लिए रजिस्टर किया जाना चाहिए.
डिवाइस का उपयोगकर्ता उसी डोमेन से पंजीकृत उपयोगकर्ता होना चाहिए.
पुष्टि किए गए ऐक्सेस के लिए Chrome एक्सटेंशन डिवाइस पर इंस्टॉल होना चाहिए.
नीतियों को इस तरह से कॉन्फ़िगर किया गया है कि वे 'पुष्टि किए गए ऐक्सेस' सुविधा को चालू कर सकें. साथ ही, Chrome को अनुमति वाली सूची में जोड़ सकें को एक्सटेंशन की अनुमति देगा और एपीआई को ऐक्सेस करने की अनुमति देगा. नेटवर्क सेवा (यह देखें Google Admin console सहायता दस्तावेज़).

उपयोगकर्ता और डिवाइस की पुष्टि करें

डेवलपर उपयोगकर्ता या डिवाइस की पुष्टि करने के लिए, 'पुष्टि किए गए ऐक्सेस' का इस्तेमाल कर सकते हैं या दोनों का इस्तेमाल कर सकते हैं सुरक्षा के लिए:

डिवाइस की पुष्टि—अगर यह प्रोसेस पूरी हो जाती है, तो डिवाइस की पुष्टि करने पर इस बात की गारंटी देता है कि Chrome डिवाइस को मैनेज किए जा रहे डोमेन में रजिस्टर किया गया है और पुष्टि किए गए बूट मोड डिवाइस की नीति का पालन करता है, जैसा कि डोमेन ने तय किया है एडमिन. अगर नेटवर्क सेवा को डिवाइस को देखने की अनुमति दी गई है पहचान (Google Admin console सहायता दस्तावेज़ देखें) तो उसे एक ऐसा डिवाइस आईडी जिसका इस्तेमाल Directory API को ऑडिट करने, ट्रैक करने या कॉल करने के लिए किया जा सकता है.
उपयोगकर्ता की पुष्टि—अगर खाते की पुष्टि हो जाती है, तो उपयोगकर्ता की पुष्टि की गारंटी मिलती है कि साइन इन किया हुआ Chrome उपयोगकर्ता एक मैनेज किया जा रहा उपयोगकर्ता है, वह रजिस्टर किए गए डिवाइस का इस्तेमाल कर रहा है, और पुष्टि किए गए बूट मोड की उपयोगकर्ता नीति का पालन करता है, जैसा कि डोमेन में बताया गया है एडमिन. क्या नेटवर्क सेवा को उपयोगकर्ता का अतिरिक्त डेटा है, तो उसे सर्टिफ़िकेट पर हस्ताक्षर करने का अनुरोध भी मिलेगा उपयोगकर्ता से (साइन-इन-की-ऐंड-चैलेंज या SPKAC के रूप में सीएसआर. को कीजेन फ़ॉर्मैट भी कहा जाता है).

उपयोगकर्ता और डिवाइस की पुष्टि करने का तरीका

चुनौती पाएं—डिवाइस पर मौजूद Chrome एक्सटेंशन, 'पुष्टि हो चुकी है' वाले उपयोगकर्ता से संपर्क करता है चुनौती पाने के लिए, एपीआई को ऐक्सेस करें. सही डेटा न होने की वजह से एक मिनट में एक ही जगह पर पुरानी चुनौती का इस्तेमाल करने पर, चैलेंज-रिस्पॉन्स की पुष्टि (तीसरा चरण) नहीं हो पाती.

इस्तेमाल के सबसे आसान उदाहरण में, उपयोगकर्ता ऐसे बटन पर क्लिक करके इस फ़्लो को शुरू करता है जो एक्सटेंशन जनरेट करता है (Google का दिया हुआ सैंपल एक्सटेंशन भी करता है).

var apiKey = 'YOUR_API_KEY_HERE';
var challengeUrlString =
  'https://verifiedaccess.googleapis.com/v2/challenge:generate?key=' + apiKey;

// Request challenge from URL
var xmlhttp = new XMLHttpRequest();
xmlhttp.open('POST', challengeUrlString, true);
xmlhttp.send();
xmlhttp.onreadystatechange = function() {
  if (xmlhttp.readyState == 4) {
    var challenge = xmlhttp.responseText;
    console.log('challenge: ' + challenge);
    // v2 of the API returns an encoded challenge so no further challenge processing is needed
  }
};

चैलेंज को कोड में बदलने के लिए हेल्पर कोड—अगर एपीआई के v1 का इस्तेमाल किया जा रहा है, तो चुनौती को कोड में बदलना होगा.

// This can be replaced by using a third-party library such as
// [https://github.com/dcodeIO/ProtoBuf.js/wiki](https://github.com/dcodeIO/ProtoBuf.js/wiki)
/**
 * encodeChallenge convert JSON challenge into base64 encoded byte array
 * @param {string} challenge JSON encoded challenge protobuf
 * @return {string} base64 encoded challenge protobuf
 */
var encodeChallenge = function(challenge) {
  var jsonChallenge = JSON.parse(challenge);
  var challengeData = jsonChallenge.challenge.data;
  var challengeSignature = jsonChallenge.challenge.signature;

  var protobufBinary = protoEncodeChallenge(
      window.atob(challengeData), window.atob(challengeSignature));

  return window.btoa(protobufBinary);
};

/**
 * protoEncodeChallenge produce binary encoding of the challenge protobuf
 * @param {string} dataBinary binary data field
 * @param {string} signatureBinary binary signature field
 * @return {string} binary encoded challenge protobuf
 */
var protoEncodeChallenge = function(dataBinary, signatureBinary) {
  var protoEncoded = '';

  // See https://developers.google.com/protocol-buffers/docs/encoding
  // for encoding details.

  // 0x0A (00001 010, field number 1, wire type 2 [length-delimited])
  protoEncoded += '\u000A';

  // encode length of the data
  protoEncoded += varintEncode(dataBinary.length);
  // add data
  protoEncoded += dataBinary;

  // 0x12 (00010 010, field number 2, wire type 2 [length-delimited])
  protoEncoded += '\u0012';
  // encode length of the signature
  protoEncoded += varintEncode(signatureBinary.length);
  // add signature
  protoEncoded += signatureBinary;

  return protoEncoded;
};

/**
 * varintEncode produce binary encoding of the integer number
 * @param {number} number integer number
 * @return {string} binary varint-encoded number
 */
var varintEncode = function(number) {
  // This only works correctly for numbers 0 through 16383 (0x3FFF)
  if (number <= 127) {
    return String.fromCharCode(number);
  } else {
    return String.fromCharCode(128 + (number & 0x7f), number >>> 7);
  }
};

चुनौती का जवाब जनरेट करना—Chrome एक्सटेंशन, उस चैलेंज का इस्तेमाल करता है Enterprise.platformKeys Chrome API को कॉल करने के लिए पहले चरण में मिला है. यह साइन किया हुआ और एन्क्रिप्ट (सुरक्षित) किया गया चैलेंज का रिस्पॉन्स जनरेट करता है, जिसे नेटवर्क सेवा को भेजे जाने वाले ऐक्सेस अनुरोध में शामिल होता है.

इस चरण में, वह प्रोटोकॉल निर्धारित करने का कोई प्रयास नहीं होता जो एक्सटेंशन और बातचीत करने के लिए नेटवर्क सेवा का इस्तेमाल. ये दोनों इकाइयां लागू की गई हैं की समीक्षा कैसे करते हैं और उन्हें एक-दूसरे से कैसे बात करनी है, यह नहीं बताया जाता. अगर आप उदाहरण के लिए, क्वेरी स्ट्रिंग के तौर पर यूआरएल के कोड में बदले गए चैलेंज का रिस्पॉन्स भेजना पैरामीटर, एचटीटीपी पीओएसटी का इस्तेमाल करके या खास एचटीटीपी हेडर का इस्तेमाल करके.

चैलेंज रिस्पॉन्स जनरेट करने के लिए, यहां सैंपल कोड दिया गया है:

चैलेंज का जवाब जनरेट करना

  // Generate challenge response
  var encodedChallenge; // obtained by generate challenge API call
  try {
    if (isDeviceVerification) { // isDeviceVerification set by external logic
      chrome.enterprise.platformKeys.challengeKey(
          {
            scope: 'MACHINE',
            challenge: decodestr2ab(encodedChallenge),
          },
          ChallengeCallback);
    } else {
      chrome.enterprise.platformKeys.challengeKey(
          {
            scope: 'USER',
            challenge: decodestr2ab(encodedChallenge),
            registerKey: { 'RSA' }, // can also specify 'ECDSA'
          },
          ChallengeCallback);
    }
  } catch (error) {
    console.log('ERROR: ' + error);
  }

कॉलबैक फ़ंक्शन को चैलेंज करें

  var ChallengeCallback = function(response) {
    if (chrome.runtime.lastError) {
      console.log(chrome.runtime.lastError.message);
    } else {
      var responseAsString = ab2base64str(response);
      console.log('resp: ' + responseAsString);
    ... // send on to network service
   };
  }

ArrayBuffer कन्वर्ज़न के लिए हेल्पर कोड

  /**
   * ab2base64str convert an ArrayBuffer to base64 string
   * @param {ArrayBuffer} buf ArrayBuffer instance
   * @return {string} base64 encoded string representation
   * of the ArrayBuffer
   */
  var ab2base64str = function(buf) {
    var binary = '';
    var bytes = new Uint8Array(buf);
    var len = bytes.byteLength;
    for (var i = 0; i < len; i++) {
      binary += String.fromCharCode(bytes[i]);
    }
    return window.btoa(binary);
  }

  /**
   * decodestr2ab convert a base64 encoded string to ArrayBuffer
   * @param {string} str string instance
   * @return {ArrayBuffer} ArrayBuffer representation of the string
   */
  var decodestr2ab = function(str) {
    var binary_string =  window.atob(str);
    var len = binary_string.length;
    var bytes = new Uint8Array(len);
    for (var i = 0; i < len; i++)        {
        bytes[i] = binary_string.charCodeAt(i);
    }
    return bytes.buffer;
  }

चैलेंज रिस्पॉन्स की पुष्टि करना—चैलेंज रिस्पॉन्स मिलने पर डिवाइस (शायद किसी मौजूदा पुष्टि करने के प्रोटोकॉल के एक्सटेंशन के तौर पर) डिवाइस की पुष्टि करने के लिए नेटवर्क सेवा को Verified Access API को कॉल करना चाहिए पहचान और नीति का पॉस्चर (नीचे दिया गया उदाहरण कोड देखें). स्पूफ़िंग (झूठे नाम से मेल भेजना) को रोकने के लिए, हम यह सुझाव दिया जा सकता है कि नेटवर्क सेवा उस क्लाइंट की पहचान करे जिससे वह बात कर रही है और अपने अनुरोध में क्लाइंट की अनुमानित पहचान शामिल करें:
- डिवाइस की पुष्टि करने के लिए, सही डिवाइस डोमेन दिया जाना चाहिए को अपनाएं. कई मामलों में यह एक हार्ड-कोड की गई वैल्यू हो सकती है, क्योंकि नेटवर्क सेवा किसी खास डोमेन के संसाधनों की सुरक्षा करती है. अगर आपको इसकी जानकारी नहीं है समय से पहले, उसका अनुमान उपयोगकर्ता की पहचान से लगाया जा सकता है.
- उपयोगकर्ता की पुष्टि के लिए, अनुमानित उपयोगकर्ता का ईमेल पता यह होना चाहिए दिया गया है. हम उम्मीद करते हैं कि नेटवर्क सेवा अपने उपयोगकर्ताओं के बारे में जाने (आम तौर पर यह उपयोगकर्ताओं को साइन इन करना होगा).
Google API को कॉल करने पर, यह कई तरह की जांच करता है, जैसे:
- पुष्टि करें कि चैलेंज रिस्पॉन्स को ChromeOS ने बनाया है, न कि ट्रांज़िट में संशोधित
- पुष्टि करें कि डिवाइस या उपयोगकर्ता को एंटरप्राइज़ मैनेज करता है.
- पुष्टि करें कि डिवाइस/उपयोगकर्ता की पहचान उम्मीद के मुताबिक है पहचान (अगर बाद वाली पहचान की गई हो).
- पुष्टि करें कि जिस चुनौती का जवाब दिया जा रहा है वह नया (एक मिनट से ज़्यादा पुराना नहीं).
- पुष्टि करें कि डिवाइस या उपयोगकर्ता, डोमेन एडमिन के तौर पर काम करता है.
- पुष्टि करें कि कॉलर (नेटवर्क सेवा) को कॉल करने की अनुमति दी गई है एपीआई को चुनें.
- अगर कॉल करने वाले व्यक्ति को अतिरिक्त डिवाइस पाने की अनुमति दी गई है या उपयोगकर्ता डेटा, डिवाइस आईडी या उपयोगकर्ता के प्रमाणपत्र पर किए गए हस्ताक्षर शामिल करें अनुरोध (CSR) के रूप में मिला है.
इस उदाहरण में, gRPC लाइब्रेरी का इस्तेमाल किया गया है
```
import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.ServiceAccountCredentials;
import com.google.chrome.verifiedaccess.v2.VerifiedAccessGrpc;
import com.google.chrome.verifiedaccess.v2.VerifyChallengeResponseRequest;
import com.google.chrome.verifiedaccess.v2.VerifyChallengeResponseResult;
import com.google.protobuf.ByteString;

import io.grpc.ClientInterceptor;
import io.grpc.ClientInterceptors;
import io.grpc.ManagedChannel;
import io.grpc.auth.ClientAuthInterceptor;
import io.grpc.netty.GrpcSslContexts;
import io.grpc.netty.NettyChannelBuilder;

import java.io.File;
import java.io.FileInputStream;
import java.util.Arrays;
import java.util.concurrent.Executors;

// https://cloud.google.com/storage/docs/authentication#generating-a-private-key
private final String clientSecretFile = "PATH_TO_GENERATED_JSON_SECRET_FILE";

private ManagedChannel channel;
private VerifiedAccessGrpc.VerifiedAccessBlockingStub client;

void setup() {

   channel = NettyChannelBuilder.forAddress("verifiedaccess.googleapis.com", 443)
      .sslContext(GrpcSslContexts.forClient().ciphers(null).build())
      .build();

   List<ClientInterceptor> interceptors = Lists.newArrayList();
   // Attach a credential for my service account and scope it for the API.
   GoogleCredentials credentials =
       ServiceAccountCredentials.class.cast(
           GoogleCredentials.fromStream(
               new FileInputStream(new File(clientSecretFile))));
  credentials = credentials.createScoped(
      Arrays.<String>asList("https://www.googleapis.com/auth/verifiedaccess"));
  interceptors.add(
       new ClientAuthInterceptor(credentials, Executors.newSingleThreadExecutor()));

  // Create a stub bound to the channel with the interceptors applied
  client = VerifiedAccessGrpc.newBlockingStub(
      ClientInterceptors.intercept(channel, interceptors));
}

/**
 * Invokes the synchronous RPC call that verifies the device response.
 * Returns the result protobuf as a string.
 *
 * @param signedData base64 encoded signedData blob (this is a response from device)
 * @param expectedIdentity expected identity (domain name or user email)
 * @return the verification result protobuf as string
 */
public String verifyChallengeResponse(String signedData, String expectedIdentity)
  throws IOException, io.grpc.StatusRuntimeException {
  VerifyChallengeResponseResult result =
    client.verifyChallengeResponse(newVerificationRequest(signedData,
        expectedIdentity)); // will throw StatusRuntimeException on error.

  return result.toString();
}

private VerifyChallengeResponseRequest newVerificationRequest(
  String signedData, String expectedIdentity) throws IOException {
  return VerifyChallengeResponseRequest.newBuilder()
    .setChallengeResponse(
        ByteString.copyFrom(BaseEncoding.base64().decode(signedData)))
    .setExpectedIdentity(expectedIdentity == null ? "" : expectedIdentity)
    .build();
}
```
ऐक्सेस देना—यह चरण नेटवर्क सेवा के लिए भी खास है. यह है (तय नहीं) लागू करने का सुझाव दिया गया है. ये कार्रवाइयां की जा सकती हैं:
- सेशन कुकी बनाना
- उपयोगकर्ता या डिवाइस के लिए सर्टिफ़िकेट जारी करना. सफल उपयोगकर्ता के मामले में पुष्टि कर सकते हैं और यह मानते हैं कि नेटवर्क सेवा को ऐक्सेस दे दिया गया है उपयोगकर्ता के अतिरिक्त डेटा (Google Admin console नीति के ज़रिए) में जोड़ा जाता है, तो उपयोगकर्ता से हस्ताक्षर की गई सीएसआर मिलती है. इसके बाद, इस जानकारी का इस्तेमाल करके सर्टिफ़िकेट देने वाली संस्था या निकाय से मिलने वाला सर्टिफ़िकेट. के साथ इंटिग्रेट करते समय Microsoft^R CA, नेटवर्क सेवा इस तरह काम कर सकती है मध्यवर्ती और ICertRequest इंटरफ़ेस का उपयोग करें.

पुष्टि किए गए ऐक्सेस के साथ क्लाइंट सर्टिफ़िकेट का इस्तेमाल करना

किसी बड़े संगठन में, एक से ज़्यादा नेटवर्क सेवाएं हो सकती हैं (वीपीएन सर्वर, वाई-फ़ाई ऐक्सेस पॉइंट, फ़ायरवॉल, और एक से ज़्यादा इंट्रानेट साइटें) को सत्यापित ऐक्सेस से फ़ायदा होगा. हालांकि, चरणों के तर्क को ध्यान में रखते हुए हो सकता है कि इनमें से हर एक नेटवर्क सेवा में 2–4 (ऊपर दिए गए सेक्शन में) व्यावहारिक. अक्सर, इनमें से कई नेटवर्क सेवाएं पहले से ही पुष्टि करने के लिए, क्लाइंट सर्टिफ़िकेट की ज़रूरत पड़ती है. उदाहरण के लिए, ईएपी-टीएलएस या म्युचुअल TLS इंट्रानेट पेज). इसलिए, अगर Enterprise Certificate ऐसी संस्था जो इन क्लाइंट सर्टिफ़िकेट को जारी करती है, वह दूसरे से चौथे चरण को लागू कर सकती है और चैलेंज रिस्पॉन्स पर क्लाइंट सर्टिफ़िकेट जारी करने की शर्त पूरी करें तब आपके पास इस बात का सबूत हो सकता है कि क्लाइंट भरोसेमंद हो और कॉर्पोरेट नीति का पालन करता हो. उसके बाद हर वाई-फ़ाई ऐक्सेस पॉइंट, वीपीएन सर्वर वगैरह इस क्लाइंट सर्टिफ़िकेट की जांच कर सकते हैं इसके लिए, चरण 2 से 4 का पालन करने की ज़रूरत नहीं होती.

दूसरे शब्दों में, यहां वह सीए (जो क्लाइंट सर्टिफ़िकेट को एंटरप्राइज़ को जारी करता है) डिवाइस) चित्र 1 में नेटवर्क सेवा की भूमिका निभाता है. उसे शुरू करने की ज़रूरत है वेरिफ़ाइड ऐक्सेस एपीआई और सिर्फ़ चैलेंज रिस्पॉन्स की पुष्टि के बाद पासिंग, क्लाइंट को प्रमाणपत्र प्रदान करें. इन्हें प्रमाणपत्र उपलब्ध कराया जा रहा है क्लाइंट, चरण 4 - इमेज 1 में ऐक्सेस दें के बराबर है.

Chromebook पर सुरक्षित रूप से क्लाइंट सर्टिफ़िकेट पाने की प्रोसेस के बारे में बताया गया है इस लेख में बताया गया है. अगर इस पैराग्राफ़ में बताए गए डिज़ाइन को फ़ॉलो करने के बाद, वेरिफ़ाइड ऐक्सेस एक्सटेंशन को लागू किया गया है और क्लाइंट सर्टिफ़िकेट के ऑनबोर्डिंग एक्सटेंशन को एक साथ जोड़ा जा सकता है. ज़्यादा जानें क्लाइंट सर्टिफ़िकेट ऑनबोर्डिंग एक्सटेंशन लिखने के तरीके के बारे में जानकारी.