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  public:
  92
  93         ModuleOperHash(InspIRCd* Me)
  94                 : Module::Module(Me)
  95         {
  96                 ID = 0;
  97                 Conf = NULL;
  98                 OnRehash("");
  99
 100                 /* Try to find the md5 service provider, bail if it can't be found */
 101                 MD5Provider = ServerInstance->FindModule("m_md5.so");
 102                 if (MD5Provider)
 103                         ID |= PROV_MD5;
 104
 105                 SHAProvider = ServerInstance->FindModule("m_sha256.so");
 106                 if (SHAProvider)
 107                         ID |= PROV_SHA;
 108
 109                 mycommand = new cmd_mkpasswd(ServerInstance, this, MD5Provider, SHAProvider, ID);
 110                 ServerInstance->AddCommand(mycommand);
 111         }
 112
 113         virtual ~ModuleOperHash()
 114         {
 115         }
 116
 117         void Implements(char* List)
 118         {
 119                 List[I_OnRehash] = List[I_OnOperCompare] = 1;
 120         }
 121
 122         virtual void OnRehash(const std::string &parameter)
 123         {
 124                 if (Conf)
 125                         delete Conf;
 126
 127                 Conf = new ConfigReader(ServerInstance);
 128         }
 129
 130         virtual int OnOperCompare(const std::string &data, const std::string &input, int tagnumber)
 131         {
 132                 std::string hashtype = Conf->ReadValue("oper", "hash", tagnumber);
 133                 Module* ModPtr = NULL;
 134
 135                 if ((hashtype == "sha256") && (data.length() == SHA256_BLOCK_SIZE) && ((ID & PROV_SHA) > 0))
 136                 {
 137                         ModPtr = SHAProvider;
 138                 }
 139                 else if ((hashtype == "md5") && (data.length() == 32) && ((ID & PROV_MD5) > 0))
 140                 {
 141                         ModPtr = MD5Provider;
 142                 }
 143                 if (ModPtr)
 144                 {
 145                         HashResetRequest(this, ModPtr).Send();
 146                         if (!strcasecmp(data.c_str(), HashSumRequest(this, ModPtr, input.c_str()).Send()))
 147                                 return 1;
 148                         else return -1;
 149                 }
 150
 151                 return 0;
 152         }
 153
 154         virtual Version GetVersion()
 155         {
 156                 return Version(1,1,0,1,VF_VENDOR,API_VERSION);
 157         }
 158 };
 159
 160
 161 class ModuleOperHashFactory : public ModuleFactory
 162 {
 163  public:
 164         ModuleOperHashFactory()
 165         {
 166         }
 167
 168         ~ModuleOperHashFactory()
 169         {
 170         }
 171
 172         virtual Module * CreateModule(InspIRCd* Me)
 173         {
 174                 return new ModuleOperHash(Me);
 175         }
 176
 177 };
 178
 179
 180 extern "C" void * init_module( void )
 181 {
 182         return new ModuleOperHashFactory;
 183 }