एक छोटे नेटवर्क के लिए ट्रैफ़िक को आकार देने के साथ PPPoE कॉन्फ़िगर करें

एक बार दर्जनों कंप्यूटर (कार्यालय और घर) के एक जोड़े के लिए इंटरनेट के वितरण को कॉन्फ़िगर करने का कार्य था। बॉक्सिंग समाधान या तो भुगतान किया गया या कॉन्फ़िगर करना मुश्किल है, इसलिए यह डेबियन लिनक्स पर आधारित हमारे अपने उपयोग का निर्णय लिया गया। मैं इस पोस्ट में इसे उठाने का अनुभव आपके साथ साझा करना चाहता हूं, लेकिन यहां दिए गए संस्करण "खुद के लिए" मैनुअल लिखने के बाद से थोड़े पुराने हो गए हैं, इसलिए कुछ ध्यान रखना होगा। इसके अलावा, आपको यह विचार करने की आवश्यकता है कि उपरोक्त समाधान आदर्श और पेशेवर से बहुत दूर है। यह बजाय उन लोगों की मदद करेगा जिन्हें इंटरनेट वितरित करने वाले सर्वर को जल्दी से लेने की आवश्यकता है। अंत में, हमारे पास पीपीपीओई के माध्यम से इंटरनेट वितरण होगा जिसमें आंतरिक आईपी क्लाइंट, ट्रैफिक को आकार देने, एक डीएनएस सर्वर और कंसोल से वर्तमान सत्रों की सरल निगरानी के साथ काम होगा।

सिस्टम की तैयारी

aptitude update

aptitude install openssh-server mc mtr tracert nano tcpdump bind9 pppoe freeradius radiusclient1 rcconf php5

DNS सर्वर सेटअप

हम बाहर ले जाते हैं

nano /etc/bind/named.conf.options







फ़ाइल के अंत में जोड़ें:

allow-transfer { none; };

allow-query { 10.128.0.0/16; localhost; }; //

allow-recursion { 10.128.0.0/16; localhost; }; //

version "My ISP DNS"; //









आइए हमारे DNS सर्वर के लिए चेरोट वातावरण सेट करना शुरू करें। DNS सर्वर के रूट फाइल सिस्टम की निर्देशिका बनाएँ - root-dns:

mkdir -p /root-dns/etc

mkdir /root-dns/dev

mkdir -p /root-dns/var/cache/bind

mkdir -p /root-dns/var/run/bind/run

/etc/init.d/bind9 stop

nano /etc/default/bind9







लाइन "विकल्प =" मिला और प्रतिस्थापित किया गया:

OPTIONS="-u bind -t /root-dns"







mv /etc/bind /root-dns/etc

ln -s /root-dns/etc/bind /etc/bind

nano /etc/init.d/bind9









लाइन "विकल्प =" मिला और प्रतिस्थापित किया गया:

OPTIONS="-u bind -t /root-dns"







हम लॉन्च करते हैं:

nano /etc/init.d/rsyslogd







"RSYSLOGD_OPTIONS" मिला और प्रतिस्थापित किया गया:

RSYSLOGD_OPTIONS="-c3 -a /root-dns/dev/log"







हम name.conf कॉन्फ़िगरेशन फ़ाइल को संपादन और हटाने से बचाते हैं:

chattr +i /root-dns/etc/bind/named.conf







नोट। कॉन्फ़िगरेशन फ़ाइल को संपादित करने से पहले "i" विशेषता को याद रखें (chattr -i ...)



mknod /root-dns/dev/null c 1 3

mknod /root-dns/dev/random c 1 8

chmod 666 /root-dns/dev/null /root-dns/dev/random

chown -R bind:bind /root-dns/var/*

chown -R bind:bind /root-dns/etc/bind

/etc/init.d/bind9 start



PPPoE सर्वर

cd /tmp

apt-get build-dep pppoe

apt-get source pppoe

cd rp-pppoe-3.8/src

./configure









हम लॉन्च करते हैं:

nano config.h







अब बस बनाए गए config.h फ़ाइल में आपको पंक्ति को बदलने की आवश्यकता है:

/* #undef HAVE_LINUX_KERNEL_PPPOE */







लाइन पर:

#define HAVE_LINUX_KERNEL_PPPOE 1







हम बाहर ले:

cd ..

./debian/rules PLUGIN_PATH=/usr/lib/pppd/2.4.4/rp-pppoe.so

./debian/rules binary

cd ..

dpkg -i pppoe_3.8-3_i386.deb









सिस्टम को अपने आप अपडेट होने से रोकने के लिए पैकेज को फ्रीज करें:

echo pppoe hold | dpkg —set-selections







अब से, कम से कम हर बार जब आप सिस्टम को अपडेट करते हैं, तो आपको अपडेट की सूची देखने की आवश्यकता होती है। यदि एक अद्यतन बंद हो जाता है pppoe के लिए जो भेद्यता को बंद कर देता है, तो पैकेज को नए स्रोतों से फिर से इकट्ठा करना आवश्यक होगा, कमांड का उपयोग करके सिस्टम से पैकेज को हटा दें:

echo pppoe install | dpkg --set-selections







अब सिस्टम पर PPPoE सर्वर वाला एक पैकेज स्थापित किया गया है, जो कर्नेल स्तर PPPoE कनेक्शन का समर्थन करने की अनुमति देता है। सर्वर को इस मोड में शुरू करने के लिए, पिछले अनुभाग में वर्णित कमांड में -k विकल्प जोड़ें: pppoe-server -I eth1 -L 192.168.0.1 -k



हम लॉन्च करते हैं:

nano /etc/ppp/pppoe-server-options







सम्मिलित करें:

logfile /var/log/pppoe.log

debug

mtu 1472

mru 1472

auth

require-pap

#require-chap

default-asyncmap

ktune

lcp-echo-interval 20

lcp-echo-failure 2

ms-dns 10.128.0.1

plugin radius.so

plugin radattr.so

10.128.0.1:

nobsdcomp

noccp

noendpoint

noipdefault

noipx

novj

receive-all







हम लॉन्च करते हैं:

nano /etc/ppp/options







कॉन्फ़िगरेशन / आदि / ppp / विकल्प में: सब कुछ निकालें, सेट करें:

lock







हम लॉन्च करते हैं:

nano /etc/init.d/pppoe-server









स्क्रिप्ट:

#!/bin/bash

# init file for rp-pppoe server

#

# description: PPPOE kernel mode server

#

# processname: pppoe-server

# chkconfig: - 45 45

# source function library

#. /etc/rc.status

case "$1" in

start)

echo -n "Starting PPPOE server: "

/usr/sbin/pppoe-server -I eth0 -L 10.128.0.1 -R 10.128.1.1 -k

# eth0 — ,

#10.128.0.1 - IP PPPoE

#10.128.1.1 - IP

#touch /var/lock/subsys/pppoed

#rc_status -v

;;

stop)

echo -n "Shutting down PPPOE server: "

pkill pppoe-server

#rm -f /var/lock/subsys/pppoed

#rc_status -v

;;

restart)

$0 stop

$0 start

;;

status)

status pppoe-server

;;

*)

echo "Usage: pppoed {start|stop|restart|status}"

exit 1

esac

exit 0









हम लॉन्च करते हैं:

rcconf







बाँध अक्षम करें। फिर हम फिर से वहां जाते हैं और देखते हैं कि वह सूची से पूरी तरह से गायब हो गया है। नीचे यह वहाँ है, और अगले हमारे pppoe- सर्वर है। उनमें यह और वह दोनों शामिल थे। आउट।



cd /root-dns/etc/bind

rndc-confgen -r /dev/urandom -a

chgrp bind rndc.key

chmod +r rndc.key

nano named.conf.options









फ़ाइल के अंत में, जोड़ें:

controls {

inet 127.0.0.1 allow { localhost; } keys { rndc-key; };

};

include "/etc/bind/rndc.key";









अब आपको अभी भी कर्नेल में अग्रेषण को सक्षम करने और iptables नियम को हुक करने की आवश्यकता है। कॉन्फ़िगरेशन का परीक्षण अभी किया जाएगा।

पैरामीटर sysctl.conf, iptables, नेटवर्क इंटरफ़ेस सेटिंग्स

हम लॉन्च करते हैं:

nano /etc/sysctl.conf







जोड़ा गया, जो नहीं था:

net.ipv4.conf.default.rp_filter=1

net.ipv4.conf.all.rp_filter=1

net.ipv4.tcp_syncookies=1

net.ipv4.ip_forward=1

kernel.panic = 1

kernel.panic_on_oops = 1

kernel.panic_on_io_nmi = 1

kernel.panic_on_unrecovered_nmi = 1







अंतिम 4 लाइनें विभिन्न सिस्टम क्रैश के दौरान रिबूट होती हैं, इसलिए रिबूट के लिए किसी दूसरे शहर की यात्रा न करें। सहेजा गया, फिर iptables के लिए एक परीक्षण कॉन्फिगर करें:

iptables -t nat -F

iptables-save > /etc/firewall.conf

nano rc.local









अब r.local में हमारे पास होगा:

ifconfig eth0 up

iptables-restore </etc/firewall.conf









इसके बाद, कॉन्फ़िगर / आदि / नेटवर्क / इंटरफेस - यहाँ eth0 स्थानीय निकला, हम ऑटो eth0 को छोड़कर, कुछ भी नहीं लिखेंगे। और eth1 के बारे में - अगर यह इंटरनेट है - मैं एक स्थिर बाहरी आईपी के बारे में सोचूंगा, अन्यथा आप SNAT का उपयोग नहीं कर सकते, लेकिन केवल MASQUERADE, और यह सिस्टम को कठिन लोड करता है।



हम लॉन्च करते हैं:

nano /etc/network/interfaces







config:

auto lo

iface lo inet loopback

auto eth0

auto eth1



allow-hotplug eth0 eth1

iface eth1 inet dhcp









इस लिस्टिंग में, NAT1 नैट और डीएचसीपी कॉन्फिग के माध्यम से इंटरनेट 1 है।

PPPoE सर्वर चलाएं

इसके बाद, आपको एक त्रिज्या के बिना पीपीपीओई का परीक्षण करने की आवश्यकता है। ऐसा करने के लिए, / etc / ppp / pppoe-server-options में प्लगइन्स की 2 पंक्तियों पर टिप्पणी करें।



हम लॉन्च करते हैं:

nano /etc/ppp/pppoe-server-options







config:

#plugin radius.so

#plugin radattr.so









हम लॉन्च करते हैं:

nano /etc/ppp/pap-secrets







अंत में जोड़ें या सामग्री को पूरी तरह से बदलें:

test * test 10.128.2.10







Pppoe-server लॉन्च करें:

/etc/init.d/pppoe-server start







सर्वर को रिबूट किया, पीपीपीओई और इंटरनेट की जांच की। किसी भी क्लाइंट पर, PPPoE कनेक्शन बनाएं और उपयोगकर्ता नाम और पासवर्ड परीक्षण का उपयोग करके कनेक्ट करें। क्लाइंट के साथ काम करने के लिए इंटरनेट के लिए, आपको संदेश भेजने में सक्षम होना चाहिए:

iptables -t nat -A POSTROUTING -o eth1 -j MASQUERADE







क्या यह काम करता है? खैर, जैसा था वैसा ही लौटा:

iptables -t nat -F

FreeRadius

हम लॉन्च करते हैं:

nano /etc/radiusclient/servers







फ़ाइल की सामग्री को बदलें:

127.0.0.1 my-isp-radius







हम लॉन्च करते हैं:

nano /etc/radiusclient/radiusclient.conf







फ़ाइल की सामग्री को बदलें:

auth_order radius,local

login_tries 4

login_timeout 60

nologin /etc/nologin

issue /etc/radiusclient/issue

# RADIUS settings

authserver localhost:1812

acctserver localhost:1812

servers /etc/radiusclient/servers

dictionary /etc/radiusclient/dictionary

login_radius /usr/sbin/login.radius

# RADIUS server

seqfile /var/run/radius.seq

mapfile /etc/radiusclient/port-id-map

default_realm

radius_timeout 10

radius_retries 3

login_local /bin/login









हम लॉन्च करते हैं:

nano /etc/freeradius/radiusd.conf







फ़ाइल की सामग्री को बदलें:

prefix = /usr

exec_prefix = /usr

sysconfdir = /etc

localstatedir = /var

sbindir = ${exec_prefix}/sbin

logdir = /var/log/freeradius

raddbdir = /etc/freeradius

radacctdir = ${logdir}/radacct

# .

confdir = ${raddbdir}

run_dir = ${localstatedir}/run/freeradius

# .

libdir = ${exec_prefix}/lib

# pid-. .

pidfile = ${run_dir}/freeradius.pid

# FreeRADIUS

user = freerad

group = freerad

# ( ) .

max_request_time = 30

# max_request_time

delete_blocked_requests = no

# ( ) reply NAS.

cleanup_delay = 5

# .

# 256.

# 1024.

max_requests = 5120

# ip . RADIUS

# ip .

bind_address = 127.0.0.1

# FreeRADIUS port. ,

# /etc/services

port = 0

# / ip dns .

# .

hostname_lookups = no

# / .

allow_core_dumps = no

# .

regular_expressions = yes

extended_expressions = yes

# User-Name .

log_stripped_names = no

# .

log_auth = yes

# .

# log_auth_badpass -

# log_auth_goodpass -

log_auth_badpass = yes

log_auth_goodpass = no

# / .

usercollide = no

# / .

lower_user = no

lower_pass = no

# / .

nospace_user = no

nospace_pass = no

# DoS .

security {

# RADIUS .

max_attributes = 200

# ( ) Access-Reject .

reject_delay = 1

# Status-Server

status_server = no

}

# RADIUS .

# .

$INCLUDE ${confdir}/clients.conf

# snmp .

snmp=no

# .

thread pool {

# .

start_servers = 5

# .

max_servers = 32

# .

min_spare_servers = 3

max_spare_servers = 10



# .

# RADIUS . 300,

# .

max_requests_per_server = 0

}



# .

modules {

# PAP .

# PAP .

# encryption_scheme .

# clear - .

pap {

encryption_scheme = clear

}

# CHAP .

# CHAP .

# authtype Auth-Type=CHAP

chap {

authtype = CHAP

}

# .

# .. .

preprocess {

# huntgroups - . huntgoups.

# hints - .

huntgroups = ${confdir}/huntgroups

hints = ${confdir}/hints



# Cisco VSA.

with_cisco_vsa_hack = no

}

# Microsoft CHAP .

# Microsoft CHAP v2

# authtype Auth-Type=MS-CHAP

# use_mppe = no VPN .

mschap {

authtype = MS-CHAP

use_mppe = no

}

# Livingston RADIUS .

# usersfile .

# .

# acctusersfile ().

# compat - . FreeRADIUS .

files {

usersfile = ${confdir}/users

compat = no

}



# .

detail {

detailfile = ${radacctdir}/%{Client-IP-Address}/detail-%Y%m%d

detailperm = 0600

}



# .

detail auth_log {

detailfile = ${radacctdir}/%{Client-IP-Address}/auth-detail-%Y%m%d

detailperm = 0600

}



# reply .

detail reply_log {

detailfile = ${radacctdir}/%{Client-IP-Address}/reply-detail-%Y%m%d

detailperm = 0600

}



# .

# NAS Acct-Session-ID.

# key Acct-Session-ID

acct_unique {

key = "User-Name, Acct-Session-Id, NAS-IP-Address, Client-IP-Address, NAS-Port-Id"

}



#

# cakesql.conf

#$INCLUDE ${confdir}/sql.conf

#$INCLUDE ${confdir}/sql/mysql/counter.conf

}



#

# preprocess

# .

# chap mschap chap mschap .

authorize {

preprocess

chap

mschap

# .

# auth_log

files

#sql

}

#

# , .

authenticate {

Auth-Type PAP {

pap

}



Auth-Type CHAP {

chap

}



Auth-Type MS-CHAP {

mschap

}



}

# .

preacct {

preprocess

}

# .

accounting {

# Acct-Session-Id NAS .

acct_unique

# detail .

detail

#

#sql

}

# reply-.

post-auth {

# .

reply_log

}

log {

destination = files

file = ${logdir}/radius.log

syslog_facility = daemon

stripped_names = no

auth = no

auth_badpass = no

auth_goodpass = no

}









हम लॉन्च करते हैं:

nano /etc/freeradius/clients.conf







फ़ाइल की सामग्री को बदलें:

client localhost {

ipaddr = 127.0.0.1

secret = my-isp-radius

require_message_authenticator = no

nastype = other

}









हम लॉन्च करते हैं:

nano /etc/freeradius/users







config:

steve Cleartext-Password := "testing"

Service-Type = Framed-User,

Framed-Protocol = PPP,

Framed-IP-Address = 10.128.13.3,

Framed-IP-Netmask = 255.255.0.0,

Framed-Routing = Broadcast-Listen,

Framed-Filter-Id = "std.ppp",

Framed-MTU = 1500,

Framed-Compression = Van-Jacobsen-TCP-IP



#



DEFAULT Framed-Protocol == PPP

Framed-Protocol = PPP,

Framed-Compression = Van-Jacobson-TCP-IP



DEFAULT Hint == "CSLIP"

Framed-Protocol = SLIP,

Framed-Compression = Van-Jacobson-TCP-IP



DEFAULT Hint == "SLIP"

Framed-Protocol = SLIP









सामान्य तौर पर, भविष्य में आपको MySQL के साथ एक बंडल कॉन्फ़िगर करने की आवश्यकता होगी, लेकिन इस स्तर पर यह महत्वपूर्ण नहीं है। उपयोगकर्ता को जोड़ते समय, आपको Freeradius को पुनरारंभ करना होगा:

/etc/init.d/freeradius restart







अब आपको ट्रैफ़िक को आकार देने से निपटने की आवश्यकता है। विचार यह है कि गति को प्रत्येक उपयोगकर्ता के लिए व्यक्तिगत रूप से समायोजित किया जाना चाहिए और रेडियस सर्वर से NAT सर्वर के लिए एक विशेषता के रूप में प्रेषित किया जाना चाहिए। क्यों? ताकि बाद में संरचना का विस्तार करना और कई एनएएस के बीच लोड को वितरित करना संभव था।

यातायात को आकार देने

तो, तैयारी। Wondershaper स्थापित करें:

aptitude install wondershaper







यह पैकेज एक एकल स्क्रिप्ट है जो CBQ / HTB प्राथमिकता के साथ काम करता है और इसमें एक सायन कॉल प्रारूप है। यदि वांछित है, तो आप कार्यान्वयन से पहले इसके काम का परीक्षण कर सकते हैं:

wondershaper ppp0 512 512







स्वाभाविक रूप से, ppp0 का अस्तित्व होना चाहिए और हमारे सर्वर से जुड़ने वाले क्लाइंट का परिणाम होना चाहिए। कमांड पूरा होने के बाद, क्लाइंट का वेब ब्राउज़र किसी भी साइट पर जा सकता है, जो स्पीड को मापता है, जैसे कि speedtest.net - और सुनिश्चित करें कि यह अभी भी शेपर के साथ काटा गया है। क्लाइंट से डिस्कनेक्ट किए बिना सेटिंग्स को रीसेट करने के लिए (अर्थात, किक), हम करते हैं

wondershaper clear ppp0







और सुनिश्चित करें कि WAN इंटरफ़ेस पर "बड़े भाई" से ली जाने वाली गति के बराबर गति फिर से सामान्य है (यानी, जो कि एक साधारण फ़ाइल parser /var/run/radattr.pppr.ppp) का उपयोग करके गति सीमा को स्वचालित किया जाना चाहिए। सफल पीपीपी कनेक्शन और इसमें रेडियस सर्वर द्वारा पीपीपीओई सर्वर को दी गई सभी विशेषताएँ शामिल हैं। हम विशेषताओं से निपटेंगे। हम इसके साथ अतिरिक्त विशेषताओं फ़ाइल / etc / freeradius / शब्दकोश की सामग्री को पूरक करते हैं:



हम लॉन्च करते हैं:

nano /etc/freeradius/dictionary







config:

# Limit session traffic

ATTRIBUTE Session-Octets-Limit 227 integer

# What to assume as limit - 0 in+out, 1 in, 2 out, 3 max(in,out)

ATTRIBUTE Octets-Direction 228 integer

# Connection Speed Limit

ATTRIBUTE PPPD-Upstream-Speed-Limit 230 integer

ATTRIBUTE PPPD-Downstream-Speed-Limit 231 integer

ATTRIBUTE PPPD-Upstream-Speed-Limit-1 232 integer

ATTRIBUTE PPPD-Downstream-Speed-Limit-1 233 integer

ATTRIBUTE PPPD-Upstream-Speed-Limit-2 234 integer

ATTRIBUTE PPPD-Downstream-Speed-Limit-2 235 integer

ATTRIBUTE PPPD-Upstream-Speed-Limit-3 236 integer

ATTRIBUTE PPPD-Downstream-Speed-Limit-3 237 integer

ATTRIBUTE Acct-Interim-Interval 85 integer







इसके अलावा, इन समान विशेषताओं को Raduisclient शब्दकोश में जोड़ने की आवश्यकता है। हम / आदि / त्रिज्या / शब्दकोश संपादित करते हैं, अंत में हम इसे जोड़ते हैं:



हम लॉन्च करते हैं:

nano /etc/radiusclient/dictionary







config:

# Limit session traffic

ATTRIBUTE Session-Octets-Limit 227 integer

# What to assume as limit - 0 in+out, 1 in, 2 out, 3 max(in,out)

ATTRIBUTE Octets-Direction 228 integer

# Connection Speed Limit

ATTRIBUTE PPPD-Upstream-Speed-Limit 230 integer

ATTRIBUTE PPPD-Downstream-Speed-Limit 231 integer

ATTRIBUTE PPPD-Upstream-Speed-Limit-1 232 integer

ATTRIBUTE PPPD-Downstream-Speed-Limit-1 233 integer

ATTRIBUTE PPPD-Upstream-Speed-Limit-2 234 integer

ATTRIBUTE PPPD-Downstream-Speed-Limit-2 235 integer

ATTRIBUTE PPPD-Upstream-Speed-Limit-3 236 integer

ATTRIBUTE PPPD-Downstream-Speed-Limit-3 237 integer

ATTRIBUTE Acct-Interim-Interval 85 integer









सब कुछ ठीक है, अब वे (फ्रीरेडियस और रेडियस क्लिएंट) एक-दूसरे को समझेंगे। तदनुसार, फ्रीराडियस उपयोगकर्ताओं की सेटिंग में, अतिरिक्त लाइनें आवक और आउटगोइंग गति (लेकिन आवश्यक नहीं) की सीमा का संकेत देती दिखाई देंगी। उदाहरण / etc / freeradius / परिवर्तन वाले उपयोगकर्ता:



हम लॉन्च करते हैं:

nano /etc/freeradius/users







config:

steve Cleartext-Password := "testing"

Service-Type = Framed-User,

Framed-Protocol = PPP,

Framed-IP-Address = 10.128.13.3,

Framed-IP-Netmask = 255.255.0.0,

Framed-Routing = Broadcast-Listen,

Framed-Filter-Id = "std.ppp",

Framed-MTU = 1500,

Framed-Compression = Van-Jacobsen-TCP-IP

PPPD-Downstream-Speed-Limit = 1024,

PPPD-Upstream-Speed-Limit = 1024



#



DEFAULT Framed-Protocol == PPP

Framed-Protocol = PPP,

Framed-Compression = Van-Jacobson-TCP-IP



DEFAULT Hint == "CSLIP"

Framed-Protocol = SLIP,

Framed-Compression = Van-Jacobson-TCP-IP



DEFAULT Hint == "SLIP"

Framed-Protocol = SLIP







अब NAS गति जानकारी प्राप्त करता है, लेकिन यह नहीं जानता कि इसे कैसे संसाधित किया जाए। हम दो स्क्रिप्ट बनाते हैं जो कनेक्शन स्थापित करते समय पारित विशेषताओं को पार्स करते हैं:



हम लॉन्च करते हैं:

nano /etc/ppp/ip-up.d/0001shaper







स्क्रिप्ट:

#!/bin/sh

/root-scripts/shape-on $1 $5

exit 0







हम लॉन्च करते हैं:

nano /etc/ppp/ip-down.d/0001shaper







स्क्रिप्ट:

#!/bin/sh

/root-scripts/shape-off $1 $5

exit 0







जैसा कि इन लिस्टिंग से देखा जा सकता है, एक निश्चित स्क्रिप्ट को कहा जाता है जो लागू होता है और आकार देने वाले कैंसिल। इस पल से - अधिक विस्तार से। $ 1 इंटरफ़ेस नाम है, जो कि, उदाहरण के लिए ppp0 है, $ 5 फ़्रेम-आईपी है, अर्थात, पीपीपी क्लाइंट का आईपी पता। प्रतिष्ठित निर्देशिका बनाएं और इसे दो फाइलों में डालें:

mkdir /root-scripts

nano /root-scripts/shape-on







स्क्रिप्ट:

#!/bin/sh

if [ -f /var/run/radattr.$1 ]

then

DOWNSPEED=`awk '/PPPD-Downstream-Speed-Limit/ {print $2}' /var/run/radattr.$1`

UPSPEED=`awk '/PPPD-Upstream-Speed-Limit/ {print $2}' /var/run/radattr.$1`

wondershaper $1 $DOWNSPEED $UPSPEED

fi

iptables -A FORWARD -s $2 -j ACCEPT

iptables -A INPUT -s $2 -j ACCEPT

iptables -t nat -A POSTROUTING -s $2 -o eth1 -j MASQUERADE









हम लॉन्च करते हैं:

nano /root-scripts/shape-off







स्क्रिप्ट:

#!/bin/sh

iptables -D FORWARD -s $2 -j ACCEPT

iptables -D INPUT -s $2 -j ACCEPT

iptables -t nat -D POSTROUTING -s $2 -o eth1 -j MASQUERADE









हम लॉन्च करते हैं:

chmod +x /root-scripts/*







लिस्टिंग में, eth1 अभी भी WAN इंटरफ़ेस है। इसलिए, परिणामस्वरूप हमें क्या मिलता है: ग्राहक पीपीपी सर्वर से जुड़ता है, एक आईपी पता प्राप्त करता है। एक स्क्रिप्ट को स्वचालित रूप से कहा जाता है कि पीपीपी क्लाइंट इंटरफ़ेस पर आकार देना और इसके लिए मास्किंग शामिल है। जब डिस्कनेक्ट किया जाता है, तो मस्कारिंग नियम भी स्वचालित रूप से हटा दिया जाता है। ऐसा लगता है कि wondershaper को pppx से डिस्कनेक्ट करने के लिए मजबूर होने की आवश्यकता नहीं है, किसी भी मामले में मैनुअल इसके बारे में चुप हैं और व्यवहार में सब कुछ ठीक काम करता है।

सरल iptables संरक्षण

अब आइए iptables और सर्वर सुरक्षा पर थोड़ा ध्यान दें। बदलें /etc/firewall.conf:



हम लॉन्च करते हैं:

nano /etc/firewall.conf







स्क्रिप्ट:

#!/bin/bash



#reset all

iptables -F

iptables -Z

iptables -t nat -F

iptables -t nat -Z



#iface config

INET_IFACE="eth1"

LO_IFACE="lo"

LO_IP="127.0.0.1"



#kernel modules

modprobe ip_tables

modprobe ip_conntrack

modprobe iptable_filter

modprobe iptable_mangle

modprobe iptable_nat

modprobe ipt_LOG

modprobe ipt_limit

modprobe ipt_state

modprobe ipt_MASQUERADE

modprobe ip_conntrack_ftp

modprobe ip_conntrack_irc

modprobe ip_nat_ftp

modprobe ip_nat_irc



#default policy

iptables -P INPUT DROP

iptables -P OUTPUT DROP

iptables -P FORWARD DROP



#user chains

iptables -N bad_tcp_packets

iptables -N allowed

iptables -N tcp_packets

iptables -N udp_packets

iptables -N icmp_packets

iptables -N blocksshd

blocksshd --start



###bad_tcp_packets chain

iptables -A bad_tcp_packets -p tcp --tcp-flags SYN,ACK SYN,ACK -m state --state NEW -j REJECT --reject-with tcp-reset

#iptables -A bad_tcp_packets -p tcp ! --syn -m state --state NEW -j LOG --log-prefix "New not syn:"

iptables -A bad_tcp_packets -p tcp ! --syn -m state --state NEW -j DROP



###allowed chain

iptables -A allowed -p TCP --syn -j ACCEPT

iptables -A allowed -p TCP -m state --state ESTABLISHED,RELATED -j ACCEPT

iptables -A allowed -p TCP -j DROP



###tcp_packets chain

iptables -A tcp_packets -p TCP -s 0/0 --dport 22 -j blocksshd

iptables -A tcp_packets -p TCP -s 0/0 --dport 22 -j allowed

iptables -A tcp_packets -p TCP -s 0/0 --dport 25 -j allowed

#iptables -A tcp_packets -p TCP -s 0/0 --dport 80 -j allowed



###udp_packets chain

iptables -A udp_packets -p UDP -s 0/0 --destination-port 53 -j ACCEPT



###icmp chain

iptables -A icmp_packets -p ICMP -s 0/0 --icmp-type 8 -j ACCEPT

iptables -A icmp_packets -p ICMP -s 0/0 --icmp-type 11 -j ACCEPT



###input chain

iptables -A INPUT -p TCP -j bad_tcp_packets

iptables -A INPUT -p ALL -i $LO_IFACE -j ACCEPT

iptables -A INPUT -p ALL -m state --state ESTABLISHED,RELATED -j ACCEPT

iptables -A INPUT -p TCP -i $INET_IFACE -j tcp_packets

iptables -A INPUT -p UDP -i $INET_IFACE -j udp_packets

iptables -A INPUT -p ICMP -i $INET_IFACE -j icmp_packets

#iptables -A INPUT -m limit --limit 3/minute --limit-burst 3 -j LOG --log-level DEBUG --log-prefix "IPT INPUT packet died: "



###forward chain

iptables -A FORWARD -p tcp -j bad_tcp_packets

#custom rules

#iptables -A FORWARD -s 10.128.0.10/32 -d 192.168.1.1/32 -p tcp -j ACCEPT

iptables -A FORWARD -s 10.128.0.0/16 -d 192.168.1.1/32 -p tcp -j DROP

#/custom rules

iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT

#iptables -A FORWARD -m limit --limit 3/minute --limit-burst 3 -j LOG --log-level DEBUG --log-prefix "IPT FORWARD packet died: "



###OUTPUT chain

iptables -A OUTPUT -p tcp -j bad_tcp_packets

iptables -A OUTPUT -p ALL -j ACCEPT

#iptables -A OUTPUT -m limit --limit 3/minute --limit-burst 3 -j LOG --log-level DEBUG --log-prefix "IPT OUTPUT packet died: "



###mangle

iptables -t mangle -A POSTROUTING -o $INET_IFACE -j TTL --ttl-set 64









हम यहां क्या देखते हैं? सबसे पहले, हाइलाइट किया गया नियम। यह वास्तविक कॉन्फ़िगरेशन में भिन्न होगा या बस अनावश्यक के रूप में अनुपस्थित होगा, लेकिन इसका अर्थ यह है: यदि सर्वर गेटवे ADSL मॉडेम या वेब व्यवस्थापक पैनल के साथ एक समान डिवाइस है, तो हमें वहां लॉग इन करने के लिए ट्रिकी पासवर्ड का आविष्कार करने की आवश्यकता नहीं है। इसके बजाय, हम उन्हें क्लाइंट सुरंगों से एक्सेस करने से रोकते हैं, लेकिन हम उनमें से एक को अनुमति देते हैं - यह एक सेवा खाता होगा जिसे तोड़ दिया जा सकता है। बेशक, यह ग्राहकों के लिए नहीं है। अगला। ऐसे कमांड जोड़े गए हैं जिनमें ब्रूट-बल SSH सर्वर के खिलाफ सुरक्षा शामिल है। उनके काम के लिए, आपको ब्लॉकशेड कॉन्फ़िगर करने की आवश्यकता है।

BlockSSHd

सबसे पहले आपको इसे blockshd.sourceforge.net से डाउनलोड करना होगा और फाइलों को कहीं अनज़िप करना होगा। मैंने डाउनलोड करने के लिए wget का उपयोग किया, लेकिन पथ - निश्चित रूप से - SourceForge पृष्ठ से काटा गया था, अर्थात यह सबसे अलग होगा:

cd /tmp

wget downloads.sourceforge.net/project/blocksshd/blocksshd/BlockSSHD%201.3/blocksshd-1.3.tar.gz?use_mirror=kent









यह स्क्रिप्ट पर्ल में लिखी गई है और इसे काम करने के लिए कुछ अतिरिक्त मॉड्यूल की आवश्यकता है। तो, चलिए मॉड्यूल में आते हैं:

cpan

upgrade

install Sys::Syslog

install Sys::Hostname

install File::Tail

install Tie::File

install Net::DNS

install Net::Subnets

install Getopt::Long

exit









मैं इस तथ्य पर आपका ध्यान आकर्षित करता हूं कि यह सब एक झपट्टा में गिर गया और इसे टर्मिनल में कॉपी और पेस्ट करने की आवश्यकता नहीं है। ऐसा इसलिए है क्योंकि प्रत्येक ऑपरेशन को पूरा करने के लिए बहुत समय की आवश्यकता होती है और पूरी स्थापना के दौरान, Cpan प्रश्न पूछेगा। सभी प्रश्नों के लिए, आप केवल Enter दबा सकते हैं, डिफ़ॉल्ट रूप से सब कुछ सही, विचित्र रूप से पर्याप्त है।



अब आपको ब्लॉकशेड को अनपैक करने और इसे स्थापित करने की आवश्यकता है:

cd /tmp

tar -xvzf ./blocksshd-1.3.tar.gz

cd blocksshd-1.3

make install









खैर, ज़ाहिर है, मैनुअल लिखने के समय संस्करण बिल्कुल यही था, या शायद कोई भी, इसलिए आपको सावधानीपूर्वक सब कुछ करने की आवश्यकता है और इसे कंसोल पर कॉपी नहीं करना चाहिए। यह ब्लॉकशेड कॉन्फ़िगरेशन को संपादित करने के लिए बना हुआ है:



हम लॉन्च करते हैं:

nano /etc/blocksshd.conf







config:

$cfg = {

os => 'linux', # Target OS - either linux or bsd

chain => 'blocksshd', # Name of iptables or pf chain

logfile => '/var/log/secure', # Log file to monitor

logcheck => '10', # How often to check the log file

max_attempts => '4', # Max number of failures

timeout => '360', # Reset IP count if no activity after time out in seconds

unblock => '1', # Enable unblocking

unblock_timeout => '43200', # Time in seconds after which to unblock a blocked IP address

restore_blocked => '0', # Turn on checking for previously blocked IPs

log_ips => '/etc/blocksshd.list', # Log file for blocked IPs

pid_file => '/var/run/blocksshd.pid', # Location of PID file

send_email => '0', # Enable the sending of email notifications

email => 'root', # Email address to send notifications

mail => '/bin/mail', # Location of mail binary

email_whois_lookup => '1', # enable whois lookup of the blocked ip addres in the sent email

whois => '/usr/bin/whois', # location of the whois binary

sed => '/bin/sed', # location of the sed binary

iptables => '/sbin/iptables', # Location of iptables binary - only for Linux

pfctl => '/sbin/pfctl', # Location of pfctl binary - only for BSD

whitelist => [qw{

127.0.0.1/32

}], # whitelist - list of IPs that will never be blocked - IPs must be specified in the form ad$

};



#leave 1; here!

1;









इस लिस्टिंग में, आपको हाइलाइट की गई लाइनों पर ध्यान देने की आवश्यकता है। पहला एक पते से प्रवेश करने के लिए अधिकतम प्रयास है, दूसरा यह है कि क्या तीसरी पंक्ति में निर्दिष्ट सेकंड में समय समाप्त होने के बाद आपको प्रतिबंधित आईपी को अनलॉक करने की आवश्यकता है। चौथा - हैकिंग प्रयासों के बारे में ईमेल द्वारा सूचित करना है या नहीं।

अब आप सर्वर को पुनरारंभ कर सकते हैं और परीक्षण कर सकते हैं कि क्या हुआ।

सरलतम निगरानी

सक्रिय सत्रों की निगरानी की सुविधा के लिए, आप "घुटने पर" लिखी गई स्क्रिप्ट का उपयोग कर सकते हैं। आइए इसे बनाते हैं और एक सरल लॉन्च, अच्छी तरह से, और निश्चित रूप से जांच के लिए सिमलिंक कॉन्फ़िगर करते हैं:



हम लॉन्च करते हैं:

nano /root-scripts/clients







स्क्रिप्ट:

#!/usr/bin/php

<?

function time_since($original) {

$chunks = array(

array(60 * 60 * 24 , 'D '),

array(60 * 60 , 'h:'),

array(60 , 'min'),

);

$today = time();

$since = $today - $original;

for ($i = 0, $j = count($chunks); $i < $j; $i++) {

$seconds = $chunks[$i][0];

$name = $chunks[$i][1];

if (($count = floor($since / $seconds)) != 0) {

break;

}

}

$print = "$count{$name}";

if ($i + 1 < $j) {

$seconds2 = $chunks[$i + 1][0];

$name2 = $chunks[$i + 1][1];

if (($count2 = floor(($since - ($seconds * $count)) / $seconds2)) != 0) {

$print .= "$count2{$name2}";

}

}

return $print;

}



function execShellCmdRaw($cmd) {

ob_start();

passthru($cmd);

$buffer = ob_get_contents();

ob_end_clean();

return $buffer;

}



function rawToArray($buffer) {

return empty($buffer)?array():preg_split('/[\r\n]+/', $buffer, -1, PREG_SPLIT_NO_EMPTY);

}



function execShellCmd($cmd) {

return rawToArray(execShellCmdRaw($cmd));

}



function getNATSources() {

$nat = execShellCmd('iptables -t nat -L | grep MASQUERADE');

$nats = array();

foreach ($nat as $s) {

$pos_start = strpos($s, '--') + 2;

$pos_end = strpos($s, 'anywhere');

$n = trim(substr($s, $pos_start, $pos_end - $pos_start));

$nats[$n] = $n;

}

return $nats;

}



function getTunnelMacAddr($pid) {

$pppdc = execShellCmd('ps -p '.$pid.' -f | grep pppd');

$pppdc = $pppdc[0];

$pos_start = strpos($pppdc, '-e ') + 3;

$pos_end = strpos($pppdc, '-S \'\'');

return trim(substr($pppdc, $pos_start, $pos_end - $pos_start));

}



function getPPPTunnels() {

$ifc = execShellCmd('ifconfig -a');

$tunnels = array();

$nat = getNATSources();

foreach ($ifc as $i => $s) {

if (substr($s, 0, 3) == 'ppp') {

$ppp = array();

$ppp['interface'] = substr($s, 0, 4);

$ppp['framed_ip'] = trim(substr($ifc[$i+1], strpos($ifc[$i+1], 'PtP:') + 6, 12));

$RXpos_start = strpos($ifc[$i+6], '(') + 1;

$RXpos_end = strpos($ifc[$i+6], ')');

$ppp['tx'] = substr($ifc[$i+6], $RXpos_start, $RXpos_end - $RXpos_start); //TX(user) = RX(server)

$tx_sub = substr($ifc[$i+6], $RXpos_end + 1);

$TXpos_start = strpos($tx_sub, '(') + 1;

$TXpos_end = strpos($tx_sub, ')');

$ppp['rx'] = substr($tx_sub, $TXpos_start, $TXpos_end - $TXpos_start);

$ppp['nat'] = array_key_exists($ppp['framed_ip'], $nat)?'on':'off';

$pidf = '/var/run/'.$ppp['interface'].'.pid';

if (file_exists($pidf)) {

$ppp['uptime'] = time_since(filemtime($pidf));

$ppp['pid'] = trim(file_get_contents($pidf));

$ppp['mac_addr'] = getTunnelMacAddr($ppp['pid']);

$ppp['username'] = 'detectedusername';

$tunnels[] = $ppp;

}

}

}

return $tunnels;

}



function clientTable($tunnels) {

printf("\n");

printf(" %15s | ","IP Address");

printf("%20s | ","MAC Address ");

printf("%3s | ","NAT");

printf("%16s | ","User name ");

printf("%9s | ","TX (up)");

printf("%9s | ","RX (down)");

printf("%11s","Uptime ");

printf("\n ");

for ($i = 0; $i < 101; $i++) printf("-");

printf("\n");

foreach($tunnels as $tun) {

printf(" %15s | ",$tun['framed_ip']);

printf("%20s | ",$tun['mac_addr']);

printf("%3s | ",$tun['nat']);

printf("%16s | ",$tun['username']);

printf("%9s | ",$tun['tx']);

printf("%9s | ",$tun['rx']);

printf("%11s",$tun['uptime']);

printf("\n");

}

printf("\n");

}



function addRadParams(&$tunnels = NULL) {

$radusers = rawToArray(file_get_contents('/etc/freeradius/users'));

$users = array();

foreach ($radusers as $i => $s) {

if (strpos($s, 'Cleartext-Password') !== FALSE) {

$user = array();

$user['username'] = trim(substr($s, 0, strpos($s, 'Cleartext-Password')));

$si = $i + 1;

while (strpos($radusers[$si], 'Framed-IP-Address') == FALSE) $si++;

$ip_raw = explode('=', $radusers[$si]);

$ip_raw = $ip_raw[1];

$users[trim($ip_raw, ' ,')] = $user;

}

}

foreach ($tunnels as $i => $tun) {

$tunnels[$i]['username'] = $users[$tun['framed_ip']]['username'];

}

return $tunnels;

}



$t = getPPPTunnels();

addRadParams($t);

clientTable($t);









हम लॉन्च करते हैं:

chmod +x /root-scripts/clients

ln -s /root-scripts/clients /usr/bin/clients

clients









हमें कुछ ऐसा मिलता है:



IP Address | MAC Address | NAT | User name | TX (up) | RX (down) | Uptime

-----------------------------------------------------------------------------------------------------

10.128.1.7 | 1:00:19:66:df:39:26 | on | room56 | 507.4 MiB | 445.5 MiB | 16h:31min

10.128.1.3 | 23:00:13:8f:70:30:03 | on | room47 | 8.2 MiB | 137.8 MiB | 1h:14min

10.128.1.5 | 3:00:a1:b0:11:74:cf | on | room50 | 19.2 MiB | 500.2 MiB | 16h:30min









यह सब, हमारे सर्वर का उपयोग करने के लिए तैयार है। मेरी टिप्पणियों के अनुसार, मैं कह सकता हूं कि 1 जीबी डीडीआर 1 और 2 गीगाहर्ट्ज प्रोसेसर वाला एक साधारण सिस्टम यूनिट 30 उपयोगकर्ताओं के लिए 16-मेगाबाइट चैनल वितरित करने के लिए पर्याप्त है (मुझे अब इसकी आवश्यकता नहीं है) और सिस्टम को किसी भी नोटिक लोड का अनुभव नहीं है।



प्रदाताओं को शुभकामनाएँ!