src/modules/m_oper_hash.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 /* $ModDesc: Allows for hashed oper passwords */
  18 /* $ModDep: m_hash.h */
  19
  20 using namespace std;
  21
  22 #include "inspircd_config.h"
  23 #include "users.h"
  24 #include "channels.h"
  25 #include "modules.h"
  26 #include "inspircd.h"
  27
  28 #include "m_hash.h"
  29
  30 enum ProviderTypes
  31 {
  32         PROV_MD5 = 1,
  33         PROV_SHA = 2
  34 };
  35
  36 /* Handle /MKPASSWD
  37  */
  38 class cmd_mkpasswd : public command_t
  39 {
  40         Module* MD5Provider;
  41         Module* SHAProvider;
  42         Module* Sender;
  43         int Prov;
  44  public:
  45         cmd_mkpasswd (InspIRCd* Instance, Module* Sender, Module* MD5Hasher, Module* SHAHasher, int P)
  46                 : command_t(Instance,"MKPASSWD", 'o', 2), MD5Provider(MD5Hasher), SHAProvider(SHAHasher), Prov(P)
  47         {
  48                 this->source = "m_oper_hash.so";
  49                 syntax = "<hashtype> <any-text>";
  50         }
  51
  52         void MakeHash(userrec* user, Module* ProviderMod, const char* algo, const char* stuff)
  53         {
  54                 HashResetRequest(Sender, ProviderMod).Send();
  55                 user->WriteServ("NOTICE %s :%s hashed password for %s is %s",user->nick, algo, stuff, HashSumRequest(Sender, ProviderMod, stuff).Send() );
  56         }
  57
  58         CmdResult Handle (const char** parameters, int pcnt, userrec *user)
  59         {
  60                 if ((!strcasecmp(parameters[0], "MD5")) && ((Prov & PROV_MD5) > 0))
  61                 {
  62                         MakeHash(user, MD5Provider, "MD5", parameters[1]);
  63                 }
  64                 else if ((!strcasecmp(parameters[0], "SHA256")) && ((Prov & PROV_SHA) > 0))
  65                 {
  66                         MakeHash(user, SHAProvider, "SHA256", parameters[1]);
  67                 }
  68                 else
  69                 {
  70                         user->WriteServ("NOTICE %s :Unknown hash type, valid hash types are:%s%s", user->nick, ((Prov & PROV_MD5) > 0) ? " MD5" : "", ((Prov & PROV_SHA) > 0) ? " SHA256" : "");
  71                 }
  72
  73                 /* NOTE: Don't propogate this across the network!
  74                  * We dont want plaintext passes going all over the place...
  75                  * To make sure it goes nowhere, return CMD_FAILURE!
  76                  */
  77                 return CMD_FAILURE;
  78         }
  79 };
  80
  81 class ModuleOperHash : public Module
  82 {
  83
  84         cmd_mkpasswd* mycommand;
  85         Module* MD5Provider;
  86         Module* SHAProvider;
  87         std::string providername;
  88         int ID;
  89         ConfigReader* Conf;
  90
  91         std::map<std::string, Module*> hashers;
  92
  93  public:
  94
  95         ModuleOperHash(InspIRCd* Me)
  96                 : Module::Module(Me)
  97         {
  98                 ID = 0;
  99                 Conf = NULL;
 100                 OnRehash("");
 101
 102                 modulelist* ml = ServerInstance->FindInterface("HashRequest");
 103
 104                 if (ml)
 105                 {
 106                         ServerInstance->Log(DEBUG, "Found interface 'HashRequest' containing %d modules", ml->size());
 107
 108                         for (modulelist::iterator m = ml->begin(); m != ml->end(); ml++)
 109                         {
 110                                 std::string name = HashNameRequest(this, *m).Send();
 111                                 hashers[name] = *m;
 112                                 ServerInstance->Log(DEBUG, "Found HashRequest interface: '%s' -> '%08x'", name.c_str(), *m);
 113                         }
 114                 }
 115
 116                 /* Try to find the md5 service provider, bail if it can't be found */
 117                 MD5Provider = ServerInstance->FindModule("m_md5.so");
 118                 if (MD5Provider)
 119                         ID |= PROV_MD5;
 120
 121                 SHAProvider = ServerInstance->FindModule("m_sha256.so");
 122                 if (SHAProvider)
 123                         ID |= PROV_SHA;
 124
 125                 mycommand = new cmd_mkpasswd(ServerInstance, this, MD5Provider, SHAProvider, ID);
 126                 ServerInstance->AddCommand(mycommand);
 127         }
 128
 129         virtual ~ModuleOperHash()
 130         {
 131         }
 132
 133         void Implements(char* List)
 134         {
 135                 List[I_OnRehash] = List[I_OnOperCompare] = 1;
 136         }
 137
 138         virtual void OnRehash(const std::string &parameter)
 139         {
 140                 if (Conf)
 141                         delete Conf;
 142
 143                 Conf = new ConfigReader(ServerInstance);
 144         }
 145
 146         virtual int OnOperCompare(const std::string &data, const std::string &input, int tagnumber)
 147         {
 148                 std::string hashtype = Conf->ReadValue("oper", "hash", tagnumber);
 149                 Module* ModPtr = NULL;
 150
 151                 if ((hashtype == "sha256") && (data.length() == SHA256_BLOCK_SIZE) && ((ID & PROV_SHA) > 0))
 152                 {
 153                         ModPtr = SHAProvider;
 154                 }
 155                 else if ((hashtype == "md5") && (data.length() == 32) && ((ID & PROV_MD5) > 0))
 156                 {
 157                         ModPtr = MD5Provider;
 158                 }
 159                 if (ModPtr)
 160                 {
 161                         HashResetRequest(this, ModPtr).Send();
 162                         if (!strcasecmp(data.c_str(), HashSumRequest(this, ModPtr, input.c_str()).Send()))
 163                                 return 1;
 164                         else return -1;
 165                 }
 166
 167                 return 0;
 168         }
 169
 170         virtual Version GetVersion()
 171         {
 172                 return Version(1,1,0,1,VF_VENDOR,API_VERSION);
 173         }
 174 };
 175
 176
 177 class ModuleOperHashFactory : public ModuleFactory
 178 {
 179  public:
 180         ModuleOperHashFactory()
 181         {
 182         }
 183
 184         ~ModuleOperHashFactory()
 185         {
 186         }
 187
 188         virtual Module * CreateModule(InspIRCd* Me)
 189         {
 190                 return new ModuleOperHash(Me);
 191         }
 192
 193 };
 194
 195
 196 extern "C" void * init_module( void )
 197 {
 198         return new ModuleOperHashFactory;
 199 }