Protect Hwid

Index: net.sf.l2j;Config.java
===================================================================
--- package net.sf.l2j;Config.java  (revision 84)
+++ package net.sf.l2j;Config.java  (working copy)

+   public static int MIN_PROTOCOL_REVISION;
+   public static int MAX_PROTOCOL_REVISION;

+       MIN_PROTOCOL_REVISION = server.getProperty("MinProtocolRevision", 730);
+       MAX_PROTOCOL_REVISION = server.getProperty("MaxProtocolRevision", 746);
+       if (MIN_PROTOCOL_REVISION > MAX_PROTOCOL_REVISION)
+           throw new Error("MinProtocolRevision is bigger than MaxProtocolRevision in server.properties.");

Index: java/hwid;Hwid.java
===================================================================
--- package java/hwid;Hwid.java (revision 84)
+++ package java/hwid;Hwid.java (working copy)

+   package hwid;
+
+   import hwid.crypt.Manager;
+   import hwid.hwidmanager.HWIDBan;
+   import hwid.hwidmanager.HWIDManager;
+   import hwid.utils.Util;
+
+   import java.io.IOException;
+   import java.nio.ByteBuffer;
+   import java.util.concurrent.ConcurrentHashMap;
+   import java.util.logging.Logger;
+
+   import net.sf.l2j.gameserver.model.actor.Player;
+   import net.sf.l2j.gameserver.network.GameClient;
+   import net.sf.l2j.gameserver.network.serverpackets.ServerClose;
+   import net.sf.l2j.loginserver.crypt.BlowfishEngine;
+
+   public class Hwid
+   {
+       protected static Logger _log = Logger.getLogger(Hwid.class.getName());
+       private static byte[] _key = new byte[16];
+       static byte version = 11;
+       protected static ConcurrentHashMap<String, Manager.InfoSet> _objects = new ConcurrentHashMap<>();
+
+       public static void Init()
+       {
+           HwidConfig.load();
+           if (isProtectionOn())
+           {
+               HWIDBan.getInstance();
+               HWIDManager.getInstance();
+               Manager.getInstance();
+           }
+       }
+
+       public static boolean isProtectionOn()
+       {
+           if (HwidConfig.ALLOW_GUARD_SYSTEM)
+               return true;
+           return false;
+       }
+
+       public static byte[] getKey(byte[] key)
+       {
+           // byte[] bfkey = FirstKey.SKBOX;
+           byte[] bfkey =
+           {
+               110,
+               36,
+               2,
+               15,
+               -5,
+               17,
+               24,
+               23,
+               18,
+               45,
+               1,
+               21,
+               122,
+               16,
+               -5,
+               12
+           };
+           try
+           {
+               BlowfishEngine bf = new BlowfishEngine();
+               bf.init(true, bfkey);
+               bf.processBlock(key, 0, _key, 0);
+               bf.processBlock(key, 8, _key, 8);
+           }
+           catch (IOException e)
+           {
+               _log.info("Bad key!!!");
+           }
+           return _key;
+       }
+
+       public static void addPlayer(GameClient client)
+       {
+           if (isProtectionOn() && client != null)
+               Manager.getInstance().addPlayer(client);
+       }
+
+       public static void removePlayer(GameClient client)
+       {
+           if (isProtectionOn() && client != null)
+               Manager.removePlayer(client.getPlayerName());
+       }
+
+       public static boolean checkVerfiFlag(GameClient client, int flag)
+       {
+           boolean result = true;
+           int fl = Integer.reverseBytes(flag);
+           if (fl == -1)
+               // Log.add("Error Verify Flag|" + client.toString(), _logFile);
+               return false;
+           else if (fl == 1342177280)
+               // Log.add("Error get net data client|" + client.toString() + "|DEBUG INFO:" + fl, _logFile);
+               return false;
+           else
+           {
+               if ((fl & 1) != 0)
+                   // Log.add("Sniffer detect |" + client.toString() + "|DEBUG INFO:" + fl, _logFile);
+                   result = false;
+
+               // Console CMD
+               if ((fl & 16) != 0)
+                   // Log.add("Sniffer detect2 |" + client.toString() + "|DEBUG INFO:" + fl, _logFile);
+                   result = false;
+
+               if ((fl & 268435456) != 0)
+                   // Log.add("L2ext detect |" + client.toString() + "|DEBUG INFO:" + fl, _logFile);
+                   result = false;
+
+               return result;
+           }
+       }
+
+       public static int dumpData(int _id, int position, GameClient pi)
+       {
+           int value = 0;
+           position = position > 4 ? 5 : position;
+           boolean isIdZero = false;
+           if (_id == 0)
+               isIdZero = true;
+           // Log.add("Cannot read DumpId|Target:" + _positionName[position] + "|" + pi.toString() + "|DEBUG INFO:" + _id, _logFile);
+           switch (position)
+           {
+               case 0:
+                   // IG
+                   if (_id != 1435233386)
+                   {
+                       if (!isIdZero)
+                       {
+                           // Log.add(_positionName[position] + " was found|" + pi.toString() + "|DEBUG INFO:" + _id, _logFile);
+                       }
+                       value = 1/* HwidConfig.PROTECT_PENALTY_IG */;
+                   }
+                   break;
+               case 1:
+                   // Console CMD
+                   if (_id != 16)
+                   {
+                       if (!isIdZero)
+                       {
+                           // Log.add(_positionName[position] + " was found|" + pi.toString() + "|DEBUG INFO:" + _id, _logFile);
+                       }
+                       value = 2/* HwidConfig.PROTECT_PENALTY_CONSOLE_CMD */;
+                   }
+                   break;
+               case 2:
+               case 3:
+               case 4:
+                   // check debuger (0xСС) or hook (0xE9)
+                   int code = _id & 0xFF000000;
+                   if (code == 0xCC)
+                   {
+                       // Log.add("Attempts!!! Debuger was found|" + pi.toString() + "|DEBUG INFO:" + _id, _logFile);
+                   }
+                   // L2phx (connect, send, recv)
+                   if (code == 0xE9)
+                       // Log.add(_positionName[position] + " was found|" + pi.toString() + "|DEBUG INFO:" + _id, _logFile);
+                       value = 3/* HwidConfig.PROTECT_PENALTY_L2PHX */;
+                   break;
+               default:
+                   value = 0;
+                   break;
+           }
+           return value;
+       }
+
+       public static int calcPenalty(byte[] data, GameClient pi)
+       {
+           int sum = -1;
+           if (Util.verifyChecksum(data, 0, data.length))
+           {
+               ByteBuffer buf = ByteBuffer.wrap(data, 0, data.length - 4);
+               sum = 0;
+               int lenPenalty = (data.length - 4) / 4;
+               for (int i = 0; i < lenPenalty; i++)
+                   sum += Hwid.dumpData(buf.getInt(), i, pi);
+           }
+           return sum;
+       }
+
+       public static boolean CheckHWIDs(GameClient client, int LastError1, int LastError2)
+       {
+           boolean resultHWID = false;
+           boolean resultLastError = false;
+           String HWID = client.getHWID();
+
+           if (HWID.equalsIgnoreCase("fab800b1cc9de379c8046519fa841e6"))
+               // Log.add("HWID:" + HWID + "|is empty, account:" + client.getLoginName() + "|IP: " + client.toString(), _logFile);
+               if (HwidConfig.PROTECT_KICK_WITH_EMPTY_HWID)
+                   resultHWID = true;
+
+           if (LastError1 != 0)
+               // Log.add("LastError(HWID):" + LastError1 + "|" + Util.LastErrorConvertion(Integer.valueOf(LastError1)) + "|isn\'t empty, " + client.toString(), _logFile);
+               if (HwidConfig.PROTECT_KICK_WITH_LASTERROR_HWID)
+                   resultLastError = true;
+
+           return resultHWID || resultLastError;
+       }
+
+       public static String fillHex(int data, int digits)
+       {
+           String number = Integer.toHexString(data);
+
+           for (int i = number.length(); i < digits; ++i)
+               number = "0" + number;
+
+           return number;
+       }
+
+       public static String ExtractHWID(byte[] _data)
+       {
+           if (!Util.verifyChecksum(_data, 0, _data.length))
+               return null;
+           StringBuilder resultHWID = new StringBuilder();
+
+           for (int i = 0; i < _data.length - 8; ++i)
+               resultHWID.append(fillHex(_data[i] & 255, 2));
+
+           return resultHWID.toString();
+       }
+
+       public static boolean doAuthLogin(GameClient client, byte[] data, String loginName)
+       {
+           if (!isProtectionOn())
+               return true;
+           client.setLoginName(loginName);
+           String fullHWID = ExtractHWID(data);
+
+           if (fullHWID == null)
+           {
+               _log.info("AuthLogin CRC Check Fail! May be BOT or unprotected client! Client IP: " + client.toString());
+               client.close(ServerClose.STATIC_PACKET);
+               return false;
+           }
+
+           int LastError1 = ByteBuffer.wrap(data, 16, 4).getInt();
+           if (CheckHWIDs(client, LastError1, 0))
+           {
+               _log.info("HWID error, look protection_logs.txt file, from IP: " + client.toString());
+               client.close(ServerClose.STATIC_PACKET);
+               return false;
+           }
+           if (HWIDBan.getInstance().checkFullHWIDBanned(client))
+           {
+               _log.info("Client " + client + " is banned. Kicked! |HWID: " + client.getHWID() + " IP: " + client.toString());
+               client.close(ServerClose.STATIC_PACKET);
+           }
+
+           int VerfiFlag = ByteBuffer.wrap(data, 40, 4).getInt();
+           if (!checkVerfiFlag(client, VerfiFlag))
+               return false;
+           return true;
+       }
+
+       public static void doDisconection(GameClient client)
+       {
+           removePlayer(client);
+       }
+
+       public static boolean checkPlayerWithHWID(GameClient client, int playerID, String playerName)
+       {
+           if (!isProtectionOn())
+               return true;
+
+           client.setPlayerName(playerName);
+           client.setPlayerId(playerID);
+
+           if (HwidConfig.PROTECT_WINDOWS_COUNT != 0)
+           {
+               final int count = Manager.getCountByHWID(client.getHWID());
+               if (count > HwidConfig.PROTECT_WINDOWS_COUNT && count > HWIDManager.getAllowedWindowsCount(client))
+               {
+                   _log.info("Multi windows: " + client.toString());
+                   client.close(ServerClose.STATIC_PACKET);
+                   return false;
+               }
+           }
+           addPlayer(client);
+           return true;
+
+       }
+
+       public static void nopath(GameClient client)
+       {
+           _log.info("Client " + client + " is no have path kick: " + client.getHWID() + " IP: " + client.toString());
+           client.close(ServerClose.STATIC_PACKET);
+       }
+
+       public static void enterlog(Player player, GameClient client)
+       {
+           if (HwidConfig.ALLOW_GUARD_SYSTEM && HwidConfig.ENABLE_CONSOLE_LOG)
+               _log.info("HWID : [" + client.getHWID() + "], character: [" + player.getName() + "] PlayerId: [" + player.getObjectId() + " ]");
+       }
+
+       public static void waitSecs(int i)
+       {
+           try
+           {
+               Thread.sleep(i * 1000);
+           }
+           catch (InterruptedException ie)
+           {
+               ie.printStackTrace();
+           }
+       }
+   }
+

Index: java/hwid;HwidConfig.java
===================================================================
--- package java/hwid;HwidConfig.java   (revision 84)
+++ package java/hwid;HwidConfig.java   (working copy)

+   package hwid;
+
+   import hwid.crypt.FirstKey;
+
+   import java.io.File;
+   import java.io.FileInputStream;
+   import java.io.InputStream;
+   import java.util.Properties;
+   import java.util.logging.Logger;
+
+   public class HwidConfig
+   {
+       protected static Logger _log = Logger.getLogger(HwidConfig.class.getName());
+       public static final String D_GUARD_FILE = "./config/protection.properties";
+       public static final boolean PROTECT_DEBUG = false;
+       public static final boolean PROTECT_ENABLE_HWID_LOCK = false;
+       public static byte[] GUARD_CLIENT_CRYPT_KEY;
+       public static byte[] GUARD_CLIENT_CRYPT;
+       public static byte[] GUARD_SERVER_CRYPT_KEY;
+       public static byte[] GUARD_SERVER_CRYPT;
+       public static byte FST_KEY;
+       public static byte SCN_KEY;
+       public static byte ANP_KEY;
+       public static byte ULT_KEY;
+       public static int NPROTECT_KEY = -1;
+       public static String NPROTECT_USERNAME;
+       public static int SITE_01;
+       public static final boolean ALLOW_DUALBOX = true;
+
+       public static boolean ALLOW_GUARD_SYSTEM;
+       public static int PROTECT_WINDOWS_COUNT;
+
+       public static int GET_CLIENT_HWID;
+       public static boolean ALLOW_SEND_GG_REPLY;
+       public static boolean ENABLE_CONSOLE_LOG;
+       public static long TIME_SEND_GG_REPLY;
+       public static boolean PROTECT_KICK_WITH_EMPTY_HWID;
+       public static boolean PROTECT_KICK_WITH_LASTERROR_HWID;
+
+       public static String MESSAGE_GOOD;
+       public static String MESSAGE_ERROR;
+
+       @SuppressWarnings("resource")
+       public static final void load()
+       {
+           File fp = new File(D_GUARD_FILE);
+           ALLOW_GUARD_SYSTEM = fp.exists();
+
+           if (ALLOW_GUARD_SYSTEM)
+               try
+           {
+                   Properties guardSettings = new Properties();
+                   InputStream is = new FileInputStream(fp);
+                   guardSettings.load(is);
+                   is.close();
+
+                   _log.info("- Loading Protection Configs");
+                   ALLOW_GUARD_SYSTEM = getBooleanProperty(guardSettings, "AllowGuardSystem", true);
+                   PROTECT_WINDOWS_COUNT = getIntProperty(guardSettings, "AllowedWindowsCount", 1);
+                   NPROTECT_USERNAME = guardSettings.getProperty("UserName", "");
+                   SITE_01 = getIntProperty(guardSettings, "Prtctn", 1);
+
+                   FST_KEY = getByteProperty(guardSettings, "FstKey", 110);
+                   SCN_KEY = getByteProperty(guardSettings, "ScnKey", 36);
+                   ANP_KEY = getByteProperty(guardSettings, "AnpKey", -5);
+                   ULT_KEY = getByteProperty(guardSettings, "UltKey", 12);
+
+                   GET_CLIENT_HWID = getIntProperty(guardSettings, "UseClientHWID", 2);
+                   ENABLE_CONSOLE_LOG = getBooleanProperty(guardSettings, "EnableConsoleLog", false);
+                   PROTECT_KICK_WITH_EMPTY_HWID = getBooleanProperty(guardSettings, "KickWithEmptyHWID", false);
+                   PROTECT_KICK_WITH_LASTERROR_HWID = getBooleanProperty(guardSettings, "KickWithLastErrorHWID", false);
+
+                   MESSAGE_GOOD = guardSettings.getProperty("ServerKey", "");
+                   MESSAGE_ERROR = guardSettings.getProperty("ClientKey", "");
+
+                   String key_client = "GOGX2_RB(]Slnjt15~EgyqTv%[$YR]!1E~ayK?$9[R%%m4{zoMF$D?f:zvS2q&>~";
+                   String key_server = "b*qR43<9J1pD>Q4Uns6FsKao~VbU0H]y`A0ytTveiWn)SuSYsM?m*eblL!pwza!t";
+                   byte[] keyS = key_server.getBytes();
+                   byte[] tmpS = new byte[32];
+
+                   byte[] keyC = key_client.getBytes();
+                   byte[] tmpC = new byte[32];
+
+                   System.arraycopy(keyC, 0, tmpC, 0, 32);
+                   GUARD_CLIENT_CRYPT_KEY = FirstKey.expandKey(tmpC, 32);
+                   System.arraycopy(keyC, 32, tmpC, 0, 32);
+                   GUARD_CLIENT_CRYPT = FirstKey.expandKey(tmpC, 32);
+
+                   System.arraycopy(keyS, 0, tmpS, 0, 32);
+                   GUARD_SERVER_CRYPT_KEY = FirstKey.expandKey(tmpS, 32);
+                   System.arraycopy(keyS, 32, tmpS, 0, 32);
+                   GUARD_SERVER_CRYPT = FirstKey.expandKey(tmpS, 32);
+           }
+           catch (Exception e)
+           {
+               e.printStackTrace();
+           }
+       }
+
+       @SuppressWarnings("resource")
+       protected static Properties getSettings(String CONFIGURATION_FILE) throws Exception
+       {
+           Properties serverSettings = new Properties();
+           InputStream is = new FileInputStream(new File(CONFIGURATION_FILE));
+           serverSettings.load(is);
+           is.close();
+           return serverSettings;
+       }
+
+       protected static String getProperty(Properties prop, String name)
+       {
+           return prop.getProperty(name.trim(), null);
+       }
+
+       protected static String getProperty(Properties prop, String name, String _default)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : s;
+       }
+
+       protected static int getIntProperty(Properties prop, String name, int _default)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : Integer.parseInt(s.trim());
+       }
+
+       protected static int getIntHexProperty(Properties prop, String name, int _default)
+       {
+           return (int) getLongHexProperty(prop, name, _default);
+       }
+
+       protected static long getLongProperty(Properties prop, String name, long _default)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : Long.parseLong(s.trim());
+       }
+
+       protected static long getLongHexProperty(Properties prop, String name, long _default)
+       {
+           String s = getProperty(prop, name);
+           if (s == null)
+               return _default;
+           s = s.trim();
+           if (!s.startsWith("0x"))
+               s = "0x" + s;
+           return Long.decode(s).longValue();
+       }
+
+       protected static byte getByteProperty(Properties prop, String name, byte _default)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : Byte.parseByte(s.trim());
+       }
+
+       protected static byte getByteProperty(Properties prop, String name, int _default)
+       {
+           return getByteProperty(prop, name, (byte) _default);
+       }
+
+       protected static boolean getBooleanProperty(Properties prop, String name, boolean _default)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : Boolean.parseBoolean(s.trim());
+       }
+
+       protected static float getFloatProperty(Properties prop, String name, float _default)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : Float.parseFloat(s.trim());
+       }
+
+       protected static float getFloatProperty(Properties prop, String name, double _default)
+       {
+           return getFloatProperty(prop, name, (float) _default);
+       }
+
+       protected static double getDoubleProperty(Properties prop, String name, double _default)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : Double.parseDouble(s.trim());
+       }
+
+       protected static int[] getIntArray(Properties prop, String name, int[] _default)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : parseCommaSeparatedIntegerArray(s.trim());
+       }
+
+       protected static float[] getFloatArray(Properties prop, String name, float[] _default)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : parseCommaSeparatedFloatArray(s.trim());
+       }
+
+       protected static String[] getStringArray(Properties prop, String name, String[] _default, String delimiter)
+       {
+           String s = getProperty(prop, name);
+           return s == null ? _default : s.split(delimiter);
+       }
+
+       protected static String[] getStringArray(Properties prop, String name, String[] _default)
+       {
+           return getStringArray(prop, name, _default, ",");
+       }
+
+       protected static float[] parseCommaSeparatedFloatArray(String s)
+       {
+           if (s.isEmpty())
+               return new float[0];
+
+           String[] tmp = s.replaceAll(",", ";").split(";");
+           float[] ret = new float[tmp.length];
+
+           for (int i = 0; i < tmp.length; i++)
+               ret[i] = Float.parseFloat(tmp[i]);
+           return ret;
+       }
+
+       protected static int[] parseCommaSeparatedIntegerArray(String s)
+       {
+           if (s.isEmpty())
+               return new int[0];
+
+           String[] tmp = s.replaceAll(",", ";").split(";");
+           int[] ret = new int[tmp.length];
+           for (int i = 0; i < tmp.length; i++)
+               ret[i] = Integer.parseInt(tmp[i]);
+
+           return ret;
+       }
+   }
+

Index: java/hwid.crypt;BlowfishEngine.java
===================================================================
--- package java/hwid.crypt;BlowfishEngine.java (revision 84)
+++ package java/hwid.crypt;BlowfishEngine.java (working copy)

+   package hwid.crypt;
+
+   import java.io.IOException;
+
+   public class BlowfishEngine
+   {
+       private final static int[] KP =
+       {
+           0x243F6A88,
+           0x85A308D3,
+           0x13198A2E,
+           0x03707344,
+           0xA4093822,
+           0x299F31D0,
+           0x082EFA98,
+           0xEC4E6C89,
+           0x452821E6,
+           0x38D01377,
+           0xBE5466CF,
+           0x34E90C6C,
+           0xC0AC29B7,
+           0xC97C50DD,
+           0x3F84D5B5,
+           0xB5470917,
+           0x9216D5D9,
+           0x8979FB1B
+
+       }, KS0 =
+   {
+           0xD1310BA6,
+           0x98DFB5AC,
+           0x2FFD72DB,
+           0xD01ADFB7,
+           0xB8E1AFED,
+           0x6A267E96,
+           0xBA7C9045,
+           0xF12C7F99,
+           0x24A19947,
+           0xB3916CF7,
+           0x0801F2E2,
+           0x858EFC16,
+           0x636920D8,
+           0x71574E69,
+           0xA458FEA3,
+           0xF4933D7E,
+           0x0D95748F,
+           0x728EB658,
+           0x718BCD58,
+           0x82154AEE,
+           0x7B54A41D,
+           0xC25A59B5,
+           0x9C30D539,
+           0x2AF26013,
+           0xC5D1B023,
+           0x286085F0,
+           0xCA417918,
+           0xB8DB38EF,
+           0x8E79DCB0,
+           0x603A180E,
+           0x6C9E0E8B,
+           0xB01E8A3E,
+           0xD71577C1,
+           0xBD314B27,
+           0x78AF2FDA,
+           0x55605C60,
+           0xE65525F3,
+           0xAA55AB94,
+           0x57489862,
+           0x63E81440,
+           0x55CA396A,
+           0x2AAB10B6,
+           0xB4CC5C34,
+           0x1141E8CE,
+           0xA15486AF,
+           0x7C72E993,
+           0xB3EE1411,
+           0x636FBC2A,
+           0x2BA9C55D,
+           0x741831F6,
+           0xCE5C3E16,
+           0x9B87931E,
+           0xAFD6BA33,
+           0x6C24CF5C,
+           0x7A325381,
+           0x28958677,
+           0x3B8F4898,
+           0x6B4BB9AF,
+           0xC4BFE81B,
+           0x66282193,
+           0x61D809CC,
+           0xFB21A991,
+           0x487CAC60,
+           0x5DEC8032,
+           0xEF845D5D,
+           0xE98575B1,
+           0xDC262302,
+           0xEB651B88,
+           0x23893E81,
+           0xD396ACC5,
+           0x0F6D6FF3,
+           0x83F44239,
+           0x2E0B4482,
+           0xA4842004,
+           0x69C8F04A,
+           0x9E1F9B5E,
+           0x21C66842,
+           0xF6E96C9A,
+           0x670C9C61,
+           0xABD388F0,
+           0x6A51A0D2,
+           0xD8542F68,
+           0x960FA728,
+           0xAB5133A3,
+           0x6EEF0B6C,
+           0x137A3BE4,
+           0xBA3BF050,
+           0x7EFB2A98,
+           0xA1F1651D,
+           0x39AF0176,
+           0x66CA593E,
+           0x82430E88,
+           0x8CEE8619,
+           0x456F9FB4,
+           0x7D84A5C3,
+           0x3B8B5EBE,
+           0xE06F75D8,
+           0x85C12073,
+           0x401A449F,
+           0x56C16AA6,
+           0x4ED3AA62,
+           0x363F7706,
+           0x1BFEDF72,
+           0x429B023D,
+           0x37D0D724,
+           0xD00A1248,
+           0xDB0FEAD3,
+           0x49F1C09B,
+           0x075372C9,
+           0x80991B7B,
+           0x25D479D8,
+           0xF6E8DEF7,
+           0xE3FE501A,
+           0xB6794C3B,
+           0x976CE0BD,
+           0x04C006BA,
+           0xC1A94FB6,
+           0x409F60C4,
+           0x5E5C9EC2,
+           0x196A2463,
+           0x68FB6FAF,
+           0x3E6C53B5,
+           0x1339B2EB,
+           0x3B52EC6F,
+           0x6DFC511F,
+           0x9B30952C,
+           0xCC814544,
+           0xAF5EBD09,
+           0xBEE3D004,
+           0xDE334AFD,
+           0x660F2807,
+           0x192E4BB3,
+           0xC0CBA857,
+           0x45C8740F,
+           0xD20B5F39,
+           0xB9D3FBDB,
+           0x5579C0BD,
+           0x1A60320A,
+           0xD6A100C6,
+           0x402C7279,
+           0x679F25FE,
+           0xFB1FA3CC,
+           0x8EA5E9F8,
+           0xDB3222F8,
+           0x3C7516DF,
+           0xFD616B15,
+           0x2F501EC8,
+           0xAD0552AB,
+           0x323DB5FA,
+           0xFD238760,
+           0x53317B48,
+           0x3E00DF82,
+           0x9E5C57BB,
+           0xCA6F8CA0,
+           0x1A87562E,
+           0xDF1769DB,
+           0xD542A8F6,
+           0x287EFFC3,
+           0xAC6732C6,
+           0x8C4F5573,
+           0x695B27B0,
+           0xBBCA58C8,
+           0xE1FFA35D,
+           0xB8F011A0,
+           0x10FA3D98,
+           0xFD2183B8,
+           0x4AFCB56C,
+           0x2DD1D35B,
+           0x9A53E479,
+           0xB6F84565,
+           0xD28E49BC,
+           0x4BFB9790,
+           0xE1DDF2DA,
+           0xA4CB7E33,
+           0x62FB1341,
+           0xCEE4C6E8,
+           0xEF20CADA,
+           0x36774C01,
+           0xD07E9EFE,
+           0x2BF11FB4,
+           0x95DBDA4D,
+           0xAE909198,
+           0xEAAD8E71,
+           0x6B93D5A0,
+           0xD08ED1D0,
+           0xAFC725E0,
+           0x8E3C5B2F,
+           0x8E7594B7,
+           0x8FF6E2FB,
+           0xF2122B64,
+           0x8888B812,
+           0x900DF01C,
+           0x4FAD5EA0,
+           0x688FC31C,
+           0xD1CFF191,
+           0xB3A8C1AD,
+           0x2F2F2218,
+           0xBE0E1777,
+           0xEA752DFE,
+           0x8B021FA1,
+           0xE5A0CC0F,
+           0xB56F74E8,
+           0x18ACF3D6,
+           0xCE89E299,
+           0xB4A84FE0,
+           0xFD13E0B7,
+           0x7CC43B81,
+           0xD2ADA8D9,
+           0x165FA266,
+           0x80957705,
+           0x93CC7314,
+           0x211A1477,
+           0xE6AD2065,
+           0x77B5FA86,
+           0xC75442F5,
+           0xFB9D35CF,
+           0xEBCDAF0C,
+           0x7B3E89A0,
+           0xD6411BD3,
+           0xAE1E7E49,
+           0x00250E2D,
+           0x2071B35E,
+           0x226800BB,
+           0x57B8E0AF,
+           0x2464369B,
+           0xF009B91E,
+           0x5563911D,
+           0x59DFA6AA,
+           0x78C14389,
+           0xD95A537F,
+           0x207D5BA2,
+           0x02E5B9C5,
+           0x83260376,
+           0x6295CFA9,
+           0x11C81968,
+           0x4E734A41,
+           0xB3472DCA,
+           0x7B14A94A,
+           0x1B510052,
+           0x9A532915,
+           0xD60F573F,
+           0xBC9BC6E4,
+           0x2B60A476,
+           0x81E67400,
+           0x08BA6FB5,
+           0x571BE91F,
+           0xF296EC6B,
+           0x2A0DD915,
+           0xB6636521,
+           0xE7B9F9B6,
+           0xFF34052E,
+           0xC5855664,
+           0x53B02D5D,
+           0xA99F8FA1,
+           0x08BA4799,
+           0x6E85076A
+   }, KS1 =
+   {
+           0x4B7A70E9,
+           0xB5B32944,
+           0xDB75092E,
+           0xC4192623,
+           0xAD6EA6B0,
+           0x49A7DF7D,
+           0x9CEE60B8,
+           0x8FEDB266,
+           0xECAA8C71,
+           0x699A17FF,
+           0x5664526C,
+           0xC2B19EE1,
+           0x193602A5,
+           0x75094C29,
+           0xA0591340,
+           0xE4183A3E,
+           0x3F54989A,
+           0x5B429D65,
+           0x6B8FE4D6,
+           0x99F73FD6,
+           0xA1D29C07,
+           0xEFE830F5,
+           0x4D2D38E6,
+           0xF0255DC1,
+           0x4CDD2086,
+           0x8470EB26,
+           0x6382E9C6,
+           0x021ECC5E,
+           0x09686B3F,
+           0x3EBAEFC9,
+           0x3C971814,
+           0x6B6A70A1,
+           0x687F3584,
+           0x52A0E286,
+           0xB79C5305,
+           0xAA500737,
+           0x3E07841C,
+           0x7FDEAE5C,
+           0x8E7D44EC,
+           0x5716F2B8,
+           0xB03ADA37,
+           0xF0500C0D,
+           0xF01C1F04,
+           0x0200B3FF,
+           0xAE0CF51A,
+           0x3CB574B2,
+           0x25837A58,
+           0xDC0921BD,
+           0xD19113F9,
+           0x7CA92FF6,
+           0x94324773,
+           0x22F54701,
+           0x3AE5E581,
+           0x37C2DADC,
+           0xC8B57634,
+           0x9AF3DDA7,
+           0xA9446146,
+           0x0FD0030E,
+           0xECC8C73E,
+           0xA4751E41,
+           0xE238CD99,
+           0x3BEA0E2F,
+           0x3280BBA1,
+           0x183EB331,
+           0x4E548B38,
+           0x4F6DB908,
+           0x6F420D03,
+           0xF60A04BF,
+           0x2CB81290,
+           0x24977C79,
+           0x5679B072,
+           0xBCAF89AF,
+           0xDE9A771F,
+           0xD9930810,
+           0xB38BAE12,
+           0xDCCF3F2E,
+           0x5512721F,
+           0x2E6B7124,
+           0x501ADDE6,
+           0x9F84CD87,
+           0x7A584718,
+           0x7408DA17,
+           0xBC9F9ABC,
+           0xE94B7D8C,
+           0xEC7AEC3A,
+           0xDB851DFA,
+           0x63094366,
+           0xC464C3D2,
+           0xEF1C1847,
+           0x3215D908,
+           0xDD433B37,
+           0x24C2BA16,
+           0x12A14D43,
+           0x2A65C451,
+           0x50940002,
+           0x133AE4DD,
+           0x71DFF89E,
+           0x10314E55,
+           0x81AC77D6,
+           0x5F11199B,
+           0x043556F1,
+           0xD7A3C76B,
+           0x3C11183B,
+           0x5924A509,
+           0xF28FE6ED,
+           0x97F1FBFA,
+           0x9EBABF2C,
+           0x1E153C6E,
+           0x86E34570,
+           0xEAE96FB1,
+           0x860E5E0A,
+           0x5A3E2AB3,
+           0x771FE71C,
+           0x4E3D06FA,
+           0x2965DCB9,
+           0x99E71D0F,
+           0x803E89D6,
+           0x5266C825,
+           0x2E4CC978,
+           0x9C10B36A,
+           0xC6150EBA,
+           0x94E2EA78,
+           0xA5FC3C53,
+           0x1E0A2DF4,
+           0xF2F74EA7,
+           0x361D2B3D,
+           0x1939260F,
+           0x19C27960,
+           0x5223A708,
+           0xF71312B6,
+           0xEBADFE6E,
+           0xEAC31F66,
+           0xE3BC4595,
+           0xA67BC883,
+           0xB17F37D1,
+           0x018CFF28,
+           0xC332DDEF,
+           0xBE6C5AA5,
+           0x65582185,
+           0x68AB9802,
+           0xEECEA50F,
+           0xDB2F953B,
+           0x2AEF7DAD,
+           0x5B6E2F84,
+           0x1521B628,
+           0x29076170,
+           0xECDD4775,
+           0x619F1510,
+           0x13CCA830,
+           0xEB61BD96,
+           0x0334FE1E,
+           0xAA0363CF,
+           0xB5735C90,
+           0x4C70A239,
+           0xD59E9E0B,
+           0xCBAADE14,
+           0xEECC86BC,
+           0x60622CA7,
+           0x9CAB5CAB,
+           0xB2F3846E,
+           0x648B1EAF,
+           0x19BDF0CA,
+           0xA02369B9,
+           0x655ABB50,
+           0x40685A32,
+           0x3C2AB4B3,
+           0x319EE9D5,
+           0xC021B8F7,
+           0x9B540B19,
+           0x875FA099,
+           0x95F7997E,
+           0x623D7DA8,
+           0xF837889A,
+           0x97E32D77,
+           0x11ED935F,
+           0x16681281,
+           0x0E358829,
+           0xC7E61FD6,
+           0x96DEDFA1,
+           0x7858BA99,
+           0x57F584A5,
+           0x1B227263,
+           0x9B83C3FF,
+           0x1AC24696,
+           0xCDB30AEB,
+           0x532E3054,
+           0x8FD948E4,
+           0x6DBC3128,
+           0x58EBF2EF,
+           0x34C6FFEA,
+           0xFE28ED61,
+           0xEE7C3C73,
+           0x5D4A14D9,
+           0xE864B7E3,
+           0x42105D14,
+           0x203E13E0,
+           0x45EEE2B6,
+           0xA3AAABEA,
+           0xDB6C4F15,
+           0xFACB4FD0,
+           0xC742F442,
+           0xEF6ABBB5,
+           0x654F3B1D,
+           0x41CD2105,
+           0xD81E799E,
+           0x86854DC7,
+           0xE44B476A,
+           0x3D816250,
+           0xCF62A1F2,
+           0x5B8D2646,
+           0xFC8883A0,
+           0xC1C7B6A3,
+           0x7F1524C3,
+           0x69CB7492,
+           0x47848A0B,
+           0x5692B285,
+           0x095BBF00,
+           0xAD19489D,
+           0x1462B174,
+           0x23820E00,
+           0x58428D2A,
+           0x0C55F5EA,
+           0x1DADF43E,
+           0x233F7061,
+           0x3372F092,
+           0x8D937E41,
+           0xD65FECF1,
+           0x6C223BDB,
+           0x7CDE3759,
+           0xCBEE7460,
+           0x4085F2A7,
+           0xCE77326E,
+           0xA6078084,
+           0x19F8509E,
+           0xE8EFD855,
+           0x61D99735,
+           0xA969A7AA,
+           0xC50C06C2,
+           0x5A04ABFC,
+           0x800BCADC,
+           0x9E447A2E,
+           0xC3453484,
+           0xFDD56705,
+           0x0E1E9EC9,
+           0xDB73DBD3,
+           0x105588CD,
+           0x675FDA79,
+           0xE3674340,
+           0xC5C43465,
+           0x713E38D8,
+           0x3D28F89E,
+           0xF16DFF20,
+           0x153E21E7,
+           0x8FB03D4A,
+           0xE6E39F2B,
+           0xDB83ADF7
+   }, KS2 =
+   {
+           0xE93D5A68,
+           0x948140F7,
+           0xF64C261C,
+           0x94692934,
+           0x411520F7,
+           0x7602D4F7,
+           0xBCF46B2E,
+           0xD4A20068,
+           0xD4082471,
+           0x3320F46A,
+           0x43B7D4B7,
+           0x500061AF,
+           0x1E39F62E,
+           0x97244546,
+           0x14214F74,
+           0xBF8B8840,
+           0x4D95FC1D,
+           0x96B591AF,
+           0x70F4DDD3,
+           0x66A02F45,
+           0xBFBC09EC,
+           0x03BD9785,
+           0x7FAC6DD0,
+           0x31CB8504,
+           0x96EB27B3,
+           0x55FD3941,
+           0xDA2547E6,
+           0xABCA0A9A,
+           0x28507825,
+           0x530429F4,
+           0x0A2C86DA,
+           0xE9B66DFB,
+           0x68DC1462,
+           0xD7486900,
+           0x680EC0A4,
+           0x27A18DEE,
+           0x4F3FFEA2,
+           0xE887AD8C,
+           0xB58CE006,
+           0x7AF4D6B6,
+           0xAACE1E7C,
+           0xD3375FEC,
+           0xCE78A399,
+           0x406B2A42,
+           0x20FE9E35,
+           0xD9F385B9,
+           0xEE39D7AB,
+           0x3B124E8B,
+           0x1DC9FAF7,
+           0x4B6D1856,
+           0x26A36631,
+           0xEAE397B2,
+           0x3A6EFA74,
+           0xDD5B4332,
+           0x6841E7F7,
+           0xCA7820FB,
+           0xFB0AF54E,
+           0xD8FEB397,
+           0x454056AC,
+           0xBA489527,
+           0x55533A3A,
+           0x20838D87,
+           0xFE6BA9B7,
+           0xD096954B,
+           0x55A867BC,
+           0xA1159A58,
+           0xCCA92963,
+           0x99E1DB33,
+           0xA62A4A56,
+           0x3F3125F9,
+           0x5EF47E1C,
+           0x9029317C,
+           0xFDF8E802,
+           0x04272F70,
+           0x80BB155C,
+           0x05282CE3,
+           0x95C11548,
+           0xE4C66D22,
+           0x48C1133F,
+           0xC70F86DC,
+           0x07F9C9EE,
+           0x41041F0F,
+           0x404779A4,
+           0x5D886E17,
+           0x325F51EB,
+           0xD59BC0D1,
+           0xF2BCC18F,
+           0x41113564,
+           0x257B7834,
+           0x602A9C60,
+           0xDFF8E8A3,
+           0x1F636C1B,
+           0x0E12B4C2,
+           0x02E1329E,
+           0xAF664FD1,
+           0xCAD18115,
+           0x6B2395E0,
+           0x333E92E1,
+           0x3B240B62,
+           0xEEBEB922,
+           0x85B2A20E,
+           0xE6BA0D99,
+           0xDE720C8C,
+           0x2DA2F728,
+           0xD0127845,
+           0x95B794FD,
+           0x647D0862,
+           0xE7CCF5F0,
+           0x5449A36F,
+           0x877D48FA,
+           0xC39DFD27,
+           0xF33E8D1E,
+           0x0A476341,
+           0x992EFF74,
+           0x3A6F6EAB,
+           0xF4F8FD37,
+           0xA812DC60,
+           0xA1EBDDF8,
+           0x991BE14C,
+           0xDB6E6B0D,
+           0xC67B5510,
+           0x6D672C37,
+           0x2765D43B,
+           0xDCD0E804,
+           0xF1290DC7,
+           0xCC00FFA3,
+           0xB5390F92,
+           0x690FED0B,
+           0x667B9FFB,
+           0xCEDB7D9C,
+           0xA091CF0B,
+           0xD9155EA3,
+           0xBB132F88,
+           0x515BAD24,
+           0x7B9479BF,
+           0x763BD6EB,
+           0x37392EB3,
+           0xCC115979,
+           0x8026E297,
+           0xF42E312D,
+           0x6842ADA7,
+           0xC66A2B3B,
+           0x12754CCC,
+           0x782EF11C,
+           0x6A124237,
+           0xB79251E7,
+           0x06A1BBE6,
+           0x4BFB6350,
+           0x1A6B1018,
+           0x11CAEDFA,
+           0x3D25BDD8,
+           0xE2E1C3C9,
+           0x44421659,
+           0x0A121386,
+           0xD90CEC6E,
+           0xD5ABEA2A,
+           0x64AF674E,
+           0xDA86A85F,
+           0xBEBFE988,
+           0x64E4C3FE,
+           0x9DBC8057,
+           0xF0F7C086,
+           0x60787BF8,
+           0x6003604D,
+           0xD1FD8346,
+           0xF6381FB0,
+           0x7745AE04,
+           0xD736FCCC,
+           0x83426B33,
+           0xF01EAB71,
+           0xB0804187,
+           0x3C005E5F,
+           0x77A057BE,
+           0xBDE8AE24,
+           0x55464299,
+           0xBF582E61,
+           0x4E58F48F,
+           0xF2DDFDA2,
+           0xF474EF38,
+           0x8789BDC2,
+           0x5366F9C3,
+           0xC8B38E74,
+           0xB475F255,
+           0x46FCD9B9,
+           0x7AEB2661,
+           0x8B1DDF84,
+           0x846A0E79,
+           0x915F95E2,
+           0x466E598E,
+           0x20B45770,
+           0x8CD55591,
+           0xC902DE4C,
+           0xB90BACE1,
+           0xBB8205D0,
+           0x11A86248,
+           0x7574A99E,
+           0xB77F19B6,
+           0xE0A9DC09,
+           0x662D09A1,
+           0xC4324633,
+           0xE85A1F02,
+           0x09F0BE8C,
+           0x4A99A025,
+           0x1D6EFE10,
+           0x1AB93D1D,
+           0x0BA5A4DF,
+           0xA186F20F,
+           0x2868F169,
+           0xDCB7DA83,
+           0x573906FE,
+           0xA1E2CE9B,
+           0x4FCD7F52,
+           0x50115E01,
+           0xA70683FA,
+           0xA002B5C4,
+           0x0DE6D027,
+           0x9AF88C27,
+           0x773F8641,
+           0xC3604C06,
+           0x61A806B5,
+           0xF0177A28,
+           0xC0F586E0,
+           0x006058AA,
+           0x30DC7D62,
+           0x11E69ED7,
+           0x2338EA63,
+           0x53C2DD94,
+           0xC2C21634,
+           0xBBCBEE56,
+           0x90BCB6DE,
+           0xEBFC7DA1,
+           0xCE591D76,
+           0x6F05E409,
+           0x4B7C0188,
+           0x39720A3D,
+           0x7C927C24,
+           0x86E3725F,
+           0x724D9DB9,
+           0x1AC15BB4,
+           0xD39EB8FC,
+           0xED545578,
+           0x08FCA5B5,
+           0xD83D7CD3,
+           0x4DAD0FC4,
+           0x1E50EF5E,
+           0xB161E6F8,
+           0xA28514D9,
+           0x6C51133C,
+           0x6FD5C7E7,
+           0x56E14EC4,
+           0x362ABFCE,
+           0xDDC6C837,
+           0xD79A3234,
+           0x92638212,
+           0x670EFA8E,
+           0x406000E0
+   }, KS3 =
+   {
+           0x3A39CE37,
+           0xD3FAF5CF,
+           0xABC27737,
+           0x5AC52D1B,
+           0x5CB0679E,
+           0x4FA33742,
+           0xD3822740,
+           0x99BC9BBE,
+           0xD5118E9D,
+           0xBF0F7315,
+           0xD62D1C7E,
+           0xC700C47B,
+           0xB78C1B6B,
+           0x21A19045,
+           0xB26EB1BE,
+           0x6A366EB4,
+           0x5748AB2F,
+           0xBC946E79,
+           0xC6A376D2,
+           0x6549C2C8,
+           0x530FF8EE,
+           0x468DDE7D,
+           0xD5730A1D,
+           0x4CD04DC6,
+           0x2939BBDB,
+           0xA9BA4650,
+           0xAC9526E8,
+           0xBE5EE304,
+           0xA1FAD5F0,
+           0x6A2D519A,
+           0x63EF8CE2,
+           0x9A86EE22,
+           0xC089C2B8,
+           0x43242EF6,
+           0xA51E03AA,
+           0x9CF2D0A4,
+           0x83C061BA,
+           0x9BE96A4D,
+           0x8FE51550,
+           0xBA645BD6,
+           0x2826A2F9,
+           0xA73A3AE1,
+           0x4BA99586,
+           0xEF5562E9,
+           0xC72FEFD3,
+           0xF752F7DA,
+           0x3F046F69,
+           0x77FA0A59,
+           0x80E4A915,
+           0x87B08601,
+           0x9B09E6AD,
+           0x3B3EE593,
+           0xE990FD5A,
+           0x9E34D797,
+           0x2CF0B7D9,
+           0x022B8B51,
+           0x96D5AC3A,
+           0x017DA67D,
+           0xD1CF3ED6,
+           0x7C7D2D28,
+           0x1F9F25CF,
+           0xADF2B89B,
+           0x5AD6B472,
+           0x5A88F54C,
+           0xE029AC71,
+           0xE019A5E6,
+           0x47B0ACFD,
+           0xED93FA9B,
+           0xE8D3C48D,
+           0x283B57CC,
+           0xF8D56629,
+           0x79132E28,
+           0x785F0191,
+           0xED756055,
+           0xF7960E44,
+           0xE3D35E8C,
+           0x15056DD4,
+           0x88F46DBA,
+           0x03A16125,
+           0x0564F0BD,
+           0xC3EB9E15,
+           0x3C9057A2,
+           0x97271AEC,
+           0xA93A072A,
+           0x1B3F6D9B,
+           0x1E6321F5,
+           0xF59C66FB,
+           0x26DCF319,
+           0x7533D928,
+           0xB155FDF5,
+           0x03563482,
+           0x8ABA3CBB,
+           0x28517711,
+           0xC20AD9F8,
+           0xABCC5167,
+           0xCCAD925F,
+           0x4DE81751,
+           0x3830DC8E,
+           0x379D5862,
+           0x9320F991,
+           0xEA7A90C2,
+           0xFB3E7BCE,
+           0x5121CE64,
+           0x774FBE32,
+           0xA8B6E37E,
+           0xC3293D46,
+           0x48DE5369,
+           0x6413E680,
+           0xA2AE0810,
+           0xDD6DB224,
+           0x69852DFD,
+           0x09072166,
+           0xB39A460A,
+           0x6445C0DD,
+           0x586CDECF,
+           0x1C20C8AE,
+           0x5BBEF7DD,
+           0x1B588D40,
+           0xCCD2017F,
+           0x6BB4E3BB,
+           0xDDA26A7E,
+           0x3A59FF45,
+           0x3E350A44,
+           0xBCB4CDD5,
+           0x72EACEA8,
+           0xFA6484BB,
+           0x8D6612AE,
+           0xBF3C6F47,
+           0xD29BE463,
+           0x542F5D9E,
+           0xAEC2771B,
+           0xF64E6370,
+           0x740E0D8D,
+           0xE75B1357,
+           0xF8721671,
+           0xAF537D5D,
+           0x4040CB08,
+           0x4EB4E2CC,
+           0x34D2466A,
+           0x0115AF84,
+           0xE1B00428,
+           0x95983A1D,
+           0x06B89FB4,
+           0xCE6EA048,
+           0x6F3F3B82,
+           0x3520AB82,
+           0x011A1D4B,
+           0x277227F8,
+           0x611560B1,
+           0xE7933FDC,
+           0xBB3A792B,
+           0x344525BD,
+           0xA08839E1,
+           0x51CE794B,
+           0x2F32C9B7,
+           0xA01FBAC9,
+           0xE01CC87E,
+           0xBCC7D1F6,
+           0xCF0111C3,
+           0xA1E8AAC7,
+           0x1A908749,
+           0xD44FBD9A,
+           0xD0DADECB,
+           0xD50ADA38,
+           0x0339C32A,
+           0xC6913667,
+           0x8DF9317C,
+           0xE0B12B4F,
+           0xF79E59B7,
+           0x43F5BB3A,
+           0xF2D519FF,
+           0x27D9459C,
+           0xBF97222C,
+           0x15E6FC2A,
+           0x0F91FC71,
+           0x9B941525,
+           0xFAE59361,
+           0xCEB69CEB,
+           0xC2A86459,
+           0x12BAA8D1,
+           0xB6C1075E,
+           0xE3056A0C,
+           0x10D25065,
+           0xCB03A442,
+           0xE0EC6E0E,
+           0x1698DB3B,
+           0x4C98A0BE,
+           0x3278E964,
+           0x9F1F9532,
+           0xE0D392DF,
+           0xD3A0342B,
+           0x8971F21E,
+           0x1B0A7441,
+           0x4BA3348C,
+           0xC5BE7120,
+           0xC37632D8,
+           0xDF359F8D,
+           0x9B992F2E,
+           0xE60B6F47,
+           0x0FE3F11D,
+           0xE54CDA54,
+           0x1EDAD891,
+           0xCE6279CF,
+           0xCD3E7E6F,
+           0x1618B166,
+           0xFD2C1D05,
+           0x848FD2C5,
+           0xF6FB2299,
+           0xF523F357,
+           0xA6327623,
+           0x93A83531,
+           0x56CCCD02,
+           0xACF08162,
+           0x5A75EBB5,
+           0x6E163697,
+           0x88D273CC,
+           0xDE966292,
+           0x81B949D0,
+           0x4C50901B,
+           0x71C65614,
+           0xE6C6C7BD,
+           0x327A140A,
+           0x45E1D006,
+           0xC3F27B9A,
+           0xC9AA53FD,
+           0x62A80F00,
+           0xBB25BFE2,
+           0x35BDD2F6,
+           0x71126905,
+           0xB2040222,
+           0xB6CBCF7C,
+           0xCD769C2B,
+           0x53113EC0,
+           0x1640E3D3,
+           0x38ABBD60,
+           0x2547ADF0,
+           0xBA38209C,
+           0xF746CE76,
+           0x77AFA1C5,
+           0x20756060,
+           0x85CBFE4E,
+           0x8AE88DD8,
+           0x7AAAF9B0,
+           0x4CF9AA7E,
+           0x1948C25C,
+           0x02FB8A8C,
+           0x01C36AE4,
+           0xD6EBE1F9,
+           0x90D4F869,
+           0xA65CDEA0,
+           0x3F09252D,
+           0xC208E69F,
+           0xB74E6132,
+           0xCE77E25B,
+           0x578FDFE3,
+           0x3AC372E6
+   };
+
+       private static final int ROUNDS = 16;
+       private static final int BLOCK_SIZE = 8;
+       private static final int SBOX_SK = 256;
+       private static final int P_SZ = ROUNDS + 2;
+       private final int[] S0, S1, S2, S3;
+       private final int[] P;
+       private boolean encrypting = false;
+       private byte[] workingKey = null;
+
+       public BlowfishEngine()
+       {
+           S0 = new int[SBOX_SK];
+           S1 = new int[SBOX_SK];
+           S2 = new int[SBOX_SK];
+           S3 = new int[SBOX_SK];
+           P = new int[P_SZ];
+       }
+
+       public void init(boolean pEncrypting, byte[] key)
+       {
+           encrypting = pEncrypting;
+           workingKey = key;
+           setKey(workingKey);
+       }
+
+       public String getAlgorithmName()
+       {
+           return "Blowfish";
+       }
+
+       public final int processBlock(byte[] in, int inOff, byte[] out, int outOff) throws IOException
+       {
+           if (workingKey == null)
+               throw new IllegalStateException("Blowfish not initialised");
+           if (inOff + BLOCK_SIZE > in.length)
+               throw new IOException("input buffer too short");
+           if (outOff + BLOCK_SIZE > out.length)
+               throw new IOException("output buffer too short");
+           if (encrypting)
+               encryptBlock(in, inOff, out, outOff);
+           else
+               decryptBlock(in, inOff, out, outOff);
+           return BLOCK_SIZE;
+       }
+
+       public void reset()
+       {
+       }
+
+       public int getBlockSize()
+       {
+           return BLOCK_SIZE;
+       }
+
+       private int F(int x)
+       {
+           return (S0[x >>> 24] + S1[x >>> 16 & 0xff] ^ S2[x >>> 8 & 0xff]) + S3[x & 0xff];
+       }
+
+       private void processTable(int xl, int xr, int[] table)
+       {
+           int size = table.length;
+           for (int s = 0; s < size; s += 2)
+           {
+               xl ^= P[0];
+               for (int i = 1; i < ROUNDS; i += 2)
+               {
+                   xr ^= F(xl) ^ P[i];
+                   xl ^= F(xr) ^ P[i + 1];
+               }
+               xr ^= P[ROUNDS + 1];
+               table[s] = xr;
+               table[s + 1] = xl;
+               xr = xl;
+               xl = table[s];
+           }
+       }
+
+       private void setKey(byte[] key)
+       {
+           System.arraycopy(KS0, 0, S0, 0, SBOX_SK);
+           System.arraycopy(KS1, 0, S1, 0, SBOX_SK);
+           System.arraycopy(KS2, 0, S2, 0, SBOX_SK);
+           System.arraycopy(KS3, 0, S3, 0, SBOX_SK);
+           System.arraycopy(KP, 0, P, 0, P_SZ);
+
+           int keyLength = key.length;
+           int keyIndex = 0;
+           for (int i = 0; i < P_SZ; i++)
+           {
+               int data = 0x0000000;
+               for (int j = 0; j < 4; j++)
+               {
+                   data = data << 8 | key[keyIndex++] & 0xff;
+                   if (keyIndex >= keyLength)
+                       keyIndex = 0;
+               }
+               P[i] ^= data;
+           }
+           processTable(0, 0, P);
+           processTable(P[P_SZ - 2], P[P_SZ - 1], S0);
+           processTable(S0[SBOX_SK - 2], S0[SBOX_SK - 1], S1);
+           processTable(S1[SBOX_SK - 2], S1[SBOX_SK - 1], S2);
+           processTable(S2[SBOX_SK - 2], S2[SBOX_SK - 1], S3);
+       }
+
+       public void encryptBlock(byte[] src, int srcIndex, byte[] dst, int dstIndex)
+       {
+           int xl = BytesTo32bits(src, srcIndex);
+           int xr = BytesTo32bits(src, srcIndex + 4);
+           xl ^= P[0];
+           for (int i = 1; i < ROUNDS; i += 2)
+           {
+               xr ^= F(xl) ^ P[i];
+               xl ^= F(xr) ^ P[i + 1];
+           }
+           xr ^= P[ROUNDS + 1];
+           Bits32ToBytes(xr, dst, dstIndex);
+           Bits32ToBytes(xl, dst, dstIndex + 4);
+       }
+
+       public void decryptBlock(byte[] src, int srcIndex, byte[] dst, int dstIndex)
+       {
+           int xl = BytesTo32bits(src, srcIndex);
+           int xr = BytesTo32bits(src, srcIndex + 4);
+           xl ^= P[ROUNDS + 1];
+           for (int i = ROUNDS; i > 0; i -= 2)
+           {
+               xr ^= F(xl) ^ P[i];
+               xl ^= F(xr) ^ P[i - 1];
+           }
+           xr ^= P[0];
+           Bits32ToBytes(xr, dst, dstIndex);
+           Bits32ToBytes(xl, dst, dstIndex + 4);
+       }
+
+       private static int BytesTo32bits(byte[] b, int i)
+       {
+           return (b[i + 3] & 0xff) << 24 | (b[i + 2] & 0xff) << 16 | (b[i + 1] & 0xff) << 8 | b[i] & 0xff;
+       }
+
+       private static void Bits32ToBytes(int in, byte[] b, int offset)
+       {
+           b[offset] = (byte) in;
+           b[offset + 1] = (byte) (in >> 8);
+           b[offset + 2] = (byte) (in >> 16);
+           b[offset + 3] = (byte) (in >> 24);
+       }
+   }
+

Index: java/hwid.crypt;FirstKey.java
===================================================================
--- package java/hwid.crypt;FirstKey.java   (revision 84)
+++ package java/hwid.crypt;FirstKey.java   (working copy)

+   package hwid.crypt;
+
+   import hwid.HwidConfig;
+
+   import java.util.logging.Logger;
+
+   public class FirstKey
+   {
+       protected static Logger _log = Logger.getLogger(FirstKey.class.getName());
+
+       private static final byte[] TKBOX =
+       {
+           -112,
+           22,
+           124,
+           -93,
+           68,
+           -116,
+           -19,
+           -125,
+           -4,
+           101,
+           -62,
+           5,
+           70,
+           25,
+           29,
+           81,
+           65,
+           -86,
+           79,
+           -69,
+           2,
+           97,
+           -108,
+           -11,
+           -84,
+           -56,
+           17,
+           7,
+           31,
+           52,
+           -34,
+           -41,
+           -110,
+           -60,
+           57,
+           -5,
+           -6,
+           -24,
+           98,
+           -100,
+           23,
+           4,
+           -74,
+           -37,
+           1,
+           6,
+           -2,
+           -14,
+           -77,
+           12,
+           -7,
+           3,
+           -29,
+           -17,
+           -75,
+           49,
+           44,
+           -78,
+           94,
+           21,
+           0,
+           35,
+           -18,
+           83,
+           9,
+           -42,
+           60,
+           93,
+           54,
+           20,
+           -49,
+           114,
+           106,
+           -82,
+           113,
+           -90,
+           86,
+           -124,
+           -73,
+           -81,
+           90,
+           121,
+           115,
+           125,
+           47,
+           24,
+           -28,
+           73,
+           56,
+           -31,
+           8,
+           71,
+           122,
+           58,
+           -33,
+           108,
+           -111,
+           102,
+           -118,
+           -103,
+           -122,
+           88,
+           28,
+           -76,
+           67,
+           -115,
+           -67,
+           78,
+           36,
+           117,
+           -8,
+           -25,
+           -97,
+           107,
+           -91,
+           -50,
+           -53,
+           -52,
+           111,
+           -114,
+           -58,
+           -128,
+           84,
+           -98,
+           63,
+           74,
+           10,
+           41,
+           -32,
+           126,
+           69,
+           -68,
+           11,
+           -119,
+           -44,
+           -39,
+           -107,
+           -40,
+           85,
+           -87,
+           61,
+           91,
+           -1,
+           50,
+           -72,
+           -117,
+           15,
+           55,
+           -51,
+           43,
+           87,
+           105,
+           120,
+           -88,
+           116,
+           80,
+           -48,
+           -123,
+           -127,
+           -105,
+           -22,
+           76,
+           109,
+           19,
+           -46,
+           -30,
+           112,
+           16,
+           -10,
+           45,
+           -63,
+           -47,
+           123,
+           -106,
+           27,
+           38,
+           104,
+           -70,
+           -79,
+           18,
+           -99,
+           -16,
+           -85,
+           -23,
+           30,
+           -66,
+           48,
+           -89,
+           -61,
+           -113,
+           -12,
+           51,
+           -95,
+           -15,
+           32,
+           -9,
+           62,
+           -38,
+           14,
+           -45,
+           -80,
+           66,
+           100,
+           103,
+           -104,
+           -27,
+           -43,
+           110,
+           -83,
+           -26,
+           -101,
+           46,
+           -120,
+           -54,
+           37,
+           42,
+           13,
+           75,
+           82,
+           -109,
+           26,
+           -94,
+           -57,
+           -64,
+           119,
+           53,
+           39,
+           -13,
+           -121,
+           33,
+           72,
+           -126,
+           -65,
+           -36,
+           -71,
+           118,
+           -35,
+           92,
+           96,
+           89,
+           64,
+           34,
+           -20,
+           -96,
+           77,
+           40,
+           127,
+           -21,
+           59,
+           -55,
+           -102,
+           95,
+           -3,
+           99,
+           -59,
+           -92
+       };
+       private static final byte[] MGBOX =
+       {
+           -14,
+           -108,
+           90,
+           75,
+           15,
+           115,
+           -38,
+           -37,
+           -125,
+           29,
+           -77,
+           9,
+           -4,
+           54,
+           -72,
+           70,
+           65,
+           -44,
+           -48,
+           85,
+           -13,
+           -121,
+           118,
+           -102,
+           40,
+           53,
+           113,
+           -5,
+           -9,
+           28,
+           3,
+           125,
+           21,
+           -124,
+           10,
+           67,
+           -6,
+           -98,
+           96,
+           -105,
+           -104,
+           126,
+           -93,
+           82,
+           -47,
+           41,
+           -91,
+           89,
+           -59,
+           122,
+           47,
+           37,
+           -31,
+           59,
+           56,
+           12,
+           -112,
+           -58,
+           -39,
+           -10,
+           -40,
+           -49,
+           22,
+           -107,
+           33,
+           -89,
+           109,
+           31,
+           88,
+           81,
+           72,
+           42,
+           -66,
+           -85,
+           -15,
+           93,
+           -101,
+           -7,
+           -128,
+           -19,
+           -27,
+           -90,
+           -11,
+           111,
+           49,
+           -70,
+           121,
+           79,
+           -123,
+           -127,
+           -79,
+           35,
+           -28,
+           114,
+           -22,
+           44,
+           -54,
+           107,
+           106,
+           30,
+           92,
+           4,
+           -43,
+           -82,
+           -78,
+           -26,
+           -61,
+           57,
+           77,
+           95,
+           58,
+           69,
+           -76,
+           103,
+           -56,
+           78,
+           26,
+           -92,
+           48,
+           -32,
+           -52,
+           16,
+           -67,
+           51,
+           -50,
+           -73,
+           -29,
+           52,
+           -60,
+           -118,
+           -1,
+           -80,
+           63,
+           2,
+           124,
+           -36,
+           -65,
+           8,
+           -33,
+           -115,
+           -3,
+           108,
+           -21,
+           18,
+           110,
+           36,
+           -51,
+           46,
+           -103,
+           94,
+           20,
+           -114,
+           80,
+           127,
+           -86,
+           19,
+           -119,
+           -113,
+           68,
+           -25,
+           -120,
+           -71,
+           32,
+           38,
+           -95,
+           -57,
+           5,
+           7,
+           105,
+           -17,
+           -34,
+           -81,
+           24,
+           -74,
+           -35,
+           100,
+           1,
+           -46,
+           -94,
+           43,
+           13,
+           17,
+           -87,
+           11,
+           -69,
+           -62,
+           -126,
+           -63,
+           -64,
+           -23,
+           -97,
+           27,
+           -18,
+           -53,
+           84,
+           0,
+           -106,
+           -83,
+           39,
+           116,
+           91,
+           104,
+           14,
+           -24,
+           -42,
+           34,
+           -88,
+           -84,
+           62,
+           61,
+           -2,
+           112,
+           23,
+           119,
+           73,
+           6,
+           -122,
+           55,
+           -99,
+           -41,
+           83,
+           99,
+           60,
+           87,
+           45,
+           120,
+           -55,
+           117,
+           -117,
+           98,
+           123,
+           -8,
+           76,
+           -16,
+           -30,
+           64,
+           -96,
+           -109,
+           -75,
+           25,
+           101,
+           -110,
+           86,
+           50,
+           71,
+           -12,
+           74,
+           -100,
+           -116,
+           -68,
+           66,
+           -20,
+           -45,
+           102,
+           -111,
+           97
+       };
+       public static final byte[] SKBOX =
+       {
+           HwidConfig.FST_KEY,
+           HwidConfig.SCN_KEY,
+           2,
+           15,
+           -5,
+           17,
+           24,
+           23,
+           18,
+           45,
+           1,
+           21,
+           122,
+           16,
+           HwidConfig.ANP_KEY,
+           HwidConfig.ULT_KEY
+       };
+
+       public static byte[] expandKey(byte[] key, int size)
+       {
+           byte[] P = new byte[64];
+
+           for (int i = 0; i < 64; i++)
+               P[i] = key[i % size];
+
+           for (int i = 0; i < 256; i++)
+           {
+               byte t = P[i % 64];
+               byte m = (byte) (MGBOX[MGBOX[t & 0xFF] & 0xFF] & 0xFF ^ TKBOX[TKBOX[i] & 0xFF] & 0xFF);
+               P[i % 64] = TKBOX[m & 0xFF];
+           }
+
+           return P;
+       }
+
+   }
+

Index: java/hwid.crypt;GameCrypt.java
===================================================================
--- package java/hwid.crypt;GameCrypt.java  (revision 84)
+++ package java/hwid.crypt;GameCrypt.java  (working copy)

+   package hwid.crypt;
+
+   import hwid.HwidConfig;
+   import hwid.crypt.impl.L2Client;
+   import hwid.crypt.impl.L2Server;
+   import hwid.crypt.impl.VMPC;
+
+   public class GameCrypt
+   {
+       private ProtectionCrypt _client;
+       private ProtectionCrypt _server;
+       private boolean _isEnabled = false;
+       private boolean _isProtected = false;
+
+       public void setProtected(boolean state)
+       {
+           _isProtected = state;
+       }
+
+       public void setKey(byte[] key)
+       {
+           if (_isProtected)
+           {
+               _client = new VMPC();
+               _client.setup(key, HwidConfig.GUARD_CLIENT_CRYPT);
+               _server = new L2Server();
+               _server.setup(key, null);
+               _server = new VMPC();
+               _server.setup(key, HwidConfig.GUARD_SERVER_CRYPT);
+           }
+           else
+           {
+               _client = new L2Client();
+               _client.setup(key, null);
+               _server = new L2Server();
+               _server.setup(key, null);
+           }
+       }
+
+       public void decrypt(byte[] raw, int offset, int size)
+       {
+           if (_isEnabled)
+               _client.crypt(raw, offset, size);
+       }
+
+       public void encrypt(byte[] raw, int offset, int size)
+       {
+           if (_isEnabled)
+               _server.crypt(raw, offset, size);
+           else
+               _isEnabled = true;
+       }
+   }
+

Index: java/hwid.crypt;GameCrypt.java
===================================================================
--- package java/hwid.crypt;Manager.java    (revision 84)
+++ package java/hwid.crypt;Manager.java    (working copy)


+   package hwid.crypt;
+
+   import hwid.hwidmanager.HWIDManager;
+
+   import java.util.Iterator;
+   import java.util.concurrent.ConcurrentHashMap;
+   import java.util.concurrent.ScheduledFuture;
+   import java.util.logging.Logger;
+
+   import net.sf.l2j.Config;
+   import net.sf.l2j.gameserver.network.GameClient;
+
+   public final class Manager
+   {
+       protected static Logger _log = Logger.getLogger(Manager.class.getName());
+
+       protected static String _logFile = "Manager";
+       protected static String _logMainFile = "hwid_logs";
+       protected static Manager _instance;
+       protected static ScheduledFuture<?> _GGTask = null;
+       protected static ConcurrentHashMap<String, Manager.InfoSet> _objects = new ConcurrentHashMap<>();
+
+       public Manager()
+       {
+           //
+       }
+
+       public static Manager getInstance()
+       {
+           if (_instance == null)
+           {
+               System.out.println("- HWID Manager read successfully...");
+               _instance = new Manager();
+           }
+
+           return _instance;
+       }
+
+       public class InfoSet
+       {
+           public String _playerName = "";
+           public long _lastGGSendTime;
+           public long _lastGGRecvTime;
+           public int _attempts;
+           public String _HWID = "";
+
+           public InfoSet(String name, String HWID)
+           {
+               _playerName = name;
+               _lastGGSendTime = System.currentTimeMillis();
+               _lastGGRecvTime = _lastGGSendTime;
+               _attempts = 0;
+               _HWID = HWID;
+           }
+       }
+
+       public void addPlayer(GameClient client)
+       {
+           int i = 1;
+           HWIDManager.updateHWIDInfo(client, i++);
+           _objects.put(client.getPlayerName(), new Manager.InfoSet(client.getPlayerName(), client.getHWID()));
+       }
+
+       public static void removePlayer(String name)
+       {
+           if (!_objects.containsKey(name))
+           {
+               if (Config.DEBUG_PATH)
+                   _log.warning("trying to remove player that non exists");
+           }
+           else
+               _objects.remove(name);
+       }
+
+       public static int getCountByHWID(String HWID)
+       {
+           int result = 0;
+           Iterator<InfoSet> var3 = _objects.values().iterator();
+
+           while (var3.hasNext())
+           {
+               Manager.InfoSet object = var3.next();
+
+               if (object._HWID.equals(HWID))
+                   ++result;
+           }
+
+           return result;
+       }
+
+   }
+

Index: java/hwid.crypt;ProtectionCrypt.java
===================================================================
--- package java/hwid.crypt;ProtectionCrypt.java    (revision 84)
+++ package java/hwid.crypt;ProtectionCrypt.java    (working copy)

+   package hwid.crypt;
+
+   public abstract interface ProtectionCrypt
+   {
+       public abstract void setup(byte[] rnd_key, byte[] client_server_key);
+
+       public abstract void crypt(byte[] raw, int offset, int size);
+   }
+

Index: java/hwid.crypt;ProtectionPackets.java
===================================================================
--- package java/hwid.crypt;ProtectionPackets.java  (revision 84)
+++ package java/hwid.crypt;ProtectionPackets.java  (working copy)

+   package hwid.crypt;
+
+   import hwid.utils.Rnd;
+
+   public class ProtectionPackets
+   {
+       public static int readB(byte[] raw, int offset, byte[] data, int size)
+       {
+           for (int i = 0; i < size; i++)
+           {
+               data[i] = (byte) (raw[offset] ^ raw[0]);
+               offset += raw[offset + 1] & 0xFF;
+           }
+
+           return offset;
+       }
+
+       public static int readS(byte[] raw, int offset, byte[] data, int size)
+       {
+           for (int i = 0; i < size; i++)
+           {
+               data[i] = (byte) (raw[offset] ^ raw[0]);
+               offset += raw[offset + 1] & 0xFF;
+
+               if (data[i] == 0)
+                   break;
+           }
+           return offset;
+       }
+
+       public static int writeB(byte[] raw, int offset, byte[] data, int size)
+       {
+           for (int i = 0; i < size; i++)
+           {
+               raw[offset] = (byte) (data[i] ^ raw[0]);
+               raw[offset + 1] = (byte) (2 + Rnd.nextInt(10));
+               offset += raw[offset + 1] & 0xFF;
+           }
+
+           return offset;
+       }
+
+       public static byte ck(byte[] raw, int offset, int size)
+       {
+           byte c = -1;
+
+           for (int i = 0; i < size; i++)
+               c = (byte) (c ^ raw[offset + i]);
+           return c;
+       }
+   }
+

Index: java/hwid.crypt.impl;L2Client.java
===================================================================
--- package java/hwid.crypt.impl;L2Client.java  (revision 84)
+++ package java/hwid.crypt.impl;L2Client.java  (working copy)

+   package hwid.crypt.impl;
+
+   import hwid.crypt.ProtectionCrypt;
+
+   public class L2Client implements ProtectionCrypt
+   {
+       private ProtectionCrypt _client;
+       private final byte[] _key = new byte[16];
+       private byte[] _iv = null;
+
+       @Override
+       public void setup(byte[] key, byte[] iv)
+       {
+           System.arraycopy(key, 0, _key, 0, 16);
+           _iv = iv;
+       }
+
+       @Override
+       public void crypt(byte[] raw, int offset, int size)
+       {
+           if (_iv != null)
+           {
+               _client = new VMPC();
+               _client.setup(_key, _iv);
+               _client.crypt(raw, offset, size);
+           }
+           int temp = 0;
+           int temp2 = 0;
+           for (int i = 0; i < size; i++)
+           {
+               temp2 = raw[offset + i] & 0xFF;
+               raw[offset + i] = (byte) (temp2 ^ _key[i & 0xF] ^ temp);
+               temp = temp2;
+           }
+
+           int old = _key[8] & 0xFF;
+           old |= _key[9] << 8 & 0xFF00;
+           old |= _key[10] << 16 & 0xFF0000;
+           old |= _key[11] << 24 & 0xFF000000;
+
+           old += size;
+
+           _key[8] = (byte) (old & 0xFF);
+           _key[9] = (byte) (old >> 8 & 0xFF);
+           _key[10] = (byte) (old >> 16 & 0xFF);
+           _key[11] = (byte) (old >> 24 & 0xFF);
+       }
+   }
+

Index: java/hwid.crypt.impl;L2Server.java
===================================================================
--- package java/hwid.crypt.impl;L2Server.java  (revision 84)
+++ package java/hwid.crypt.impl;L2Server.java  (working copy)

+   package hwid.crypt.impl;
+
+   import hwid.crypt.ProtectionCrypt;
+
+   public class L2Server implements ProtectionCrypt
+   {
+       private final byte[] _key = new byte[16];
+       private byte[] _iv = null;
+       private ProtectionCrypt _server;
+
+       @Override
+       public void setup(byte[] key, byte[] iv)
+       {
+           System.arraycopy(key, 0, _key, 0, 16);
+           _iv = iv;
+       }
+
+       @Override
+       public void crypt(byte[] raw, int offset, int size)
+       {
+           int temp = 0;
+           for (int i = 0; i < size; i++)
+           {
+               int temp2 = raw[offset + i] & 0xFF;
+               temp = temp2 ^ _key[i & 0xF] ^ temp;
+               raw[offset + i] = (byte) temp;
+           }
+
+           int old = _key[8] & 0xFF;
+           old |= _key[9] << 8 & 0xFF00;
+           old |= _key[10] << 16 & 0xFF0000;
+           old |= _key[11] << 24 & 0xFF000000;
+
+           old += size;
+
+           _key[8] = (byte) (old & 0xFF);
+           _key[9] = (byte) (old >> 8 & 0xFF);
+           _key[10] = (byte) (old >> 16 & 0xFF);
+           _key[11] = (byte) (old >> 24 & 0xFF);
+
+           if (_iv != null)
+           {
+               _server = new VMPC();
+               _server.setup(_key, _iv);
+               _server.crypt(raw, offset, size);
+           }
+       }
+   }
+

Index: java/hwid.crypt.impl;VMPC.java
===================================================================
--- package java/hwid.crypt.impl;VMPC.java  (revision 84)
+++ package java/hwid.crypt.impl;VMPC.java  (working copy)

+   package hwid.crypt.impl;
+
+   import hwid.crypt.ProtectionCrypt;
+
+   public class VMPC implements ProtectionCrypt
+   {
+       private byte _n = 0;
+       private final byte[] _P = new byte[256];
+       private byte _s = 0;
+
+       @Override
+       public void setup(byte[] key, byte[] iv)
+       {
+           _s = 0;
+
+           for (int i = 0; i < 256; i++)
+               _P[i] = (byte) (i & 0xFF);
+
+           for (int m = 0; m < 768; m++)
+           {
+               _s = _P[_s + _P[m & 0xFF] + key[m % 64] & 0xFF];
+               byte temp = _P[m & 0xFF];
+               _P[m & 0xFF] = _P[_s & 0xFF];
+               _P[_s & 0xFF] = temp;
+           }
+
+           for (int m = 0; m < 768; m++)
+           {
+               _s = _P[_s + _P[m & 0xFF] + iv[m % 64] & 0xFF];
+               byte temp = _P[m & 0xFF];
+               _P[m & 0xFF] = _P[_s & 0xFF];
+               _P[_s & 0xFF] = temp;
+           }
+
+           for (int m = 0; m < 768; m++)
+           {
+               _s = _P[_s + _P[m & 0xFF] + key[m % 64] & 0xFF];
+               byte temp = _P[m & 0xFF];
+               _P[m & 0xFF] = _P[_s & 0xFF];
+               _P[_s & 0xFF] = temp;
+           }
+
+           _n = 0;
+       }
+
+       @Override
+       public void crypt(byte[] raw, int offset, int size)
+       {
+           for (int i = 0; i < size; i++)
+           {
+               _s = _P[_s + _P[_n & 0xFF] & 0xFF];
+               byte z = _P[_P[_P[_s & 0xFF] & 0xFF] + 1 & 0xFF];
+               byte temp = _P[_n & 0xFF];
+               _P[_n & 0xFF] = _P[_s & 0xFF];
+               _P[_s & 0xFF] = temp;
+               _n = (byte) (_n + 1 & 0xFF);
+               raw[offset + i] = (byte) (raw[offset + i] ^ z);
+           }
+       }
+   }
+

Index: java/hwid.hwidmanager;HWIDAdminBan.java
===================================================================
--- package java/hwid.hwidmanager;HWIDAdminBan.java (revision 84)
+++ package java/hwid.hwidmanager;HWIDAdminBan.java (working copy)

+   package hwid.hwidmanager;
+
+   import hwid.HwidConfig;
+
+   import net.sf.l2j.gameserver.handler.IAdminCommandHandler;
+   import net.sf.l2j.gameserver.model.WorldObject;
+   import net.sf.l2j.gameserver.model.actor.Player;
+
+   public class HWIDAdminBan implements IAdminCommandHandler
+   {
+       private static final String[] ADMIN_COMMANDS =
+       {
+           "admin_ban_hwid"
+       };
+
+       @Override
+       public boolean useAdminCommand(String command, Player activeChar)
+       {
+           if (!HwidConfig.ALLOW_GUARD_SYSTEM)
+               return false;
+
+           if (activeChar == null)
+               return false;
+
+           if (command.startsWith("admin_ban_hwid"))
+           {
+               WorldObject playerTarger = activeChar.getTarget();
+
+               if (playerTarger != null && !playerTarger.equals(activeChar))
+               {
+                   activeChar.sendMessage("Target is empty");
+                   return false;
+               }
+
+               if (playerTarger == null && activeChar.equals(""))
+               {
+                   activeChar.sendMessage("Usage: //ban_hwid <account_name> (if none, target char's account gets banned).");
+                   return false;
+               }
+
+               Player target = (Player) playerTarger;
+               if (target != null)
+               {
+                   HWIDBan.addHWIDBan(target.getClient());
+                   activeChar.sendMessage(target.getName() + " banned in HWID");
+               }
+           }
+
+           return true;
+       }
+
+       @Override
+       public String[] getAdminCommandList()
+       {
+           return ADMIN_COMMANDS;
+       }
+   }
+

Index: java/hwid.hwidmanager;HWIDBan.java
===================================================================
--- package java/hwid.hwidmanager;HWIDBan.java  (revision 84)
+++ package java/hwid.hwidmanager;HWIDBan.java  (working copy)

+   package hwid.hwidmanager;
+
+   import java.sql.Connection;
+   import java.sql.PreparedStatement;
+   import java.sql.ResultSet;
+   import java.util.HashMap;
+   import java.util.Map;
+   import java.util.logging.Logger;
+
+   import net.sf.l2j.L2DatabaseFactory;
+   import net.sf.l2j.gameserver.network.GameClient;
+
+
+   public class HWIDBan
+   {
+       protected static Logger _log = Logger.getLogger(HWIDBan.class.getName());
+       private static HWIDBan _instance;
+       private static Map<Integer, HWIDBanList> _lists;
+
+       public HWIDBan()
+       {
+           _lists = new HashMap<>();
+           load();
+           System.out.println("- HWID Ban: Loaded " + _lists.size() + " HWIDs");
+       }
+
+       public static HWIDBan getInstance()
+       {
+           if (_instance == null)
+               _instance = new HWIDBan();
+           return _instance;
+       }
+
+       @SuppressWarnings("resource")
+       private static void load()
+       {
+           String HWID = "";
+           int counterHWIDBan = 0;
+           try
+           {
+               Connection con = L2DatabaseFactory.getInstance().getConnection();
+               Throwable localThrowable2 = null;
+               try
+               {
+                   PreparedStatement statement = con.prepareStatement("SELECT * FROM hwid_bans");
+                   ResultSet rset = statement.executeQuery();
+                   while (rset.next())
+                   {
+                       HWID = rset.getString("HWID");
+                       HWIDBanList hb = new HWIDBanList(counterHWIDBan);
+                       hb.setHWIDBan(HWID);
+                       _lists.put(Integer.valueOf(counterHWIDBan), hb);
+                       counterHWIDBan++;
+                   }
+               }
+               catch (Throwable localThrowable1)
+               {
+                   localThrowable2 = localThrowable1;
+                   throw localThrowable1;
+               }
+               finally
+               {
+                   if (con != null)
+                       if (localThrowable2 != null)
+                           try
+                   {
+                               con.close();
+                   }
+                   catch (Throwable x2)
+                   {
+                       localThrowable2.addSuppressed(x2);
+                   }
+                       else
+                           con.close();
+               }
+           }
+           catch (Exception e)
+           {
+               e.printStackTrace();
+           }
+       }
+
+       public static void reload()
+       {
+           _instance = new HWIDBan();
+       }
+
+       public boolean checkFullHWIDBanned(GameClient client)
+       {
+           if (_lists.size() == 0)
+               return false;
+           for (int i = 0; i < _lists.size(); i++)
+               if (_lists.get(Integer.valueOf(i)).getHWID().equals(client.getHWID()))
+                   return true;
+           return false;
+       }
+
+       public static int getCountHWIDBan()
+       {
+           return _lists.size();
+       }
+
+       @SuppressWarnings("resource")
+       public static void addHWIDBan(GameClient client)
+       {
+           String HWID = client.getHWID();
+           int counterHwidBan = _lists.size();
+           HWIDBanList hb = new HWIDBanList(counterHwidBan);
+           hb.setHWIDBan(HWID);
+           _lists.put(Integer.valueOf(counterHwidBan), hb);
+           try
+           {
+               Connection con = L2DatabaseFactory.getInstance().getConnection();
+               Throwable localThrowable2 = null;
+               try
+               {
+                   PreparedStatement statement = con.prepareStatement("INSERT INTO hwid_bans SET HWID=?");
+                   statement.setString(1, HWID);
+                   statement.execute();
+               }
+               catch (Throwable localThrowable1)
+               {
+                   localThrowable2 = localThrowable1;
+                   throw localThrowable1;
+               }
+               finally
+               {
+                   if (con != null)
+                       if (localThrowable2 != null)
+                           try
+                   {
+                               con.close();
+                   }
+                   catch (Throwable x2)
+                   {
+                       localThrowable2.addSuppressed(x2);
+                   }
+                       else
+                           con.close();
+               }
+           }
+           catch (Exception e)
+           {
+               e.printStackTrace();
+           }
+       }
+   }
+

Index: java/hwid.hwidmanager;HWIDBanList.java
===================================================================
--- package java/hwid.hwidmanager;HWIDBanList.java  (revision 84)
+++ package java/hwid.hwidmanager;HWIDBanList.java  (working copy)

+   package hwid.hwidmanager;
+
+   public class HWIDBanList
+   {
+       private final int _id;
+       private String HWID;
+
+       public HWIDBanList(int id)
+       {
+           _id = id;
+       }
+
+       public int getId()
+       {
+           return _id;
+       }
+
+       public String getHWID()
+       {
+           return HWID;
+       }
+
+       public void setHWIDBan(String hwid1)
+       {
+           HWID = hwid1;
+       }
+   }
+

Index: java/hwid.hwidmanager;HWIDInfoList.java
===================================================================
--- package java/hwid.hwidmanager;HWIDInfoList.java (revision 84)
+++ package java/hwid.hwidmanager;HWIDInfoList.java (working copy)

+   package hwid.hwidmanager;
+
+   public class HWIDInfoList
+   {
+       private final int _id;
+       private String HWID;
+       private int count;
+       private int playerID;
+       private String login;
+       private LockType lockType;
+
+       public static enum LockType
+       {
+           PLAYER_LOCK,
+           ACCOUNT_LOCK,
+           NONE
+       }
+
+       public HWIDInfoList(int id)
+       {
+           _id = id;
+       }
+
+       public int get_id()
+       {
+           return _id;
+       }
+
+       public void setHwids(String hwid)
+       {
+           HWID = hwid;
+           count = 1;
+       }
+
+       public String getHWID()
+       {
+           return HWID;
+       }
+
+       public void setHWID(String HWID)
+       {
+           this.HWID = HWID;
+       }
+
+       public int getPlayerID()
+       {
+           return playerID;
+       }
+
+       public void setPlayerID(int playerID)
+       {
+           this.playerID = playerID;
+       }
+
+       public String getLogin()
+       {
+           return login;
+       }
+
+       public void setLogin(String login)
+       {
+           this.login = login;
+       }
+
+       public LockType getLockType()
+       {
+           return lockType;
+       }
+
+       public void setLockType(LockType lockType)
+       {
+           this.lockType = lockType;
+       }
+
+       public int getCount()
+       {
+           return count;
+       }
+
+       public void setCount(int count)
+       {
+           this.count = count;
+       }
+   }
+

Index: java/hwid.hwidmanager;HWIDManager.java
===================================================================
--- package java/hwid.hwidmanager;HWIDManager.java  (revision 84)
+++ package java/hwid.hwidmanager;HWIDManager.java  (working copy)

+   package hwid.hwidmanager;
+
+   import java.sql.Connection;
+   import java.sql.PreparedStatement;
+   import java.sql.ResultSet;
+   import java.util.HashMap;
+   import java.util.Map;
+   import java.util.logging.Logger;
+
+   import net.sf.l2j.L2DatabaseFactory;
+   import net.sf.l2j.gameserver.network.GameClient;
+
+   public class HWIDManager
+   {
+       protected static Logger _log = Logger.getLogger(HWIDManager.class.getName());
+       private static HWIDManager _instance;
+       public static Map<Integer, HWIDInfoList> _listHWID;
+       public static Map<Integer, Integer> _sessions;
+
+       public HWIDManager()
+       {
+           _listHWID = new HashMap<>();
+           load();
+           System.out.println("- HWID Info: Loaded " + _listHWID.size() + " HWIDs");
+       }
+
+       public static HWIDManager getInstance()
+       {
+           if (_instance == null)
+               _instance = new HWIDManager();
+
+           return _instance;
+       }
+
+       @SuppressWarnings("resource")
+       private static void load()
+       {
+           try
+           {
+               Connection con = L2DatabaseFactory.getInstance().getConnection();
+               Throwable localThrowable2 = null;
+               try
+               {
+                   PreparedStatement statement = con.prepareStatement("SELECT * FROM hwid_info");
+                   ResultSet rset = statement.executeQuery();
+                   int counterHWIDInfo = 0;
+                   while (rset.next())
+                   {
+                       HWIDInfoList hInfo = new HWIDInfoList(counterHWIDInfo);
+                       hInfo.setHwids(rset.getString("HWID"));
+                       hInfo.setCount(rset.getInt("WindowsCount"));
+                       hInfo.setLogin(rset.getString("Account"));
+                       hInfo.setPlayerID(rset.getInt("PlayerID"));
+                       hInfo.setLockType(HWIDInfoList.LockType.valueOf(rset.getString("LockType")));
+                       _listHWID.put(Integer.valueOf(counterHWIDInfo), hInfo);
+                       counterHWIDInfo++;
+                   }
+               }
+               catch (Throwable localThrowable1)
+               {
+                   localThrowable2 = localThrowable1;
+                   throw localThrowable1;
+               }
+               finally
+               {
+                   if (con != null)
+                       if (localThrowable2 != null)
+                           try
+                   {
+                               con.close();
+                   }
+                   catch (Throwable x2)
+                   {
+                       localThrowable2.addSuppressed(x2);
+                   }
+                       else
+                           con.close();
+               }
+           }
+           catch (Exception e)
+           {
+               e.printStackTrace();
+           }
+       }
+
+       public static int getAllowedWindowsCount(final GameClient pi)
+       {
+           if (_listHWID.size() == 0)
+               return -1;
+
+           for (int i = 0; i < _listHWID.size(); i++)
+               if (_listHWID.get(i).getHWID().equals(pi.getHWID()))
+               {
+                   if (_listHWID.get(i).getHWID().equals(""))
+                       return -1;
+
+                   return _listHWID.get(i).getCount();
+               }
+           return -1;
+       }
+
+       public static void reload()
+       {
+           _instance = new HWIDManager();
+       }
+
+       public static void updateHWIDInfo(GameClient client, int windowscount)
+       {
+           updateHWIDInfo(client, windowscount, HWIDInfoList.LockType.NONE);
+       }
+
+       public static void updateHwidInfo(final GameClient client, final HWIDInfoList.LockType lockType)
+       {
+           updateHWIDInfo(client, 1, lockType);
+       }
+
+       @SuppressWarnings("resource")
+       public static void updateHWIDInfo(GameClient client, int windowsCount, HWIDInfoList.LockType lockType)
+       {
+           int counterHwidInfo = _listHWID.size();
+           boolean isFound = false;
+
+           for (int i = 0; i < _listHWID.size(); i++)
+               if (_listHWID.get(i).getHWID().equals(client.getHWID()))
+               {
+                   isFound = true;
+                   counterHwidInfo = i;
+                   break;
+               }
+
+           final HWIDInfoList hInfo = new HWIDInfoList(counterHwidInfo);
+           hInfo.setHwids(client.getHWID());
+           hInfo.setCount(windowsCount);
+           hInfo.setLogin(client.getAccountName());
+           hInfo.setPlayerID(client.getPlayerId());
+           hInfo.setLockType(lockType);
+           _listHWID.put(Integer.valueOf(counterHwidInfo), hInfo);
+
+           if (isFound)
+               try
+           {
+                   Connection con = L2DatabaseFactory.getInstance().getConnection();
+                   Throwable localThrowable3 = null;
+                   try
+                   {
+                       PreparedStatement statement = con.prepareStatement("UPDATE hwid_info SET WindowsCount=?,Account=?,PlayerID=?,LockType=? WHERE HWID=?");
+                       statement.setInt(1, windowsCount);
+                       statement.setString(2, client.getPlayerName());
+                       statement.setInt(3, client.getPlayerId());
+                       statement.setString(4, lockType.toString());
+                       statement.setString(5, client.getHWID());
+                       statement.execute();
+                   }
+                   catch (Throwable localThrowable1)
+                   {
+                       localThrowable3 = localThrowable1;
+                       throw localThrowable1;
+                   }
+                   finally
+                   {
+                       if (con != null)
+                           if (localThrowable3 != null)
+                               try
+                       {
+                                   con.close();
+                       }
+                       catch (Throwable x2)
+                       {
+                           localThrowable3.addSuppressed(x2);
+                       }
+                           else
+                               con.close();
+                   }
+           }
+           catch (Exception e)
+           {
+               e.printStackTrace();
+           }
+           else
+               try
+           {
+                   Connection con = L2DatabaseFactory.getInstance().getConnection();
+                   Throwable localThrowable3 = null;
+                   try
+                   {
+                       PreparedStatement statement = con.prepareStatement("INSERT INTO hwid_info (HWID, WindowsCount, Account, PlayerID, LockType) values (?,?,?,?,?)");
+                       statement.setString(1, client.getHWID());
+                       statement.setInt(2, windowsCount);
+                       statement.setString(3, client.getPlayerName());// .getAccountName());
+                       statement.setInt(4, client.getPlayerId());
+                       statement.setString(5, lockType.toString());
+                       statement.execute();
+                   }
+                   catch (Throwable localThrowable2)
+                   {
+                       localThrowable3 = localThrowable2;
+                       throw localThrowable2;
+                   }
+                   finally
+                   {
+                       if (con != null)
+                           if (localThrowable3 != null)
+                               try
+                       {
+                                   con.close();
+                       }
+                       catch (Throwable x2)
+                       {
+                           localThrowable3.addSuppressed(x2);
+                       }
+                           else
+                               con.close();
+                   }
+           }
+           catch (Exception e)
+           {
+               e.printStackTrace();
+           }
+       }
+
+       public static void updateHWIDInfo(GameClient client, HWIDInfoList.LockType lockType)
+       {
+           updateHWIDInfo(client, 1, lockType);
+       }
+
+       public static int getCountHwidInfo()
+       {
+           return _listHWID.size();
+       }
+   }
+

Index: java/hwid.utils;Rnd.java
===================================================================
--- package java/hwid.utils;Rnd.java    (revision 84)
+++ package java/hwid.utils;Rnd.java    (working copy)

+   package hwid.utils;
+
+   import java.util.Random;
+
+   public class Rnd
+   {
+       private static final Random random = new Random();
+
+       public static int nextInt(int n)
+       {
+           if (n < 0)
+               return random.nextInt(-n) * -1;
+           if (n == 0)
+               return 0;
+           return random.nextInt(n);
+       }
+
+       public static byte[] nextBytes(byte[] array)
+       {
+           random.nextBytes(array);
+           return array;
+       }
+   }
+

Index: java/hwid.utils;Util.java
===================================================================
--- package java/hwid.utils;Util.java   (revision 84)
+++ package java/hwid.utils;Util.java   (working copy)

+   package hwid.utils;
+
+   public class Util
+   {
+       public Util()
+       {
+       }
+
+       public static void intToBytes(int value, byte[] array, int offset)
+       {
+           array[offset++] = (byte) (value & 255);
+           array[offset++] = (byte) (value >> 8 & 255);
+           array[offset++] = (byte) (value >> 16 & 255);
+           array[offset++] = (byte) (value >> 24 & 255);
+       }
+
+       public static String LastErrorConvertion(Integer LastError)
+       {
+           return LastError.toString();
+       }
+
+       public static final String asHex(byte[] raw)
+       {
+           return asHex(raw, 0, raw.length);
+       }
+
+       public static final String asHex(byte[] raw, int offset, int size)
+       {
+           StringBuffer strbuf = new StringBuffer(raw.length * 2);
+
+           for (int i = 0; i < size; ++i)
+           {
+               if ((raw[offset + i] & 255) < 16)
+                   strbuf.append("0");
+
+               strbuf.append(Long.toString(raw[offset + i] & 255, 16));
+           }
+
+           return strbuf.toString();
+       }
+
+       public static int bytesToInt(byte[] array, int offset)
+       {
+           return array[offset++] & 255 | (array[offset++] & 255) << 8 | (array[offset++] & 255) << 16 | (array[offset++] & 255) << 24;
+       }
+
+       public static String asHwidString(String hex)
+       {
+           byte[] buf = asByteArray(hex);
+           return asHex(buf);
+       }
+
+       public static byte[] asByteArray(String hex)
+       {
+           byte[] buf = new byte[hex.length() / 2];
+
+           for (int i = 0; i < hex.length(); i += 2)
+           {
+               int j = Integer.parseInt(hex.substring(i, i + 2), 16);
+               buf[i / 2] = (byte) (j & 255);
+           }
+
+           return buf;
+       }
+
+       public static boolean verifyChecksum(byte[] raw, int offset, int size)
+       {
+           if ((size & 3) == 0 && size > 4)
+           {
+               long chksum = 0L;
+               int count = size - 4;
+
+               for (int i1 = offset; i1 < count; i1 += 4)
+                   chksum ^= bytesToInt(raw, i1);
+
+               long check = bytesToInt(raw, count);
+               return check == chksum;
+           }
+           return false;
+       }
+
+       /*
+        * public static byte[] asByteArray(String hex) { byte[] buf = new byte[hex.length() / 2]; for (int i = 0; i < hex.length(); i += 2) { int j = Integer.parseInt(hex.substring(i, i + 2), 16); buf[(i / 2)] = (byte)(j & 0xFF); } return buf; } public static String asHwidString(String hex) { byte[]
+        * buf = asByteArray(hex); return asHex(buf); } public static final String asHex(byte[] raw, int offset, int size) { StringBuffer strbuf = new StringBuffer(raw.length * 2); for (int i = 0; i < size; i++) { if ((raw[(offset + i)] & 0xFF) < 16) { strbuf.append("0"); }
+        * strbuf.append(Long.toString(raw[(offset + i)] & 0xFF, 16)); } return strbuf.toString(); } public static final String asHex(byte[] raw) { return asHex(raw, 0, raw.length); }
+        */
+   }
+

Index: net.sf.l2j.gameserver;GameServer.java
===================================================================
--- package net.sf.l2j.gameserver;GameServer.java   (revision 84)
+++ package net.sf.l2j.gameserver;GameServer.java   (working copy)

+   import hwid.Hwid;

+       StringUtil.printSection("Hwid Manager");
+       Hwid.Init();

Index: net.sf.l2j.gameserver.handler;AdminCommandHandler.java
===================================================================
--- package net.sf.l2j.gameserver.handler;AdminCommandHandler.java  (revision 84)
+++ package net.sf.l2j.gameserver.handler;AdminCommandHandler.java  (working copy)

+   import hwid.hwidmanager.HWIDAdminBan;

+   registerHandler(new HWIDAdminBan());

Index: net.sf.l2j.gameserver.network;GameClient.java
===================================================================
--- package net.sf.l2j.gameserver.network;GameClient.java   (revision 84)
+++ package net.sf.l2j.gameserver.network;GameClient.java   (working copy)

+   import hwid.Hwid;

        catch (RejectedExecutionException e)
        {
        }

+       Hwid.doDisconection(this);


    public byte[] enableCrypt()
    {
        byte[] key = BlowFishKeygen.getRandomKey();
        _crypt.setKey(key);

+       if (Hwid.isProtectionOn())
+           key = Hwid.getKey(key);

        return key;
    }

            // Cancel cleanup task, if running.
        if (_cleanupTask != null)
        {
            _cleanupTask.cancel(true);
            _cleanupTask = null;
        }

+       Hwid.doDisconection(this);

Index: net.sf.l2j.gameserver.network.clientpackets;AuthLogin.java
===================================================================
--- package net.sf.l2j.gameserver.network.clientpackets;AuthLogin.java  (revision 84)
+++ package net.sf.l2j.gameserver.network.clientpackets;AuthLogin.java  (working copy)

+   import hwid.Hwid;

    @Override
    protected void runImpl()
    {
+       if (Hwid.isProtectionOn())
+           if (!Hwid.doAuthLogin(getClient(), _data, _loginName))
+               return;

Index: net.sf.l2j.gameserver.network.clientpackets;EnterWorld.java
===================================================================
--- package net.sf.l2j.gameserver.network.clientpackets;EnterWorld.java (revision 84)
+++ package net.sf.l2j.gameserver.network.clientpackets;EnterWorld.java (working copy)

+   import hwid.Hwid;


    @Override
    protected void runImpl()
    {
        final Player player = getClient().getPlayer();

+       // Means that it's not ok multiBox situation, so logout
+       Hwid.enterlog(player, getClient());

Index: net.sf.l2j.gameserver.network.clientpackets;GameGuardReply.java
===================================================================
--- package net.sf.l2j.gameserver.network.clientpackets;ProtocolVersion.java    (revision 84)
+++ package net.sf.l2j.gameserver.network.clientpackets;ProtocolVersion.java    (working copy)
===================================================================
--- package net.sf.l2j.gameserver.network.clientpackets;GameGuardReply.java (revision 84)
+++ package net.sf.l2j.gameserver.network.clientpackets;GameGuardReply.java (working copy)


+   private int _version;
+   private byte _data[];
+   private String _hwidHdd = "NoHWID-HD";
+   private String _hwidMac = "NoHWID-MAC";
+   private String _hwidCPU = "NoHWID-CPU";

    @Override
    protected void readImpl()
    {

+       _version = readD();
+       if (Hwid.isProtectionOn())
+       {
+           if (_buf.remaining() > 260)
+           {
+               _data = new byte[260];
+               readB(_data);
+               if (Hwid.isProtectionOn())
+               {
+                   _hwidHdd = readS();
+                   _hwidMac = readS();
+                   _hwidCPU = readS();
+               }
+           }
+       }
+       else if (Hwid.isProtectionOn())
+           getClient().close(new KeyPacket(getClient().enableCrypt()));
    }

        @Override
    protected void runImpl()
    {
+       if (_version == -2)
+           getClient().close((L2GameServerPacket) null);
+       else if (_version < Config.MIN_PROTOCOL_REVISION || _version > Config.MAX_PROTOCOL_REVISION)
+       {
+           LOGGER.info("Client: " + getClient().toString() + " -> Protocol Revision: " + _version + " is invalid. Minimum and maximum allowed are: " + Config.MIN_PROTOCOL_REVISION + " and " + Config.MAX_PROTOCOL_REVISION + ". Closing connection.");
+           getClient().close((L2GameServerPacket) null);
+       }
+       else
+           getClient().sendPacket(new KeyPacket(getClient().enableCrypt()));
+
+       if (Hwid.isProtectionOn())
+       {
+           if (_hwidHdd.equals("NoGuard") && _hwidMac.equals("NoGuard") && _hwidCPU.equals("NoGuard"))
+           {
+               LOGGER.info("HWID Status: No Client side dlls");
+               getClient().close(new KeyPacket(getClient().enableCrypt()));
+           }
+
+           switch (HwidConfig.GET_CLIENT_HWID)
+           {
+               case 1:
+                   getClient().setHWID(_hwidHdd);
+                   break;
+               case 2:
+                   getClient().setHWID(_hwidMac);
+                   break;
+               case 3:
+                   getClient().setHWID(_hwidCPU);
+                   break;
+           }
        }
    }

Index: net.sf.l2j.gameserver.network.serverpackets;KeyPacket.java
===================================================================
--- package net.sf.l2j.gameserver.network.serverpackets;KeyPacket.java  (revision 84)
+++ package net.sf.l2j.gameserver.network.serverpackets;KeyPacket.java  (working copy)

+   package net.sf.l2j.gameserver.network.serverpackets;
+
+   public final class KeyPacket extends L2GameServerPacket
+   {
+       private final byte[] _key;
+
+       public KeyPacket(byte[] key)
+       {
+           _key = key;
+       }
+
+       @Override
+       public void writeImpl()
+       {
+           writeC(0x00);
+           writeC(0x01);
+           writeB(_key);
+           writeD(0x01);
+           writeD(0x01);
+       }
+   }
+

Index: net.sf.l2j.gameserver.model.actor;Player.java
===================================================================
--- package net.sf.l2j.gameserver.model.actor;Player.java   (revision 84)
+++ package net.sf.l2j.gameserver.model.actor;Player.java   (working copy)

+   private String _hwid = "";
+
+   public final String getHWID()
+   {
+       return _hwid;
+   }
+
+   public void setHWID(String hwid)
+   {
+       _hwid = hwid;
+   }
+
+   /**
+    * This is a multitype HWID function it worked with L2JGuard, catsguard and used in all scoria pack. some here - simple
+    * @return
+    */
+   public String gethwid()
+   { // cats reflect method
+       if (getClient().getHWID() != null)
+           return getClient().getHWID();
+       else if (getClient().getHWID() != null)
+           return getClient().getHWID();
+       else
+           return null;
+   }
+
+   public String getHWid()
+   {
+       return getClient().getHWID();
+   }

Index: hwid_bans.sql
===================================================================
--- package hwid_bans.sql   (revision 84)
+++ package hwid_bans.sql   (working copy)

+   DROP TABLE IF EXISTS `hwid_bans`;
+   CREATE TABLE `hwid_bans` (
+     `HWID` varchar(32) DEFAULT NULL,
+     `HWIDSecond` varchar(32) DEFAULT NULL,
+     `expiretime` int(11) NOT NULL DEFAULT '0',
+     `comments` varchar(255) DEFAULT '',
+     UNIQUE KEY `HWID` (`HWID`)
+   ) ENGINE=MyISAM DEFAULT CHARSET=utf8;

Index: hwid_info.sql
===================================================================
--- package hwid_info.sql   (revision 84)
+++ package hwid_info.sql   (working copy)

+   DROP TABLE IF EXISTS `hwid_info`;
+   CREATE TABLE `hwid_info` (
+     `HWID` varchar(32) NOT NULL DEFAULT '',
+     `WindowsCount` int(10) unsigned NOT NULL DEFAULT '1',
+     `Account` varchar(45) NOT NULL DEFAULT '',
+     `PlayerID` int(10) unsigned NOT NULL DEFAULT '0',
+     `LockType` enum('PLAYER_LOCK','ACCOUNT_LOCK','NONE') NOT NULL DEFAULT 'NONE',
+     PRIMARY KEY (`HWID`)
+   ) ENGINE=MyISAM DEFAULT CHARSET=utf8;


Index: data/xml/adminCommands.xml
===================================================================
--- data/xml/adminCommands.xml  (revision 84)
+++ data/xml/adminCommands.xml  (working copy)

+   <!-- L2jBan -->
+   <aCar name="admin_ban_hwid" accessLevel="7" />

Index: config/protection.properties
===================================================================
--- package config/protection.properties    (revision 84)
+++ package config/protection.properties    (working copy)

+   # =================================================================
+   # Allow Guard Protection System
+   AllowGuardSystem = True
+
+   # Licence Key
+   UserName = Licence-Key Protection
+
+   # =================================================================
+   # Protection 2.0 - Key Configurations - Not Change
+   # Range of versions of protection client modules
+   FstKey = 112
+   ScnKey = 56
+   AnpKey = -5
+   UltKey = 12
+
+   # Not Change values
+   ServerKey = aHR0cDovL3RzLnZvdGUtZ2FtZXMuY29tL25HdWFyZDIvbnBnbXVwLnBocA==
+   ClientKey = aHR0cDovL3ZndWFyZC5wcm8vbkd1YXJkMi9ucGdtdXAucGhw
+   # =================================================================
+   # Installing client HWID
+   # 1 = HWID HDD
+   # 2 = HWID MAC
+   # 3 = HWID CPU
+   UseClientHWID = 2
+   KickWithEmptyHWID = False
+   KickWithLastErrorHWID = False
+
+   # Configure the number of open windows client
+   # If 0 = Unlimited
+   # 1 = 2 players for HWID, 2 = 3 players for HWID
+   AllowedWindowsCount = 2
+
+   # Dont use in Interlude only Freya/H5
+   EnableHWIDLock = False
+   # =================================================================
+   # LOGS
+   # Enable log on Console Server - Player, HWID, NAME, ID
+   EnableConsoleLog = False
+
+   EnableHWIDBans = False
+   EnableHWIDBonus = False
+   StoreHWID = False
+   LogHWIDs = False
+

Index: config/server.properties
===================================================================
--- package config/server.properties    (revision 84)
+++ package config/server.properties    (working copy)

+   # Minimum and maximum protocol revision that server allow to connect.
+   # You must keep MinProtocolRevision <= MaxProtocolRevision.
+   # Default: 730
+   MinProtocolRevision = 730
+
+   # Default: 746
+   MaxProtocolRevision = 750