mirrors_public/schollz_croc
0
0
Fork 0
mirror of https://github.com/schollz/croc.git synced 2025-10-11 13:21:00 +02:00
Code Activity

fix

Browse source
This commit is contained in:
Zack Scholl 2021-04-16 14:01:48 -07:00
parent 8250a39534
commit b0693751c1
3 changed files with 54 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

2
go.mod
View file

@ -16,7 +16,7 @@ require (
github.com/schollz/logger v1.2.0 github.com/schollz/logger v1.2.0
github.com/schollz/mnemonicode v1.0.1 github.com/schollz/mnemonicode v1.0.1
github.com/schollz/pake/v2 v2.0.7 github.com/schollz/pake/v2 v2.0.7
github.com/schollz/pake3 v0.0.0-00010101000000-000000000000 // indirect github.com/schollz/pake3 v0.0.0-00010101000000-000000000000
github.com/schollz/peerdiscovery v1.6.3 github.com/schollz/peerdiscovery v1.6.3
github.com/schollz/progressbar/v3 v3.7.6 github.com/schollz/progressbar/v3 v3.7.6
github.com/spaolacci/murmur3 v1.1.0 // indirect github.com/spaolacci/murmur3 v1.1.0 // indirect

110
src/croc/croc.go
View file

@ -165,9 +165,9 @@ func New(ops Options) (c *Client, err error) {
// initialize pake // initialize pake
if c.Options.IsSender { if c.Options.IsSender {
c.Pake, err = pake.InitCurve([]byte(c.Options.SharedSecret[5:]), 1, "siec", 1*time.Microsecond) c.Pake, err = pake.InitCurve([]byte(c.Options.SharedSecret[5:]), 1, "siec")
} else { } else {
c.Pake, err = pake.InitCurve([]byte(c.Options.SharedSecret[5:]), 0, "siec", 1*time.Microsecond) c.Pake, err = pake.InitCurve([]byte(c.Options.SharedSecret[5:]), 0, "siec")
} }
if err != nil { if err != nil {
return return
@ -816,80 +816,72 @@ func (c *Client) processMessageFileInfo(m message.Message) (done bool, err error
func (c *Client) procesMessagePake(m message.Message) (err error) { func (c *Client) procesMessagePake(m message.Message) (err error) {
log.Debug("received pake payload") log.Debug("received pake payload")
// if // c.spinner.Suffix != " performing PAKE..." {
// // c.spinner.Stop()
// // c.spinner.Suffix = " performing PAKE..."
// // c.spinner.Start()
// }
notVerified := !c.Pake.IsVerified()
err = c.Pake.Update(m.Bytes) err = c.Pake.Update(m.Bytes)
if err != nil { if err != nil {
return return
} }
if (notVerified && c.Pake.IsVerified() && !c.Options.IsSender) || !c.Pake.IsVerified() { if c.Options.IsSender {
err = message.Send(c.conn[0], c.Key, message.Message{ err = message.Send(c.conn[0], c.Key, message.Message{
Type: "pake", Type: "pake",
Bytes: c.Pake.Bytes(), Bytes: c.Pake.Bytes(),
}) })
} } else {
if c.Pake.IsVerified() { log.Debug("generating salt")
if c.Options.IsSender { salt := make([]byte, 8)
log.Debug("generating salt") if _, rerr := rand.Read(salt); err != nil {
salt := make([]byte, 8) log.Errorf("can't generate random numbers: %v", rerr)
if _, rerr := rand.Read(salt); err != nil { return
log.Errorf("can't generate random numbers: %v", rerr)
return
}
err = message.Send(c.conn[0], c.Key, message.Message{
Type: "salt",
Bytes: salt,
})
if err != nil {
return
}
} }
err = message.Send(c.conn[0], c.Key, message.Message{
Type: "salt",
Bytes: salt,
})
if err != nil {
return
}
}
// connects to the other ports of the server for transfer // connects to the other ports of the server for transfer
var wg sync.WaitGroup var wg sync.WaitGroup
wg.Add(len(c.Options.RelayPorts)) wg.Add(len(c.Options.RelayPorts))
for i := 0; i < len(c.Options.RelayPorts); i++ { for i := 0; i < len(c.Options.RelayPorts); i++ {
log.Debugf("port: [%s]", c.Options.RelayPorts[i]) log.Debugf("port: [%s]", c.Options.RelayPorts[i])
go func(j int) { go func(j int) {
defer wg.Done() defer wg.Done()
var host string var host string
if c.Options.RelayAddress == "localhost" { if c.Options.RelayAddress == "localhost" {
host = c.Options.RelayAddress host = c.Options.RelayAddress
} else { } else {
host, _, err = net.SplitHostPort(c.Options.RelayAddress) host, _, err = net.SplitHostPort(c.Options.RelayAddress)
if err != nil {
log.Errorf("bad relay address %s", c.Options.RelayAddress)
return
}
}
server := net.JoinHostPort(host, c.Options.RelayPorts[j])
log.Debugf("connecting to %s", server)
c.conn[j+1], _, _, err = tcp.ConnectToTCPServer(
server,
c.Options.RelayPassword,
fmt.Sprintf("%s-%d", utils.SHA256(c.Options.SharedSecret[:5])[:6], j),
)
if err != nil { if err != nil {
panic(err) log.Errorf("bad relay address %s", c.Options.RelayAddress)
return
} }
log.Debugf("connected to %s", server) }
if !c.Options.IsSender { server := net.JoinHostPort(host, c.Options.RelayPorts[j])
go c.receiveData(j) log.Debugf("connecting to %s", server)
} c.conn[j+1], _, _, err = tcp.ConnectToTCPServer(
}(i) server,
} c.Options.RelayPassword,
wg.Wait() fmt.Sprintf("%s-%d", utils.SHA256(c.Options.SharedSecret[:5])[:6], j),
)
if err != nil {
panic(err)
}
log.Debugf("connected to %s", server)
if !c.Options.IsSender {
go c.receiveData(j)
}
}(i)
} }
wg.Wait()
return return
} }
func (c *Client) processMessageSalt(m message.Message) (done bool, err error) { func (c *Client) processMessageSalt(m message.Message) (done bool, err error) {
log.Debug("received salt") log.Debug("received salt")
if !c.Options.IsSender { if c.Options.IsSender {
log.Debug("sending salt back") log.Debug("sending salt back")
err = message.Send(c.conn[0], c.Key, message.Message{ err = message.Send(c.conn[0], c.Key, message.Message{
Type: "salt", Type: "salt",
@ -899,7 +891,7 @@ func (c *Client) processMessageSalt(m message.Message) (done bool, err error) {
return true, err return true, err
} }
} }
log.Debugf("session key is verified, generating encryption with salt: %x", m.Bytes) log.Debugf("generating encryption with salt: %x", m.Bytes)
key, err := c.Pake.SessionKey() key, err := c.Pake.SessionKey()
if err != nil { if err != nil {
return true, err return true, err

16
src/tcp/tcp.go
View file

@ -152,7 +152,7 @@ var weakKey = []byte{1, 2, 3}
func (s *server) clientCommunication(port string, c *comm.Comm) (room string, err error) { func (s *server) clientCommunication(port string, c *comm.Comm) (room string, err error) {
// establish secure password with PAKE for communication with relay // establish secure password with PAKE for communication with relay
B, err := pake.InitCurve(weakKey, 1, "siec", 1*time.Microsecond) B, err := pake.InitCurve(weakKey, 1, "siec")
if err != nil { if err != nil {
return return
} }
@ -173,14 +173,6 @@ func (s *server) clientCommunication(port string, c *comm.Comm) (room string, er
if err != nil { if err != nil {
return return
} }
Abytes, err = c.Receive()
if err != nil {
return
}
err = B.Update(Abytes)
if err != nil {
return
}
strongKey, err := B.SessionKey() strongKey, err := B.SessionKey()
if err != nil { if err != nil {
return return
@ -425,7 +417,7 @@ func ConnectToTCPServer(address, password, room string, timelimit ...time.Durati
} }
// get PAKE connection with server to establish strong key to transfer info // get PAKE connection with server to establish strong key to transfer info
A, err := pake.InitCurve(weakKey, 0, "siec", 1*time.Microsecond) A, err := pake.InitCurve(weakKey, 0, "siec")
if err != nil { if err != nil {
return return
} }
@ -441,10 +433,6 @@ func ConnectToTCPServer(address, password, room string, timelimit ...time.Durati
if err != nil { if err != nil {
return return
} }
err = c.Send(A.Bytes())
if err != nil {
return
}
strongKey, err := A.SessionKey() strongKey, err := A.SessionKey()
if err != nil { if err != nil {
return return