แแแแแ แแแแแแแแ แแแแแแแขแแแแกแแแแก IP แแแกแแแแ แแแแแก แแแชแแแแก แแแฌแงแแแ. แแ แแแแแแแก แแแ แแแแแ:
- แฉแแแ แแ แแแแชแแแ แชแแแแ แกแแ แแแ แก แแแขแแ แแแแชแแแกแแแแก - แแฅแแแ แแแแแแแแแ ๐
- แแแแแแแขแแแแ แฃแแแ แแแแฆแแ แฅแกแแแแก แแแ แแแแขแ แแแ DHCP-แแก แกแแจแฃแแแแแแ
- แฅแกแแแ แฐแแขแแ แแแแแฃแแแ. แแก แแแแชแแแก PON แแฆแญแฃแ แแแแแแแก แแ แ แแแฃแแแ แฃแ แแแแแแ แแแแแแแก แแแแคแแแฃแ แแ แแแฃแแ แแแ แแแแขแ 82 แแ WiFi แแแแแแแ แชแฎแแแ แฌแแ แขแแแแแแ
- แแฃ แแแแแชแแแแแ แแ แแฅแแแแแแแแ แแแ IP-แแก แแแชแแแแก แ แแแแแแแ แแแ แแแแก, แแฅแแแ แฃแแแ แแแกแชแแ IP "แกแขแฃแแแ แ" แฅแกแแแแแแ.
แแแ แแ แแฎแแ แ: FreeBSD-แแ แฏแแ แแแแแ แแ แแก แกแแ แแแ แ, แ แแแแแกแแช แจแแฃแซแแแ โแแฃแจแแแแโ, แแแแ แแ แแก โแจแแ แกโ ;), แแ แ โแกแฌแแ แแ แแ แฅแกแแแจแโ.
แแกแแแ แแ แแก แจแแกแแแแจแแแแ แแแฌแงแแแแแแแ, แกแแฎแแแแ Mikrotik. แกแแแ แแ แฅแกแแแแก แแแแแ แแแ แแแแฎแแแแแแ แแกแแแแ:
แแแ แแแแฃแแ แคแแฅแ แแก แจแแแแแ, แแแแแฌแงแแ FreeRadius-แแก แแแแแงแแแแแ แแแแแแแขแแแแกแแแแก แฅแกแแแแก แแแ แแแแขแ แแแแก แแแกแแชแแแแ. แแ แแแชแแแจแ, แกแฅแแแ แฉแแแฃแแแแ แแแแ: แฉแแแ แแแแฅแขแแฃแ แแแ DHCP แกแแ แแแ แก Microtick-แแ แแ Radius Client แแแกแแ. แฉแแแ แแแแแแคแแแฃแ แแ แแแ DHCP แกแแ แแแ แก -> Radius Client -> Radius แกแแ แแแ แแก แแแแจแแ แ.
แแ แฉแแแก แ แแฃแแ. แแแแ แแ! แแจแแแแ แแแขแแแแแจแแ. แแแ แซแแ:
- แแ แกแฅแแแแก แแแแแงแแแแแแ PON OLT-แแก แแแขแแ แแแแชแแแกแแก, แแแแฎแแแแ แแแแแแแแแ FreeRadius-แก แแแแฎแแแ แแแแแก แกแแฎแแแแ, แ แแแแแแช แฃแแ แแก headend-แแก MAC แแแกแแแแ แแก, Agent-Circuit-Id-แแก แขแแแ MAC PON Onu-แก แแ แชแแ แแแแ แแแ แแแแ.
- 82-แ แแแ แแแแขแแก แแฅแแแ แแแแแแ แแแแแแแแแแ แแแขแแ แแแแชแแแกแแก, FreeRadius แแฆแแแก แแแแฎแแแแแก แชแแ แแแแ แแแแฎแแแ แแแแแก แกแแฎแแแแ, แ แแแแแแช แฃแแ แแก แแแแแแแขแแก แแแฌแงแแแแแแแแก MAC-แก แแ แแแกแแแ แแแแแขแแแแแ แแขแ แแแฃแขแแแแ Agent-Circuit-Id แแ Agent-Remote-Id, แ แแแแแแแช แจแแแชแแแก, แจแแกแแแแแแกแแ, แแกแแ MAC-แก. แกแแ แแแแ แแแแแแ แแแแแ แแ แแแ แขแ, แ แแแแแแแแแช แแแแแแจแแ แแแฃแแแ แแแแแแแขแ.
- WiFI แฅแฃแแแแแก แแฅแแแ แแแแแแ แแ แแแแแแแขแ แแแขแแ แแแแแฃแแแ PAP-CHAP แแ แแขแแแแแแแแ
- WIFI แฌแแ แขแแแแแแก แแแแแแ แแ แแแแแแแขแ แแแขแแ แแแแแฃแแแ แแแแฎแแแ แแแแแก แกแแฎแแแแ, แ แแแแแแช แขแแแแ WIFI แฌแแ แขแแแแก MAC แแแกแแแแ แแก, แแแ แแแแก แแแ แแจแ.
แแกแขแแ แแฃแแ แคแแแ: แ แ แแ แแก "แแคแชแแ 82" DHCP-แจแ
แแก แแ แแก แแแแแขแแแแแ แแแ แแแแขแ แแแ DHCP แแ แแขแแแแแแกแแแแก, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแขแแแแ แแแแแขแแแแแ แแแคแแ แแแชแแ, แแแแแแแแแ Agent-Circuit-Id แแ Agent-Remote-Id แแแแแแจแ. แฉแแแฃแแแแ แแ แแแแแแงแแแแแ แกแแ แแแแ แแแแแแ แแแแแแกแ แแ แแแ แขแแก MAC แแแกแแแแ แแแก แแแแแกแแชแแแแ, แ แแแแแกแแช แแแแแแแขแ แฃแแแแจแแ แแแแ. PON แแฆแญแฃแ แแแแแแแก แแ WIFI แกแแแแแ แกแแแแฃแ แแแแก แจแแแแฎแแแแแจแ, Agent-Circuit-Id แแแแ แแ แจแแแชแแแก แกแแกแแ แแแแแ แแแคแแ แแแชแแแก (แแ แแ แแก แแแแแแแขแแก แแแ แขแ). แแ แจแแแแฎแแแแแจแ DHCP แแแแ แแชแแแก แแแแแแ แกแฅแแแ แจแแแแแแแ:
แแขแแแแแ แแแแ แแก แกแฅแแแ แแกแ แแฃแจแแแแก:
- แแแแฎแแแ แแแแแก แแฆแญแฃแ แแแแแแ แแแแแแแก DHCP แแแฃแฌแงแแแแแแแก แแแแฎแแแแแก แฅแกแแแแก แแแ แแแแขแ แแแแก แแแกแแฆแแแแ
- แแแฌแงแแแแแแแ (แแแแแแแแแ, แแแแแแ แแแแแ, WiFi แแ PON แกแแแแแ แกแแแแฃแ แ), แ แแแแแแแช แฃแจแฃแแแแ แแ แแก แแแแแแจแแ แแแฃแแ แแแแแแแขแแก แแฆแญแฃแ แแแแแแ, โแฉแแญแ แแกโ แแ แแแแแขแก แแ แชแแแแก แแแก, แจแแแแแฅแแก แแแกแจแ แแแแแขแแแแแ แแคแชแแแแ 82 แแ แกแแ แแแแ แแแแแขแแก IP แแแกแแแแ แแ แแ แแแแแกแชแแแก แแแก แจแแแแแแแจแ. แฅแกแแแ.
- DHCP แกแแ แแแ แ แแฆแแแก แแแแฎแแแแแก, แฅแแแแก แแแกแฃแฎแก แแ แแแแแแแแก แแแก แกแแ แแแแ แแแฌแงแแแแแแแแแ
- แกแแ แแแแ แแแฌแงแแแแแแแ แแแแแแแแก แกแแแแกแฃแฎแ แแแแแขแก แแแแแแแขแแก แแแฌแงแแแแแแแแแ
แ แ แแฅแแ แฃแแแ, แแก แงแแแแแคแแ แ แแกแ แแแ แขแแแแ แแ แแฃแจแแแแก; แแฅแแแ แฃแแแ แแแแแแแคแแแฃแ แแ แแ แแฅแแแแ แฅแกแแแแก แแฆแญแฃแ แแแแแแ แจแแกแแแแแแกแแ.
FreeRadius-แแก แแแกแขแแแแชแแ
แ แ แแฅแแ แฃแแแ, แแแแก แแแฆแฌแแแ แจแแกแแซแแแแแแแ FreeRadius-แแก แแแแคแแแฃแ แแชแแแก แแแ แแแแขแ แแแแ, แแแแ แแ แแก แ แแฃแแ แแ แแแฃแแแแแ แแ... แแแแกแแแฃแแ แแแแ แแแจแแ, แ แแชแ แแฅ แแแแแฎแแ N แแแแก แจแแแแแ แแ โแงแแแแแคแแ แ แแฃแจแแแแกโ. แแแแขแแ, แฉแแแ แแแแแแฌแงแแแขแแ แแแแฌแแ แแ แฉแแแแ แแแขแแ แแแแชแแแก แแแแฃแแ FreeRadius-แแกแแแแก Python-แจแ. แฉแแแ แแแแฆแแแ แแแขแแ แแแแชแแแก แแแแแชแแแแแก MySQL แแแแแชแแแแ แแแแแแแ. แแแ แ แแ แแฅแแก แแแกแ แกแขแ แฃแฅแขแฃแ แแก แแฆแฌแแ แแก; แงแแแแ แจแแแแฎแแแแแจแ, แงแแแแ แแแแแแแแแก แแแก "แแแแแกแแแแก". แแแ แซแแ, แแ แแแแฆแ แกแขแ แฃแฅแขแฃแ แ, แ แแแแแกแแช แกแแแแแแแแแ FreeRadius-แแก sql แแแแฃแแก แแ แแแแแ แจแแแชแแแแ, แงแแแแแ แแแแแแแขแแกแแแแก Mac-แแก แแ แแแ แขแแก แแแแแก แแแแแขแแแแ, แจแแกแแแ-แแแ แแแแก แแแแแขแแแแ.
แแกแ แ แแ, แฏแแ แแแแแแกแขแแแแ แแ FreeRadius:
cd /usr/ports/net/freeradius3
make config
make
install clean
แแแ แแแแขแ แแแจแ แแแ แฉแแแ แแแกแแงแแแแแแแ:
แฉแแแ แแแแแแแแ แกแแแแแแฃแ แแแฃแแก แแแแแแแก แแแแฃแแแแ (แแแฃ โแฉแแ แแแโ):
ln -s /usr/local/etc/raddb/mods-available/python /usr/local/etc/raddb/mods-enabled
แแแแแ แแแแแงแแแแ แแแแแขแแแแแ แแแแฃแแ แแแแแแแกแแแแก:
pip install mysql-connector
แแแแแแแก แแแแฃแแแก แแแ แแแแขแ แแแจแ FreeRadius-แแกแแแแก, แแฅแแแ แฃแแแ แแแฃแแแแแ แแแแฃแแแก แซแแแแแก แแแแแแแแ python_path แชแแแแแจแ. แแแแแแแแแ แแ แแแฅแแก แแก:
python_path="/usr/local/etc/raddb/mods-config/python:/usr/local/lib/python2.7:/usr/local/lib/python27.zip:/usr/local/lib/python2.7:/usr/local/lib/python2.7/plat-freebsd12:/usr/local/lib/python2.7/lib-tk:/usr/local/lib/python2.7/lib-old:/usr/local/lib/python2.7/lib-dynload:/usr/local/lib/python2.7/site-packages"
แแฅแแแ แจแแแแซแแแแ แแแแแแ แแแแแแแแ แแแแแแแก แแแ แฏแแแแแก แแแจแแแแแ แแ แแ แซแแแแแแแแก แจแแงแแแแแ:
root@phaeton:/usr/local/etc/raddb/mods-enabled# python
Python 2.7.15 (default, Dec 8 2018, 01:22:25)
[GCC 4.2.1 Compatible FreeBSD Clang 6.0.1 (tags/RELEASE_601/final 335540)] on freebsd12
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.path
['', '/usr/local/lib/python27.zip', '/usr/local/lib/python2.7', '/usr/local/lib/python2.7/plat-freebsd12', '/usr/local/lib/python2.7/lib-tk', '/usr/local/lib/python2.7/lib-old', '/usr/local/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/site-packages']
>
แแฃ แแ แแแแแฏแก แแ แแแแแแแแแ, แแแจแแ แแแแแแจแ แแแฌแแ แแแ แแ FreeRadius-แแก แแแแ แแแจแแแแฃแแ แกแแ แแแขแแแ แแแ แแแแแแแ แแ แแแแฃแแแแก, แ แแแแแแแช แฉแแแแแแแแแแ แแแแแ แขแจแ. แแแ แแ แแแแกแ, แแฅแแแ แฃแแแ แแแแฃแฅแแแ แแแขแแ แแแแชแแแก แแ แแฆแ แแชแฎแแแก แคแฃแแฅแชแแแแ แแแแฃแแแก แแแ แแแแขแ แแแจแ. แแแแแแแแแ, แแก แแแแฃแแ แแกแ แแแแแแงแฃแ แแแ:
python {
python_path="/usr/local/etc/raddb/mods-config/python:/usr/local/lib/python2.7:/usr/local/lib/python2.7/site-packages:/usr/local/lib/python27.zip:/usr/local/lib/python2.7:/usr/local/lib/python2.7/plat-freebsd12:/usr/local/lib/python2.7/lib-tk:/usr/local/lib/python2.7/lib-old:/usr/local/lib/python2.7/lib-dynload:/usr/local/lib/python2.7/site-packages"
module = work
mod_instantiate = ${.module}
mod_detach = ${.module}
mod_authorize = ${.module}
func_authorize = authorize
mod_authenticate = ${.module}
func_authenticate = authenticate
mod_preacct = ${.module}
func_preacct = preacct
mod_accounting = ${.module}
func_accounting = accounting
mod_checksimul = ${.module}
mod_pre_proxy = ${.module}
mod_post_proxy = ${.module}
mod_post_auth = ${.module}
mod_recv_coa = ${.module}
mod_send_coa = ${.module}
}
work.py แกแแ แแแขแ (แแ แงแแแแ แกแฎแแ) แฃแแแ แแแแแแแกแแแก /usr/local/etc/raddb/mods-config/python-แจแ แกแฃแ แกแแแ แกแแ แแแขแ แแแฅแแก.
work.py:
#!/usr/local/bin/python
# coding=utf-8
import radiusd
import func
import sys
from pprint import pprint
mysql_host="localhost"
mysql_username="ัะบะฐััะบ"
mysql_password="ััะบะฐััะบะฐััะบ"
mysql_base="ััะบะฐัะบัะฐัั"
def instantiate(p):
print ("*** instantiate ***")
print (p)
# return 0 for success or -1 for failure
def authenticate(p):
print ("*** ะััะตะฝัะธะบะฐัะธั!!***")
print (p)
def authorize(p):
radiusd.radlog(radiusd.L_INFO, '*** radlog call in authorize ***')
conn=func.GetConnectionMysql(mysql_host, mysql_username, mysql_password, mysql_base);
param=func.ConvertArrayToNames(p);
pprint(param)
print ("*** ะะฒัะพัะธะทะฐัะธั ***")
reply = ()
conf = ()
cnt=0
username="";mac="";
# ัะฝะฐัะฐะปะฐ ะฟัะพะฒะตััะตะผ "ะบะฐะบ ะฟะพะปะพะถะตะฝะพ", ะฟะพ ัะฒัะทะบะต ะปะพะณะธะฝ/ะฟะฐัะพะปั
if ("User-Name" in param) and ("User-Password" in param) :
print ("ะะฐัะธะฐะฝั ะฐะฒัะพัะธะทะฐัะธะธ (1): ะตััั ะปะพะณะธะฝ-ะฟะฐัะพะปั")
pprint(param["User-Name"])
pprint(param["User-Password"])
pprint(conn)
print(sys.version_info)
print (radiusd.config)
sql="select radreply.attribute,radreply.value from radcheck inner join radreply on radreply.username=radcheck.username where radcheck.username=%s and radcheck.value=%s"
print(sql)
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql,[param["User-Name"], param["User-Password"]]);
row = cursor.fetchone()
while row is not None:
cnt=cnt+1
username=row["username"]
reply = reply+((str(row["attribute"]),str(row["value"])), )
row = cursor.fetchone()
# ะฒะฐัะธะฐะฝั, ััะพ User-Name - ััะพ ะะะก ะฐะดัะตั ะะก,ะฟะฐัะพะปั ะธ ะฟะพััะฐ ะฝะตั
if ("User-Name" in param) and ("User-Password" in param) and (cnt==0):
if param["User-Password"] =='':
if ":" in param["User-Name"]:
pprint(param["User-Name"])
print ("ะะฐัะธะฐะฝั ะฐะฒัะพัะธะทะฐัะธะธ (2): User-Name - ััะพ MAC ะฐะดัะตั ะฑะฐะทะพะฒะพะน ััะฐะฝัะธะธ, ะฟะพััะฐ ะธ ะฟะฐัะพะปั ะฝะตั")
sql="select radreply.username,radreply.attribute,radreply.value from radcheck inner join radreply on radreply.username=radcheck.username where REPLACE(radcheck.mac,':','') = REPLACE(REPLACE('"+str(param["User-Name"])+"','0x',''),':','') and radcheck.sw_port=''"
print (sql)
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql);
row = cursor.fetchone()
while row is not None:
cnt=cnt+1
username=row["username"]
mac=param["User-Name"]
reply = reply+((str(row["attribute"]),str(row["value"])), )
row = cursor.fetchone()
if ("Agent-Remote-Id" in param) and ("User-Password" in param) and (cnt==0):
if param["User-Password"] =='':
pprint(param["Agent-Remote-Id"])
print ("ะะฐัะธะฐะฝั ะฐะฒัะพัะธะทะฐัะธะธ (2.5): Agent-Remote-Id - ััะพ MAC ะฐะดัะตั PON ะพะฑะพััะดะพะฒะฐะฝะธั")
sql="select radreply.username,radreply.attribute,radreply.value from radcheck inner join radreply on radreply.username=radcheck.username where REPLACE(radcheck.mac,':','') = REPLACE(REPLACE('"+str(param["Agent-Remote-Id"])+"','0x',''),':','') and radcheck.sw_port=''"
print (sql)
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql);
row = cursor.fetchone()
while row is not None:
cnt=cnt+1
username=row["username"]
mac=param["User-Name"]
reply = reply+((str(row["attribute"]),str(row["value"])), )
row = cursor.fetchone()
#ะะฐัะธะฐะฝั, ััะพ Agent-Remote-Id - ััะพ ะะะก ะฐะดัะตั ะะก,ะฟะฐัะพะปั ะธ ะฟะพััะฐ ะฝะตั ะธ ะฟัะตะดัะดััะธะต ะฒะฐัะธะฐะฝัั ะฟะพะธัะบะฐ IP ัะตะทัะปััะฐัะฐ ะฝะต ะดะฐะปะธ
if ("Agent-Remote-Id" in param) and ("User-Password" not in param) and (cnt==0):
pprint(param["Agent-Remote-Id"])
print ("ะะฐัะธะฐะฝั ะฐะฒัะพัะธะทะฐัะธะธ (3): Agent-Remote-Id - ะะะก ะฑะฐะทะพะฒะพะน ััะฐะฝัะธะธ/ะฟะพะฝ. ะะพััะฐ ะฒ ะฑะธะปะปะธะฝะณะต ะฝะตั")
sql="select radreply.username,radreply.attribute,radreply.value from radcheck inner join radreply on radreply.username=radcheck.username where REPLACE(radcheck.mac,':','') = REPLACE(REPLACE('"+str(param["Agent-Remote-Id"])+"','0x',''),':','') and radcheck.sw_port=''"
print(sql)
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql);
row = cursor.fetchone()
while row is not None:
cnt=cnt+1
mac=param["Agent-Remote-Id"]
username=row["username"]
reply = reply+((str(row["attribute"]),str(row["value"])), )
row = cursor.fetchone()
#ะะฐัะธะฐะฝั, ััะพ ะฟัะตะดัะดััะธะต ะฟะพะฟััะบะธ ัะตะทัะปััะฐัะฐ ะฝะต ะดะฐะปะธ, ะฝะพ ะตััั Agent-Remote-Id ะธ Agent-Circuit-Id
if ("Agent-Remote-Id" in param) and ("Agent-Circuit-Id" in param) and (cnt==0):
pprint(param["Agent-Remote-Id"])
pprint(param["Agent-Circuit-Id"])
print ("ะะฐัะธะฐะฝั ะฐะฒัะพัะธะทะฐัะธะธ (4): ะฐะฒัะพัะธะทะฐัะธั ะฟะพ Agent-Remote-Id ะธ Agent-Circuit-Id, ะฒ ะฑะธะปะปะธะฝะณะต ะตััั ะฟะพัั/ะผะฐะบ")
sql="select radreply.username,radreply.attribute,radreply.value from radcheck inner join radreply on radreply.username=radcheck.username where upper(radcheck.sw_mac)=upper(REPLACE('"+str(param["Agent-Remote-Id"])+"','0x','')) and upper(radcheck.sw_port)=upper(RIGHT('"+str(param["Agent-Circuit-Id"])+"',2)) and radcheck.sw_port<>''"
print(sql)
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql);
row = cursor.fetchone()
while row is not None:
cnt=cnt+1
mac=param["Agent-Remote-Id"]
username=row["username"]
reply = reply+((str(row["attribute"]),str(row["value"])), )
row = cursor.fetchone()
# ะตัะปะธ ัะฐะบ ะดะพ ัะธั
ะฟะพั IP ะฝะต ะฟะพะปััะตะฝ, ัะพ ะฒัะดะฐั ะธะตะณะพ ะธะท ะณะพััะตะฒะพะน ัะตัะธ..
if cnt==0:
print ("ะะธ ะพะดะธะฝ ะธะท ะฒะฐัะธะฐะฝัะพะฒ ะฐะฒัะพัะธะทะฐัะธะธ ะฝะต ััะฐะฑะพัะฐะป, ะฟะพะปััะฐั IP ะธะท ะณะพััะตะฒะพะน ัะตัะธ..")
ip=func.GetGuestNet(conn)
if ip!="":
cnt=cnt+1;
reply = reply+(("Framed-IP-Address",str(ip)), )
# ะตัะปะธ ัะพะฒัะตะผ ะฒัั ะฟะปะพั
ะพ, ัะพ Reject
if cnt==0:
conf = ( ("Auth-Type", "Reject"), )
else:
#ะตัะปะธ ะฐะฒัะพัะธะทะฐัะธั ััะฟะตัะฝะฐั (ะตััั ัะฐะบะพะน ะฐะฑะพะฝะตะฝั), ัะพ ะทะฐะฟะธัะตะผ ะธััะพัะธั ะฐะฒัะพัะธะทะฐัะธะธ
if username!="":
func.InsertToHistory(conn,username,mac, reply);
conf = ( ("Auth-Type", "Accept"), )
pprint (reply)
conn=None;
return radiusd.RLM_MODULE_OK, reply, conf
def preacct(p):
print ("*** preacct ***")
print (p)
return radiusd.RLM_MODULE_OK
def accounting(p):
print ("*** ะะบะบะฐัะฝัะธะฝะณ ***")
radiusd.radlog(radiusd.L_INFO, '*** radlog call in accounting (0) ***')
print (p)
conn=func.GetConnectionMysql(mysql_host, mysql_username, mysql_password, mysql_base);
param=func.ConvertArrayToNames(p);
pprint(param)
print("ะฃะดะฐะปะธะผ ััะฐััะต ัะตััะธะธ (ะฑะพะปะตะต 20 ะผะธะฝัั ะฝะตั ะฐะบะบะฐัะฝัะธะฝะณะฐ)");
sql="delete from radacct where TIMESTAMPDIFF(minute,acctupdatetime,now())>20"
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql);
conn.commit()
print("ะะฑะฝะพะฒะธะผ/ะดะพะฑะฐะฒะธะผ ะธะฝัะพัะผะฐัะธั ะพ ัะตััะธะธ")
if (("Acct-Unique-Session-Id" in param) and ("User-Name" in param) and ("Framed-IP-Address" in param)):
sql='insert into radacct (radacctid,acctuniqueid,username,framedipaddress,acctstarttime) values (null,"'+str(param['Acct-Unique-Session-Id'])+'","'+str(param['User-Name'])+'","'+str(param['Framed-IP-Address'])+'",now()) ON DUPLICATE KEY update acctupdatetime=now()'
print(sql)
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql)
conn.commit()
conn=None;
return radiusd.RLM_MODULE_OK
def pre_proxy(p):
print ("*** pre_proxy ***")
print (p)
return radiusd.RLM_MODULE_OK
def post_proxy(p):
print ("*** post_proxy ***")
print (p)
return radiusd.RLM_MODULE_OK
def post_auth(p):
print ("*** post_auth ***")
print (p)
return radiusd.RLM_MODULE_OK
def recv_coa(p):
print ("*** recv_coa ***")
print (p)
return radiusd.RLM_MODULE_OK
def send_coa(p):
print ("*** send_coa ***")
print (p)
return radiusd.RLM_MODULE_OK
def detach():
print ("*** ะะฐ ััะพะผ ะฒัั ะดะตัะธัะตัะบะธ ***")
return radiusd.RLM_MODULE_OK
func.py:
#!/usr/bin/python2.7
# coding=utf-8
import mysql.connector
from mysql.connector import Error
# ะคัะฝะบัะธั ะฒะพะทะฒัะฐัะฐะตั ัะพะตะดะธะฝะตะฝะธะต ั MySQL
def GetConnectionMysql(mysql_host, mysql_username, mysql_password, mysql_base):
try:
conn = mysql.connector.connect(host=mysql_host,database=mysql_base,user=mysql_username,password=mysql_password)
if conn.is_connected(): print('---cะพะตะดะธะฝะตะฝะธะต ั ะะ '+mysql_base+' ัััะฐะฝะพะฒะปะตะฝะพ')
except Error as e:
print("ะัะธะฑะบะฐ: ",e);
exit(1);
return conn
def ConvertArrayToNames(p):
mass={};
for z in p:
mass[z[0]]=z[1]
return mass
# ะคัะฝะบัะธั ะทะฐะฟะธััะฒะฐะตั ะธััะพัะธั ัะพะตะดะธะฝะตะฝะธั ะฟะพ ะธะทะฒะตััะฝัะผ ะดะฐะฝะฝัะผ
def InsertToHistory(conn,username,mac, reply):
print("--ะทะฐะฟะธััะฒะฐั ะดะปั ะธััะพัะธะธ")
repl=ConvertArrayToNames(reply)
if "Framed-IP-Address" in repl:
sql='insert into radpostauth (username,reply,authdate,ip,mac,session_id,comment) values ("'+username+'","Access-Accept",now(),"'+str(repl["Framed-IP-Address"])+'","'+str(mac)+'","","")'
print(sql)
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql);
conn.commit()
# ะคัะฝะบัะธั ะฒัะดะฐะตั ะฟะพัะปะตะดะฝะธะน ะฟะพ ะดะฐัะต ะฒัะดะฐัะธ IP ะฐะดัะตั ะธะท ะณะพััะตะฒะพะน ัะตัะธ
def GetGuestNet(conn):
ip="";id=0
sql="select * from guestnet order by dt limit 1"
print (sql)
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql);
row = cursor.fetchone()
while row is not None:
ip=row["ip"]
id=row["id"]
row = cursor.fetchone()
if id>0:
sql="update guestnet set dt=now() where id="+str(id)
print (sql)
cursor = conn.cursor(dictionary=True,buffered=True)
cursor.execute(sql);
conn.commit()
return ip
radiusd.py:
#!/usr/bin/python2.7
# coding=utf-8
# from modules.h
RLM_MODULE_REJECT = 0
RLM_MODULE_FAIL = 1
RLM_MODULE_OK = 2
RLM_MODULE_HANDLED = 3
RLM_MODULE_INVALID = 4
RLM_MODULE_USERLOCK = 5
RLM_MODULE_NOTFOUND = 6
RLM_MODULE_NOOP = 7
RLM_MODULE_UPDATED = 8
RLM_MODULE_NUMCODES = 9
# from log.h
L_AUTH = 2
L_INFO = 3
L_ERR = 4
L_WARN = 5
L_PROXY = 6
L_ACCT = 7
L_DBG = 16
L_DBG_WARN = 17
L_DBG_ERR = 18
L_DBG_WARN_REQ = 19
L_DBG_ERR_REQ = 20
# log function
def radlog(level, msg):
import sys
sys.stdout.write(msg + 'n')
level = level
แ แแแแ แช แแแแแแแ แฎแแแแแ, แฉแแแ แแชแแแแแแ แแแแแแแขแแก แแแแแขแแคแแชแแ แแแแก แงแแแแ แแ แกแแแฃแแ แแแแแแแก แแแแแงแแแแแแ แแแกแ แชแแแแแแ แแแแแแแขแแก MAC แแแกแแแแ แแแแแ แแ แแคแชแแ 82 แแแแแแแแชแแแ, แแ แแฃ แแก แแ แแฃแจแแแแก, แแแจแแ แฉแแแ แแแแชแแแ แฃแซแแแแแก IP แแแกแแแแ แแก, แ แแแแแแช แแแแกแแ แแแแแงแแแแแฃแแแ "แกแขแฃแแ แแกแแแ". โ แฅแกแแแ. แ แฉแแแ แแฎแแแแ แแแแฃแแแกแฎแแแแ แกแแ แแแขแแก แแแแคแแแฃแ แแชแแ แกแแแขแแแแ แฉแแ แแฃแแ แกแแฅแแฆแแแแแจแ, แแกแ, แ แแ แแแแแแแก แกแแ แแแขแแก แกแแญแแ แ แคแฃแแฅแชแแแแ แแแแแจแแฃแ แแแแแแขแแแจแ แแแแชแแแ. แกแแแแแแแแแแจแ, แกแแแแแ แแกแแ แคแแแแแก แคแแ แแแจแ แแแขแแแ:
แแแกแขแ
server default {
listen {
type = auth
ipaddr = *
port = 0
limit {
max_connections = 16
lifetime = 0
idle_timeout = 30
}
}
listen {
ipaddr = *
port = 0
type = acct
limit {
}
}
listen {
type = auth
port = 0
limit {
max_connections = 1600
lifetime = 0
idle_timeout = 30
}
}
listen {
ipv6addr = ::
port = 0
type = acct
limit {
}
}
authorize {
python
filter_username
preprocess
expiration
logintime
}
authenticate {
Auth-Type PAP {
pap
python
}
Auth-Type CHAP {
chap
python
}
Auth-Type MS-CHAP {
mschap
python
}
eap
}
preacct {
preprocess
acct_unique
suffix
files
}
accounting {
python
exec
attr_filter.accounting_response
}
session {
}
post-auth {
update {
&reply: += &session-state:
}
exec
remove_reply_message_if_eap
Post-Auth-Type REJECT {
attr_filter.access_reject
eap
remove_reply_message_if_eap
}
Post-Auth-Type Challenge {
}
}
pre-proxy {
}
post-proxy {
eap
}
}
แแแแแ แแชแแแแ แแแกแ แแแจแแแแ แแ แแแแฎแแ, แ แ แจแแแแก แแแแแ แแแแก แแฃแ แแแแจแ:
/usr/local/etc/rc.d/radiusd debug
แฒกแฎแแ แ แ. FreeRadius-แแก แแแงแแแแแแกแแก แแแกแแฎแแ แฎแแแแแแ แแแกแ แแแฅแแแแแแแก แขแแกแขแแ แแแ radclient แแ แแแ แแแแก แแแแแงแแแแแแ. แแแแแแแแแ, แแแขแแ แแแแชแแ:
echo "User-Name=4C:5E:0C:2E:7F:15,Agent-Remote-Id=0x9845623a8c98,Agent-Circuit-Id=0x00010006" | radclient -x 127.0.0.1:1812 auth testing123
แแ แแแแแ แแจแ:
echo "User-Name=4C:5E:0C:2E:7F:15,Agent-Remote-Id=0x00030f26054a,Agent-Circuit-Id=0x00010002" | radclient -x 127.0.0.1:1813 acct testing123
แแแแแ แแแแแคแ แแฎแแแแ, แ แแ แแแกแแแฃแขแฃแ แแ แจแแฃแซแแแแแแแ แแกแแแ แกแฅแแแแกแ แแ แกแแ แแแขแแแแก แแแแแงแแแแแ โแชแแแแแแแแแแก แแแ แแจแโ โแแแแฃแกแขแ แแฃแแโ แแแกแจแขแแแแ. แงแแแแ แจแแแแฎแแแแแจแ แจแแกแแแฉแแแแ:
- แจแแกแแซแแแแแแแ MAC แแแกแแแแ แแแก โแแแงแแแแแแโ. แกแแแแแ แแกแแ แแแแแแแขแแ แแแแ แแแแกแขแ แแ แแก แกแฎแแแกแ MAC แแ แแฅแแแแ แแ แแแแแแแแ
- แกแขแฃแแ แแแแก แฅแกแแแแแแก แแแชแแแแก แแแแแแ แแ แแขแแแแก แแแฆแแแ. แจแแแแฌแแแแแช แแ แแ แแ แแก "แแฅแแแ แฃแแแ แแ แแแ แแแแแแขแแแ แแแแแ IP แแแกแแแแ แแแ?"
แแก แแ แแก แแฎแแแแ "แแแแชแฎแแ แแแแก แกแแญแ แแแ แฎแกแแแ แ", แ แแแแแแช แจแแฅแแแแแแ แกแแแชแแแแฃแ แแ แฉแแแก แแแ แแแแแจแ แกแแแฃแจแแแ, แแแขแ แแ แแคแแ แ. แแแแชแ แแ แแฃ แแแแกแฏแแ ๐
แฌแงแแ แ: www.habr.com