Beiträge von Razer

.bg-hbox {
	-fx-background-color: #3A73BF;
}


.choicebox {
	-fx-pref-width: 300;
	-fx-pref-height: 30;
}


.logoText {
	-fx-font-family: Roboto;
	-fx-font-weight: 400;
	-fx-font-size: 25;
	-fx-font-style: none;
}


.btn {
	-fx-pref-width: 300;
	-fx-pref-height: 50;
	-fx-background-color: #3A73BF;

	-fx-font-family: Open-Sans;
	-fx-font-weight: 300;
	-fx-font-size: 18;
	-fx-font-style: none;
	-fx-text-fill: #FFF;
}


.btn:hover, :focus, :active {
	-fx-background-color: #366CB2;
}

package com.steekarlkani.dakine.networking;


import java.util.logging.Level;
import java.util.logging.Logger;


import com.steekarlkani.dakine.communication.encryption.HabboEncryption;


import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.bytes.ByteArrayEncoder;


public class DakineServer implements Runnable {
	private Logger dakineLogger = Logger.getLogger(DakineServer.class.getName());


	@Override
	public void run() {
		// TODO Auto-generated method stub		
		// netty scheduling here 
		HabboEncryption.initialize();
		EventLoopGroup canBoss = new NioEventLoopGroup();
		EventLoopGroup steeBoss = new NioEventLoopGroup();
		try {
			ServerBootstrap dakineSocket = new ServerBootstrap();
			dakineSocket.group(canBoss, steeBoss)
			.channel(NioServerSocketChannel.class)
			.childHandler(new ChannelInitializer<SocketChannel>() {
				protected void initChannel(SocketChannel channel) throws Exception {
					// TODO Auto-generated method stub
					channel.pipeline().addLast(new DakineServerHandler());
				}				
			})
			.option(ChannelOption.SO_BACKLOG, 128)
			.childOption(ChannelOption.SO_KEEPALIVE, true);
			ChannelFuture bossFuture = dakineSocket.bind(1232).sync();
			bossFuture.channel().closeFuture().sync();
		}catch(Exception ex){
			dakineLogger.log(Level.INFO, "[ÏNFO] > Eine Exception wurde ausgelösst " + ex.getMessage() + "");
		}
	}
}

package com.steekarlkani.dakine.networking;


import java.util.logging.Level;
import java.util.logging.Logger;


import com.steekarlkani.dakine.communication.ClientRequest;
import com.steekarlkani.dakine.communication.encryption.rc4.ARC4;
import com.steekarlkani.dakine.communication.messages.ClientMessage;


import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandler;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;


public class DakineServerHandler extends ChannelInboundHandlerAdapter {
	private Logger dakineLogger = Logger.getLogger(DakineServerHandler.class.getName());
	private ClientRequest packetRequest;
	private ClientMessage packetMessage;
	private ChannelHandlerContext dakineChannel;
	private ARC4 rc4Decipher;
	public void channelActive(ChannelHandlerContext ctx){ 
       if(ctx != null){
    	   this.dakineChannel = ctx;
    	   this.dakineLogger.log(Level.INFO, "[DAKINE-EMULATION] > [INFO] Neue Verbindung von " + this.dakineChannel.channel().remoteAddress() + "");
       }else{
    	   this.dakineLogger.log(Level.INFO, "[DAKINE-EMULATION] > [INFO] Verbindung geschlossen von " + this.dakineChannel.channel().remoteAddress() + "");
       }
    }
	public void channelRead(ChannelHandlerContext ctx, Object msg){
	    ByteBuf decoder = (ByteBuf) msg;
	    try {
	    	 if(decoder.readableBytes() < 6) return; 
	         if(decoder.getByte(0) == 60){
	        	 decoder.discardReadBytes();
	        	 String crossdomain = "<?xml version=\"1.0\"?>\r\n"
								+ "<!DOCTYPE cross-domain-policy SYSTEM \"/xml/dtds/cross-domain-policy.dtd\">\r\n"
								+ "<cross-domain-policy>\r\n"
								+ "<allow-access-from domain=\"*\" to-ports=\"*\" />\r\n"
								+ "</cross-domain-policy>\0";
	        	 ctx.channel().writeAndFlush(Unpooled.wrappedBuffer(crossdomain.getBytes()));
	         }else{
	        	 if(rc4Decipher != null){
	        		 decoder = rc4Decipher.decipher(decoder); // decrypt rc4 Data
	        		 handlePackets(decoder, ctx);
	        	 }else{
	        		 handlePackets(decoder, ctx);
	        	 }
	         }
	    }catch(Exception ex){
	    	ex.printStackTrace();
	    	dakineLogger.log(Level.INFO, "[ÏNFO] > Eine Exception wurde ausgelösst " + ex.getMessage() + "");
	    }
	}
    private void handlePackets(ByteBuf decoder, ChannelHandlerContext ctx) {
		// TODO Auto-generated method stub
    	while(decoder.readableBytes() != 0){
   		 	int packetLength = decoder.readInt();
   		 	ByteBuf newBuffer = decoder.readBytes(packetLength);
   		 	short packetHeader = newBuffer.readShort();
   		 	packetMessage = new ClientMessage(newBuffer);
   		 	packetRequest = new ClientRequest();
   		 	if(packetRequest.packetRegistered(packetHeader)){
   		 		String packetName = packetRequest.getPacket(packetHeader).getClass().getSimpleName();
   		 		dakineLogger.log(Level.INFO, "[DAKINE-EMULATION] > [HANDLED] > Packet ["+packetName+"]");
   		 		packetRequest.getPacket(packetHeader).parse(this, packetHeader);
   		 	}else{
				dakineLogger.log(Level.INFO, "[DAKINE-EMULATION] > [UNHANDLED] Packet ["+packetHeader+"]");
   		 	}
    	}
    }
    public void setRC4(byte[] publicKey){
    	rc4Decipher = new ARC4();
    	rc4Decipher.init(publicKey);
    }


    public ClientMessage getMessage(){
    	return packetMessage;
    }
    public Channel getChannel(){
    	return dakineChannel.channel();
    }
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause){
        cause.printStackTrace();
        ctx.close();
    }
}

package com.steekarlkani.dakine.communication.messages;


import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;


public class ServerMessage {
	private int serverPacket;
	private ByteBuf buffer;
	public ServerMessage(int packet){
		serverPacket = packet;
		buffer = Unpooled.buffer(100);
		buffer.writeInt(0);
		buffer.writeShort(serverPacket);
	}
	public void writeBoolean(boolean b){
        buffer.writeByte(b ? 1 : 0);
    }


    public void writeInt(int i){
        buffer.writeInt(i);
    }


	public void writeString(String s){
		if(s == null){
			s = "";
		}
		byte[] dat = s.getBytes();
		buffer.writeShort(dat.length);
		buffer.writeBytes(dat);
	}
	public ByteBuf getBuffer(){
		buffer.setInt(0, buffer.writerIndex() - 4);
		return buffer;
	}
}

package com.steekarlkani.dakine.communication;


import java.util.HashMap;


import com.steekarlkani.dakine.communication.packets.incoming.hanshake.GenerateSecretKeyMessageEvent;
import com.steekarlkani.dakine.communication.packets.incoming.hanshake.InfoMessageEvent;
import com.steekarlkani.dakine.communication.packets.incoming.hanshake.InitCryptoMessageEvent;
import com.steekarlkani.dakine.communication.packets.incoming.hanshake.SSOLoginMessageEvent;
import com.steekarlkani.dakine.communication.packets.incoming.hanshake.UniqueIDMessageEvent;
import com.steekarlkani.dakine.communication.packets.incoming.hanshake.VersionCheckMessageEvent;


public class ClientRequest {	
	private HashMap<Short, ClientEvent> clientRequest;
	public ClientRequest(){
		this.clientRequest = new HashMap<Short, ClientEvent>();
		this.registerHandshake();
	}
	private void registerHandshake(){
		// handshake 
		this.clientRequest.put((short)4000, new VersionCheckMessageEvent());
		this.clientRequest.put((short)316, new InitCryptoMessageEvent());
		this.clientRequest.put((short)3847, new GenerateSecretKeyMessageEvent());
		this.clientRequest.put((short)1600, new InfoMessageEvent());
		this.clientRequest.put((short)1471, new UniqueIDMessageEvent());
		this.clientRequest.put((short)1778, new SSOLoginMessageEvent());
	}
	public boolean packetRegistered(short packetHeader){
		return this.clientRequest.containsKey(packetHeader);
	}


	public ClientEvent getPacket(short packetHeader){
		return this.clientRequest.get(packetHeader);
	}
}