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