25.2. 프로그램언어 고(Go)의 UDP 기반 통신

by

프로그램언어 고(Go)의 UDP 서버 구축

Go언어로 UDP 서버를 구축하는 방법을 최대한 쉽고 자세하게 설명드리겠습니다.

package main

import (
    "net"
    "fmt"
)

func main() {

    // UDP 서버를 위한 주소 정의
    serverAddr, err := net.ResolveUDPAddr("udp", ":9999")
    if err != nil {
        fmt.Println(err)
        return
    }

    // UDP LISTENER 생성
    serverConn, err := net.ListenUDP("udp", serverAddr)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer serverConn.Close()

    buffer := make([]byte, 1024)

    for {
        // 데이터 읽기
        n, remoteAddr, err := serverConn.ReadFromUDP(buffer)
        if err != nil {
            fmt.Println(err)
            continue
        }

        // 읽은 데이터 출력
        fmt.Printf("Received: %s from %v\n", string(buffer[:n]), remoteAddr)
        
        // 데이터 쓰기
        _, err = serverConn.WriteToUDP([]byte("Response"), remoteAddr)
        if err != nil {
            fmt.Println(err)
            continue 
        }
    }
}

우선 net 패키지를 import하여 네트워크 기능을 사용할 수 있도록 합니다.

그다음 UDP 서버가 사용할 주소와 포트를 지정합니다. 여기서는 9999 포트를 사용하겠습니다.

ResolveUDPAddr 함수로 주소 구조체를 생성한 뒤, ListenUDP 함수로 서버 소켓을 엽니다.

이 때 데이터 전송에 사용할 1024바이트의 버퍼를 만들어 둡니다.

for문 안에서 ReadFromUDP 함수를 사용하여 클라이언트로부터 데이터를 읽습니다.

읽은 데이터와 remoteAddr 변수에 저장된 클라이언트의 주소 정보를 출력합니다.

마지막으로 WriteToUDP 함수로 “Response”라는 데이터를 클라이언트에게 전송함으로써 응답을 보내는 간단한 서버 로직이 완성됩니다.

주석을 통해 각 줄의 역할을 자세히 설명드렸으니 참고하시기 바랍니다.

UDP 서버 구축시 주의할 점이나 보완 사항이 있다면 언제든지 문의 주시기 바랍니다.

프로그램언어 고(Go)에서의 UDP 클라이언트 구성

Go 언어에서 UDP 클라이언트를 구성하는 방법은 다음과 같습니다.

package main

import (
        "net"
        "fmt"
)

func main() {

        // UDP소켓 생성
        conn, err := net.Dial("udp", "localhost:8000")
        if err != nil {
                fmt.Println(err)
                return
        }

        // 서버에 메시지 보내기
        _, err = conn.Write([]byte("Hello Server"))
        if err != nil {
                fmt.Println(err)
                return
        }

        // 서버의 응답 받기
        buffer := make([]byte, 1024)
        n, addr, err := conn.ReadFromUDP(buffer)
        message := string(buffer[:n])
        fmt.Println("Reply: " + message)

        // 소켓 닫기
        conn.Close()
}

주요 내용은 다음과 같습니다.

1. net 패키지의 Dial 함수를 사용하여 UDP 소켓을 생성합니다.
2. 소켓의 Write 메서드를 사용하여 서버에 데이터를 보냅니다.
3. 소켓의 ReadFromUDP 메서드를 사용하여 서버로부터 데이터를 받습니다.
4. 연결을 끝내기 위해 Close 메서드를 사용하여 소켓을 닫습니다.

이와 같이 Go언어의 표준 네트워크 라이브러리를 활용하여 간단하게 UDP 클라이언트를 구성할 수 있습니다.

ReadFromUDP 메서드에서 받은 데이터 외에도 서버의 주소와 포트번호 정보를 얻을 수 있다는 점이 특징입니다.

UDP소켓과의 통신이 끝난 후에는 꼭 Close메서드를 사용하여 자원을 정리해주는 습관이 필요합니다.

이상으로 Go언어의 UDP 클라이언트 구성에 대해 간략히 설명드렸습니다.

프로그램언어 고(Go)의 UDP 패킷 조작

Go언어의 UDP 패킷 조작에 대해 설명드리겠습니다.

Go언어에서 UDP 패킷을 조작하려면 net 패키지의 Conn, PacketConn 인터페이스를 사용합니다. 


// Conn 인터페이스를 사용한 예
conn, err := net.Dial("udp", "192.0.2.1:8000")
if err != nil {
    // 에러 처리
}
defer conn.Close()

// 패킷 보내기
_, err = conn.Write([]byte("Hello World"))

// PacketConn 인터페이스를 사용한 예 
pc, err := net.ListenPacket("udp", ":8000")
if err != nil {
    // 에러 처리
}
defer pc.Close()

// 패킷 받기
buf := make([]byte, 1024)
n, addr, err := pc.ReadFrom(buf)

// 패킷 보내기
_, err = pc.WriteTo([]byte("Reply"), addr)

UDP는 연결지향 프로토콜이 아니기 때문에 다소 복잡합니다.

Conn 인터페이스를 사용하면 TCP 소켓과 비슷한 방식으로 사용할 수 있습니다. Write() 메서드로 데이터를 보내고, SetReadDeadline() 메서드로 타임아웃을 설정할 수 있습니다.

PacketConn 인터페이스는 저수준 제어를 할 수 있습니다. 패킷을 읽고 쓸 때 마다 주소 정보를 제공합니다. 따라서 패킷의 출발지와 목적지를 정확히 알 수 있죠.

UDP 처리 시 주의할 점은 데이터 gram의 경계입니다. UDP 패킷의 크기는 제한이 없기 때문에 응용 계층에서 데이터경계를 반드시 정의해야 합니다. 예를들어 각 패킷 앞에 데이터 크기 정보를 붙이는 방법이 있습니다.

수신자는 이 정보를 참고하여 데이터를 적절히 분할하여 읽을 수 있습니다. 이런 처리를 해주지 않으면 데이터 손상이 발생할 수 있습니다.

수신 버퍼도 적절한 크기로 설정이 필요합니다. 수신 버퍼가 작으면 큰 데이터가 버퍼를 넘치게 됩니다. 이 경우 일부 데이터가 손실되는 오버플로가 발생합니다.

Go의 UDP API는 비교적 저수준이기 때문에, 실제로 사용할 때에는 보다 고수준의 프레임워크나 라이브러리를 사용하는 것이 좋습니다.

예를들어 Google에서 제공하는 Quic-go, Discord에서 만든 DiscordGo 등 입니다. 이들은 수신 버퍼, 혼잡제어, 시퀀스 관리 등 복잡한 문제들을 대부분 해결해놓았습니다.

지금까지 Go언어의 UDP 패킷 조작에 대해 간단히 설명드렸습니다. 보다 자세한 내용은 공식 문서나 참고 자료를 참고하시기 바랍니다. Go언어 학습에 도움이 되었으면 좋겠습니다.

프로그램언어 고(Go)에서의 UDP 연결 관리

프로그램언어 고(Go)에서 UDP 연결을 사용하시려면 net 패키지의 Conn, PacketConn 인터페이스를 사용하시면 됩니다.

UDP는 연결지향적이지 않은 프로토콜이기 때문에 Listen과 Accept 메서드가 없습니다. 대신 PacketConn 인터페이스의 ReadFrom과 WriteTo 메서드를 사용하여 데이터를 읽고 쓰실 수 있습니다.

예를들어 UDP 서버를 만드실 때는 다음과 같은 코드를 사용하실 수 있습니다.


func main() {
  addr := net.UDPAddr{
    Port: 8888,
    IP: net.ParseIP("0.0.0.0"),
  }
  
  conn, err := net.ListenUDP("udp", &addr)
  if err != nil {
    log.Fatal(err)
  }
  defer conn.Close() 

  for {
    handleClient(conn)
  }  
}

func handleClient(conn *net.UDPConn) {
  var buf [512]byte
  
  n, addr, err := conn.ReadFromUDP(buf[0:])
  if err != nil {
    return 
  }

  fmt.Println("Received ", string(buf[0:n]), " from ", addr) 

  _, err = conn.WriteToUDP([]byte("Hello "+addr.String()), addr)
  if err != nil {
    return
  }  
}

위 코드에서 UDP 서버를 8888 포트로 Listen합니다. 그리고 클라이언트로부터 데이터가 오면 ReadFromUDP 메서드를 사용하여 데이터를 읽은 뒤 WriteToUDP 메서드로 클라이언트에 응답합니다.

UDP 클라이언트는 다음과 같이 구현하실 수 있습니다.


func main() {
  raddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8888")
  if err != nil {
    log.Fatal(err)
  }

  conn, err := net.DialUDP("udp", nil, raddr)
  if err != nil {
    log.Fatal(err)
  }
  defer conn.Close()

  _, err = conn.Write([]byte("Hello Server"))
  if err != nil {
    log.Fatal(err) 
  }

  var buf [512]byte
  n, _, err := conn.ReadFromUDP(buf[0:])
  if err != nil {
    log.Fatal(err)
  }

  fmt.Println("Received ", string(buf[0:n]))  
}

클라이언트는 서버의 IP와 포트정보를 갖고 있어야 하며, DialUDP 메서드로 소켓을 연결합니다. 그 후 ReadFromUDP와 Write 메서드를 이용하여 서버와 통신하는 구조입니다.

UDP 연결에서 주의하실 점은 패킷 손실이 있다는 것입니다. 신뢰성이 떨어지기 때문에 중요한 데이터 전송시에는 TCP를 권장합니다.

또한 방화벽 및 네트워크 정책에 따라 UDP 트래픽이 차단될 수 있다는 것도 염두에 두시기 바랍니다.

이상으로 프로그램언어 고(Go)의 UDP 연결 관리에 대한 내용을 간단하게 설명드렸습니다.
더 궁금하신 사항이 있으시면 문의 주시면 성심껏 답변 드리겠습니다.

프로그램언어 고(Go)의 UDP 통신 보안

프로그램언어 고(Go)의 UDP 통신 보안에 대해 다음과 같이 설명드리겠습니다.

UDP는 기본적으로 보안이 취약한 통신 프로토콜입니다. 데이터가 암호화되지 않고 전송되기 때문에 가로채기, 변조, 요구 사항 충돌 공격 등의 보안 위협에 취약합니다.

고(Go)에서 UDP 통신의 보안을 위해 주로 사용하는 방법은 다음과 같습니다.


package main

import (
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "net"
)

func main() {

    p := generateKey()

    conn, _ := net.Dial("udp", "localhost:50000")
    defer conn.Close() 

    msg := []byte("Hello Server")
    sign := signMessage(msg, p)

    _, _ = conn.Write(append(msg, sign...))

}

func generateKey() []byte {
    k := make([]byte, 32)
    _, _ = rand.Read(k)
    return k 
}

func signMessage(msg []byte, privKey []byte) []byte {
    h := sha256.New()
    h.Write(msg)
    h.Write(privKey)

    return h.Sum(nil)
}

1. 메시지 전송 전에 개인키를 생성합니다.
2. 메시지를 해시화하고 개인키와 결합한 후 서명합니다.
3. 서명된 메시지를 UDP로 전송합니다.

이 방법을 사용하면 메시지를 암호화하지 않아도 변조 여부를 확인할 수 있습니다. 서버에서도 동일한 개인키로 서명을 검증할 수 있습니다.

다른 보안 방법으로는 SSL/TLS를 사용하는 것입니다. 고(Go) 표준 라이브러리의 crypto/tls 패키지를 사용하면 UDP 통신을 위한 TLS 커넥션을 구성할 수 있습니다.


package main

import (
    "crypto/tls"
    "net"
)

func main() {

    cer, _ := tls.LoadX509KeyPair("cert.pem", "key.pem")
    config := tls.Config{Certificates: []tls.Certificate{cer}}
    conn := dtls.Client(config, "udp")

    addr := &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 4444}
    _, _ = conn.Dial(addr.Network(), addr.String())

    _, _ = conn.Write([]byte("Hello Server"))

}

tls.Config를 구성하고 dtls.Client() 함수로 UDP를 위한 TLS 연결을 생성합니다. 인증서와 개인키를 사용하여 상호 인증도 가능합니다. 암호화 통신 채널이 확보되어 보안성이 높아집니다.

UDP 통신의 가장 큰 단점은 연결 지향성이 없다는 것입니다. 상태 정보를 저장하지 않기 때문에 요구 사항 충돌 공격에 취약합니다. 이를 방지하려면 서버에서 클라이언트의 상태를 관리하는 로직을 추가로 구현해야 합니다.

고(Go)의 표준 라이브러리를 활용한 보안화는 어느정도 가능하지만, 핵심 로직을 직접 개발해야 하는 제약이 있습니다. 보다 나은 보안을 위해서는 전문 보안 라이브러리의 도입을 고려해 볼 수 있습니다.

UDP 통신 보안에 대한 고(Go)의 구현 사례를 중심으로 설명드렸습니다. 보다 자세한 내용이 필요하시면 답변 부탁드립니다.

Leave a Comment