2022-07-29 22:07:08 +00:00
|
|
|
import time
|
2023-06-29 15:56:16 +00:00
|
|
|
import secrets
|
|
|
|
import user_agents
|
2023-07-07 21:50:26 +00:00
|
|
|
import uuid
|
2022-11-15 09:19:08 +00:00
|
|
|
from flask import g, request, session
|
|
|
|
|
|
|
|
from files.classes.clients import ClientAuth
|
|
|
|
from files.helpers.alerts import *
|
2022-12-11 23:44:34 +00:00
|
|
|
from files.helpers.config.const import *
|
2022-11-15 09:19:08 +00:00
|
|
|
from files.helpers.get import get_account
|
2022-11-30 18:09:31 +00:00
|
|
|
from files.helpers.logging import log_file
|
2023-06-29 16:14:24 +00:00
|
|
|
from files.helpers.settings import *
|
|
|
|
from files.helpers.cloudflare import *
|
2022-11-15 09:19:08 +00:00
|
|
|
from files.routes.routehelpers import validate_formkey
|
2023-03-16 06:27:58 +00:00
|
|
|
from files.__main__ import app, db_session, limiter
|
2022-10-15 07:31:24 +00:00
|
|
|
|
2023-02-26 08:49:09 +00:00
|
|
|
def rpath(n):
|
2023-02-26 01:42:39 +00:00
|
|
|
return request.path
|
|
|
|
|
2023-01-21 04:39:46 +00:00
|
|
|
def get_ID():
|
|
|
|
if request.headers.get("Authorization"):
|
|
|
|
x = request.headers.get("Authorization")
|
|
|
|
elif session.get("lo_user"):
|
|
|
|
x = session.get("lo_user")
|
|
|
|
else:
|
|
|
|
x = "logged_out"
|
2023-02-22 17:27:33 +00:00
|
|
|
|
2023-01-21 04:39:46 +00:00
|
|
|
return f'{SITE}-{x}'
|
|
|
|
|
2023-06-29 15:56:16 +00:00
|
|
|
def calc_users():
|
|
|
|
g.loggedin_counter = 0
|
|
|
|
g.loggedout_counter = 0
|
|
|
|
g.loggedin_chat = 0
|
|
|
|
v = getattr(g, 'v', None) if g else None
|
2023-07-14 09:20:33 +00:00
|
|
|
if has_request_context and g and g.desires_auth and not g.is_api_or_xhr:
|
|
|
|
loggedin = cache.get(LOGGED_IN_CACHE_KEY) or {}
|
|
|
|
loggedout = cache.get(LOGGED_OUT_CACHE_KEY) or {}
|
|
|
|
g.loggedin_chat = cache.get(CHAT_ONLINE_CACHE_KEY) or 0
|
|
|
|
timestamp = int(time.time())
|
2023-06-29 15:56:16 +00:00
|
|
|
|
2023-07-14 09:20:33 +00:00
|
|
|
if not session.get("session_id"):
|
|
|
|
session.permanent = True
|
|
|
|
session["session_id"] = str(uuid.uuid4())
|
2023-06-29 15:56:16 +00:00
|
|
|
|
2023-07-14 09:20:33 +00:00
|
|
|
if v:
|
|
|
|
if session["session_id"] in loggedout: del loggedout[session["session_id"]]
|
|
|
|
loggedin[v.id] = timestamp
|
|
|
|
else:
|
|
|
|
ua = str(user_agents.parse(g.agent))
|
|
|
|
if 'spider' not in ua.lower() and 'bot' not in ua.lower():
|
|
|
|
loggedout[session["session_id"]] = (timestamp, ua)
|
2023-06-29 15:56:16 +00:00
|
|
|
|
2023-07-14 09:20:33 +00:00
|
|
|
loggedin = {k: v for k, v in loggedin.items() if (timestamp - v) < LOGGEDIN_ACTIVE_TIME}
|
|
|
|
loggedout = {k: v for k, v in loggedout.items() if (timestamp - v[0]) < LOGGEDIN_ACTIVE_TIME}
|
|
|
|
cache.set(LOGGED_IN_CACHE_KEY, loggedin)
|
|
|
|
cache.set(LOGGED_OUT_CACHE_KEY, loggedout)
|
|
|
|
g.loggedin_counter = len(loggedin)
|
|
|
|
g.loggedout_counter = len(loggedout)
|
2023-06-29 15:56:16 +00:00
|
|
|
|
2023-07-14 09:20:33 +00:00
|
|
|
if g.loggedout_counter > 3000:
|
|
|
|
if not get_setting('ddos_detected'):
|
|
|
|
toggle_setting('ddos_detected')
|
|
|
|
set_security_level('under_attack')
|
|
|
|
else:
|
|
|
|
if get_setting('ddos_detected'):
|
|
|
|
toggle_setting('ddos_detected')
|
|
|
|
set_security_level('high')
|
2023-07-07 20:46:49 +00:00
|
|
|
return ''
|
2023-06-29 15:56:16 +00:00
|
|
|
|
2022-05-04 23:09:46 +00:00
|
|
|
def get_logged_in_user():
|
2023-03-11 09:56:32 +00:00
|
|
|
if hasattr(g, 'v') and g.v: return g.v
|
2023-03-16 06:27:58 +00:00
|
|
|
if not hasattr(g, 'db'): g.db = db_session()
|
2022-11-09 05:35:24 +00:00
|
|
|
g.desires_auth = True
|
2022-05-04 23:09:46 +00:00
|
|
|
v = None
|
|
|
|
token = request.headers.get("Authorization","").strip()
|
|
|
|
if token:
|
2023-03-16 06:27:58 +00:00
|
|
|
client = g.db.query(ClientAuth).filter(ClientAuth.access_token == token).one_or_none()
|
2023-01-01 11:36:20 +00:00
|
|
|
if client:
|
2022-05-04 23:09:46 +00:00
|
|
|
v = client.user
|
|
|
|
v.client = client
|
|
|
|
else:
|
|
|
|
lo_user = session.get("lo_user")
|
|
|
|
if lo_user:
|
|
|
|
id = int(lo_user)
|
2022-09-05 20:37:38 +00:00
|
|
|
v = get_account(id, graceful=True)
|
2022-11-28 01:48:53 +00:00
|
|
|
if v:
|
2022-11-28 19:41:08 +00:00
|
|
|
v.client = None
|
2022-05-04 23:09:46 +00:00
|
|
|
nonce = session.get("login_nonce", 0)
|
2022-10-29 01:07:39 +00:00
|
|
|
if nonce < v.login_nonce or v.id != id:
|
2022-11-27 16:59:36 +00:00
|
|
|
session.pop("lo_user")
|
|
|
|
v = None
|
2022-05-04 23:09:46 +00:00
|
|
|
|
2022-11-27 16:59:36 +00:00
|
|
|
if v and request.method != "GET":
|
2022-11-27 01:01:02 +00:00
|
|
|
submitted_key = request.values.get("formkey")
|
2022-11-28 19:41:08 +00:00
|
|
|
if not validate_formkey(v, submitted_key):
|
|
|
|
v = None
|
2022-11-28 01:48:53 +00:00
|
|
|
else:
|
|
|
|
session.pop("lo_user")
|
|
|
|
|
2022-11-30 18:26:07 +00:00
|
|
|
if request.method.lower() != "get" and get_setting('read_only_mode') and not (v and v.admin_level >= PERMS['SITE_BYPASS_READ_ONLY_MODE']):
|
2023-03-25 21:35:13 +00:00
|
|
|
abort(403, "Site is in read-only mode right now. It will be back shortly!")
|
|
|
|
|
|
|
|
if get_setting('offline_mode') and not (v and v.admin_level >= PERMS['SITE_OFFLINE_MODE']):
|
|
|
|
abort(403, "Site is in offline mode right now. It will be back shortly!")
|
2022-05-04 23:09:46 +00:00
|
|
|
|
2022-05-26 00:54:05 +00:00
|
|
|
g.v = v
|
2022-05-25 18:59:24 +00:00
|
|
|
|
2022-10-15 10:08:14 +00:00
|
|
|
if v:
|
2023-06-27 12:01:40 +00:00
|
|
|
v.poor = session.get('poor')
|
2022-10-15 10:08:14 +00:00
|
|
|
# Check against last_active + ACTIVE_TIME to reduce frequency of
|
|
|
|
# UPDATEs in exchange for a ±ACTIVE_TIME margin of error.
|
2023-03-09 23:43:52 +00:00
|
|
|
|
|
|
|
if not session.get("GLOBAL"):
|
|
|
|
timestamp = int(time.time())
|
|
|
|
if (v.last_active + LOGGEDIN_ACTIVE_TIME) < timestamp:
|
|
|
|
v.last_active = timestamp
|
2023-03-16 06:27:58 +00:00
|
|
|
g.db.add(v)
|
2023-07-18 13:02:31 +00:00
|
|
|
try: g.db.flush()
|
|
|
|
except: g.db.rollback()
|
2022-06-27 03:46:32 +00:00
|
|
|
|
2023-06-01 13:05:07 +00:00
|
|
|
if not v and SITE == 'rdrama.net' and request.headers.get("Cf-Ipcountry") == 'EG':
|
|
|
|
abort(404)
|
|
|
|
|
2022-12-27 03:00:15 +00:00
|
|
|
g.is_api_or_xhr = bool((v and v.client) or request.headers.get("xhr"))
|
|
|
|
|
2022-05-04 23:09:46 +00:00
|
|
|
return v
|
|
|
|
|
|
|
|
def auth_desired(f):
|
|
|
|
def wrapper(*args, **kwargs):
|
2022-10-11 13:19:55 +00:00
|
|
|
v = get_logged_in_user()
|
2022-05-04 23:09:46 +00:00
|
|
|
return make_response(f(*args, v=v, **kwargs))
|
|
|
|
wrapper.__name__ = f.__name__
|
|
|
|
return wrapper
|
|
|
|
|
2022-08-05 20:40:48 +00:00
|
|
|
def auth_desired_with_logingate(f):
|
|
|
|
def wrapper(*args, **kwargs):
|
2022-10-11 13:19:55 +00:00
|
|
|
v = get_logged_in_user()
|
2023-04-08 22:38:26 +00:00
|
|
|
if not v and (get_setting('login_required') or get_setting('ddos_detected')):
|
|
|
|
abort(401)
|
2022-05-04 23:09:46 +00:00
|
|
|
|
2022-11-09 05:35:24 +00:00
|
|
|
if request.path.startswith('/logged_out'):
|
2022-09-20 00:51:01 +00:00
|
|
|
redir = request.full_path.replace('/logged_out','')
|
|
|
|
if not redir: redir = '/'
|
|
|
|
return redirect(redir)
|
|
|
|
|
2022-08-05 20:40:48 +00:00
|
|
|
return make_response(f(*args, v=v, **kwargs))
|
|
|
|
wrapper.__name__ = f.__name__
|
|
|
|
return wrapper
|
|
|
|
|
|
|
|
def auth_required(f):
|
2022-05-04 23:09:46 +00:00
|
|
|
def wrapper(*args, **kwargs):
|
2022-10-11 13:19:55 +00:00
|
|
|
v = get_logged_in_user()
|
2022-05-04 23:09:46 +00:00
|
|
|
if not v: abort(401)
|
|
|
|
return make_response(f(*args, v=v, **kwargs))
|
|
|
|
wrapper.__name__ = f.__name__
|
|
|
|
return wrapper
|
|
|
|
|
2023-07-22 14:40:23 +00:00
|
|
|
def is_not_banned(f):
|
|
|
|
def wrapper(*args, **kwargs):
|
|
|
|
v = get_logged_in_user()
|
|
|
|
if not v: abort(401)
|
|
|
|
if v.is_suspended: abort(403, "You can't perform this action while banned!")
|
|
|
|
return make_response(f(*args, v=v, **kwargs))
|
|
|
|
wrapper.__name__ = f.__name__
|
|
|
|
return wrapper
|
|
|
|
|
2022-05-04 23:09:46 +00:00
|
|
|
def is_not_permabanned(f):
|
|
|
|
def wrapper(*args, **kwargs):
|
2022-10-11 13:19:55 +00:00
|
|
|
v = get_logged_in_user()
|
2022-05-04 23:09:46 +00:00
|
|
|
if not v: abort(401)
|
2023-07-22 14:40:23 +00:00
|
|
|
if v.is_permabanned: abort(403, "You can't perform this action while permabanned!")
|
2022-05-04 23:09:46 +00:00
|
|
|
return make_response(f(*args, v=v, **kwargs))
|
|
|
|
wrapper.__name__ = f.__name__
|
|
|
|
return wrapper
|
|
|
|
|
|
|
|
def admin_level_required(x):
|
|
|
|
def wrapper_maker(f):
|
|
|
|
def wrapper(*args, **kwargs):
|
2022-10-11 13:19:55 +00:00
|
|
|
v = get_logged_in_user()
|
2022-05-04 23:09:46 +00:00
|
|
|
if not v: abort(401)
|
2022-12-25 20:13:29 +00:00
|
|
|
if v.admin_level < x: abort(403)
|
2022-12-27 01:54:19 +00:00
|
|
|
if x and SITE != 'devrama.net' and not IS_LOCALHOST and not v.mfa_secret:
|
2023-03-16 15:17:53 +00:00
|
|
|
abort(403, "You need to enable two-factor authentication to use admin features!")
|
2022-10-11 13:43:57 +00:00
|
|
|
return make_response(f(*args, v=v, **kwargs))
|
2022-05-04 23:09:46 +00:00
|
|
|
|
|
|
|
wrapper.__name__ = f.__name__
|
|
|
|
return wrapper
|
2022-05-30 01:43:16 +00:00
|
|
|
return wrapper_maker
|
|
|
|
|
2022-10-11 07:17:54 +00:00
|
|
|
def feature_required(x):
|
|
|
|
def wrapper_maker(f):
|
|
|
|
def wrapper(*args, **kwargs):
|
|
|
|
if not FEATURES[x]: abort(404)
|
2022-10-11 13:19:55 +00:00
|
|
|
return make_response(f(*args, **kwargs))
|
2022-10-11 07:17:54 +00:00
|
|
|
wrapper.__name__ = f.__name__
|
|
|
|
return wrapper
|
2022-10-11 07:29:24 +00:00
|
|
|
return wrapper_maker
|