Nginx में LUA: थोड़ा बुद्धिमान फ़ायरवॉल

यह पोस्ट नगनेक्स में लुआ के उपयोग की निरंतरता है ।

उन्होंने स्मृति में कैशिंग पर चर्चा की, और यहाँ नुआनेक्स-बैलेन्सर पर एक प्रकार के फ़ायरवॉल के रूप में आने वाले अनुरोधों को फ़िल्टर करने के लिए लुआ का उपयोग किया जाएगा। 2GIS में भी कुछ ऐसा ही था । हमारे पास अपनी बाइक है :) जिसमें हम गतिशीलता और स्टैटिक्स साझा करते हैं, हम NAT और सफेद सूची को ध्यान में रखने की कोशिश करते हैं। और, ज़ाहिर है, आप हमेशा कुछ और विशिष्ट तर्क प्राप्त कर सकते हैं जो तैयार किए गए मॉड्यूल का उपयोग करते समय काम नहीं करेंगे।
यह योजना अब चुपचाप और अनायास (व्यावहारिक रूप से सीपीयू के उपयोग को प्रभावित नहीं करती है), यह लगभग 1200 अनुरोधों / सेकंड की प्रक्रिया करती है। सीमा मानों का परीक्षण नहीं किया गया था। शायद, सौभाग्य से :)


मैं रसीद पर तुरंत आने वाले सभी अनुरोधों को संसाधित करना चाहता हूं, और एक्सेस_लॉग में एक पंक्ति के तथ्य पर नहीं (जो अभी भी उसी स्टैटिक्स के लिए बंद माना जाता है)। कोई सवाल नहीं, हम पूरे http के लिए विश्व स्तर पर हैंडलर को लटकाते हैं:

http { include lua/req.conf; } #  lua/req.conf #      ( ,      LRU ) lua_shared_dict req_limit 1024m; #      (   ,    ) lua_shared_dict ban_list 128m; #  .   ,     geo $lua_req_whitelist { default 0; 12.34.56.78/24 1; } #  init_by_lua ' --      lua_req_priv_key = "secretpassphrase" --    lua_req_cookie_name = "reqcookiename" --      lua_req_ban_log = "/path/to/log/file" --     ( ) --     lua_req_d_one = 42 --    URI lua_req_d_mul = 84 --    URI lua_req_s_one = 100 --    URI lua_req_s_mul = 200 --    URI lua_req_d_ip = 200 --    IP lua_req_s_ip = 400 --    IP --   10  lua_req_ban_ttl = 600 --  math.randomseed(math.floor(ngx.now()*1000)) '; #   ,   access    access_by_lua_file /path/to/nginx/lua/req.lua; 

अब nginx पर आने वाले सभी अनुरोध हमारे req.lua स्क्रिप्ट के माध्यम से जाएंगे।
इसी समय, हमारे पास अनुरोधों के इतिहास और पहले से प्रतिबंधित की गई सूची (नीचे अधिक विवरण) की सूची को संग्रहीत करने के लिए दो टेबल req_limit और ban_list हैं।
और आईपी पर श्वेतसूची को लागू करने के लिए, साइकिल के बजाय, जियो नगनेक्स मॉड्यूल का उपयोग किया गया था, जिसमें lua_req_whitelist चर का मूल्य नीचे रखा गया है, जिसका उपयोग कुछ इस तरह किया जाता है:

 if ngx.var.lua_req_whitelist ~= '1' then -- IP    ,   end 

स्टेटिक्स / डायनामिक्स (डिस्क / बैकएंड सर्वर पर फ़ाइल के लिए अनुरोध) की जांच करने के लिए, हम अनुरोधित फ़ाइल के नाम पर एक साधारण जांच करते हैं (यहां आप अपने व्यावसायिक तर्क को स्वीकार करके कार्यान्वयन को जटिल बना सकते हैं):

 function string.endswith(haystack, needle) return (needle == '') or (needle == string.sub(haystack, -string.len(needle))) end local function path_is_static(path) local exts = {'js', 'css', 'png', 'jpg', 'jpeg', 'gif', 'xml', 'ico', 'swf'} path = path:lower() for _,ext in ipairs(exts) do if path:endswith(ext) then return true end end return false end local uri_path = ngx.var.request_uri if ngx.var.is_args == '?' then uri_path = uri_path:gsub('^([^?]+)\\?.*$', '%1') end local is_static = path_is_static(uri_path) 

कम से कम कुछ NAT प्रोसेसिंग के लिए, IP क्लाइंट के अलावा, उनके UserAgent को भी ध्यान में रखा जाता है और एक विशेष कुकी जोड़ी जाती है। एक पूरे के रूप में सभी तीन तत्व उपयोगकर्ता आईडी बनाते हैं। यदि कुछ खलनायक सर्वर को खोखला कर देते हैं, संचारित कुकी की अनदेखी करते हैं, तो सबसे खराब स्थिति में, इसके आईपी / सबनेट पर प्रतिबंध लगा दिया जाएगा। इसी समय, इस सबनेट से उन उपयोगकर्ताओं को जो पहले से ही कुकी प्राप्त कर चुके हैं, चुपचाप आगे काम करेंगे (आईपी पर प्रतिबंध के मामले को छोड़कर)। समाधान सही नहीं है, लेकिन अभी भी आधे देश / मोबाइल ऑपरेटर को एक उपयोगकर्ता के रूप में गिनने से बेहतर है।
कुकीज़ का सृजन और सत्यापन:

 local function gen_cookie_rand() return tostring(math.random(2147483647)) end local function gen_cookie(prefix, rnd) return ngx.encode_base64( --       IP    UserAgent,     ngx.sha1_bin(ngx.today() .. prefix .. lua_req_priv_key .. rnd) ) end local uri = ngx.var.request_uri --  URI local host = ngx.var.http_host --      (   nginx   ) local ip = ngx.var.remote_addr local user_agent = ngx.var.http_user_agent or '' if user_agent:len() > 0 then user_agent = ngx.encode_base64(ngx.sha1_bin(user_agent)) end local key_prefix = ip .. ':' .. user_agent --    local user_cookie = ngx.unescape_uri(ngx.var['cookie_' .. lua_req_cookie_name]) or '' local rnd = gen_cookie_rand() local p = user_cookie:find('_') if p then rnd = user_cookie:sub(p+1) user_cookie = user_cookie:sub(1, p-1) end local control_cookie = gen_cookie(key_prefix, rnd) if user_cookie ~= control_cookie then user_cookie = '' rnd = gen_cookie_rand() control_cookie = gen_cookie(key_prefix, rnd) end key_prefix = key_prefix .. ':' .. user_cookie ngx.header['Set-Cookie'] = string.format('%s=%s; path=/; expires=%s', lua_req_cookie_name, ngx.escape_uri(control_cookie .. '_' .. rnd), ngx.cookie_time(ngx.time()+24*3600) ) 

अब key_prefix में क्लाइंट का पहचानकर्ता होता है जिसका अनुरोध हम प्रोसेस कर रहे हैं। यदि इस ग्राहक पर पहले से ही प्रतिबंध है, तो आगे की प्रक्रिया की आवश्यकता नहीं है:

 local ban_key = key_prefix..':ban' if ban_list:get(ban_key) or ban_list:get(ip..':ban') then --          IP return ngx.exit(ngx.HTTP_FORBIDDEN) end 

हमें कुंजी मिली, हमने प्रतिबंध की जांच की, अब हम यह गणना कर सकते हैं कि क्या यह अनुरोध सीमा से अधिक नहीं है:

 --   :   URI    URI local limits = { [false] = { [false] = lua_req_d_mul, --    URI [true] = lua_req_d_one, --    URI }, [true] = { [false] = lua_req_s_mul, --    URI [true] = lua_req_s_one, --    URI } } for _,one_path in ipairs({true, false}) do local limit = limits[is_static][one_path] local key = {key_prefix} --        if is_static then table.insert(key, 'S') else table.insert(key, 'D') end --          (  API   ) if one_path then table.insert(key, host..uri) end --    "12.34.56.78:useragentsha1base64:cookiesha1base64:S:site.com/path/to/file" key = table.concat(key, ':') local exhaust = check_limit_exhaust(key, limit, ban_ttl) if exhaust then return ngx.exit(ngx.HTTP_FORBIDDEN) end end 

हम काउंटरों के 4 संस्करणों की जांच करते हैं: स्थिर / गतिशीलता, एक पथ / अलग। सीधी जाँच check_limit_exerate () में की जाती है:

 local function check_limit_exhaust(key, limit, cnt_ttl) local key_ts = key..':ts' local cnt, _ = req_limit:incr(key, 1) --   ,     --        if cnt == nil then if req_limit:add(key, 1, cnt_ttl) then req_limit:set(key_ts, ngx.now(), cnt_ttl) end return false end --     (    ) if cnt <= limit then return false end --     (  ), --              local key_lock = key..':lock' local key_lock_ttl = 0.5 local ts local try_until = ngx.now() + key_lock_ttl local locked while true do locked = req_limit:add(key_lock, 1, key_lock_ttl) cnt = req_limit:get(key) ts = req_limit:get(key_ts) if locked or (try_until < ngx.now()) then break end ngx.sleep(0.01) end --            - , ,  . --      IP  blacklist --       if (not locked) and ((not cnt) or (not ts)) then return true, 'lock_failed' end --    ( )   local ts_diff = math.max(0.001, ngx.now() - ts) --      local cnt_norm = math.floor(cnt / ts_diff) --        if cnt_norm <= limit then --  ts  cnt (    set'  -        ) req_limit:set(key, cnt_norm, cnt_ttl) req_limit:set(key_ts, ngx.now() - 1, cnt_ttl) --  ;  blacklist  ;    if locked then req_limit:delete(key_lock) end return false end --  . ,  ,    req_limit:delete(key) req_limit:delete(key_ts) if locked then req_limit:delete(key_lock) end return true, cnt_norm end 

Lua_req_ban_ttl सेकंड के लिए सीधे प्रतिबंध के अलावा, आप स्थायी भंडारण को लागू कर सकते हैं, और एक ही समय में IP द्वारा iptables / analogues पर लॉगिंग और अग्रेषण को प्रतिबंधित कर सकते हैं। यह पहले से ही विषय है।

यह सब, ज़ाहिर है, केवल एक उदाहरण है, न कि एक चांदी की कॉपी-पेस्ट बुलेट। इसके अलावा, सीमा की दी गई संख्या छत से इंगित की जाती है।

हेडर में छवि यहां से ली गई है ।