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_md5.h m_sha256.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_md5.h"
  29 #include "m_sha256.h"
  30
  31 enum ProviderTypes
  32 {
  33         PROV_MD5 = 1,
  34         PROV_SHA = 2
  35 };
  36
  37 /* Handle /MKPASSWD
  38  */
  39 class cmd_mkpasswd : public command_t
  40 {
  41         Module* MD5Provider;
  42         Module* SHAProvider;
  43         Module* Sender;
  44         int Prov;
  45  public:
  46         cmd_mkpasswd (InspIRCd* Instance, Module* Sender, Module* MD5Hasher, Module* SHAHasher, int P)
  47                 : command_t(Instance,"MKPASSWD", 'o', 2), MD5Provider(MD5Hasher), SHAProvider(SHAHasher), Prov(P)
  48         {
  49                 this->source = "m_oper_hash.so";
  50                 syntax = "<hashtype> <any-text>";
  51         }
  52
  53         CmdResult Handle (const char** parameters, int pcnt, userrec *user)
  54         {
  55                 if (!strcasecmp(parameters[0], "md5"))
  56                 {
  57                         if ((Prov & PROV_MD5) > 0)
  58                         {
  59                                 MD5ResetRequest(Sender, Provider).Send();
  60                                 user->WriteServ("NOTICE %s :MD5 hashed password for %s is %s",user->nick, parameters[1], MD5SumRequest(Sender, Provider, parameters[1]).Send() );
  61                         }
  62                         else
  63                         {
  64                                 user->WriteServ("NOTICE %s :MD5 hashing is not available (m_md5.so not loaded)");
  65                         }
  66                 }
  67                 else if (!strcasecmp(parameters[0], "sha256"))
  68                 {
  69                         if ((Prov & PROV_SHA) > 0)
  70                         {
  71                                 SHA256ResetRequest(Sender, Provider).Send();
  72                                 user->WriteServ("NOTICE %s :SHA256 hashed password for %s is %s",user->nick, parameters[1], SHA256SumRequest(Sender, Provider, parameters[1]).Send() );
  73                         }
  74                         else
  75                         {
  76                                 user->WriteServ("NOTICE %s :SHA256 hashing is not available (m_sha256.so not loaded)");
  77                         }
  78                 }
  79                 else
  80                 {
  81                         user->WriteServ("NOTICE %s :Unknown hash type, valid hash types are 'sha256' and 'md5'");
  82                 }
  83
  84                 /* NOTE: Don't propogate this across the network!
  85                  * We dont want plaintext passes going all over the place...
  86                  * To make sure it goes nowhere, return CMD_FAILURE!
  87                  */
  88                 return CMD_FAILURE;
  89         }
  90 };
  91
  92 class ModuleOperHash : public Module
  93 {
  94
  95         cmd_mkpasswd* mycommand;
  96         Module* MD5Provider, SHAProvider;
  97         std::string providername;
  98         int ID;
  99         ConfigReader* Conf;
 100
 101  public:
 102
 103         ModuleOperHash(InspIRCd* Me)
 104                 : Module::Module(Me), Conf(NULL)
 105         {
 106                 OnRehash("");
 107
 108                 /* Try to find the md5 service provider, bail if it can't be found */
 109                 MD5Provider = ServerInstance->FindModule("m_md5.so");
 110                 if (MD5Provider)
 111                         ID |= PROV_MD5;
 112
 113                 SHAProvider = ServerInstance->FindModule("m_sha256.so");
 114                 if (SHAProvider)
 115                         ID |= PROV_SHA;
 116
 117                 mycommand = new cmd_mkpasswd(ServerInstance, this, MD5Provider, SHAProvider, ID);
 118                 ServerInstance->AddCommand(mycommand);
 119         }
 120
 121         virtual ~ModuleOperHash()
 122         {
 123         }
 124
 125         void Implements(char* List)
 126         {
 127                 List[I_OnRehash] = List[I_OnOperCompare] = 1;
 128         }
 129
 130         virtual void OnRehash(const std::string &parameter)
 131         {
 132                 if (Conf)
 133                         delete Conf;
 134
 135                 Conf = new ConfigReader(ServerInstance);
 136         }
 137
 138         virtual int OnOperCompare(const std::string &data, const std::string &input, int tagnumber)
 139         {
 140                 std::string hashtype = Conf->ReadValue("oper", "hash", tagnumber);
 141                 if ((hashtype == "sha256") && (data.length() == SHA256_BLOCK_SIZE) && ((ID & PROV_SHA) > 0))
 142                 {
 143                         SHA256ResetRequest(this, Provider).Send();
 144                         if (!strcasecmp(data.c_str(), SHA256SumRequest(this, Provider, input.c_str()).Send()))
 145                                 return 1;
 146                         else return -1;
 147                 }
 148                 else if ((hashtype == "md5") && (data.length() == 32) && ((ID & PROV_MD5) > 0))
 149                 {
 150                         MD5ResetRequest(this, Provider).Send();
 151                         if (!strcasecmp(data.c_str(), MD5SumRequest(this, Provider, input.c_str()).Send()))
 152                                 return 1;
 153                         else return -1;
 154                 }
 155                 return 0;
 156         }
 157
 158         virtual Version GetVersion()
 159         {
 160                 return Version(1,1,0,1,VF_VENDOR,API_VERSION);
 161         }
 162 };
 163
 164
 165 class ModuleOperHashFactory : public ModuleFactory
 166 {
 167  public:
 168         ModuleOperHashFactory()
 169         {
 170         }
 171
 172         ~ModuleOperHashFactory()
 173         {
 174         }
 175
 176         virtual Module * CreateModule(InspIRCd* Me)
 177         {
 178                 return new ModuleOperHash(Me);
 179         }
 180
 181 };
 182
 183
 184 extern "C" void * init_module( void )
 185 {
 186         return new ModuleOperHashFactory;
 187 }