1 // VoRS -- Vo(IP) Really Simple
2 // Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU Affero General Public License as
6 // published by the Free Software Foundation, version 3 of the License.
8 // This program is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 // GNU General Public License for more details.
13 // You should have received a copy of the GNU General Public License
14 // along with this program. If not, see <http://www.gnu.org/licenses/>.
35 "github.com/flynn/noise"
36 "github.com/jroimartin/gocui"
37 vors "go.stargrave.org/vors/internal"
38 "golang.org/x/crypto/blake2s"
39 "golang.org/x/crypto/chacha20"
40 "golang.org/x/crypto/poly1305"
45 MinVersion: tls.VersionTLS13,
46 CurvePreferences: []tls.CurveID{tls.X25519},
49 Cookies = map[vors.Cookie]chan *net.UDPAddr{}
52 func newPeer(conn *net.TCPConn) {
53 logger := slog.With("remote", conn.RemoteAddr().String())
54 logger.Info("connected")
56 err := conn.SetNoDelay(true)
58 log.Fatalln("nodelay:", err)
60 buf := make([]byte, len(vors.NoisePrologue))
62 if _, err = io.ReadFull(conn, buf); err != nil {
63 logger.Error("handshake: read prologue", "err", err)
66 if string(buf) != vors.NoisePrologue {
67 logger.Error("handshake: wrong prologue", "err", err)
71 hs, err := noise.NewHandshakeState(noise.Config{
72 CipherSuite: vors.NoiseCipherSuite,
73 Pattern: noise.HandshakeNK,
75 StaticKeypair: noise.DHKey{Private: Prv, Public: Pub},
76 Prologue: []byte(vors.NoisePrologue),
79 log.Fatalln("noise.NewHandshakeState:", err)
81 buf, err = vors.PktRead(conn)
83 logger.Error("read handshake", "err", err)
90 rx: make(chan []byte),
91 tx: make(chan []byte, 10),
92 alive: make(chan struct{}),
96 nameAndRoom, _, _, err := hs.ReadMessage(nil, buf)
98 logger.Error("handshake: decrypt", "err", err)
101 cols := strings.SplitN(string(nameAndRoom), " ", 3)
110 peer.name = string(cols[0])
111 logger = logger.With("name", peer.name, "room", roomName)
113 room = Rooms[roomName]
118 peers: make(map[byte]*Peer),
119 alive: make(chan struct{}),
121 Rooms[roomName] = room
126 tick := time.Tick(vors.ScreenRefresh)
132 GUI.DeleteView(room.name)
135 v, err = GUI.View(room.name)
138 v.Write([]byte(strings.Join(room.Stats(now), "\n")))
146 logger.Error("wrong password")
147 buf, _, _, err = hs.WriteMessage(nil, []byte("wrong password"))
151 vors.PktWrite(conn, buf)
157 for _, p := range room.peers {
158 if p.name != peer.name {
161 logger.Error("name already taken")
162 buf, _, _, err = hs.WriteMessage(nil, []byte("name already taken"))
166 vors.PktWrite(conn, buf)
175 for i = 0; i <= (1<<8)-1; i++ {
176 if _, ok = Peers[i]; !ok {
183 Peers[peer.sid] = peer
188 buf, _, _, err = hs.WriteMessage(nil, []byte("too many users"))
192 vors.PktWrite(conn, buf)
196 logger = logger.With("sid", peer.sid)
197 room.peers[peer.sid] = peer
198 logger.Info("logged in")
201 logger.Info("removing")
203 delete(Peers, peer.sid)
204 delete(room.peers, peer.sid)
206 s := []byte(fmt.Sprintf("%s %d", vors.CmdDel, peer.sid))
207 for _, p := range room.peers {
208 go func(tx chan []byte) { tx <- s }(p.tx)
213 var cookie vors.Cookie
214 if _, err = io.ReadFull(rand.Reader, cookie[:]); err != nil {
215 log.Fatalln("cookie:", err)
217 gotCookie := make(chan *net.UDPAddr)
218 Cookies[cookie] = gotCookie
220 var txCS, rxCS *noise.CipherState
221 buf, txCS, rxCS, err := hs.WriteMessage(nil,
222 []byte(fmt.Sprintf("OK %s", hex.EncodeToString(cookie[:]))))
224 log.Fatalln("hs.WriteMessage:", err)
226 if err = vors.PktWrite(conn, buf); err != nil {
227 logger.Error("handshake write", "err", err)
228 delete(Cookies, cookie)
231 peer.rxCS, peer.txCS = txCS, rxCS
233 timeout := time.NewTimer(vors.PingTime)
235 case peer.addr = <-gotCookie:
237 logger.Error("cookie timeout")
238 delete(Cookies, cookie)
241 delete(Cookies, cookie)
242 logger.Info("got cookie", "addr", peer.addr)
248 peer.tx <- []byte(fmt.Sprintf("SID %d", peer.sid))
250 for _, p := range room.peers {
251 if p.sid == peer.sid {
254 peer.tx <- []byte(fmt.Sprintf("%s %d %s %s",
255 vors.CmdAdd, p.sid, p.name, hex.EncodeToString(p.key)))
259 h, err := blake2s.New256(hs.ChannelBinding())
263 h.Write([]byte(vors.NoisePrologue))
264 peer.key = h.Sum(nil)
268 s := []byte(fmt.Sprintf("%s %d %s %s",
269 vors.CmdAdd, peer.sid, peer.name, hex.EncodeToString(peer.key)))
270 for _, p := range room.peers {
271 if p.sid != peer.sid {
278 go func(seen *time.Time) {
279 ticker := time.Tick(vors.PingTime)
284 if seen.Add(2 * vors.PingTime).Before(now) {
285 logger.Error("timeout:", "seen", seen)
295 for buf := range peer.rx {
296 if string(buf) == vors.CmdPing {
298 peer.tx <- []byte(vors.CmdPong)
304 bind := flag.String("bind", "[::1]:"+strconv.Itoa(vors.DefaultPort),
305 "Host:TCP/UDP port to listen on")
306 kpFile := flag.String("key", "key", "Path to keypair file")
308 log.SetFlags(log.Lmicroseconds | log.Lshortfile)
311 data, err := os.ReadFile(*kpFile)
315 Prv, Pub = data[:len(data)/2], data[len(data)/2:]
318 lnTCP, err := net.ListenTCP("tcp",
319 net.TCPAddrFromAddrPort(netip.MustParseAddrPort(*bind)))
323 lnUDP, err := net.ListenUDP("udp",
324 net.UDPAddrFromAddrPort(netip.MustParseAddrPort(*bind)))
329 LoggerReady := make(chan struct{})
332 slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, nil)))
335 GUI, err = gocui.NewGui(gocui.OutputNormal)
340 GUI.SetManagerFunc(guiLayout)
341 if err := GUI.SetKeybinding("", gocui.KeyF10, gocui.ModNone, guiQuit); err != nil {
347 v, err := GUI.View("logs")
351 slog.SetDefault(slog.New(slog.NewTextHandler(v, nil)))
354 time.Sleep(vors.ScreenRefresh)
355 GUI.Update(func(gui *gocui.Gui) error {
364 buf := make([]byte, 2*vors.FrameLen)
366 var from *net.UDPAddr
370 var ciph *chacha20.Cipher
372 var mac *poly1305.MAC
373 tag := make([]byte, poly1305.TagSize)
374 nonce := make([]byte, 12)
376 n, from, err = lnUDP.ReadFromUDP(buf)
378 log.Fatalln("recvfrom:", err)
381 if n == vors.CookieLen {
382 var cookie vors.Cookie
384 if c, ok := Cookies[cookie]; ok {
388 slog.Info("unknown cookie", "cookie", cookie)
396 slog.Info("unknown", "sid", sid, "from", from)
400 if from.Port != peer.addr.Port || !from.IP.Equal(peer.addr.IP) {
401 slog.Info("wrong addr",
409 peer.stats.bytesRx += vors.IPHdrLen(from.IP) + 8 + uint64(n)
413 if n <= 4+vors.TagLen {
418 copy(nonce[len(nonce)-4:], buf)
419 ciph, err = chacha20.NewUnauthenticatedCipher(peer.key, nonce)
424 ciph.XORKeyStream(macKey[:], macKey[:])
426 mac = poly1305.New(&macKey)
427 if _, err = mac.Write(buf[4 : n-vors.TagLen]); err != nil {
431 if subtle.ConstantTimeCompare(
433 buf[n-vors.TagLen:n],
439 peer.stats.last = time.Now()
440 for _, p := range peer.room.peers {
445 p.stats.bytesTx += vors.IPHdrLen(p.addr.IP) + 8 + uint64(n)
446 if _, err = lnUDP.WriteToUDP(buf[:n], p.addr); err != nil {
447 slog.Warn("sendto", "peer", peer.name, "err", err)
455 slog.Info("listening", "bind", *bind, "pub", hex.EncodeToString(Pub))
457 conn, err := lnTCP.AcceptTCP()
459 log.Fatalln("accept:", err)
466 <-make(chan struct{})
469 if err != nil && err != gocui.ErrQuit {