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