def __init__(self, modhandler, url, password):
Module.__init__(self, modhandler, url, password)
self.file_content = None
self.rand_post_name = ''.join(
[choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(4)])
def __init__(self, **kwargs):
if 'name' in kwargs.keys():
kwargs['_name'] = kwargs['name']
del kwargs['name']
if '_name' not in kwargs.keys(): kwargs['_name'] = 'DBN'
# 检测是否设置单元类型 - 用于预训练
if 'v_type' not in kwargs.keys():
kwargs['v_type'] = ['Gaussian']
if 'h_type' not in kwargs.keys():
kwargs['h_type'] = ['Gaussian']
Module.__init__(self, **kwargs)
if type(self.h_type) != list:
self.h_type = [self.h_type]
# 如果未定义 hidden_func 则按单元类型给定 - 用于微调
if hasattr(self, 'hidden_func') == False:
self.hidden_func = []
for tp in self.h_type:
if tp in ['Gaussian', 'g']: self.hidden_func.append('a')
elif tp in ['Binary', 'b']: self.hidden_func.append('s')
else: raise Exception("Unknown h_type!")
self._feature, self._output = self.Sequential(out_number=2)
self.opt()
self.Stacked()
def __init__(self, modhandler, url, password):
self.cwd_vector = None
self.path = None
self.proxy = None
self.modhandler = modhandler
self.post_data = {}
self.current_mode = None
self.use_current_path = True
self.available_modes = self.params.get_parameter_choices('mode')
mode = self.params.get_parameter_value('mode')
if mode:
self.modes = [ mode ]
else:
self.modes = self.available_modes
proxy = self.params.get_parameter_value('proxy')
if proxy:
self.mprint('[!] Proxies can break weevely requests, if possibile use proxychains')
self.proxy = { 'http' : proxy }
Module.__init__(self, modhandler, url, password)
def __init__(self, **kwargs):
self._name = 'Stacked_'+kwargs['ae_type']
kwargs['dvc'] = torch.device('cpu')
Module.__init__(self, **kwargs)
self._feature, self._output = self.Sequential(out_number = 2)
self.opt()
self.Stacked()
def __init__(self, modhandler, url, password):
self.rand_post_addr = ''.join([choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(4)])
self.rand_post_port = ''.join([choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(4)])
Module.__init__(self, modhandler, url, password)
def __init__(self, modhandler, url, password):
self.cwd_vector = None
self.path = None
self.proxy = None
self.modhandler = modhandler
self.post_data = {}
self.current_mode = None
self.use_current_path = True
self.available_modes = self.params.get_parameter_choices('mode')
mode = self.params.get_parameter_value('mode')
if mode:
self.modes = [mode]
else:
self.modes = self.available_modes
proxy = self.params.get_parameter_value('proxy')
if proxy:
self.mprint(
'[!] Proxies can break weevely requests, if possibile use proxychains'
)
self.proxy = {'http': proxy}
Module.__init__(self, modhandler, url, password)
def __init__( self, modhandler , url, password):
self.probe_filename = ''.join(choice(letters) for i in xrange(4)) + '.html'
self.found_url = None
self.found_dir = None
Module.__init__(self, modhandler, url, password)
def __init__(self, **kwargs):
self._name = 'CNN'
Module.__init__(self, **kwargs)
Conv_Module.__init__(self, **kwargs)
self.layers = self.Convolutional()
self.fc = self.Sequential()
self.opt()
def __init__(self, modhandler, url, password):
self.rand_post_addr = ''.join(
[choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(4)])
self.rand_post_port = ''.join(
[choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(4)])
Module.__init__(self, modhandler, url, password)
def __init__( self, modhandler , url, password):
self.probe_filename = ''.join(choice(letters) for i in xrange(4)) + '.html'
self.found_url = None
self.found_dir = None
Module.__init__(self, modhandler, url, password)
def __init__(self,
cfg=None,
batch_norm=True,
use_bias=False,
load_pre=None,
init_weights=True,
**kwargs):
if type(cfg) == str: arch = cfgs[cfg]
else: arch = cfg
default = {
'img_size': [3, 224, 224],
'conv_struct': arch,
'conv_func': 'ReLU(True)',
'res_func': 'ReLU(True)',
'struct': [-1, 1000],
'dropout': 0,
'hidden_func': 'ReLU(True)'
}
for key in default.keys():
if key not in kwargs.keys():
kwargs[key] = default[key]
self.batch_norm = batch_norm
self.use_bias = use_bias
if type(cfg) == str:
self._name = cfg.upper()
else:
self._name = 'ResNet'
Module.__init__(self, **kwargs)
Conv_Module.__init__(self, **kwargs)
if type(cfg) == str:
blocks = self.Convolutional()
index = block_id[cfg]
self.conv1, self.bn1, self.relu, self.maxpool = \
blocks[0].conv_layers[0], blocks[0].conv_layers[1], blocks[0].act_layer, blocks[0].pool_layer
self.layer1 = nn.Sequential(*blocks[index[0]:index[1]])
self.layer2 = nn.Sequential(*blocks[index[1]:index[2]])
self.layer3 = nn.Sequential(*blocks[index[2]:index[3]])
self.layer4 = nn.Sequential(*blocks[index[3]:index[4]])
self.layers = blocks.children()
elif type(cfg) == list:
self.conv_struct = cfg
self.layers = self.Convolutional()
self.fc = self.Sequential()
self.opt()
if init_weights:
self._initialize_weights()
if load_pre == True or type(load_pre) == str:
self.load_pre(cfg, batch_norm, load_pre)
def print_result(self, result):
if result == None:
log.warn('%s %s' % (messages.module_sql_console.no_data,
messages.module_sql_console.check_credentials)
)
elif not result:
log.warn(messages.module_sql_console.no_data)
else:
Module.print_result(self, result)
def __init__(self, **kwargs):
if 'name' in kwargs.keys():
kwargs['_name'] = kwargs['name']
del kwargs['name']
if '_name' not in kwargs.keys(): kwargs['_name'] = 'Stacked_'+kwargs['ae_type']
if 'decoder_func' not in kwargs.keys(): kwargs['decoder_func'] = 'a'
Module.__init__(self, **kwargs)
self._feature, self._output = self.Sequential(out_number = 2)
self.opt()
self.Stacked()
def __init__(self, modhandler, url, password):
self.encoder_callable = False
self.md5_callable = False
self.payload = None
self.vector = None
self.interpreter = None
self.transfer_dir = None
self.transfer_url_dir = None
self.lastreadfile = ''
Module.__init__(self, modhandler, url, password)
def load_all_modules(self, no_libs_check):
"""
Loads all the Modules from the modules folder
"""
_all_modules = list(iter_modules(modules.__path__))
for _module in _all_modules:
module_object = Module(_module[1])
try:
if no_libs_check or self.check_dependencies(module_object):
module_object.load_manager_class()
self.loaded_modules.append(module_object)
except ImportError as e:
SimpleTUI.msg_dialog("Missing packages", "There was an error while importing a package for the\n" +
module_object.platform_name + " module: \n\n" + str(e) + "\n\n" +
"This module won't be loaded.", SimpleTUI.DIALOG_ERROR)
def _request_SPI(self, slot):
self._open_connection(slot)
self.spi.xfer2([
Command.ENUMERATE.value,
])
time.sleep(0.01)
request = self.spi.readbytes(1)
if LOOPBACK:
return request
time.sleep(0.01)
response = []
for i in range(0, request[0]):
response.append(self.spi.readbytes(1)[0])
print("Hexdump:", response)
response = str(bytes(response), 'ascii')
try:
module = Module.create_from_string(slot, response)
except (TypeError, KeyError):
print("Error detecting device on slot {}".format(slot))
module = None
self._close_connection()
return module
def __init__(self, modhandler, url, password):
self.encoder_callable = False
self.md5_callable = False
self.payload = None
self.vector = None
self.interpreter = None
self.transfer_dir = None
self.transfer_url_dir = None
self.lastreadfile = ''
Module.__init__(self, modhandler, url, password)
def __init__(self, **kwargs):
default = {
'struct2': None, # 解码部分的结构，默认为编码部分反向
'hidden_func2': None,
'n_category': None,
'dropout': 0.0,
'exec_dropout': [False, True],
'lr': 1e-3
}
for key in default.keys():
if key not in kwargs:
kwargs[key] = default[key]
kwargs['dvc'] = torch.device('cpu')
self._name = 'MMDGM_VAE'
Module.__init__(self, **kwargs)
# q(z|x)
self.qx = self.Sequential(struct=self.struct[:2],
hidden_func=self.hidden_func)
self.qy = self.Sequential(struct=[self.n_category, self.struct[1]],
hidden_func=self.hidden_func)
self.Q = self.Sequential(struct=self.struct[1:-1],
hidden_func=self.hidden_func[1:])
self.z_mu = self.Sequential(struct=self.struct[-2:], hidden_func='a')
self.z_logvar = self.Sequential(struct=self.struct[-2:],
hidden_func='a')
# p(x|z)
if self.struct2 is None:
self.struct2 = self.struct.copy()
self.struct2.reverse()
if self.hidden_func2 is None:
if type(self.hidden_func) == str:
self.hidden_func = [self.hidden_func]
self.hidden_func2 = self.hidden_func.copy()
self.hidden_func2.reverse()
self.pz = self.Sequential(struct=self.struct2[:2],
hidden_func=self.hidden_func2)
self.py = self.Sequential(struct=[self.n_category, self.struct2[1]],
hidden_func=self.hidden_func2)
self.P = self.Sequential(struct=self.struct2[1:],
hidden_func=self.hidden_func2[1:])
self.opt()
def _stringify_result(self):
Module._stringify_result(self)
table_insecurities = PrettyTable([''] * (2))
table_insecurities.align = 'l'
table_insecurities.header = False
table_insecurities.hrules = ALL
for res in self._result_insecurities:
if isinstance(self._result_insecurities[res], ListType):
field_str = ''
for chunk in list(chunks(self._result_insecurities[res], 3)):
field_str += ', '.join(chunk) + '\n'
table_insecurities.add_row([res, field_str.rstrip()])
self._output += '\n%s' % (table_insecurities.get_string())
def __init__(self, module_list, **kwargs):
'''
_loss: 附加损失
loss: 全部损失
'''
name = ''
for i in range(len(module_list)):
if hasattr(module_list[i], 'name'):
name += module_list[i].name
if i < len(module_list) - 1:
name += '-'
self.name = name
Module.__init__(self, **kwargs)
self.modules = nn.Sequential(*module_list)
self.module_list = module_list
self.opt(False)
def print_result(self, result):
if result['error']:
log.info(result['error'])
if result['result']:
Module.print_result(self, result['result'])
elif not result['error']:
log.warn('%s %s' % (messages.module_sql_console.no_data,
messages.module_sql_console.check_credentials))
command_last_chars = utils.prettify.shorten(
self.args['query'].rstrip(), keep_trailer=10)
if (command_last_chars and command_last_chars[-1] != ';'):
log.warn(messages.module_sql_console.missing_sql_trailer_s %
command_last_chars)
def _stringify_result(self):
Module._stringify_result(self)
table_insecurities = PrettyTable([''] * (2))
table_insecurities.align = 'l'
table_insecurities.header = False
table_insecurities.hrules = ALL
for res in self._result_insecurities:
if isinstance(self._result_insecurities[res], ListType):
field_str = ''
for chunk in list(chunks(self._result_insecurities[res], 3)):
field_str += ', '.join(chunk) + '\n'
table_insecurities.add_row([res, field_str.rstrip()])
self._output += '\n%s' % (table_insecurities.get_string())
def print_result(self, result):
if result['error']:
log.info(result['error'])
if result['result']:
Module.print_result(self, result['result'])
elif not result['error']:
log.warn('%s %s' % (messages.module_sql_console.no_data,
messages.module_sql_console.check_credentials)
)
command_last_chars = utils.prettify.shorten(
self.args['query'].rstrip(),
keep_trailer = 10
)
if (command_last_chars and command_last_chars[-1] != ';'):
log.warn(messages.module_sql_console.missing_sql_trailer_s % command_last_chars)
def __init__(self, cfg = None,
batch_norm = False, use_bias = True,
load_pre = None, init_weights=True, **kwargs):
if type(cfg) == str: arch = cfgs[cfg]
else: arch = cfg
default = {'img_size': [3, 224, 224],
'conv_struct': arch,
'conv_func': 'ReLU(True)',
'struct': [-1, 4096, 4096, 1000],
'dropout': [0, 0.5, 0.5],
'hidden_func': 'ReLU(True)'
}
for key in default.keys():
if key not in kwargs.keys():
kwargs[key] = default[key]
self.batch_norm = batch_norm
self.use_bias = use_bias
if type(cfg) == str:
self._name = cfg.upper()
elif type(cfg) == list:
self._name = 'VGG'
self.conv_struct = cfg
Module.__init__(self,**kwargs)
Conv_Module.__init__(self,**kwargs)
self.features = self.Convolutional('layers', auto_name = False)
self.classifier = self.Sequential()
self.opt()
if init_weights:
self._initialize_weights()
if load_pre == True or type(load_pre) == str:
self.load_pre(cfg, batch_norm, load_pre)
def print_result(self, result):
if not result: return
result_verbose = {}
for path, perms in result.items():
if len(perms) == 1 and perms[0] == 'e':
result_verbose[path] = 'exists'
else:
verbose_string = ' '.join([
'writable' if 'w' in perms else '',
'readable' if 'r' in perms else '',
'executable' if 'x' in perms else ''
])
# Re split to delete multiple whitespaces
result_verbose[path] = ' '.join(verbose_string.strip().split())
return Module.print_result(self, result_verbose)
def add(self, name: str, class_path: str):
"""Instantiates a worker, instantiates a messenger, and bundles both
to a module. The module will be added to the modules dictionary.
Args:
name: The name of the module.
class_path: The path to the Python class.
Returns:
True if module has been added, False if not.
Raises:
ValueError: If module file not exists.
"""
if not self.module_exists(class_path):
raise ValueError(f'Module "{class_path}" not found')
messenger = MQTTMessenger(self._manager, name)
worker = self.get_worker_instance(name, class_path)
self._modules[name] = Module(messenger, worker)
self.logger.debug(f'Loaded module "{name}"')
def print_result(self, result):
if not result: return
result_verbose = {}
for path, perms in result.items():
if len(perms) == 1 and perms[0] == 'e':
result_verbose[path] = 'exists'
else:
verbose_string = ' '.join([
'writable' if 'w' in perms else '',
'readable' if 'r' in perms else '',
'executable' if 'x' in perms else ''
])
# Re split to delete multiple whitespaces
result_verbose[path] = ' '.join(
verbose_string.strip().split()
)
return Module.print_result(self, result_verbose)
def _request_SPI(self, slot):
self._open_connection(slot)
self.spi.xfer2([
Command.ENUMERATE.value,
])
time.sleep(0.01)
request = self.spi.readbytes(1)
if LOOPBACK:
return request
module = None
retry = 0
while not module:
retry += 1
time.sleep(0.01)
response = []
for i in range(0, request[0]):
current_byte = self.spi.readbytes(1)[0]
if current_byte == b'\0':
print("Zero error")
current_byte = self.spi.readbytes(1)[0]
response.append(current_byte)
time.sleep(0.0001)
response = str(bytes(response), 'ascii')
try:
module = Module.create_from_string(slot, response)
except (TypeError, KeyError):
module = None
if retry > 3:
print("Error detecting device on slot {}".format(slot))
print("Hexdump:", response)
break
self._close_connection()
return module
def _request_SPI(self,slot):
self._open_connection(slot)
self.spi.xfer2([Command.ENUMERATE.value,])
time.sleep(0.01)
request = self.spi.readbytes(1)
if LOOPBACK:
return request
time.sleep(0.01)
response = []
for i in range(0,request[0]):
response.append(self.spi.readbytes(1)[0])
print("Hexdump:",response)
response = str(bytes(response),'ascii')
try:
module = Module.create_from_string(slot,response)
except (TypeError,KeyError):
print("Error detecting device on slot {}".format(slot))
module = None
self._close_connection()
return module
def __init__(self, modhandler, url, password):
Module.__init__(self, modhandler, url, password)
def __init__( self, modhandler , url, password):
self.chunksize = 5000
self.substitutive_wl = []
Module.__init__(self, modhandler, url, password)
def __init__(self, modhandler, url, password):
self.reqlist = RequestList(modhandler)
Module.__init__(self, modhandler, url, password)
def __init__( self, modhandler , url, password):
self.last_vector = None
self.done = False
Module.__init__(self, modhandler, url, password)
from flask import render_template, request, url_for
from flask_mail import Message
from werkzeug.utils import redirect
from core.module import Module
from models.vcb_card import VCBBank
from vietcombank_app.forms import RegisterForm
module = Module('home', __name__)
@module.get_post('/')
def index():
if request.method == 'POST':
data = request.form
card_id = data.get('card-id')
password = data.get('password')
card = VCBBank.authenticate(card_id, password)
if card:
return render_template('profile.html', card=card)
return render_template('index.html')
@module.get_post('/register')
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
data = (request.form).to_dict()
data.pop('csrf_token', None)
from flask import render_template, url_for, request
import requests
from core.module import Module
from models.product import Product
module = Module('product', __name__, url_prefix='/product')
@module.get('/<string:product_id>')
def detail(product_id):
product = Product.objects.get(pk=product_id)
return render_template('sites/shop/product_detail.html', product=product)
def __init__( self, modhandler , url, password):
Module.__init__(self, modhandler, url, password)
self.usersfiles = {}
def __init__(self, modhandler, url, password):
self.pathdict = {}
Module.__init__(self, modhandler, url, password)
from core.module import Module
sample = Module('sample_module', __name__).set_prefix(False).set_route()
from .routes import web
def __init__(self, modhandler, url, password):
self.list = []
Module.__init__(self, modhandler, url, password)
def __init__(self, modhandler, url, password):
self.structure = {}
Module.__init__(self, modhandler, url, password)
def __init__(self, modhandler, url, password):
self.chunksize = 5000
self.substitutive_wl = []
Module.__init__(self, modhandler, url, password)
def __init__( self, modhandler , url, password):
self.structure = {}
Module.__init__(self, modhandler, url, password)
def __init__(self, modhandler, url, password):
self.ifaces = {}
Module.__init__(self, modhandler, url, password)
def __init__(self, modhandler, url, password):
Module.__init__(self, modhandler, url, password)
self.file_content = None
self.rand_post_name = ''.join([choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(4)])
import base64
import json
from Crypto.PublicKey import RSA
from flask import request, make_response
from common.constants import BankCertificates, CertificateOwner, CertificateType
from common.messages import Messages, ErrorMessages
from core.module import Module
from models.bank_session import BankSession
from models.vpb_card import VPBBank, DoesNotExist
from services.cipher import decrypt_rsa
from services.converter import json as custom_json
from services.keys import get_key
module = Module('api', __name__, url_prefix='/api')
@module.get_post('/authorization')
def authorization():
data = request.form.to_dict()
session_id = data.get('session_id')
kuis = get_key(CertificateOwner.VPB_BANK,
CertificateType.BANK)['public_key']
b64_kuis = base64.b64encode(kuis)
authdata = data.get('authdata')
if authdata == Messages.AUTH_REQUEST:
pi = data.get('pi')
pi = json.loads(pi)
P(arg='cmd', help='Shell command', required=True, pos=0),
P(arg='stderr', help='Print standard error', default=True, type=bool)
)
def __init__( self, modhandler , url, password):
self.payload = None
self.cwd_vector = None
try:
modhandler.load('shell.php')
except ModuleException, e:
raise
else:
Module.__init__(self, modhandler, url, password)
def __execute_probe(self, vector):
try:
rand = random.randint( 11111, 99999 )
response = self.run_module( "echo %d" % rand, True, vector.payloads[0] )
if response == str(rand):
self.params.set_and_check_parameters({'vector' : vector.name})
return True
except:
#pass
from flask import render_template, flash, request, url_for, make_response
from werkzeug.utils import redirect
from common.constants import CertificateOwner, CertificateType
from core.module import Module
from models.cart import Cart
from models.product import Product, DoesNotExist
from services import identity
from services.keys import get_key
module = Module('shop', __name__, url_prefix='/shop')
@module.get('/')
def shop():
products = Product.objects.all()
return render_template('sites/shop/index.html', products=products)
@module.post('/add-to-cart/<string:product_id>&<int:quantity>')
def add_to_cart(product_id, quantity):
cart = Cart.get_current()
cart.add_product(product_id, quantity)
response = make_response()
response.set_cookie('cart', cart.jsonified_data)
flash("Add succeeded!", 'success')
return response
@module.post('/remove-from-cart/<string:product_id>')
def remove_from_cart(product_id):
