फिर भी एक और पी 2 पी मैसेंजर

समीक्षा और भाषा प्रलेखन पढ़ना इस पर अधिक या कम उपयोगी एप्लिकेशन लिखने के लिए सीखने के लिए पर्याप्त नहीं है।

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

यह लेख शुरुआती भाषा और पीयर-टू-पीयर नेटवर्क में रुचि रखने वाले शुरुआती लोगों के लिए है।
और ऐसे पेशेवरों के लिए जो उचित विचारों की पेशकश कर सकते हैं या रचनात्मक आलोचना कर सकते हैं।

मैं काफी समय से जावा, पीएचपी, जेएस, अजगर में विसर्जन की डिग्री के साथ प्रोग्रामिंग कर रहा हूं।
और हर प्रोग्रामिंग भाषा अपने क्षेत्र में अच्छी है।

गो के लिए मुख्य क्षेत्र वितरित सेवाओं, माइक्रोसर्विसेज का निर्माण है।
सबसे अधिक बार, एक माइक्रोसेवा एक छोटा कार्यक्रम है जो इसकी अत्यधिक विशिष्ट कार्यक्षमता करता है।

लेकिन माइक्रोसर्विसेज को अभी भी एक-दूसरे के साथ संवाद करने में सक्षम होना चाहिए, इसलिए माइक्रोसिस्टर्स बनाने के लिए उपकरण को आसान और दर्द रहित नेटवर्किंग की अनुमति देनी चाहिए।
इसका परीक्षण करने के लिए, हम एक विकेंद्रीकृत नेटवर्क ऑफ पीयर (पीयर-टू-पीयर) के आयोजन के लिए एक आवेदन लिखेंगे, सबसे सरल एक पी 2 पी मैसेंजर है (वैसे, इस शब्द के लिए एक रूसी पर्याय है?)।

कोड में, मैं सक्रिय रूप से साइकिल चलाता हूं और गोलगप्पे को महसूस करने के लिए कदम उठाता हूं, रचनात्मक आलोचना और तर्कसंगत सुझाव प्राप्त करता हूं।

हम क्या करें?

पीयर (सहकर्मी) - मैसेंजर का एक अनूठा उदाहरण।

हमारे दूत को सक्षम होना चाहिए:

• आस-पास की दावतों का पता लगाएं
• अन्य साथियों के साथ संबंध स्थापित करें
• साथियों के साथ डेटा विनिमय एन्क्रिप्ट करें
• उपयोगकर्ता से संदेश प्राप्त करें
• उपयोगकर्ता को संदेश दिखाएं

कार्य को थोड़ा और दिलचस्प बनाने के लिए, आइए हम सभी को एक नेटवर्क पोर्ट के माध्यम से जाने दें।

यदि आप HTTP पर इस पोर्ट को खींचते हैं, तो हमें एक रिएक्ट एप्लिकेशन मिलता है जो वेब सॉकेट कनेक्शन स्थापित करके उसी पोर्ट को खींचता है।

यदि आप स्थानीय मशीन से HTTP के माध्यम से पोर्ट को खींचते हैं, तो हम बैनर दिखाते हैं।

यदि कोई अन्य सहकर्मी इस पोर्ट से जुड़ा है, तो एंड-टू-एंड एन्क्रिप्शन के साथ एक स्थायी कनेक्शन स्थापित किया जाता है।

आने वाले कनेक्शन का प्रकार निर्धारित करें

सबसे पहले, सुनने के लिए पोर्ट खोलें और हम नए कनेक्शन की प्रतीक्षा करेंगे।

net.ListenTCP("tcp", tcpAddr) 

नए कनेक्शन पर, पहले 4 बाइट्स पढ़ें।

हम HTTP क्रियाओं की सूची लेते हैं और इसके साथ हमारी 4 बाइट्स की तुलना करते हैं।

अब हम निर्धारित करते हैं कि क्या स्थानीय मशीन से एक कनेक्शन बनाया गया है, और यदि नहीं, तो हम एक बैनर के साथ प्रतिक्रिया करते हैं और लटकाते हैं।

  buf, err := readWriter.Peek(4) /*   */ if ItIsHttp(buf) { handleHttp(readWriter, conn, p) } else { peer := proto.NewPeer(conn) p.HandleProto(readWriter, peer) } /* ... */ if !strings.EqualFold(s, "127") && !strings.EqualFold(s, "[::") { response.Body = ioutil.NopCloser(strings.NewReader("Peer To Peer Messenger. see https://github.com/easmith/p2p-messenger")) } 

यदि कनेक्शन स्थानीय है, तो हम अनुरोध के अनुरूप फ़ाइल के साथ प्रतिक्रिया करते हैं।

तब मैंने स्वयं प्रसंस्करण लिखने का फैसला किया, हालांकि मैं मानक पुस्तकालय में उपलब्ध हैंडलर का उपयोग कर सकता था।

  //   func processRequest(request *http.Request, response *http.Response) {/*    */} //     fileServer := http.FileServer(http.Dir("./front/build/")) fileServer.ServeHTTP(NewMyWriter(conn), request) 

यदि पथ /ws डब्ल्यूएस /ws अनुरोध किया जाता है, तो हम एक वेबसोकेट कनेक्शन स्थापित करने का प्रयास करते हैं।

चूंकि मैंने बाइक को प्रसंस्करण फ़ाइल अनुरोधों में इकट्ठा किया है, इसलिए मैं गोरिल्ला / वेबस्कॉक लाइब्रेरी का उपयोग करके डब्ल्यूएस कनेक्शन का प्रसंस्करण करूंगा ।

ऐसा करने के लिए, MyWriter बनाएं और इसमें इंटरफ़ेस http.ResponseWriter और http.Hijacker अनुरूप तरीके लागू करें।

  // w - MyWriter func handleWs(w http.ResponseWriter, r *http.Request, p *proto.Proto) { c, err := upgrader.Upgrade(w, r, w.Header()) /*          */ } 

पीयर डिटेक्शन

एक स्थानीय नेटवर्क में साथियों की खोज करने के लिए, हम यूडीपी मल्टीकास्ट का उपयोग करेंगे।

हम मल्टीकास्ट आईपी पते पर अपने बारे में जानकारी के साथ पैकेट भेजेंगे।

  func startMeow(address string, p *proto.Proto) { conn, err := net.DialUDP("udp", nil, addr) /* ... */ for { _, err := conn.Write([]byte(fmt.Sprintf("meow:%v:%v", hex.EncodeToString(p.PubKey), p.Port))) /* ... */ time.Sleep(1 * time.Second) } } 

और सभी यूडीपी पैकेट के लिए मल्टीकास्ट आईपी से अलग से सुनें।

  func listenMeow(address string, p *proto.Proto, handler func(p *proto.Proto, peerAddress string)) { /* ... */ conn, err := net.ListenMulticastUDP("udp", nil, addr) /* ... */ _, src, err := conn.ReadFromUDP(buffer) /* ... */ // connectToPeer handler(p, peerAddress) } 

इस प्रकार हम खुद को घोषित करते हैं और अन्य दावतों की उपस्थिति के बारे में सीखते हैं।

आईपी ​​स्तर पर इसे व्यवस्थित करना संभव होगा, और यहां तक कि आईपीवी 4 पैकेज के आधिकारिक दस्तावेज में, कोड के उदाहरण के रूप में बस मल्टीकास्ट डेटा पैकेट दिया गया है।

पीयर इंटरेक्शन प्रोटोकॉल

हम एक लिफाफे (लिफाफा) में साथियों के बीच सभी संचार पैक करेंगे।

किसी भी लिफाफे पर हमेशा एक प्रेषक और एक प्राप्तकर्ता होता है, इसके लिए हम एक कमांड (जो वह उसके साथ ले जाता है) जोड़ देगा, एक पहचानकर्ता (अब तक यह एक यादृच्छिक संख्या है, लेकिन सामग्री के हैश के रूप में किया जा सकता है), सामग्री की लंबाई और लिफाफे की सामग्री - एक संदेश या कमांड पैरामीटर।

आदेश, (या सामग्री का प्रकार) को सफलतापूर्वक लिफाफे की शुरुआत में रखा गया है और हम 4 बाइट्स के आदेशों की एक सूची को परिभाषित करते हैं जो HTTP क्रियाओं के नाम के साथ अंतर नहीं करते हैं।

ट्रांसमिशन के दौरान पूरे लिफाफे को बाइट्स के एक सरणी में क्रमबद्ध किया जाता है।

हाथ मिलाना

जब कनेक्शन स्थापित हो जाता है, तो दावत तुरंत साझा सत्र कुंजी उत्पन्न करने के लिए अपना नाम, सार्वजनिक कुंजी और पंचाट सार्वजनिक कुंजी देते हुए, एक हैंडशेक के लिए पहुंचता है।

जवाब में, सहकर्मी को डेटा का एक समान सेट प्राप्त होता है, अपनी सूची में पाए जाने वाले सहकर्मी को पंजीकृत करता है और सामान्य सत्र कुंजी की गणना करता है (CalcSedenSecret)।

  func handShake(p *proto.Proto, conn net.Conn) *proto.Peer { /* ... */ peer := proto.NewPeer(conn) /*     */ p.SendName(peer) /*     */ envelope, err := proto.ReadEnvelope(bufio.NewReader(conn)) /* ... */ } 

दावत का आदान-प्रदान

एक हाथ मिलाने के बाद, साथियों ने अपने साथियों की सूची का आदान-प्रदान किया =)

ऐसा करने के लिए, लिस्ट कमांड के साथ एक लिफाफा भेजा जाता है, और साथियों की एक JSON सूची को इसकी सामग्री में रखा जाता है।
जवाब में, हमें एक समान लिफाफा मिलता है।

हम नए की सूचियों में पाते हैं और उनमें से प्रत्येक के साथ हम कनेक्ट करने की कोशिश करते हैं, हाथ मिलाते हैं, दावतों का आदान-प्रदान करते हैं और इसी तरह ...

उपयोगकर्ता संदेश

कस्टम संदेश हमारे लिए सबसे बड़े मूल्य हैं, इसलिए हम प्रत्येक कनेक्शन को एन्क्रिप्ट और हस्ताक्षर करेंगे।

एन्क्रिप्शन के बारे में

क्रिप्टो पैकेज से मानक (Google) गोलंग पुस्तकालयों में, बहुत सारे अलग-अलग एल्गोरिदम लागू होते हैं (कोई GOST मानक नहीं हैं)।

मुझे लगता है कि हस्ताक्षर के लिए सबसे सुविधाजनक Ed25519 वक्र है। हम संदेश साइन करने के लिए ed25519 लाइब्रेरी का उपयोग करेंगे।

बहुत शुरुआत में, मैंने ed25519 से प्राप्त एक महत्वपूर्ण जोड़ी का उपयोग करने के बारे में सोचा, न केवल हस्ताक्षर करने के लिए, बल्कि एक सत्र कुंजी बनाने के लिए भी।

हालांकि, साझा करने की कुंजी की गणना के लिए हस्ताक्षर करने की कुंजी लागू नहीं होती है - आपको अभी भी उन्हें संलग्न करने की आवश्यकता है:

 func CreateKeyExchangePair() (publicKey [32]byte, privateKey [32]byte) { pub, priv, err := ed25519.GenerateKey(nil) /* ... */ copy(publicKey[:], pub[:]) copy(privateKey[:], priv[:]) curve25519.ScalarBaseMult(&publicKey, &privateKey) /* ... */ } 

इसलिए, यह पंचांग कुंजी उत्पन्न करने का निर्णय लिया गया था, और आम तौर पर बोलना, यह सही दृष्टिकोण है जो हमलावरों को एक सामान्य कुंजी लेने का मौका नहीं छोड़ता है।

गणित प्रेमियों के लिए, यहाँ विकि लिंक दिए गए हैं:
डिफी प्रोटोकॉल - एलिप्टिकल कर्व्स पर Hellman_
डिजिटल सिग्नेचर एडीडीएसए

एक साझा कुंजी की पीढ़ी काफी मानक है: पहला, एक नए कनेक्शन के लिए, हम पंचांग कुंजी उत्पन्न करते हैं, हम सॉकेट के लिए एक सार्वजनिक कुंजी के साथ एक लिफाफा भेजते हैं।

विपरीत पक्ष एक ही करता है, लेकिन एक अलग क्रम में: यह एक सार्वजनिक कुंजी के साथ एक लिफाफा प्राप्त करता है, अपनी जोड़ी बनाता है और सार्वजनिक कुंजी को सॉकेट में भेजता है।

अब प्रत्येक प्रतिभागी के पास किसी और की सार्वजनिक और निजी पंचांग कुंजी है।

उन्हें गुणा करते हुए, हम दोनों के लिए एक ही कुंजी प्राप्त करते हैं, जिसका उपयोग हम संदेशों को एन्क्रिप्ट करने के लिए करेंगे।

 //CalcSharedSecret Calculate shared secret func CalcSharedSecret(publicKey []byte, privateKey []byte) (secret [32]byte) { var pubKey [32]byte var privKey [32]byte copy(pubKey[:], publicKey[:]) copy(privKey[:], privateKey[:]) curve25519.ScalarMult(&secret, &privKey, &pubKey) return } 

हम ब्लॉक युग्मन मोड (CBC) में लंबे समय से स्थापित एईएस एल्गोरिथ्म द्वारा संदेशों को एन्क्रिप्ट करेंगे।

ये सभी कार्यान्वयन आसानी से गोलंग प्रलेखन में पाए जाते हैं।

एन्क्रिप्शन ब्लॉक की लंबाई (16 बाइट्स) की लंबाई के लिए शून्य परिशोधन के साथ संदेश को ऑटो-फिलिंग एकमात्र शोधन है।

  //Encrypt the message func Encrypt(content []byte, key []byte) []byte { padding := len(content) % aes.BlockSize if padding != 0 { repeat := bytes.Repeat([]byte("\x00"), aes.BlockSize-(padding)) content = append(content, repeat...) } /* ... */ } //Decrypt encrypted message func Decrypt(encrypted []byte, key []byte) []byte { /* ... */ encrypted = bytes.Trim(encrypted, string([]byte("\x00"))) return encrypted } 

2013 में वापस, उन्होंने एईईएस (सीबीसी के समान मोड के साथ) को टेलिग्राम में संदेशों को एन्क्रिप्ट करने के लिए पावेल डुरोव से एक प्रतियोगिता के भाग के रूप में लागू किया।

उस समय, सबसे आम डिफी-हेलमैन प्रोटोकॉल का उपयोग टेलीग्रामों में एक अल्पकालिक कुंजी उत्पन्न करने के लिए किया जाता था ।

और फर्जी कनेक्शन से लोड को बाहर करने के लिए, प्रत्येक प्रमुख एक्सचेंज से पहले, ग्राहकों ने फैक्टराइजेशन समस्या को हल किया।

जीयूआई

हमें साथियों की सूची और उनके साथ संदेशों की एक सूची दिखाने की आवश्यकता है, और सहकर्मी के नाम के आगे काउंटर बढ़ाकर नए संदेशों का जवाब भी देना है।

यहाँ मुसीबतों के बिना - ReactJS + websocket।

वेब सॉकेट संदेश अनिवार्य रूप से अद्वितीय लिफाफे हैं, केवल उनमें सिफरटेक्स्ट नहीं होते हैं।

वे सभी WsCmd प्रकार के "वारिस" हैं और स्थानांतरण पर JSON में क्रमबद्ध हैं।

  //Serializable interface to detect that can to serialised to json type Serializable interface { ToJson() []byte } func toJson(v interface{}) []byte { json, err := json.Marshal(v) /*  err */ return json } /* ... */ //WsCmd WebSocket command type WsCmd struct { Cmd string `json:"cmd"` } //WsMessage WebSocket command: new Message type WsMessage struct { WsCmd From string `json:"from"` To string `json:"to"` Content string `json:"content"` } //ToJson convert to JSON bytes func (v WsMessage) ToJson() []byte { return toJson(v) } /* ... */ 

तो, एक HTTP अनुरोध रूट ("/") पर आता है, अब सामने प्रदर्शित करने के लिए, "सामने / निर्माण" निर्देशिका में देखें और index.html दें

वैसे इंटरफ़ेस बना हुआ है, अब उपयोगकर्ताओं के लिए विकल्प यह है: इसे एक ब्राउज़र में या एक अलग विंडो में चलाएं - WebView।

अंतिम विकल्प के लिए zserge / webview का उपयोग किया

  e := webview.Open("Peer To Peer Messenger", fmt.Sprintf("http://localhost:%v", initParams.Port), 800, 600, false) 

इसके साथ एक एप्लिकेशन बनाने के लिए, आपको एक और सिस्टम इंस्टॉल करना होगा

  sudo apt install libwebkit2gtk-4.0-dev 

जीयूआई के बारे में सोचने के क्रम में, मुझे जीटीके, क्यूटी के लिए कई लाइब्रेरी मिलीं, और कंसोल इंटरफ़ेस बहुत geeky लगेगा - https://github.com/jroimartin/gocui - मेरी राय में एक बहुत ही दिलचस्प विचार।

मैसेंजर लॉन्च

गोलांग स्थापना

बेशक, आपको पहले गो स्थापित करने की आवश्यकता है।
ऐसा करने के लिए, मैं अत्यधिक golang.org/doc/install अनुदेश का उपयोग करने की सलाह देता हूं ।

स्क्रिप्ट को कोसने के लिए सरल निर्देश

GOPATH में एक एप्लिकेशन डाउनलोड करें

यह इतनी व्यवस्था है कि सभी पुस्तकालय और यहां तक ​​कि आपकी परियोजनाएं तथाकथित GOPATH में होनी चाहिए।

डिफ़ॉल्ट रूप से, यह $ HOME / गो है। गो आपको एक साधारण आदेश के साथ सार्वजनिक भंडार से स्रोत को खींचने की अनुमति देता है:

  go get github.com/easmith/p2p-messenger 

अब, आपके $HOME/go/src/github.com/easmith/p2p-messenger मास्टर शाखा से स्रोत दिखाई देगा

Npm स्थापना और फ्रंट असेंबली

जैसा कि मैंने ऊपर लिखा है, हमारा GUI ReactJs पर फ्रंट के साथ एक वेब एप्लिकेशन है, इसलिए सामने वाले को अभी भी इकट्ठा होने की आवश्यकता है।

Nodejs + npm - यहाँ हमेशा की तरह।

बस मामले में, यहाँ ubuntu के लिए निर्देश है

अब हम मानक के रूप में सामने की विधानसभा शुरू करते हैं

 cd front npm update npm run build 

सामने तैयार है!

लांच

आइए जड़ पर वापस जाएं और अपने दूत की दावत का शुभारंभ करें।

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

डिफ़ॉल्ट रूप से, $USER@$HOSTNAME का उपयोग $USER@$HOSTNAME नाम और पोर्ट 35035 के रूप में किया जाता है।

इसलिए, हम स्थानीय नेटवर्क पर दोस्तों के साथ शुरू और चैट करते हैं।

  go run app.go -name Snowden 

गोलंग प्रोग्रामिंग पर प्रतिक्रिया

• सबसे महत्वपूर्ण बात जो मैं नोट करना चाहूंगा: जाने पर, यह तुरंत लागू हो जाता है कि मैंने क्या इरादा किया था ।
  लगभग आपकी जरूरत की हर चीज मानक पुस्तकालय में है।
• हालाँकि, एक कठिनाई थी जब मैंने GOPATH के अलावा एक निर्देशिका में परियोजना शुरू की।
  मैंने कोड लिखने के लिए GoLand का उपयोग किया। और पहले तो यह स्वतः-आयात पुस्तकालयों के साथ कोड को स्वचालित रूप से प्रारूपित करने के लिए शर्मनाक था।
• आईडीई में बहुत सारे कोड जनरेटर हैं , जो हमें कोड सेट के बजाय विकास पर ध्यान केंद्रित करने की अनुमति देते हैं।
• आपको जल्दी से बार-बार त्रुटि से निपटने की आदत होती है, लेकिन एक हाथ-चेहरा तब होता है जब आपको पता चलता है कि सामान्य स्थिति में जाने के लिए जब त्रुटि का सार उसके स्ट्रिंग प्रतिनिधित्व के अनुसार विश्लेषण किया जाता है।
  

   err != io.EOF 

• ओएस लाइब्रेरी के साथ चीजें थोड़ी बेहतर हैं। इस तरह के निर्माण समस्या के सार को समझने में मदद करते हैं।
  

   if os.IsNotExist(err) { /* ... */ } 

• बॉक्स से बाहर, हमें कोड को ठीक से पढ़ाने और परीक्षण लिखने के लिए सिखाता है।
  और कुछ हैं लेकिन। हमने ToJson() विधि के साथ इंटरफ़ेस का वर्णन किया है।
  इसलिए, दस्तावेज़ीकरण जनरेटर इस पद्धति के विवरण को लागू नहीं करता है जो इसे लागू करते हैं, इसलिए अनावश्यक चेतावनियों को हटाने के लिए, आपको दस्तावेज़ को प्रत्येक कार्यान्वित विधि (प्रोटो / mtypes.go) में कॉपी करना होगा।
• हाल ही में मुझे जावा में log4j की शक्ति की आदत हो गई है, इसलिए गो में पर्याप्त अच्छा लकड़हारा नहीं है।
  शायद परिशिष्टों और फॉर्मेटर्स के साथ गितूब सुंदर लॉगिंग की विशालता को देखने के लायक है।
• सरणियों के साथ असामान्य काम।
  उदाहरण के लिए, append फ़ंक्शन के माध्यम से होता है, और copy माध्यम से निश्चित लंबाई के एक सरणी में मनमानी लंबाई के एक सरणी का रूपांतरण।
• switch-case काम करता है जैसे if-elseif-else - लेकिन यह एक दिलचस्प तरीका है, लेकिन फिर से हाथ-चेहरा:
  यदि हम सामान्य switch-case व्यवहार चाहते हैं, तो हमें प्रत्येक मामले पर fallthrough करने की आवश्यकता है।
  आप भी goto उपयोग कर सकते हैं, लेकिन चलो नहीं, कृपया!
• कोई टर्नरी ऑपरेटर नहीं है और अक्सर यह सुविधाजनक नहीं है।

आगे क्या है?

तो सबसे सरल पीर-टू-पीयर मैसेंजर लागू किया जाता है।

शंकु crammed हैं, आगे आप उपयोगकर्ता की कार्यक्षमता में सुधार कर सकते हैं: फाइलें, चित्र, ऑडियो, इमोटिकॉन्स, आदि भेजना, आदि।

और आप अपने प्रोटोकॉल का आविष्कार नहीं कर सकते हैं, और Google प्रोटोकॉल बफर का उपयोग कर सकते हैं,
ब्लॉकचैन कनेक्ट करें और एथेरम स्मार्ट कॉन्ट्रैक्ट्स का उपयोग करके अपने आप को स्पैम से बचाएं।

स्मार्ट कॉन्ट्रैक्ट पर, समूह चैट, चैनल, एक नाम प्रणाली, अवतार और उपयोगकर्ता प्रोफाइल व्यवस्थित करें।

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

नतीजतन, आपको एक अच्छा प्रतिस्थापन टेलीग्राम / फोन मिलता है, आपको बस अपने सभी दोस्तों को वहां स्थानांतरित करना होगा =)

उपयोगिता

 godoc -HTTP=:6060