भाषा जाओ। छोटे ग्राहक-सर्वर अनुप्रयोग

यह कोड स्व-अध्ययन के लिए लिखा गया है। सामग्री को मजबूत करने के लिए, मैंने किए गए काम पर थोड़ी टिप्पणी करने का फैसला किया।
मुझे तुरंत कहना चाहिए: मैंने संकलित भाषाओं में नहीं लिखा।

आवेदन क्या करता है

[k] - क्लाइंट
[ग] - सर्वर
1. स्थापित टीसीपी कनेक्शन पर, [k] सार्वजनिक कुंजी rsa स्थानांतरित करता है।
2. स्वीकार की गई सार्वजनिक कुंजी का उपयोग करना, [c] प्रयास करता है और संदेश भेजता है [को]
3. [के] डिक्रिप्ट और संदेश प्रदर्शित करता है।

यहाँ यह सांत्वना में कैसा दिखता है:

सर्वर

package main 

हम आवश्यक पैकेज आयात करते हैं

 import( //   / .      "fmt" //      Unix networks sockets, including TCP/IP, UDP . //      TCP . "net" //        "os" //   / "bufio" //           "crypto/rsa" //       "crypto/rand" //     sha1 "crypto/sha1" //           "strconv" //      "big" ) 

पैकेज तक आगे पहुंच डॉट के माध्यम से इसके नाम से होगी।
उदाहरण के लिए: fmt । Println() , os । Exit() आदि
यदि आप सुनिश्चित नहीं हैं कि आपको किस पैकेज के नाम की आवश्यकता है, तो आप कोड के शीर्ष रेखा पर पैकेज स्रोतों को देख सकते हैं।
उदाहरण के लिए, क्रिप्टो / rsa के लिए छठी पंक्ति rsa.go
गोइस्ट कमांड के साथ , आप अन्य डेवलपर्स से पैकेज स्थापित कर सकते हैं।
इस स्थिति में, आप कुछ इस तरह से आयात करेंगे "bitbucket.org/user/project", "github.com/user/project" या "project.googlecode.com/hg"

हमें जिन स्थिरांक की आवश्यकता है, उनकी घोषणा करें

 const( //  tcp  tcpProtocol = "tcp4" //   rsa  keySize = 1024 //       readWriterSize = keySize/8 ) 

कनेक्शन "c" और इस कनेक्शन की कुंजी "pubK" को एक साथ रखने के लिए, रिमोट कंट्रोल डेटा प्रकार को एक प्रकार से घोषित करें:

 type remoteConn struct { c *net.TCPConn pubK *rsa.PublicKey } 

चर के प्रकार से पहले तारांकन "*" का अर्थ है कि चर घोषित प्रकार के डेटा का एक संदर्भ है
net.TCPConn एक डेटा प्रकार है जिसमें TCP कनेक्शन जानकारी की संरचना होती है।
rsa.PublicKey - डेटा प्रकार। यह प्रेषित संदेशों के एन्क्रिप्शन के लिए आवश्यक है।

खुद को परिचित करने के लिए, हम इस तरह से दिखाई देने वाली त्रुटियों को संसाधित करेंगे:
फ़ंक्शन एक एकल गलत मान लेता है जिसका प्रकार os.Error है ।
इस स्थिति में, हम ओएस पैकेज ( os.Error ) से त्रुटि प्रकार के साथ काम कर रहे हैं।

 func checkErr(err os.Error){ if err != nil { //    fmt.Println(err) //   os.Exit(1) } } 

वैश्विक वैरिएबल listenAddr घोषित करें जो कि listenAddr संरचना का संदर्भ होगा। एसीडीडीआर

 var listenAddr = &net.TCPAddr{IP: net.IPv4(192,168,0,4), Port: 0} 

Ampersand "&" net से पहले। CPAddr इस प्रकार का एक संदर्भ लौटाएगा।
इस मामले में "पोर्ट: 0" का मतलब है - कोई भी मुफ्त पोर्ट।

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

 func getRemoteConn(c *net.TCPConn) *remoteConn{ return &remoteConn{c: c, pubK: waitPubKey(bufio.NewReader())} } 

bufio.NewReader() - कनेक्शन "c" से बाइट बफर बनाता है। वापसी का प्रकार *bufio.Reader ( *bufio.Reader लिंक)
waitPubKey() - "क्लाइंट" से उम्मीद करता है कि जब एक निश्चित अनुक्रम में PublicKey संचारित होगा

फ़ंक्शन बफ़र ( *bufio.Reader ) के संदर्भ को स्वीकार करता है जिसमें बदले में सभी बाइट्स होते हैं जो कनेक्शन "c" से आते हैं।

 //      rsa.PublicKey func waitPubKey(buf *bufio.Reader) (*rsa.PublicKey) { //     line, _, err := buf.ReadLine(); checkErr(err) //    line - []byte ( ) //      <code><b>line</b></code>   if string(line) == "CONNECT" { //         ,       line, _, err := buf.ReadLine(); checkErr(err) //  PublicKey.N //   rsa.PublicKey pubKey := rsa.PublicKey{N: big.NewInt(0)} // pubKey.N == 0 //  pubKey.N big.Int http://golang.org/pkg/big/#Int //       pubKey.N big.Int pubKey.N.SetString(string(line), 10) //  SetString()  2 : // string(line) -      // 10 -       // (2 , 8 , 10 , 16  ...) //       pubKey.E line, _, err = buf.ReadLine(); checkErr(err) //   strconv    string   int pubKey.E, err = strconv.Atoi(string(line)); checkErr(err) //    rsa.PublicKey return &pubKey } else { //        .  : //    fmt.Println("Error: unkown command ", string(line)) os.Exit(1) //   } return nil } 

निम्न फ़ंक्शन एक तरीका है जो remoteConn एक चर को संदर्भित करने के लिए है
एन्क्रिप्ट करने और संदेश भेजने के लिए कई क्रियाएं करता है।

 func (rConn *remoteConn) sendCommand(comm string) { //   eComm, err := rsa.EncryptOAEP(sha1.New(), rand.Reader, rConn.pubK, []byte(comm), nil) // sha1.New()    hash.Hash //       sha512.New() sha256.New() ... // rand.Reader   io.Reader       //    /dev/unrandom   Linux  CryptGenRandom API   Windows // rConn.pubK -       func waitPubKey // []byte(comm) -   comm    ([]byte) checkErr(err) //    //        rConn.c.Write(eComm) // rConn.c  ? - net.TCPConn     Write() // http://golang.org/pkg/net/#TCPConn.Write } 

नीचे एक फ़ंक्शन है जो पहले घोषित कार्यों पर काम करता है और अंततः विभिन्न भाषाओं में "क्लाइंट" सर्वर नाम और शुभकामनाएं भेजता है।

 func listen() { //     l, err := net.ListenTCP(tcpProtocol, listenAddr); checkErr(err) //    fmt.Println("Listen port: ", l.Addr().(*net.TCPAddr).Port) // l == *net.TCPListener ==     // .Addr() http://golang.org/pkg/net/#TCPListener.Addr ==   *net.TCPListener   "" // net.Addr http://golang.org/pkg/net/#Addr        TCPAddr - *net.TCPAddr //    Network()  String() c, err := l.AcceptTCP(); checkErr(err) //             // AcceptTCP() -   *net.TCPListener http://golang.org/pkg/net/#TCPListener.AcceptTCP //     fmt.Println("Connect from:", c.RemoteAddr()) //  3     fmt.Print[f|ln]()    // 1. c.RemoteAddr() // 2. c.RemoteAddr().(*net.TCPAddr) // 3. c.RemoteAddr().String() //     : fmt.Println(), fmt.Print(), fmt.Printf()    String() //       //             rConn := getRemoteConn() //     rConn.sendCommand("Go Language Server v0.1 for learning") rConn.sendCommand("!") rConn.sendCommand("і!") rConn.sendCommand("і!") rConn.sendCommand("Hello!") rConn.sendCommand("Salut!") rConn.sendCommand("ハイ!") rConn.sendCommand("您好!") rConn.sendCommand("안녕!") rConn.sendCommand("Hej!") } 

यह सर्वर समीक्षा को पूरा करता है।

 func main() { listen() } 

ग्राहक

 package main import( "fmt" "net" "os" "bufio" "crypto/rsa" "crypto/rand" "crypto/sha1" "strconv" ) const( tcpProtocol = "tcp4" keySize = 1024 readWriterSize = keySize/8 ) func checkErr(err os.Error){ if err != nil { fmt.Println(err) os.Exit(1) } } var connectAddr = &net.TCPAddr{IP: net.IPv4(192,168,0,2), Port: 0} //             func connectTo() *net.TCPConn{ //   "Enter port:"      fmt.Print("Enter port:") //        "%d" fmt.Scanf("%d", &connectAddr.Port) // Scanf           fmt.Println("Connect to", connectAddr) //     c ,err := net.DialTCP(tcpProtocol, nil, connectAddr); checkErr(err) return c } //      PublicKey func sendKey(c *net.TCPConn, k *rsa.PrivateKey) { //       PublicKey c.Write([]byte("CONNECT\n")) //  N  *big.Int c.Write([]byte(k.PublicKey.N.String() + "\n")) // String()  *big.Int  string //  E  int c.Write([]byte(strconv.Itoa(k.PublicKey.E) + "\n")) // strconv.Itoa()  int  string // []byte()  ""    } //       //    func getBytes(buf *bufio.Reader, n int) []byte { //  n  bytes, err:= buf.Peek(n); checkErr(err) //  n  skipBytes(buf, n) return bytes } // ,     func skipBytes(buf *bufio.Reader, skipCount int){ for i:=0; i<skipCount; i++ { buf.ReadByte() } } func main() { //    c := connectTo() //       "c" buf := bufio.NewReader() //           k, err := rsa.GenerateKey(rand.Reader, keySize); checkErr(err) //     sendKey(c, k) //        for { //      cryptMsg := getBytes(buf, readWriterSize) //   msg, err := rsa.DecryptOAEP(sha1.New(), rand.Reader, k, cryptMsg, nil) //    checkErr(err) //    fmt.Println(string(msg)) } } 

एक भी टिप्पणी के बिना स्रोत यहाँ पाया जा सकता है:
code.google.com/p/learning-go-language/source/browse