मैसेजिंग एपीआई की मदद से, आपके एक्सटेंशन से जुड़े कॉन्टेक्स्ट में चल रही अलग-अलग स्क्रिप्ट के बीच कम्यूनिकेट किया जा सकता है. इसमें आपके सर्विस वर्कर, chrome-extension://pages, और कॉन्टेंट स्क्रिप्ट के बीच होने वाला कम्यूनिकेशन शामिल है. उदाहरण के लिए, आरएसएस रीडर एक्सटेंशन, कॉन्टेंट स्क्रिप्ट का इस्तेमाल करके किसी पेज पर आरएसएस फ़ीड की मौजूदगी का पता लगा सकता है. इसके बाद, सर्विस वर्कर को उस पेज के लिए ऐक्शन आइकॉन अपडेट करने की सूचना दे सकता है.
मैसेज पास करने वाले दो एपीआई हैं: एक एक बार के अनुरोधों के लिए और दूसरा ज़्यादा जटिल एपीआई, लंबे समय तक चलने वाले कनेक्शन के लिए है. इससे कई मैसेज भेजे जा सकते हैं.
एक्सटेंशन के बीच मैसेज भेजने के बारे में जानकारी पाने के लिए, क्रॉस-एक्सटेंशन मैसेज सेक्शन देखें.
एक बार के लिए किए जाने वाले अनुरोध
अपने एक्सटेंशन के किसी दूसरे हिस्से में एक मैसेज भेजने और जवाब पाने के लिए, runtime.sendMessage() या tabs.sendMessage() को कॉल करें.
इन तरीकों से, कॉन्टेंट स्क्रिप्ट से एक्सटेंशन या एक्सटेंशन से कॉन्टेंट स्क्रिप्ट में, एक बार JSON-सीरियलाइज़ किया जा सकने वाला मैसेज भेजा जा सकता है. दोनों एपीआई, एक प्रॉमिस दिखाते हैं. यह प्रॉमिस, पेमेंट पाने वाले व्यक्ति से मिले जवाब के आधार पर रिज़ॉल्व होता है.
कॉन्टेंट स्क्रिप्ट से अनुरोध भेजने का तरीका कुछ ऐसा दिखता है:
content-script.js:
(async () => {
const response = await browser.runtime.sendMessage({greeting: "hello"});
// do something with response here, not outside the function
console.log(response);
})();
जवाब
मैसेज सुनने के लिए, browser.runtime.onMessage इवेंट का इस्तेमाल करें:
// Event listener
function handleMessages(message, sender, sendResponse) {
if (message !== 'get-status') return;
fetch('https://example.com')
.then((response) => sendResponse({statusCode: response.status}))
// Since `fetch` is asynchronous, must return an explicit `true`
return true;
}
browser.runtime.onMessage.addListener(handleMessages);
// From the sender's context...
const {statusCode} = await browser.runtime.sendMessage('get-status');
इवेंट लिसनर को कॉल करने पर, तीसरे पैरामीटर के तौर पर sendResponse फ़ंक्शन को पास किया जाता है. यह एक ऐसा फ़ंक्शन है जिसे जवाब देने के लिए कॉल किया जा सकता है. डिफ़ॉल्ट रूप से, sendResponse कॉलबैक को सिंक्रोनस तरीके से कॉल किया जाना चाहिए.
अगर आपने बिना किसी पैरामीटर के sendResponse को कॉल किया, तो जवाब के तौर पर null भेजा जाता है.
असिंक्रोनस तरीके से जवाब भेजने के लिए, आपके पास दो विकल्प हैं: true या प्रॉमिस को रिटर्न करना.
true को वापस करें
sendResponse() का इस्तेमाल करके, एसिंक्रोनस तरीके से जवाब देने के लिए, इवेंट लिसनर से लिटरल true (सिर्फ़ ट्रुथी वैल्यू नहीं) दिखाएं. ऐसा करने से, मैसेज चैनल दूसरे एंड पर तब तक खुला रहेगा, जब तक sendResponse को कॉल नहीं किया जाता. इससे आपको बाद में कॉल करने की सुविधा मिलती है.
प्रॉमिस रिटर्न करना
Chrome 148 से, मैसेज लिसनर से प्रॉमिस को रिटर्न किया जा सकता है, ताकि एसिंक्रोनस तरीके से जवाब दिया जा सके. यह अपडेट धीरे-धीरे रोल आउट किया जा रहा है. इसलिए, हो सकता है कि यह अभी सभी उपयोगकर्ताओं के ब्राउज़र में उपलब्ध न हो. आपको यह पक्का करना चाहिए कि आपका एक्सटेंशन, इस सुविधा के चालू या बंद होने पर काम कर सके. return true; का इस्तेमाल करने पर, एसिंक्रोनस रिस्पॉन्स मिलते रहेंगे. भले ही, यह सुविधा चालू हो या नहीं.
अगर प्रॉमिस रिज़ॉल्व हो जाता है, तो रिज़ॉल्व की गई वैल्यू को जवाब के तौर पर भेजा जाता है.
अगर प्रॉमिस अस्वीकार कर दिया जाता है, तो गड़बड़ी के मैसेज के साथ, भेजने वाले का sendMessage() कॉल अस्वीकार कर दिया जाएगा. ज़्यादा जानकारी और उदाहरणों के लिए, गड़बड़ी ठीक करना सेक्शन देखें.
यहां एक उदाहरण दिया गया है, जिसमें प्रॉमिस को रिज़ॉल्व या अस्वीकार किया जा सकता है:
// Event listener
function handleMessages(message, sender, sendResponse) {
// Return a promise that wraps fetch
// If the response is OK, resolve with the status. If it's not OK then reject
// with the network error that prevents the fetch from completing.
return new Promise((resolve, reject) => {
fetch('https://example.com')
.then(response => {
if (!response.ok) {
reject(response);
} else {
resolve(response.status);
}
})
.catch(error => {
reject(error);
});
});
}
browser.runtime.onMessage.addListener(handleMessages);
प्रॉमिस रिटर्न करने के लिए, लिसनर को async के तौर पर भी डिक्लेयर किया जा सकता है:
browser.runtime.onMessage.addListener(async function(message, sender) {
const response = await fetch('https://example.com');
if (!response.ok) {
// rejects the promise returned by `async function`.
throw new Error(`Fetch failed: ${response.status}`);
}
// resolves the promise returned by `async function`.
return {statusCode: response.status};
});
प्रॉमिस रिटर्न करना: async फ़ंक्शन से जुड़ी समस्याएं
ध्यान रखें कि लिसनर के तौर पर काम करने वाला async फ़ंक्शन, हमेशा प्रॉमिस रिटर्न करेगा. भले ही, उसमें return स्टेटमेंट न हो. अगर कोई async लिसनर कोई वैल्यू नहीं दिखाता है, तो उसका प्रॉमिस अपने-आप undefined पर रिज़ॉल्व हो जाता है. साथ ही, ईमेल भेजने वाले को जवाब के तौर पर null भेजा जाता है. जब एक से ज़्यादा लिसनर हों, तो इसकी वजह से अनचाहा व्यवहार देखने को मिल सकता है:
// content_script.js
function handleResponse(message) {
// The first listener promise resolves to `undefined` before the second
// listener can respond. When a listener responds with `undefined`, Chrome
// sends null as the response.
console.assert(message === null);
}
function notifyBackgroundPage() {
const sending = browser.runtime.sendMessage('test');
sending.then(handleResponse);
}
notifyBackgroundPage();
// background.js
browser.runtime.onMessage.addListener(async (message) => {
// This just causes the function to pause for a millisecond, but the promise
// is *not* returned from the listener so it doesn't act as a response.
await new Promise(resolve => {
setTimeout(resolve, 1, 'OK');
});
// `async` functions always return promises. So once we
// reach here there is an implicit `return undefined;`. Chrome translates
// `undefined` responses to `null`.
});
browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
return new Promise((resolve) => {
setTimeout(resolve, 1000, 'response');
});
});
गड़बड़ी ठीक करना
Chrome 146 से, अगर कोई onMessage लिसनर गड़बड़ी दिखाता है (सिंक्रोनस तरीके से या एसिंक्रोनस तरीके से, अस्वीकार करने वाला प्रॉमिस दिखाकर), तो भेजने वाले के sendMessage() से दिखाया गया प्रॉमिस, गड़बड़ी के मैसेज के साथ अस्वीकार कर दिया जाएगा. यह अपडेट धीरे-धीरे रोल आउट किया जा रहा है. इसलिए, हो सकता है कि यह बदलाव अभी सभी उपयोगकर्ताओं के ब्राउज़र में लागू न हुआ हो. आपको यह पक्का करना चाहिए कि आपका एक्सटेंशन,
इस बदलाव को हैंडल कर सकता है या नहीं.
अगर कोई लिसनर ऐसा जवाब देने की कोशिश करता है जिसे सीरियलाइज़ नहीं किया जा सकता (नतीजे के तौर पर मिलने वाले TypeError को पकड़े बिना), तो इसे भी लिसनर की गड़बड़ी माना जाएगा.
अगर कोई लिसनर, प्रॉमिस को अस्वीकार करता है, तो उसे Error के इंस्टेंस के साथ अस्वीकार करना होगा, ताकि ईमेल भेजने वाले को गड़बड़ी का मैसेज मिल सके. अगर प्रॉमिस को किसी अन्य वैल्यू (जैसे, null या undefined) के साथ अस्वीकार किया जाता है, तो sendMessage() को गड़बड़ी के सामान्य मैसेज के साथ अस्वीकार कर दिया जाएगा.
अगर onMessage के लिए एक से ज़्यादा लिसनर रजिस्टर किए गए हैं, तो सिर्फ़ जवाब देने वाले, अस्वीकार करने वाले या गड़बड़ी दिखाने वाले पहले लिसनर का असर, ईमेल भेजने वाले पर पड़ेगा. अन्य सभी लिसनर चलेंगे, लेकिन उनके नतीजों को अनदेखा कर दिया जाएगा.
उदाहरण
अगर कोई लिसनर ऐसा प्रॉमिस दिखाता है जो अस्वीकार हो जाता है, तो sendMessage() को अस्वीकार कर दिया जाता है:
// sender.js
try {
await browser.runtime.sendMessage('test');
} catch (e) {
console.log(e.message); // "some error"
}
// listener.js
browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
return Promise.reject(new Error('some error'));
});
अगर लिसनर ऐसी वैल्यू के साथ जवाब देता है जिसे सीरियलाइज़ नहीं किया जा सकता, तो sendMessage() को अस्वीकार कर दिया जाता है:
// sender.js
try {
await browser.runtime.sendMessage('test');
} catch (e) {
console.log(e.message); // "Error: Could not serialize message."
}
// listener.js
browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
sendResponse(() => {}); // Functions are not serializable
return true; // Keep channel open for async sendResponse
});
अगर कोई लिसनर, किसी दूसरे लिसनर के जवाब देने से पहले सिंक्रोनस तरीके से गड़बड़ी दिखाता है, तो लिसनर का sendMessage() प्रॉमिस अस्वीकार कर दिया जाता है:
// sender.js
try {
await browser.runtime.sendMessage('test');
} catch (e) {
console.log(e.message); // "error!"
}
// listener.js
browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
throw new Error('error!');
});
हालांकि, अगर कोई लिसनर किसी दूसरे लिसनर के गड़बड़ी का मैसेज देने से पहले जवाब देता है, तो sendMessage() सफल हो जाता है:
// sender.js
const response = await browser.runtime.sendMessage('test');
console.log(response); // "OK"
// listener.js
browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
sendResponse('OK');
});
browser.runtime.onMessage.addListener((message, sender, sendResponse) => {
throw new Error('error!');
});
लंबे समय तक चलने वाले कनेक्शन
फिर से इस्तेमाल किया जा सकने वाला और लंबे समय तक चलने वाला मैसेज पासिंग चैनल बनाने के लिए, इसे कॉल करें:
runtime.connect(), ताकि कॉन्टेंट स्क्रिप्ट से एक्सटेंशन पेज पर मैसेज भेजे जा सकेंtabs.connect(), ताकि एक्सटेंशन पेज से कॉन्टेंट स्क्रिप्ट में मैसेज भेजे जा सकें.
अलग-अलग तरह के कनेक्शन के बीच अंतर करने के लिए, name कुंजी के साथ विकल्प पैरामीटर पास करके, अपने चैनल को नाम दिया जा सकता है:
const port = browser.runtime.connect({name: "example"});
लंबे समय तक चलने वाले कनेक्शन का एक संभावित इस्तेमाल, फ़ॉर्म को अपने-आप भरने वाला एक्सटेंशन है. कॉन्टेंट स्क्रिप्ट, किसी खास लॉगिन के लिए एक्सटेंशन पेज पर एक चैनल खोल सकती है. साथ ही, पेज पर मौजूद हर इनपुट एलिमेंट के लिए एक्सटेंशन को एक मैसेज भेज सकती है, ताकि फ़ॉर्म में भरने के लिए डेटा का अनुरोध किया जा सके. शेयर किए गए कनेक्शन की मदद से, एक्सटेंशन के कॉम्पोनेंट के बीच एक्सटेंशन की स्थिति शेयर की जा सकती है.
कनेक्शन बनाते समय, हर सिरे को एक runtime.Port ऑब्जेक्ट असाइन किया जाता है. इससे उस कनेक्शन के ज़रिए मैसेज भेजे और पाए जा सकते हैं.
कॉन्टेंट स्क्रिप्ट से चैनल खोलने और मैसेज भेजने और सुनने के लिए, यहां दिए गए कोड का इस्तेमाल करें:
content-script.js:
const port = browser.runtime.connect({name: "knockknock"});
port.onMessage.addListener(function(msg) {
if (msg.question === "Who's there?") {
port.postMessage({answer: "Madame"});
} else if (msg.question === "Madame who?") {
port.postMessage({answer: "Madame... Bovary"});
}
});
port.postMessage({joke: "Knock knock"});
एक्सटेंशन से कॉन्टेंट स्क्रिप्ट को अनुरोध भेजने के लिए, पिछले उदाहरण में runtime.connect() के कॉल को tabs.connect() से बदलें.
कॉन्टेंट स्क्रिप्ट या एक्सटेंशन पेज के लिए, इनकमिंग कनेक्शन मैनेज करने के लिए, runtime.onConnect इवेंट लिसनर सेट अप करें. जब आपके एक्सटेंशन का कोई दूसरा हिस्सा connect() को कॉल करता है, तो यह इस इवेंट और runtime.Port ऑब्जेक्ट को चालू कर देता है. इनकमिंग कनेक्शन का जवाब देने के लिए कोड इस तरह दिखता है:
service-worker.js:
browser.runtime.onConnect.addListener(function(port) {
if (port.name !== "knockknock") {
return;
}
port.onMessage.addListener(function(msg) {
if (msg.joke === "Knock knock") {
port.postMessage({question: "Who's there?"});
} else if (msg.answer === "Madame") {
port.postMessage({question: "Madame who?"});
} else if (msg.answer === "Madame... Bovary") {
port.postMessage({question: "I don't get it."});
}
});
});
एपिसोड क्रम से लगाने की सेटिंग
Chrome में, मैसेज पास करने वाले एपीआई, JSON सीरियलाइज़ेशन का इस्तेमाल करते हैं. ध्यान देने वाली बात यह है कि यह उन अन्य ब्राउज़र से अलग है जो स्ट्रक्चर्ड क्लोन एल्गोरिदम के साथ एक जैसे एपीआई लागू करते हैं.
इसका मतलब है कि किसी मैसेज (और पाने वालों के जवाबों) में कोई भी मान्य JSON.stringify() वैल्यू शामिल हो सकती है. अन्य वैल्यू को सीरियलाइज़ की जा सकने वाली वैल्यू में बदल दिया जाएगा. खास तौर पर,
undefined को null के तौर पर सीरियलाइज़ किया जाएगा;
मैसेज के साइज़ की सीमाएं
मैसेज का साइज़ ज़्यादा से ज़्यादा 64 एमआईबी हो सकता है.
पोर्ट लाइफ़टाइम
पोर्ट को किसी एक्सटेंशन के अलग-अलग हिस्सों के बीच, दोतरफ़ा कम्यूनिकेशन के तरीके के तौर पर डिज़ाइन किया गया है. जब एक्सटेंशन का कोई हिस्सा tabs.connect(), runtime.connect() या runtime.connectNative() को कॉल करता है, तो यह एक पोर्ट बनाता है. यह पोर्ट, postMessage() का इस्तेमाल करके तुरंत मैसेज भेज सकता है.
अगर किसी टैब में कई फ़्रेम हैं, तो tabs.connect() को कॉल करने पर, टैब में मौजूद हर फ़्रेम के लिए, runtime.onConnect इवेंट को एक बार ट्रिगर किया जाता है. इसी तरह, अगर runtime.connect() को कॉल किया जाता है, तो एक्सटेंशन प्रोसेस में हर फ़्रेम के लिए, onConnect इवेंट को एक बार ट्रिगर किया जा सकता है.
आपको यह पता लगाना पड़ सकता है कि कनेक्शन कब बंद हुआ. उदाहरण के लिए, अगर आपको हर खुले पोर्ट के लिए अलग-अलग स्टेटस बनाए रखने हैं. ऐसा करने के लिए, runtime.Port.onDisconnect इवेंट को सुनें. यह इवेंट तब ट्रिगर होता है, जब चैनल के दूसरे सिरे पर कोई मान्य पोर्ट न हो. इसकी ये वजहें हो सकती हैं:
runtime.onConnectके लिए, दूसरी तरफ़ कोई सुनने वाला नहीं है.- पोर्ट वाला टैब अनलोड हो गया हो. उदाहरण के लिए, अगर टैब को नेविगेट किया गया हो.
- वह फ़्रेम अनलोड हो गया है जिसमें
connect()को कॉल किया गया था. runtime.onConnectके ज़रिए पोर्ट पाने वाले सभी फ़्रेम अनलोड हो गए हैं.runtime.Port.disconnect()को दूसरे छोर से कॉल किया जाता है. अगर किसीconnect()कॉल की वजह से, रिसीवर के एंड पर कई पोर्ट बनते हैं और इनमें से किसी भी पोर्ट परdisconnect()को कॉल किया जाता है, तोonDisconnectइवेंट सिर्फ़ भेजने वाले पोर्ट पर ट्रिगर होता है, अन्य पोर्ट पर नहीं.
क्रॉस-एक्सटेंशन मैसेजिंग
अपने एक्सटेंशन के अलग-अलग कॉम्पोनेंट के बीच मैसेज भेजने के अलावा, मैसेजिंग एपीआई का इस्तेमाल करके अन्य एक्सटेंशन के साथ भी कम्यूनिकेट किया जा सकता है. इससे, अन्य एक्सटेंशन के इस्तेमाल के लिए, सार्वजनिक एपीआई को एक्सपोज़ किया जा सकता है.
अन्य एक्सटेंशन से आने वाले अनुरोधों और कनेक्शन को सुनने के लिए, runtime.onMessageExternal या runtime.onConnectExternal तरीके इस्तेमाल करें. यहां हर एक का उदाहरण दिया गया है:
service-worker.js
// For a single request:
browser.runtime.onMessageExternal.addListener(
function(request, sender, sendResponse) {
if (sender.id !== allowlistedExtension) {
return; // don't allow this extension access
}
if (request.getTargetData) {
sendResponse({ targetData: targetData });
} else if (request.activateLasers) {
const success = activateLasers();
sendResponse({ activateLasers: success });
}
}
);
// For long-lived connections:
browser.runtime.onConnectExternal.addListener(function(port) {
port.onMessage.addListener(function(msg) {
// See other examples for sample onMessage handlers.
});
});
किसी दूसरे एक्सटेंशन को मैसेज भेजने के लिए, उस एक्सटेंशन का आईडी पास करें जिससे आपको कम्यूनिकेट करना है. इसके लिए, यह तरीका अपनाएं:
service-worker.js
// The ID of the extension we want to talk to.
const laserExtensionId = "abcdefghijklmnoabcdefhijklmnoabc";
// For a minimal request:
browser.runtime.sendMessage(laserExtensionId, {getTargetData: true},
function(response) {
if (targetInRange(response.targetData))
browser.runtime.sendMessage(laserExtensionId, {activateLasers: true});
}
);
// For a long-lived connection:
const port = browser.runtime.connect(laserExtensionId);
port.postMessage(...);
वेब पेजों से मैसेज भेजना
एक्सटेंशन, वेब पेजों से मैसेज पा सकते हैं और उनका जवाब दे सकते हैं. किसी वेब पेज से एक्सटेंशन पर मैसेज भेजने के लिए, अपनी manifest.json में बताएं कि आपको किन वेबसाइटों से मैसेज पाने की अनुमति देनी है. इसके लिए, "externally_connectable" मेनिफ़ेस्ट कुंजी का इस्तेमाल करें. उदाहरण के लिए:
manifest.json
"externally_connectable": {
"matches": ["https://*.example.com/*"]
}
इससे, मैसेज सेवा एपीआई को उन सभी पेजों के लिए उपलब्ध कराया जाता है जो आपके तय किए गए मैच पैटर्न से मेल खाते हैं.
किसी एक्सटेंशन को मैसेज भेजने के लिए, runtime.sendMessage() या runtime.connect() एपीआई का इस्तेमाल करें. उदाहरण के लिए:
webpage.js
// The ID of the extension we want to talk to.
const editorExtensionId = 'abcdefghijklmnoabcdefhijklmnoabc';
// Check if extension is installed
if (chrome && browser.runtime) {
// Make a request:
browser.runtime.sendMessage(
editorExtensionId,
{
openUrlInEditor: url
},
(response) => {
if (!response.success) handleError(url);
}
);
}
अपने एक्सटेंशन से, वेब पेजों से मिलने वाले मैसेज सुनें. इसके लिए, runtime.onMessageExternal या runtime.onConnectExternal एपीआई का इस्तेमाल करें. यह तरीका, क्रॉस-एक्सटेंशन मैसेजिंग में इस्तेमाल किए जाने वाले तरीके जैसा ही है. यहां एक उदाहरण दिया गया है:
service-worker.js
browser.runtime.onMessageExternal.addListener(
function(request, sender, sendResponse) {
if (sender.url === blocklistedWebsite)
return; // don't allow this web page access
if (request.openUrlInEditor)
openUrl(request.openUrlInEditor);
});
किसी एक्सटेंशन से वेब पेज पर मैसेज नहीं भेजा जा सकता.
नेटिव मैसेज सेवा
एक्सटेंशन, नेटिव मैसेजिंग होस्ट के तौर पर रजिस्टर किए गए नेटिव ऐप्लिकेशन के साथ मैसेज एक्सचेंज कर सकते हैं. इस सुविधा के बारे में ज़्यादा जानने के लिए, नेटिव मैसेजिंग लेख पढ़ें.
सुरक्षा से जुड़ी ज़रूरी बातें
मैसेज सेवा से जुड़ी सुरक्षा के बारे में कुछ ज़रूरी बातें यहां दी गई हैं.
कॉन्टेंट स्क्रिप्ट कम भरोसेमंद होती हैं
एक्सटेंशन सर्विस वर्कर की तुलना में, कॉन्टेंट स्क्रिप्ट कम भरोसेमंद होती हैं. उदाहरण के लिए, नुकसान पहुंचाने वाला कोई वेब पेज, कॉन्टेंट स्क्रिप्ट को चलाने वाली रेंडरिंग प्रोसेस को नुकसान पहुंचा सकता है. यह मान लें कि कॉन्टेंट स्क्रिप्ट से मिले मैसेज, किसी हमलावर ने बनाए हैं. साथ ही, सभी इनपुट की पुष्टि करें और उन्हें सैनिटाइज़ करें. यह मान लें कि कॉन्टेंट स्क्रिप्ट को भेजा गया कोई भी डेटा, वेब पेज पर लीक हो सकता है. कॉन्टेंट स्क्रिप्ट से मिले मैसेज से ट्रिगर होने वाली खास कार्रवाइयों के दायरे को सीमित करें.
क्रॉस-साइट स्क्रिप्टिंग
पक्का करें कि आपकी स्क्रिप्ट, क्रॉस-साइट स्क्रिप्टिंग से सुरक्षित हों. जब किसी ऐसे सोर्स से डेटा मिलता है जिस पर भरोसा नहीं किया जा सकता, जैसे कि उपयोगकर्ता का इनपुट, कॉन्टेंट स्क्रिप्ट के ज़रिए दूसरी वेबसाइटें या कोई एपीआई, तो इस बात का ध्यान रखें कि इसे एचटीएमएल के तौर पर न समझा जाए या इसका इस्तेमाल इस तरह से न किया जाए जिससे अनचाहा कोड चल सके.
जब भी संभव हो, ऐसे एपीआई इस्तेमाल करें जो स्क्रिप्ट नहीं चलाते:
service-worker.js
browser.tabs.sendMessage(tab.id, {greeting: "hello"}, function(response) { // JSON.parse doesn't evaluate the attacker's scripts. const resp = JSON.parse(response.farewell); });
service-worker.js
browser.tabs.sendMessage(tab.id, {greeting: "hello"}, function(response) { // innerText does not let the attacker inject HTML elements. document.getElementById("resp").innerText = response.farewell; });
इन तरीकों का इस्तेमाल करने से बचें, क्योंकि इनसे आपके एक्सटेंशन को नुकसान पहुंच सकता है:
service-worker.js
browser.tabs.sendMessage(tab.id, {greeting: "hello"}, function(response) { // WARNING! Might be evaluating a malicious script! const resp = eval(`(${response.farewell})`); });
service-worker.js
browser.tabs.sendMessage(tab.id, {greeting: "hello"}, function(response) { // WARNING! Might be injecting a malicious script! document.getElementById("resp").innerHTML = response.farewell; });