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