]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/radius/radius.cpp
Cosmetic changes
[stg.git] / projects / stargazer / plugins / other / radius / radius.cpp
1 /*
2  *    This program is free software; you can redistribute it and/or modify
3  *    it under the terms of the GNU General Public License as published by
4  *    the Free Software Foundation; either version 2 of the License, or
5  *    (at your option) any later version.
6  *
7  *    This program is distributed in the hope that it will be useful,
8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  *    GNU General Public License for more details.
11  *
12  *    You should have received a copy of the GNU General Public License
13  *    along with this program; if not, write to the Free Software
14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15  */
16
17 /*
18  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
19  */
20
21 /*
22  *  This file contains a realization of radius data access plugin for Stargazer
23  *
24  *  $Revision: 1.14 $
25  *  $Date: 2009/12/13 14:17:13 $
26  *
27  */
28
29 #include <csignal>
30 #include <cerrno>
31 #include <algorithm>
32
33 #include "stg/store.h"
34 #include "stg/common.h"
35 #include "stg/user_conf.h"
36 #include "stg/user_property.h"
37 #include "stg/plugin_creator.h"
38 #include "radius.h"
39
40 extern volatile const time_t stgTime;
41
42 void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password);
43 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
44 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
45
46 //-----------------------------------------------------------------------------
47 //-----------------------------------------------------------------------------
48 //-----------------------------------------------------------------------------
49 PLUGIN_CREATOR<RADIUS> radc;
50 //-----------------------------------------------------------------------------
51 //-----------------------------------------------------------------------------
52 //-----------------------------------------------------------------------------
53 PLUGIN * GetPlugin()
54 {
55 return radc.GetPlugin();
56 }
57 //-----------------------------------------------------------------------------
58 //-----------------------------------------------------------------------------
59 //-----------------------------------------------------------------------------
60 int RAD_SETTINGS::ParseServices(const std::vector<std::string> & str, std::list<std::string> * lst)
61 {
62 std::copy(str.begin(), str.end(), std::back_inserter(*lst));
63 std::list<std::string>::iterator it(std::find(lst->begin(),
64                                lst->end(),
65                                "empty"));
66 if (it != lst->end())
67     *it = "";
68
69 return 0;
70 }
71 //-----------------------------------------------------------------------------
72 int RAD_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
73 {
74 int p;
75 PARAM_VALUE pv;
76 std::vector<PARAM_VALUE>::const_iterator pvi;
77 ///////////////////////////
78 pv.param = "Port";
79 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
80 if (pvi == s.moduleParams.end())
81     {
82     errorStr = "Parameter \'Port\' not found.";
83     printfd(__FILE__, "Parameter 'Port' not found\n");
84     return -1;
85     }
86 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
87     {
88     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
89     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
90     return -1;
91     }
92 port = p;
93 ///////////////////////////
94 pv.param = "Password";
95 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
96 if (pvi == s.moduleParams.end())
97     {
98     errorStr = "Parameter \'Password\' not found.";
99     printfd(__FILE__, "Parameter 'Password' not found\n");
100     return -1;
101     }
102 password = pvi->value[0];
103 ///////////////////////////
104 pv.param = "AuthServices";
105 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
106 if (pvi != s.moduleParams.end())
107     {
108     ParseServices(pvi->value, &authServices);
109     }
110 ///////////////////////////
111 pv.param = "AcctServices";
112 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
113 if (pvi != s.moduleParams.end())
114     {
115     ParseServices(pvi->value, &acctServices);
116     }
117
118 return 0;
119 }
120 //-----------------------------------------------------------------------------
121 //-----------------------------------------------------------------------------
122 //-----------------------------------------------------------------------------
123 RADIUS::RADIUS()
124     : ctx(),
125       errorStr(),
126       radSettings(),
127       settings(),
128       authServices(),
129       acctServices(),
130       sessions(),
131       nonstop(false),
132       isRunning(false),
133       users(NULL),
134       stgSettings(NULL),
135       store(NULL),
136       thread(),
137       mutex(),
138       sock(-1),
139       packet()
140 {
141 InitEncrypt(&ctx, "");
142 }
143 //-----------------------------------------------------------------------------
144 int RADIUS::ParseSettings()
145 {
146 int ret = radSettings.ParseSettings(settings);
147 if (ret)
148     errorStr = radSettings.GetStrError();
149 return ret;
150 }
151 //-----------------------------------------------------------------------------
152 int RADIUS::PrepareNet()
153 {
154 sock = socket(AF_INET, SOCK_DGRAM, 0);
155
156 if (sock < 0)
157     {
158     errorStr = "Cannot create socket.";
159     printfd(__FILE__, "Cannot create socket\n");
160     return -1;
161     }
162
163 struct sockaddr_in inAddr;
164 inAddr.sin_family = AF_INET;
165 inAddr.sin_port = htons(radSettings.GetPort());
166 inAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
167
168 if (bind(sock, (struct sockaddr*)&inAddr, sizeof(inAddr)) < 0)
169     {
170     errorStr = "RADIUS: Bind failed.";
171     printfd(__FILE__, "Cannot bind socket\n");
172     return -1;
173     }
174
175 return 0;
176 }
177 //-----------------------------------------------------------------------------
178 int RADIUS::FinalizeNet()
179 {
180 close(sock);
181 return 0;
182 }
183 //-----------------------------------------------------------------------------
184 int RADIUS::Start()
185 {
186 std::string password(radSettings.GetPassword());
187
188 authServices = radSettings.GetAuthServices();
189 acctServices = radSettings.GetAcctServices();
190
191 InitEncrypt(&ctx, password);
192
193 nonstop = true;
194
195 if (PrepareNet())
196     {
197     return -1;
198     }
199
200 if (!isRunning)
201     {
202     if (pthread_create(&thread, NULL, Run, this))
203         {
204         errorStr = "Cannot create thread.";
205         printfd(__FILE__, "Cannot create thread\n");
206         return -1;
207         }
208     }
209
210 errorStr = "";
211 return 0;
212 }
213 //-----------------------------------------------------------------------------
214 int RADIUS::Stop()
215 {
216 if (!IsRunning())
217     return 0;
218
219 nonstop = false;
220
221 std::map<std::string, RAD_SESSION>::iterator it;
222 for (it = sessions.begin(); it != sessions.end(); ++it)
223     {
224     USER_PTR ui;
225     if (users->FindByName(it->second.userName, &ui))
226         {
227         users->Unauthorize(ui->GetLogin(), this);
228         }
229     }
230 sessions.erase(sessions.begin(), sessions.end());
231
232 FinalizeNet();
233
234 if (isRunning)
235     {
236     //5 seconds to thread stops itself
237     for (int i = 0; i < 25 && isRunning; i++)
238         {
239         struct timespec ts = {0, 200000000};
240         nanosleep(&ts, NULL);
241         }
242     }
243
244 if (isRunning)
245     return -1;
246
247 return 0;
248 }
249 //-----------------------------------------------------------------------------
250 void * RADIUS::Run(void * d)
251 {
252 sigset_t signalSet;
253 sigfillset(&signalSet);
254 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
255
256 RADIUS * rad = (RADIUS *)d;
257 RAD_PACKET packet;
258
259 rad->isRunning = true;
260
261 while (rad->nonstop)
262     {
263     if (!WaitPackets(rad->sock))
264         {
265         continue;
266         }
267     struct sockaddr_in outerAddr;
268     if (rad->RecvData(&packet, &outerAddr))
269         {
270         printfd(__FILE__, "RADIUS::Run Error on RecvData\n");
271         }
272     else
273         {
274         if (rad->ProcessData(&packet))
275             {
276             packet.packetType = RAD_REJECT_PACKET;
277             }
278         rad->Send(packet, &outerAddr);
279         }
280     }
281
282 rad->isRunning = false;
283
284 return NULL;
285 }
286 //-----------------------------------------------------------------------------
287 int RADIUS::RecvData(RAD_PACKET * packet, struct sockaddr_in * outerAddr)
288 {
289     int8_t buf[RAD_MAX_PACKET_LEN];
290     socklen_t outerAddrLen = sizeof(struct sockaddr_in);
291     int dataLen = recvfrom(sock, buf, RAD_MAX_PACKET_LEN, 0, reinterpret_cast<struct sockaddr *>(outerAddr), &outerAddrLen);
292     if (dataLen > 0) {
293         Decrypt(&ctx, (char *)packet, (const char *)buf, dataLen / 8);
294     }
295     if (strncmp((char *)packet->magic, RAD_ID, RAD_MAGIC_LEN))
296         {
297         printfd(__FILE__, "RADIUS::RecvData Error magic. Wanted: '%s', got: '%s'\n", RAD_ID, packet->magic);
298         return -1;
299         }
300     return 0;
301 }
302 //-----------------------------------------------------------------------------
303 int RADIUS::Send(const RAD_PACKET & packet, struct sockaddr_in * outerAddr)
304 {
305 size_t len = sizeof(RAD_PACKET);
306 char buf[1032];
307
308 Encrypt(&ctx, buf, (char *)&packet, len / 8);
309 return sendto(sock, buf, len, 0, reinterpret_cast<struct sockaddr *>(outerAddr), sizeof(struct sockaddr_in));
310 }
311 //-----------------------------------------------------------------------------
312 int RADIUS::ProcessData(RAD_PACKET * packet)
313 {
314 if (strncmp((const char *)packet->protoVer, "01", 2))
315     {
316     printfd(__FILE__, "RADIUS::ProcessData packet.protoVer incorrect\n");
317     return -1;
318     }
319 switch (packet->packetType)
320     {
321     case RAD_AUTZ_PACKET:
322         return ProcessAutzPacket(packet);
323     case RAD_AUTH_PACKET:
324         return ProcessAuthPacket(packet);
325     case RAD_POST_AUTH_PACKET:
326         return ProcessPostAuthPacket(packet);
327     case RAD_ACCT_START_PACKET:
328         return ProcessAcctStartPacket(packet);
329     case RAD_ACCT_STOP_PACKET:
330         return ProcessAcctStopPacket(packet);
331     case RAD_ACCT_UPDATE_PACKET:
332         return ProcessAcctUpdatePacket(packet);
333     case RAD_ACCT_OTHER_PACKET:
334         return ProcessAcctOtherPacket(packet);
335     default:
336         printfd(__FILE__, "RADIUS::ProcessData Unsupported packet type: %d\n", packet->packetType);
337         return -1;
338     };
339 return 0;
340 }
341 //-----------------------------------------------------------------------------
342 int RADIUS::ProcessAutzPacket(RAD_PACKET * packet)
343 {
344 USER_CONF conf;
345
346 if (!IsAllowedService((char *)packet->service))
347     {
348     printfd(__FILE__, "RADIUS::ProcessAutzPacket service '%s' is not allowed to authorize\n", packet->service);
349     packet->packetType = RAD_REJECT_PACKET;
350     return 0;
351     }
352
353 if (store->RestoreUserConf(&conf, (char *)packet->login))
354     {
355     packet->packetType = RAD_REJECT_PACKET;
356     printfd(__FILE__, "RADIUS::ProcessAutzPacket cannot restore conf for user '%s'\n", packet->login);
357     return 0;
358     }
359
360 // At this point service can be authorized at least
361 // So we send a plain-text password
362
363 packet->packetType = RAD_ACCEPT_PACKET;
364 strncpy((char *)packet->password, conf.password.c_str(), RAD_PASSWORD_LEN);
365
366 return 0;
367 }
368 //-----------------------------------------------------------------------------
369 int RADIUS::ProcessAuthPacket(RAD_PACKET * packet)
370 {
371 USER_PTR ui;
372
373 if (!CanAcctService((char *)packet->service))
374     {
375
376     // There are no sense to check for allowed service
377     // It has allready checked at previous stage (authorization)
378
379     printfd(__FILE__, "RADIUS::ProcessAuthPacket service '%s' neednot stargazer authentication\n", (char *)packet->service);
380     packet->packetType = RAD_ACCEPT_PACKET;
381     return 0;
382     }
383
384 // At this point we have an accountable service
385 // All other services got a password if allowed or rejected
386
387 if (!FindUser(&ui, (char *)packet->login))
388     {
389     packet->packetType = RAD_REJECT_PACKET;
390     printfd(__FILE__, "RADIUS::ProcessAuthPacket user '%s' not found\n", (char *)packet->login);
391     return 0;
392     }
393
394 if (ui->IsInetable())
395     {
396     packet->packetType = RAD_ACCEPT_PACKET;
397     }
398 else
399     {
400     packet->packetType = RAD_REJECT_PACKET;
401     }
402
403 packet->packetType = RAD_ACCEPT_PACKET;
404 return 0;
405 }
406 //-----------------------------------------------------------------------------
407 int RADIUS::ProcessPostAuthPacket(RAD_PACKET * packet)
408 {
409 USER_PTR ui;
410
411 if (!CanAcctService((char *)packet->service))
412     {
413
414     // There are no sense to check for allowed service
415     // It has allready checked at previous stage (authorization)
416
417     packet->packetType = RAD_ACCEPT_PACKET;
418     return 0;
419     }
420
421 if (!FindUser(&ui, (char *)packet->login))
422     {
423     packet->packetType = RAD_REJECT_PACKET;
424     printfd(__FILE__, "RADIUS::ProcessPostAuthPacket user '%s' not found\n", (char *)packet->login);
425     return 0;
426     }
427
428 // I think that only Framed-User services has sense to be accountable
429 // So we have to supply a Framed-IP
430
431 USER_IPS ips = ui->GetProperty().ips;
432 packet->packetType = RAD_ACCEPT_PACKET;
433
434 // Additional checking for Framed-User service
435
436 if (!strncmp((char *)packet->service, "Framed-User", RAD_SERVICE_LEN))
437     packet->ip = ips[0].ip;
438 else
439     packet->ip = 0;
440
441 return 0;
442 }
443 //-----------------------------------------------------------------------------
444 int RADIUS::ProcessAcctStartPacket(RAD_PACKET * packet)
445 {
446 USER_PTR ui;
447
448 if (!FindUser(&ui, (char *)packet->login))
449     {
450     packet->packetType = RAD_REJECT_PACKET;
451     printfd(__FILE__, "RADIUS::ProcessAcctStartPacket user '%s' not found\n", (char *)packet->login);
452     return 0;
453     }
454
455 // At this point we have to unauthorize user only if it is an accountable service
456
457 if (CanAcctService((char *)packet->service))
458     {
459     if (sessions.find((const char *)packet->sessid) != sessions.end())
460         {
461         printfd(__FILE__, "RADIUS::ProcessAcctStartPacket session already started!\n");
462         packet->packetType = RAD_REJECT_PACKET;
463         return -1;
464         }
465     USER_IPS ips = ui->GetProperty().ips;
466     if (!users->Authorize(ui->GetLogin(), ips[0].ip, 0xffFFffFF, this))
467         {
468         printfd(__FILE__, "RADIUS::ProcessAcctStartPacket cannot authorize user '%s'\n", packet->login);
469         packet->packetType = RAD_REJECT_PACKET;
470         return -1;
471         }
472     sessions[(const char *)packet->sessid].userName = (const char *)packet->login;
473     sessions[(const char *)packet->sessid].serviceType = (const char *)packet->service;
474     for_each(sessions.begin(), sessions.end(), SPrinter());
475     }
476 else
477     {
478     printfd(__FILE__, "RADIUS::ProcessAcctStartPacket service '%s' can not be accounted\n", (char *)packet->service);
479     }
480
481 packet->packetType = RAD_ACCEPT_PACKET;
482 return 0;
483 }
484 //-----------------------------------------------------------------------------
485 int RADIUS::ProcessAcctStopPacket(RAD_PACKET * packet)
486 {
487 std::map<std::string, RAD_SESSION>::iterator sid;
488
489 if ((sid = sessions.find((const char *)packet->sessid)) == sessions.end())
490     {
491     printfd(__FILE__, "RADIUS::ProcessAcctStopPacket session had not started yet\n");
492     packet->packetType = RAD_REJECT_PACKET;
493     return -1;
494     }
495
496 USER_PTR ui;
497
498 if (!FindUser(&ui, sid->second.userName))
499     {
500     packet->packetType = RAD_REJECT_PACKET;
501     printfd(__FILE__, "RADIUS::ProcessPostAuthPacket user '%s' not found\n", sid->second.userName.c_str());
502     return 0;
503     }
504
505 sessions.erase(sid);
506
507 users->Unauthorize(ui->GetLogin(), this);
508
509 packet->packetType = RAD_ACCEPT_PACKET;
510 return 0;
511 }
512 //-----------------------------------------------------------------------------
513 int RADIUS::ProcessAcctUpdatePacket(RAD_PACKET * packet)
514 {
515 // Fake. May be use it later
516 packet->packetType = RAD_ACCEPT_PACKET;
517 return 0;
518 }
519 //-----------------------------------------------------------------------------
520 int RADIUS::ProcessAcctOtherPacket(RAD_PACKET * packet)
521 {
522 // Fake. May be use it later
523 packet->packetType = RAD_ACCEPT_PACKET;
524 return 0;
525 }
526 //-----------------------------------------------------------------------------
527 void RADIUS::PrintServices(const std::list<std::string> & svcs)
528 {
529 for_each(svcs.begin(), svcs.end(), Printer());
530 }
531 //-----------------------------------------------------------------------------
532 bool RADIUS::FindUser(USER_PTR * ui, const std::string & login) const
533 {
534 if (users->FindByName(login, ui))
535     {
536     return false;
537     }
538 return true;
539 }
540 //-----------------------------------------------------------------------------
541 bool RADIUS::CanAuthService(const std::string & svc) const
542 {
543 return find(authServices.begin(), authServices.end(), svc) != authServices.end();
544 }
545 //-----------------------------------------------------------------------------
546 bool RADIUS::CanAcctService(const std::string & svc) const
547 {
548 return find(acctServices.begin(), acctServices.end(), svc) != acctServices.end();
549 }
550 //-----------------------------------------------------------------------------
551 bool RADIUS::IsAllowedService(const std::string & svc) const
552 {
553 return CanAuthService(svc) || CanAcctService(svc);
554 }
555 //-----------------------------------------------------------------------------
556 inline
557 void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password)
558 {
559 unsigned char keyL[RAD_PASSWORD_LEN];  // Пароль для шифровки
560 memset(keyL, 0, RAD_PASSWORD_LEN);
561 strncpy((char *)keyL, password.c_str(), RAD_PASSWORD_LEN);
562 Blowfish_Init(ctx, keyL, RAD_PASSWORD_LEN);
563 }
564 //-----------------------------------------------------------------------------
565 inline
566 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
567 {
568 // len8 - длина в 8-ми байтовых блоках
569 if (dst != src)
570     memcpy(dst, src, len8 * 8);
571
572 for (int i = 0; i < len8; i++)
573     Blowfish_Encrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
574 }
575 //-----------------------------------------------------------------------------
576 inline
577 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
578 {
579 // len8 - длина в 8-ми байтовых блоках
580 if (dst != src)
581     memcpy(dst, src, len8 * 8);
582
583 for (int i = 0; i < len8; i++)
584     Blowfish_Decrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
585 }