def test_b2a_hqx_a2b_hqx_round_trip(self, payload):
# assuming len(payload) as 3, since it throws exception: binascii.Incomplete, when length is not a multiple of 3
if len(payload) % 3:
with self.assertRaises(binascii.Incomplete):
x = binascii.b2a_hqx(payload)
binascii.a2b_hqx(x)
payload += b"\x00" * (-len(payload) % 3)
x = binascii.b2a_hqx(payload)
res, _ = binascii.a2b_hqx(x)
self.assertEqual(payload, res)
def args_serializer(self, *args, **kwargs):
args_bytes = pickle.dumps((args, kwargs))
args_ascii = b'P' + binascii.b2a_hqx(args_bytes)
if len(args_ascii) >= self.MAX_KEY_LENGTH:
args_hash = b''.join([
hashlib.sha256(args_bytes).digest(),
hashlib.sha1(args_bytes).digest(),
hashlib.sha512(args_bytes).digest(),
hashlib.md5(args_bytes).digest()
])
args_ascii = b'H' + binascii.b2a_hqx(args_hash)
return args_ascii
def args_serializer(self, *args, **kwargs):
args_bytes = pickle.dumps((args, kwargs))
args_ascii = binascii.b2a_hqx(args_bytes)
if len(args_ascii) >= self.SERIALIZE_LENGTH_THRESHOLD:
args_hash = b''.join([
hashlib.sha256(args_bytes).digest(),
hashlib.sha1(args_bytes).digest(),
hashlib.sha512(args_bytes).digest(),
hashlib.md5(args_bytes).digest()
])
args_ascii = binascii.b2a_hqx(args_hash)
return args_ascii
def close(self):
if self.data:
with _ignore_deprecation_warning():
self.hqxdata = self.hqxdata + binascii.b2a_hqx(self.data)
self._flush(1)
self.ofp.close()
del self.ofp
def close(self):
if self.data:
self.hqxdata = \
self.hqxdata + binascii.b2a_hqx(self.data)
self._flush(1)
self.ofp.close()
del self.ofp
def create(self, args, config, connection):
name = args['name']
password = args['password']
if args['json'] is not None:
user = self._read(name,
password,
args['json'],
connection=connection)
name = user.user_name()
else:
user = User(name, password, connection=connection)
if 'password' not in user._config:
user._config['password'] = str(b2a_hqx(urandom(64)))
if user.exists():
print("Error: User already exists: {0}".format(args['name']))
sys.exit(1)
self.roles = []
self._properties(user, args)
if len(self.roles) > 0:
user.set_role_names(self.roles)
print("Create user {0}...".format(args['name']))
user.create()
def close(self):
if self.data:
self.hqxdata = \
self.hqxdata + binascii.b2a_hqx(self.data)
self._flush(1)
self.ofp.close()
del self.ofp
def hashbuf(buf):
hasher = hashlib.sha1()
bb = bytes(buf, 'utf-8')
BLOCK_SIZE = 65536
for i in range(0, math.ceil(len(bb) / BLOCK_SIZE)):
data = binascii.b2a_hqx(bb[i * BLOCK_SIZE:(i + 1) * BLOCK_SIZE])
hasher.update(data)
return hasher.hexdigest()
def test_hqx(self):
# Perform binhex4 style RLE-compression
# Then calculate the hexbin4 binary-to-ASCII translation
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def test_not_implemented(self):
test_cases = [
lambda: binascii.a2b_hqx(None),
lambda: binascii.rledecode_hqx(None),
lambda: binascii.rlecode_hqx(None),
lambda: binascii.b2a_hqx(None),
]
for temp_func in test_cases:
self.assertRaises(NotImplementedError, temp_func)
def test_hqx(self):
# Perform binhex4 style RLE-compression
# Then calculate the hexbin4 binary-to-ASCII translation
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def PSKgen(ID, PSKpath):
# b2a_hqx output len is 4/3 input len
secret = os.urandom(192) # int(256/1.3333)
secretstring = b2a_hqx(secret)
PSKstring = ID+":"+secretstring
with open(PSKpath, 'w') as f:
f.write(PSKstring)
restartStunnel()
def write(self, data):
self.data = self.data + data
datalen = len(self.data)
todo = datalen // 3 * 3
data = self.data[:todo]
self.data = self.data[todo:]
if not data:
return
self.hqxdata = self.hqxdata + binascii.b2a_hqx(data)
self._flush(0)
def write(self, data):
self.data = self.data + data
datalen = len(self.data)
todo = (datalen / 3) * 3
data = self.data[:todo]
self.data = self.data[todo:]
if not data:
return
self.hqxdata = self.hqxdata + binascii.b2a_hqx(data)
self._flush(0)
def test_hqx(self):
# Perform binhex4 style RLE-compression
# Then calculate the hexbin4 binary-to-ASCII translation
if test_support.due_to_ironpython_bug("http://ironpython.codeplex.com/workitem/28171"):
return
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def test_deprecated_warnings(self):
with self.assertWarns(DeprecationWarning):
self.assertEqual(binascii.b2a_hqx(b'abc'), b'B@*M')
with self.assertWarns(DeprecationWarning):
self.assertEqual(binascii.a2b_hqx(b'B@*M'), (b'abc', 0))
with self.assertWarns(DeprecationWarning):
self.assertEqual(binascii.rlecode_hqx(b'a' * 10), b'a\x90\n')
with self.assertWarns(DeprecationWarning):
self.assertEqual(binascii.rledecode_hqx(b'a\x90\n'), b'a' * 10)
def write(self, data):
self.data = self.data + data
datalen = len(self.data)
todo = (datalen // 3) * 3
data = self.data[:todo]
self.data = self.data[todo:]
if not data:
return
with _ignore_deprecation_warning():
self.hqxdata = self.hqxdata + binascii.b2a_hqx(data)
self._flush(0)
def test_hqx(self):
# Perform binhex4 style RLE-compression
# Then calculate the hexbin4 binary-to-ASCII translation
if test_support.due_to_ironpython_bug(
"http://ironpython.codeplex.com/workitem/28171"):
return
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def test_not_implemented(self):
test_cases = [
lambda: binascii.a2b_qp(None),
lambda: binascii.a2b_qp(None, None),
lambda: binascii.a2b_hqx(None),
lambda: binascii.rledecode_hqx(None),
lambda: binascii.rlecode_hqx(None),
lambda: binascii.b2a_hqx(None),
lambda: binascii.crc_hqx(None, None),
]
for temp_func in test_cases:
self.assertRaises(NotImplementedError, temp_func)
def test_not_implemented():
test_cases = [
lambda: binascii.a2b_qp(None),
lambda: binascii.a2b_qp(None, None),
lambda: binascii.a2b_hqx(None),
lambda: binascii.rledecode_hqx(None),
lambda: binascii.rlecode_hqx(None),
lambda: binascii.b2a_hqx(None),
lambda: binascii.crc_hqx(None, None),
]
for temp_func in test_cases:
AssertError(NotImplementedError, temp_func)
def encode(encoding, fields):
#encoding: An encoding
for field in fields:
if encoding == 'base64':
field.value = binascii.b2a_base64(field.value)
elif encoding == 'hex':
field.value = binascii.b2a_hex(field.value).upper()
elif encoding == 'hqx':
field.value = binascii.b2a_hqx(field.value)
elif encoding == 'qp':
field.value = binascii.b2a_qp(field.value)
elif encoding == 'uu':
field.value = binascii.b2a_uu(field.value)
yield field
def encode(encoding, fields):
#encoding: An encoding
for field in fields:
if encoding == 'base64':
field.value = binascii.b2a_base64(field.value)
elif encoding == 'hex':
field.value = binascii.b2a_hex(field.value).upper()
elif encoding == 'hqx':
field.value = binascii.b2a_hqx(field.value)
elif encoding == 'qp':
field.value = binascii.b2a_qp(field.value)
elif encoding == 'uu':
field.value = binascii.b2a_uu(field.value)
yield field
def secret_key():
""" Get secret key from datastore.
Read Secret Key from db. If one does not exist, create one
and the event gets logged since this is an important security event
"""
secret_check = ndb.gql("SELECT key_string FROM Secret")
key = secret_check.get()
if key: # if key is present return it
return key.key_string
else: # if not make one and return/store it
new_key = binascii.b2a_hqx(os.urandom(64)) # 64-bits of ASCII
k = Secret(key_string=new_key)
k.put()
logging.critical("A NEW SECRET KEY HAS BEEN CREATED FOR HMAC")
return new_key
def default_configuration(app):
setdefault(app.config, 'PRODUCTION', True)
setdefault(app.config, 'MONGODB_HOST', os.environ.get('MONGODB_HOST'))
setdefault(app.config, 'MONGODB_PORT', int(os.environ.get('MONGODB_PORT')))
setdefault(app.config, 'MONGODB_DATABASE', os.environ.get('MONGODB_DATABASE'))
setdefault(app.config, 'MONGODB_USERNAME', os.environ.get('MONGODB_USERNAME'))
setdefault(app.config, 'MONGODB_PASSWORD', os.environ.get('MONGODB_PASSWORD'))
setdefault(app.config, 'CACHE_MEMCACHED_SERVERS',
["%s:%s@%s" % (
os.environ.get('MEMCACHE_USERNAME'),
os.environ.get('MEMCACHE_PASSWORD'),
os.environ.get('MEMCACHE_SERVERS')
)
]
)
setdefault(app.config, 'SECRET_KEY', binascii.b2a_hqx(os.urandom(42)))
def default_configuration(app):
setdefault(app.config, 'PRODUCTION', True)
setdefault(app.config, 'MONGODB_HOST', os.environ.get('MONGODB_HOST'))
setdefault(app.config, 'MONGODB_PORT', int(os.environ.get('MONGODB_PORT')))
setdefault(app.config, 'MONGODB_DATABASE',
os.environ.get('MONGODB_DATABASE'))
setdefault(app.config, 'MONGODB_USERNAME',
os.environ.get('MONGODB_USERNAME'))
setdefault(app.config, 'MONGODB_PASSWORD',
os.environ.get('MONGODB_PASSWORD'))
setdefault(app.config, 'CACHE_MEMCACHED_SERVERS', [
"%s:%s@%s" % (os.environ.get('MEMCACHE_USERNAME'),
os.environ.get('MEMCACHE_PASSWORD'),
os.environ.get('MEMCACHE_SERVERS'))
])
setdefault(app.config, 'SECRET_KEY', binascii.b2a_hqx(os.urandom(42)))
def get_settings():
settings = dict()
# Prompt User for Settings
pblue("Enter your environment settings.")
settings['PRODUCTION'] = False
if confirm(blue("Are these settings for a production server?")):
settings['PRODUCTION'] = True
puts('')
pblue('##### ADMIN SETUP #####')
settings['ADMIN_USERNAME'] = prompt(magenta('ADMIN_USERNAME:'******'ADMIN_PASSWORD:'******'ADMIN_PASSWORD_HASH'] = admin_password_hashed
puts('')
pblue('##### DATABASE SETUP #####')
settings['MONGODB_HOST'] = prompt(magenta('MONGODB_HOST:'))
settings['MONGODB_PORT'] = prompt(magenta('MONGODB_PORT:'))
settings['MONGODB_DATABASE'] = prompt(magenta('MONGODB_DATABASE:'))
settings['MONGODB_USERNAME'] = prompt(magenta('MONGODB_USERNAME:'******'MONGODB_PASSWORD'] = prompt(magenta('MONGODB_PASSWORD:'******'')
pblue('##### MAIL SETUP #####')
settings['MAIL_SERVER'] = prompt(magenta('MAIL_SERVER:'))
settings['MAIL_PORT'] = prompt(magenta('MAIL_PORT:'))
settings['MAIL_USERNAME'] = prompt(magenta('MAIL_USERNAME:'******'MAIL_PASSWORD'] = prompt(magenta('MAIL_PASSWORD:'******'MAILGUN_API_KEY'] = prompt(magenta('MAIL_API_KEY:'))
puts('')
pblue('##### MEMCACHE SETUP #####')
settings['MEMCACHE_SERVER'] = prompt(magenta('MEMCACHE_SERVER:'))
settings['MEMCACHE_USERNAME'] = prompt(magenta('MEMCACHE_USERNAME:'******'MEMCACHE_PASSWORD'] = prompt(magenta('MEMCACHE_PASSWORD:'******'\nSECRET KEY: %s' % secret_key)
if confirm(yellow("Verify everything looks correct?")):
settings['SECRET_KEY'] = secret_key
return settings
return None
def get_settings():
settings = dict()
# Prompt User for Settings
pblue("Enter your environment settings.")
settings['PRODUCTION'] = False
if confirm(blue("Are these settings for a production server?")):
settings['PRODUCTION'] = True
puts('')
pblue('##### ADMIN SETUP #####')
settings['ADMIN_USERNAME'] = prompt(magenta('ADMIN_USERNAME:'******'ADMIN_PASSWORD:'******'ADMIN_PASSWORD_HASH'] = admin_password_hashed
puts('')
pblue('##### DATABASE SETUP #####')
settings['MONGODB_HOST'] = prompt(magenta('MONGODB_HOST:'))
settings['MONGODB_PORT'] = prompt(magenta('MONGODB_PORT:'))
settings['MONGODB_DATABASE'] = prompt(magenta('MONGODB_DATABASE:'))
settings['MONGODB_USERNAME'] = prompt(magenta('MONGODB_USERNAME:'******'MONGODB_PASSWORD'] = prompt(magenta('MONGODB_PASSWORD:'******'')
pblue('##### MAIL SETUP #####')
settings['MAIL_SERVER'] = prompt(magenta('MAIL_SERVER:'))
settings['MAIL_PORT'] = prompt(magenta('MAIL_PORT:'))
settings['MAIL_USERNAME'] = prompt(magenta('MAIL_USERNAME:'******'MAIL_PASSWORD'] = prompt(magenta('MAIL_PASSWORD:'******'MAILGUN_API_KEY'] = prompt(magenta('MAIL_API_KEY:'))
puts('')
pblue('##### MEMCACHE SETUP #####')
settings['MEMCACHE_SERVER'] = prompt(magenta('MEMCACHE_SERVER:'))
settings['MEMCACHE_USERNAME'] = prompt(magenta('MEMCACHE_USERNAME:'******'MEMCACHE_PASSWORD'] = prompt(magenta('MEMCACHE_PASSWORD:'******'\nSECRET KEY: %s' % secret_key)
if confirm(yellow("Verify everything looks correct?")):
settings['SECRET_KEY'] = secret_key
return settings
return None
def make_settings():
""" Creates a new settings.py """
settings = dict()
# Prompt User for Settings
pblue("Enter your environment settings.")
settings['PRODUCTION'] = False
if confirm(blue("Are these settings for a production server?")):
settings['PRODUCTION'] = True
puts('')
if confirm(yellow("Verify everything looks correct?")):
settings['SECRET_KEY'] = binascii.b2a_hqx(os.urandom(42))
with cd(env.PROJECT_ROOT):
with prefix('workon ' % env.PROJECT_VENV):
upload_template('settings.py.template',
os.path.join(env.PROJECT_ROOT, 'settings.py'),
context=settings, use_jinja=True, backup=False)
def cmd_random(args):
try:
tamanho = 8
response = list()
## Eu não faço args['command_list'][0] pra evitar IndexError
## Mas tem outras formas de testar isto, ler o manual do dict()
argumento = ''.join(args['command_list'])
if argumento:
if argumento.isdigit(
) and int(argumento) <= 872 and int(argumento) > 2:
tamanho = int(argumento)
else:
response.append(
u"Tamanho deve ser entre 1 e 872, %s não serve! Revertendo para %s...\n"
% (str(argumento), str(tamanho)))
aleatorio = os.urandom(tamanho)
response.append(u"<b>HEX</b>:\n<pre>%s</pre>\n" %
binascii.hexlify(aleatorio).decode('utf-8'))
response.append(u"<b>B64</b>:\n<pre>%s</pre>" %
binascii.b2a_base64(aleatorio).decode('utf-8'))
response.append(
u"<b>HQX</b>:\n<pre>%s</pre>" %
binascii.b2a_hqx(binascii.rlecode_hqx(aleatorio)).decode('utf-8'))
return {
'status': True,
'type': 'grupo',
'response': '\n'.join(response),
'debug': u"Número aleatório gerado",
'multi': False,
'parse_mode': 'HTML',
'reply_to_message_id': args['message_id'],
}
except Exception as e:
return {
'status': False,
'type': 'erro',
'response': u"Erro tentando gerar número aleatório.",
'debug': u"Random falhou, exceção: %s" % (e),
'multi': False,
'parse_mode': None,
'reply_to_message_id': args['message_id'],
}
def create_settings():
settings = {}
pcyan("## Environment settings.")
settings['PRODUCTION'] = False
if confirm(blue("Are these settings for a production server?")):
settings['PRODUCTION'] = True
puts('')
pcyan("## Database Info:")
settings['MUSIC_DATABASE'] = prompt(blue("Absolute path to music database: "))
settings['USERS_DATABASE'] = prompt(blue("Absolute path to users database: "))
settings['MAIL_SERVER'] = prompt(blue("Mail server URI: "))
secret_key = binascii.b2a_hqx(os.urandom(42))
pred('\nSECRET_KEY: %s' % secret_key)
if confirm(yellow("Verify everything looks correct?")):
settings['SECRET_KEY'] = secret_key
return settings
return None
def create_settings():
settings = dict()
# Prompt User for Settings
pblue("Enter your environment settings.")
settings['PRODUCTION'] = False
if confirm(blue("Are these settings for a production server?")):
settings['PRODUCTION'] = True
puts('')
settings['MPD_HOST'] = prompt(magenta('MPD_HOST:'))
settings['MPD_PORT'] = prompt(magenta('MPD_PORT:'))
puts('')
secret_key = binascii.b2a_hqx(os.urandom(42))
pred('\nSECRET KEY: %s' % secret_key)
if confirm(yellow("Verify everything looks correct?")):
settings['SECRET_KEY'] = secret_key
return settings
return None
"""Macintosh binhex compression/decompression.
def close(self):
if self.data:
self.ofp.write(binascii.b2a_hqx(self.data))
self.ofp.write(':\n')
self.ofp.close()
def random_ascii_string(self, size, salt=b''): '''Returns a random string containing ascii characters.''' return binascii.b2a_hqx(self.random(size, salt))[:size].decode()
import binascii text = "hello, mrs teal" data = binascii.b2a_base64(text) text = binascii.a2b_base64(data) print text, "<=>", repr(data) data = binascii.b2a_uu(text) text = binascii.a2b_uu(data) print text, "<=>", repr(data) data = binascii.b2a_hqx(text) text = binascii.a2b_hqx(data)[0] print text, "<=>", repr(data) # 2.0 and newer data = binascii.b2a_hex(text) text = binascii.a2b_hex(data) print text, "<=>", repr(data)
def encode(self, s):
return binascii.b2a_hqx(s)
"""Test deprecated methods from Python 3.9.""" import binascii binascii.b2a_hqx() # [deprecated-method]
def test_hqx(self):
rle = binascii.rlecode_hqx(self.data)
a = binascii.b2a_hqx(self.type2test(rle))
b, _ = binascii.a2b_hqx(self.type2test(a))
res = binascii.rledecode_hqx(b)
self.assertEqual(res, self.rawdata)
def getMd5(stringArray):
returnArray = []
for n in stringArray:
returnArray.append("%s - %s" % (n, binascii.b2a_hqx(hashlib.md5(str(n)).digest())))
return returnArray
#!/usr/bin/env python
# -*- coding: utf-8 -*-
## Cria uma senha pseudo aleatória boa pra criptografia
import binascii, os, sys
## Usar 8 como tamanho por omissão se nenhum parâmetro for fornecido
tamanho = 8
## Caso um número seja fornecido, use-o como tamanho
if len(sys.argv) > 1 and str(sys.argv[1]).isdigit():
tamanho = int(sys.argv[1])
senha = os.urandom(tamanho)
print(u"HEX:\n%s\n" % binascii.hexlify(senha).decode('utf-8'))
print(u"B64:\n%s" % binascii.b2a_base64(senha).decode('utf-8'))
print(u"HQX:\n%s\n" % binascii.b2a_hqx(binascii.rlecode_hqx(senha)).decode('utf-8'))
def write(self, data):
self.data = self.data + data
while len(self.data) > LINELEN:
hqxdata = binascii.b2a_hqx(self.data[:LINELEN])
self.ofp.write(hqxdata + '\n')
self.data = self.data[LINELEN:]
def close(self):
if self.data:
self.ofp.write(binascii.b2a_hqx(self.data))
self.ofp.write(':\n')
self.ofp.close()
import os
import socket
import paho.mqtt.client as mqtt
import struct
import binascii
ALERTMSG_LENGTH = 256
SNAPLEN = 1500
snort_mqtt = mqtt.Client()
snort_mqtt.connect("10.0.0.100")
snort_mqtt.loop_start()
s = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
format = "%ds9l%ds" % (ALERTMSG_LENGTH, SNAPLEN)
format_size = struct.calcsize(format)
try:
os.remove("/var/log/snort/snort_alert")
except OSError:
pass
s.bind("/var/log/snort/snort_alert")
#s.listen(3)
while True:
data, addr = s.recvfrom(4096)
msg, ts_sec, ts_usec, caplen, pktlen, dlthdr, nethdr, transhdr, data_snort, val, pkt = struct.unpack(
format, data[:format_size])
#print pkt
print msg
snort_mqtt.publish("snort/test", binascii.b2a_hqx(data))
conn.close()
"""Macintosh binhex compression/decompression.
def thg_encode(self, args):
"""modulo referente a encode de estrings"""
arg_mensage = args.split(" ")
if arg_mensage[0] == "":
print("""suporte encode:
Este módulo fornece funções para codificar dados binários em caracteres ASCII
imprimíveis e decodificar essas codificações de volta para dados binários.
Ele fornece funções de codificação e decodificação para as codificações
especificadas em RFC 3548 ,que define os algoritmos Base16, Base32 e Base64,
e para as codificações Ascii85 e Base85 padrão de fato.
a2b_uu
b2a_uu
a2b_base64
b2a_base64
a2b_qp
b2a_qp
a2b_hqx
rledecode_hqx
rlecode_hqx
b2a_hqx
crc_hqx
crc32
b2a_hex
a2b_hex
hexlify
unhexlify
Charcode
binary
base62
basen
bcd
ur
unicode_normalize
qp_encoding
encode type[2,16,32,64] str
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
elif arg_mensage[0] == "64":
arg_mensage[1] = arg_mensage[1].encode('ascii')
base64_bytes = base64.b64encode(arg_mensage[1])
by_to_st(base64_bytes)
elif arg_mensage[0] == "32":
arg_mensage[1] = arg_mensage[1].encode('ascii')
b32encode_bytes = base64.b32encode(arg_mensage[1])
by_to_st(b32encode_bytes)
elif arg_mensage[0] == "16":
arg_mensage[1] = arg_mensage[1].encode('ascii')
b16encode_bytes = base64.b16encode(arg_mensage[1])
by_to_st(b16encode_bytes)
elif arg_mensage[0] == "a85encode":
arg_mensage[1] = arg_mensage[1].encode('ascii')
a85encode_bytes = base64.a85encode(arg_mensage[1])
by_to_st(a85encode_bytes)
elif arg_mensage[0] == "b85encode":
arg_mensage[1] = arg_mensage[1].encode('ascii')
b85encode_bytes = base64.b85encode(arg_mensage[1])
by_to_st(b85encode_bytes)
elif arg_mensage[0] == "a2b_uu":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Converta uma única linha de dados uuencodificados de volta em binários e retorne os dados binários. As linhas normalmente contêm 45 bytes (binários), exceto a última linha. Os dados da linha podem ser seguidos de espaços em branco."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.a2b_uu(arg_mensage[1])))
elif arg_mensage[0] == "a2b_base64":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED}Converta dados binários em uma linha de caracteres ASCII na codificação base64. O valor de retorno é a linha convertida, incluindo um caractere de nova linha. O comprimento dos dados deve ser de no máximo 57 para aderir ao padrão base64."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.a2b_base64(arg_mensage[1]))
elif arg_mensage[0] == "b2a_base64":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Converta dados binários em uma linha de caracteres ASCII na codificação base64. O valor de retorno é a linha convertida, incluindo um caractere de nova linha. O comprimento dos dados deve ser de no máximo 57 para aderir ao padrão base64."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.b2a_base64(b'arg_mensage[1]'))
elif arg_mensage[0] == "a2b_qp":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED}Converta um bloco de dados imprimíveis entre aspas de volta em binários e retorne os dados binários. Mais de uma linha pode ser passada por vez. Se o cabeçalho do argumento opcional estiver presente e verdadeiro, os sublinhados serão decodificados como espaços."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.a2b_qp(arg_mensage[1]))
elif arg_mensage[0] == "b2a_qp":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED}Converta dados binários em uma (s) linha (s) de caracteres ASCII em codificação imprimível entre aspas. O valor de retorno é a (s) linha (s) convertida (s). Se o argumento opcional quotetabs estiver presente e verdadeiro, todas as tabulações e espaços serão codificados. Se o argumento opcional istext estiver presente e verdadeiro, as novas linhas não serão codificadas, mas os espaços em branco finais serão codificados. Se o cabeçalho do argumento opcional estiver presente e verdadeiro, os espaços serão codificados como sublinhados de acordo com RFC1522. Se o cabeçalho do argumento opcional estiver presente e for falso, os caracteres de nova linha também serão codificados; caso contrário, a conversão de alimentação de linha pode corromper o fluxo de dados binários."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.a2b_qp(arg_mensage[1].encode()))
elif arg_mensage[0] == "a2b_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED}Converta dados ASCII formatados de binhex4 em binários, sem fazer a descompressão RLE. A string deve conter um número completo de bytes binários ou (no caso da última parte dos dados binhex4) ter os bits restantes zero.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st(binascii.a2b_hqx(arg_mensage[1]))
elif arg_mensage[0] == "rledecode_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Execute a descompressão RLE nos dados, de acordo com o padrão binhex4. O algoritmo usa 0x90 após um byte como um indicador de repetição, seguido por uma contagem. Uma contagem de 0 especifica um valor de byte de 0x90 . A rotina retorna os dados descompactados, a menos que os dados de entrada de dados terminem em um indicador de repetição órfão, caso em que a exceção Incompleta é levantada."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.rledecode_hqx(arg_mensage[1].encode())))
elif arg_mensage[0] == "rlecode_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Execute a compactação RLE no estilo binhex4 nos dados e retorne o resultado."""
.format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.rlecode_hqx(arg_mensage[1].encode())))
elif arg_mensage[0] == "b2a_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Execute a conversão hexbin4 binário para ASCII e retorne a string resultante. O argumento já deve ser codificado por RLE e ter um comprimento divisível por 3 (exceto possivelmente o último fragmento).
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.b2a_hqx(arg_mensage[1].encode())))
elif arg_mensage[0] == "crc_hqx":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Calcule o valor binhex4 crc dos dados , começando com um crc inicial e retornando o resultado.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.crc_hqx(arg_mensage[1].encode(),
int(arg_mensage[2]))))
elif arg_mensage[0] == "crc32":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Calcule CRC-32, a soma de verificação de dados de
32 bits, começando com um crc inicial. Isso é consistente com a soma de verificação do arquivo ZIP.
Uma vez que o algoritmo é projetado para uso como um algoritmo de soma de verificação, não é adequado
para uso como um algoritmo de hash geral.
{YELLOW}Nota{YELLOW}{RED} Para gerar o mesmo valor numérico em todas as versões e plataformas Python, {RED}{BLUE}use crc32 (dados) & 0xffffffff{BLUE}{RED}. Se você estiver usando apenas a soma de verificação no formato binário compactado, isso não é necessário, pois o valor de retorno é a representação binária correta de 32 bits, independentemente do sinal.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.crc32(arg_mensage[1].encode())))
elif arg_mensage[0] == "hexlify":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Retorna a representação hexadecimal dos dados
binários . Cada byte de dados é convertido na representação hexadecimal de 2 dígitos correspondente.
A string resultante é, portanto, o dobro do comprimento dos dados .
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.hexlify(arg_mensage[1].encode(),
arg_mensage[2].encode())))
elif arg_mensage[0] == "b2a_hex":
if arg_mensage[1] == "help":
print("""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} hex
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.b2a_hex(arg_mensage[1].encode(),
int(arg_mensage[2]))))
elif arg_mensage[0] == "unhexlify":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Retorna os dados binários representados pela string hexadecimal hexstr . Esta função é o inverso de b2a_hex () . hexstr deve conter um número par de dígitos hexadecimais (que podem ser maiúsculas ou minúsculas), caso contrário, um TypeError é gerado.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.unhexlify(arg_mensage[1].encode())))
elif arg_mensage[0] == "b2a_uu":
if arg_mensage[1] == "help":
print(
"""{YELLOW}a2b_uu{YELLOW}{BLUE} =>{BLUE}{RED} Converta dados binários em uma linha de caracteres ASCII, o valor de retorno é a linha convertida, incluindo um caractere de nova linha. O comprimento dos dados deve ser de no máximo 45.
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
by_to_st((binascii.b2a_uu(arg_mensage[1].encode(),
int(arg_mensage[2]))))
elif arg_mensage[0] == "charcode":
if arg_mensage[1] == "help":
print(
"""{YELLOW}charcode{YELLOW}{BLUE} =>{BLUE}{RED}converte string em charcode
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(ord(arg_mensage[1].encode()))
elif arg_mensage[0] == "binary":
if arg_mensage[1] == "help":
print(
"""{YELLOW}binary{YELLOW}{BLUE} =>{BLUE}{RED}converte string em binary
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(' '.join(format(ord(x), 'b') for x in arg_mensage[1]))
elif arg_mensage[0] == "base62":
if arg_mensage[1] == "help":
print(
"""{YELLOW}base62{YELLOW}{BLUE} =>{BLUE}{RED}converte string em base62
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(decode62(arg_mensage[1]))
elif arg_mensage[0] == "basen":
if arg_mensage[1] == "help":
print(
"""{YELLOW}basen{YELLOW}{BLUE} =>{BLUE}{RED}converte decimal em basen
""".format(YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(
numpy.base_repr(int(arg_mensage[1]),
base=int(arg_mensage[2])))
elif arg_mensage[0] == "url":
try:
if arg_mensage[1] == "help":
print(
"""{YELLOW}url_encode{YELLOW}{BLUE} =>{BLUE}{RED}encode personalidado para url\nencode url_encode safa[] encoding"""
.format(YELLOW=Fore.YELLOW,
BLUE=Fore.BLUE,
RED=Fore.RED))
else:
print(
quote(arg_mensage[1],
safe=arg_mensage[2],
encoding=arg_mensage[3]))
except IndexError:
print(
"digite a sintaxe correta\nncode url_encode safa[] encoding\n ou use o comando help"
)
elif arg_mensage[0] == "unicode_normalize":
try:
if arg_mensage[1] == "help":
print(
"""{YELLOW}unicode_normalize{YELLOW}{BLUE} =>{BLUE}{RED}Transforme caracteres Unicode em uma das formas de normalização['NFC', 'NFKC', 'NFD','NFKD']\n
{YELLOW}NFD{YELLOW}{BLUE} =>{BLUE}{RED}Normalisation Form Canonical Decomposition
{YELLOW}NFC{YELLOW}{BLUE} =>{BLUE}{RED}Normalisation Form Canonical Composition
{YELLOW}NFKD{YELLOW}{BLUE} =>{BLUE}{RED}Normalisation Form Compatibility Decomposition
{YELLOW}NFKC{YELLOW}{BLUE} =>{BLUE}{RED}Normalisation Form Compatibility Composition
encode unicode_normalize str encoding['NFC', 'NFKC', 'NFD','NFKD']\n""".format(
YELLOW=Fore.YELLOW, BLUE=Fore.BLUE, RED=Fore.RED))
else:
print(unicodedata.normalize(arg_mensage[1],
arg_mensage[2]))
except IndexError:
print(
"digite a sintaxe correta\nncode url_encode safa[] encoding\n ou use o comando help"
)
elif arg_mensage[0] == "qp_encoding":
try:
if arg_mensage[1] == "help":
print("""{YELLOW}qp_encoding{YELLOW}{BLUE} =>{BLUE}{RED}
Quoted-Printable, ou QP encoding,
é uma codificação que usa caracteres ASCII imprimíveis (alfanuméricos e o sinal de igual '=')
para transmitir dados de 8 bits em um caminho de dados de 7 bits ou, geralmente, em um meio que não é 8- um pouco limpo.
É definido como uma codificação de transferência de conteúdo MIME para uso em e-mail.
QP funciona usando o sinal de igual '=' como um caractere de escape. Ele também limita o comprimento da linha a 76, pois alguns softwares têm limites no comprimento da linha\nencode qp_encoding TXT encode"""
.format(YELLOW=Fore.YELLOW,
BLUE=Fore.BLUE,
RED=Fore.RED))
else:
encoded = quopri.encodestring(arg_mensage[1].encode(
arg_mensage[2]))
print(encoded.decode())
except IndexError:
print(
"digite a sintaxe correta\nencode qp_encoding é utf-16\n ou use o comando help"
)
elif arg_mensage[0] == "idna":
try:
if arg_mensage[1] == "help":
print(
"""{YELLOW}idna{YELLOW}{BLUE} =>{BLUE}{RED}encode personalidado para url\nencode url_encode safa[] encoding"""
.format(YELLOW=Fore.YELLOW,
BLUE=Fore.BLUE,
RED=Fore.RED))
else:
print(idna.encode(arg_mensage[1]).decode(arg_mensage[2]))
except IndexError:
print(
"digite a sintaxe correta\nncode idna string encoding\n ou use o comando help"
)
else:
pass
try:
pass
except IndexError:
print("verificar a saida")
b2a = binascii.b2a_qp(str) print repr(b2a) a2b = binascii.a2b_qp(b2a) print repr(a2b) b2a = binascii.b2a_uu(str) print repr(b2a) a2b = binascii.a2b_uu(b2a) print repr(a2b) b2a = binascii.b2a_hex(str) print repr(b2a) a2b = binascii.a2b_hex(b2a) print repr(a2b) b2a = binascii.b2a_hqx(str) print repr(b2a) a2b,done = binascii.a2b_hqx(b2a) # returns a string instead of a tuple print repr(a2b),done b2a = binascii.b2a_base64(str) print repr(b2a) a2b = binascii.a2b_base64(b2a) print repr(a2b) b2a = binascii.rlecode_hqx(str) print repr(b2a) a2b = binascii.rledecode_hqx(b2a) print repr(a2b) b2a = binascii.hexlify(str)
import binascii text = "hello, mrs teal" data = binascii.b2a_base64(text) text = binascii.a2b_base64(data) print text, "<=>", repr(data) data = binascii.b2a_uu(text) text = binascii.a2b_uu(data) print text, "<=>", repr(data) data = binascii.b2a_hqx(text) text = binascii.a2b_hqx(data)[0] print text, "<=>", repr(data) # 2.0 and newer data = binascii.b2a_hex(text) text = binascii.a2b_hex(data) print text, "<=>", repr(data) ## hello, mrs teal <=> 'aGVsbG8sIG1ycyB0ZWFs\012' ## hello, mrs teal <=> '/:&5L;&\\L(&UR<R!T96%L\012' ## hello, mrs teal <=> 'D\'9XE\'mX)\'ebFb"dC@&X' ## hello, mrs teal <=> '68656c6c6f2c206d7273207465616c'
def encode(self, s):
return binascii.b2a_hqx(s)
def write(self, data): self.data = self.data + data while len(self.data) > LINELEN: hqxdata = binascii.b2a_hqx(self.data[:LINELEN]) self.ofp.write(hqxdata+'\n') self.data = self.data[LINELEN:]
def hexbin4_binary_to_ascii(flag):
return str(binascii.b2a_hqx(flag.encode()).decode())