सील्ड और पबनब के साथ एंड-टू-एंड एन्क्रिप्टेड चैट कैसे बनाएं

नमस्ते 👋

आज, आइए जानें कि पबनब और सीलबंद एसडीके के साथ एंड-टू-एंड एन्क्रिप्टेड चैट कैसे बनाएं ।

👉 पबनब और सील्ड का उपयोग कैसे करें इसका एक पूरी तरह से काम करने वाला उदाहरण यहां पाया जा सकता है: https://github.com/seald/pubnub-example-project

पबनब क्या है?

पबनब एक वास्तविक समय संचार सेवा है जिसे अधिकांश अनुप्रयोगों में एकीकृत किया जा सकता है। विश्वसनीय और स्केलेबल, इसे आसानी से सबसे सामान्य ढांचे के साथ एकीकृत किया जा सकता है।

सील्ड क्या है?

Seald.io एक SDK प्रदान करता है जो आपको बिना किसी पूर्व क्रिप्टोग्राफ़िक ज्ञान के उन्नत प्रबंधन सुविधाओं के साथ एंड-टू-एंड एन्क्रिप्शन करने की अनुमति देता है। इस एसडीके को वेब, बैकएंड, मोबाइल या डेस्कटॉप एप्लिकेशन में एकीकृत किया जा सकता है।

सामग्री अवलोकन

• एंड-टू-एंड एन्क्रिप्शन का उपयोग क्यों करें?
• PubNub एन्क्रिप्शन हुक के बजाय Seald.io का उपयोग क्यों करें?👀
• लक्ष्य 🏆
• कार्यान्वयन 🧠
• सील्ड 🔒💬 के साथ एंड-टू-एंड एन्क्रिप्शन जोड़ना
• निष्कर्ष ✅

एंड-टू-एंड एन्क्रिप्शन का उपयोग क्यों करें? 🔒

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

एंड-टू-एंड एन्क्रिप्शन आपको हर समय नियंत्रण रखने की अनुमति देता है, जब आपका डेटा पारगमन में होता है, जब यह आराम पर होता है, और यहां तक कि जब यह आपके हाथ में नहीं होता है। इस प्रकार, यह अन्य एन्क्रिप्शन प्रौद्योगिकियों (टीएलएस, पूर्ण-डिस्क एन्क्रिप्शन, ...) की तुलना में कहीं अधिक व्यापक सुरक्षा प्रदान करता है।

जब भी आप किसी ऐसे मामले का सामना करते हैं जहां अनुपालन महत्वपूर्ण है (जीडीपीआर, एचआईपीएए, एसओसी-2,...) या जहां आपके पास संवेदनशील डेटा (चिकित्सा, रक्षा,...) है, तो एंड-टू-एंड एन्क्रिप्शन जरूरी है। लेकिन अधिक सामान्य डेटा के लिए भी, यह अच्छा अभ्यास है। डेटा उल्लंघन एक विनाशकारी घटना है जो लगातार बढ़ती जा रही है।

PubNub एन्क्रिप्शन हुक के बजाय Seald.io का उपयोग क्यों करें?👀

PubNub SDK अपने SDK को इंस्टेंट करते समय cipherKey तर्क का उपयोग करके एक सरल एन्क्रिप्शन हुक प्रदान करता है। ऐसा करने से यह सुनिश्चित हो जाएगा कि अपलोड किए गए सभी संदेश भेजे जाने से पहले एन्क्रिप्ट किए गए हैं। हालाँकि, आपको कुंजी प्रबंधन स्वयं करना होगा, जो एंड-टू-एंड एन्क्रिप्टेड सिस्टम का सबसे कठिन हिस्सा है।

कमजोरियाँ शायद ही कभी एन्क्रिप्शन से आती हैं, लेकिन अधिकतर सुरक्षा मॉडल में खामियों के कारण चाबियाँ लीक होने से आती हैं ।

अपनी सुरक्षा के लिए तृतीय-पक्ष सेवा का उपयोग करने से आपको विफलता का एक भी बिंदु नहीं मिलता है। Seald.io एक मजबूत सुरक्षा मॉडल का प्रस्ताव करता है, जो वास्तविक समय पहुंच-प्रबंधन नियंत्रण, उपयोगकर्ता निरस्तीकरण और पुनर्प्राप्ति, 2FA और बहुत कुछ के साथ ANSSI द्वारा प्रमाणित है ।

लक्ष्य 🏆

यह आलेख बताता है कि अपनी चैट को एंड-टू-एंड एन्क्रिप्शन के साथ सुरक्षित करने के लिए चरण-दर-चरण पबनब के साथ सीलड को कैसे एकीकृत किया जाए। हम निम्नलिखित सुविधाओं के साथ एक उदाहरण मैसेजिंग ऐप बनाएंगे:

• एक-से-एक और समूह चैट रूम।

• प्रत्येक सदस्य के पास प्रत्येक अन्य उपयोगकर्ता के साथ एक समर्पित चैट रूम है।

• कोई भी व्यक्ति कई अन्य उपयोगकर्ताओं के साथ समूह चैट रूम बना सकता है।

• भेजे गए प्रत्येक संदेश और फ़ाइल के लिए एंड-टू-एंड एन्क्रिप्शन का उपयोग करें।

• चैट के लिए वास्तविक समय पहुंच प्रबंधन की अनुमति दें।

  
  

कार्यान्वयन 🧠

एक पबनब खाता सेट करें 👤

आरंभ करने के लिए, आपको एक पबनब खाते की आवश्यकता होगी। आप साइन अप कर सकते हैं यहाँ . एक बार अपने डैशबोर्ड पर लॉग इन करने के बाद, आपको देखना चाहिए कि डेमो कीसेट के साथ एक डेमो ऐप बनाया गया है:

डेमो कीसेट चुनें, और कॉन्फ़िगरेशन टैब पर स्क्रॉल करें। हमारे डेमो के लिए, हमें Files और Objects अनुमतियाँ सक्रिय करने की आवश्यकता है। Object अनुमति के लिए, हम निम्नलिखित इवेंट का उपयोग करेंगे: User Metadata Events , Channel Metadata Events और Membership Events ।

एक बार कीसेट बन जाने और कॉन्फ़िगर हो जाने के बाद, हमें इसे अपने फ्रंटएंड पर कॉपी करना होगा।

आइए src/ फ़ोल्डर पर एक JSON फ़ाइल बनाएं, जिसे settings.json कहा जाता है। हम इस फ़ाइल का उपयोग उन सभी एपीआई कुंजियों के लिए करेंगे जिनकी हमें आवश्यकता होगी। PubNub कुंजीसेट से प्रारंभ करें:

 { "PUBNUB_PUB_KEY": "pub-c-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", "PUBNUB_SUB_KEY": "sub-c-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" }

PubNub 💬 का उपयोग करके एक बुनियादी चैट बनाना

हम लगभग हर बैकएंड कार्य के लिए PubNub का उपयोग करेंगे। हमारा बैकएंड केवल उपयोगकर्ता साइन-अप/साइन-इन को संभालेगा, और केवल एक आईडी, एक नाम और एक ईमेल के साथ एक न्यूनतम उपयोगकर्ता मॉडल का उपयोग करेगा।

सामने की ओर, हमें एक छोटे प्रमाणीकरण इंटरफ़ेस की आवश्यकता है:

एक बार जब उपयोगकर्ता के पास खाता हो, तो सबसे पहली चीज़ जो उन्हें चाहिए वह है पबनब एसडीके का एक उदाहरण।

पबनब पर उपयोगकर्ता की पहचान करने के लिए, हमें एक यूयूआईडी प्रदान करना होगा।

चीजों को सरल बनाए रखने के लिए, हम अपने बैकएंड पर उसी आईडी का उपयोग करेंगे:

 /* frontend/src/App.js */ import settings from './settings.json' // our settings file for API keys /* ... */ const pubnub = new PubNub({ publishKey: settings.PUBNUB_PUB_KEY, subscribeKey: settings.PUBNUB_SUB_KEY, uuid: currentUser.id })

अपने बैकएंड को यथासंभव सरल बनाए रखने के लिए, हम उपयोगकर्ताओं की जानकारी का आदान-प्रदान करने के लिए पबनब के उपयोगकर्ता मेटाडेटा का उपयोग करेंगे।

SDK इन्स्टेन्शियेशन के ठीक बाद, हम बस PubNub setUUIDMetadata फ़ंक्शन को कॉल करते हैं:

 /* frontend/src/App.js */ await pubnub.objects.setUUIDMetadata({ uuid: currentUser.id, data: { email: currentUser.emailAddress, name: currentUser.name } })

प्रारंभिक ऐप स्थिति प्राप्त करना 🌱

PubNub के साथ करने वाली पहली चीज़ सभी मौजूदा सदस्यों को पुनः प्राप्त करना और उन्हें हमारे स्थानीय डेटा स्टोर में संग्रहीत करना है:

 /* frontend/src/App.js */ const existingMembers = await pubnub.objects.getAllUUIDMetadata() dispatch({ type: SET_USERS, payload: { users: existingMembers.data.map(u => new User({ id: u.id, name: u.name, emailAddress: u.email })) } })

प्रत्येक चैट रूम एक पबनब चैनल के अनुरूप होगा। हम प्रत्येक चैनल में कुछ मेटाडेटा भी जोड़ेंगे:

• ownerId : उस उपयोगकर्ता की आईडी जिसने कमरा बनाया है।

• one2one : डायरेक्ट मैसेजिंग रूम और ग्रुप रूम को अलग करने के लिए एक बूलियन।

• archived : एक बूलियन, हटाए गए समूह कक्ष को छिपाने के लिए।

  
  

सील्ड एसडीके जोड़ते समय ownerId मेटाडेटा का उपयोग बाद में किया जाएगा। पबनब के पास स्वामित्व अवधारणा नहीं है, लेकिन सील्ड के पास है। यह परिभाषित करेगा कि किसी चैनल से उपयोगकर्ताओं को कौन जोड़ या हटा सकता है। यह मूल रूप से एक समूह प्रशासक को परिभाषित करता है।

हम मौजूदा चैट रूम को पुनः प्राप्त करके शुरुआत करेंगे। हमें रूम मेटाडेटा की भी आवश्यकता होगी, इसलिए हमें कस्टम फ़ील्ड शामिल करने होंगे। फिर, हमें संग्रहीत कमरों को फ़िल्टर करना होगा और सब कुछ अपने डेटा स्टोर में भेजना होगा।

अंत में, हम कमरे से जुड़े पबनब चैनल की subscribe , इसलिए हमें नए संदेश प्राप्त होंगे:

 /* frontend/src/App.js */ // Retrieve rooms of which we are members const memberships = await pubnub.objects.getMemberships({ include: { customChannelFields: true } }) const knownRooms = [] // For each room, retrieve room members for (const room of memberships.data.filter(r => !r.channel.custom.archived)) { const roomMembers = await pubnub.objects.getChannelMembers({ channel: room.channel.id }) knownRooms.push(new Room({ id: room.channel.id, name: room.channel.name, users: roomMembers.data.map(u => u.uuid.id), ownerId: room.channel.custom.ownerId, one2one: room.channel.custom.one2one })) } // Store rooms in our data store dispatch({ type: SET_ROOMS, payload: { rooms: knownRooms } }) // Subscribe to channels to get new messages pubnub.subscribe({ channels: knownRooms.map(r => r.id) })

अब हमने वे सभी कमरे ले लिए हैं जिनमें हम हैं। ऐप इनिशियलाइज़ेशन को पूरा करने के लिए हमें एक आखिरी चीज़ की ज़रूरत है: यह सुनिश्चित करना कि हमारे पास नए पंजीकृत सदस्यों सहित सभी अन्य सदस्यों के साथ एक one2one कमरा है।

प्रत्येक नए पाए गए उपयोगकर्ता के लिए, हम एक नया कमरा बनाएंगे और एक हैलो संदेश भेजेंगे।

फिर, हम कमरे का मेटाडेटा सेट करेंगे, और उसकी सदस्यता लेंगे:

 /* frontend/src/App.js */ // Ensure that we have a one2one room with everyone const one2oneRooms = knownRooms.filter(r => r.one2one) for (const m of existingMembers.data.filter(u => u.id!== currentUser.id)) { if (!one2oneRooms.find(r => r.users.includes(m.id))) { // New user found: generating a new one2one room const newRoomId = PubNub.generateUUID() const newRoom = new Room({ id: newRoomId, users: [currentUser.id, m.id], one2one: true, name: m.name, ownerId: currentUser.id }) // Add the new room to our local list dispatch({ type: EDIT_OR_ADD_ROOM, payload: { room: new Room({ id: newRoomId, users: [currentUser.id, m.id], one2one: true, name: m.name, ownerId: currentUser.id }) } }) // Publish a "Hello" message in the room await pubnub.publish({ channel: newRoomId, message: { type: 'message', data: (await sealdSession.encryptMessage('Hello 👋')) } }) // Subscribe to the new room pubnub.subscribe({ channels: [newRoomId] }) await pubnub.objects.setChannelMetadata({ channel: newRoomId, data: { name: 'one2one', custom: { one2one: true, ownerId: currentUser.id, }, } }) await pubnub.objects.setChannelMembers({ channel: newRoomId, uuids: [currentUser.id, m.id] }) } }

एक बार यह सब हो जाने के बाद, हमारी प्रारंभिक ऐप स्थिति पूरी तरह से परिभाषित हो जाती है। हालाँकि, हमें इसे अद्यतन रखने की आवश्यकता है।

यह केवल membership आयोजनों के लिए एक ईवेंट श्रोता जोड़कर किया जा सकता है:

 /* frontend/src/App.js */ pubnub.addListener({ objects: async function(objectEvent) { if (objectEvent.message.type === 'membership') { if (objectEvent.message.event === 'delete') { // User is removed from a room /* Removing the room from store... */ } if (objectEvent.message.event === 'set') { // User is added to a room const metadata = await pubnub.objects.getChannelMetadata({ channel: objectEvent.message.data.channel.id }) const roomMembers = (await pubnub.objects.getChannelMembers({ channel: objectEvent.message.data.channel.id })).data.map(u => u.uuid.id) /* Adding new room to store + subscribing to new room channel... */ } } } }) pubnub.subscribe({ channels: [currentUser.id] }) // channel on which events concerning the current user are published

अब हम one2one चैट रूम पर ही नज़र डाल सकते हैं। फिर हम ग्रुप रूम संभालेंगे.

चैट रूम में संदेश प्राप्त करना और भेजना 📩

chat.js फ़ाइल में, हमारे पास चैट रूम के संदेशों को प्रदर्शित करने के लिए सभी तर्क होंगे।

इस कमरे को आरंभ करने के लिए, हमें केवल पहले से मौजूद सभी संदेशों को लाना होगा।

यह केवल कमरे की आईडी जानकर किया जा सकता है:

 /* frontend/src/components/Chat.jsx */ const fetchedMessages = (await pubnub.fetchMessages({ channels: [currentRoomId] })).channels[currentRoomId]

हम नए संदेश प्राप्त करने के लिए चैनल की सदस्यता ले सकते हैं, और उन्हें वास्तविक समय में प्रदर्शित करने के लिए एक श्रोता जोड़ सकते हैं:

 /* frontend/src/components/Chat.jsx */ pubnub.addListener({ message: handleReceiveMessage }) pubnub.subscribe({ channels: [currentRoomId] })

एक संदेश भेजने के लिए, हमें बस उसे चैनल पर प्रकाशित करना होगा:

 /* frontend/src/components/Chat.jsx */ const handleSubmitMessage = async e => { /* Some checks that the room is in a correct state... */ await pubnub.publish({ channel: state.room.id, message: { type: 'message', data: state.message } }) }

फ़ाइल भेजने के लिए, हम पहले उसे PubNub पर अपलोड करेंगे। फिर हम अपलोड की गई फ़ाइल यूआरआई प्राप्त करेंगे, और इसे चैट रूम में एक संदेश के रूप में प्रकाशित करेंगे:

 /* frontend/src/components/UploadButton.jsx */ // Upload Encrypted file const uploadData = await pubnub.sendFile({ channel: room.id, file: myFile, storeInHistory: false }) const fileURL = await pubnub.getFileUrl({ id: uploadData.id, name: uploadData.name, channel: room.id }) await pubnub.publish({ channel: state.room.id, message: { type: 'file', url: fileURL, fileName: await sealdSession.encryptMessage(selectedFiles[0].name) } })

समूह चैट प्रबंधित करना 👨‍👩‍👦‍👦

समूह बनाने और प्रबंधित करने के लिए, हमें उपयोगकर्ताओं के चयन के लिए एक इंटरफ़ेस की आवश्यकता होगी:

एक बार समूह के सदस्यों का चयन हो जाने के बाद, हम अपने कमरे के लिए एक पबनब चैनल बना सकते हैं, और फिर चैनल के लिए मेटाडेटा और सदस्यता सेट कर सकते हैं। यह कोड काफी हद तक वैसा ही है जैसा one2one कमरों के लिए किया जाता है, इसलिए हम इसे यहां नहीं दोहराएंगे।

अब हमारे पास एक पूर्ण चैट ऐप है। आइए प्रत्येक संदेश के लिए एंड-टू-एंड एन्क्रिप्शन जोड़ें!

सील्ड 🔒💬 के साथ एंड-टू-एंड एन्क्रिप्शन जोड़ना

एक सील्ड खाता सेट करें 👤

सील्ड से शुरुआत करने के लिए, एक निःशुल्क परीक्षण खाता बनाएं यहाँ

सील्ड डैशबोर्ड पर उतरते समय, कुछ यूआरएल और एपीआई टोकन प्रदर्शित होते हैं।

निम्नलिखित तत्व प्राप्त करें:

• ऐपआईडी
• एपीआईयूआरएल
• keyStorageURL

हम इन कुंजियों को अपनी settings.json में जोड़ देंगे:

 { "PUBNUB_PUB_KEY": "pub-c-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", "PUBNUB_SUB_KEY": "sub-c-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", "SEALD_APP_ID": "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", "SEALD_API_URL": "https://api.staging-0.seald.io", "SEALD_KEYSTORAGE_URL": "https://ssks.staging-0.seald.io" }

सील्ड एसडीके का उपयोग करने में सक्षम होने के लिए, साइन-अप करते समय प्रत्येक उपयोगकर्ता को लाइसेंस जेडब्ल्यूटी की आवश्यकता होती है।

इन JWT को एक गुप्त और एक गुप्त आईडी का उपयोग करके बैकएंड पर उत्पन्न करने की आवश्यकता है।

डैशबोर्ड लैंडिंग पृष्ठ से, JWT रहस्य और उससे संबंधित आईडी को backend/settings.json में कॉपी करें:

 { "SEALD_JWT_SECRET_ID": "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX", "SEALD_JWT_SECRET": "XXXXXXXXXXXXXXXXXXXXXXXX" }

साइनअप एपीआई कॉल के दौरान, हम एक सील्ड लाइसेंस जेडब्ल्यूटी उत्पन्न करेंगे, और इसे वापस लौटा देंगे:

 /* backend/routes/account.js */ const token = new SignJWT({ iss: settings.SEALD_JWT_SECRET_ID, jti: uuidv4(), /// Random string with enough entropy to never repeat. iat: Math.floor(Date.now() / 1000), // JWT valid only for 10 minutes. `Date.now()` returns the in milliseconds, this needs it in seconds. scopes: [3], // PERMISSION_JOIN_TEAM join_team: true }) .setProtectedHeader({ alg: 'HS256' }) const signupJWT = await token.sign(Buffer.from(settings.SEALD_JWT_SECRET, 'ascii'))

इसके बारे में अधिक जानकारी के लिए देखें JWT के बारे में हमारा दस्तावेज़ीकरण लेख .

फिर, हमें सील्ड एसडीके स्थापित करने की आवश्यकता है।

हमें सील्ड सर्वर पर उपयोगकर्ताओं की पहचान करने के लिए एक प्लगइन स्थापित करने की भी आवश्यकता है । ऐसा करने के लिए, हम sdk-plugin-ssks-password पैकेज का उपयोग करेंगे।

यह प्लगइन हमारे उपयोगकर्ताओं के सरल पासवर्ड प्रमाणीकरण की अनुमति देता है:

 npm i -S @seald-io/sdk @seald-io/sdk-plugin-ssks-password

सील्ड एसडीके को त्वरित करना 💡

फिर, हम एक seald.js फ़ाइल बनाएंगे। इस फ़ाइल में, हम सील्ड एसडीके को तुरंत चालू करने के लिए एक फ़ंक्शन बनाकर शुरुआत करेंगे:

 /* frontend/src/services/seald.js */ import SealdSDK from '@seald-io/sdk-web' import SealdSDKPluginSSKSPassword from '@seald-io/sdk-plugin-ssks-password' import settings from './settings.json' let sealdSDKInstance = null const instantiateSealdSDK = async () => { sealdSDKInstance = SealdSDK({ appId: settings.SEALD_APP_ID, apiURL: settings.SEALD_API_URL, plugins: [SealdSDKPluginSSKSPassword(settings.SEALD_KEYSTORAGE_URL)] }) }

सील पहचान बनाना और पुनः प्राप्त करना 🔑

seald.js में, हम दो फ़ंक्शन भी जोड़ेंगे: एक पहचान बनाने के लिए और दूसरा किसी को पुनः प्राप्त करने के लिए। पहचान बनाने के लिए, हमें खाता निर्माण के समय लौटाए गए लाइसेंस JWT की भी आवश्यकता होती है:

 /* frontend/src/services/seald.js */ export const createIdentity = async ({ userId, password, signupJWT }) => { await instantiateSealdSDK() await sealdSDKInstance.initiateIdentity({ signupJWT }) await sealdSDKInstance.ssksPassword.saveIdentity({ userId, password }) } export const retrieveIdentity = async ({ userId, password }) => { await instantiateSealdSDK() await sealdSDKInstance.ssksPassword.retrieveIdentity({ userId, password }) }

हमारे साइनअप और साइन-इन प्रवाह के दौरान, उपयोगकर्ता द्वारा लॉग इन करने के बाद हमें बस इन कार्यों को कॉल करने की आवश्यकता है।

इस बिंदु पर, जब भी हमारा उपयोगकर्ता कनेक्ट होता है, उसके पास एक कार्यशील सील्ड एसडीके होता है, जो एन्क्रिप्ट और डिक्रिप्ट करने के लिए तैयार होता है!

चेतावनी: उचित सुरक्षा के लिए, प्रमाणीकरण सर्वर पर भेजे जाने से पहले पासवर्ड को पहले से हैश किया जाना चाहिए। इस पर अधिक जानकारी के लिए कृपया देखें हमारे दस्तावेज़ में पासवर्ड प्रमाणीकरण के बारे में पैराग्राफ .

संदेशों को एन्क्रिप्ट और डिक्रिप्ट करना प्रारंभ करें 🔒🔓

प्रत्येक चैट रूम सील्ड एसडीके पर एक encryptionSession से जुड़ा होगा।

हर बार जब हम एक चैट रूम बनाते हैं, तो हमें एन्क्रिप्शन सत्र बनाने के लिए बस एक पंक्ति जोड़नी होती है, फिर इसका उपयोग करना होता है:

 /* frontend/src/App.js */ // Create a Seald session const sealdSession = await getSealdSDKInstance().createEncryptionSession( { userIds: [currentUser.id, m.id] }, { metadata: newRoomId } ) // Publish a "Hello" message in the room await pubnub.publish({ channel: newRoomId, message: { type: 'message', data: (await sealdSession.encryptMessage('Hello 👋')) } })

ध्यान दें कि हमारा उपयोगकर्ता encryptionSession.

किसी कमरे तक पहुँचते समय, हमें संबंधित encryptionSession प्राप्त करने की आवश्यकता होती है। इसे किसी भी एन्क्रिप्टेड संदेश या फ़ाइल से पुनर्प्राप्त किया जा सकता है। एक बार यह हमारे पास आ जाए, तो हम इसे घटक संदर्भ में रखेंगे।

फिर हम बस session.encryptMessage , session.encryptFile , session.decryptMessage और session.decryptFile फ़ंक्शंस का उपयोग कर सकते हैं।

आइए संदेशों से शुरू करें। संदेश भेजने के लिए:

 /* frontend/src/components/Chat.js */ const handleSubmitMessage = async m => { /* Some validation that we are in a valid room... */ // if there is no encryption session set in cache yet, create one // (should never happen, as a "Hello" is sent on room creation) if (!sealdSessionRef.current) { sealdSessionRef.current = await getSealdSDKInstance().createEncryptionSession( { userIds: state.room.users }, { metadata: state.room.id } ) } // use the session to encrypt the message we are trying to send const encryptedMessage = await sealdSessionRef.current.encryptMessage(state.message) // publish the encrypted message to pubnub await pubnub.publish({ channel: state.room.id, message: { type: 'message', data: encryptedMessage } }) /* Some cleanup... */ }

और जब हमें कोई संदेश प्राप्त होता है:

 /* frontend/src/components/Chat.js */ const decryptMessage = async m => { /* Filter out files... */ let encryptedData = m.message.data if (!sealdSessionRef.current) { // no encryption session set in cache yet // we try to get it by parsing the current message sealdSessionRef.current = await getSealdSDKInstance().retrieveEncryptionSession({ encryptedMessage: encryptedData }) // now that we have a session loaded, let's decrypt } const decryptedData = await sealdSessionRef.current.decryptMessage(encryptedData) // we have successfully decrypted the message return { ...m, uuid: m.uuid || m.publisher, value: decryptedData } /* Some error handling... */ } /* Other stuff... */ const handleReceiveMessage = async m => { const decryptedMessage = await decryptMessage(m) setState(draft => { draft.messages = [...draft.messages, decryptedMessage] }) }

इसके अलावा, हम कमरा खोलते समय सत्र में पहले से मौजूद सभी संदेशों को डिक्रिप्ट करने के लिए इस decryptMessage फ़ंक्शन का उपयोग करते हैं:

 /* frontend/src/components/Chat.js */ const fetchedMessages = (await pubnub.fetchMessages({ channels: [currentRoomId] })).channels[currentRoomId] const clearMessages = fetchedMessages ? await Promise.all(fetchedMessages.map(decryptMessage)) : []

और अब फाइलों के लिए. फ़ाइल अपलोड करने के लिए:

 /* frontend/src/components/UploadButton.js */ // Encrypt file const encryptedBlob = await sealdSession.encryptFile( selectedFiles[0], selectedFiles[0].name, { fileSize: selectedFiles[0].size } ) const encryptedFile = new File([encryptedBlob], selectedFiles[0].name) // Upload Encrypted file const uploadData = await pubnub.sendFile({ channel: room.id, file: encryptedFile, storeInHistory: false })

और किसी फ़ाइल को डिक्रिप्ट करने के लिए:

 /* frontend/src/components/Message.js */ const onClick = async () => { if (state.data.type === 'file') { const response = await fetch(state.data.url) const encryptedBlob = await response.blob() const { data: clearBlob, filename } = await sealdSession.decryptFile(encryptedBlob) const href = window.URL.createObjectURL(clearBlob) /* Create an <a> element and simulate a click on it to download the created objectURL */ } }

समूह के सदस्यों को प्रबंधित करना 👨‍👩‍👦

समूह चैट का अपना encryptionSession भी होगा। हर बार जब कोई समूह बनाया जाता है, तो हमें एक समूह बनाना होगा:

 /* frontend/src/components/ManageDialogRoom.js.js */ // To create the encryptionSession const sealdSession = await getSealdSDKInstance().createEncryptionSession( { userIds: dialogRoom.selectedUsersId }, { metadata: newRoomId } )

फिर, हर बार जब हम समूह के सदस्यों को संशोधित करते हैं, तो हमें उन्हें इसमें जोड़ना या हटाना होगा:

 /* frontend/src/components/ManageDialogRoom.js.js */ // we compare old and new members to figure out which ones were just added or removed const usersToRemove = dialogRoom.room.users.filter(id => !dialogRoom.selectedUsersId.includes(id)) const usersToAdd = dialogRoom.selectedUsersId.filter(id => !dialogRoom.room.users.includes(id)) if (usersToAdd.length > 0) { // for every added user, add them to the Seald session await dialogRoom.sealdSession.addRecipients({ userIds: usersToAdd }) // then add them to the pubnub channel await pubnub.objects.setChannelMembers({ channel: dialogRoom.room.id, uuids: usersToAdd }) } if (usersToRemove.length > 0) { // for every removed user, revoke them from the Seald session await dialogRoom.sealdSession.revokeRecipients({ userIds: usersToRemove }) // then remove them from the pubnub channel for (const u of usersToRemove) { await pubnub.objects.removeMemberships({ channels: [dialogRoom.room.id], uuid: u }) } }

निष्कर्ष ✅

एक बार यह हो गया, तो हमारा काम ख़त्म हो गया!

हम कोड की केवल कुछ पंक्तियों के साथ Seald को PubNub में एकीकृत करने में कामयाब रहे।

अब जब चैट एंड-टू-एंड एन्क्रिप्टेड है, तो आप अपने उपयोगकर्ताओं को आश्वस्त कर सकते हैं कि डेटा उल्लंघन के मामले में भी उनका डेटा गोपनीय रहेगा।

हमेशा की तरह, संकोच न करें संपर्क करें यदि आपको किसी अतिरिक्त मार्गदर्शन की आवश्यकता है।

यह देखने के लिए इंतजार नहीं कर सकते कि आपने क्या बनाया है 🥳।