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 : Maksym Mamontov <stg@madf.info>
  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