Pablu/Uftp
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New Project Structure - Encryption From and to Server

Browse Source
This commit is contained in:
Pablu23
2023-11-11 00:09:11 +01:00
parent 82ca232d61
commit 2c83751574
14 changed files with 396 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

211
internal/client/client.go Normal file
View File

@@ -0,0 +1,211 @@
package client
import (
"common"
"crypto/rand"
"encoding/hex"
"fmt"
"net"
"os"
"sort"
"time"
)
func SendPacket(pck *common.Packet, key [32]byte, conn *net.UDPConn) {
secPck := common.NewSymetricSecurePacket(key, pck)
if _, err := conn.Write(secPck.ToBytes()); err != nil {
panic(err)
}
}
func ReceivePacket(key [32]byte, conn *net.UDPConn) common.Packet {
bytes := make([]byte, common.PacketSize+common.SecureHeaderSize)
_, _, err := conn.ReadFrom(bytes)
if err != nil {
panic(err)
}
secPck := common.SecurePacketFromBytes(bytes)
pck, err := secPck.ExtractPacket(key)
if err != nil {
panic(err)
}
fmt.Printf("Decrypted Packet, Sync: %v, Type: %v\n", pck.Sync, pck.Flag)
return pck
}
func ReceivePacketWithTimeout(key [32]byte, conn *net.UDPConn) (common.Packet, bool) {
conn.SetReadDeadline(time.Now().Add(10 * time.Second))
bytes := make([]byte, common.PacketSize)
_, _, err := conn.ReadFrom(bytes)
if err != nil {
if e, ok := err.(net.Error); !ok || !e.Timeout() {
// If it's not a timeout, log the error as usual
panic(err)
}
return common.Packet{}, false
}
secPck := common.SecurePacketFromBytes(bytes)
pck, err := secPck.ExtractPacket(key)
if err != nil {
panic(err)
}
return pck, true
}
func GetFile(path string) {
request := common.NewRequest(path)
k := make([]byte, 32)
_, err := rand.Read(k)
if err != nil {
panic(err)
}
key := [32]byte(k)
keyExchangePck := common.NewRsaPacket(request.Sid, key)
udpAddr, err := net.ResolveUDPAddr("udp", "0.0.0.0:13374")
// udpAddr, err := net.ResolveUDPAddr("udp", "192.168.2.145:13374")
if err != nil {
fmt.Println(err)
os.Exit(1)
}
// Dial to the address with UDP
conn, err := net.DialUDP("udp", nil, udpAddr)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
_, err = conn.Write(keyExchangePck.ToBytes())
if err != nil {
panic(err)
}
SendPacket(request, key, conn)
file, err := os.Create("out/" + hex.EncodeToString(request.Sid[:]) + ".recv")
if err != nil {
panic(err)
}
pck := ReceivePacket(key, conn)
if pck.Flag != common.PTE {
panic("Header flag was supposed to be PTE")
}
size, err := pck.GetUint32Payload()
if err != nil {
panic(err)
}
file.Truncate(int64(size))
ackPck := common.NewAck(&pck)
SendPacket(ackPck, key, conn)
recvPackets := make([]uint32, 0)
var endPacket common.Packet
for {
pck := ReceivePacket(key, conn)
if pck.Flag == common.End {
endPacket = pck
break
}
if pck.Flag != common.File {
fmt.Printf("Received %v Packet, but expected File Packet\n", pck.Flag)
continue
}
recvPackets = append(recvPackets, pck.Sync)
offset := (int64(pck.Sync) - int64(ackPck.Sync+1)) * (common.PacketSize - int64(common.HeaderSize))
// fmt.Printf("Sync: %v, Offset: %v\n", pck.Sync, offset)
_, err = file.WriteAt(pck.Data, offset)
if err != nil {
panic(err)
}
}
sort.Slice(recvPackets, func(i, j int) bool {
pckI := recvPackets[i]
pckJ := recvPackets[j]
return pckI < pckJ
})
lostPackets := make([]uint32, 0)
for i := ackPck.Sync + 1; i < endPacket.Sync; i++ {
if b, _ := contains(recvPackets, i); !b {
lostPackets = append(lostPackets, i)
}
}
for _, i := range lostPackets {
fmt.Println(i)
}
lastPacket := ackPck
for {
if len(lostPackets) == 0 {
break
}
for _, sync := range lostPackets {
fmt.Printf("Request resend for %v\n", sync)
resend := common.NewResend(uint32(sync), lastPacket)
SendPacket(resend, key, conn)
lastPacket = resend
pck, received := ReceivePacketWithTimeout(key, conn)
if !received {
continue
}
offset := (int64(pck.Sync) - int64(ackPck.Sync+1)) * (common.PacketSize - int64(common.HeaderSize))
// fmt.Printf("Sync: %v, Offset: %v\n", pck.sync, offset)
_, err = file.WriteAt(pck.Data, offset)
if err != nil {
panic(err)
}
_, index := contains(lostPackets, pck.Sync)
fmt.Printf("Removing sync %v from LostPackets\n", pck.Sync)
lostPackets = remove(lostPackets, index)
}
}
ack := common.NewAck(&endPacket)
SendPacket(ack, key, conn)
}
func remove(s []uint32, i int) []uint32 {
s[i] = s[len(s)-1]
return s[:len(s)-1]
}
func contains(s []uint32, e uint32) (bool, int) {
for i, a := range s {
if a == e {
return true, i
}
}
return false, 0
}

3
internal/client/go.mod Normal file
View File

@@ -0,0 +1,3 @@
module client
go 1.21.1

7
internal/common/go.mod Normal file
View File

@@ -0,0 +1,7 @@
module common
go 1.21.1
require golang.org/x/crypto v0.15.0
require golang.org/x/sys v0.14.0 // indirect

4
internal/common/go.sum Normal file
View File

@@ -0,0 +1,4 @@
golang.org/x/crypto v0.15.0 h1:frVn1TEaCEaZcn3Tmd7Y2b5KKPaZ+I32Q2OA3kYp5TA=
golang.org/x/crypto v0.15.0/go.mod h1:4ChreQoLWfG3xLDer1WdlH5NdlQ3+mwnQq1YTKY+72g=
golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=
golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

251
internal/common/packets.go Normal file
View File

@@ -0,0 +1,251 @@
package common
import (
"crypto/rand"
"encoding/binary"
"errors"
"fmt"
"golang.org/x/crypto/chacha20poly1305"
)
const PacketSize = 504
const HeaderSize int = 32 + 1 + 4 + 4
const SecureHeaderSize int = 1 + 42 + 32 + 4
type SessionID [32]byte
type SecurePacket struct {
IsRsa byte // 0 = false everything else is true
Nonce [24]byte
Sid SessionID
DataLength uint32
EncryptedData []byte
}
type Packet struct {
// headerLength uint32
Sid SessionID
Flag HeaderFlag
Sync uint32
DataLength uint32
Data []byte
}
func NewSymetricSecurePacket(key [32]byte, pck *Packet) *SecurePacket {
sid := pck.Sid
data := pck.ToBytes()
aead, err := chacha20poly1305.NewX(key[:])
if err != nil {
panic(err)
}
nonce := make([]byte, 24)
if _, err = rand.Read(nonce); err != nil {
panic(err)
}
encrypted := make([]byte, len(data)+aead.Overhead())
encrypted = aead.Seal(nil, nonce, data, nil)
return &SecurePacket{
IsRsa: 0,
Nonce: [24]byte(nonce),
Sid: sid,
DataLength: uint32(len(encrypted)),
EncryptedData: encrypted,
}
}
func SecurePacketFromBytes(bytes []byte) SecurePacket {
isRsa := bytes[0]
nonce := bytes[1:25]
sid := SessionID(bytes[25:57])
length := binary.LittleEndian.Uint32(bytes[57:61])
enc := bytes[61 : 61+length]
return SecurePacket{
IsRsa: isRsa,
Nonce: [24]byte(nonce),
Sid: sid,
DataLength: length,
EncryptedData: enc,
}
}
func (secPck *SecurePacket) ToBytes() []byte {
arr := make([]byte, SecureHeaderSize+len(secPck.EncryptedData))
arr[0] = secPck.IsRsa
copy(arr[1:25], secPck.Nonce[:])
copy(arr[25:57], secPck.Sid[:])
binary.LittleEndian.PutUint32(arr[57:61], secPck.DataLength)
copy(arr[61:], secPck.EncryptedData)
return arr
}
func (secPck *SecurePacket) ExtractPacket(key [32]byte) (Packet, error) {
aead, err := chacha20poly1305.NewX(key[:])
if err != nil {
panic(err)
}
data, err := aead.Open(nil, secPck.Nonce[:], secPck.EncryptedData, nil)
if err != nil {
return Packet{}, err
}
// fmt.Println(data)
packet := PacketFromBytes(data)
return packet, nil
}
func NewRsaPacket(sid SessionID, key [32]byte) *SecurePacket {
return &SecurePacket{
IsRsa: 1,
Nonce: [24]byte(make([]byte, 24)),
Sid: sid,
EncryptedData: key[:],
}
}
func (secPck *SecurePacket) ExtractKey( /*RSA HERE LATER*/ ) []byte {
return secPck.EncryptedData[:32]
}
func PacketFromBytes(bytes []byte) Packet {
flag := HeaderFlag(bytes[0])
sid := SessionID(bytes[1:33])
sync := binary.LittleEndian.Uint32(bytes[33:37])
dataLength := binary.LittleEndian.Uint32(bytes[37:41])
pck := Packet{
Sid: sid,
Flag: flag,
Sync: sync,
DataLength: dataLength,
Data: bytes[HeaderSize : HeaderSize+int(dataLength)],
}
return pck
}
func NewAck(pckToAck *Packet) *Packet {
data := make([]byte, 4)
binary.LittleEndian.PutUint32(data, pckToAck.Sync)
return &Packet{
Sid: pckToAck.Sid,
Flag: Ack,
Sync: pckToAck.Sync + 1,
DataLength: uint32(4),
Data: data,
}
}
func NewRequest(path string) *Packet {
data := []byte(path)
buf := make([]byte, 32)
_, err := rand.Read(buf)
if err != nil {
panic(err)
}
return &Packet{
Sid: SessionID(buf),
Flag: Request,
Sync: 0,
DataLength: uint32(len(data)),
Data: data,
}
}
func (pck *Packet) GetUint32Payload() (uint32, error) {
flag := pck.Flag
if flag != PTE && flag != Ack && flag != End && flag != Resend {
return 0, errors.New(fmt.Sprintf("Can not get Sync from Packet Type with flag: %v", flag))
}
return binary.LittleEndian.Uint32(pck.Data), nil
}
func (pck *Packet) GetFilePath() (string, error) {
if pck.Flag != Request {
return "", errors.New("Can not get FilePath from Packet that is not Request")
}
return string(pck.Data), nil
}
func NewResendFile(resendPck *Packet, data []byte) *Packet {
sync, _ := resendPck.GetUint32Payload()
return &Packet{
Sid: resendPck.Sid,
Flag: File,
Sync: sync,
DataLength: uint32(len(data)),
Data: data,
}
}
func NewFile(lastPck *Packet, data []byte) *Packet {
return &Packet{
Sid: lastPck.Sid,
Flag: File,
Sync: lastPck.Sync + 1,
DataLength: uint32(len(data)),
Data: data,
}
}
func NewEnd(lastFilePck *Packet) *Packet {
data := make([]byte, 4)
binary.LittleEndian.PutUint32(data, lastFilePck.Sync)
return &Packet{
Sid: lastFilePck.Sid,
Flag: End,
Sync: lastFilePck.Sync + 1,
DataLength: uint32(4),
Data: data,
}
}
func NewResend(sync uint32, lastPck *Packet) *Packet {
data := make([]byte, 4)
binary.LittleEndian.PutUint32(data, sync)
return &Packet{
Sid: lastPck.Sid,
Flag: Resend,
Sync: lastPck.Sync + 1,
DataLength: uint32(4),
Data: data,
}
}
func NewPte(fileSize uint32, lastPck *Packet) *Packet {
data := make([]byte, 4)
binary.LittleEndian.PutUint32(data, fileSize)
return &Packet{
Sid: lastPck.Sid,
Flag: PTE,
Sync: lastPck.Sync + 1,
DataLength: uint32(4),
Data: data,
}
}
func (pck *Packet) ToBytes() []byte {
arr := make([]byte, HeaderSize+int(pck.DataLength))
arr[0] = byte(pck.Flag)
copy(arr[1:33], pck.Sid[:])
binary.LittleEndian.PutUint32(arr[33:37], pck.Sync)
binary.LittleEndian.PutUint32(arr[37:41], pck.DataLength)
copy(arr[41:], pck.Data)
return arr
}
type HeaderFlag uint8
const (
Request HeaderFlag = iota
PTE HeaderFlag = iota
Ack HeaderFlag = iota
File HeaderFlag = iota
End HeaderFlag = iota
Resend HeaderFlag = iota
)

3
internal/server/go.mod Normal file
View File

@@ -0,0 +1,3 @@
module server
go 1.21.1

203
internal/server/server.go Normal file
View File

@@ -0,0 +1,203 @@
package server
import (
"common"
"crypto/rand"
"crypto/rsa"
"encoding/hex"
"errors"
"fmt"
"io"
"net"
"os"
)
type info struct {
path string
lastSync uint32
lastPckSend common.HeaderFlag
key [32]byte
}
type Server struct {
sessions map[common.SessionID]*info
rsa *rsa.PrivateKey
}
func New() (*Server, error) {
key, err := rsa.GenerateKey(rand.Reader, 4096)
if err != nil {
return nil, err
}
return &Server{
sessions: make(map[common.SessionID]*info),
rsa: key,
}, nil
}
func (server *Server) sendPacket(conn *net.UDPConn, addr *net.UDPAddr, pck *common.Packet) {
key := server.sessions[pck.Sid].key
fmt.Printf("Sending Packet, Sync: %v, Type: %v\n", pck.Sync, pck.Flag)
secPck := common.NewSymetricSecurePacket(key, pck)
if _, err := conn.WriteToUDP(secPck.ToBytes(), addr); err != nil {
panic(err)
}
conn.WriteToUDP(secPck.ToBytes(), addr)
}
func (server *Server) handlePacket(conn *net.UDPConn, addr *net.UDPAddr, rPacket *common.Packet) {
switch rPacket.Flag {
case common.Request:
server.sendPTE(conn, addr, rPacket)
break
case common.Ack:
server.handleAck(conn, addr, rPacket)
break
case common.Resend:
server.resend(conn, addr, rPacket)
}
}
func (server *Server) resend(conn *net.UDPConn, addr *net.UDPAddr, pck *common.Packet) {
resend, err := pck.GetUint32Payload()
if err != nil {
panic(err)
}
path := server.sessions[pck.Sid].path
file, err := os.Open(path)
if err != nil {
panic(err)
}
defer file.Close()
// This should be different
offset := (int64(resend) - 3) * (common.PacketSize - int64(common.HeaderSize))
buf := make([]byte, common.PacketSize-common.HeaderSize)
_, err = file.ReadAt(buf, offset)
if err != nil && !errors.Is(err, io.EOF) {
panic(err)
}
resendPck := common.NewResendFile(pck, buf)
server.sendPacket(conn, addr, resendPck)
}
func (server *Server) handleAck(conn *net.UDPConn, addr *net.UDPAddr, pck *common.Packet) {
ack, err := pck.GetUint32Payload()
if err != nil {
panic(err)
}
session := server.sessions[pck.Sid]
if session == nil {
panic(err)
}
if ack != session.lastSync {
fmt.Printf("Wrong Ack %v, expected %v\n", ack, session.lastSync)
return
}
if session.lastPckSend == common.End {
fmt.Printf("Deleting Session %v\n", hex.EncodeToString(pck.Sid[:]))
delete(server.sessions, pck.Sid)
} else {
server.sendData(conn, addr, pck)
}
}
func (server *Server) sendPTE(conn *net.UDPConn, addr *net.UDPAddr, pck *common.Packet) {
path, err := pck.GetFilePath()
if err != nil {
panic(err)
}
fi, err := os.Stat(path)
if err != nil {
panic(err)
}
fileSize := fi.Size()
ptePck := common.NewPte(uint32(fileSize), pck)
server.sendPacket(conn, addr, ptePck)
server.sessions[pck.Sid].path = path
server.sessions[pck.Sid].lastSync = ptePck.Sync
server.sessions[pck.Sid].lastPckSend = ptePck.Flag
}
func (server *Server) sendData(conn *net.UDPConn, addr *net.UDPAddr, pck *common.Packet) {
path := server.sessions[pck.Sid].path
file, err := os.Open(path)
if err != nil {
panic(err)
}
defer file.Close()
buf := make([]byte, common.PacketSize-common.HeaderSize)
filePck := pck
for {
r, err := file.Read(buf)
if err != nil && !errors.Is(err, io.EOF) {
panic(err)
}
if r == 0 {
break
}
filePck = common.NewFile(filePck, buf[:r])
server.sendPacket(conn, addr, filePck)
}
eodPck := common.NewEnd(filePck)
server.sessions[pck.Sid].lastSync = eodPck.Sync
server.sessions[pck.Sid].lastPckSend = eodPck.Flag
server.sendPacket(conn, addr, eodPck)
}
func (server *Server) Serve() {
udpAddr, err := net.ResolveUDPAddr("udp", "0.0.0.0:13374")
if err != nil {
fmt.Println(err)
os.Exit(1)
}
conn, err := net.ListenUDP("udp", udpAddr)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
for {
var buf [common.PacketSize]byte
_, addr, err := conn.ReadFromUDP(buf[0:])
if err != nil {
fmt.Println(err)
return
}
secPck := common.SecurePacketFromBytes(buf[:])
if secPck.IsRsa == 0 {
key := server.sessions[secPck.Sid].key
pck, err := secPck.ExtractPacket(key)
if err != nil {
fmt.Println(err)
}
go server.handlePacket(conn, addr, &pck)
} else {
key := secPck.ExtractKey()
fmt.Printf("Session: %v, Key: %v\n", hex.EncodeToString(secPck.Sid[:]), hex.EncodeToString(key))
server.sessions[secPck.Sid] = &info{
key: [32]byte(key),
}
}
}
}