🍪 🚆 🐳 फिर भी एक और अजगर चैट क्लाइंट 🤘🏿 🔟 🤞🏽

अभिवादन, हब्रायुज़र।
एक हब पर अजगर पर एक चैट क्लाइंट के बारे में पहले से ही एक लेख था इस लेख ने मुझे अकादमिक उद्देश्यों के लिए अपनी बाइक लिखी, लेकिन किसी और के कोड को दोहराना दिलचस्प नहीं है। हम एक और दिलचस्प काम करेंगे: जब्बार (असममित आरएसए एन्क्रिप्शन) + पायक्यूट।
यदि दिलचस्पी है, तो बिल्ली में आपका स्वागत है।

बेशक, न केवल यह, बल्कि उदाहरण के लिए कि सामाजिक नेटवर्क में चैट टैप किया जाएगा, और सिर्फ अजगर में प्रोग्राम लिखने में अपने कौशल को बढ़ाएं।
यह कोड डेबियन, पायथन 2.7, क्यूटी 4.7 के तहत लिखा गया था, इसलिए मैं इसके लिए इसका वर्णन करूंगा, अन्य प्रणालियों में इसका परीक्षण नहीं किया गया था।

चलिए शुरू करते हैं

संदेश प्रारूप पर निर्णय लें।
1. प्रमुख अनुरोध
●getche "यदि आप यह संदेश देखते हैं, तो आपको उपयोगिता स्थापित करने की आवश्यकता है ..."
2. एक कुंजी भेज रहा है
# एसेंडकी 234234234
3. संदेश
#mesg 123123123
4. अंतिम संदेश अग्रेषित करना (लागू नहीं)
#getlastmesg
मैंने तय किया कि # <कुछ> आदेशों को नामित करने के लिए एक अच्छा विकल्प है, इसके अलावा, सभी संदेश एन्क्रिप्ट किए गए हैं और फॉर्म का एक संदेश # <कुछ भी> सही तरीके से भेजा जाएगा। मुझे लगता है कि कोई इसके बिना कर सकता था, मैं सिर्फ और अधिक सुंदर बनना चाहता था।

आइए सरल भाग से शुरू करें, जिसका नाम है जेबबीर भाग।

गिलबर क्लाइंट के लिए अपना खुद का इंजन लिखना दिलचस्प है, लेकिन अब हम परिणाम के लिए आगे बढ़ रहे हैं, तो चलिए तैयार किए गए xmpppy मॉड्यूल को लेते हैं। इसे कमांड के साथ इंस्टॉल करें
sudo easy_install xmpppy
आप निश्चित रूप से, इस पुस्तकालय का उपयोग तुरंत कर सकते हैं, लेकिन मुझे लगता है कि हमारे आवरण का उपयोग करना बेहतर है और इस कार्यक्षमता को एक अलग फ़ाइल में डाल दें, जो कि भविष्य में रिफ्लैक्टर के लिए आसान हो जाएगा यदि ऐसी आवश्यकता उत्पन्न होती है। इस लाइब्रेरी को काम करने के लिए, आपको निम्नलिखित की आवश्यकता है: हमारा जीडी, हमारा पासवर्ड और आने वाले संदेशों के लिए कॉलबैक।

jabber.py

#!/usr/bin/env python # -*- coding: utf-8 -*- import xmpp,sys #     xmpp class sjabber: def __init__(self,xmpp_jid,xmpp_pwd): self.xmpp_jid = xmpp_jid self.xmpp_pwd = xmpp_pwd self.jid = xmpp.protocol.JID(xmpp_jid) self.client = xmpp.Client(self.jid.getDomain(),debug=[]) def connect(self): con=self.client.connect() if not con: print 'could not connect!' sys.exit() print 'connected with',con auth = self.client.auth(self.jid.getNode(),str(self.xmpp_pwd),resource='xmpppy') if not auth: print 'could not authenticate!' sys.exit() print 'authenticated using',auth #    ! self.client.sendInitPresence(1) def Process(self): a = self.client.Process(1) def send(self,to,mess): id = self.client.send(xmpp.protocol.Message(to,mess)) print 'sent message with id',id def disconnect(self): self.client.sendInitPresence(1) self.client.disconnect() def userList(self): return self.client.getRoster().keys() def StepOn(self): try: self.Process() except: return 0 return 1 def setCB(self, CB): self.CB = CB self.client.RegisterHandler('message',self.messageCB) def messageCB(self,conn,mess): if ( mess.getBody() == None ): return self.CB(self,mess)

यह कोड, निर्मित होने पर, ऑब्जेक्ट्स को कनेक्ट होने के लिए इनिशियलाइज़ करता है। कनेक्ट कमांड सर्वर से कनेक्ट होता है। संदेश भेजने के लिए एक आवरण भी है। और वास्तव में, यह पुस्तकालय कोड के लिए केवल एक सज्जाकार है। बड़ी संख्या में तैयार पुस्तकालयों की उपस्थिति, मेरी राय में, अजगर के लिए एक बड़ा प्लस है और आपको काफी कम समय में कोड लिखने की अनुमति देता है।

हम एन्क्रिप्शन को फास्ट करते हैं।

मैंने RSA को एन्क्रिप्शन एल्गोरिथम के रूप में लेने का फैसला किया, सिर्फ इसलिए कि मुझे यह पसंद है। इसके अलावा, यह असममित है, अर्थात। प्रत्येक सत्र में हम नए कुंजी जोड़े उत्पन्न कर सकते हैं और केवल सार्वजनिक भाग वितरित कर सकते हैं। इस प्रकार, संदेशों के बजाय, तीसरे पक्ष को संदेशों के बजाय केवल HEX का एक गुच्छा दिखाई देगा।
मैंने उन्हीं कारणों से एन्क्रिप्शन मॉड्यूल को अलग बनाया।

rsa_decor.py

 # -*- coding: utf-8 -*- import rsa class Crypt: def __init__(self): #        self.keys = dict() #     (a,b) = self.genKey(1024) self.privateKey = b self.pubKey = a def hasKey(self,id): #      if self.keys.has_key(id)==False: return False else: return True def decodeKey(self,key): #         return rsa.PublicKey(1,1).load_pkcs1(key,format='DER') def saveKey(self,id,key): #  self.keys[id]= key def genKey(self,size): #   return rsa.newkeys(size, poolsize=8) def cryptMesg(self,to,mesg): #  getHex =mesg.encode('utf-8').encode('hex') a = rsa.encrypt(getHex, self.keys[to]) #print len(mesg),len(a) return a.encode('hex') def decryptMesg(self,mesg): #  ,    try: mess = rsa.decrypt(mesg.decode("hex"),self.privateKey) except rsa.pkcs1.DecryptionError: print "cant decrypt" return "#errorDecrypt" return mess.decode('hex').decode('utf-8')

यहाँ भी, सब कुछ सरल और तार्किक है। हम उन कार्यों को सजाते हैं जिनकी हमें ज़रूरत होती है, और कुंजियों से जुड़ी हर चीज़ को स्टोर भी करते हैं (अधिक सटीक रूप से, हमारी निजी और सार्वजनिक कुंजियाँ, जिन शब्दकोशों को आप जानते हैं, उनके साथ एक शब्दकोश)।

चलो मुख्य करने के लिए नीचे उतरो

यह हिस्सा जल्दी से पर्याप्त लिखा गया था, और मुख्य मॉड्यूल को मूर्तिकला देने का निर्णय लिया गया था, आवेदन का वास्तविक कोर, जो भागों को जोड़ता था।

प्रारंभ में, टीके पर एक इंटरफ़ेस लिखने का निर्णय लिया गया था। लेकिन यह बुरी तरह से निकला, और मुझे याद आया कि अजगर क्यूटी के साथ अच्छी तरह से संवाद कर सकता है।
इसलिए, हम Pytt को Qt डिज़ाइनर सिस्टम में वितरित करते हैं, लिखने के समय संस्करण 4.7 था (दुर्भाग्य से मैं आपको यह नहीं बताऊंगा कि यह सब कैसे विन के तहत स्थापित किया जाए, लिनक्स में सब कुछ आपके वितरण के पैकेज सिस्टम द्वारा स्थापित है)
sudo apt-get install pyqt4-dev-टूल्स libqt4-core libqt4-dev libqt4-gu python-qt4 qt4-designer
पैकेजों का यह सेट पर्याप्त होना चाहिए।
तो चलिए एक फॉर्म ड्राइंग करके शुरू करते हैं।
क्यूटी डिजाइनर लॉन्च करें
प्रपत्र main_widget बनाएँ।
निम्नानुसार व्यवस्थित करें, केंद्रीय विजेट
- लंबवत परत।
हम इसमें 2 विजेट रखेंगे: एक क्षैतिज परत जिसमें संदेश भेजने के लिए एक जगह होगी और भेजने के लिए एक बटन, एक फाड़नेवाला जिसमें संदेश प्रदर्शित करने के लिए एक पाठ ब्राउज़र और एक विजेट शीट होगी जिसमें हम संपर्क सूची डालते हैं।
अंत में, इसे इस तरह से बदलना चाहिए।

हम QtDesigner के काम पर ध्यान केंद्रित नहीं करेंगे, यह अच्छी तरह से प्रलेखन में वर्णित है (Qt के पास बहुत अच्छे दस्तावेज हैं)
Ui फ़ाइल तैयार है।
हालांकि, यह फ़ाइल हमारे द्वारा उपयोग के लिए तैयार नहीं है, इसे पायथन कोड में बदलना आवश्यक है, इसके लिए हमें pyuic4 उपयोगिता की आवश्यकता है।
हम इसका उपयोग करेंगे।
pyuic4 main_window.ui -o gui.py
अब हमारे पास ग्राफिक्स वाली फ़ाइल है, एन्क्रिप्शन के साथ, जैबर के साथ, यह सब कुछ एक साथ संयोजित करने के लिए बनी हुई है।
इसे संयोजित करने के लिए, हम एक कक्षा लिखेंगे।

        def __init__(self):               #                  self.loadConfig()               #                  self.crypt = Crypt()               #                   self.jb = sjabber(self.xmpp_jid,self.xmpp_pwd)               self.jb.connect()               #                   self.jb.setCB(self.messageCB)              # Qt-                  self.app = QApplication(sys.argv)               self.window = QMainWindow()               self.ui = Ui_MainWindow()               self.ui.setupUi(self.window)

यहां हम अधिक विस्तार से बताते हैं, क्यूटी में सिग्नल और स्लॉट की एक प्रणाली है, इसके प्रसंस्करण के लिए QApplication वर्ग की आवश्यकता होती है, और चूंकि ग्राफिक्स उनका उपयोग करते हैं, इसलिए हम इसे जोड़ देंगे। उसके बाद हम विंडो और ग्राफिक तत्वों को स्वयं बनाएंगे (हमने उन्हें ऊपर बनाया है), जिसके बाद हम उन्हें अपनी विंडो में रखेंगे।

                #                       self.ui.pushButton.clicked.connect(self.sendMsg)               self.ui.lineEdit.returnPressed.connect(self.sendMsg)               self.window.show()               #                  userList = self.jb.userList()               for i in userList:                       self.ui.listWidget.addItem(i)               #                   self.ui.listWidget.currentRowChanged.connect(self.setToRow)               #                   self.ui.listWidget.setCurrentRow(0)               #    ""                 self.workThread = WorkThread()               self.workThread.setWorker(self.jb)               self.workThread.start()

जब्बार क्लाइंट के इस कार्यान्वयन के लिए आने वाले संदेशों को संसाधित करने के लिए निरंतर "चिकोटी" की आवश्यकता होती है, जो मुख्य धागे को भी अवरुद्ध करता है, इसलिए हम कार्यकर्ता का एक अलग वर्ग बनाएंगे जो अलग थ्रेड में रहेंगे और गैबर क्लाइंट की सेवा करेंगे। क्या विशेषता है, यह वर्ग धाराओं के साथ काम करने के लिए क्यूटी के लिए सी ++ कोड के समान है।

 class WorkThread(QThread):       def __init__(self):               QThread.__init__(self)       def setWorker(self,jb):               self.jb = jb       def run(self):               while self.jb.StepOn(): pass

वास्तव में, यह वह जगह है जहां हमारा आवेदन लगभग तैयार है, कॉलबैक के अपवाद के साथ जो आने वाले संदेशों (अच्छी तरह से, थोड़ी अलग छोटी चीजों) को संसाधित करता है।

डीईएफ़ संदेश संदेश (सेल्फ, कोन, मेस)

        def messageCB(self,conn,mess):               #    ,                 #   ,                  if ( mess.getBody() == None ):                       return               msg = mess.getBody()               patern = re.compile('^#(getkey|sendkey|mesg|getlastmesg) ?(.*)')               res = patern.search(msg)               if res:                       #                       a = res.groups()[0]                       if a == "getkey":                               self.sendKey(mess.getFrom())                               if  self.crypt.hasKey(mess.getFrom())!=False:                                       conn.send(mess.getFrom(),"#getkey")                           elif a == "sendkey":                               if res.groups()[1]!='':                                       a = self.crypt.decodeKey(res.groups()[1].decode("hex"))                                       self.crypt.saveKey(mess.getFrom().getStripped(),a)                       elif a == "mesg":                               decryptMess = self.crypt.decryptMesg(res.groups()[1])                               if decryptMess=="#errorDecrypt":                                       self.sendKey(mess.getFrom())                                       self.print_("Error decrypt sendKey")                               else:                                       self.print_(self.to+"--> "+decryptMess)                       elif a == "getlastmesg*":                               print a

एक हैंडलर के रूप में, मैं कुछ भी नया नहीं आया था, इसलिए संदेश को एक नियमित अभिव्यक्ति के साथ जांचा जाता है, इसके साथ संयोग की स्थिति में, संदेश के प्रकार के अनुरूप प्रतिक्रिया के लिए एक संक्रमण किया जाता है।

एक और डरावना संदेश भेज रहा है। तथ्य यह है कि मानक आरएसए एल्गोरिथ्म कुंजी के आकार के आधार पर एक निश्चित लंबाई के तारों को एन्क्रिप्ट कर सकता है, जो कि 1024 बाइट्स के लिए यूनिकोड में लगभग 52 वर्ण हैं, इसलिए प्रक्रिया स्ट्रिंग को टुकड़ों में विभाजित करती है, जिसे यह एन्क्रिप्ट करता है और भेजता है। मेरी राय में, यह एक भयानक बैसाखी है, लेकिन अजगर के बारे में मेरे ज्ञान ने मुझे इसे और अधिक सुंदर बनाने की अनुमति नहीं दी।

आप जीथब पर सभी कोड देख सकते हैं ।

वास्तव में परिणाम

संहिता की रचनात्मक आलोचना का स्वागत है।

फिर भी एक और अजगर चैट क्लाइंट

चलिए शुरू करते हैं

आइए सरल भाग से शुरू करें, जिसका नाम है जेबबीर भाग।

हम एन्क्रिप्शन को फास्ट करते हैं।

चलो मुख्य करने के लिए नीचे उतरो

More articles: