]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/radius/radius.cpp
a4eea3a8902a68089568904a36c1a30bf74f1f54
[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 "store.h"
35 #include "common.h"
36 #include "user_conf.h"
37 #include "user_property.h"
38
39 extern volatile const time_t stgTime;
40
41 void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password);
42 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
43 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
44
45 //-----------------------------------------------------------------------------
46 //-----------------------------------------------------------------------------
47 //-----------------------------------------------------------------------------
48 class RAD_CREATOR {
49 private:
50     RADIUS * rad;
51
52 public:
53     RAD_CREATOR()
54         : rad(new RADIUS())
55         {
56         }
57     ~RAD_CREATOR()
58         {
59         delete rad;
60         }
61
62     RADIUS * GetPlugin()
63         {
64         return rad;
65         }
66 };
67 //-----------------------------------------------------------------------------
68 //-----------------------------------------------------------------------------
69 //-----------------------------------------------------------------------------
70 RAD_CREATOR radc;
71 //-----------------------------------------------------------------------------
72 //-----------------------------------------------------------------------------
73 //-----------------------------------------------------------------------------
74 PLUGIN * GetPlugin()
75 {
76 return radc.GetPlugin();
77 }
78 //-----------------------------------------------------------------------------
79 //-----------------------------------------------------------------------------
80 //-----------------------------------------------------------------------------
81 int RAD_SETTINGS::ParseIntInRange(const std::string & str, int min, int max, int * val)
82 {
83 if (str2x(str.c_str(), *val))
84     {
85     errorStr = "Incorrect value \'" + str + "\'.";
86     return -1;
87     }
88 if (*val < min || *val > max)
89     {
90     errorStr = "Value \'" + str + "\' out of range.";
91     return -1;
92     }
93 return 0;
94 }
95 //-----------------------------------------------------------------------------
96 int RAD_SETTINGS::ParseServices(const std::vector<std::string> & str, std::list<std::string> * lst)
97 {
98 std::copy(str.begin(), str.end(), std::back_inserter(*lst));
99 std::list<std::string>::iterator it(std::find(lst->begin(),
100                                lst->end(),
101                                "empty"));
102 if (it != lst->end())
103     *it = "";
104
105 return 0;
106 }
107 //-----------------------------------------------------------------------------
108 int RAD_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
109 {
110 int p;
111 PARAM_VALUE pv;
112 std::vector<PARAM_VALUE>::const_iterator pvi;
113 ///////////////////////////
114 pv.param = "Port";
115 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
116 if (pvi == s.moduleParams.end())
117     {
118     errorStr = "Parameter \'Port\' not found.";
119     printfd(__FILE__, "Parameter 'Port' not found\n");
120     return -1;
121     }
122 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
123     {
124     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
125     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
126     return -1;
127     }
128 port = p;
129 ///////////////////////////
130 pv.param = "Password";
131 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
132 if (pvi == s.moduleParams.end())
133     {
134     errorStr = "Parameter \'Password\' not found.";
135     printfd(__FILE__, "Parameter 'Password' not found\n");
136     return -1;
137     }
138 password = pvi->value[0];
139 ///////////////////////////
140 pv.param = "AuthServices";
141 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
142 if (pvi != s.moduleParams.end())
143     {
144     ParseServices(pvi->value, &authServices);
145     }
146 ///////////////////////////
147 pv.param = "AcctServices";
148 pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv);
149 if (pvi != s.moduleParams.end())
150     {
151     ParseServices(pvi->value, &acctServices);
152     }
153
154 return 0;
155 }
156 //-----------------------------------------------------------------------------
157 //-----------------------------------------------------------------------------
158 //-----------------------------------------------------------------------------
159 RADIUS::RADIUS()
160     : nonstop(false),
161       isRunning(false),
162       users(NULL),
163       stgSettings(NULL),
164       store(NULL),
165       sock(-1)
166 {
167 InitEncrypt(&ctx, "");
168 }
169 //-----------------------------------------------------------------------------
170 void RADIUS::SetUsers(USERS * u)
171 {
172 users = u;
173 }
174 //-----------------------------------------------------------------------------
175 void RADIUS::SetStgSettings(const SETTINGS * s)
176 {
177 stgSettings = s;
178 }
179 //-----------------------------------------------------------------------------
180 void RADIUS::SetSettings(const MODULE_SETTINGS & s)
181 {
182 settings = s;
183 }
184 //-----------------------------------------------------------------------------
185 void RADIUS::SetStore(STORE * s)
186 {
187 store = s;
188 }
189 //-----------------------------------------------------------------------------
190 int RADIUS::ParseSettings()
191 {
192 int ret = radSettings.ParseSettings(settings);
193 if (ret)
194     errorStr = radSettings.GetStrError();
195 return ret;
196 }
197 //-----------------------------------------------------------------------------
198 bool RADIUS::IsRunning()
199 {
200 return isRunning;
201 }
202 //-----------------------------------------------------------------------------
203 const std::string RADIUS::GetVersion() const
204 {
205 return "RADIUS data access plugin v 0.6";
206 }
207 //-----------------------------------------------------------------------------
208 uint16_t RADIUS::GetStartPosition() const
209 {
210 // Start before any authorizers!!!
211 return 20;
212 }
213 //-----------------------------------------------------------------------------
214 uint16_t RADIUS::GetStopPosition() const
215 {
216 return 20;
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 std::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 std::map<std::string, RAD_SESSION>::iterator it;
289 for (it = sessions.begin(); it != sessions.end(); ++it)
290     {
291     USER_PTR 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_PTR 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_PTR 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->GetProperty().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_PTR 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->GetProperty().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 std::map<std::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_PTR 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::PrintServices(const std::list<std::string> & svcs)
599 {
600 for_each(svcs.begin(), svcs.end(), Printer());
601 }
602 //-----------------------------------------------------------------------------
603 bool RADIUS::FindUser(USER_PTR * ui, const std::string & login) const
604 {
605 if (users->FindByName(login, ui))
606     {
607     return false;
608     }
609 return true;
610 }
611 //-----------------------------------------------------------------------------
612 bool RADIUS::CanAuthService(const std::string & svc) const
613 {
614 return find(authServices.begin(), authServices.end(), svc) != authServices.end();
615 }
616 //-----------------------------------------------------------------------------
617 bool RADIUS::CanAcctService(const std::string & svc) const
618 {
619 return find(acctServices.begin(), acctServices.end(), svc) != acctServices.end();
620 }
621 //-----------------------------------------------------------------------------
622 bool RADIUS::IsAllowedService(const std::string & svc) const
623 {
624 return CanAuthService(svc) || CanAcctService(svc);
625 }
626 //-----------------------------------------------------------------------------
627 bool RADIUS::WaitPackets(int sd) const
628 {
629 fd_set rfds;
630 FD_ZERO(&rfds);
631 FD_SET(sd, &rfds);
632
633 struct timeval tv;
634 tv.tv_sec = 0;
635 tv.tv_usec = 500000;
636
637 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
638 if (res == -1) // Error
639     {
640     if (errno != EINTR)
641         {
642         printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
643         }
644     return false;
645     }
646
647 if (res == 0) // Timeout
648     {
649     return false;
650     }
651
652 return true;
653 }
654 //-----------------------------------------------------------------------------
655 inline
656 void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password)
657 {
658 unsigned char keyL[RAD_PASSWORD_LEN];  // Пароль для шифровки
659 memset(keyL, 0, RAD_PASSWORD_LEN);
660 strncpy((char *)keyL, password.c_str(), RAD_PASSWORD_LEN);
661 Blowfish_Init(ctx, keyL, RAD_PASSWORD_LEN);
662 }
663 //-----------------------------------------------------------------------------
664 inline
665 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
666 {
667 // len8 - длина в 8-ми байтовых блоках
668 if (dst != src)
669     memcpy(dst, src, len8 * 8);
670
671 for (int i = 0; i < len8; i++)
672     Blowfish_Encrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
673 }
674 //-----------------------------------------------------------------------------
675 inline
676 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
677 {
678 // len8 - длина в 8-ми байтовых блоках
679 if (dst != src)
680     memcpy(dst, src, len8 * 8);
681
682 for (int i = 0; i < len8; i++)
683     Blowfish_Decrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
684 }