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