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