ryzom/client/src/permanent_ban.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2019  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdpch.h"
  21 #include "permanent_ban.h"
  22 #include "nel/misc/file.h"
  23 #include "nel/misc/path.h"
  24 #include "nel/misc/big_file.h"
  25 #include "nel/misc/random.h"
  26
  27
  28 using namespace NLMISC;
  29
  30
  31 #define REGKEY_RYZOM_PATH L"Software\\Nevrax\\ryzom"
  32 #define REGKEY_PERMANENT_BAN L"PB"
  33
  34
  35 // ************************************************************
  36 static void setPermanentBanRegistryKey(bool on)
  37 {
  38 #ifndef NL_OS_WINDOWS
  39         nlinfo("Not implemented");
  40 #else
  41         HKEY hKey;
  42         if (RegCreateKeyW(HKEY_CURRENT_USER, REGKEY_RYZOM_PATH, &hKey)==ERROR_SUCCESS)
  43         {
  44                 DWORD permanentBan = on ? 1 : 0;
  45                 LONG result = RegSetValueExW(hKey, REGKEY_PERMANENT_BAN, 0, REG_DWORD, (LPBYTE)&permanentBan, 4);
  46
  47                 if (result != ERROR_SUCCESS)
  48                 {
  49                         nlwarning("pb key not created");
  50                 }
  51         }
  52         else
  53         {
  54                 nlwarning("pb key not created");
  55         }
  56 #endif
  57 }
  58
  59 // ************************************************************
  60 static bool getPermanentBanRegistryKey()
  61 {
  62 #ifndef NL_OS_WINDOWS
  63         return false; // not implemented
  64 #else
  65         HKEY hKey;
  66         if (RegOpenKeyExW(HKEY_CURRENT_USER, REGKEY_RYZOM_PATH, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
  67         {
  68                 DWORD permanentBan;
  69                 DWORD type;
  70                 DWORD dataSize = sizeof(DWORD);
  71
  72                 RegQueryValueExW(hKey, REGKEY_PERMANENT_BAN, 0, &type, (LPBYTE)&permanentBan, &dataSize);
  73
  74                 if (type == REG_DWORD && dataSize == sizeof(DWORD))
  75                 {
  76                         return permanentBan != 0;
  77                 }
  78         }
  79
  80         return false;
  81 #endif
  82 }
  83
  84 // ***********************************************************
  85 static void setPermanentBanFileMarker(const std::string &path, bool on)
  86 {
  87         if (on)
  88         {
  89                 try
  90                 {
  91                         // simply touch a file
  92                         COFile f(path);
  93 #ifdef NL_OS_WINDOWS
  94                         SetFileAttributesW(nlUtf8ToWide(path), FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
  95 #endif
  96                 }
  97                 catch(const EStream &e)
  98                 {
  99                         nlinfo(e.what());
 100                 }
 101         }
 102         else
 103         {
 104                 CFile::deleteFile(path);
 105         }
 106 }
 107
 108 // ***********************************************************
 109 static bool getPermanentBanFileMarker(const std::string &path)
 110 {
 111         return CFile::isExists(path);
 112 }
 113
 114 #define PERMANENT_BAN_FILE0 "c:\\3289763c1ecd044e"
 115 #define PERMANENT_BAN_FILE1 "78d0732e50bf2bbd"
 116
 117 // ************************************************************
 118 void setPermanentBanMarkers(bool on)
 119 {
 120         setPermanentBanRegistryKey(on);
 121         setPermanentBanFileMarker(PERMANENT_BAN_FILE0, on);
 122         setPermanentBanFileMarker(CPath::getWindowsDirectory() + PERMANENT_BAN_FILE1, on);
 123 }
 124
 125
 126 // ************************************************************
 127 bool testPermanentBanMarkers()
 128 {
 129         /*#ifndef NL_OS_WINDOWS
 130                 nlinfo("Not implemented");
 131                 return false;
 132         #else
 133                 if (getPermanentBanRegistryKey()) return true;
 134                 if (getPermanentBanFileMarker(PERMANENT_BAN_FILE0)) return true;
 135                 if (getPermanentBanFileMarker(CPath::getWindowsDirectory() + PERMANENT_BAN_FILE1)) return true;
 136         #endif
 137         return false;
 138         */
 139         return false;
 140 }
 141
 142
 143 // mark a bnp file without corrupting its datas (this force the patch to be applied the next time the client is launched, thus delaying the trouble maker)
 144 static void markBNPFile(std::string &path)
 145 {
 146         CRandom rnd;
 147         rnd.srand((sint32) CTime::getLocalTime());
 148
 149         uint32 nFileSize=CFile::getFileSize(path);
 150         if (!nFileSize) return;
 151         FILE *f = nlfopen(path, "rb+");
 152         if (!f) return;
 153 // Result
 154         if (nlfseek64 (f, nFileSize-4, SEEK_SET) != 0)
 155         {
 156                 fclose (f);
 157                 return;
 158         }
 159
 160         uint32 nOffsetFromBeginning;
 161         if (fread (&nOffsetFromBeginning, sizeof(uint32), 1, f) != 1)
 162         {
 163                 fclose (f);
 164                 return;
 165         }
 166
 167 #ifdef NL_BIG_ENDIAN
 168         NLMISC_BSWAP32(nOffsetFromBeginning);
 169 #endif
 170
 171         if (nlfseek64 (f, nOffsetFromBeginning, SEEK_SET) != 0)
 172         {
 173                 fclose (f);
 174                 return;
 175         }
 176
 177         // Read the file count
 178         uint32 nNbFile;
 179         if (fread (&nNbFile, sizeof(uint32), 1, f) != 1)
 180         {
 181                 fclose (f);
 182                 return;
 183         }
 184
 185 #ifdef NL_BIG_ENDIAN
 186         NLMISC_BSWAP32(nNbFile);
 187 #endif
 188
 189         for (uint32 i = 0; i < nNbFile; ++i)
 190         {
 191                 char FileName[MAX_PATH];
 192                 uint8 nStringSize;
 193                 if (fread (&nStringSize, 1, 1, f) != 1)
 194                 {
 195                         fclose(f);
 196                         return;
 197                 }
 198
 199                 sint64 currPos = nlftell64(f);
 200                 if (currPos < 0)
 201                 {
 202                         fclose(f);
 203                         return;
 204                 }
 205                 if (fread (FileName, 1, nStringSize, f) != nStringSize)
 206                 {
 207                         fclose (f);
 208                         return;
 209                 }
 210
 211                 FileName[nStringSize] = 0;
 212
 213                 for(uint k = 0; k < nStringSize; ++k)
 214                 {
 215                         if (rnd.rand() & 1) FileName[k] = toupper(FileName[k]);
 216                         else FileName[k] = tolower(FileName[k]);
 217                 }
 218
 219
 220                 if (nlfseek64 (f, currPos, SEEK_SET) != 0)
 221                 {
 222                         fclose (f);
 223                         return;
 224                 }
 225
 226
 227                 // write shuffled version
 228                 if (fwrite(FileName, 1, nStringSize, f) != nStringSize)
 229                 {
 230                         fclose(f);
 231                         return;
 232                 }
 233                 fflush(f);
 234
 235                 uint32 nFileSize2;
 236                 if (fread (&nFileSize2, sizeof(uint32), 1, f) != 1)
 237                 {
 238                         fclose (f);
 239                         return;
 240                 }
 241
 242 #ifdef NL_BIG_ENDIAN
 243                 NLMISC_BSWAP32(nFileSize2);
 244 #endif
 245
 246                 uint32 nFilePos;
 247                 if (fread (&nFilePos, sizeof(uint32), 1, f) != 1)
 248                 {
 249                         fclose (f);
 250                         return;
 251                 }
 252
 253 #ifdef NL_BIG_ENDIAN
 254                 NLMISC_BSWAP32(nFilePos);
 255 #endif
 256         }
 257
 258         fclose (f);
 259 }
 260
 261 // ************************************************************
 262 void applyPermanentBanPunishment()
 263 {
 264         // go in the data directory & touch all bnp files so that the client should repatch all its datas
 265         std::vector<std::string> bigFilePaths;
 266         CBigFile::getInstance().getBigFilePaths(bigFilePaths);
 267         for(uint k = 0; k < bigFilePaths.size(); ++k)
 268         {
 269                 markBNPFile(bigFilePaths[k]);
 270         }
 271 }
 272
 273