]> git.netwichtig.de Git - user/henk/code/inspircd.git/blob - src/modules/m_dnsbl.cpp
Add support for LOCKSERV/UNLOCKSERV to block/open for new connections. Thanks to...
[user/henk/code/inspircd.git] / src / modules / m_dnsbl.cpp
1 /*       +------------------------------------+
2  *       | Inspire Internet Relay Chat Daemon |
3  *       +------------------------------------+
4  *
5  *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
6  * See: http://www.inspircd.org/wiki/index.php/Credits
7  *
8  * This program is free but copyrighted software; see
9  *            the file COPYING for details.
10  *
11  * ---------------------------------------------------
12  */
13
14 #include <sys/types.h>
15 #include <sys/socket.h>
16 #include <netinet/in.h>
17 #include <arpa/inet.h>
18 #include <stdint.h>
19 #include "inspircd.h"
20 #include "dns.h"
21 #include "users.h"
22 #include "channels.h"
23 #include "modules.h"
24
25 /* $ModDesc: Provides handling of DNS blacklists */
26
27 /* Class holding data for a single entry */
28 class DNSBLConfEntry
29 {
30         public:
31                 enum EnumBanaction { I_UNKNOWN, I_KILL, I_ZLINE, I_KLINE, I_GLINE };
32                 std::string name, domain, reason;
33                 EnumBanaction banaction;
34                 long duration;
35                 int bitmask;
36                 DNSBLConfEntry(): duration(86400),bitmask(0) {}
37 };
38
39
40 /** Resolver for CGI:IRC hostnames encoded in ident/GECOS
41  */
42 class DNSBLResolver : public Resolver
43 {
44         int theirfd;
45         userrec* them;
46         DNSBLConfEntry *ConfEntry;
47
48     public:
49         DNSBLResolver(Module *me, InspIRCd *ServerInstance, const std::string &hostname, userrec* u, int userfd, DNSBLConfEntry *conf)
50                 : Resolver(ServerInstance, hostname, DNS_QUERY_A, me)
51         {
52                 theirfd = userfd;
53                 them = u;
54                 ConfEntry = conf;
55         }
56
57         virtual void OnLookupComplete(const std::string &result)
58         {
59                 /* Check the user still exists */
60                 if ((them) && (them == ServerInstance->SE->GetRef(theirfd)))
61                 {
62                         ServerInstance->Log(DEBUG, "m_dnsbl:  %s got a result from dnsbl %s", them->nick, ConfEntry->name.c_str());
63
64                         // Now we calculate the bitmask: 256*(256*(256*a+b)+c)+d
65                         if(result.length())
66                         {
67                                 unsigned int bitmask=0;
68                                 unsigned int octetpos=0;
69                                 std::string tmp = result;
70
71                                 while(tmp.length()>0)
72                                 {
73                                         std::string octet;
74                                         /* Fix by brain, npos is -1, so unsigned int will never match */
75                                         std::string::size_type lastdot = tmp.rfind(".");
76
77                                         if (lastdot == std::string::npos)
78                                         {
79                                                 octet=tmp;
80                                                 tmp.clear();
81                                         }
82                                         else
83                                         {
84                                                 octet=tmp.substr(lastdot+1,tmp.length()-lastdot+1);
85                                                 tmp.resize(lastdot);
86                                         }
87
88                                         bitmask += (256 ^ octetpos) * atoi(octet.c_str());
89                                         octetpos += 1;
90                                 }
91
92                                 bitmask &= ConfEntry->bitmask;
93
94                                 if (bitmask != 0)
95                                 {
96                                         std::string reason = ConfEntry->reason;
97
98                                         while (int pos = reason.find("%ip%") != std::string::npos)
99                                         {
100                                                 reason.replace(pos, 4, them->GetIPString());
101                                         }
102
103                                         ServerInstance->WriteOpers("*** Connecting user %s detected as being on a DNS blacklist (%s) with result %d", them->GetFullRealHost(), ConfEntry->name.c_str(), bitmask);
104
105                                         switch (ConfEntry->banaction)
106                                         {
107                                                 case DNSBLConfEntry::I_KILL:
108                                                 {
109                                                         them->QuitUser(ServerInstance, them, std::string("Killed (") + reason + ")");
110                                                         break;
111                                                 }
112                                                 case DNSBLConfEntry::I_KLINE:
113                                                 {
114                                                         ServerInstance->AddKLine(ConfEntry->duration, ServerInstance->Config->ServerName, reason, std::string("*@") + them->GetIPString());
115                                                         break;
116                                                 }
117                                                 case DNSBLConfEntry::I_GLINE:
118                                                 {
119                                                         ServerInstance->AddGLine(ConfEntry->duration, ServerInstance->Config->ServerName, reason, std::string("*@") + them->GetIPString());
120                                                         break;
121                                                 }
122                                                 case DNSBLConfEntry::I_ZLINE:
123                                                 {
124                                                         ServerInstance->AddZLine(ConfEntry->duration, ServerInstance->Config->ServerName, reason, them->GetIPString());
125                                                         break;
126                                                 }
127                                                 case DNSBLConfEntry::I_UNKNOWN:
128                                                 {
129                                                         break;
130                                                 }
131                                                 break;
132                                         }
133                                 }
134                         }
135                 }
136         }
137
138         virtual void OnError(ResolverError e, const std::string &errormessage)
139         {
140                 /*
141                 this just means they don't appear in the respective dnsbl
142                 if ((them) && (them == ServerInstance->SE->GetRef(theirfd)))
143                 {
144                 }
145                 */
146                 /* Check the user still exists */
147                 if ((them) && (them == ServerInstance->SE->GetRef(theirfd)))
148                 {
149                         ServerInstance->Log(DEBUG, "m_dnsbl:  %s got an error while resolving for dnsbl %s", them->nick, ConfEntry->name.c_str());
150                 }
151         }
152  
153         virtual ~DNSBLResolver()
154         {
155         }
156 };
157
158 class ModuleDNSBL : public Module
159 {
160  private:
161         std::vector<DNSBLConfEntry *> DNSBLConfEntries;
162         
163         /*
164          *      Convert a string to EnumBanaction
165          */
166         DNSBLConfEntry::EnumBanaction str2banaction(const std::string &action)
167         {
168                 if(action.compare("KILL")==0)
169                         return DNSBLConfEntry::I_KILL;
170                 if(action.compare("KLINE")==0)
171                         return DNSBLConfEntry::I_KLINE;
172                 if(action.compare("ZLINE")==0)
173                         return DNSBLConfEntry::I_ZLINE;
174                 if(action.compare("GLINE")==0)
175                         return DNSBLConfEntry::I_GLINE;
176         
177                 return DNSBLConfEntry::I_UNKNOWN;
178         }
179  public:
180         ModuleDNSBL(InspIRCd *Me) : Module::Module(Me)
181         {
182                 ReadConf();
183         }
184         
185         virtual ~ModuleDNSBL()
186         {
187                 ClearEntries();
188         }
189         
190         virtual Version GetVersion()
191         {
192                 return Version(2, 0, 0, 1, VF_VENDOR, API_VERSION);
193         }
194
195         void Implements(char* List)
196         {
197                 List[I_OnRehash] = List[I_OnUserRegister] = 1;
198         }
199
200         /** Clear entries and free the mem it was using
201          */
202         void ClearEntries()
203         {
204                 std::vector<DNSBLConfEntry *>::iterator i;
205                 while ((i = DNSBLConfEntries.begin()) != DNSBLConfEntries.end())
206                 {
207                         DNSBLConfEntries.erase(i);
208                         delete *i;
209                 }
210         }
211
212         /** Fill our conf vector with data
213          */     
214         virtual void ReadConf()
215         {
216                 ConfigReader *MyConf = new ConfigReader(ServerInstance);
217                 ClearEntries();
218
219                 for (int i=0; i< MyConf->Enumerate("dnsbl"); i++)
220                 {
221                         DNSBLConfEntry *e = new DNSBLConfEntry();
222
223                         e->name = MyConf->ReadValue("dnsbl", "name", i);
224                         e->reason = MyConf->ReadValue("dnsbl", "reason", i);
225                         e->domain = MyConf->ReadValue("dnsbl", "domain", i);
226                         e->banaction = str2banaction(MyConf->ReadValue("dnsbl", "action", i));
227                         e->duration = ServerInstance->Duration(MyConf->ReadValue("dnsbl", "duration", i).c_str());
228                         e->bitmask = MyConf->ReadInteger("dnsbl", "bitmask", i, false);
229
230                         /* yeah, logic here is a little messy */
231                         if (e->bitmask <= 0)
232                         {
233                                 ServerInstance->WriteOpers("*** DNSBL(#%d): invalid bitmask",i);
234                         }
235                         else if (e->name == "")
236                         {
237                                 ServerInstance->WriteOpers("*** DNSBL(#%d): Invalid name",i);
238                         }
239                         else if (e->domain == "")
240                         {
241                                 ServerInstance->WriteOpers("*** DNSBL(#%d): Invalid domain",i);
242                         }
243                         else if (e->banaction == DNSBLConfEntry::I_UNKNOWN)
244                         {
245                                 ServerInstance->WriteOpers("*** DNSBL(#%d): Invalid banaction", i);
246                         }
247                         else
248                         {
249                                 if (e->reason == "")
250                                 {
251                                         ServerInstance->WriteOpers("*** DNSBL(#%d): empty reason, using defaults",i);
252                                         e->reason = "Your IP has been blacklisted.";
253                                 }
254
255                                 /* add it, all is ok */
256                                 DNSBLConfEntries.push_back(e);
257                                 continue;
258                         }
259
260                         /* delete and drop it, error somewhere */
261                         delete e;
262                 }
263
264                 delete MyConf;
265         }
266
267         virtual void OnRehash(const std::string &parameter)
268         {
269                 ReadConf();
270         }
271
272         /*
273          * We will check each user that connects *locally* (userrec::fd>0)
274          */
275         virtual int OnUserRegister(userrec* user)
276         {
277                 if (IS_LOCAL(user))
278                 {
279                         /* following code taken from bopm, reverses an IP address. */
280                         struct in_addr in;
281                         unsigned char a, b, c, d;
282                         char reversedipbuf[128];
283                         std::string reversedip;
284
285                         if (!inet_aton(user->GetIPString(), &in))
286                         {
287                                 ServerInstance->WriteOpers("Invalid IP address in m_dnsbl! Bailing check");
288                                 return 0;
289                         }
290
291                         d = (unsigned char) (in.s_addr >> 24) & 0xFF;
292                         c = (unsigned char) (in.s_addr >> 16) & 0xFF;
293                         b = (unsigned char) (in.s_addr >> 8) & 0xFF;
294                         a = (unsigned char) in.s_addr & 0xFF;
295
296                         snprintf(reversedipbuf, 128, "%d.%d.%d.%d", d, c, b, a);
297                         reversedip = std::string(reversedipbuf);
298
299                         // For each DNSBL, we will run through this lookup
300                         for (std::vector<DNSBLConfEntry *>::iterator i = DNSBLConfEntries.begin(); i != DNSBLConfEntries.end(); i++)
301                         {
302                                 // Fill hostname with a dnsbl style host (d.c.b.a.domain.tld)
303                                 std::string hostname=reversedip+"."+ (*i)->domain;
304
305                                 ServerInstance->Log(DEBUG, "m_dnsbl: sending %s for resolution", hostname.c_str());
306
307                                 /* now we'd need to fire off lookups for `hostname'. */
308                                 DNSBLResolver *r = new DNSBLResolver(this, ServerInstance, hostname, user, user->GetFd(), *i);
309                                 ServerInstance->AddResolver(r);
310                         }
311                 }
312
313                 /* don't do anything with this hot potato */
314                 return 0;
315         }
316 };
317
318 // stuff down here is the module-factory stuff.
319
320 class ModuleDNSBLFactory : public ModuleFactory
321 {
322  public:
323         ModuleDNSBLFactory()
324         {
325         }
326         
327         ~ModuleDNSBLFactory()
328         {
329         }
330         
331         virtual Module *CreateModule(InspIRCd *Me)
332         {
333                 return new ModuleDNSBL(Me);
334         }
335         
336 };
337
338
339 extern "C" void * init_module( void )
340 {
341         return new ModuleDNSBLFactory;
342 }