]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/radius/radius.cpp
Full and correct rollback in SMUX::Stop method
[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     : nonstop(false),
125       isRunning(false),
126       users(NULL),
127       stgSettings(NULL),
128       store(NULL),
129       sock(-1)
130 {
131 InitEncrypt(&ctx, "");
132 }
133 //-----------------------------------------------------------------------------
134 void RADIUS::SetUsers(USERS * u)
135 {
136 users = u;
137 }
138 //-----------------------------------------------------------------------------
139 void RADIUS::SetStgSettings(const SETTINGS * s)
140 {
141 stgSettings = s;
142 }
143 //-----------------------------------------------------------------------------
144 void RADIUS::SetSettings(const MODULE_SETTINGS & s)
145 {
146 settings = s;
147 }
148 //-----------------------------------------------------------------------------
149 void RADIUS::SetStore(STORE * s)
150 {
151 store = s;
152 }
153 //-----------------------------------------------------------------------------
154 int RADIUS::ParseSettings()
155 {
156 int ret = radSettings.ParseSettings(settings);
157 if (ret)
158     errorStr = radSettings.GetStrError();
159 return ret;
160 }
161 //-----------------------------------------------------------------------------
162 bool RADIUS::IsRunning()
163 {
164 return isRunning;
165 }
166 //-----------------------------------------------------------------------------
167 const std::string RADIUS::GetVersion() const
168 {
169 return "RADIUS data access plugin v 0.6";
170 }
171 //-----------------------------------------------------------------------------
172 uint16_t RADIUS::GetStartPosition() const
173 {
174 // Start before any authorizers!!!
175 return 20;
176 }
177 //-----------------------------------------------------------------------------
178 uint16_t RADIUS::GetStopPosition() const
179 {
180 return 20;
181 }
182 //-----------------------------------------------------------------------------
183 int RADIUS::PrepareNet()
184 {
185 sock = socket(AF_INET, SOCK_DGRAM, 0);
186
187 if (sock < 0)
188     {
189     errorStr = "Cannot create socket.";
190     printfd(__FILE__, "Cannot create socket\n");
191     return -1;
192     }
193
194 struct sockaddr_in inAddr;
195 inAddr.sin_family = AF_INET;
196 inAddr.sin_port = htons(radSettings.GetPort());
197 inAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
198
199 if (bind(sock, (struct sockaddr*)&inAddr, sizeof(inAddr)) < 0)
200     {
201     errorStr = "RADIUS: Bind failed.";
202     printfd(__FILE__, "Cannot bind socket\n");
203     return -1;
204     }
205
206 return 0;
207 }
208 //-----------------------------------------------------------------------------
209 int RADIUS::FinalizeNet()
210 {
211 close(sock);
212 return 0;
213 }
214 //-----------------------------------------------------------------------------
215 int RADIUS::Start()
216 {
217 std::string password(radSettings.GetPassword());
218
219 authServices = radSettings.GetAuthServices();
220 acctServices = radSettings.GetAcctServices();
221
222 InitEncrypt(&ctx, password);
223
224 nonstop = true;
225
226 if (PrepareNet())
227     {
228     return -1;
229     }
230
231 if (!isRunning)
232     {
233     if (pthread_create(&thread, NULL, Run, this))
234         {
235         errorStr = "Cannot create thread.";
236         printfd(__FILE__, "Cannot create thread\n");
237         return -1;
238         }
239     }
240
241 errorStr = "";
242 return 0;
243 }
244 //-----------------------------------------------------------------------------
245 int RADIUS::Stop()
246 {
247 if (!IsRunning())
248     return 0;
249
250 nonstop = false;
251
252 std::map<std::string, RAD_SESSION>::iterator it;
253 for (it = sessions.begin(); it != sessions.end(); ++it)
254     {
255     USER_PTR ui;
256     if (users->FindByName(it->second.userName, &ui))
257         {
258         users->Unauthorize(ui->GetLogin(), this);
259         }
260     }
261 sessions.erase(sessions.begin(), sessions.end());
262
263 FinalizeNet();
264
265 if (isRunning)
266     {
267     //5 seconds to thread stops itself
268     for (int i = 0; i < 25 && isRunning; i++)
269         {
270         usleep(200000);
271         }
272
273     //after 5 seconds waiting thread still running. now killing it
274     if (isRunning)
275         {
276         if (pthread_kill(thread, SIGINT))
277             {
278             errorStr = "Cannot kill thread.";
279             printfd(__FILE__, "Cannot kill thread\n");
280             return -1;
281             }
282         printfd(__FILE__, "RADIUS::Stop killed Run\n");
283         }
284     }
285
286 return 0;
287 }
288 //-----------------------------------------------------------------------------
289 void * RADIUS::Run(void * d)
290 {
291 RADIUS * rad = (RADIUS *)d;
292 RAD_PACKET packet;
293
294 rad->isRunning = true;
295
296 while (rad->nonstop)
297     {
298     if (!WaitPackets(rad->sock))
299         {
300         continue;
301         }
302     struct sockaddr_in outerAddr;
303     if (rad->RecvData(&packet, &outerAddr))
304         {
305         printfd(__FILE__, "RADIUS::Run Error on RecvData\n");
306         }
307     else
308         {
309         if (rad->ProcessData(&packet))
310             {
311             packet.packetType = RAD_REJECT_PACKET;
312             }
313         rad->Send(packet, &outerAddr);
314         }
315     }
316
317 rad->isRunning = false;
318
319 return NULL;
320 }
321 //-----------------------------------------------------------------------------
322 int RADIUS::RecvData(RAD_PACKET * packet, struct sockaddr_in * outerAddr)
323 {
324     int8_t buf[RAD_MAX_PACKET_LEN];
325     socklen_t outerAddrLen = sizeof(struct sockaddr_in);
326     int dataLen = recvfrom(sock, buf, RAD_MAX_PACKET_LEN, 0, reinterpret_cast<struct sockaddr *>(outerAddr), &outerAddrLen);
327     if (dataLen > 0) {
328         Decrypt(&ctx, (char *)packet, (const char *)buf, dataLen / 8);
329     }
330     if (strncmp((char *)packet->magic, RAD_ID, RAD_MAGIC_LEN))
331         {
332         printfd(__FILE__, "RADIUS::RecvData Error magic. Wanted: '%s', got: '%s'\n", RAD_ID, packet->magic);
333         return -1;
334         }
335     return 0;
336 }
337 //-----------------------------------------------------------------------------
338 int RADIUS::Send(const RAD_PACKET & packet, struct sockaddr_in * outerAddr)
339 {
340 size_t len = sizeof(RAD_PACKET);
341 char buf[1032];
342
343 Encrypt(&ctx, buf, (char *)&packet, len / 8);
344 return sendto(sock, buf, len, 0, reinterpret_cast<struct sockaddr *>(outerAddr), sizeof(struct sockaddr_in));
345 }
346 //-----------------------------------------------------------------------------
347 int RADIUS::ProcessData(RAD_PACKET * packet)
348 {
349 if (strncmp((const char *)packet->protoVer, "01", 2))
350     {
351     printfd(__FILE__, "RADIUS::ProcessData packet.protoVer incorrect\n");
352     return -1;
353     }
354 switch (packet->packetType)
355     {
356     case RAD_AUTZ_PACKET:
357         return ProcessAutzPacket(packet);
358     case RAD_AUTH_PACKET:
359         return ProcessAuthPacket(packet);
360     case RAD_POST_AUTH_PACKET:
361         return ProcessPostAuthPacket(packet);
362     case RAD_ACCT_START_PACKET:
363         return ProcessAcctStartPacket(packet);
364     case RAD_ACCT_STOP_PACKET:
365         return ProcessAcctStopPacket(packet);
366     case RAD_ACCT_UPDATE_PACKET:
367         return ProcessAcctUpdatePacket(packet);
368     case RAD_ACCT_OTHER_PACKET:
369         return ProcessAcctOtherPacket(packet);
370     default:
371         printfd(__FILE__, "RADIUS::ProcessData Unsupported packet type: %d\n", packet->packetType);
372         return -1;
373     };
374 return 0;
375 }
376 //-----------------------------------------------------------------------------
377 int RADIUS::ProcessAutzPacket(RAD_PACKET * packet)
378 {
379 USER_CONF conf;
380
381 if (!IsAllowedService((char *)packet->service))
382     {
383     printfd(__FILE__, "RADIUS::ProcessAutzPacket service '%s' is not allowed to authorize\n", packet->service);
384     packet->packetType = RAD_REJECT_PACKET;
385     return 0;
386     }
387
388 if (store->RestoreUserConf(&conf, (char *)packet->login))
389     {
390     packet->packetType = RAD_REJECT_PACKET;
391     printfd(__FILE__, "RADIUS::ProcessAutzPacket cannot restore conf for user '%s'\n", packet->login);
392     return 0;
393     }
394
395 // At this point service can be authorized at least
396 // So we send a plain-text password
397
398 packet->packetType = RAD_ACCEPT_PACKET;
399 strncpy((char *)packet->password, conf.password.c_str(), RAD_PASSWORD_LEN);
400
401 return 0;
402 }
403 //-----------------------------------------------------------------------------
404 int RADIUS::ProcessAuthPacket(RAD_PACKET * packet)
405 {
406 USER_PTR ui;
407
408 if (!CanAcctService((char *)packet->service))
409     {
410
411     // There are no sense to check for allowed service
412     // It has allready checked at previous stage (authorization)
413
414     printfd(__FILE__, "RADIUS::ProcessAuthPacket service '%s' neednot stargazer authentication\n", (char *)packet->service);
415     packet->packetType = RAD_ACCEPT_PACKET;
416     return 0;
417     }
418
419 // At this point we have an accountable service
420 // All other services got a password if allowed or rejected
421
422 if (!FindUser(&ui, (char *)packet->login))
423     {
424     packet->packetType = RAD_REJECT_PACKET;
425     printfd(__FILE__, "RADIUS::ProcessAuthPacket user '%s' not found\n", (char *)packet->login);
426     return 0;
427     }
428
429 if (ui->IsInetable())
430     {
431     packet->packetType = RAD_ACCEPT_PACKET;
432     }
433 else
434     {
435     packet->packetType = RAD_REJECT_PACKET;
436     }
437
438 packet->packetType = RAD_ACCEPT_PACKET;
439 return 0;
440 }
441 //-----------------------------------------------------------------------------
442 int RADIUS::ProcessPostAuthPacket(RAD_PACKET * packet)
443 {
444 USER_PTR ui;
445
446 if (!CanAcctService((char *)packet->service))
447     {
448
449     // There are no sense to check for allowed service
450     // It has allready checked at previous stage (authorization)
451
452     packet->packetType = RAD_ACCEPT_PACKET;
453     return 0;
454     }
455
456 if (!FindUser(&ui, (char *)packet->login))
457     {
458     packet->packetType = RAD_REJECT_PACKET;
459     printfd(__FILE__, "RADIUS::ProcessPostAuthPacket user '%s' not found\n", (char *)packet->login);
460     return 0;
461     }
462
463 // I think that only Framed-User services has sense to be accountable
464 // So we have to supply a Framed-IP
465
466 USER_IPS ips = ui->GetProperty().ips;
467 packet->packetType = RAD_ACCEPT_PACKET;
468
469 // Additional checking for Framed-User service
470
471 if (!strncmp((char *)packet->service, "Framed-User", RAD_SERVICE_LEN))
472     packet->ip = ips[0].ip;
473 else
474     packet->ip = 0;
475
476 return 0;
477 }
478 //-----------------------------------------------------------------------------
479 int RADIUS::ProcessAcctStartPacket(RAD_PACKET * packet)
480 {
481 USER_PTR ui;
482
483 if (!FindUser(&ui, (char *)packet->login))
484     {
485     packet->packetType = RAD_REJECT_PACKET;
486     printfd(__FILE__, "RADIUS::ProcessAcctStartPacket user '%s' not found\n", (char *)packet->login);
487     return 0;
488     }
489
490 // At this point we have to unauthorize user only if it is an accountable service
491
492 if (CanAcctService((char *)packet->service))
493     {
494     if (sessions.find((const char *)packet->sessid) != sessions.end())
495         {
496         printfd(__FILE__, "RADIUS::ProcessAcctStartPacket session already started!\n");
497         packet->packetType = RAD_REJECT_PACKET;
498         return -1;
499         }
500     USER_IPS ips = ui->GetProperty().ips;
501     if (users->Authorize(ui->GetLogin(), ips[0].ip, 0xffFFffFF, this))
502         {
503         printfd(__FILE__, "RADIUS::ProcessAcctStartPacket cannot authorize user '%s'\n", packet->login);
504         packet->packetType = RAD_REJECT_PACKET;
505         return -1;
506         }
507     sessions[(const char *)packet->sessid].userName = (const char *)packet->login;
508     sessions[(const char *)packet->sessid].serviceType = (const char *)packet->service;
509     for_each(sessions.begin(), sessions.end(), SPrinter());
510     }
511 else
512     {
513     printfd(__FILE__, "RADIUS::ProcessAcctStartPacket service '%s' can not be accounted\n", (char *)packet->service);
514     }
515
516 packet->packetType = RAD_ACCEPT_PACKET;
517 return 0;
518 }
519 //-----------------------------------------------------------------------------
520 int RADIUS::ProcessAcctStopPacket(RAD_PACKET * packet)
521 {
522 std::map<std::string, RAD_SESSION>::iterator sid;
523
524 if ((sid = sessions.find((const char *)packet->sessid)) == sessions.end())
525     {
526     printfd(__FILE__, "RADIUS::ProcessAcctStopPacket session had not started yet\n");
527     packet->packetType = RAD_REJECT_PACKET;
528     return -1;
529     }
530
531 USER_PTR ui;
532
533 if (!FindUser(&ui, sid->second.userName))
534     {
535     packet->packetType = RAD_REJECT_PACKET;
536     printfd(__FILE__, "RADIUS::ProcessPostAuthPacket user '%s' not found\n", sid->second.userName.c_str());
537     return 0;
538     }
539
540 sessions.erase(sid);
541
542 users->Unauthorize(ui->GetLogin(), this);
543
544 packet->packetType = RAD_ACCEPT_PACKET;
545 return 0;
546 }
547 //-----------------------------------------------------------------------------
548 int RADIUS::ProcessAcctUpdatePacket(RAD_PACKET * packet)
549 {
550 // Fake. May be use it later
551 packet->packetType = RAD_ACCEPT_PACKET;
552 return 0;
553 }
554 //-----------------------------------------------------------------------------
555 int RADIUS::ProcessAcctOtherPacket(RAD_PACKET * packet)
556 {
557 // Fake. May be use it later
558 packet->packetType = RAD_ACCEPT_PACKET;
559 return 0;
560 }
561 //-----------------------------------------------------------------------------
562 void RADIUS::PrintServices(const std::list<std::string> & svcs)
563 {
564 for_each(svcs.begin(), svcs.end(), Printer());
565 }
566 //-----------------------------------------------------------------------------
567 bool RADIUS::FindUser(USER_PTR * ui, const std::string & login) const
568 {
569 if (users->FindByName(login, ui))
570     {
571     return false;
572     }
573 return true;
574 }
575 //-----------------------------------------------------------------------------
576 bool RADIUS::CanAuthService(const std::string & svc) const
577 {
578 return find(authServices.begin(), authServices.end(), svc) != authServices.end();
579 }
580 //-----------------------------------------------------------------------------
581 bool RADIUS::CanAcctService(const std::string & svc) const
582 {
583 return find(acctServices.begin(), acctServices.end(), svc) != acctServices.end();
584 }
585 //-----------------------------------------------------------------------------
586 bool RADIUS::IsAllowedService(const std::string & svc) const
587 {
588 return CanAuthService(svc) || CanAcctService(svc);
589 }
590 //-----------------------------------------------------------------------------
591 inline
592 void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password)
593 {
594 unsigned char keyL[RAD_PASSWORD_LEN];  // Пароль для шифровки
595 memset(keyL, 0, RAD_PASSWORD_LEN);
596 strncpy((char *)keyL, password.c_str(), RAD_PASSWORD_LEN);
597 Blowfish_Init(ctx, keyL, RAD_PASSWORD_LEN);
598 }
599 //-----------------------------------------------------------------------------
600 inline
601 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
602 {
603 // len8 - длина в 8-ми байтовых блоках
604 if (dst != src)
605     memcpy(dst, src, len8 * 8);
606
607 for (int i = 0; i < len8; i++)
608     Blowfish_Encrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
609 }
610 //-----------------------------------------------------------------------------
611 inline
612 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
613 {
614 // len8 - длина в 8-ми байтовых блоках
615 if (dst != src)
616     memcpy(dst, src, len8 * 8);
617
618 for (int i = 0; i < len8; i++)
619     Blowfish_Decrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
620 }