हम पॉवरशेल पर रिवर्स सॉक्स 5 प्रॉक्सी लिखते हैं। पार्ट 2

3 भागों में अनुसंधान और विकास की कहानी। भाग 2 - विकासात्मक।
कई मधुमक्खी हैं - और भी अधिक लाभ।

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

सबसे पहले, हमें यह समझने की आवश्यकता है कि हमारा मॉड्यूल किस मोड में काम करेगा। जाहिर है, प्राइमा डेटा ट्रांसफर के लिए हमें विंडोज़ सॉकेट मैकेनिज्म और .net क्षमताओं को पढ़ने-लिखने से लेकर सॉकेट तक के लिए इस्तेमाल करना होगा। लेकिन, दूसरी ओर, क्योंकि चूंकि हमारे मॉड्यूल को एक ही समय में कई yamux स्ट्रीम परोसना चाहिए, इसलिए सभी I / O संचालन को हमारे प्रोग्राम के निष्पादन को पूरी तरह से ब्लॉक नहीं करना चाहिए। इससे यह निष्कर्ष निकलता है कि हमारे मॉड्यूल को सॉफ्टवेयर को मल्टीथ्रेडिंग का उपयोग करना चाहिए और एक यमक्स सर्वर के साथ रीड-राइट ऑपरेशन करना चाहिए, साथ ही विभिन्न प्रोग्राम स्ट्रीम में डेस्टिनेशन सर्वर पर रीड-राइट ऑपरेशन करना चाहिए। खैर, निश्चित रूप से, हमारे समानांतर प्रवाह के बीच बातचीत का एक तंत्र प्रदान करना आवश्यक है। सौभाग्य से, पॉवरशेल, प्रोग्राम फ्लो को लॉन्च करने और प्रबंधित करने के पर्याप्त अवसर प्रदान करता है।

काम का सामान्य एल्गोरिथ्म

इस प्रकार, हमारे ग्राहक का सामान्य एल्गोरिदम कुछ इस तरह होना चाहिए:

• सर्वर से एक एसएसएल कनेक्शन स्थापित करें;
• एक पासवर्ड के साथ लॉग इन करें ताकि सर्वर हमें एक सुरक्षा अधिकारी से अलग कर सके;
• नई स्ट्रीम को स्थापित करने के लिए यमक्स पैकेज की प्रतीक्षा करें, समय-समय पर सर्वर के रख-रखाव अनुरोधों का जवाब देना;
• जैसे ही एक नया स्ट्रीम स्थापित करने के लिए yamux पैकेज आता है, वैसे ही एक नया मोजेस्क्रिप्ट प्रोग्राम स्ट्रीम (स्ट्रीम से भ्रमित न होना) शुरू करें। मोजे के अंदर, मोजे 5 सर्वर के काम को लागू करें;
• यामक्स से डेटा के साथ एक पैकेट के आगमन पर - एक 12-बाइट हेडर से समझें कि डेटा किन धाराओं के लिए अभिप्रेत है, साथ ही साथ उनके आकार, यामक्स सर्वर से डेटा पढ़ें और प्राप्त डेटा को इसी स्ट्रीम नंबर के साथ स्ट्रीम में स्थानांतरित करें;
• समय-समय पर चल रहे मोज़े स्क्रिप्ट में से प्रत्येक में यमक्स सर्वर के लिए इच्छित डेटा की उपलब्धता की निगरानी करें। यदि ऐसा कोई डेटा है, तो उनके लिए संबंधित 12-बाइट हेडर जोड़ें और इसे yamux सर्वर पर भेजें;
• स्ट्रीम को बंद करने के लिए एक yamux पैकेज के आगमन पर, स्ट्रीम को समाप्त करने और डिस्कनेक्ट करने के लिए संबंधित स्ट्रीम में एक सिग्नल संचारित करें, और उसके बाद, स्ट्रीम को स्वयं पूरा करें;

तो, हमारे क्लाइंट में कम से कम 3 प्रोग्राम फ्लो को लागू करना आवश्यक है:

1. मुख्य एक, जो कनेक्शन स्थापित करेगा, yamux सर्वर में लॉग इन करेगा, इससे डेटा प्राप्त करेगा, yamux हेडर प्रोसेस करेगा और अन्य प्रोग्राम स्ट्रीम में कच्चा डेटा भेजेगा;
2. मोजे सर्वर के साथ स्ट्रीम। प्रत्येक स्ट्रीम के लिए कई - एक हो सकते हैं। वे मोजे 5 कार्यक्षमता को लागू करते हैं। ये प्रवाह आंतरिक नेटवर्क पर गंतव्य बिंदुओं के साथ बातचीत करेंगे;
3. रिवर्स प्रवाह। यह मोज़े धाराओं से डेटा प्राप्त करता है, उन्हें yamux हेडर जोड़ता है और इसे yamux सर्वर को भेजता है;

और, ज़ाहिर है, हमें इन सभी प्रवाह के बीच बातचीत के लिए प्रदान करने की आवश्यकता है।

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

मोज़े धाराओं को चलाने के बारे में जानकारी संगत डेटा संरचना में संग्रहीत की जानी चाहिए। इस संरचना में एक मोजे धागा बनाते समय, हमें लिखना होगा:

• yamux सत्र संख्या: $ ymxstream;
• पाइप (चैनल) के साथ काम करने के लिए 4 चर: $ सिपिप, $ कॉपिप, $ सिपिप, $ सोपिप। चूंकि अनाम चैनल या तो IN या OUT में काम करते हैं, प्रत्येक मोजे स्ट्रीम के लिए हमें दो अनाम चैनलों की आवश्यकता होती है, जिनमें से प्रत्येक में दो छोर (पिपेस्ट्रीम) (सर्वर और क्लाइंट) होना चाहिए;
• स्ट्रीम पर कॉल करने का परिणाम $ AsyncJobResult है;
• स्ट्रीम हैंडलर - $ Psobj। इसके माध्यम से हम स्ट्रीम को बंद कर देंगे और संसाधन जारी करेंगे;
• रिवर्स स्ट्रीम ($ readjob) द्वारा अनाम पाइप से अतुल्यकालिक पढ़ने का परिणाम। इस चर का उपयोग रिवर्स यमूक्सस्क्रिप्ट स्ट्रीम में संबंधित पाइप से अतुल्यकालिक पढ़ने के लिए किया जाता है;
• प्रत्येक मोजे स्ट्रीम के लिए डेटा पढ़ने के लिए बफर;

मुख्य धारा

इसलिए, डाटा प्रोसेसिंग के दृष्टिकोण से, हमारे कार्यक्रम का कार्य निम्नानुसार बनाया गया है:

• सर्वर साइड (रोसकस्टुन - गोलंग पर लागू) एसएलएल सर्वर उठाता है और क्लाइंट से कनेक्शन की प्रतीक्षा करता है;
• क्लाइंट से एक कनेक्शन प्राप्त करने पर, सर्वर पासवर्ड की जांच करता है, और यदि यह सही है, तो एक yamux कनेक्शन स्थापित करता है, मोज़े पोर्ट को उठाता है और मोज़े क्लाइंट (हमारे प्रॉक्साइकिन्स, ब्राउज़र इत्यादि) से कनेक्शन के लिए प्रतीक्षा करता है, समय-समय पर रखने वाले पैकेट की जाँच करता है। हमारे ग्राहक के साथ। यदि पासवर्ड गलत है - सर्वर को स्थापित करते समय हमारे द्वारा निर्दिष्ट पृष्ठ पर पुनर्निर्देशित किया जाता है (यह सूचना सुरक्षा के सतर्क प्रशासक के लिए "कानूनी" पृष्ठ है);
• मोज़े क्लाइंट से कनेक्शन प्राप्त होने पर, सर्वर हमारे क्लाइंट को एक नई स्ट्रीम (YMX SYN) स्थापित करने के लिए एक यमक्स पैकेट भेजता है;

यमक्स हेडर प्राप्त करना और उसका विश्लेषण करना

हमारा मॉड्यूल पहले सर्वर से एक SSL कनेक्शन स्थापित करता है और एक पासवर्ड के साथ लॉग इन करता है:

$tcpConnection = New-Object System.Net.Sockets.TcpClient($server, $port) $tcpStream = New-Object System.Net.Security.SslStream($tcpConnection.GetStream(),$false,({$True} -as [Net.Security.RemoteCertificateValidationCallback])) $tcpStream.AuthenticateAsClient('127.0.0.1') 

फिर, स्क्रिप्ट 12-बाइट यमक्स हेडर की प्रतीक्षा करती है और इसे पार्स करती है।
एक छोटी सी बारीकियाँ है ... जैसा कि अभ्यास से पता चलता है, बस सॉकेट से 12 बाइट्स पढ़ना:

  $num = $tcpStream.Read($tmpbuffer,0,12) 

पर्याप्त नहीं है, क्योंकि आवश्यक बाइट्स के केवल भाग के आगमन के बाद रीड ऑपरेशन पूरा किया जा सकता है। इसलिए, हमें लूप में सभी 12 बाइट्स का इंतजार करना होगा:

  do { try { $num = $tcpStream.Read($tmpbuffer,0,12) } catch {} $tnum += $num $ymxbuffer += $tmpbuffer[0..($num-1)] }while ($tnum -lt 12 -and $tcpConnection.Connected) 

लूप पूरा होने के बाद, हमें यमक्स के विनिर्देश के अनुसार $ ymxbuffer वैरिएबल में इसके प्रकार और सेट फ्लैग के लिए निहित 12-बाइट हेडर का विश्लेषण करना चाहिए।

यमक्स हेडर कई प्रकार के हो सकते हैं:

• ymx syn - एक नई स्ट्रीम स्थापित करें;
• ymx fin - धारा पूर्णता;
• ymx डेटा - डेटा के बारे में जानकारी का प्रतिनिधित्व करता है (वे किस आकार और किस स्ट्रीम के लिए लक्षित हैं);
• ymx पिंग - रखने का संदेश;
• ymx जीत अद्यतन - डेटा के एक हिस्से के हस्तांतरण की पुष्टि;

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

एक नया मोजे धागा बनाना

एक नई स्ट्रीम को स्थापित करने के लिए एक yamux पैकेज प्राप्त करने के बाद, हमारा क्लाइंट क्रमशः दो अज्ञात सर्वर पाइप ($ sipipe, $ sopipe) बनाता है, उनके आधार पर क्रमशः ग्राहक पाइप ($ cipipe, $ copipe) बनाता है:

 $sipipe = new-object System.IO.Pipes.AnonymousPipeServerStream(1) $sopipe = new-object System.IO.Pipes.AnonymousPipeServerStream(2,1) $sipipe_clHandle = $sipipe.GetClientHandleAsString() $sopipe_clHandle = $sopipe.GetClientHandleAsString() $cipipe = new-object System.IO.Pipes.AnonymousPipeClientStream(1,$sopipe_clHandle) $copipe = new-object System.IO.Pipes.AnonymousPipeClientStream(2,$sipipe_clHandle) 

मोजे स्ट्रीम के लिए एक रनस्पेस बनाता है, इस स्ट्रीम (StopFlag) के साथ बातचीत के लिए साझा चर सेट करता है, और स्क्रिप्टब्लॉक SocksScript चलाता है, जो एक अलग स्ट्रीम में मोज़े सर्वर की कार्यक्षमता को लागू करता है:

 $state = [PSCustomObject]@{"StreamID"=$ymxstream;"inputStream"=$cipipe;"outputStream"=$copipe} $PS = [PowerShell]::Create() $socksrunspace = [runspacefactory]::CreateRunspace() $socksrunspace.Open() $socksrunspace.SessionStateProxy.SetVariable("StopFlag",$StopFlag) $PS.Runspace = $socksrunspace $PS.AddScript($socksScript).AddArgument($state) | Out-Null [System.IAsyncResult]$AsyncJobResult = $null $StopFlag[$ymxstream] = 0 $AsyncJobResult = $PS.BeginInvoke() 

बनाए गए चर एक विशेष ArrayList संरचना के लिए लिखे गए हैं - पायथन में शब्दकोश का एक एनालॉग

 [System.Collections.ArrayList]$streams = @{} 

जोड़ना बिल्ट-इन ऐड विधि से होता है:

 $streams.add(@{ymxId=$ymxstream;cinputStream=$cipipe;sinputStream=$sipipe;coutputStream=$copipe;soutputStream=$sopipe;asyncobj=$AsyncJobResult;psobj=$PS;readjob=$null;readbuffer=$readbuffer}) | out-null 

यमक्स डाटा प्रोसेसिंग

यमक्स सर्वर से किसी भी मोज़े स्ट्रीम के लिए नियत डेटा प्राप्त होने पर, हमें यमूक्स स्ट्रीम की संख्या निर्धारित करनी चाहिए (इस डेटा के लिए मोज़े स्ट्रीम की संख्या) और 12-बाइट यॉट हेडर से डेटा बाइट्स की संख्या:

 $ymxstream = [bitconverter]::ToInt32($buffer[7..4],0) $ymxcount = [bitconverter]::ToInt32($buffer[11..8],0) 

फिर, ArrayList स्ट्रीम से, ymxId फ़ील्ड का उपयोग करके, हम इस मोजे स्ट्रीम के अनुरूप सर्वर आउट-पाइप के हैंडलर प्राप्त करते हैं:

  if ($streams.Count -gt 1){$streamind = $streams.ymxId.IndexOf($ymxstream)} else {$streamind = 0} $outStream = $streams[$streamind].soutputStream 

उसके बाद, हम सॉकेट से डेटा पढ़ते हैं, यह याद रखते हुए कि हमें लूप के माध्यम से एक निश्चित संख्या में बाइट्स पढ़ने की जरूरत है:

  $databuffer = $null $tnum = 0 do { if ($buffer.length -le ($ymxcount-$tnum)) { $num = $tcpStream.Read($buffer,0,$buffer.Length) }else { $num = $tcpStream.Read($buffer,0,($ymxcount-$tnum)) } $tnum += $num $databuffer += $buffer[0..($num-1)] }while ($tnum -lt $ymxcount -and $tcpConnection.Connected) 

और संबंधित डेटा को संबंधित पाइप पर लिखें:

 $num = $tcpStream.Read($buffer,0,$ymxcount) $outStream.Write($buffer,0,$ymxcount) 

यमक्स फिन प्रोसेसिंग - एंड स्ट्रीम

जब हम एक yamix सर्वर से एक पैकेट प्राप्त करते हैं जो एक स्ट्रीम को बंद करने का संकेत देता है, तो हम सबसे पहले 12-बाइट हेडर से yamux स्ट्रीम की संख्या प्राप्त करते हैं:

  $ymxstream = [bitconverter]::ToInt32($buffer[7..4],0) 

फिर, एक साझा चर (या बल्कि, झंडे की एक सरणी के माध्यम से, जहां सूचकांक यमक्स स्ट्रीम नंबर है), हम मोजे के धागे को पूरा करने के लिए संकेत देते हैं:

 if ($streams.Count -gt 1){$streamind = $streams.ymxId.IndexOf($ymxstream)} else {$streamind = 0} if ($StopFlag[$ymxstream] -eq 0){ write-host "stopflag is 0. Setting to 1" $StopFlag[$ymxstream] = 1 } 

ध्वज को स्थापित करने के बाद, मोजे की धारा को मारने से पहले, आपको इस ध्वज को संसाधित करने के लिए मोजे की धारा के लिए एक निश्चित समय तक प्रतीक्षा करने की आवश्यकता है। 200 एमएस इसके लिए पर्याप्त है:

 start-sleep -milliseconds 200 #wait for thread check flag 

फिर इस स्ट्रीम से संबंधित सभी पाइपों को बंद करें, संबंधित रनस्पेस को बंद करें और पॉवर्सशेल ऑब्जेक्ट को फ्री रिसोर्स पर मारें:

 $streams[$streamind].cinputStream.close() $streams[$streamind].coutputStream.close() $streams[$streamind].sinputStream.close() $streams[$streamind].soutputStream.close() $streams[$streamind].psobj.Runspace.close() $streams[$streamind].psobj.Dispose() $streams[$streamind].readbuffer.clear() 

मोज़े की धारा को बंद करने के बाद, हमें ArrayList धाराओं से संबंधित तत्व को निकालने की आवश्यकता है:

 $streams.RemoveAt($streamind) 

और अंत में, हमें .Net कचरा कलेक्टर को थ्रेड द्वारा उपयोग किए गए संसाधनों को जारी करने के लिए मजबूर करने की आवश्यकता है। अन्यथा, हमारी स्क्रिप्ट लगभग 100-200 एमबी मेमोरी का उपभोग करेगी, जो एक अनुभवी और संक्षारक उपयोगकर्ता की आंख को पकड़ सकती है, लेकिन हमें इसकी आवश्यकता नहीं है:

 [System.GC]::Collect()#clear garbage to minimize memory usage 

यमक्स लिपि - उल्टा प्रवाह

जैसा कि ऊपर उल्लेख किया गया है, मोज़े धाराओं से प्राप्त डेटा एक अलग यमक्सस्क्रिप्ट स्ट्रीम द्वारा संसाधित किया जाता है, जो बहुत शुरुआत (सर्वर के सफल कनेक्शन के बाद) से शुरू होता है। इसका कार्य समय-समय पर ArrayList $ धाराओं में स्थित मोजे धाराओं के आउटपुट पाइप को प्रदूषित करना है:

 foreach ($stream in $state.streams){ ... } 

और यदि उनमें डेटा है, तो उन्हें यमक्स सर्वर पर भेजें, पहले से 12-बाइट यमक्स हेडर प्रदान करें जिसमें यमक्स सत्र की संख्या और डेटा बाइट्स की संख्या हो:

  if ($stream.readjob -eq $null){ $stream.readjob = $stream.sinputStream.ReadAsync($stream.readbuffer,0,1024) }elseif ( $stream.readjob.IsCompleted ){ #if read asyncjob completed - generate yamux header $outbuf = [byte[]](0x00,0x00,0x00,0x00)+ [bitconverter]::getbytes([int32]$stream.ymxId)[3..0]+ [bitconverter]::getbytes([int32]$stream.readjob.Result)[3..0] $state.tcpstream.Write($outbuf,0,12) #write raw data from socks thread to yamux $state.tcpstream.Write($stream.readbuffer,0,$stream.readjob.Result) $state.tcpstream.flush() #create new readasync job $stream.readjob = $stream.sinputStream.ReadAsync($stream.readbuffer,0,1024) }else{ #write-host "Not readed" } 

यमक्सस्क्रिप्ट भी निष्पादित किए जाने वाले प्रत्येक मोज़ेक धागे के लिए साझा किए गए $ StopFlag सरणी में ध्वज सेट की निगरानी करता है। इस ध्वज को 2 पर सेट किया जा सकता है यदि दूरस्थ सर्वर जो मोजेस्क्रिप्ट डिस्कनेक्ट के साथ काम कर रहा है। इस स्थिति में, मोज़े क्लाइंट को सूचना देने की आवश्यकता है। श्रृंखला निम्नानुसार है: yamuxScript को yamux सर्वर को वियोग के बारे में सूचित करना चाहिए ताकि यह बदले में मोज़े क्लाइंट को संकेत दे।

 if ($StopFlag[$stream.ymxId] -eq 2){ $stream.ymxId | out-file -Append c:\work\log.txt $outbuf = [byte[]](0x00,0x01,0x00,0x04)+ [bitconverter]::getbytes([int32]$stream.ymxId)[3..0]+ [byte[]](0x00,0x00,0x00,0x00) $state.tcpstream.Write($outbuf,0,12) $state.tcpstream.flush() } 

यमक्स विंडो अपडेट

इसके अलावा, yamuxScript को yamux सर्वर से प्राप्त बाइट्स की संख्या की निगरानी करनी चाहिए और समय-समय पर YMX WinUpdate Message भेजना चाहिए। यमक्स में यह तंत्र तथाकथित विंडो आकार (टीसीपी प्रोटोकॉल के समान) की निगरानी और बदलने के लिए जिम्मेदार है - डेटा बाइट्स की संख्या जिन्हें पावती के बिना भेजा जा सकता है। डिफ़ॉल्ट रूप से, विंडो का आकार 256 Kbytes है। इसका अर्थ है कि इस आकार से बड़ी फ़ाइलों या डेटा को भेजते या प्राप्त करते समय, हमें विंडपू अपडेट पैकेज को यमक्स सर्वर पर भेजने की आवश्यकता होती है। यमक्स सर्वर से प्राप्त डेटा की मात्रा को नियंत्रित करने के लिए, एक विशेष साझा सरणी $ RcvBytes पेश किया गया है, जिसमें वर्तमान मूल्य में वृद्धि से मुख्य धारा प्रत्येक स्ट्रीम के लिए सर्वर से प्राप्त बाइट्स की संख्या रिकॉर्ड करती है। यदि सेट सीमा पार हो गई है, तो yamuxScript को WinUpdate सर्वर पर एक पैकेट भेजना चाहिए और काउंटर रीसेट करना चाहिए:

  if ($RcvBytes[$stream.ymxId] -ge 256144){ #out win update ymx packet with 256K size $outbuf = [byte[]](0x00,0x01,0x00,0x00)+ [bitconverter]::getbytes([int32]$stream.ymxId)[3..0]+ (0x00,0x04,0x00,0x00) $state.tcpstream.Write($outbuf,0,12) $RcvBytes[$stream.ymxId] = 0 } 

SocksScript स्ट्रीम

चलिए अब सीधे अपने आप ही मोज़ेस्क्रिप्ट पर जाएँ।
याद दिलाना है कि मोजे को असंगत रूप से लगाया जाता है:

 $state = [PSCustomObject]@{"StreamID"=$ymxstream;"inputStream"=$cipipe;"outputStream"=$copipe} $PS = [PowerShell]::Create() .... $AsyncJobResult = $PS.BeginInvoke() 

और कॉल के समय, निम्न डेटा स्ट्रीम में स्थानांतरित $ स्थिति चर में मौजूद है:

• $ State.streamId - yamux सत्र संख्या;
• $ State.inputStream - पाइप पढ़ें;
• $ state.oututStream - पाइप लिखें;

पाइप में डेटा यमक्स हेडर के बिना कच्चे रूप में आता है, अर्थात। जिस रूप में वे मोज़े क्लाइंट से आए थे।

मोजे के अंदर, सबसे पहले, हमें मोजे के संस्करण को निर्धारित करने की आवश्यकता है और सुनिश्चित करें कि यह 5 है:

 $state.inputStream.Read($buffer,0,2) | Out-Null $socksVer=$buffer[0] if ($socksVer -eq 5){ ... } 

ठीक है, तो हम बिल्कुल वैसा ही करते हैं जैसा कि Invoke-SocksProxy स्क्रिप्ट में लागू किया गया। फर्क सिर्फ इतना होगा कि कॉल के बजाय

 $AsyncJobResult.AsyncWaitHandle.WaitOne(); $AsyncJobResult2.AsyncWaitHandle.WaitOne(); 

चक्रीय मोड में $ StopFlag सरणी में tcp कनेक्शन और संबंधित समाप्ति ध्वज की निगरानी करना आवश्यक है, अन्यथा हम मोज़े क्लाइंट और yuxux सर्वर की ओर से कनेक्शन के अंत की स्थिति को पहचान नहीं पाएंगे:

 while ($StopFlag[$state.StreamID] -eq 0 -and $tmpServ.Connected ){ start-sleep -Milliseconds 50 } 

यदि हम जिस सर्वर से जुड़ रहे हैं, उसके tcp पर कनेक्शन समाप्त हो जाता है, तो हम इस ध्वज को 2 पर सेट करते हैं, जो yamuxscript को यह पहचानने के लिए बाध्य करेगा और संबंधित ymx फिन पैकेट को yamux सर्वर पर भेजेगा:

 if ($tmpServ.Connected){ $tmpServ.close() }else{ $StopFlag[$state.StreamID] = 2 } 

यदि फ़ुटबॉल सर्वर गंतव्य सर्वर से कनेक्ट नहीं हो सकता है तो हमें भी इस ध्वज को सेट करना होगा:

 if($tmpServ.Connected){ ... } else{ $buffer[1]=4 $state.outputStream.Write($buffer,0,2) $StopFlag[$state.StreamID] = 2 } 

दूसरे भाग का निष्कर्ष

हमारे कोडिंग अनुसंधान के दौरान, हम क्षमता के साथ हमारे RsocksTun सर्वर के लिए एक पॉवरशेल क्लाइंट बनाने में सक्षम थे:

• एसएसएल कनेक्शन
• सर्वर पर प्राधिकरण;
• यमक्स-सर्वर के साथ काम के साथ रखने के लिए पिंगल पिंग्स;
• ऑपरेशन के बहु-थ्रेडेड मोड;
• बड़ी फ़ाइलों को स्थानांतरित करने के लिए समर्थन;

लेख के बाहर, एक प्रॉक्सी सर्वर के माध्यम से कनेक्ट करने और उस पर अधिकृत करने के साथ-साथ हमारी स्क्रिप्ट को इनलाइन संस्करण में बदलने की कार्यक्षमता का कार्यान्वयन था, जिसे कमांड लाइन से चलाया जा सकता है। यह तीसरे भाग में होगा।

आज के लिए बस इतना ही। जैसा कि वे कहते हैं - सदस्यता लें, जैसे, टिप्पणी छोड़ें (विशेषकर कोड में सुधार और कार्यक्षमता जोड़ने पर आपके विचारों के बारे में)।