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 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 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 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
"""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)
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)))
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)