from time import monotonic
from app.utils import get_logger
logger = get_logger('Middleware.Timing')
class ResponseTimingMiddleware(object):
def __init__(self, app):
self.app = app
def __call__(self, environ, start_response):
start_time = monotonic()
response = self.app(environ, start_response)
response_time = (monotonic() - start_time) * 1000
data = {
'path': environ.get('PATH_INFO'),
'method': environ.get('REQUEST_METHOD'),
'time': int(response_time)
}
logger.info(data)
return response
from bson.objectid import ObjectId
import time
from app import services
from app.modules import ScanPortType, TaskStatus, CollectSource
from app.services import fetchCert
from app import utils
logger = utils.get_logger()
from app.config import Config
def ssl_cert(ip_info_list):
try:
targets = []
for ip_info in ip_info_list:
for port_info in ip_info["port_info"]:
if port_info["port_id"] == 80:
continue
targets.append("{}:{}".format(ip_info["ip"],
port_info["port_id"]))
f = fetchCert.SSLCert(targets)
return f.run()
except Exception as e:
logger.exception(e)
return {}
class IPTask():
def __init__(self, ip_target=None, task_id=None, options=None):
self.ip_target = ip_target
from flask_restplus import Resource, Api, reqparse, fields, Namespace
from app.utils import get_logger, auth
from . import base_query_fields, ARLResource, get_arl_parser
ns = Namespace('fileleak', description="文件泄漏信息")
logger = get_logger()
base_search_fields = {
'url': fields.String(required=False, description="URL"),
'site': fields.String(description="站点"),
'content_length': fields.Integer(description="body 长度"),
'status_code': fields.Integer(description="状态码"),
'title': fields.String(description="标题"),
"task_id": fields.String(description="任务ID")
}
base_search_fields.update(base_query_fields)
@ns.route('/')
class ARLFileLeak(ARLResource):
parser = get_arl_parser(base_search_fields, location='args')
@auth
@ns.expect(parser)
def get(self):
"""
文件泄露信息查询
"""
args = self.parser.parse_args()
from flask import Blueprint
from flask_login import current_user, login_required, login_user, logout_user
from wtforms import StringField, IntegerField
from wtforms.validators import DataRequired, Length
from app.extensions import (FlaskAPIForm, MultipleResultsFound, NoResultFound,
db, login_manager)
from app.model import RssContentModel, RssModel, User
from app.utils import response_success, parse_params_from_request, get_logger
from app.utils.errors import (ConflictExeception, NotFoundExeception,
ParameterException, UnknownExeception,
PermissionException)
from common import get_random_num, getmd5
logger = get_logger(__name__)
prefix: str = "rss"
api: Blueprint = Blueprint(prefix, __name__)
class _AddRssForm(FlaskAPIForm):
source = StringField('source', validators=[DataRequired()])
@api.post("/add/")
def add_rss_resource():
form = _AddRssForm()
if not form.validate():
raise ParameterException(message=form.errors)
rss: RssModel = RssModel.get_by_link(form.source.data)
import json
from app.event import Event
from app.responder import send_ok_response, send_response
from app.utils import get_logger
# Setup logging
logger = get_logger("app")
def return_aliens(event: Event):
return send_response(404, json.dumps({'message': 'Aliens!'}))
def run(event: Event):
route_key = event.route_key()
logger.info(route_key)
router = {
'GET /echo': handle_get_echo,
'GET /greetings': handle_get_greetings
}
return router.get(route_key, return_aliens)(event)
def handle_get_echo(event: Event):
return send_ok_response(body=json.dumps({'message': 'got echo!'}))
def handle_get_greetings(event: Event):
return send_ok_response(body=json.dumps({'message': 'good day!'}))
from app.http.controllers.base import (
BaseController,
RequestType,
invalid_return,
)
from app.http.permissions import (
admin_permission,
member_permission,
login_required,
)
from app.utils.exceptions import custom_exceptions
from app.utils import get_logger
logger = get_logger('Controller.Public.Base')
class BasePublicController(BaseController):
def __init__(self):
super(BasePublicController, self).__init__()
self.user = current_user
def _route(self, request_type, action, **kwargs):
if action is not None and action.startswith('_'):
abort(403)
if action is None:
action = 'index'
if request_type == RequestType.GET:
block, meaning that a subscriber is created with a given set of
subscriptions, which cannot later be altered. If wished for, this can be
easily changed, since the db schema allows to do so.
"""
import datetime
from typing import List, Optional
from sqlalchemy.orm import noload
from app import models
from app import utils as app_utils
from app.connections import db
from app.core.notifications import webhooks
logger = app_utils.get_logger()
def get_subscribable_events() -> List[dict]:
event_types = models.EventType.query.all()
res = []
for event_type in event_types:
name = event_type.name
optional_filters = []
if name.startswith("project:"):
optional_filters.append(["project_uuid"])
if name.startswith("project:cron-job:") or name.startswith(
"project:one-off-job:"
):
optional_filters.append(["project_uuid", "job_uuid"])
from app.http.controllers.base import (
BaseController,
RequestType,
invalid_return,
)
from app.http.permissions import (
admin_permission,
member_permission,
login_required,
)
from app.utils.exceptions import custom_exceptions
from app.utils import get_logger
logger = get_logger('Controller.Public.Base')
class BasePublicController(BaseController):
def __init__(self):
super(BasePublicController, self).__init__()
self.user = current_user
def _route(self, request_type, action, **kwargs):
if action is not None and action.startswith('_'):
abort(403)
if action is None:
action = 'index'
if request_type == RequestType.GET:
