// decodeSecureBlock handles the secure login block and the login response (via doLogin)
func (svc *GameService) decodeSecureBlock(client player.Player) error {
rsaBlock := encoding.RSABlock{&game_protocol.InboundSecureLoginBlock{}}
rsaArgs := encoding.RSADecodeArgs{
Key: svc.key,
BlockSize: client.SecureBlockSize(),
}
if err := rsaBlock.Decode(client.Conn().ReadBuffer, rsaArgs); err != nil {
return err
}
secureBlock := rsaBlock.Codable.(*game_protocol.InboundSecureLoginBlock)
// Seed the RNGs
inSeed := make([]uint32, 4)
outSeed := make([]uint32, 4)
for i := range inSeed {
inSeed[i] = uint32(secureBlock.ISAACSeed[i])
outSeed[i] = uint32(secureBlock.ISAACSeed[i]) + 50
}
client.InitISAAC(inSeed, outSeed)
username := string(secureBlock.Username)
password := string(secureBlock.Password)
password = auth.HashPassword(password)
return svc.doLogin(client, username, password)
}
// doLogin authenticates the user, sends the login response, and sets up the client for standard packet processing
func (svc *GameService) doLogin(client player.Player, username, password string) error {
profile, responseCode := svc.auth.LookupProfile(username, password)
if responseCode != auth.AuthOkay {
client.Conn().Write <- &game_protocol.OutboundLoginResponseUnsuccessful{
Response: encoding.Uint8(responseCode),
}
client.Conn().Disconnect()
return nil
}
client.SetProfile(profile.(player.Profile))
// Successful login, do all the stuff
client.Conn().Write <- &game_protocol.OutboundLoginResponse{
Response: encoding.Uint8(responseCode),
Rights: encoding.Uint8(client.Profile().Rights()),
Flagged: 0,
}
client.SetDecodeFunc(svc.decodePacket)
go svc.packetConsumer(client)
game_event.PlayerLogin.NotifyObservers(client)
client.LoadProfile()
game_event.PlayerFinishLogin.NotifyObservers(client)
go func() {
client.Conn().WaitForDisconnect()
game_event.PlayerLogout.NotifyObservers(client)
}()
return nil
}
// packetConsumer is the goroutine which picks packets from the readQueue and does something with them
func (svc *GameService) packetConsumer(client player.Player) {
L:
for {
select {
case <-client.Conn().DisconnectChan:
break L
case pkt := <-client.Conn().Read:
if _, ok := pkt.(*game_protocol.UnknownPacket); ok {
/* unknown packet; dump to the log */
client.Log().Debug("Got unknown packet: %v", pkt)
continue
}
packet.Dispatch(client, pkt)
}
}
}
// decodeLoginBlock handles the unencrypted login block
func (svc *GameService) decodeLoginBlock(client player.Player) error {
loginBlock := game_protocol.InboundLoginBlock{}
if err := loginBlock.Decode(client.Conn().ReadBuffer, nil); err != nil {
return err
}
expectedSecureBlockSize := int(loginBlock.LoginLen) - ((9 * 4) + 1 + 1 + 1 + 2)
if expectedSecureBlockSize != int(loginBlock.SecureBlockSize) {
client.Log().Error("Secure block size mismatch: got %v expected %v", loginBlock.SecureBlockSize, expectedSecureBlockSize)
client.Conn().Disconnect()
}
client.SetSecureBlockSize(int(loginBlock.SecureBlockSize))
client.SetDecodeFunc(svc.decodeSecureBlock)
return nil
}
// handshake performs the isaac key exchange
func (svc *GameService) handshake(client player.Player) error {
serverSeed := client.ServerISAACSeed()
handshake := protocol.InboundGameHandshake{}
if err := handshake.Decode(client.Conn().ReadBuffer, nil); err != nil {
return err
}
client.Conn().Write <- &protocol.OutboundGameHandshake{
ServerISAACSeed: [2]encoding.Uint32{
encoding.Uint32(serverSeed[0]), encoding.Uint32(serverSeed[1]),
},
}
client.SetDecodeFunc(svc.decodeLoginBlock)
return nil
}
// decodePacket decodes from the readBuffer using the ISAAC rand generator
func (svc *GameService) decodePacket(client player.Player) error {
b := client.Conn().ReadBuffer
data, err := b.Peek(1)
if err != nil {
return err
}
idByte := int(data[0])
rand := client.ISAACIn().Rand()
realId := uint8(uint32(idByte) - rand)
packet, err := game_protocol.NewInboundPacket(int(realId))
if err != nil {
return fmt.Errorf("%v: packet %v", err, realId)
}
err = packet.Decode(b, rand)
if err != nil {
return err
}
if !client.Conn().IsDisconnecting() {
client.Conn().Read <- packet
}
return nil
}