1. HIGHWAY ist ein Forum und Multihoster.
    Unsere Plattform steht nur überprüften Nutzern zur Verfügung.
    Zur Zeit sind die Registrierungen geöffnet. Die Prüfung einer Registrierung beträgt wenige Stunden.
    Die Prüfung ist notwendig, da sich auf unserer Seite aktuell gut hundert Forenspammer pro Tag registrieren wollen.

golang textproto client-server mit ecdsa elliptic curve

Dieses Thema im Forum "Programmierung" wurde erstellt von MrNice, 14 Oktober 2022.

  1. MrNice

    MrNice Chefkoch Premium Trusted User Beta-Tester Geilster Typ

    Registriert seit:
    15 August 2017
    Beiträge:
    158
    Zustimmungen:
    570
    build_project.sh
    projects in: ~/GO/projectX
    Code:
    #!/bin/bash
    PATH="$PATH:/usr/local/go/bin"
    
    test -z "$1" && echo "usage $0 project" && exit 1
    
    export GOPATH=~/GO/"$1"
    #export GO11MODULE=auto
    export GO111MODULE=auto
    
    cd ~/GO/"$1" || exit 1
    
    go build *.go
    
    RET=$?
    test -e rsync.sh && ./rsync.sh
    echo -n "RET=$RET "
    test $RET -gt 0 && echo "BUILD FAILED!" || echo "BUILD OK!"
    exit $RET
    
    
    Code:
    ./binary --listen 1234
    2022/10/14 09:51:09 llisten=1234
    2022/10/14 09:51:12 peer: host=127.0.0.1 raddr=127.0.0.1:55736
    2022/10/14 09:51:12 peersession authed
    2022/10/14 09:51:19 peersession EOF err=EOF
    ^C
    
    Code:
    ./binary --ecconn 127.0.0.1:1234
    2022/10/14 09:51:12 recconn=127.0.0.1:1234
    2022/10/14 09:51:12 peering ecconn() connaddr='127.0.0.1:1234'
    2022/10/14 09:51:12 peering authed, send verify
    2022/10/14 09:51:12 authed received plaintext='1665733872'
    2022/10/14 09:51:13 authed received plaintext='1665733873'
    2022/10/14 09:51:14 authed received plaintext='1665733874'
    2022/10/14 09:51:15 authed received plaintext='1665733875'
    2022/10/14 09:51:16 authed received plaintext='1665733876'
    2022/10/14 09:51:17 authed received plaintext='1665733877'
    2022/10/14 09:51:18 authed received plaintext='1665733878'
    ^C
    
    @ go 1.19.1
    Code:
    package main
    
    import (
       "bufio"
       "crypto/aes"
       "crypto/x509"
       "crypto/cipher"
       "crypto/ecdsa"
       "crypto/elliptic"
       "crypto/sha256"
       crand "crypto/rand"
       mrand "math/rand"
       "encoding/hex"
       "encoding/pem"
       "fmt"
       "flag"
       "io"
       "log"
       "net"
       "net/textproto"
       "os"
       "reflect"
       "time"
       "strings"
       "strconv"
    )
    
    const NORA = 1
    const CPX = "X"
    const CDELIM = "x"
    const KEYRX = "0"
    const KEYTX = "1"
    const K1 = "gAOIMeZIiTpLe3rtm61BmPzQnWEIMgcZ5XxtHBRUrKeeH9geFjnHoP61FUBwLGLDKPrWtop4bFrCo3AGYoYs7YGU5AbXaZiolNlNLKsyir6QXemDafEVOwUUzSl1zpbr"
    const K2 = "GZDhwiDYg6dcr6hbQnbg6BAxSk29fF409NMqWsXZ1JweLhex8ntm40apy4tDYBr717SHpyXqDSb2KQL8BQGKHrHQJ9wVxEvKGSqDyWNqcXNdzG0jJJ8TZ0POUlXeMxAL"
    const K3 = "LDgmMxq5M4Vg4UkM2Vm7f23G8xgtCiI9hON0ddszhnb3idhBMNCMcfq0wHvSdS5oiy06IoRJsHllXxtv7VtjQX3kH7TR7HzqHxGd5nysq1qc2p61BE4r6JS9TiYZZzFR"
    
    var (
       err             error
     
       AESK            string
       HASH            string
     
       PKEY            *ecdsa.PrivateKey
       PUBK            *ecdsa.PublicKey
       PUBS            string
       strPKEYpem      string
       hexPKEYpem      string
       strPUBKpem      string
       hexPUBKpem      string
     
       KK1             string
       KK2             string
       KK3             string
    )
    
    func main(){
       flag_initec := flag.String("initec", "false", "gen")
       flag_listen := flag.String("listen", "", "1234")
       flag_ecconn := flag.String("ecconn", "", "127.0.0.1:1234")
       flag.Parse()
    
       initec(fmt.Sprintf("%s",*flag_initec))
       llisten := fmt.Sprintf("%s",*flag_listen)
       recconn := fmt.Sprintf("%s",*flag_ecconn)
       if llisten != "" {
           log.Printf("llisten=%s",llisten)
           eclisten(llisten)
           os.Exit(0)
       }else
       if recconn != "" {
           log.Printf("recconn=%s",recconn)
           ecconn(recconn)
           for {
               time.Sleep(2^32 * time.Second)
           }
           os.Exit(0)
       }
    }
    
    func hashkk() {
       KK1 = fmt.Sprintf("%s",hash256(K1))
       KK2 = fmt.Sprintf("%s",hash256(K2))
       KK3 = fmt.Sprintf("%s",hash256(K3))
    } // end func hashkk
    
    func genec(){
       PKEY, err = ecdsa.GenerateKey(elliptic.P256(), crand.Reader)
       if err != nil {
           log.Printf("genec() ecdsa.GenerateKey err='%v'", err)
           os.Exit(1)
       }
       PUBK = &PKEY.PublicKey
       strPKEYpem, strPUBKpem = ecdsa_pem_encode(PKEY, PUBK)
       hexPKEYpem, hexPUBKpem = hex.EncodeToString([]byte(strPKEYpem)), hex.EncodeToString([]byte(strPUBKpem))
       PUBS = hex.EncodeToString(elliptic.Marshal(PUBK.Curve, PUBK.X, PUBK.Y))
       if len(PUBS) != 130 && len(PUBS) != 194 {
           log.Printf("ERROR initec() len(PUBS)=%d", len(PUBS))
           os.Exit(1)
       }
    } // end func genec
    
    func initec(v string){
       mrand.Seed(time.Now().UnixNano())
       genec()
       if v == "gen" {
           log.Printf("initEC()\n\nPUBK_HEX=\n'\n%s\n'\n\nPUBK_PEM=\n'\n%s'\n\nPKEY_HEX=\n'\n%s\n'\n\nPKEY_PEM=\n'\n%s'\n\nPUBS=\n'\n%s\n'\n\n", hexPUBKpem, strPUBKpem, hexPKEYpem, strPKEYpem, PUBS)
           log.Printf("len(hexPUBKpem)=%d", len(hexPUBKpem))
           log.Printf("len(strPUBKpem)=%d", len(strPUBKpem))
           log.Printf("len(hexPKEYpem)=%d", len(hexPKEYpem))
           log.Printf("len(strPKEYpem)=%d", len(strPKEYpem))
           log.Printf("len(PUBS)=%d", len(PUBS))
           /*
            * curve P256:
            len(hexPUBKpem)=356
            len(strPUBKpem)=178
            len(hexPKEYpem)=442
            len(strPKEYpem)=221
            len(PUBS)=130
           */
       
           /*
            * curve P384:
            len(hexPUBKpem)=430
            len(strPUBKpem)=215
            len(hexPKEYpem)=564
            len(strPKEYpem)=282
            len(PUBS)=194
           */
           os.Exit(0)
       } else
       if v == "test" {
           log.Print("test_de_en_code()")
           test_de_en_code()
           os.Exit(0)
       }
    } // end func initec
    
    func ecdsa_pem_encode(privateKey *ecdsa.PrivateKey, publicKey *ecdsa.PublicKey) (string, string) {
       x509Encoded, _ := x509.MarshalECPrivateKey(privateKey)
       pemEncoded := pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: x509Encoded})
    
       x509EncodedPub, _ := x509.MarshalPKIXPublicKey(publicKey)
       pemEncodedPub := pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: x509EncodedPub})
    
       return string(pemEncoded), string(pemEncodedPub)
    }
    
    
    func ecdsa_pem_decode(pemEncoded string, pemEncodedPub string) (*ecdsa.PrivateKey, *ecdsa.PublicKey) {
       block, _ := pem.Decode([]byte(pemEncoded))
       x509Encoded := block.Bytes
       privateKey, _ := x509.ParseECPrivateKey(x509Encoded)
    
       blockPub, _ := pem.Decode([]byte(pemEncodedPub))
       x509EncodedPub := blockPub.Bytes
       genericPublicKey, _ := x509.ParsePKIXPublicKey(x509EncodedPub)
       publicKey := genericPublicKey.(*ecdsa.PublicKey)
    
       return privateKey, publicKey
    }
    
    
    func test_de_en_code() {
       privateKey, _ := ecdsa.GenerateKey(elliptic.P384(), crand.Reader)
       publicKey := &privateKey.PublicKey
    
       encPriv, encPub := ecdsa_pem_encode(privateKey, publicKey)
    
       fmt.Println(encPriv)
       fmt.Println(encPub)
    
       priv2, pub2 := ecdsa_pem_decode(encPriv, encPub)
    
       if !reflect.DeepEqual(privateKey, priv2) {
           fmt.Println("Private keys do not match.")
       }
       if !reflect.DeepEqual(publicKey, pub2) {
           fmt.Println("Public keys do not match.")
       }
    }
    
    
    type peering struct {
       RConn               net.Conn
       nonce               int
       sharedkeyS          string
       sharedkeyB          []byte
       sessionidB          string
       prip                string
       CliWriter           *bufio.Writer
       srvtp               *textproto.Conn
       authed              bool
       authlevel           int
    }
    
    func eclisten(lport string) {
       laddr := fmt.Sprintf("[::]:%s", lport)
       listr, err := net.Listen("tcp", laddr)
       if err == nil {
           for {
               conn, err := listr.Accept()
               if err != nil {
                   log.Printf("Error Peer: err=%v", err.Error())
                   os.Exit(0)
               }
               go handlePeerRequest(conn)
           }
       }
    } // end func eclistenr
    
    func ecconn(connaddr string) bool {
       var conn net.Conn
       peer := &peering{
           conn,
           0,
           "",
           nil,
           "",
           "",
           nil,
           nil,
           false,
           0,
       }
     
     
       tcpmode := "tcp"
     
       if connaddr == "" {
           log.Printf("peering ecconn() connaddr empty")
           os.Exit(1)
       }
       log.Printf("peering ecconn() connaddr='%s'", connaddr)
     
       conn, err := net.Dial(tcpmode, connaddr)
       if err != nil {
           log.Printf("ERROR net.Dial: tcpmode=%s connaddr='%s' err=%v", tcpmode, connaddr, err)
           return false
       }
     
       peer.srvtp, peer.RConn = textproto.NewConn(conn), conn
       initnonce := 0
       if !peer.psend(fmt.Sprintf("%s%s%s", KEYRX , CDELIM, PUBS), initnonce) { return false }
     
       for
       {
           r, err := peer.srvtp.ReadLine()
           if err != nil {
               log.Printf("ERROR ecconn()->peer.srvtp.ReadLine() err=%v", err)
               return false
           }
       
           len_r := len(r)
           if len_r >= 1 && len_r <= 1024 {
               line := strings.Split(r, CDELIM)
               cmd := string(line[0])
    
               args := []string{}
    
               if len(line) > 1 {
                   args = line[1:]
               }
           
               //log.Printf("peer.srvtp.ReadLine: r='%s' len=%d line='%s' cmd='%s' args='%s'", r, len_r, line, cmd, args)
               peer.pRXCMD(cmd, args)
           } else {
               err := peer.RConn.Close()
               if err != nil {
                   log.Printf("ERROR peer.RConn.Close() err=%v", err)
                   return false
               }
               break
           } // end if else len(r)
           
       } // end for
     
       return false
    }
    
    
    func (p *peering) genShared(pubkey string) bool {
       rpubb, err := hex.DecodeString(pubkey)
       if err != nil {
           log.Printf("ERROR peering genShared() err='%v'", err)
           return false
       }
     
       rpubx, rpuby := elliptic.Unmarshal(PUBK.Curve, rpubb)
    
       if rpubx != nil && rpuby != nil {
           b, _ := PUBK.Curve.ScalarMult(rpubx, rpuby, PKEY.D.Bytes())
           sharedkey := sha256.Sum256(b.Bytes())
           p.sharedkeyS = hex.EncodeToString(sharedkey[:])
           p.sharedkeyB = sharedkey[:]
           //log.Printf("peering genShared() sharedkey: '%x'",  p.sharedkeyS)
           return true
       }
     
       return false
    }
    
    
    func (p *peering) pRXCMD(cmd string, args []string) bool {
       //log.Printf("debug peering pRXCMD: cmd='%s' args='%s' len_args=%d", cmd, args, len(args))
    
       if !p.authed && p.sharedkeyS == "" && cmd == KEYRX && len(args) == 1 && len(args[0]) == 130 {
       
           if p.genShared(args[0]) {
               return p.psend(fmt.Sprintf("%s%s%s", KEYTX, CDELIM, PUBS), 0)
           }
       
       } else
     
     
       if !p.authed && p.sharedkeyS == "" && cmd == KEYTX && len(args) == 1 && len(args[0]) == 130 {
    
           if p.genShared(args[0]) {
               return p.psendcrypt(KK1)
           }
       
       } else
     
       if strings.HasPrefix(cmd, CPX) {
           ciphertext := strings.Split(cmd, CPX)[1]
           //log.Printf("peering RX ciphertext='%s'", ciphertext)
           ret, plaintext, nonceint, err := decrypt(ciphertext, p.sharedkeyB, p.nonce)
           if err == nil && ret == true && nonceint == p.nonce+NORA {
               p.nonce = nonceint
               if !p.authed && plaintext == KK2 {
                   p.authed = true
                   log.Printf("peering authed, send verify")
                   return p.psendcrypt(KK3)
               } else
               if !p.authed {
                   NNOW := UnixTimeSec()
                   ANYS := randomChars(16)
                   HASH := hash256(fmt.Sprintf("%s|%d",ANYS,NNOW))
                   data := fmt.Sprintf("DATA:ANYS=%s|NNOW=%d|HASH=%s", ANYS, NNOW, HASH)
                   return p.psendcrypt(data)
               } else
               if p.authed {
                   log.Printf("authed received plaintext='%s'", plaintext)
                   // process peering authed commands here
                   now := fmt.Sprintf("%d", UnixTimeSec())
                   time.Sleep(1000 * time.Millisecond)
                   return p.psendcrypt(now)
               }
           
           } else {
               log.Printf("ERROR peering pRXCMD() decrypt err='%v'", err)
           }
       }
     
       log.Printf("peering pRXCMD() close")
       p.RConn.Close()
       return false
    }
    
    
    func (p *peering) psendcrypt(message string) bool {
       //log.Printf("debug peering psendcrypt() message='%s", message)
       ret, ciphertext, nonceint, err := encrypt(message, p.sharedkeyB, p.nonce)
       if ret == true && nonceint > p.nonce {
           p.nonce = nonceint
           return p.psend(ciphertext, nonceint)
       } else {
           log.Printf("peering psendcrypt() encrypt failed p.nonce=%d nonceint=%d err='%v'", p.nonce, nonceint, err)
       }
       panic(err.Error())
       return false
    }
    
    
    func (p *peering) psend(message string, nonceint int) bool {
       var msg string
       //log.Printf("debug peering psend: message '%s' nonceint=%d", message, nonceint)
       if nonceint > 100000000000 {
           msg = fmt.Sprintf("%s%s\n", CPX, message)
       } else {
           msg = fmt.Sprintf("%s\n", message)
       }
     
       _, err := io.WriteString(p.RConn, msg)
       if err != nil {
           log.Printf("ERROR: peering psend failed")
           return false
       }
       return true
    } // end func psend
    
    
    func encrypt(message string, key []byte, nonceint int) (bool, string, int, error) {
       if nonceint == 0 { nonceint = 100000000000 }
       //log.Printf("encrypt: message='%s', key='%x', nonceint=%d", message, key, nonceint)
       plaintext := []byte(message)
       block, err := aes.NewCipher(key)
       if err != nil {
           return false, "", nonceint, err
           //panic(err.Error())
       }
       nonce := []byte(strconv.Itoa(nonceint))
       aesgcm, err := cipher.NewGCM(block)
     
       if err != nil {
           return false, "", nonceint, err
           //panic(err.Error())
       }
       ciphertext := aesgcm.Seal(nil, nonce, plaintext, nil)
       //log.Printf("Encrypted Ciphertext: '%x' nonce=%d\n", ciphertext, nonceint)
       ct := hex.EncodeToString(ciphertext)
       nonceint += NORA
       return true, ct, nonceint, nil
    }
    
    
    func decrypt(ciphermessage string, key []byte, nonceint int) (bool, string, int, error) {
       if nonceint == 0 { nonceint = 100000000000 }
       ciphertext, _ := hex.DecodeString(ciphermessage)
       nonce := []byte(strconv.Itoa(nonceint))
       block, err := aes.NewCipher(key)
       if err != nil {
           return false, "", nonceint, err
       }
       aesgcm, err := cipher.NewGCM(block)
       if err != nil {
           return false, "", nonceint, err
           //panic(err.Error())
       }
       plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil)
       if err != nil {
           return false, "", nonceint, err
           //panic(err.Error())
       }
       //log.Printf("Deciphered Plaintext: %s\n", string(plaintext))
       nonceint += NORA
       return true, string(plaintext), nonceint, nil
    }
    
    
    
    
    type peersession struct {
       SConn               net.Conn
       nonce               int
       sharedkeyS          string
       sharedkeyB          []byte
       peersessionidS      string
       srip                string
       CliWriter           *bufio.Writer
       clitp               *textproto.Conn
       authed              bool
       authlevel           int
    }
    
    func handlePeerRequest(conn net.Conn) {
       sess := &peersession{
           conn,
           0,
           "",
           nil,
           "",
           "",
           nil,
           nil,
           false,
           0,
       }
     
       sess.CliWriter = bufio.NewWriterSize(sess.SConn,1024)
     
       peer := sess.SConn.RemoteAddr().String()
       host, _, err := net.SplitHostPort(peer)
       if err != nil {
           log.Printf("get RIP Error")
           os.Exit(1)
       } else {
           log.Printf("peer: host=%s raddr=%s", host, peer)
       }
     
       //sess.srip = host
       sess.clitp = textproto.NewConn(conn)
     
       for
       {
           r, err := sess.clitp.ReadLine()
           if err != nil {
               log.Printf("peersession EOF err=%v", err)
               return
           }
       
           len_r := len(r)
           if len_r >= 1 && len_r <= 1024 {
               line := strings.Split(r, CDELIM)
               cmd := string(line[0])
    
               args := []string{}
    
               if len(line) > 1 {
                   args = line[1:]
               }
           
               //log.Printf("rx: '%s' len=%d line='%s' cmd='%s' args='%s'", r, len_r , line, cmd, args)
               sess.sRXCMD(cmd, args)
           } else {
               err := sess.SConn.Close()
               if err != nil {
                   return
               }
               log.Printf("ERROR peer cmd len=%d rip='%s' line='%s'", len_r, sess.srip)
               break
           } // end if else len(r)
           
           } // end for
       
    } // end func handlePeerRequest
    
    func (s *peersession) genShared(pubkey string) bool {
       rpubb, err := hex.DecodeString(pubkey)
       if err != nil {
           log.Printf("peersession genShared error=%v", err)
           return false
       }
     
       rpubx, rpuby := elliptic.Unmarshal(PUBK.Curve, rpubb)
     
       if rpubx != nil && rpuby != nil {
           b, _ := PUBK.Curve.ScalarMult(rpubx, rpuby, PKEY.D.Bytes())
           sharedkey := sha256.Sum256(b.Bytes())
           s.sharedkeyS = hex.EncodeToString(sharedkey[:])
           s.sharedkeyB = sharedkey[:]
           //log.Printf("peersession sharedkey: '%x'",  s.sharedkeyS)
           return true
       }
     
       return false
    }
    
    
    func (s *peersession) sRXCMD(cmd string, args []string) bool {
       //log.Printf("peersession sRXCMD: cmd=%v args=%s len_args=%d", cmd, args, len(args))
     
       if !s.authed && s.sharedkeyS == "" && cmd == KEYRX && len(args) == 1 && len(args[0]) == 130 {
       
           if s.genShared(args[0]) {
               return s.ssend(fmt.Sprintf("%s%s%s",KEYTX,CDELIM,PUBS),0)
           }
       
       } else
     
     
       if !s.authed && s.sharedkeyS == "" && cmd == KEYTX && len(args) == 1 && len(args[0]) == 130 {
       
           if s.genShared(args[0]) {
               return s.ssendcrypt(KK1)
           }
       
       } else
     
       if strings.HasPrefix(cmd, CPX) {
           now := fmt.Sprintf("%d", UnixTimeSec())
           ciphertext := strings.Split(cmd, CPX)[1]
           //log.Printf("peersession RX ciphertext: '%s'", ciphertext)
           ret, plaintext, nonceint, err := decrypt(ciphertext, s.sharedkeyB, s.nonce)
           if ret == true && nonceint > s.nonce && err == nil {
               s.nonce = nonceint
               if !s.authed && s.authlevel == 0 && plaintext == KK1 {
                   s.authlevel += 1
                   return s.ssendcrypt(KK2)
               } else
               if s.authlevel == 1 && plaintext == KK3 {
                   log.Printf("peersession authed")
                   s.authed = true
                   return s.ssendcrypt(now)
               
               } else
               if s.authed {
                   // DATA:ANYS=1234,NNOW=5678,HASH=abcd
                   if strings.HasPrefix(plaintext, "DATA:") {
                       getdata := strings.Split(plaintext,":")
                       data := strings.Split(getdata[1],"|")
                       log.Printf("got data: %s", data)
                   }
                   // process peersession authed commands here
                   return s.ssendcrypt(now)
               }
           
           } else {
               log.Printf("peersession decrypt error")
           }
       }
     
       log.Printf("peersession sRXCMD close")
       s.SConn.Close()
       return false
    }
    
    
    func (s *peersession) ssendcrypt(message string) bool {
       //log.Printf("debug peersession sendcrypt %s", message)
       ret, ciphertext, nonceint, err := encrypt(message, s.sharedkeyB, s.nonce)
       if ret == true && nonceint > s.nonce {
           s.nonce = nonceint
           return s.ssend(ciphertext, nonceint)
       } else {
           log.Printf("peering ssendcrypt encrypt failed s.nonce=%d nonceint=%d err='%x'", s.nonce, nonceint, err)
       }
       panic(err.Error())
       return false
    }
    
    
    func (s *peersession) ssend(message string, nonceint int) bool {
       var msg string
       if nonceint > 100000000000 {
           msg = fmt.Sprintf("%s%s\n", CPX, message)
       } else {
           msg = fmt.Sprintf("%s\n", message)
       }
     
       _, err := io.WriteString(s.SConn, msg)
       if err != nil {
           log.Printf("ERROR: peering ssend failed")
           return false
       }
       return true
    } // end func ssend
    
    
    func hash256(line string) string {
       ahash := sha256.Sum256([]byte(line))
       return hex.EncodeToString(ahash[:])
    }
    
    
    func UnixTimeSec() int64 {
       return time.Now().UnixNano() / 1e9
    }
    
    func UnixTimeMilliSec() int64 {
       return time.Now().UnixNano() / 1e6
    }
    
    func UnixTimeMicroSec() int64 {
       return time.Now().UnixNano() / 1e3
    }
    
    func UnixTimeNanoSec() int64 {
       return time.Now().UnixNano()
    }
    
    func randomChars(size int) string {
       charset := "0123456789abcdef"
       buf := make([]byte, size)
       for i := 0; i < size; i++ {
           buf[i] = charset[mrand.Intn(len(charset))]
       }
       return string(buf)
    } // end func randomChars
    
    nur ein test/PoC skeleton^^ wer was damit anfangen kann: go!
     
    3way gefällt das.
  2. Mydgard

    Mydgard Premium Trusted User Beta-Tester

    Registriert seit:
    21 März 2015
    Beiträge:
    3.375
    Zustimmungen:
    4.129
    Free:
    778.500 MB
    Für die "Nicht-Programmierer" unter uns, wofür ist das gut?
     
  3. MrNice

    MrNice Chefkoch Premium Trusted User Beta-Tester Geilster Typ

    Registriert seit:
    15 August 2017
    Beiträge:
    158
    Zustimmungen:
    570
    zB zum programmieren lernen ;)
     
  4. Mydgard

    Mydgard Premium Trusted User Beta-Tester

    Registriert seit:
    21 März 2015
    Beiträge:
    3.375
    Zustimmungen:
    4.129
    Free:
    778.500 MB
    Eher nicht danke ;)
     
    MrNice gefällt das.
  5. MrNice

    MrNice Chefkoch Premium Trusted User Beta-Tester Geilster Typ

    Registriert seit:
    15 August 2017
    Beiträge:
    158
    Zustimmungen:
    570
    warum nicht?

    du fängst bei main() an und arbeitest dich durch ;)
    in der main gibts nur 2 funktionsaufrufe
    eclisten(llisten) und ecconn(recconn)
    und so weiter geht die reise ;)

    golang ist geil! war noch nie so einfach echtes multitread zu coden. wer hilfe bei threadsafemaps brauch. PM.
     
    3way gefällt das.
  6. 3way

    3way Vollzeit-OS-Ausprobierer Premium Trusted User Beta-Tester

    Registriert seit:
    14 Juli 2015
    Beiträge:
    4.603
    Zustimmungen:
    6.927
    [​IMG] :devil:
     
  7. Mydgard

    Mydgard Premium Trusted User Beta-Tester

    Registriert seit:
    21 März 2015
    Beiträge:
    3.375
    Zustimmungen:
    4.129
    Free:
    778.500 MB
    3way;) Ich habe andere Interessen und Wissen das reicht mir :)
     
    3way gefällt das.
  8. MrNice

    MrNice Chefkoch Premium Trusted User Beta-Tester Geilster Typ

    Registriert seit:
    15 August 2017
    Beiträge:
    158
    Zustimmungen:
    570
    Da stellt man sich die Frage, wieso überhaut gefragt wird, wofür das gut ist, wenn du von Anfang an weißt, dass du dein Wissen nicht erweitern willst, dann kann man sich das Fragen auch sparen? Oder aners rum, wenn dir dein Wissen doch reicht warum fragst dann überhaupt. Weißt doch alles, oder nich? :joycat:

    Gibts Menschen hier die Usenet Server (Text-News, non-binary) betreiben?
     
    Mydgard gefällt das.
  9. K3npachi

    K3npachi Premium Serious User

    Registriert seit:
    4 August 2018
    Beiträge:
    28
    Zustimmungen:
    24
    Free:
    3.834 MB
    schöner code, mal ne frage dazu: wieso horcht der auf port 1234 ?
    und ich vermute mal du hast keine Ahnung welche Mathematik hinter elliptischen Kurven steht.
     
    MrNice gefällt das.
  10. Mydgard

    Mydgard Premium Trusted User Beta-Tester

    Registriert seit:
    21 März 2015
    Beiträge:
    3.375
    Zustimmungen:
    4.129
    Free:
    778.500 MB
    Früher häufiger, vor allem für VGA Planets (Planets 3, PBEM Strategiespiel), aber schon bestimmt 15-18 Jahre nicht mehr.

    EDIT: Sehe grade, die Frage war weniger ob man das nutzt als das man einen Server betreibt ... dann ist die Antwort: Nein.
     
    MrNice gefällt das.
  11. MrNice

    MrNice Chefkoch Premium Trusted User Beta-Tester Geilster Typ

    Registriert seit:
    15 August 2017
    Beiträge:
    158
    Zustimmungen:
    570
    --listen ist ein argument und port 1234 ist variabel? server-client benötigt zumindest irgendeinen port, oder wie kann C kann mit S reden?

    und welche Mathematik meinst du? basiert vermutlich auf dem standard model von openssl?

    das https://en.wikipedia.org/wiki/Elliptic_curve ?
    das https://mathworld.wolfram.com/EllipticCurve.html ?
    das https://crypto.stanford.edu/pbc/notes/elliptic/ ?
    das https://pkg.go.dev/crypto/elliptic ?
     
  12. K3npachi

    K3npachi Premium Serious User

    Registriert seit:
    4 August 2018
    Beiträge:
    28
    Zustimmungen:
    24
    Free:
    3.834 MB
    der von dir gepostete Code verwendet elliptische Kurven. daher die frage wieso. Und in welchem Kontext soll das arbeiten ? Alls dll-Aufruf oder shared library beispielsweise wird ein Einsprungspunkt benötigt und kein Port belegt. Das will mir nicht einleuchten.
     
    MrNice gefällt das.
  13. MrNice

    MrNice Chefkoch Premium Trusted User Beta-Tester Geilster Typ

    Registriert seit:
    15 August 2017
    Beiträge:
    158
    Zustimmungen:
    570
  14. K3npachi

    K3npachi Premium Serious User

    Registriert seit:
    4 August 2018
    Beiträge:
    28
    Zustimmungen:
    24
    Free:
    3.834 MB
    genial: zuerst den Quelltest posten und dann erst die Doku dazu. Bei so einem Vorgehen siebst du effektiv alle Loser aus. Ich gesteh hier reumütig an dieser Stelle das ich kein Gehirn wie ein Computer besitze.
     
  15. MrNice

    MrNice Chefkoch Premium Trusted User Beta-Tester Geilster Typ

    Registriert seit:
    15 August 2017
    Beiträge:
    158
    Zustimmungen:
    570
    Keine Ahnung worauf du hinauswillst oder was dein Problem ist aber die Doku hättest du auch mit den ersten 2 Worten des subjects selbst finden können und deine vorher gestellte Frage erübrigt sich auch, wenn das subject komplett gelesen wird, ist klar, dass ein Port für irgendeine Art der Kommunikation zwischen client-server benutzt wird, der Port impliziert dazu irgendwas mit Netzwerk.
    Ich weiß auch nicht welche Loser ich aussieben soll. Ich hab just for fun was in golang geschrieben und es mit der welt geteilt, in der Hoffnung, dass irgendwer damit was anfangen kann. Meiner einer kann Sprachen durch lesen lernen, da ich nicht Gott bin, geh ich davon aus, dass das andere auch können. Du vermutlich nicht, du siebst dich ja selbst aus :D
     
    HHFrosch gefällt das.