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