API tools faq
paste
Advertisement
BeerHuntor

Untitled

BeerHuntor
May 2nd, 2019
278
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 9.69 KB | None | 0 0
raw download clone embed print report
  1. package com.rs2hd.net.codec;
  2.  
  3. //import java.io.FileNotFoundException;
  4. //import java.io.IOException;
  5. //import java.util.LinkedList;
  6. //import java.util.Queue;
  7.  
  8. import org.apache.mina.common.ByteBuffer;
  9. import org.apache.mina.common.IdleStatus;
  10. import org.apache.mina.common.IoFuture;
  11. import org.apache.mina.common.IoFutureListener;
  12. import org.apache.mina.common.IoSession;
  13. import org.apache.mina.filter.codec.CumulativeProtocolDecoder;
  14. import org.apache.mina.filter.codec.ProtocolCodecFilter;
  15. import org.apache.mina.filter.codec.ProtocolDecoderOutput;
  16.  
  17. //import com.grahamedgecombe.rs2.cache.Cache;
  18. import com.rs2hd.Constants;
  19. import com.rs2hd.WorkerThread;
  20. import com.rs2hd.model.PlayerDetails;
  21. import com.rs2hd.net.Packet;
  22. import com.rs2hd.packetbuilder.StaticPacketBuilder;
  23. import com.rs2hd.util.Misc;
  24. import com.rs2hd.util.log.Logger;
  25.  
  26. /**
  27.  * Login protocol decoder.
  28.  * @author Graham
  29.  *
  30.  */
  31. public class RS2LoginProtocolDecoder extends CumulativeProtocolDecoder {
  32.    
  33.     /**
  34.      * Logger instance.
  35.      */
  36.     private Logger logger = Logger.getInstance();
  37.    
  38.     private WorkerThread workerThread;
  39.    
  40.     public RS2LoginProtocolDecoder(WorkerThread workerThread) {
  41.         this.workerThread = workerThread;
  42.     }
  43.    
  44. //  public static Cache CACHE;
  45. //  static {
  46. //      try {
  47. //          CACHE = new Cache("data/cache/");
  48. //      } catch (FileNotFoundException e) {
  49. //          CACHE = null;
  50. //      }
  51. //  }
  52.    
  53. //  private Queue<int[]> requests = new LinkedList<int[]>();
  54.    
  55.     /**
  56.      * Parses the data in the provided byte buffer and writes it to
  57.      * <code>out</code> as a <code>Packet</code>.
  58.      *
  59.      * @param session The IoSession the data was read from
  60.      * @param in      The buffer
  61.      * @param out    The decoder output stream to which to write the <code>Packet</code>
  62.      * @return Whether enough data was available to create a packet
  63.      */
  64.     @Override
  65.     public boolean doDecode(IoSession session, ByteBuffer in, ProtocolDecoderOutput out) {
  66.         try {
  67.             Object loginStageObj = session.getAttribute("LOGIN_STAGE");
  68.             int loginStage = 0;
  69.             if(loginStageObj != null) {
  70.                 loginStage = (Integer)loginStageObj;
  71.             }
  72.             //Logger.log("recv login packet, stage: "+loginStage);
  73.             switch(loginStage) {
  74.             case -2:
  75. //              if(CACHE != null) {
  76. //                  while(session.isConnected() && in.remaining() >= 4) {
  77. //                      int requestType  = in.get()      & 0xFF;
  78. //                      int requestCache = in.get()      & 0xFF;
  79. //                      int requestId    = in.getShort() & 0xFFFF;
  80. //                      switch(requestType) {
  81. //                      case 0:
  82. //                          /*
  83. //                           * Get.
  84. //                           */
  85. //                          requests.add(new int[] { requestType, requestCache, requestId });
  86. //                          break;
  87. //                      case 1:
  88. //                          /*
  89. //                           * Get now.
  90. //                           */
  91. //                          session.write(getFile(requestCache, requestId));
  92. //                          break;
  93. //                      case 3:
  94. //                          /*
  95. //                           * Clear equests.
  96. //                           */
  97. //                          requests.clear();
  98. //                          break;
  99. //                      }
  100. //                      return true;
  101. //                  }
  102. //                  return false;
  103. //              } else {
  104.                     if(8 <= in.remaining()) {
  105.                         for(int i = 0; i < 8; i++) {
  106.                             in.get();
  107.                         }
  108.                         StaticPacketBuilder ukeys = new StaticPacketBuilder();
  109.                         ukeys.setBare(true);
  110.                         for(int key : Constants.UPDATE_KEYS) {
  111.                             ukeys.addByte((byte) key);
  112.                         }
  113.                         session.write(ukeys.toPacket()).addListener(new IoFutureListener() {
  114.                             @Override
  115.                             public void operationComplete(IoFuture arg0) {
  116.                                 arg0.getSession().close();
  117.                             }
  118.                         });
  119.                         return true;
  120.                     }
  121.                     in.rewind();
  122.                     System.out.print("Case switch -2");
  123.                     return false;
  124. //              }
  125.  
  126.             case -1:
  127.                 if(3 <= in.remaining()) {
  128.                     in.get();
  129.                     int clientVersion = in.getShort();
  130.                     if(clientVersion == 508) {
  131.                         StaticPacketBuilder u1Response = new StaticPacketBuilder();
  132.                         u1Response.setBare(true).addByte((byte) 0);
  133.                         session.write(u1Response.toPacket());
  134.                         session.setAttribute("LOGIN_STAGE", -2);
  135.                     } else {
  136.                         StaticPacketBuilder u1Response = new StaticPacketBuilder();
  137.                         u1Response.setBare(true).addByte((byte) 6);
  138.                         session.write(u1Response.toPacket()).addListener(new IoFutureListener() {
  139.                             @Override
  140.                             public void operationComplete(IoFuture arg0) {
  141.                                 arg0.getSession().close();
  142.                             }
  143.                         });
  144.                         session.removeAttribute("LOGIN_STAGE");
  145.                     }
  146.                     return true;
  147.                 }
  148.                 in.rewind();
  149.                 System.out.print("Case number -1");
  150.                 return false;
  151.             case 0: //first login packets
  152.                 if(2 <= in.remaining()) {
  153.                     int protocolId = in.get() & 0xff;
  154.                     int nameHash = in.get() & 0xff;
  155.                     if(protocolId == 15) {
  156.                         session.setAttribute("LOGIN_STAGE", -1);
  157.                     } else {
  158.                         long serverSessionKey = ((long) (java.lang.Math.random() * 99999999D) << 32) + (long) (java.lang.Math.random() * 99999999D);
  159.                         StaticPacketBuilder s1Response = new StaticPacketBuilder();
  160.                         s1Response.setBare(true).addByte((byte) 0).addLong(serverSessionKey);
  161.                         session.setAttribute("SERVER_SESSION_KEY", serverSessionKey);
  162.                         session.write(s1Response.toPacket());
  163.                         session.setAttribute("LOGIN_STAGE", 1);
  164.                         session.setAttribute("NAME_HASH", nameHash);
  165.                         //Logger.log("protocolId="+protocolId+"; namePart="+namePart);
  166.                     }
  167.                     System.out.print("case last");
  168.                     return true;
  169.                 } else {
  170.                     in.rewind();
  171.                     System.out.print("case last else");
  172.                     return false;
  173.                 }
  174.  
  175.             case 1: //here's where we get the username and password
  176.                 @SuppressWarnings("unused")
  177.                 int loginType = -1, loginPacketSize = -1;
  178.                 if(3 <= in.remaining()) {
  179.                     loginType = in.get() & 0xff; //should be 16 or 18
  180.                     loginPacketSize = in.getUnsignedShort();
  181.                     //Logger.log("loginType="+loginType);
  182.                 } else {
  183.                     in.rewind();
  184.                     return false;
  185.                 }
  186.                 if(loginPacketSize <= in.remaining()) {
  187.                     byte[] payload = new byte[loginPacketSize];
  188.                     in.get(payload);
  189.                     Packet p = new Packet(session, -1, payload);
  190.                     @SuppressWarnings("unused")
  191.                     int loginEncryptPacketSize = loginPacketSize - (36 + 1 + 1 + 2); // can't be negative
  192.                     int clientVersion = p.readInt();
  193.                     if(clientVersion != 508) {
  194.                         Logger.getInstance().error("Invalid ver : " + clientVersion);
  195.                         session.close();
  196.                         return true;
  197.                     }
  198.                     @SuppressWarnings("unused")
  199.                     int lowMemoryVersion = p.readByte() & 0xff; // is this still low mem ver?
  200.                     p.readInt();
  201.                     for(int n=0; n<24; n++) {
  202.                         int cacheIDX = p.readByte(); //i don't care personally
  203.                         if(cacheIDX == 0) {
  204.                             // possibly a bot
  205.                             session.close();
  206.                             return true;
  207.                         }
  208.                     }
  209.                     p.readRS2String(); // settings string?
  210.                     for(int n=0; n<29; n++) {
  211.                         int junk = p.readInt();
  212.                         if(junk == 0 && n != 0) {
  213.                             // possibly a bot
  214.                             session.close();
  215.                             return true;
  216.                         }
  217.                     }
  218.                     int tmpEncryptPacketSize = p.readByte() & 0xff; //hopefully same as (--loginEncryptPacketSize)
  219.                     boolean hd = true;
  220.                     if(tmpEncryptPacketSize != 10) {
  221.                         @SuppressWarnings("unused")
  222.                         int encryptPacketId = p.readByte() & 0xff; //hopefully 10
  223.                         hd = false;
  224.                     }
  225.                     long clientSessionKey = p.readLong();
  226.                     long serverSessionKey = p.readLong();
  227.                     //int uid = p.readInt(); //unique identifier for this session i think ?
  228.                     long l = p.readLong();
  229.                     int hash = (int) (31 & l >> 16);
  230.                     if(hash != (Integer) session.getAttribute("NAME_HASH")) {
  231.                         // invalid name hash (possibly a bot attacking)
  232.                         session.close();
  233.                         return true;
  234.                     }
  235.                     String  user = Misc.longToPlayerName(l), //given username
  236.                             pass = p.readRS2String(); //given password
  237.                    
  238.                     int sessionKey[] = new int[4];
  239.                     sessionKey[0] = (int)(clientSessionKey >> 32);
  240.                     sessionKey[1] = (int)clientSessionKey;
  241.                     sessionKey[2] = (int)(serverSessionKey >> 32);
  242.                     sessionKey[3] = (int)serverSessionKey;
  243.                    
  244.                     // set in ISAAC
  245.                     for(int i = 0; i < 4; i++) sessionKey[i] += 50;
  246.                     // set out ISAAC
  247.                    
  248.                     session.removeAttribute("LOGIN_STAGE");
  249.                     session.removeAttribute("NAME_HASH");
  250.                    
  251.                     /**
  252.                      * Here's where we add the user to the login queue, and if the login is
  253.                      * accepted, we change their session filter to a standard RS2ProtocolCodec.
  254.                      */
  255.                     logger.debug("Login request: [username="+user+",password="+pass+"].");
  256.                    
  257.                     PlayerDetails d = new PlayerDetails(user, pass, session, hd);
  258.                     workerThread.loadPlayer(d);
  259.                    
  260.                     session.setIdleTime(IdleStatus.BOTH_IDLE, Constants.SESSION_IDLE_TIME);
  261.                    
  262.                     session.getFilterChain().remove("protocolFilter");
  263.                     session.getFilterChain().addLast("protocolFilter", new ProtocolCodecFilter(new CodecFactory()));
  264.                    
  265.                     return true;
  266.                 } else {
  267.                     in.rewind();
  268.                     return false;
  269.                 }
  270.             }
  271.         } catch(Exception e) {
  272.             //logger.stackTrace(e);
  273.         }
  274.         return false;
  275.     }
  276.    
  277.    
  278.    
  279. //  private ByteBuffer getFile(int requestCache, int requestId) throws IOException {
  280. //      ByteBuffer buffer = ByteBuffer.allocate(520);
  281. //      buffer.put((byte) requestCache);
  282. //      buffer.putShort((short) requestId);
  283. //      byte[] cache = CACHE.read(CACHE.index(requestCache, requestId));
  284. //      int len = (((cache[1] & 0xff) << 24)+((cache[2] & 0xff) << 16)+((cache[3] & 0xff) << 8)+(cache[4] & 0xff)) + 9;
  285. //      if(cache[0] == 0) {
  286. //          len -= 4;
  287. //      }
  288. //      int c = 3;
  289. //      for(int i = 0; i < len; i++) {
  290. //          if(c == 512) {
  291. //              buffer.put((byte) 0xFF);
  292. //              c = 1;
  293. //          }
  294. //          buffer.put(cache[i]);
  295. //      }
  296. //      return buffer.flip();
  297. //  }
  298.  
  299.  
  300.     /**
  301.      * Releases the buffer used by the given session.
  302.      *
  303.      * @param session The session for which to release the buffer
  304.      * @throws Exception if failed to dispose all resources
  305.      */
  306.     @Override
  307.     public void dispose(IoSession session) throws Exception {
  308.         super.dispose(session);
  309.     }
  310.  
  311. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!