]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/radius/radius.cpp
9c5ab1db128c9b28dc36d4c0d9c82ee4fec77774
[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 "radius.h"
34 #include "common.h"
35
36 extern volatile const time_t stgTime;
37
38 void InitEncrypt(BLOWFISH_CTX * ctx, const string & password);
39 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
40 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
41
42 //-----------------------------------------------------------------------------
43 //-----------------------------------------------------------------------------
44 //-----------------------------------------------------------------------------
45 class RAD_CREATOR
46 {
47 private:
48     RADIUS * rad;
49
50 public:
51     RAD_CREATOR()
52         : rad(new RADIUS())
53         {
54         };
55     ~RAD_CREATOR()
56         {
57         delete rad;
58         };
59
60     RADIUS * GetPlugin()
61         {
62         return rad;
63         };
64 };
65 //-----------------------------------------------------------------------------
66 //-----------------------------------------------------------------------------
67 //-----------------------------------------------------------------------------
68 RAD_CREATOR radc;
69 //-----------------------------------------------------------------------------
70 //-----------------------------------------------------------------------------
71 //-----------------------------------------------------------------------------
72 BASE_PLUGIN * GetPlugin()
73 {
74 return radc.GetPlugin();
75 }
76 //-----------------------------------------------------------------------------
77 //-----------------------------------------------------------------------------
78 //-----------------------------------------------------------------------------
79 int RAD_SETTINGS::ParseIntInRange(const string & str, int min, int max, int * val)
80 {
81 if (str2x(str.c_str(), *val))
82     {
83     errorStr = "Incorrect value \'" + str + "\'.";
84     return -1;
85     }
86 if (*val < min || *val > max)
87     {
88     errorStr = "Value \'" + str + "\' out of range.";
89     return -1;
90     }
91 return 0;
92 }
93 //-----------------------------------------------------------------------------
94 int RAD_SETTINGS::ParseServices(const vector<string> & str, list<string> * lst)
95 {
96     copy(str.begin(), str.end(), back_inserter(*lst));
97     list<string>::iterator it(find(lst->begin(),
98                                    lst->end(),
99                                    "empty"));
100     if (it != lst->end())
101         *it = "";
102
103     return 0;
104 }
105 //-----------------------------------------------------------------------------
106 int RAD_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
107 {
108 int p;
109 PARAM_VALUE pv;
110 vector<PARAM_VALUE>::const_iterator pvi;
111 ///////////////////////////
112 pv.param = "Port";
113 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
114 if (pvi == s.moduleParams.end())
115     {
116     errorStr = "Parameter \'Port\' not found.";
117     printfd(__FILE__, "Parameter 'Port' not found\n");
118     return -1;
119     }
120 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
121     {
122     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
123     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
124     return -1;
125     }
126 port = p;
127 ///////////////////////////
128 pv.param = "Password";
129 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
130 if (pvi == s.moduleParams.end())
131     {
132     errorStr = "Parameter \'Password\' not found.";
133     printfd(__FILE__, "Parameter 'Password' not found\n");
134     return -1;
135     }
136 password = pvi->value[0];
137 ///////////////////////////
138 pv.param = "AuthServices";
139 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
140 if (pvi != s.moduleParams.end())
141     {
142     ParseServices(pvi->value, &authServices);
143     }
144 ///////////////////////////
145 pv.param = "AcctServices";
146 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
147 if (pvi != s.moduleParams.end())
148     {
149     ParseServices(pvi->value, &acctServices);
150     }
151
152 return 0;
153 }
154 //-----------------------------------------------------------------------------
155 //-----------------------------------------------------------------------------
156 //-----------------------------------------------------------------------------
157 RADIUS::RADIUS()
158     : nonstop(false),
159       isRunning(false),
160       users(NULL),
161       stgSettings(NULL),
162       store(NULL),
163       sock(-1)
164 {
165 InitEncrypt(&ctx, "");
166 }
167 //-----------------------------------------------------------------------------
168 void RADIUS::SetUsers(USERS * u)
169 {
170 users = u;
171 }
172 //-----------------------------------------------------------------------------
173 void RADIUS::SetStgSettings(const SETTINGS * s)
174 {
175 stgSettings = s;
176 }
177 //-----------------------------------------------------------------------------
178 void RADIUS::SetSettings(const MODULE_SETTINGS & s)
179 {
180 settings = s;
181 }
182 //-----------------------------------------------------------------------------
183 void RADIUS::SetStore(BASE_STORE * s)
184 {
185 store = s;
186 }
187 //-----------------------------------------------------------------------------
188 int RADIUS::ParseSettings()
189 {
190 int ret = radSettings.ParseSettings(settings);
191 if (ret)
192     errorStr = radSettings.GetStrError();
193 return ret;
194 }
195 //-----------------------------------------------------------------------------
196 bool RADIUS::IsRunning()
197 {
198 return isRunning;
199 }
200 //-----------------------------------------------------------------------------
201 const string RADIUS::GetVersion() const
202 {
203 return "RADIUS data access plugin v 0.6";
204 }
205 //-----------------------------------------------------------------------------
206 uint16_t RADIUS::GetStartPosition() const
207 {
208 // Start before any authorizers!!!
209 return 20;
210 }
211 //-----------------------------------------------------------------------------
212 uint16_t RADIUS::GetStopPosition() const
213 {
214 return 20;
215 }
216 //-----------------------------------------------------------------------------
217 int RADIUS::PrepareNet()
218 {
219 sock = socket(AF_INET, SOCK_DGRAM, 0);
220
221 if (sock < 0)
222     {
223     errorStr = "Cannot create socket.";
224     printfd(__FILE__, "Cannot create socket\n");
225     return -1;
226     }
227
228 struct sockaddr_in inAddr;
229 inAddr.sin_family = AF_INET;
230 inAddr.sin_port = htons(radSettings.GetPort());
231 inAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
232
233 if (bind(sock, (struct sockaddr*)&inAddr, sizeof(inAddr)) < 0)
234     {
235     errorStr = "RADIUS: Bind failed.";
236     printfd(__FILE__, "Cannot bind socket\n");
237     return -1;
238     }
239
240 return 0;
241 }
242 //-----------------------------------------------------------------------------
243 int RADIUS::FinalizeNet()
244 {
245 close(sock);
246 return 0;
247 }
248 //-----------------------------------------------------------------------------
249 int RADIUS::Start()
250 {
251 string password(radSettings.GetPassword());
252
253 authServices = radSettings.GetAuthServices();
254 acctServices = radSettings.GetAcctServices();
255
256 InitEncrypt(&ctx, password);
257
258 nonstop = true;
259
260 if (PrepareNet())
261     {
262     return -1;
263     }
264
265 if (!isRunning)
266     {
267     if (pthread_create(&thread, NULL, Run, this))
268         {
269         errorStr = "Cannot create thread.";
270         printfd(__FILE__, "Cannot create thread\n");
271         return -1;
272         }
273     }
274
275 errorStr = "";
276 return 0;
277 }
278 //-----------------------------------------------------------------------------
279 int RADIUS::Stop()
280 {
281 if (!IsRunning())
282     return 0;
283
284 nonstop = false;
285
286 map<string, RAD_SESSION>::iterator it;
287 for (it = sessions.begin(); it != sessions.end(); ++it)
288     {
289     user_iter ui;
290     if (users->FindByName(it->second.userName, &ui))
291         {
292         ui->Unauthorize(this);
293         }
294     }
295 sessions.erase(sessions.begin(), sessions.end());
296
297 FinalizeNet();
298
299 if (isRunning)
300     {
301     //5 seconds to thread stops itself
302     for (int i = 0; i < 25 && isRunning; i++)
303         {
304         usleep(200000);
305         }
306
307     //after 5 seconds waiting thread still running. now killing it
308     if (isRunning)
309         {
310         if (pthread_kill(thread, SIGINT))
311             {
312             errorStr = "Cannot kill thread.";
313             printfd(__FILE__, "Cannot kill thread\n");
314             return -1;
315             }
316         printfd(__FILE__, "RADIUS::Stop killed Run\n");
317         }
318     }
319
320 return 0;
321 }
322 //-----------------------------------------------------------------------------
323 void * RADIUS::Run(void * d)
324 {
325 RADIUS * rad = (RADIUS *)d;
326 RAD_PACKET packet;
327
328 rad->isRunning = true;
329
330 while (rad->nonstop)
331     {
332     if (!rad->WaitPackets(rad->sock))
333         {
334         continue;
335         }
336     struct sockaddr_in outerAddr;
337     if (rad->RecvData(&packet, &outerAddr))
338         {
339         printfd(__FILE__, "RADIUS::Run Error on RecvData\n");
340         }
341     else
342         {
343         if (rad->ProcessData(&packet))
344             {
345             packet.packetType = RAD_REJECT_PACKET;
346             }
347         rad->Send(packet, &outerAddr);
348         }
349     }
350
351 rad->isRunning = false;
352
353 return NULL;
354 }
355 //-----------------------------------------------------------------------------
356 int RADIUS::RecvData(RAD_PACKET * packet, struct sockaddr_in * outerAddr)
357 {
358     int8_t buf[RAD_MAX_PACKET_LEN];
359     socklen_t outerAddrLen = sizeof(struct sockaddr_in);
360     int dataLen = recvfrom(sock, buf, RAD_MAX_PACKET_LEN, 0, reinterpret_cast<struct sockaddr *>(outerAddr), &outerAddrLen);
361     if (dataLen > 0) {
362         Decrypt(&ctx, (char *)packet, (const char *)buf, dataLen / 8);
363     }
364     if (strncmp((char *)packet->magic, RAD_ID, RAD_MAGIC_LEN))
365         {
366         printfd(__FILE__, "RADIUS::RecvData Error magic. Wanted: '%s', got: '%s'\n", RAD_ID, packet->magic);
367         return -1;
368         }
369     return 0;
370 }
371 //-----------------------------------------------------------------------------
372 int RADIUS::Send(const RAD_PACKET & packet, struct sockaddr_in * outerAddr)
373 {
374 size_t len = sizeof(RAD_PACKET);
375 char buf[1032];
376
377 Encrypt(&ctx, buf, (char *)&packet, len / 8);
378 return sendto(sock, buf, len, 0, reinterpret_cast<struct sockaddr *>(outerAddr), sizeof(struct sockaddr_in));
379 }
380 //-----------------------------------------------------------------------------
381 int RADIUS::ProcessData(RAD_PACKET * packet)
382 {
383 if (strncmp((const char *)packet->protoVer, "01", 2))
384     {
385     printfd(__FILE__, "RADIUS::ProcessData packet.protoVer incorrect\n");
386     return -1;
387     }
388 switch (packet->packetType)
389     {
390     case RAD_AUTZ_PACKET:
391         return ProcessAutzPacket(packet);
392     case RAD_AUTH_PACKET:
393         return ProcessAuthPacket(packet);
394     case RAD_POST_AUTH_PACKET:
395         return ProcessPostAuthPacket(packet);
396     case RAD_ACCT_START_PACKET:
397         return ProcessAcctStartPacket(packet);
398     case RAD_ACCT_STOP_PACKET:
399         return ProcessAcctStopPacket(packet);
400     case RAD_ACCT_UPDATE_PACKET:
401         return ProcessAcctUpdatePacket(packet);
402     case RAD_ACCT_OTHER_PACKET:
403         return ProcessAcctOtherPacket(packet);
404     default:
405         printfd(__FILE__, "RADIUS::ProcessData Unsupported packet type: %d\n", packet->packetType);
406         return -1;
407     };
408 return 0;
409 }
410 //-----------------------------------------------------------------------------
411 int RADIUS::ProcessAutzPacket(RAD_PACKET * packet)
412 {
413 USER_CONF conf;
414
415 if (!IsAllowedService((char *)packet->service))
416     {
417     printfd(__FILE__, "RADIUS::ProcessAutzPacket service '%s' is not allowed to authorize\n", packet->service);
418     packet->packetType = RAD_REJECT_PACKET;
419     return 0;
420     }
421
422 if (store->RestoreUserConf(&conf, (char *)packet->login))
423     {
424     packet->packetType = RAD_REJECT_PACKET;
425     printfd(__FILE__, "RADIUS::ProcessAutzPacket cannot restore conf for user '%s'\n", packet->login);
426     return 0;
427     }
428
429 // At this point service can be authorized at least
430 // So we send a plain-text password
431
432 packet->packetType = RAD_ACCEPT_PACKET;
433 strncpy((char *)packet->password, conf.password.c_str(), RAD_PASSWORD_LEN);
434
435 return 0;
436 }
437 //-----------------------------------------------------------------------------
438 int RADIUS::ProcessAuthPacket(RAD_PACKET * packet)
439 {
440 user_iter ui;
441
442 if (!CanAcctService((char *)packet->service))
443     {
444
445     // There are no sense to check for allowed service
446     // It has allready checked at previous stage (authorization)
447
448     printfd(__FILE__, "RADIUS::ProcessAuthPacket service '%s' neednot stargazer authentication\n", (char *)packet->service);
449     packet->packetType = RAD_ACCEPT_PACKET;
450     return 0;
451     }
452
453 // At this point we have an accountable service
454 // All other services got a password if allowed or rejected
455
456 if (!FindUser(&ui, (char *)packet->login))
457     {
458     packet->packetType = RAD_REJECT_PACKET;
459     printfd(__FILE__, "RADIUS::ProcessAuthPacket user '%s' not found\n", (char *)packet->login);
460     return 0;
461     }
462
463 if (ui->IsInetable())
464     {
465     packet->packetType = RAD_ACCEPT_PACKET;
466     }
467 else
468     {
469     packet->packetType = RAD_REJECT_PACKET;
470     }
471
472 packet->packetType = RAD_ACCEPT_PACKET;
473 return 0;
474 }
475 //-----------------------------------------------------------------------------
476 int RADIUS::ProcessPostAuthPacket(RAD_PACKET * packet)
477 {
478 user_iter ui;
479
480 if (!CanAcctService((char *)packet->service))
481     {
482
483     // There are no sense to check for allowed service
484     // It has allready checked at previous stage (authorization)
485
486     packet->packetType = RAD_ACCEPT_PACKET;
487     return 0;
488     }
489
490 if (!FindUser(&ui, (char *)packet->login))
491     {
492     packet->packetType = RAD_REJECT_PACKET;
493     printfd(__FILE__, "RADIUS::ProcessPostAuthPacket user '%s' not found\n", (char *)packet->login);
494     return 0;
495     }
496
497 // I think that only Framed-User services has sense to be accountable
498 // So we have to supply a Framed-IP
499
500 USER_IPS ips = ui->property.ips;
501 packet->packetType = RAD_ACCEPT_PACKET;
502
503 // Additional checking for Framed-User service
504
505 if (!strncmp((char *)packet->service, "Framed-User", RAD_SERVICE_LEN))
506     packet->ip = ips[0].ip;
507 else
508     packet->ip = 0;
509
510 return 0;
511 }
512 //-----------------------------------------------------------------------------
513 int RADIUS::ProcessAcctStartPacket(RAD_PACKET * packet)
514 {
515 user_iter ui;
516
517 if (!FindUser(&ui, (char *)packet->login))
518     {
519     packet->packetType = RAD_REJECT_PACKET;
520     printfd(__FILE__, "RADIUS::ProcessAcctStartPacket user '%s' not found\n", (char *)packet->login);
521     return 0;
522     }
523
524 // At this point we have to unauthorize user only if it is an accountable service
525
526 if (CanAcctService((char *)packet->service))
527     {
528     if (sessions.find((const char *)packet->sessid) != sessions.end())
529         {
530         printfd(__FILE__, "RADIUS::ProcessAcctStartPacket session already started!\n");
531         packet->packetType = RAD_REJECT_PACKET;
532         return -1;
533         }
534     USER_IPS ips = ui->property.ips;
535     if (ui->Authorize(ips[0].ip, "", 0xffFFffFF, this))
536         {
537         printfd(__FILE__, "RADIUS::ProcessAcctStartPacket cannot authorize user '%s'\n", packet->login);
538         packet->packetType = RAD_REJECT_PACKET;
539         return -1;
540         }
541     sessions[(const char *)packet->sessid].userName = (const char *)packet->login;
542     sessions[(const char *)packet->sessid].serviceType = (const char *)packet->service;
543     for_each(sessions.begin(), sessions.end(), SPrinter());
544     }
545 else
546     {
547     printfd(__FILE__, "RADIUS::ProcessAcctStartPacket service '%s' can not be accounted\n", (char *)packet->service);
548     }
549
550 packet->packetType = RAD_ACCEPT_PACKET;
551 return 0;
552 }
553 //-----------------------------------------------------------------------------
554 int RADIUS::ProcessAcctStopPacket(RAD_PACKET * packet)
555 {
556 map<string, RAD_SESSION>::iterator sid;
557
558 if ((sid = sessions.find((const char *)packet->sessid)) == sessions.end())
559     {
560     printfd(__FILE__, "RADIUS::ProcessAcctStopPacket session had not started yet\n");
561     packet->packetType = RAD_REJECT_PACKET;
562     return -1;
563     }
564
565 user_iter ui;
566
567 if (!FindUser(&ui, sid->second.userName))
568     {
569     packet->packetType = RAD_REJECT_PACKET;
570     printfd(__FILE__, "RADIUS::ProcessPostAuthPacket user '%s' not found\n", sid->second.userName.c_str());
571     return 0;
572     }
573
574 sessions.erase(sid);
575
576 ui->Unauthorize(this);
577
578 packet->packetType = RAD_ACCEPT_PACKET;
579 return 0;
580 }
581 //-----------------------------------------------------------------------------
582 int RADIUS::ProcessAcctUpdatePacket(RAD_PACKET * packet)
583 {
584 // Fake. May be use it later
585 packet->packetType = RAD_ACCEPT_PACKET;
586 return 0;
587 }
588 //-----------------------------------------------------------------------------
589 int RADIUS::ProcessAcctOtherPacket(RAD_PACKET * packet)
590 {
591 // Fake. May be use it later
592 packet->packetType = RAD_ACCEPT_PACKET;
593 return 0;
594 }
595 //-----------------------------------------------------------------------------
596 void RADIUS::PrintServices(const list<string> & svcs)
597 {
598     for_each(svcs.begin(), svcs.end(), Printer());
599 }
600 //-----------------------------------------------------------------------------
601 bool RADIUS::FindUser(user_iter * ui, const std::string & login) const
602 {
603 if (users->FindByName(login, ui))
604     {
605     return false;
606     }
607 return true;
608 }
609 //-----------------------------------------------------------------------------
610 bool RADIUS::CanAuthService(const std::string & svc) const
611 {
612     return find(authServices.begin(), authServices.end(), svc) != authServices.end();
613 }
614 //-----------------------------------------------------------------------------
615 bool RADIUS::CanAcctService(const std::string & svc) const
616 {
617     return find(acctServices.begin(), acctServices.end(), svc) != acctServices.end();
618 }
619 //-----------------------------------------------------------------------------
620 bool RADIUS::IsAllowedService(const std::string & svc) const
621 {
622     return CanAuthService(svc) || CanAcctService(svc);
623 }
624 //-----------------------------------------------------------------------------
625 bool RADIUS::WaitPackets(int sd) const
626 {
627 fd_set rfds;
628 FD_ZERO(&rfds);
629 FD_SET(sd, &rfds);
630
631 struct timeval tv;
632 tv.tv_sec = 0;
633 tv.tv_usec = 500000;
634
635 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
636 if (res == -1) // Error
637     {
638     if (errno != EINTR)
639         {
640         printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
641         }
642     return false;
643     }
644
645 if (res == 0) // Timeout
646     {
647     return false;
648     }
649
650 return true;
651 }
652 //-----------------------------------------------------------------------------
653 inline
654 void InitEncrypt(BLOWFISH_CTX * ctx, const string & password)
655 {
656 unsigned char keyL[RAD_PASSWORD_LEN];  // Пароль для шифровки
657 memset(keyL, 0, RAD_PASSWORD_LEN);
658 strncpy((char *)keyL, password.c_str(), RAD_PASSWORD_LEN);
659 Blowfish_Init(ctx, keyL, RAD_PASSWORD_LEN);
660 }
661 //-----------------------------------------------------------------------------
662 inline
663 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
664 {
665 // len8 - длина в 8-ми байтовых блоках
666 if (dst != src)
667     memcpy(dst, src, len8 * 8);
668
669 for (int i = 0; i < len8; i++)
670     Blowfish_Encrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
671 }
672 //-----------------------------------------------------------------------------
673 inline
674 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
675 {
676 // len8 - длина в 8-ми байтовых блоках
677 if (dst != src)
678     memcpy(dst, src, len8 * 8);
679
680 for (int i = 0; i < len8; i++)
681     Blowfish_Decrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
682 }