def test_error_make_ref_failure(self):
""" Test that github api make ref fails does not break API
"""
self.github_api.sha_origin = "789456"
self.github_api.exist_file["path/to/some/file.xml"] = False
# We need to make checking the ref fail first (because the branch should not exist to trigger creation)
self.github_api.route_fail[
"http://localhost/repos/ponteineptique/dummy/git/refs/heads/uuid-1234"
] = True
# And then make creating fail
self.github_api.route_fail[
"http://localhost/repos/ponteineptique/dummy/git/refs"
] = True
result = self.makeRequest(
base64.encodebytes(b'Some content'),
make_secret(base64.encodebytes(b'Some content').decode("utf-8"), self.secret),
{
"author_name": "ponteineptique",
"date": "19/06/2016",
"logs": "Hard work of transcribing file",
"auithor_email": "*****@*****.**",
"branch": "uuid-1234"
}
)
data, http = response_read(result)
self.assertEqual(
data, {'message': 'Not Found', 'status': 'error', 'step': 'make_ref'},
"Error message should be carried by ProxyError in Ref Creation Failure"
)
self.assertEqual(http, 404, "Status code should be carried by ProxyError")
def load(self, f, pretty = False, no_payload = False):
entries = []
gf = pb.ghost_file_entry()
buf = f.read(4)
size, = struct.unpack('i', buf)
gf.ParseFromString(f.read(size))
g_entry = pb2dict.pb2dict(gf, pretty)
if gf.chunks:
entries.append(g_entry)
while True:
gc = pb.ghost_chunk_entry()
buf = f.read(4)
if buf == '':
break
size, = struct.unpack('i', buf)
gc.ParseFromString(f.read(size))
entry = pb2dict.pb2dict(gc, pretty)
if no_payload:
f.seek(gc.len, os.SEEK_CUR)
else:
entry['extra'] = base64.encodebytes(f.read(gc.len))
entries.append(entry)
else:
if no_payload:
f.seek(0, os.SEEK_END)
else:
g_entry['extra'] = base64.encodebytes(f.read())
entries.append(g_entry)
return entries
def saveWindowState(self):
""" Save:
* which tools are loaded
* geometry of the top level windows
* layout of dockwidgets and toolbars
"""
# Save tool list
tools = pyzo.toolManager.getLoadedTools()
pyzo.config.state.loadedTools = tools
# Store window geometry
geometry = self.saveGeometry()
try:
geometry = bytes(geometry) # PyQt4
except:
geometry = bytes().join(geometry) # PySide
geometry = base64.encodebytes(geometry).decode('ascii')
pyzo.config.state.windowGeometry = geometry
# Store window state
state = self.saveState()
try:
state = bytes(state) # PyQt4
except:
state = bytes().join(state) # PySide
state = base64.encodebytes(state).decode('ascii')
pyzo.config.state.windowState = state
def home(self, request):
app = self.app.materialize()
if app.main_window.widget_id == self.widget_id:
window = app.main_window
else:
try:
window = app.windows[self.widget_id]
except KeyError:
raise Exception("Unknown window")
sourcefile = os.path.join(os.path.dirname(__file__), 'libs.py')
py_compile.compile(sourcefile)
with open(os.path.join(
os.path.dirname(sourcefile),
'__pycache__/%s.cpython-34.pyc' % os.path.splitext(os.path.basename(sourcefile))[0]
), 'rb') as compiled:
toga = base64.encodebytes(compiled.read())
return render(request, 'toga/window.html', {
'toga': toga,
'bootstrap': base64.encodebytes(b'\xee\x0c\r\n00000000' + marshal.dumps(bootstrap.__code__)).strip(),
'app': app,
'window': window,
'callbacks': {
# 'sample': base64.encodebytes(b'\x08\x1c\xe8VU\x00\x00\x00' + marshal.dumps(sample.__code__)).strip()
'%s-%s' % (widget, message): base64.encodebytes(b'\xee\x0c\r\n00000000' + marshal.dumps(callback.__code__)).strip()
for (widget, message), callback in self.callbacks.items()
}
})
def hide_email(self):
""" base64 encodes all email addresses for use with wptool.js
reveal functions.
for spam protection.
(as long as the email-harvest-bot doesn't decode Base64)
"""
if not self.lines:
return False
final_output = []
for sline in self.lines:
mailtos = self.find_mailtos()
for mailto in mailtos:
b64_mailto = base64.encodebytes(mailto.encode('utf-8'))
sline = sline.replace(
mailto,
b64_mailto.decode('utf-8').replace('\n', ''))
emails = self.find_email_addresses()
for email in emails:
b64_addr = base64.encodebytes(email.encode('utf-8'))
sline = sline.replace(
email,
b64_addr.decode('utf-8').replace('\n', ''))
# add line (encoded or not)
final_output.append(sline)
self.lines = [l for l in final_output]
return True
def test_fail_get_upstream_ref(self):
""" Test when getting the file fails
"""
self.proxy.__default_branch__ = GithubProxy.DEFAULT_BRANCH.AUTO_SHA
self.github_api.sha_origin = "789456"
self.github_api.exist_file["path/to/some/file.xml"] = False
self.github_api.route_fail[
"http://localhost/repos/ponteineptique/dummy/git/refs/heads/uuid-1234"
] = "master_ref"
self.github_api.route_fail[
"http://localhost/repos/ponteineptique/dummy/git/refs/heads/master"
] = "master_ref"
result = self.makeRequest(
base64.encodebytes(b'Some content'),
make_secret(base64.encodebytes(b'Some content').decode("utf-8"), self.secret),
{
"author_name": "ponteineptique",
"date": "19/06/2016",
"logs": "Hard work of transcribing file",
"author_email": "*****@*****.**",
"branch": "uuid-1234"
}
)
data, http = response_read(result)
self.assertEqual(
data, {'message': 'The default branch from which to checkout is either not available or does not exist',
'status': 'error', "step": "make_ref"},
"Error message should be carried by ProxyError in Check Reference Failure"
)
self.assertEqual(http, 404, "Status code should be produced by ProxyError")
def _write_filedata(self, pathfrom, datatype='text', enc64=True):
'''Take the given file and create a series of SQL statements that create a table
and write the file data to it. If enc64 is True, use base64 encoding, otherwise
use hex encoding. datatype is the column datatype used for the table.
Returns teh (random) table name and series of SQL statements.'''
table = ''.join(random.choice(string.ascii_uppercase) for _ in range(16))
statements = []
statements.append('CREATE TABLE {} (data {})'.format(table, datatype))
default_chunk_len = 1024
with open(pathfrom, 'rb') as fd:
chunk_len = default_chunk_len if not self._se.has_message_size() else self._se.message_size()
log.debug('Reading {} bytes from {}.'.format(chunk_len, pathfrom))
chunk = fd.read(chunk_len)
if enc64:
data = base64.encodebytes(chunk).decode() # the decode() decodes the python byte string.
else:
data = binascii.b2a_hex(chunk).decode()
statements.append('INSERT INTO {} (data) VALUES(\'{}\')'.format(table, data))
while chunk:
chunk_len = default_chunk_len if not self._se.has_message_size() else self._se.message_size()
log.debug('Reading {} bytes from {}.'.format(chunk_len, pathfrom))
chunk = fd.read(chunk_len)
if chunk:
if enc64:
data = base64.encodebytes(chunk).decode()
else:
data = binascii.b2a_hex(chunk).decode()
statements.append('UPDATE {} SET data = concat(data,\'{}\')'.format(table, data))
return table, statements
def test_fail_update_file(self, logger):
""" Test when update the file fails
"""
self.github_api.sha_origin = "789456"
self.github_api.exist_file["path/to/some/file.xml"] = True
self.github_api.route_fail[
"http://localhost/repos/ponteineptique/dummy/contents/path/to/some/file.xml"
] = 500
result = self.makeRequest(
base64.encodebytes(b'Some content'),
make_secret(base64.encodebytes(b'Some content').decode("utf-8"), self.secret),
{
"author_name": "ponteineptique",
"date": "19/06/2016",
"logs": "Hard work of transcribing file",
"author_email": "*****@*****.**",
"branch": "uuid-1234"
}
)
data, http = response_read(result)
self.assertEqual(
data, {'message': 'Not Found', 'status': 'error', 'step': 'update'},
"Error message should be carried by ProxyError in Update File Failure"
)
self.assertEqual(http, 404, "Status code should be carried by ProxyError")
logger.assert_called_with("Request::PUT::/repos/ponteineptique/dummy/contents/path/to/some/file.xml", extra={
'response': mock.ANY,
'request': mock.ANY
})
def test_fail_get_file(self):
""" Test when getting the file fails
"""
self.github_api.sha_origin = "789456"
self.github_api.exist_file["path/to/some/file.xml"] = False
self.github_api.route_fail[
"http://localhost/repos/ponteineptique/dummy/contents/path/to/some/file.xml"
] = 501
result = self.makeRequest(
base64.encodebytes(b'Some content'),
make_secret(base64.encodebytes(b'Some content').decode("utf-8"), self.secret),
{
"author_name": "ponteineptique",
"date": "19/06/2016",
"logs": "Hard work of transcribing file",
"author_email": "*****@*****.**",
"branch": "uuid-1234"
}
)
data, http = response_read(result)
self.assertEqual(
data, {'message': 'Error checking a file', 'status': 'error', "step": "get"},
"Error message should be carried by ProxyError in Check Reference Failure"
)
self.assertEqual(http, 501, "Status code should be carried by ProxyError")
def test_fail_pull_request(self, logger):
""" Test when pull request the file fails
"""
self.github_api.sha_origin = "789456"
self.github_api.route_fail[
"http://localhost/repos/perseusDL/dummy/pulls"
] = 500
result = self.makeRequest(
base64.encodebytes(b'Some content'),
make_secret(base64.encodebytes(b'Some content').decode("utf-8"), self.secret),
{
"author_name": "ponteineptique",
"date": "19/06/2016",
"logs": "Hard work of transcribing file",
"author_email": "*****@*****.**",
"branch": "uuid-1234"
}
)
data, http = response_read(result)
self.assertEqual(
data, {'message': 'Not Found', 'status': 'error', 'step': 'pull_request'},
"Error message should be carried by ProxyError in Pull Request Failure"
)
self.assertEqual(http, 404, "Status code should be carried by ProxyError")
logger.assert_called_with("Not Found", extra={
'step': 'pull_request',
'context': {
'params': {
'base': 'master', 'body': '',
'head': 'ponteineptique:uuid-1234', 'title': '[Proxy] Hard work of transcribing file'
},
'uri': '/repos/perseusDL/dummy/pulls'
}
})
def home(self, request):
# app = self.app.materialize()
# if app.main_window.id == self.id:
# window = app.main_window
# else:
# try:
# window = app.windows[self.id]
# except KeyError:
# raise Exception("Unknown window")
sourcefile = os.path.join(os.path.dirname(__file__), 'render', '__init__.py')
fd, tempname = tempfile.mkstemp()
py_compile.compile(sourcefile, cfile=tempname, doraise=True)
with open(os.path.join(os.path.dirname(sourcefile), tempname), 'rb') as compiled:
toga = base64.encodebytes(compiled.read())
return render(request, 'toga/app.html', {
'toga': toga,
'bootstrap': base64.encodebytes(b'\xee\x0c\r\n00000000' + marshal.dumps(bootstrap.__code__)).strip(),
'window': self._impl,
'callbacks': {
# 'sample': base64.encodebytes(b'\x08\x1c\xe8VU\x00\x00\x00' + marshal.dumps(sample.__code__)).strip()
'%s-%s' % (widget, message): base64.encodebytes(b'\xee\x0c\r\n00000000' + marshal.dumps(callback.__code__)).strip()
for (widget, message), callback in self.callbacks.items()
}
})
def access_keys(url, identity, key_file, csr_file, crt_file, ca_crt_file):
csr = CryptoFunctions.load_csr(csr_file)
# Note the signature is only based on the CSR data - not the identity...
# We send the identity only to enable the server to identify who we are.
signature = CryptoFunctions.sign(CryptoFunctions.get_csr_bytes(csr), key_file)
# We need to also send a suitable header to indicate that we're sending JSON...
headers = {'Content-Type': 'application/json'}
# And note that we must use base64 encoding for the signature – since it is composed from an arbitrary bytestream
# when we receive the signature from the server we must reverse this process...
data = {'csr': base64.encodebytes(CryptoFunctions.get_csr_bytes(csr)).decode(), 'identity': identity,
'signature': base64.encodebytes(signature).decode()}
r = requests.post(url, data=json.dumps(data), headers=headers)
if r.status_code == 200:
# If we do have HTTP 200 – then we need to write the data we have to files...
with open(crt_file, 'wb') as f:
f.write(base64.decodebytes(r.json()['certificate'].encode()))
with open(ca_crt_file, 'wb') as f:
f.write(base64.decodebytes(r.json()['CA_certificate'].encode()))
return True
else:
return False
def encode_images(format_dict):
"""b64-encodes images in a displaypub format dict
Perhaps this should be handled in json_clean itself?
Parameters
----------
format_dict : dict
A dictionary of display data keyed by mime-type
Returns
-------
format_dict : dict
A copy of the same dictionary,
but binary image data ('image/png' or 'image/jpeg')
is base64-encoded.
"""
encoded = format_dict.copy()
pngdata = format_dict.get('image/png')
if isinstance(pngdata, bytes) and pngdata[:8] == PNG:
encoded['image/png'] = encodebytes(pngdata).decode('ascii')
jpegdata = format_dict.get('image/jpeg')
if isinstance(jpegdata, bytes) and jpegdata[:2] == JPEG:
encoded['image/jpeg'] = encodebytes(jpegdata).decode('ascii')
return encoded
def test_error_get_ref_failure(self):
""" Test that github api check ref fails does not break API
"""
self.github_api.sha_origin = "789456"
self.github_api.exist_file["path/to/some/file.xml"] = False
self.github_api.route_fail[
"http://localhost/repos/ponteineptique/dummy/git/refs/heads/uuid-1234"
] = 500
result = self.makeRequest(
base64.encodebytes(b'Some content'),
make_secret(base64.encodebytes(b'Some content').decode("utf-8"), self.secret),
{
"author_name": "ponteineptique",
"date": "19/06/2016",
"logs": "Hard work of transcribing file",
"auithor_email": "*****@*****.**",
"branch": "uuid-1234"
}
)
data, http = response_read(result)
self.assertEqual(
data, {'message': 'Bad credentials', 'status': 'error', 'step': 'get_ref'},
"Error message should be carried by ProxyError in Ref Failure"
)
self.assertEqual(http, 401, "Status code should be carried by ProxyError")
def __init__(self, **kwargs): # Basic Config Items
__app = kwargs.get('appli')
__id = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
__output = kwargs.get ('output', '/tmp/otecconfgen/' + __app + __id + '.conf')
__comments = kwargs.get ('comments', '1')
__virt = kwargs.get ('virt', 'vmware')
__format = kwargs.get ('outputformat', 'txt')
__web = kwargs.get('web', False)
# Build Common Objects
self.netConf = NETCONFIG(**(self.__filterdict__(self.__buildfilter__(self.__net_fileopt), **kwargs)))
self.sshConf = SSHCONFIG(**(self.__filterdict__(self.__buildfilter__(self.__ssh_fileopt), **kwargs)))
self.localeConf = LOCALECONFIG(**(self.__filterdict__(self.__buildfilter__(self.__locale_fileopt), **kwargs)))
# Add common objets to string used to fill config file
s = self.__headerwrite()
s += self.__sshconfwrite(__comments)
s += self.__netconfwrite(__virt, __comments)
s += self.__localeconfwrite(__comments)
if __app == 'oxe': # OXE
# Build OXE specific Objects
self.oxeConf = OXECONFIG(**(self.__filterdict__(self.__buildfilter__(self.__oxe_fileopt), **kwargs)))
# Add OXE specific objets to string used to fill config file
s += self.__oxeconfwrite(__comments)
elif (__app == 'oxems') or (__app == 'otes') or (__app == 'licsrv'): # OMS/OTES/LICSRV
# Build OXEMS/OTES/LICSRV specific Objects
self.adminConf = ADMINCONFIG(**(self.__filterdict__(self.__buildfilter__(self.__admin_fileopt), **kwargs)))
self.sysAdmConf = SYSADMCONFIG(**(self.__filterdict__(self.__buildfilter__(self.__sysadm_fileopt), **kwargs)))
# Add OXEMS/OTES/LICSRV specific objets to string used to fill config file
s += self.__adminconfwrite(__comments)
s += self.__sysadmconfwrite(__comments)
elif __app == 'ot': # OTMS
# Build OT specific Objects
self.adminConf = ADMINCONFIG(**(self.__filterdict__(self.__buildfilter__(self.__admin_fileopt), **kwargs)))
self.otmsConf = OTMSCONFIG(**(self.__filterdict__(self.__buildfilter__(self.__otms_fileopt), **kwargs)))
# Add OT specific objets to string used to fill config file
s += self.__adminconfwrite(__comments)
s += self.__otmsconfwrite(__comments)
s += self.__footerwrite()
# Writing Config File
pprint.pprint(s)
try:
# os.makedirs(os.path.split(__output)[0]) # To modify, problems if directory already exists
if __format == 'txt' or __virt == 'vmware':
if __output != 'stdout':
with open(__output, 'w') as fh: # Unix/Linux path //test default path as /tmp/otecconfgen/
fh.write(s)
print('Config File generated: {}'.format(__output))
else:
print(s)
elif __virt == 'amazon' and __format == 'b64':
if __output != 'stdout':
with open(__output, 'wb') as fh: # Unix/Linux path
fh.write(base64.encodebytes(bytes(s, encoding="UTF-8")))
print('Config File generated: {}'.format(__output))
else:
sys.stdout.buffer.write(base64.encodebytes(bytes(s, encoding="UTF-8")))
except:
print('failed to write config file '+ __output)
if __web == True:
webserver(os.path.split(__output)[0])
def load(self, f, pbuff):
d = {}
inq = f.read(pbuff.inq_len)
outq = f.read(pbuff.outq_len)
d['inq'] = base64.encodebytes(inq)
d['outq'] = base64.encodebytes(outq)
return d
def on_selection_modified(self,view):
self.output("on_selection_modified")
global last_select_time
if view.name() == "Lua Context":
if not protocol or not protocol.server:
print("not server")
return
if time.time()-(last_select_time or 0) <= 0.1:
print("time too close")
return
last_select_time = time.time()
sel = view.sel()[0]
line_no = view.rowcol(sel.a)[0]
if line_no < 0:
return
fullname = mng_context.getfullnamebyline(line_no)
print(fullname)
if not fullname or re.match(r"\[+",fullname):
return
mdict = mng_context.fullnamedict[fullname]
if mdict["value"].find("table") != -1 or mdict["value"].find("userdata") != -1:
protocol.property_get_context(base64.encodebytes(fullname.encode()).decode())
elif view.name() == "Lua expression":
if not protocol or not protocol.server:
return
if time.time()-(last_select_time or 0) <= 0.1:
return
last_select_time = time.time()
sel = view.sel()[0]
line_no = view.rowcol(sel.a)[0]
if line_no < 0:
return
fullname = mng_exp.getfullnamebyline(line_no)
print(fullname)
if not fullname:
return
mdict = mng_exp.fullnamedict[fullname]
if mdict["lv"] > 0:
if mdict["value"].find("table") != -1 or mdict["value"].find("userdata") != -1:
protocol.property_get_eval(base64.encodebytes(fullname.encode()).decode())
def encode_images(format_dict):
"""b64-encodes images in a displaypub format dict
Perhaps this should be handled in json_clean itself?
Parameters
----------
format_dict : dict
A dictionary of display data keyed by mime-type
Returns
-------
format_dict : dict
A copy of the same dictionary,
but binary image data ('image/png', 'image/jpeg' or 'application/pdf')
is base64-encoded.
"""
encoded = format_dict.copy()
pngdata = format_dict.get('image/png')
if isinstance(pngdata, bytes):
# make sure we don't double-encode
if not pngdata.startswith(PNG64):
pngdata = encodebytes(pngdata)
encoded['image/png'] = pngdata.decode('ascii')
jpegdata = format_dict.get('image/jpeg')
if isinstance(jpegdata, bytes):
# make sure we don't double-encode
if not jpegdata.startswith(JPEG64):
jpegdata = encodebytes(jpegdata)
encoded['image/jpeg'] = jpegdata.decode('ascii')
gifdata = format_dict.get('image/gif')
if isinstance(gifdata, bytes):
# make sure we don't double-encode
if not gifdata.startswith((GIF_64, GIF89_64)):
gifdata = encodebytes(gifdata)
encoded['image/gif'] = gifdata.decode('ascii')
pdfdata = format_dict.get('application/pdf')
if isinstance(pdfdata, bytes):
# make sure we don't double-encode
if not pdfdata.startswith(PDF64):
pdfdata = encodebytes(pdfdata)
encoded['application/pdf'] = pdfdata.decode('ascii')
return encoded
def pem_objects(draw):
"""
Strategy for generating ``pem`` objects.
"""
key = RSAPrivateKey((
b'-----BEGIN RSA PRIVATE KEY-----\n' +
encodebytes(draw(s.binary(min_size=1))) +
b'-----END RSA PRIVATE KEY-----\n'))
return [key] + [
Certificate((
b'-----BEGIN CERTIFICATE-----\n' +
encodebytes(cert) +
b'-----END CERTIFICATE-----\n'))
for cert in draw(s.lists(s.binary(min_size=1), min_size=1))]
def __authorization_header(self):
if self.config.has_client_credentials():
return b"Basic " + encodebytes(
self.config.client_id.encode('ascii') +
b":" +
self.config.client_secret.encode('ascii')
).replace(b"\n", b"").strip()
elif self.config.has_access_token():
return b"Bearer " + self.config.access_token.encode('ascii')
else:
return b"Basic " + encodebytes(
self.config.public_key.encode('ascii') +
b":" +
self.config.private_key.encode('ascii')
).replace(b"\n", b"").strip()
def _do_numeric(self, value):
idx = self._register(value)
if PY_VER > 2:
data = base64.encodebytes(gzip_string(numpy.ndarray.dumps(value)))
else:
data = base64.encodestring(gzip_string(numpy.ndarray.dumps(value)))
return dict(type='numeric', id=idx, data=data)
def send_mail(to, subject, text, files=[]):
assert type(files)==list
msg = MIMEMultipart()
msg['From'] = gmail_user
msg['To'] = to
msg['Subject'] = subject
msg.attach(MIMEText(text.encode('utf-8'), 'plain', 'UTF-8'))
for f in files:
fp = open(os.path.join(config.application_path,f),"rb")
part = MIMEBase('application', "octet-stream")
part.set_payload(encodebytes(fp.read()).decode())
fp.close()
part.add_header('Content-Transfer-Encoding', 'base64')
part.add_header('Content-Disposition', 'attachment; filename="%s"' % f)
msg.attach(part) # msg is an instance of MIMEMultipart()
mailServer = smtplib.SMTP("smtp.gmail.com", 587)
mailServer.ehlo()
mailServer.starttls()
mailServer.ehlo()
mailServer.login(gmail_user, gmail_pwd)
mailServer.sendmail(gmail_user, to, msg.as_string())
# Should be mailServer.quit(), but that crashes...
mailServer.close()
def generate_authorization(self, username, password):
password_manager = urllib.request.HTTPPasswordMgrWithDefaultRealm()
password_manager.add_password(None, self.url, username, password)
urllib.request.install_opener(
urllib.request.build_opener(urllib.request.HTTPBasicAuthHandler(password_manager)))
base64string = base64.encodebytes(('%s:%s' % (username, password)).encode()).decode()[:-1]
return "Basic %s" % base64string
def seguid(seq):
"""Returns the SEGUID (string) for a sequence (string or Seq object).
Given a nucleotide or amino-acid secuence (or any string),
returns the SEGUID string (A SEquence Globally Unique IDentifier).
seq type = str.
For more information about SEGUID, see:
http://bioinformatics.anl.gov/seguid/
DOI: 10.1002/pmic.200600032
"""
import hashlib
import base64
m = hashlib.sha1()
try:
# Assume it's a Seq object
seq = str(seq)
except AttributeError:
# Assume it's a string
pass
m.update(_as_bytes(seq.upper()))
try:
# For Python 3+
return base64.encodebytes(m.digest()).decode().replace("\n", "").rstrip("=")
except AttributeError:
pass
# For all other Pythons
return base64.b64encode(m.digest()).rstrip("=")
def make_cache(self):
from gramps.webapp.libdjango import DjangoInterface
if self.dji is None:
self.dji = DjangoInterface()
if isinstance(self, Person):
raw = self.dji.get_person(self)
elif isinstance(self, Family):
raw = self.dji.get_family(self)
elif isinstance(self, Place):
raw = self.dji.get_place(self)
elif isinstance(self, Media):
raw = self.dji.get_media(self)
elif isinstance(self, Source):
raw = self.dji.get_source(self)
elif isinstance(self, Citation):
raw = self.dji.get_citation(self)
elif isinstance(self, Repository):
raw = self.dji.get_repository(self)
elif isinstance(self, Note):
raw = self.dji.get_note(self)
elif isinstance(self, Event):
raw = self.dji.get_event(self)
elif isinstance(self, Tag):
raw = self.dji.get_tag(self)
else:
raise Exception("Don't know how to get raw '%s'" % type(item))
return str(base64.encodebytes(pickle.dumps(raw)), "utf-8")
def latex_to_png(s, encode=False, backend=None, wrap=False):
"""Render a LaTeX string to PNG.
Parameters
----------
s : text
The raw string containing valid inline LaTeX.
encode : bool, optional
Should the PNG data base64 encoded to make it JSON'able.
backend : {matplotlib, dvipng}
Backend for producing PNG data.
wrap : bool
If true, Automatically wrap `s` as a LaTeX equation.
None is returned when the backend cannot be used.
"""
s = cast_unicode(s)
allowed_backends = LaTeXTool.instance().backends
if backend is None:
backend = allowed_backends[0]
if backend not in allowed_backends:
return None
if backend == 'matplotlib':
f = latex_to_png_mpl
elif backend == 'dvipng':
f = latex_to_png_dvipng
else:
raise ValueError('No such backend {0}'.format(backend))
bin_data = f(s, wrap)
if encode and bin_data:
bin_data = encodebytes(bin_data)
return bin_data
def export_config(self, request):
"""
Exports the script file from a VPCS instance.
Mandatory request parameters:
- id (vm identifier)
Response parameters:
- script_file_base64 (script file base64 encoded)
- False if no configuration can be exported
"""
# validate the request
if not self.validate_request(request, VPCS_EXPORT_CONFIG_SCHEMA):
return
# get the instance
vpcs_instance = self.get_vpcs_instance(request["id"])
if not vpcs_instance:
return
response = {}
script_file_path = os.path.join(vpcs_instance.working_dir, vpcs_instance.script_file)
try:
with open(script_file_path, "rb") as f:
config = f.read()
response["script_file_base64"] = base64.encodebytes(config).decode("utf-8")
except OSError as e:
self.send_custom_error("unable to export the script file: {}".format(e))
return
if not response:
self.send_response(False)
else:
self.send_response(response)
def execute(self, method, params=None, progress=True):
"""
:param str method: remote method name
:param params: method kwargs
:param bool progress: use native progress bar support
:rtype str: return task id
"""
assert method and isinstance(method, str)
task_id = self._get_task_id()
data = {
'id': task_id,
'params': None,
'progress': progress,
}
if params:
data.update(
params=base64.encodebytes(pickle.dumps(params)))
cmd = self._new_cmd(
target=CommandTargetType.call_method, data=data, method=method)
self._send(cmd)
for cmd in self._read():
if cmd.target == CommandTargetType.problem:
raise ExecuteError(cmd.data)
elif cmd.target == CommandTargetType.ok:
return task_id
def represent_binary(self, data):
if hasattr(base64, 'encodebytes'):
data = base64.encodebytes(data).decode('ascii')
else:
data = base64.encodestring(data).decode('ascii')
return self.represent_scalar(u'tag:yaml.org,2002:binary', data,
style='|')
def __init__(self, loop):
self._loop = loop
handlers = [
# Static file handlers
(r'/(favicon.ico)', StaticFileHandler, {"path": ""}),
# File upload handler
(r'/upload', upload.StreamHandler, {"loop": self._loop}),
(r'/quote', QuoteHandler, {"loop": self._loop}),
(r'/provider_upload', UploadToProvider, {"loop": self._loop}),
# Web sockets
(r'/ws/upload_progress', UploadProgressWS),
(r'/ws/provider_upload_progress', ProviderUploadProgressWS),
(r'/ws/provider_request', ProvidersService),
# Page handlers
(r"/", MainHandler),
(r"/auth/create", AuthCreateHandler, {"loop": self._loop}),
(r"/auth/login", AuthLoginHandler, {"loop": self._loop}),
(r"/auth/logout", AuthLogoutHandler, {"loop": self._loop}),
]
settings = dict(
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
cookie_secret=base64.encodebytes(uuid.uuid4().bytes + uuid.uuid4().bytes),
login_url="/auth/login",
debug=True,
)
self._sessions = {}
self._web_socks = {}
super().__init__(handlers, **settings)
def get_url_file(url):
return 'tmp/' + base64.encodebytes(str.encode(url)).decode('utf-8').strip()
from base64 import encodebytes
c = int.from_bytes(b"Hello! Can you give me the flag, please? I would really appreciate it!", "big")
m = int.from_bytes(b"Quack! Quack!", "big")
p = 11 # just pick some arbitrary prime here and change it until something works
for i in range(1, 10000):
q = i * 2**559 + 1
if not isprime(q):
continue
try:
n = p*q
d = discrete_log(n, c, m)
e = mod_inverse(d,(p-1)*(q-1))
if pow(m,d,n)!=c: raise
if pow(c,e,n)!=m: raise
except:
print(f'i={i} failed')
continue
# Success! Let's construct the PEM file
print(f'i={i} succeeded')
print(f'd={d}')
seq = Sequence()
for i,x in enumerate([0, n, e, d, p, q, d%(p-1), d%(q-1), mod_inverse(q,p)]):
seq.setComponentByPosition(i, Integer(x))
b64 = encodebytes(encode(seq)).decode('ascii')
print(f'-----BEGIN RSA PRIVATE KEY-----\n{b64}-----END RSA PRIVATE KEY-----')
break
def mimecast_post( # noqa: MC0001
self,
url: str,
uri: str,
access_key: str,
secret_key: str,
app_id: str,
app_key: str,
data: dict,
meta: dict = None,
) -> dict:
"""
This method will send a properly formatted post request to the Mimecast server
:param url: The server URL
:param uri: The URI for the api call
:param access_key: The access key for the session
:param secret_key: The secret key for the session
:param app_id: The application ID for the app that will be logging in
:param app_key: The key associated with the app_id
:param data: The payload for the api call
:param meta: The meta information for request
:return:
"""
# Set full URL
url = url + uri
# Generate request header values
request_id = str(uuid.uuid4())
hdr_date = datetime.datetime.utcnow().strftime(
"%a, %d %b %Y %H:%M:%S") + " UTC"
# Decode secret key
encoded_secret_key = secret_key.encode()
bytes_secret_key = base64.b64decode(encoded_secret_key)
# Create hmac message
msg = ":".join([hdr_date, request_id, uri, app_key])
# Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
hmac_sha1 = hmac.new(bytes_secret_key,
msg.encode(),
digestmod=hashlib.sha1).digest()
# Use the HMAC SHA1 value to sign the hdrDate + ":" requestId + ":" + URI + ":" + appkey
sig = base64.encodebytes(hmac_sha1).rstrip()
sig = sig.decode("UTF-8")
# Create request headers
headers = {
"Authorization": "MC " + access_key + ":" + sig,
"x-mc-app-id": app_id,
"x-mc-date": hdr_date,
"x-mc-req-id": request_id,
"Content-Type": "application/json",
}
# build payload data
if data is not None:
payload = {"data": [data]}
else:
payload = {"data": []}
if meta is not None:
payload["meta"] = meta
try:
request = requests.post(url=url,
headers=headers,
data=str(payload))
except requests.exceptions.RequestException as e:
raise PluginException(data=e)
try:
response = request.json()
except json.decoder.JSONDecodeError:
self.logger.error(request.text)
raise PluginException(
cause="Unknown error.",
assistance=
"The Mimecast server did not respond correctly. Response not in JSON format. Response in logs.",
)
try:
# Check for expired key
if response["fail"]:
for errors in response["fail"]:
for codes in errors["errors"]:
if codes["code"] == "err_xdk_binding_expired":
raise PluginException(
cause="AccessKey has expired.",
assistance="Please provide a valid AccessKey.",
)
except KeyError:
self.logger.error(response)
raise PluginException(
cause="Unknown error.",
assistance=
"The Mimecast server did not respond correctly. Response in logs.",
)
try:
if response["meta"]["status"] != 200:
self.logger.error(response)
raise PluginException(
cause="Server request failed.",
assistance="Status code is {}, see log for details.".
format(response["meta"]["status"]),
data=response["fail"],
)
except KeyError:
self.logger.error(response)
raise PluginException(
cause="Unknown error.",
assistance=
"The Mimecast server did not respond correctly. Response in logs.",
)
return response
import pymongo
import json
import base64
#connect to mongodb
myclient = pymongo.MongoClient("mongodb://*****:*****@140.131.149.39:465")
mydb = myclient["menu"]
mycol = mydb["menu"]
#data
name = "炒面"
price = 70
date = 20200614
with open("upload.jpg", "rb") as image:
img_data = image.read()
img_string = base64.encodebytes(img_data)
#dict
mydict = {"name": name, "price": price, "date": date, "image": img_string}
#update if name = "炒面" & date = 20200614
x = mycol.update_one({
"name": name,
"date": date
}, {'$set': mydict},
upsert=True)
#x = mycol.insert_one(mydict)
def collect_events(helper, ew):
# Get variables
apikey = helper.get_arg('apikey') + ":"
interval = helper.get_arg('interval')
helper.get_input_type()
loglevel = helper.get_log_level()
proxy_settings = helper.get_proxy()
account = helper.get_arg('global_account')
username = account['username']
password = account['password']
helper.log_debug("Parameters correctly obtained")
# for each entry in KVstore not searched
service = client.connect(username=username, password=password)
helper.log_debug("Connection to splunk API OK")
kwargs_oneshot = {
"earliest_time": "2000-01-01T00:00:00.000-00:00",
"latest_time": "now",
"count": 40
}
searchquery_oneshot = "|inputlookup botdc_distinct_threat_indicators | stats values(enriched) as enriched, values(feed_type) as feed_type, min(event_time) as first_time_seen, sum(count) as count by threat_indicator | where NOT (isnull(enriched) OR match(enriched,\"1\"))| sort - count"
oneshotsearch_results = service.jobs.oneshot(searchquery_oneshot,
**kwargs_oneshot)
helper.log_debug("Splunk search executed properly")
# Get the results and display them using the ResultsReader
reader = splunk_results.ResultsReader(oneshotsearch_results)
for item in reader:
threat_indicator = item.get('threat_indicator')
if item.get('feed_type') == "IP Address":
threat_indicator_type = "ip"
elif item.get('feed_type') == "FQDN":
threat_indicator_type = "host"
# Do a Dossier search
helper.log_info("Start perform an Infoblox Dossier Search for " +
threat_indicator)
url = "https://platform.activetrust.net:8000/api/services/intel/lookup/indicator/"
url = url + threat_indicator_type
url = url + "?value=" + threat_indicator + "&wait=true"
method = "GET"
auth = base64.encodebytes(
('%s:' % (apikey)).encode('utf8')).decode('utf8').replace(
'\n', '')
headers = {
'Authorization': 'Basic %s' % auth,
'Content-Type': 'application/x-www-form-urlencoded',
'User-Agent':
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36',
'Cache-Control': 'no-cache'
}
if not proxy_settings:
response = requests.get(url,
headers=headers,
cookies=None,
verify=True,
timeout=(600, 600),
stream=True)
else:
response = requests.get(url,
headers=headers,
cookies=None,
verify=True,
timeout=(600, 600),
proxies=proxy_settings,
stream=True)
if response.encoding is None:
response.encoding = 'utf-8'
if response.text:
try:
r_json = json.loads(response.text)
except:
raise Exception("Unable to load into a json format")
data = json.dumps(r_json)
data = data.replace("\"host\":", "\"hostname\":")
data = data.replace("\"source\":", "\"src\":")
helper.log_debug("data: " + data)
data = json.loads(data)
if "results" in data.keys():
for result in data["results"]:
if "params" in result.keys():
if "src" in result["params"].keys():
if "data" in result.keys():
if result["params"]["src"] == "atp":
for threat in result["data"]["threat"]:
threat[
"threat_indicator"] = threat_indicator
threat[
"threat_indicator_type"] = threat_indicator_type
result_data = json.dumps(threat)
event = helper.new_event(
source=result["params"]["src"],
index=helper.get_output_index(),
sourcetype=helper.get_sourcetype(),
data=result_data)
ew.write_event(event)
elif result["params"][
"src"] == "malware_analysis":
if "details" in result["data"].keys():
if "detected_communicating_samples" in result[
"data"]["details"].keys():
for malware_analysis in result[
"data"]["details"][
"detected_communicating_samples"]:
malware_analysis[
"threat_indicator"] = threat_indicator
malware_analysis[
"threat_indicator_type"] = threat_indicator_type
malware_analysis[
"threat_indicator_type"] = "detected_communicating_samples"
result_data = json.dumps(
malware_analysis)
event = helper.new_event(
source=result["params"]
["src"],
index=helper.
get_output_index(),
sourcetype=helper.
get_sourcetype(),
data=result_data)
ew.write_event(event)
if "detected_downloaded_samples" in result[
"data"]["details"].keys():
for malware_analysis in result[
"data"]["details"][
"detected_downloaded_samples"]:
malware_analysis[
"threat_indicator"] = threat_indicator
malware_analysis[
"threat_indicator_type"] = threat_indicator_type
malware_analysis[
"threat_indicator_type"] = "detected_downloaded_samples"
result_data = json.dumps(
malware_analysis)
event = helper.new_event(
source=result["params"]
["src"],
index=helper.
get_output_index(),
sourcetype=helper.
get_sourcetype(),
data=result_data)
ew.write_event(event)
if "detected_urls" in result["data"][
"details"].keys():
for malware_analysis in result[
"data"]["details"][
"detected_urls"]:
malware_analysis[
"threat_indicator"] = threat_indicator
malware_analysis[
"threat_indicator_type"] = threat_indicator_type
malware_analysis[
"threat_indicator_type"] = "detected_urls"
result_data = json.dumps(
malware_analysis)
event = helper.new_event(
source=result["params"]
["src"],
index=helper.
get_output_index(),
sourcetype=helper.
get_sourcetype(),
data=result_data)
ew.write_event(event)
elif result["params"]["src"] == "pdns":
for pdns in result["data"]["items"]:
pdns[
"threat_indicator"] = threat_indicator
pdns[
"threat_indicator_type"] = threat_indicator_type
result_data = json.dumps(pdns)
event = helper.new_event(
source=result["params"]["src"],
index=helper.get_output_index(),
sourcetype=helper.get_sourcetype(),
data=result_data)
ew.write_event(event)
else:
result["data"][
"threat_indicator"] = threat_indicator
result["data"][
"threat_indicator_type"] = threat_indicator_type
result_data = json.dumps(result["data"])
event = helper.new_event(
source=result["params"]["src"],
index=helper.get_output_index(),
sourcetype=helper.get_sourcetype(),
data=result_data)
ew.write_event(event)
searchquery_oneshot_update = "|makeresults | eval threat_indicator=\"" + threat_indicator + "\" | eval enriched=1 | outputlookup botdc_distinct_threat_indicators append=true createinapp=true"
oneshotsearch_update_results = service.jobs.oneshot(
searchquery_oneshot_update,
**kwargs_oneshot)
helper.log_info("Completed an Infoblox Dossier Search for " +
threat_indicator)
def get_kube_config_base64(self):
file_name = self.fetch_config()
with open(file_name) as f:
text = f.read()
return base64.encodebytes(bytes(text, 'utf-8')).decode().replace(
'\n', '')
def _create_sec_websocket_key():
uid = uuid.uuid4()
return base64.encodebytes(uid.bytes).strip().decode("utf-8")
def do_check(request):
# Check if defined any Host HTTP header.
if menu.options.host and settings.HOST_INJECTION == None:
request.add_header(settings.HOST, menu.options.host)
# Check if defined any User-Agent HTTP header.
if menu.options.agent:
request.add_header(settings.USER_AGENT, menu.options.agent)
# Check if defined any Referer HTTP header.
if menu.options.referer and settings.REFERER_INJECTION == None:
request.add_header(settings.REFERER, menu.options.referer)
# Check if defined any Cookie HTTP header.
if menu.options.cookie and settings.COOKIE_INJECTION == False:
request.add_header(settings.COOKIE, menu.options.cookie)
if not checks.get_header(request.headers, settings.HTTP_ACCEPT_HEADER):
request.add_header(settings.HTTP_ACCEPT_HEADER,
settings.HTTP_ACCEPT_HEADER_VALUE)
# The MIME media type for JSON.
if menu.options.data:
if re.search(settings.JSON_RECOGNITION_REGEX, menu.options.data) or \
re.search(settings.JSON_LIKE_RECOGNITION_REGEX, menu.options.data):
request.add_header("Content-Type", "application/json")
# Appends a fake HTTP header 'X-Forwarded-For'
if settings.TAMPER_SCRIPTS["xforwardedfor"]:
from src.core.tamper import xforwardedfor
xforwardedfor.tamper(request)
# Default value for "Accept-Encoding" HTTP header
request.add_header('Accept-Encoding',
settings.HTTP_ACCEPT_ENCODING_HEADER_VALUE)
# Check if defined any HTTP Authentication credentials.
# HTTP Authentication: Basic / Digest Access Authentication.
if menu.options.auth_cred and menu.options.auth_type:
try:
settings.SUPPORTED_HTTP_AUTH_TYPES.index(menu.options.auth_type)
if menu.options.auth_type == "basic":
b64_string = encodebytes(
menu.options.auth_cred.encode(
settings.UNICODE_ENCODING)).decode().replace('\n', '')
request.add_header("Authorization", "Basic " + b64_string + "")
elif menu.options.auth_type == "digest":
try:
url = menu.options.url
try:
response = _urllib.request.urlopen(
url, timeout=settings.TIMEOUT)
except _urllib.error.HTTPError as e:
try:
authline = e.headers.get('www-authenticate', '')
authobj = re.match('''(\w*)\s+realm=(.*),''',
authline).groups()
realm = authobj[1].split(',')[0].replace("\"", "")
user_pass_pair = menu.options.auth_cred.split(":")
username = user_pass_pair[0]
password = user_pass_pair[1]
authhandler = _urllib.request.HTTPDigestAuthHandler(
)
authhandler.add_password(realm, url, username,
password)
opener = _urllib.request.build_opener(authhandler)
_urllib.request.install_opener(opener)
result = _urllib.request.urlopen(
url, timeout=settings.TIMEOUT)
except AttributeError:
pass
except _urllib.error.HTTPError as e:
pass
except ValueError:
err_msg = "Unsupported / Invalid HTTP authentication type '" + menu.options.auth_type + "'."
err_msg += " Try basic or digest HTTP authentication type."
print(settings.print_critical_msg(err_msg))
raise SystemExit()
else:
pass
# Check if defined any extra HTTP headers.
if menu.options.headers or menu.options.header or len(
settings.RAW_HTTP_HEADERS) >= 1:
if len(settings.RAW_HTTP_HEADERS) >= 1:
menu.options.headers = settings.RAW_HTTP_HEADERS
# Do replacement with the 'INJECT_HERE' tag, if the wildcard char is provided.
if menu.options.headers:
menu.options.headers = checks.wildcard_character(
menu.options.headers)
extra_headers = menu.options.headers
else:
menu.options.header = checks.wildcard_character(
menu.options.header)
extra_headers = menu.options.header
extra_headers = extra_headers.replace(":", ": ")
if ": //" in extra_headers:
extra_headers = extra_headers.replace(": //", "://")
if "\\n" in extra_headers:
extra_headers = extra_headers.split("\\n")
# Remove empty strings and "Content-Length"
extra_headers = [
x for x in extra_headers if "Content-Length" not in x
]
else:
tmp_extra_header = []
tmp_extra_header.append(extra_headers)
extra_headers = tmp_extra_header
# Remove empty strings
extra_headers = [x for x in extra_headers if x]
for extra_header in extra_headers:
try:
# Extra HTTP Header name
http_header_name = extra_header.split(':', 1)[0]
http_header_name = ''.join(http_header_name).strip()
# Extra HTTP Header value
http_header_value = extra_header.split(':', 1)[1]
http_header_value = ''.join(http_header_value).strip().replace(
": ", ":")
# Check if it is a custom header injection.
if settings.CUSTOM_HEADER_INJECTION == False and \
settings.INJECT_TAG in http_header_value:
settings.CUSTOM_HEADER_INJECTION = True
settings.CUSTOM_HEADER_NAME = http_header_name
# Add HTTP Header name / value to the HTTP request
if http_header_name not in [
settings.HOST, settings.USER_AGENT, settings.REFERER,
settings.COOKIE
]:
request.add_header(
http_header_name.encode(settings.UNICODE_ENCODING),
http_header_value.encode(settings.UNICODE_ENCODING))
except:
pass
# eof
def on_task_output(self, task, config):
"""Add torrents to deluge at exit."""
config = self.prepare_config(config)
client = self.setup_client(config)
# don't add when learning
if task.options.learn:
return
if not config['enabled'] or not (task.accepted or task.options.test):
return
try:
client.connect()
except ConnectionError as exc:
raise plugin.PluginError(
f'Error connecting to deluge daemon: {exc}', logger=logger
) from exc
if task.options.test:
logger.debug('Test connection to deluge daemon successful.')
client.disconnect()
return
# loop through entries to get a list of labels to add
labels = set()
for entry in task.accepted:
label = entry.get('label') or config.get('label')
if label and label.lower() != 'no label':
try:
label = self._format_label(entry.render(label))
logger.debug('Rendered label: {}', label)
except RenderError as e:
logger.error('Error rendering label `{}`: {}', label, e)
continue
labels.add(label)
if labels:
# Make sure the label plugin is available and enabled, then add appropriate labels
enabled_plugins = client.call('core.get_enabled_plugins')
label_enabled = 'Label' in enabled_plugins
if not label_enabled:
available_plugins = client.call('core.get_available_plugins')
if 'Label' in available_plugins:
logger.debug('Enabling label plugin in deluge')
label_enabled = client.call('core.enable_plugin', 'Label')
else:
logger.error('Label plugin is not installed in deluge')
if label_enabled:
d_labels = client.call('label.get_labels')
for label in labels:
if label not in d_labels:
logger.debug('Adding the label `{}` to deluge', label)
client.call('label.add', label)
# add the torrents
torrent_ids = client.call('core.get_session_state')
for entry in task.accepted:
# Generate deluge options dict for torrent add
add_opts = {}
try:
path = entry.render(entry.get('path') or config['path'])
if path:
add_opts['download_location'] = pathscrub(os.path.expanduser(path))
except RenderError as e:
logger.error('Could not set path for {}: {}', entry['title'], e)
for fopt, dopt in self.options.items():
value = entry.get(fopt, config.get(fopt))
if value is not None:
add_opts[dopt] = value
if fopt == 'ratio':
add_opts['stop_at_ratio'] = True
# Make another set of options, that get set after the torrent has been added
modify_opts = {
'queue_to_top': entry.get('queue_to_top', config.get('queue_to_top')),
'main_file_only': entry.get('main_file_only', config.get('main_file_only', False)),
'main_file_ratio': entry.get('main_file_ratio', config.get('main_file_ratio')),
'hide_sparse_files': entry.get(
'hide_sparse_files', config.get('hide_sparse_files', True)
),
'keep_subs': entry.get('keep_subs', config.get('keep_subs', True)),
'container_directory': config.get('container_directory', ''),
'force_recheck': entry.get('force_recheck', config.get('force_recheck')),
}
try:
label = entry.render(entry.get('label') or config['label'])
modify_opts['label'] = self._format_label(label)
except RenderError as e:
logger.error('Error setting label for `{}`: {}', entry['title'], e)
try:
move_completed_path = entry.render(
entry.get('move_completed_path') or config['move_completed_path']
)
modify_opts['move_completed_path'] = pathscrub(
os.path.expanduser(move_completed_path)
)
except RenderError as e:
logger.error('Error setting move_completed_path for {}: {}', entry['title'], e)
try:
content_filename = entry.get('content_filename') or config.get(
'content_filename', ''
)
modify_opts['content_filename'] = pathscrub(entry.render(content_filename))
except RenderError as e:
logger.error('Error setting content_filename for {}: {}', entry['title'], e)
torrent_id = entry.get('deluge_id') or entry.get('torrent_info_hash')
torrent_id = torrent_id and torrent_id.lower()
if torrent_id in torrent_ids:
logger.info('{} is already loaded in deluge, setting options', entry['title'])
# Entry has a deluge id, verify the torrent is still in the deluge session and apply options
# Since this is already loaded in deluge, we may also need to change the path
modify_opts['path'] = add_opts.pop('download_location', None)
client.call('core.set_torrent_options', [torrent_id], add_opts)
self._set_torrent_options(client, torrent_id, entry, modify_opts)
elif config['action'] != 'add':
logger.warning(
'Cannot {} {}, because it is not loaded in deluge.',
config['action'],
entry['title'],
)
continue
else:
magnet, filedump = None, None
if entry.get('url', '').startswith('magnet:'):
magnet = entry['url']
else:
if not os.path.exists(entry['file']):
entry.fail('Downloaded temp file \'%s\' doesn\'t exist!' % entry['file'])
del entry['file']
return
with open(entry['file'], 'rb') as f:
filedump = base64.encodebytes(f.read())
logger.verbose('Adding {} to deluge.', entry['title'])
added_torrent = None
if magnet:
try:
added_torrent = client.call('core.add_torrent_magnet', magnet, add_opts)
except Exception as exc:
logger.error('{} was not added to deluge! {}', entry['title'], exc)
logger.opt(exception=True).debug('Error adding magnet:')
entry.fail('Could not be added to deluge')
else:
if config.get('magnetization_timeout'):
timeout = config['magnetization_timeout']
logger.verbose(
'Waiting {} seconds for "{}" to magnetize', timeout, entry['title']
)
for _ in range(timeout):
time.sleep(1)
try:
status = client.call(
'core.get_torrent_status', added_torrent, ['files']
)
except Exception as err:
logger.error('wait_for_metadata Error: {}', err)
break
if status.get('files'):
logger.info('"{}" magnetization successful', entry['title'])
break
else:
logger.warning(
'"{}" did not magnetize before the timeout elapsed, '
'file list unavailable for processing.',
entry['title'],
)
else:
try:
added_torrent = client.call(
'core.add_torrent_file', entry['title'], filedump, add_opts
)
except Exception as e:
logger.error('{} was not added to deluge! {}', entry['title'], e)
entry.fail('Could not be added to deluge')
if not added_torrent:
logger.error('There was an error adding {} to deluge.', entry['title'])
else:
logger.info('{} successfully added to deluge.', entry['title'])
self._set_torrent_options(client, added_torrent, entry, modify_opts)
if config['action'] in ('remove', 'purge'):
client.call('core.remove_torrent', torrent_id, config['action'] == 'purge')
logger.info('{} removed from deluge.', entry['title'])
elif config['action'] == 'pause':
client.call('core.pause_torrent', [torrent_id])
logger.info('{} has been paused in deluge.', entry['title'])
elif config['action'] == 'resume':
client.call('core.resume_torrent', [torrent_id])
logger.info('{} has been resumed in deluge.', entry['title'])
client.disconnect()
sorted_contests = []
for c in contests:
sorted_contests.append(c[0])
contest_id = max(sorted_contests)
decfilename = "/var/rc24/File-Maker/Channels/Check_Mii_Out_Channel/decfiles/contests/{}/con_detail1.dec".format(
str(contest_id))
if path.exists(decfilename):
boundary2 = "----=_CMOC_Contest_Icon"
with open(decfilename, "rb") as f:
contest_icon = str(
encodebytes(f.read()).replace(b"\n", b"\r\n").decode("utf-8"))
message += (
boundary + "\r\n" + "Content-Type: text/plain\r\n\r\n" +
"Date: {}\r\n".format(date) + "From: [email protected]\r\n" +
"To: [email protected]\r\n" +
"Message-ID: <[email protected]@rc24.xyz>\r\n"
+ "Subject: \r\n" + "MIME-Version: 1.0\r\n" +
'Content-Type: multipart/mixed; boundary="{}"\r\n'.format(boundary2) +
"Content-Transfer-Encoding: base64\r\n" +
"X-Wii-AppID: 3-48415041-3031\r\n" + "X-Wii-Tag: 00000001\r\n" +
"X-Wii-Cmd: 00080001\r\n\r\n" + "--" + boundary2 + "\r\n" +
"Content-Type: application/octet-stream;\r\n" +
" name=storage.bin\r\n" + "Content-Transfer-Encoding: base64\r\n" +
"Content-Disposition: attachment;\r\n" +
" filename=storage.bin\r\n\r\n" + contest_icon + "\r\n\r\n" + "--" +
def enc(text, description):
return str(
encodebytes(text.format(description).encode("utf-16be")).replace(
b"\n", b"\r\n").decode("utf-8"))
def get_image(image_path):
img = Image.open(image_path, mode='r')
img_byte_arr = BytesIO()
img.save(img_byte_arr, format='PNG')
encoded_img = base64.encodebytes(img_byte_arr.getvalue()).decode('ascii')
return encoded_img
if (os.path.isfile(pass_file)):
wordlist = open(pass_file, encoding='latin-1')
else:
print("Error:\n\t Wordlist not found!\n")
exit(1)
# Login Page URL
ip_address = "http://172.26.0.2:80"
port = 80
words = wordlist.readlines()
for user in ["admin"]:
for passwd in words:
user_pass = "******" % (user, passwd.strip())
base64_value = base64.encodebytes(user_pass.encode()).split()[0]
base64_value = base64_value.decode()
hdr = {'Authorization': "Basic %s" % base64_value}
print(hdr)
try:
res = requests.get(ip_address, headers=hdr)
except:
print("No such URL")
exit(1)
if res.status_code == 200:
print("%s CRACKED: " % res.status_code + user + ":" + passwd)
exit(0)
elif res.status_code == 401:
print("FAILED %s: %s:%s" % (res.status_code, user, passwd))
else:
def encode_audio(self, file_path):
f = open(file_path, 'rb')
contents = f.read()
return base64.encodebytes(contents)
def write_secret(filename, secret):
encoded_secret = base64.encodebytes(bytes(secret, encoding='utf-8'))
with open(filename, 'wb') as new_secret:
new_secret.write(encoded_secret)
def dump_bytes(self, value, write):
write("<value><base64>\n")
encoded = base64.encodebytes(value)
write(encoded.decode('ascii'))
write("</base64></value>\n")
def csp(request):
return {'csp_nonce': base64.encodebytes(os.urandom(32)).decode().rstrip()}
def genePwd(pwd, salt):
m = hashlib.md5()
str = "%s-%s" % (base64.encodebytes(pwd.encode("utf-8")), salt)
m.update(str.encode("utf-8"))
return m.hexdigest()
def encode(self, input, final=False):
assert self.errors == 'strict'
return base64.encodebytes(input)
def btoa(str):
# timestamp = str(int(time.time()))
# a = '8808'
b = base64.encodebytes(str.encode("utf8"))
tokens = b.decode("utf8").strip()
return tokens
def encode(self, out):
out.write("<value><base64>\n")
encoded = base64.encodebytes(self.data)
out.write(encoded.decode('ascii'))
out.write("</base64></value>\n")
print('NEW_keydatabytes: ' + privatekeypaket)
newCheckSum = printDSAKeyPaket(keydatabytes)
keydatabytes[len(keydatabytes) - 1] = newCheckSum.to_bytes(2,
byteorder='big')[1]
keydatabytes[len(keydatabytes) - 2] = newCheckSum.to_bytes(2,
byteorder='big')[0]
printDSAKeyPaket(keydatabytes)
print('---')
print(binascii.hexlify(keydatabytes))
print('---')
print(binascii.hexlify(keypackets[0].data))
print('---')
print(binascii.hexlify(keydata.data))
keydata.data = keydata.data.replace(keypackets[0].data, keydatabytes)
print('---')
print(binascii.hexlify(keydata.data))
print(b64encode(keydata.data))
print(standard_b64encode(keydata.data))
print(encodebytes(keydata.data))
# writes manipulated pakets to file
writePrivateKeyASC("bob-dsa-private-keyasc-AUTOgenerated.sec", keydata.data)
print("done")
def __init__(self,w):
#Create the frames to pack individual frames inside the GUI for better organization
self.myTOPFrame = Frame(w)
self.myTOPFrame.pack(side=TOP)
self.myLeftFrame = Frame(w)
self.myLeftFrame.pack(side=LEFT)
#Create frames within the main frames above for organization
self.left0 = Frame(self.myLeftFrame)
self.left0.pack()
self.left1 = Frame(self.myLeftFrame)
self.left1.pack()
self.left2 = Frame(self.myLeftFrame)
self.left2.pack()
self.left3 = Frame(self.myLeftFrame)
self.left3.pack()
#Get GT logo, no real value, just thought it looked nice
url = "http://w4aql.gtorg.gatech.edu/images/buzzzap.gif"
response = urllib.request.urlopen(url)
myPicture = response.read()
import base64
b64_data = base64.encodebytes(myPicture)
self.mainImage = PhotoImage(data=b64_data)
#These values can be used throughout the code because they are global
self.totalOrders = 0
self.kValue = .999
self.switch = True
self.iteration = 0
#Image
self.photoLabel = Label(self.myTOPFrame, image=self.mainImage)
self.photoLabel.grid(row=0, column=0)
#Load Buttons
self.loadFirstInputCSVFile = Button(self.left1, width=78, text="Load Weekly Demand", command=self.loadFirstCSVclicked).grid(row=0, column=0, sticky=E+W)
self.loadSecondInputCSVFile = Button(self.left1, width=78, text="Load Master Data", command=self.loadSecondCSVclicked).grid(row=1, column=0, sticky=E+W)
#Week Number Variable and Week Number Entry
self.entryWeekNumber = StringVar()
self.weekNumber = Label(self.left2, text="Week Number:").grid(row=0, column=0, sticky=E)
self.weekNumber = Entry(self.left2, width=60, state=NORMAL, text=self.entryWeekNumber).grid(row=0, column=1, sticky=W)
#Allocation Variable and Allocation Entry
self.entryAllocationAmount = StringVar()
self.allocationAmount = Label(self.left2, text="Allocation Amount:").grid(row=1, column=0, sticky=E)
self.allocationAmount = Entry(self.left2, width=60, state=NORMAL, text=self.entryAllocationAmount).grid(row=1, column=1, sticky=W)
#I thought it would be beneficial to show the file location
self.inputFirstCSVFile = Label(self.left2, text="Weekly Demand File Path:").grid(row=2, column=0, sticky=E)
self.inputFirstCSVFileEntry = Entry(self.left2, width=60, state="readonly")
self.inputFirstCSVFileEntry.grid(row=2, column=1)
#File location
self.inputSecondCSVFile= Label(self.left2, text ="Master Data File Path:").grid(row=3, column=0, sticky=E)
self.inputSecondCSVFileEntry=Entry(self.left2, width =60, state="readonly")
self.inputSecondCSVFileEntry.grid(row=3, column=1)
#Output file location, needs to be saved as file.csv
self.outputCSVFile = Label(self.left2, text="DV Model File Path:").grid(row=5, column=0, sticky=E)
self.outputCSVFileEntry = Entry(self.left2, width=60, state="readonly")
self.outputCSVFileEntry.grid(row=5, column=1)
self.outputCSVFile1 = Label(self.left2, text="DOS Model File Path:").grid(row=6, column=0, sticky=E)
self.outputCSVFileEntry1 = Entry(self.left2, width=60, state="readonly")
self.outputCSVFileEntry1.grid(row=6, column=1)
#After all the data has been entered, click process button
self.process_Data = Button(self.left3, text="Process Data", width=78, state="disabled", command=self.processDataButtonClicked)
self.process_Data.grid(row=0, column=0, sticky=E+W)
self.convertData = 0
def base64_encode(input, errors='strict'):
assert errors == 'strict'
return (base64.encodebytes(input), len(input))
def get_url(address, user, password):
request = Request(address)
base64string = base64.encodebytes(ensure_binary('%s:%s' % (user, password))).replace(b'\n', b'')
request.add_header("Authorization", "Basic %s" % ensure_str(base64string))
return urlopen(request)
def format_basicAuth(client_id, client_secret):
return (base64.encodebytes(('%s:%s' % (client_id,client_secret)).encode('utf-8')).decode().strip()).replace('\n', '')
def _binary_value_prep(value: bytes) -> str:
return base64.encodebytes(value).decode()
def get_cmd(self):
cmd = LineBreakpoint.get_cmd(self)
cmd += " -- " + base64.encodebytes(
self.condition.encode("UTF-8")).decode("UTF-8")
return cmd
def predict_card():
print("predict_card")
if request.method == 'POST':
print("predict_card")
try:
print("predict_card")
try:
file = request.files['file']
image_file = file.read()
image = cv2.imdecode(np.frombuffer(image_file, dtype=np.uint8),
-1)
except Exception as e:
print(e)
logger.error(str(e))
logger.error(str(traceback.print_exc()))
return_result = {'code': '1001', 'status': rcode.code_1001}
now = datetime.now()
date_time = now.strftime("%m_%d_%Y_%H_%M_%S")
image_path = os.path.join(UPLOAD_FOLDER, date_time + '.jpg')
print("image_path: ", image_path)
cv2.imwrite(image_path, image)
url = 'http://service.aiclub.cs.uit.edu.vn/gpu150/paddle_ocr/predict'
is_success, buffer = cv2.imencode('.png', image)
f = io.BytesIO(buffer)
image_encoded = base64.encodebytes(f.getvalue()).decode('utf-8')
####################################
start_time = time.time()
data = {"images": [image_encoded]}
headers = {'Content-type': 'application/json'}
data_json = json.dumps(data)
response = requests.post(url, data=data_json, headers=headers)
response = response.json()
data = response['data']
predict = data['predict'][0]
# image = cv2.imread(image_path)
# image = cv2.resize(image, (500, 500))
image, list_info_bankcard, list_flag_bbox = draw_bankcard(
image, predict)
bank, name, type_card, valid_from, good_thru, number = get_info_card(
image, list_info_bankcard, list_flag_bbox)
image_path_recog = os.path.join(RECOG_FOLDER, date_time + '.jpg')
cv2.imwrite(image_path_recog, image)
print("bank: ", bank)
print("name: ", name)
print("number: ", number)
print("type_card: ", type_card)
print("valid_from: ", valid_from)
print("good_thru: ", good_thru)
return_result = {
'recog_path': image_path_recog,
'path': image_path,
'bank': bank,
'name': name,
'type_card': type_card,
'valid_from': valid_from,
'good_thru': good_thru,
'number': number
}
with open(os.path.join(RESULT_FOLDER, date_time + '.json'),
'w') as f:
json.dump(return_result, f)
except Exception as e:
print("ERROR: ", e)
logger.error(str(e))
logger.error(str(traceback.print_exc()))
return_result = {'code': '1009', 'status': rcode.code_1001}
finally:
return jsonify(return_result)
def _l10n_it_post_invoices_step_1(self, invoices):
''' Send the invoices to the proxy.
'''
to_return = {}
to_send = {}
for invoice in invoices:
xml = b"<?xml version='1.0' encoding='UTF-8'?>" + invoice._export_as_xml(
)
filename = self._l10n_it_edi_generate_electronic_invoice_filename(
invoice)
attachment = self.env['ir.attachment'].create({
'name':
filename,
'res_id':
invoice.id,
'res_model':
invoice._name,
'datas':
base64.encodebytes(xml),
'description':
_('Italian invoice: %s', invoice.move_type),
'type':
'binary',
})
invoice.l10n_it_edi_attachment_id = attachment
if invoice._is_commercial_partner_pa():
invoice.message_post(body=(_(
"Invoices for PA are not managed by Odoo, you can download the document and send it on your own."
)))
to_return[invoice] = {'attachment': attachment}
else:
to_send[filename] = {
'invoice': invoice,
'data': {
'filename': filename,
'xml': base64.b64encode(xml).decode()
}
}
company = invoices.company_id
proxy_user = self._get_proxy_user(company)
if not proxy_user: # proxy user should exist, because there is a check in _check_move_configuration
return {
invoice: {
'error':
_("You must accept the terms and conditions in the settings to use FatturaPA."
),
'blocking_level':
'error'
}
for invoice in invoices
}
if proxy_user._get_demo_state() == 'demo':
responses = {
filename: {
'id_transaction': 'demo'
}
for invoice in invoices
}
else:
try:
responses = self._l10n_it_edi_upload(
[i['data'] for i in to_send.values()], proxy_user)
except AccountEdiProxyError as e:
return {
invoice: {
'error': e.message,
'blocking_level': 'error'
}
for invoice in invoices
}
for filename, response in responses.items():
invoice = to_send[filename]['invoice']
to_return[invoice] = response
if 'id_transaction' in response:
invoice.l10n_it_edi_transaction = response['id_transaction']
to_return[invoice].update({
'error':
_('The invoice was successfully transmitted to the Public Administration and we are waiting for confirmation.'
),
'blocking_level':
'info',
})
return to_return
