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