def close(self):
if self.data:
with _ignore_deprecation_warning():
rledata = binascii.rlecode_hqx(self.data)
self.ofp.write(rledata)
self.ofp.close()
del self.ofp
def find_dicoms(self, path):
import binascii
import os
folder_contents = os.listdir(path)
if path[-1] == "/":
path = path[0:len(path)-1]
dicom_files = []
for i in range(len(folder_contents)):
full_path = path + "/" + folder_contents[i]
if (os.path.isfile(full_path)):
w = open(full_path,"rb")
data = w.read()
w.close()
if (b'DICM' in binascii.rlecode_hqx(data[0:1000])):
dicom_files.append(full_path)
return dicom_files
def write(self, data):
self.data = self.data + data
if len(self.data) < REASONABLY_LARGE:
return
rledata = binascii.rlecode_hqx(self.data)
self.ofp.write(rledata)
self.data = ''
def write(self, data):
self.data = self.data + data
if len(self.data) < REASONABLY_LARGE:
return
rledata = binascii.rlecode_hqx(self.data)
self.ofp.write(rledata)
self.data = ''
def DumpBitMapInDatabase(self, db):
"""
Encode bitmap for each word using RLE encoding technique
and update the dictionary adding another field
"""
self.ElapsedTime = CommonFunctions.ConvertSecondsToDayHourMinSec(
time.time() - self.StartTime)
self.ParseStatus = "Updating Database Index!"
self.SendEvent()
manyValues = []
i = 0
query = "INSERT INTO " + Constants.TextCatBitMapIndex + " (Keyword, Bitmap, Compressed) values (?,?,?)"
for kword in Globals.EmailsBitMap:
i += 1
manyValues.append(
(kword, Globals.EmailsBitMap[kword]['bitmap'],
MySQLdb.escape_string(
binascii.rlecode_hqx(
Globals.EmailsBitMap[kword]['bitmap']))))
if i == 10000:
try:
db.ExecuteMany(query, manyValues)
except:
print "Exception query:: " + query + str(manyValues)
manyValues = []
if len(manyValues) > 0:
try:
db.ExecuteMany(query, manyValues)
except:
print "Exception query:: " + query + str(manyValues[0])
def write(self, data):
self.data = self.data + data
if len(self.data) < REASONABLY_LARGE:
return
with _ignore_deprecation_warning():
rledata = binascii.rlecode_hqx(self.data)
self.ofp.write(rledata)
self.data = b''
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 write(self, data): if DEBUG: testf.write(data) # XXXX self.data = self.data + data if len(self.data) < REASONABLY_LARGE: return rledata = binascii.rlecode_hqx(self.data) self.ofp.write(rledata) self.data = ''
def write(self, data):
if DEBUG:
testf.write(data) # XXXX
self.data = self.data + data
if len(self.data) < REASONABLY_LARGE:
return
rledata = binascii.rlecode_hqx(self.data)
self.ofp.write(rledata)
self.data = ''
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_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 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 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_rle(self):
# test repetition with a repetition longer than the limit of 255
data = (b'a' * 100 + b'b' + b'c' * 300)
encoded = binascii.rlecode_hqx(data)
self.assertEqual(encoded,
(b'a\x90d' # 'a' * 100
b'b' # 'b'
b'c\x90\xff' # 'c' * 255
b'c\x90-')) # 'c' * 45
decoded = binascii.rledecode_hqx(encoded)
self.assertEqual(decoded, data)
def test_rle(self):
# test repetition with a repetition longer than the limit of 255
data = (b'a' * 100 + b'b' + b'c' * 300)
encoded = binascii.rlecode_hqx(data)
self.assertEqual(encoded,
(b'a\x90d' # 'a' * 100
b'b' # 'b'
b'c\x90\xff' # 'c' * 255
b'c\x90-')) # 'c' * 45
decoded = binascii.rledecode_hqx(encoded)
self.assertEqual(decoded, data)
def make_key(bins):
l = []
d = {}
for b in bins:
l.append(b.remaining)
for i in b.items:
s = i.size
if s not in d: d[s] = 1
else: d[s] += 1
l.sort() # break symmetries
# MEMORY: spare some memory by removing the following line:
l.append(-1)
# separate bins from items / use less memory than making a list of tuples...
# not required here since the number of bins is fixed
for i, j in d.iteritems():
l.append(i)
l.append(j)
return binascii.rlecode_hqx(' '.join(str(i) for i in l))
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 close(self):
if self.data:
rledata = binascii.rlecode_hqx(self.data)
self.ofp.write(rledata)
self.ofp.close()
del self.ofp
def close(self):
if self.data:
rledata = binascii.rlecode_hqx(self.data)
self.ofp.write(rledata)
self.ofp.close()
del self.ofp
"""Macintosh binhex compression/decompression.
#!/usr/bin/python
import socket
import binascii
def input_file(nome_arq):
with open(nome_arq, "rb") as f:
byte = f.read()
return byte
def output_file(out_info, out_name):
nome_cypt = str(out_name[0:-3]) + "dec"
arq_out = open(nome_cypt, "wb+")
arq_out.write(out_info)
arq_out.close()
datainput = binascii.rlecode_hqx(input_file('FF.txt'))
#print(datainput)
output_file( datainput, 'FF.txt')
dataoutput = binascii.rledecode_hqx(datainput)
output_file(dataoutput, "FFO.txt")
#print(dataoutput)
def test():
for _ in range(9999):
try:
binascii.a2b_uu(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_uu(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.a2b_base64(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_base64(fstr(), newline=fbool())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.a2b_qp(fstr(), header=fbool())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_qp(fstr(),
quotetabs=fbool(),
istext=fbool(),
header=fbool())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.a2b_hqx(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.rledecode_hqx(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.rlecode_hqx(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_hqx(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.crc_hqx(fstr(), flong())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.crc32(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.crc32(fstr(), flong())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.b2a_hex(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.hexlify(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.a2b_hex(fstr())
except (binascii.Error, binascii.Incomplete):
pass
try:
binascii.unhexlify(fstr())
except (binascii.Error, binascii.Incomplete):
pass
def parse_data(data, my_decode_flag, my_caesar_flag):
my_answers = list()
if my_decode_flag is True:
for name in ('hex_codec', 'base64_codec', 'rot_13', 'utf_8',
'utf_16_be', 'utf_16_le', 'bz2', 'zip', 'idna', 'palmos',
'punycode', 'quopri_codec', 'utf_7'):
try:
result = data.decode(name)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'base32'
try:
result = base64.b32decode(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'uuencode'
try:
result = binascii.a2b_uu(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'quotable'
try:
result = binascii.a2b_qp(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'binhex4'
try:
result = binascii.rledecode_hqx(binascii.a2b_hqx(data))
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'yenc'
try:
decoder = yenc.Decoder()
decoder.feed(data)
result = decoder.getDecoded()
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
else:
for name in ('hex_codec', 'base64_codec', 'rot_13', 'utf_8',
'utf_16_be', 'utf_16_le', 'bz2', 'zip', 'idna', 'palmos',
'punycode', 'quopri_codec', 'utf_7'):
try:
result = data.encode(name)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'base32'
try:
result = base64.b32encode(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'uuencode'
try:
result = binascii.b2a_uu(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'quotable'
try:
result = binascii.b2a_qp(data)
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'binhex4'
try:
result = binascii.b2a_hqx(binascii.rlecode_hqx(data))
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
name = 'yenc'
try:
encoder = yenc.Encoder()
encoder.feed(data)
result = encoder.getEncoded()
if verbose_flag:
print "%s succeeded" % name
my_answers.append([name, repr(result)])
except Exception as ex:
if verbose_flag:
print "%s FAILED: %s" % (name, ex)
if my_caesar_flag:
for i in range(1, 256):
my_answers.append([
"Caesar_%d" % i,
repr(''.join([chr((ord(c) + i) % 256) for c in data]))
])
my_answers.append([
"xor_%d" % i,
repr(''.join([chr((ord(c) ^ i) % 256) for c in data]))
])
return my_answers
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")
import sys
import time
import shutil
LEN = 2 ** 16
huffman = False
TARGET = os.getcwd()
SOURCE = sys.argv[1]
LOC = os.path.dirname(os.path.realpath(__file__))
HUFFMAN_ENCODER = os.path.join(LOC, "..", "tools", "huffman", "huffman-encode")
data = open(SOURCE, "r").read()
print "Load %s, %i bytes" % (SOURCE, len(data))
data = data[:LEN]
print "Use %i bytes" % (len(data))
data = binascii.rlecode_hqx(data)
print "RLE crunch (%i) bytes" % (len(data))
rle_size = len(data)
huffman_size = 0
if huffman:
binfile = open("/tmp/loader.rle", "w")
binfile.write(data)
binfile.close()
cmd = "%s /tmp/loader.rle" % HUFFMAN_ENCODER
print cmd
os.system(cmd)
data = open("/tmp/loader.rle.hfm", "r").read()
print "HUFFMAN crunch (%i) bytes" % (len(data))
def test_rle(self):
data = b'a' * 100 + b'b' + b'c' * 300
encoded = binascii.rlecode_hqx(data)
self.assertEqual(encoded, b'a\x90dbc\x90\xffc\x90-')
decoded = binascii.rledecode_hqx(encoded)
self.assertEqual(decoded, data)
"""Macintosh binhex compression/decompression.
def encode_file(nome_arq): datainput = binascii.rlecode_hqx(input_file(nome_arq)) return datainput
def test_rlecode_hqx_rledecode_hqx_round_trip(self, payload):
x = binascii.rlecode_hqx(payload)
self.assertEqual(payload, binascii.rledecode_hqx(x))
def encodeData(data):
return binascii.b2a_base64(binascii.rlecode_hqx(cPickle.dumps(data)))
def encodeData(data):
return binascii.b2a_base64(binascii.rlecode_hqx(cPickle.dumps(data)))
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) print repr(b2a) a2b = binascii.unhexlify(b2a) print repr(a2b) # delslice bug all = range(10) print all[2:8:2] all[1:3] = range(5) print all del all[1:7:2]
#!/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'))
import sys
import time
import shutil
LEN = 2**16
huffman = False
TARGET = os.getcwd()
SOURCE = sys.argv[1]
HUFFMAN_ENCODER = "/Users/david/Devel/arch/avr/code/quickdev16/packages/huffman/huffman-encode"
data = open(SOURCE, "r").read()
print "Load %s, %i bytes" % (SOURCE, len(data))
data = data[:LEN]
print "Use %i bytes" % (len(data))
data = binascii.rlecode_hqx(data)
print "RLE crunch (%i) bytes" % (len(data))
rle_size = len(data)
huffman_size = 0
if huffman == True:
binfile = open("/tmp/loader.rle", "w")
binfile.write(data)
binfile.close()
cmd = "%s /tmp/loader.rle" % HUFFMAN_ENCODER
print cmd
os.system(cmd)
data = open("/tmp/loader.rle.hfm", "r").read()
print "HUFFMAN crunch (%i) bytes" % (len(data))
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)
