def map_local_file(self, flow):
_host = flow.request.host
if _host in self.local_rule:
(rule, pathname) = self.local_rule[_host], flow.request.path.split("?")[0]
for match in rule:
if match in pathname:
local_file = rule[match] + pathname.replace('/', sep).replace(match, '', 1).lstrip(sep)
#process hash filename like my_program_xxxxxx.js to local_file my_program_.js'
striped_file = re.sub(r'[a-f0-9]{6}\.(js|css|jpg|png|jpeg|gif)$', r'.\1', local_file)
if path.isfile(local_file) or path.isfile(striped_file):
if path.exists(striped_file): local_file = striped_file
content_type = mimetypes.guess_type(local_file)[0]
if content_type is None: break
body = str(open(local_file).read()).encode('utf-8')
header = self.custom_header(_host, content_type, len(body))
_response = HTTPResponse(b"HTTP/1.1", 200, "local", header, body, is_replay=True)
flow.response = _response
self.log("\n%s\n%s\nReplied with Local File:\n%s\n%s\n%s\n" % (flow.request.path, '='*80, '-'*80, local_file, "-"*80))
break
elif _host == 'config.qq.com':
header = self.custom_header(_host, 'text/html', 0)
flow.response = HTTPResponse(b"HTTP/1.1", 404, "not found", header, '', is_replay=True)
self.log("\n%s\n%s\nReplied with empty file%s\n" % (flow.request.path, '=' * 80, '-' * 80))
break
elif DEFAULT_PROXY is not None:
self.proxy_request_to_upstream(flow, DEFAULT_PROXY)
def request(self, flow):
try:
flow.response = self.create_response(flow.request)
except ConnectionError:
# If TCP Rst Configured
if self.on_rst:
self.logger.debug("Got TCP Rst, While TCP Rst Configured")
self.multitor.new_identity()
# Set Response
try:
flow.response = self.create_response(flow.request)
except Exception as error:
self.logger.error(
"Got Unknown Error (after second TCP Rst) %s" % error)
flow.response = HTTPResponse.make(
400, "Unknown Error (after second TCP Rst) %s" % error)
return
else:
self.logger.error("Got TCP Rst, While TCP Rst Not Configured")
flow.response = HTTPResponse.make(400, "Got TCP Rst")
return
except Exception as error:
self.logger.error("Got Unknown Error %s" % error)
flow.response = HTTPResponse.make(400, "Unknown Error %s" % error)
return
# If String Found In Response Content
if self.on_string and self.on_string in flow.response.text:
self.logger.debug("String Found In Response Content")
self.multitor.new_identity()
# Set Response
flow.response = self.create_response(flow.request)
# If Regex Found In Response Content
if self.on_regex and re.search(self.on_regex, flow.response.text,
re.IGNORECASE):
self.logger.debug("Regex Found In Response Content")
self.multitor.new_identity()
# Set Response
flow.response = self.create_response(flow.request)
# If Counter Raised To The Configured Number
if self.on_count and next(self.counter) >= self.on_count:
self.logger.debug("Counter Raised To The Configured Number")
self.counter = itertools.count(1)
self.multitor.new_identity()
# If A Specific Status Code Returned
if self.on_error_code and self.on_error_code == flow.response.status_code:
self.logger.debug("Specific Status Code Returned")
self.multitor.new_identity()
# Set Response
flow.response = self.create_response(flow.request)
def request(flow):
if LOG_LEVEL is None:
start()
_changeHeader(flow.request.headers, 'Proxy-Connection')
_changeHeader(flow.request.headers, 'X-Requested-With')
flow.remote_server = True
flow.own_response = False
if '127.0.0.1' in flow.request.pretty_host:
urls = flow.request.url.split('/')
flow.request.url = '/'.join(urls[:2] + urls[3:])
flow.remote_server = False
host = flow.request.pretty_host
if host.endswith('.ssl'):
flow.request.scheme = 'https'
flow.request.port = 443
flow.request.url = flow.request.url.replace('.ssl/', '/', 1)
if flow.request.scheme != 'https' and FORCE_HTTPS:
flow.request.scheme = 'https'
newUrl = _sanitizeLocation(flow.request.url)
flow.response = HTTPResponse.make(301, '', {'Location': newUrl})
flow.own_response = True
return
if flow.remote_server and PDF_PORT and flow.request.url.endswith('.pdf'):
parts = _sanitizeLocation(flow.request.url).split('/')
flow.request.port = int(PDF_PORT)
newUrl = '/'.join(parts[:2] + ['127.0.0.1:' + PDF_PORT] + parts[2:])
flow.response = HTTPResponse.make(302, '', {'Location': newUrl})
flow.own_response = True
return
_changeHeader(flow.request.headers, 'Referer', '.ssl')
_changeHeader(flow.request.headers, 'Origin', '.ssl')
_changeHeader(flow.request.headers, 'User-Agent', TOR_UA)
_changeHeader(
flow.request.headers, 'Accept',
'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8')
_changeHeader(flow.request.headers, 'Accept-Language', 'en-US,en;q=0.5')
uirh = 'Upgrade-Insecure-Requests'
if not _iGet(flow.request.headers, uirh, None):
flow.request.headers[uirh] = '1'
newReqData = re.sub(b'http%3A%2F%2F' + dnsRegExp + b'.ssl',
b'https%3A%2F%2F' + b'\\1',
flow.request.content,
flags=re.IGNORECASE)
# Touch content only if needed:
if newReqData != flow.request.content:
if LOG_LEVEL > 0:
print('newReqData !=;', flow.request.url)
flow.request.content = newReqData
if LOG_LEVEL > 0:
print('requestH(' + flow.request.url + ')', flow.request.headers)
if LOG_LEVEL > 1:
print('requestC(' + flow.request.url + ')', flow.request.content)
def request(self, flow):
if (flow.request.pretty_host == prettyHost
and flow.request.method == reqMethod):
if (flow.request.pretty_url == prettyURL):
if self.process != None:
self.process.terminate()
flow.request.decode()
uForm = json.loads(flow.request.content)
quizMatch = self.regex.match(flow.request.headers['referer'])
quiz = quizMatch.group(1)
runDir = os.path.dirname(os.path.abspath(__file__))
runExec = os.path.join(runDir, 'MentiMemer')
ctx.log.info("Calling \'" + runExec + "\'")
self.process = Popen([
runExec, quiz, uForm['question'], uForm['question_type'],
json.dumps(uForm['vote'], ensure_ascii=False)
],
cwd=runDir)
elif (flow.request.pretty_host == stopHost):
if self.process != None:
self.process.terminate()
self.process = None
flow.response = HTTPResponse(
"HTTP/1.1", 200, "OK", Headers(Content_Type="text/html"),
b'<!DOCTYPE html><html><body><big style=\"font-size: 5em\">Stopped auto-send</big></body></html>'
)
def replaceImage(flow):
attrs = dict((x.lower(), y) for x, y in flow.response.headers.items())
if "content-type" in attrs:
if "image" in attrs[
'content-type'] and not "svg" in attrs['content-type']:
if flow.response.status_code == 304:
content = flow.response.content
else:
content = requests.get(flow.request.url).content
if len(content) == 0:
return flow
try:
img = Image.open(io.BytesIO(content))
size = img.size
if size[0] > 40 and size[1] > 40:
filename = random.choice(os.listdir("images"))
img = resizeImg("images/" + filename, size[0], size[1])
#content = img.make_blob()
imgByteArr = io.BytesIO()
img.save(imgByteArr, format='JPEG')
content = imgByteArr.getvalue()
responseHeaders = {'Content-Length': str(len(content))}
responseHeaders['Content-Type'] = "image/jpg"
#import pdb;pdb.set_trace()
resp = HTTPResponse.make(status_code=200,
headers=responseHeaders,
content=content)
flow.response = resp
except:
PrintException()
return flow
def replaceImage(flow):
attrs = dict((x.lower(), y) for x, y in flow.response.headers.items())
if "content-type" in attrs:
if "image" in attrs['content-type'] and not "svg" in attrs['content-type']:
if flow.response.status_code == 304:
content = flow.response.content
else:
content = requests.get(flow.request.url).content
if len(content) == 0:
return flow
try:
img = Image.open(io.BytesIO(content))
size = img.size
if size[0] > 40 and size[1] > 40:
filename = random.choice(os.listdir("images"))
img = resizeImg("images/" + filename, size[0], size[1])
#content = img.make_blob()
imgByteArr = io.BytesIO()
img.save(imgByteArr, format='BMP')
content = imgByteArr.getvalue()
responseHeaders = {'Content-Length':str(len(content))}
responseHeaders['Content-Type'] = "image/bmp"
#import pdb;pdb.set_trace()
resp = HTTPResponse.make(status_code=200, headers=responseHeaders, content=content)
flow.response = resp
except:
PrintException()
return flow
def request(self, flow: HTTPFlow):
if flow.request.host in self.ServersList and flow.request.path.startswith(
"/charBuild/setDefaultSkill"):
self.info("Receive default skill change change request")
req = json.loads(flow.request.get_text())
self.tBuilder.chars[str(
req["charInstId"]
)]["defaultSkillIndex"] = req["defaultSkillIndex"]
resp = {
"playerDataDelta": {
"deleted": {},
"modified": {
"troop": {
"chars": {
str(req["charInstId"]): {
"defaultSkillIndex":
req["defaultSkillIndex"]
}
}
}
}
}
}
self.info("make response")
flow.response = HTTPResponse.make(
200, json.dumps(resp),
{"Content-Type": "application/json; charset=utf-8"})
self.info("Reply Complete")
def request(self, flow: HTTPFlow):
"""
{
"charInstId": 9,
"skinId": "char_123_fang#1"
}
"""
if self.inServersList(
flow.request.host) and flow.request.path.startswith(
"/charBuild/changeCharSkin"):
self.info("Receive skin change request")
req = json.loads(flow.request.get_text())
resp = {
"playerDataDelta": {
"deleted": {},
"modified": {
"troop": {
"chars": {
str(req["charInstId"]): {
"skin": req["skinId"]
}
}
}
}
}
}
self.info("make response")
self.tBuilder.chars[str(req["charInstId"])]["skin"] = req["skinId"]
flow.response = HTTPResponse.make(
200, json.dumps(resp),
{"Content-Type": "application/json; charset=utf-8"})
self.info("Reply Complete")
def request(context, flow):
rewrite = False
mockresp = open("mock/success.json", "r").read()
flow.request.oldpath = flow.request.path
# if flow.request.path.endswith("/api/2/account/api/"):
# flow.request.path = "/api/2/account/myapitest"
if flow.request.path.startswith(
"/api/2/account/my/profile/plan/circlesswitch/upgrade/"):
rewrite = True
if flow.request.path.startswith(
"/api/2/account/my/profile/id/digits/verify/get/"):
mockresp = open("mock/my_profile_id_digits_verify_get.json",
"r").read()
rewrite = True
if flow.request.path.startswith(
"/api/2/account/my/portin/request/cancel/"):
rewrite = True
print("\nRequest : " + str(flow.request.oldpath) + "\n")
# print("Request Rewrite : " + str(flow.request.path)+"\n")
print("\nRequest Body : " + str(flow.request.content) + "\n")
if rewrite:
time.sleep(0.3)
resp = HTTPResponse(
"HTTP/1.1", 200, "OK",
Headers(Content_Type="application/json; charset=utf-8"), mockresp)
flow.reply(resp)
print("\nResponse : " + str(flow.response.content) + "\n")
def to_mitmproxy(self) -> HTTPResponse:
return HTTPResponse(
http_version='HTTP/1.1',
status_code=self.status_code,
reason=self.status_message,
headers=self.headers.to_mitmproxy(),
content=self.body,
)
def request(self, flow):
if self.pred(flow):
try:
if flow.request.method == 'GET':
row = self.st.get_row_by_url(flow.request.url)
if row is None:
ctx.log.info('@ not found: {}'.format(flow.request.url))
flow.response = HTTPResponse.make(404, content=flow.request.url)
else:
ctx.log.info('@ using row: {}'.format(row))
flow.response = HTTPResponse.make(
content=self.st.get_blob(row.hash),
headers={
'content-type': row.content_type
},
)
except Exception as e:
flow.response = HTTPResponse.make(500, content=str(e))
def homepage_refresh(self, flow, url):
flow.direct_response = True
environ = {}
environ['webrec.template_params'] = {'url': url}
resp_data = self.home_redir_view.render_to_string(environ).encode(
'utf-8')
flow.response = HTTPResponse.make(
200, resp_data, {'Content-Type': 'text/html; charset=utf-8'})
return True
def request(flow):
url = flow.request.pretty_url
host = flow.request.pretty_host
print('request():', host, url)
if any(map(lambda s: host.startswith(s), ignoreHosts)):
return
resp = HTTPResponse.make(
303, url, {
'Content_Type': "text/html",
'Location': url.replace('http://', 'https://', 1)
})
now = time.time()
if insecure_urls[url] + 61 > now:
resp = HTTPResponse.make(500, "mitm seen before" + url, {})
if len(insecure_urls) > 5 * 1024:
print('request(): insecure_urls.clear()')
insecure_urls.clear()
insecure_urls[url] = now
flow.response = resp
def block_telemetry(flow: HTTPFlow):
if config.block_telemetry and flow.request.path.startswith('/telemetry'):
flow.request.text = '{}' # Just in case
flow.response = HTTPResponse.make(200, '{}')
flow.response.headers.add('Content-Type', 'application/json')
flow.response.headers.add('server', 'eos-gateway')
flow.response.headers.add('access-control-allow-origin', '*')
flow.response.headers.add('x-epic-correlation-id', '12345678-1234-1234-1234-123456789abc')
log.info('Blocked telemetry request from Epic Games')
def response_config_rule(self, flow):
(_host, _path) = flow.request.host, flow.request.path
header = self.custom_header(_host, 'text/plain', 7)
header['location'] = 'http://' + _host + _path
_response = HTTPResponse(b"HTTP/1.1",
200,
'ok',
header,
content=b'{ret:0}',
is_replay=True)
flow.response = _response
def request(self, flow):
error_message = None
try:
flow.response = self.create_response(flow.request)
except ConnectionError:
# If TCP Rst Configured
if self.on_rst:
self.logger.debug("Got TCP Rst, While TCP Rst Configured")
self.multitor.new_identity()
# Set Response
try:
flow.response = self.create_response(flow.request)
except Exception as error:
error_message = f"Got Error: {error}"
else:
error_message = "Got TCP Rst, While TCP Rst Not Configured"
except Exception as error:
error_message = f"Got Error: {error}"
# When There Is No Response
if error_message:
self.logger.error(error_message)
flow.response = HTTPResponse.make(
status_code=500,
content=error_message,
headers={"Server": f"pymultitor/{__version__}"})
return
# If String Found In Response Content
if self.on_string and self.on_string in flow.response.text:
self.logger.debug("String Found In Response Content")
self.multitor.new_identity()
# Set Response
flow.response = self.create_response(flow.request)
# If Regex Found In Response Content
if self.on_regex and re.search(self.on_regex, flow.response.text,
re.IGNORECASE):
self.logger.debug("Regex Found In Response Content")
self.multitor.new_identity()
# Set Response
flow.response = self.create_response(flow.request)
# If Counter Raised To The Configured Number
if self.on_count and not next(self.counter) % self.on_count:
self.logger.debug("Counter Raised To The Configured Number")
self.multitor.new_identity()
# If A Specific Status Code Returned
if self.on_error_code and self.on_error_code == flow.response.status_code:
self.logger.debug("Specific Status Code Returned")
self.multitor.new_identity()
# Set Response
flow.response = self.create_response(flow.request)
def redirect_https_to_http(flow):
(_host, _path) = flow.request.host, flow.request.path
header = Smarthost.custom_header(_host, None, 0)
header['location'] = 'http://' + _host + _path
_response = HTTPResponse(b"HTTP/1.1",
302,
'redirect temporary',
header,
'',
is_replay=True)
flow.response = _response
def _load_http_response(o: http_pb2.HTTPResponse) -> HTTPResponse:
d: dict = {}
_move_attrs(o, d, ['http_version', 'status_code', 'reason',
'content', 'timestamp_start', 'timestamp_end'])
if d['content'] is None:
d['content'] = b""
d["headers"] = []
for header in o.headers:
d["headers"].append((bytes(header.name, "utf-8"), bytes(header.value, "utf-8")))
return HTTPResponse(**d)
def request(flow):
global rules
req = flow.request
# accept = flow.request.headers["Accept"]
# log("accept: %s" % flow.request.accept)
options = {'domain': req.host}
if IMAGE_MATCHER.search(req.path):
options["image"] = True
elif SCRIPT_MATCHER.search(req.path):
options["script"] = True
elif STYLESHEET_MATCHER.search(req.path):
options["stylesheet"] = True
if rules.should_block(req.url, options):
log("vvvvvvvvvvvvvvvvvvvv BLOCKED vvvvvvvvvvvvvvvvvvvvvvvvvvv")
log("accept: %s" % flow.request.headers.get("Accept"))
log("blocked-url: %s" % flow.request.url)
log("^^^^^^^^^^^^^^^^^^^^ BLOCKED ^^^^^^^^^^^^^^^^^^^^^^^^^^^")
# resp = HTTPResponse((1,1), 404, "OK",
# ODictCaseless([["Content-Type", "text/html"]]),
# "A terrible ad has been removed!")
# HTTPResponse(http_version, status_code, reason, headers, content, timestamp_start=None, timestamp_end=None)
# resp = HTTPResponse(
# (1,1),
# 200,
# "OK",
# ODictCaseless(
# [
# ["Content-Type", "text/html"]
# ]
# ),
# "BLOCKED."
# )
resp = HTTPResponse(
(1,1),
200,
"OK",
Headers(content_type="text/html"),
"BLOCKED."
)
flow.reply(resp)
else:
log("url: %s" % flow.request.url)
def request(self, flow: HTTPFlow):
"""MITMProxy addon event interface for outgoing request."""
try:
request = MITMRequest.from_mitmproxy(flow.request)
response = self.process_request(request).to_mitmproxy()
flow.response = response
except DoNotIntercept as e:
# Let the request pass through, by not interrupting the flow, but log it
logger.warning(str(e))
except Exception as e:
flow.response = HTTPResponse.make(
status_code=getattr(e, 'http_status_code', 500),
content=str(e),
headers={'Content-Type': 'text/plain'})
def create_response(self, request):
response = requests.request(method=request.method,
url=request.url,
data=request.content,
headers=request.headers,
allow_redirects=False,
verify=not self.insecure,
proxies=self.multitor.proxy)
return HTTPResponse.make(
status_code=response.status_code,
content=response.content,
headers=dict(response.headers),
)
def tampper_fields(self, flow):
rules = self.reuse_header
req = flow.request
_host = req.host
_url = req.pretty_url
_headers = req.headers if req.headers is not None else {}
_querys = req.query if req.query is not None else {}
if _host in self.reuse_header:
rule = self.reuse_header[_host]
match, cnt, vals = rule['matches'], 0, []
_check = _querys if rule['is_query'] == 1 else _headers
if 'url_match' in rule:
if _url.find(rule['url_match']) == -1:
return
for k, v in enumerate(match):
if v in _check and len(_check[v]) > 0:
cnt += 1
vals.append(_check[v])
if cnt == len(match):
self.reuse_header[_host]['values'] = vals
elif len(rule['values']) == len(match):
vals = self.reuse_header[_host]['values']
for k, v in enumerate(match):
val = urllib.quote(vals[k].encode('utf-8'))
if rule['is_query'] == 1:
if _url.find(v + '=') > -1:
_url = re.sub(r''.join([v, '=[^&]*?']), _url,
r'%s%s<1>' % (v, val))
else:
flag = '&' if _url.find('?') != -1 else '?'
_url += '%s%s=%s' % (flag, v, val)
else:
req.request.headers[v] = vals[k]
if rule['is_query'] == 1:
header = Headers(host=_host)
header['location'] = _url
header["Connection"] = 'closed'
header["Content-Length"] = '0'
flow.is_replay = True
flow.response = HTTPResponse(b"HTTP/1.1",
302,
'redirect temporary',
header,
b'',
is_replay=True)
def request(flow):
host = flow.request.headers.get('Host', '')
if host.endswith('.https'):
flow.request.scheme = 'https'
flow.request.port = 443
origHost = host.replace('.https', '')
flow.request.host = origHost
elif host.endswith('.http'):
flow.request.scheme = 'http'
flow.request.port = 80
origHost = host.replace('.http', '')
flow.request.host = origHost
else:
flow.response = HTTPResponse.make(418)
if False:
print('requestH(' + flow.request.url + ')', flow.request.headers)
def block_playtime(flow: HTTPFlow):
if config.block_playtime and flow.request.path.startswith('/library/api/public/playtime/'):
original_playtime = json.loads(flow.request.text)
flow.request.text = '{}' # Just in case
correlation_id = flow.request.headers.get('X-Epic-Correlation-ID')
if m := re.match(r"UE4-(\w+)", correlation_id):
device_id = m.group(1)
else:
device_id = '123456789abcdef01234567890abcdef'
flow.response = HTTPResponse.make(204)
flow.response.headers.add('x-epic-device-id', device_id)
flow.response.headers.add('x-epic-correlation-id', correlation_id)
flow.response.headers.add('x-envoy-upstream-service-time', '10') # ?
flow.response.headers.add('server', 'istio-envoy')
log.info('Blocked playtime request from Epic Games')
log.debug(f'\n{json.dumps(original_playtime, indent=4)}')
def create_response(self, request):
response = requests.request(method=request.method,
url=request.url,
data=request.content,
headers=request.headers,
allow_redirects=False,
verify=not self.insecure,
proxies=self.multitor.proxy,
stream=False)
# Content-Length and Transfer-Encoding set. This is expressly forbidden by RFC 7230 sec 3.3.2.
if response.headers.get("Transfer-Encoding") == "chunked":
response.headers.pop("Transfer-Encoding")
return HTTPResponse.make(
status_code=response.status_code,
content=response.content,
headers=dict(response.headers),
)
def request(self, flow: HTTPFlow):
if flow.request.host in self.ServersList and flow.request.path.startswith(
"/quest/battleStart"):
req = json.loads(flow.request.get_text())
if (req["stageId"] != "main_08-16"):
return
self.info("Receive JT8-2 battle start request")
fakeData = {
"apFailReturn": 20,
"battleId": "6c86c7c0-3373-11eb-9784-0d36b8275660",
"isApProtect": 0,
"notifyPowerScoreNotEnoughIfFailed": False,
"playerDataDelta": {
"deleted": {},
"modified": {
# "dungeon": {
# "stages": {
# "main_07-01": {
# "completeTimes": 1,
# "hasBattleReplay": 1,
# "noCostCnt": 0,
# "practiceTimes": 0,
# "stageId": "main_07-01",
# "startTimes": 2,
# "state": 3
# }
# }
# }
}
},
"result": 0
}
flow.response = HTTPResponse.make(
200, json.dumps(fakeData),
{"Content-Type": "application/json; charset=utf-8"})
self.info("complete")
def request(flow):
global rules
req = flow.request
options = {'domain': req.host}
db_insert(req.host)
with open('hostname.txt', 'a') as f:
f.write(f"{req.host} ===> url {flow.request.url}\n \n\n\n\n")
if IMAGE_MATCHER.search(req.path):
options["image"] = True
elif SCRIPT_MATCHER.search(req.path):
options["script"] = True
elif STYLESHEET_MATCHER.search(req.path):
options["stylesheet"] = True
if rules.should_block(req.url, options):
log("vvvvvvvvvvvvvvvvvvvv BLOCKED vvvvvvvvvvvvvvvvvvvvvvvvvvv")
with open('block_sites.txt', 'a') as file:
file.write(
f'{flow.request.url} ===> header: {flow.request.headers.get("Accept")}\n'
)
file.write(f'options {options}\n\n\n\n\n')
log("accept: %s" % flow.request.headers.get("Accept"))
log("blocked-url: %s" % flow.request.url)
log("^^^^^^^^^^^^^^^^^^^^ BLOCKED ^^^^^^^^^^^^^^^^^^^^^^^^^^^")
flow.response = HTTPResponse.make(404, b"OK",
{"Content-Type": "text/html"})
# HTTPResponse(http_version, status_code, reason, headers, content, timestamp_start=None, timestamp_end=None)
else:
log("url: %s" % flow.request.url)
def perform(self, flow, qs):
flow.response = HTTPResponse.make(
302,
b"",
{"Location": self.build_destination(qs)}
)
def homepage_redir(self, flow, redir_url):
flow.request.host = self.fwd_host
flow.response = HTTPResponse.make(303, b'', {'Location': redir_url})
return True
# gzipped utf-8-encoded "Hello, world!"
'body': b'x\x9c\xf3H\xcd\xc9\xc9\xd7Q(\xcf/\xcaIQ\x04\x00 ^\x04\x8a',
'headers': {
'Content-Type': ['text/plain; charset=UTF-8'],
'Date': ['Wed, 21 Mar 2018 12:47:18 GMT'],
'Server': ['nginx/1.12.2'],
'Content-Encoding': ['gzip']
}
}
TEST_MITM_RESPONSE = HTTPResponse(
http_version='HTTP/1.1',
status_code=200,
reason='OK',
headers=Headers(fields=[
(b'Content-Type', b'text/plain; charset=ISO-8859-2'),
(b'Date', b'Wed, 21 Mar 2018 12:47:18 GMT'),
(b'Server', b'nginx/1.12.2'),
]),
content=b'Witaj, \xb6wiecie!',
)
TEST_MITM_RESPONSE_GZIP = HTTPResponse(
http_version='HTTP/1.1',
status_code=200,
reason='OK',
headers=Headers(fields=[
(b'Content-Type', b'text/plain; charset=UTF-8'),
(b'Date', b'Wed, 21 Mar 2018 12:47:18 GMT'),
(b'Server', b'nginx/1.12.2'),
(b'Content-Encoding', b'gzip'),
def block_telemetry(flow: HTTPFlow):
if config.block_telemetry and flow.request.path.startswith(
'/ratt/telm'):
flow.response = HTTPResponse.make(500, 'No more spying')
log.debug('Blocked telemetry request from Origin')
def request(self, flow: HTTPFlow):
if self.inServersList(
flow.request.host) and flow.request.path.startswith(
"/gacha/tenAdvancedGacha"):
respData = {
"gachaResultList": [],
"playerDataDelta": {
"deleted": {},
"modified": {}
},
"result": 0
}
self.info("十连中...")
charlist = self.getTen()
for charId, rarity in charlist:
gacha = {}
gacha["isNew"] = 0
gacha["charId"] = charId
cdata = self.tBuilder.getCharData(charId)
if cdata == None:
continue
gacha["charInstId"] = cdata["instId"]
if rarity == "5":
gacha["itemGet"] = [{
"count": 15,
"id": "4004",
"type": "HGG_SHD"
}, {
"count": 1,
"id": "p_" + charId,
"type": "MATERIAL"
}]
if rarity == "4":
gacha["itemGet"] = [{
"count": 8,
"id": "4004",
"type": "HGG_SHD"
}, {
"count": 1,
"id": "p_" + charId,
"type": "MATERIAL"
}]
if rarity == "3":
gacha["itemGet"] = [{
"count": 30,
"id": "4005",
"type": "LGG_SHD"
}, {
"count": 1,
"id": "p_" + charId,
"type": "MATERIAL"
}]
if rarity == "2":
gacha["itemGet"] = [{
"count": 5,
"id": "4005",
"type": "LGG_SHD"
}, {
"count": 1,
"id": "p_" + charId,
"type": "MATERIAL"
}]
respData["gachaResultList"].append(gacha)
flow.response = HTTPResponse.make(
200, json.dumps(respData),
{"Content-Type": "application/json; charset=utf-8"})
self.info("完成")
if self.inServersList(
flow.request.host) and flow.request.path.startswith(
"/gacha/advancedGacha"):
respData = {
"charGet": {},
"playerDataDelta": {
"deleted": {},
"modified": {}
},
"result": 0
}
self.info("单抽中...")
charId, rarity = self.getOne()
gacha = {}
gacha["isNew"] = 0
gacha["charId"] = charId
cdata = self.tBuilder.getCharData(charId)
gacha["charInstId"] = cdata["instId"]
if rarity == "5":
gacha["itemGet"] = [{
"count": 15,
"id": "4004",
"type": "HGG_SHD"
}, {
"count": 1,
"id": "p_" + charId,
"type": "MATERIAL"
}]
if rarity == "4":
gacha["itemGet"] = [{
"count": 8,
"id": "4004",
"type": "HGG_SHD"
}, {
"count": 1,
"id": "p_" + charId,
"type": "MATERIAL"
}]
if rarity == "3":
gacha["itemGet"] = [{
"count": 30,
"id": "4005",
"type": "LGG_SHD"
}, {
"count": 1,
"id": "p_" + charId,
"type": "MATERIAL"
}]
if rarity == "2":
gacha["itemGet"] = [{
"count": 5,
"id": "4005",
"type": "LGG_SHD"
}, {
"count": 1,
"id": "p_" + charId,
"type": "MATERIAL"
}]
respData["charGet"] = gacha
flow.response = HTTPResponse.make(
200, json.dumps(respData),
{"Content-Type": "application/json; charset=utf-8"})
self.info("完成")
