def test_roundtrip(input_bytes): """Ensures type consistency. Suggested by @dhimmel""" base62_encoded = base62.encodebytes(input_bytes) assert isinstance(base62_encoded, str) output_bytes = base62.decodebytes(base62_encoded) assert isinstance(output_bytes, bytes) assert input_bytes == output_bytes
def test_roundtrip(input_bytes): """Ensures type consistency. Suggested by @dhimmel""" base62_encoded = base62.encodebytes(input_bytes) assert isinstance(base62_encoded, str) output_bytes = base62.decodebytes(base62_encoded) assert isinstance(output_bytes, bytes) assert input_bytes == output_bytes
def decode(self, ctext: T) -> Optional[U]: """ Performs Base62 decoding """ try: return base62.decodebytes(ctext).decode("utf-8") except Exception: return None
def decrypt(cipherText): private_key = hashlib.sha256(PASSWORD.encode("utf-8")).digest() cipherText = base62.decodebytes(cipherText) iv = cipherText[:16] cipherText = cipherText[16:] cipher = AES.new(private_key, AES.MODE_CBC, iv) p = unpad(cipher.decrypt(cipherText)) return p.decode("utf-8")
def run(s): mm = s.strip().encode("utf8") output = "" try: output += "base16:" + base64.b16decode(mm).decode("utf8") except: output += "base16:失败" try: output += "\r\nbase24:" + pybase24.decode24(mm) except: output += "\r\nbase24:失败,pybase24解密貌似代码有问题" try: output += "\r\nbase32:" + base64.b32decode(mm).decode("utf8") except: output += "\r\nbase32:失败" try: output += "\r\nbase36" + str(base36.dumps(int(mm, 10))) except: output += "\r\nbase36:失败" try: output += "\r\nbase58:" + base58.b58decode(mm).decode("utf8") except: output += "\r\nbase58:失败" try: output += "\r\nbase62:" + base62.decodebytes( mm.decode("utf8")).decode("utf8") except: output += "\r\nbase62:失败" try: output += "\r\nbase64:" + base64.b64decode(mm).decode("utf8") except: output += "\r\nbase64:失败" try: output += "\r\nbase85:" + base64.b85decode(mm).decode("utf8") except: output += "\r\nbase85:失败" try: output += "\r\nbase91:" + base91.decode(mm) except: output += "\r\nbase91:失败" try: output += "\r\nbase92:" + base92.b92decode(mm).decode("utf8") except: output += "\r\nbase92:失败" try: output += "\r\nbase128:" + base128.decode(mm).decode("utf8") except: output += "\r\nbase128:失败" return output
def decode(self, token, ttl=None): token = base62.decodebytes(token) header = token[0:CRYPTO_AEAD_XHCACHA20POLY1305_IETF_NPUBBYTES + 5] nonce = header[5:CRYPTO_AEAD_XHCACHA20POLY1305_IETF_NPUBBYTES + 5] ciphertext = token[CRYPTO_AEAD_XHCACHA20POLY1305_IETF_NPUBBYTES + 5:] version, time = struct.unpack(">BL", bytes(header[0:5])) # Implementation should accept only current version. if version is not self.VERSION: raise RuntimeError("Invalid token version") payload = crypto_aead_xchacha20poly1305_ietf_decrypt(ciphertext, header, nonce, self._key) if ttl is not None: future = time + ttl timestamp = calendar.timegm(datetime.utcnow().timetuple()) if future < timestamp: raise RuntimeError("Token is expired") return payload
def decode_base(self, encoded_base): def contains_replacement_char(res): return True if u'\ufffd' in res else False encoding_type = [] results = [] if len(encoded_base) != 0: try: base16_decode = base64.b16decode(encoded_base, casefold=False).decode( 'utf-8', 'replace') if not contains_replacement_char(base16_decode): encoding_type.append('Base16') results.append(base16_decode) if not self.api_call: print( colored('\n[>] Decoding as Base16: ', 'blue') + colored(base16_decode, 'green')) except: pass try: base32_decode = base64.b32decode(encoded_base, casefold=False, map01=None).decode( 'utf-8', 'replace') if not contains_replacement_char(base32_decode): encoding_type.append('Base32') results.append(base32_decode) if not self.api_call: print( colored('\n[>] Decoding as Base32: ', 'blue') + colored(base32_decode, 'green')) except: pass try: base36_decode = base36.dumps(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base36_decode): encoding_type.append('Base36') results.append(base36_decode) if not self.api_call: print( colored('\n[>] Decoding as Base36: ', 'blue') + colored(base36_decode, 'green')) except: pass try: base58_decode = base58.b58decode(encoded_base.encode()).decode( 'utf-8', 'replace') if not contains_replacement_char(base58_decode): encoding_type.append('Base58') results.append(base58_decode) if not self.api_call: print( colored('\n[>] Decoding as Base58: ', 'blue') + colored(base58_decode, 'green')) except: pass try: base62_decode = base62.decodebytes(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base62_decode): encoding_type.append('Base62') results.append(base62_decode) if not self.api_call: print( colored('\n[>] Decoding as Base62: ', 'blue') + colored(base62_decode, 'green')) except: pass try: base64_decode = base64.b64decode(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base64_decode): encoding_type.append('Base64') results.append(base64_decode) if not self.api_call: print( colored('\n[>] Decoding as Base64: ', 'blue') + colored(base64_decode, 'green')) except: pass try: base64url_decode = base64.urlsafe_b64decode( encoded_base + '=' * (4 - len(encoded_base) % 4)).decode( 'utf-8', 'replace') if not contains_replacement_char(base64url_decode): encoding_type.append('Base64URL') results.append(base64url_decode) if not self.api_call: print( colored('\n[>] Decoding as Base64URL: ', 'blue') + colored(base64url_decode, 'green')) except: pass try: base85_decode = base64.b85decode(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base85_decode): encoding_type.append('Base85') results.append(base85_decode) if not self.api_call: print( colored('\n[>] Decoding as Base85: ', 'blue') + colored(base85_decode, 'green')) except: pass try: ascii85_decode = base64.a85decode(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(ascii85_decode): encoding_type.append('Ascii85') results.append(ascii85_decode) if not self.api_call: print( colored('\n[>] Decoding as Ascii85: ', 'blue') + colored(ascii85_decode, 'green')) except: pass try: base91_decode = base91.decode(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base91_decode): encoding_type.append('Base91') results.append(base91_decode) if not self.api_call: print( colored('\n[>] Decoding as Base91: ', 'blue') + colored(base91_decode, 'green')) except: pass try: base92_decode = base92.decode(encoded_base) if not contains_replacement_char(base92_decode): encoding_type.append('Base92') results.append(base92_decode) if not self.api_call: print( colored('\n[>] Decoding as Base92: ', 'blue') + colored(base92_decode, 'green')) except: pass if not results and not self.api_call: quit(colored('\n[!] Not a valid encoding.\n', 'red')) for x in range(len(results)): """ It runs through all the results and compares them with a regex pattern of 'alphabets, numbers, and special characters' thus ending up with the right result as false results will contain invalid characters. """ if re.match('[A-Za-z0-9$&+,:;=?@#|\'<>.^*()%!_-]', results[x]): if not self.api_call: print( colored('\n[-] The Encoding Scheme Is ', 'blue') + colored(encoding_type[x], 'green')) if self.output != None: open(self.output, 'a').write(results[x] + '\n') else: return (results[x], encoding_type[x])
def timestamp(self, token): token = base62.decodebytes(token) version, time = struct.unpack(">BL", bytes(token[0:5])) return time
def decrypt(code): code = base62.decodebytes(code) message = blowfish.decrypt(code).decode('utf-8') return json.loads(message)
#!/usr/bin/env python3 import base64 import base58 import base62 s = 'O53GG4CSJRHEWQT2GJ5HC4CGOM4VKY3SOZGECZ2YNJTXO6LROV3DIR3CK4ZEMWCDHFMTOWSXGRSHU23DLJVTS5BXOQZXMU3ONJSFKRCVO5BEGVSELJSGUNSYLI2XQ32UOI3FKWDYMJQWOMKQOJ4XIU2WN5KTKWT2INUW44SZONGUUN2BMFRTQQJYKM3WGSSUNVXGEU3THFIFUSDHIVWVEQ3LJVUXEMSXK5MXSZ3TG5JXORKTMZRFIVQ=' print(s) s = base64.b32decode(s) print(s) s = base58.b58decode(s) print(s) s = base62.decodebytes(bytes.decode(s)) print(s) s = base64.b64decode(s) print(s) s = base64.a85decode(s) print(s)
def base_all(): cypher_text = '' plain_text = '' text = request.values.get('text') num_of_base = request.values.get('num_of_base') encode_or_decode = request.values.get('encode_or_decode') try: if text and num_of_base and encode_or_decode: if encode_or_decode == 'encode': plain_text = text.encode(encoding='utf-8') if num_of_base == '64': cypher_text = base64.b64encode(plain_text) elif num_of_base == '32': cypher_text = base64.b32encode(plain_text) elif num_of_base == '58': cypher_text = base58.b58encode(plain_text) elif num_of_base == '91': cypher_text = base91.encode(plain_text) # elif num_of_base == '92': # cypher_text = base92.encode(plain_text) elif num_of_base == '36': cypher_text = base36.loads(plain_text) # elif num_of_base=='16': # cypher_text = hex(plain_text) elif num_of_base == '62': cypher_text = base62.encodebytes(plain_text) elif num_of_base == '85': cypher_text = base64.a85encode(plain_text) if type(cypher_text) == bytes: resu = { 'code': 200, 'result': cypher_text.decode('utf-8'), 'length': len(cypher_text.decode('utf-8')) } else: resu = { 'code': 200, 'result': cypher_text, 'length': len(cypher_text) } return render_template('base-base64.html', result=resu) elif encode_or_decode == 'decode': cypher_text = text if num_of_base == '64': plain_text = base64.b64decode(cypher_text) elif num_of_base == '32': plain_text = base64.b32decode(cypher_text) elif num_of_base == '58': plain_text = base58.b58decode(cypher_text) elif num_of_base == '91': plain_text = base91.decode(cypher_text) # elif num_of_base == '92': # plain_text = base92.decode(cypher_text) elif num_of_base == '36': plain_text = base36.dumps(cypher_text) # elif num_of_base=='16': # plain_text = int(cypher_text) elif num_of_base == '62': plain_text = base62.decodebytes(cypher_text) elif num_of_base == '85': plain_text = base64.a85decode(cypher_text) if type(plain_text) == bytes: resu = { 'code': 200, 'result': plain_text.decode('utf-8'), 'length': len(plain_text.decode('utf-8')) } else: resu = { 'code': 200, 'result': plain_text, 'length': len(plain_text) } #resu = {'code': 200, 'cypher_text':plain_text.decode('utf-8') } return render_template('base-base64.html', result=resu) else: resu = {'code': 10001, 'message': 'args can not be blank!'} return render_template('base-base64.html', result=resu) except: resu = {'code': 10000, 'message': 'input error'} return render_template('base-base64.html', result=resu)
def test_decodebytes_type(): with pytest.raises(TypeError): base62.decodebytes(b"1234")
def decode(txt): print("[+]input is ", end="") print(txt) print( "==============================================================================" ) #base16 try: base16_decode = base64.b16decode(txt) print("[成功]base16 decode: ", end="") print(base16_decode) print() except Exception as e: print("[失败]base16 decode: ", end="") print(e) #base32 try: base32_decode = base64.b32decode(txt) print("[成功]base32 decode: ", end="") print(base32_decode) print() except Exception as e: print("[失败]base32 decode: ", end="") print(e) #base36 try: base36_decode = base36.loads(txt) print("[成功]base36 decode: ", end="") print(base36_decode) print() except Exception as e: print("[失败]base36 decode: ", end="") print(e) #base58 try: base58_decode = base58.b58decode(txt) print("[成功]base58 decode: ", end="") print(base58_decode) print() except Exception as e: print("[失败]base58 decode: ", end="") print(e) #base62 try: base62_c_string = bytes.decode(txt) base62_decode = base62.decodebytes(base62_c_string) print("[成功]base62 decode: ", end="") print(base62_decode) print() except Exception as e: print("[失败]base62 decode: ", end="") print(e) #base64 try: base64_decode = base64.b64decode(txt) print("[成功]base64 decode: ", end="") print(base64_decode) print() except Exception as e: print("[失败]base64 decode: ", end="") print(e) #base85 try: base85_decode = base64.a85decode(txt).decode() print("[成功]base85 decode: ", end="") print(base85_decode) print() except Exception as e: print("[失败]base85 decode: ", end="") print(e) #base91 try: base91_decode = base91.decode(str(txt, encoding="utf-8")).decode() print("[成功]base91 decode: ", end="") print(base91_decode) print() except Exception as e: print("[失败]base91 decode: ", end="") print(e) #base92 try: base92_decode = py3base92.decode(str(txt, encoding="utf-8")) print("[成功]base92 decode: ", end="") print(base92_decode) print() except Exception as e: print("[-]base92 decode: ", end="") print(e)
def decode_base(self): encoded_base = self.encoded_base process_decode = self.process_decode # decoding as base16 try: process_decode( base64.b16decode(encoded_base, casefold=False).decode('utf-8', 'replace'), 'Base16') except Exception as _: pass # decoding as base32 try: process_decode( base64.b32decode(encoded_base, casefold=False, map01=None).decode('utf-8', 'replace'), 'Base32') self.b32_once = True except Exception as _: pass # decoding as base32 (RFC 3548) if not self.b32_once: try: """ Base32 charset can differ based on their spec, this requires stripping the padding or changing charsets to get the correct results. By default this `anybase32` implementation follows the RFC 3548 spec. """ temp_clean_base = str.encode(encoded_base.replace('=', '')) process_decode( anybase32.decode(temp_clean_base).decode( 'utf-8', 'replace'), 'Base32') except Exception as _: pass # decoding as base36 try: process_decode(base36.dumps(int(encoded_base)), 'Base36') except Exception as _: pass # decoding as base58 try: process_decode( base58.b58decode(encoded_base.encode()).decode( 'utf-8', 'replace'), 'Base58') except Exception as _: pass # decoding as base62 try: process_decode( base62.decodebytes(encoded_base).decode('utf-8', 'replace'), 'Base62') except Exception as _: pass # decoding as base64 try: process_decode( base64.b64decode(encoded_base).decode('utf-8', 'replace'), 'Base64') except Exception as _: pass # decoding as base64url try: process_decode( base64.urlsafe_b64decode(encoded_base + '=' * (4 - len(encoded_base) % 4)).decode( 'utf-8', 'replace'), 'Base64URL') except Exception as _: pass # decoding as base85 try: process_decode( base64.b85decode(encoded_base).decode('utf-8', 'replace'), 'Base85') except Exception as _: pass # decoding as ascii85 try: process_decode( base64.a85decode(encoded_base).decode('utf-8', 'replace'), 'Ascii85') except Exception as _: pass # decoding as base91 try: process_decode( base91.decode(encoded_base).decode('utf-8', 'replace'), 'Base91') except Exception as _: pass # decoding as base92 try: process_decode(base92.decode(encoded_base), 'Base92') except Exception as _: pass # decoding as base100 lol why??!! try: process_decode(pybase100.decode(encoded_base).decode(), 'Base100') except Exception as _: pass
def decode_base(self, encoded_base): def contains_replacement_char(res): """ `contains_replacement_char()` checks whether the decoded base contains an unknown unicode, ie: invalid character. these are replaced with 'replacement character', which is '�' and 'U+FFFD' in unicode and also checks for unicode chars after `127`. """ if u'\ufffd' in res: return True else: count = 0 for char in res: if ord(char) > 127: count += 1 return True if count > 0 else False # to store the encoding schemes which haven't caused errors encoding_type = [] # to store the decoded results which haven't caused errors results = [] def process_decode(decode_string, scheme): """ `process_decode()` stores the result if the encoding is valid after checks from `contains_replacement_char()` and prints the output if it isn't an API call """ if len(decode_string) < 3: return if not contains_replacement_char(decode_string): # don't repeat `base64url` when `base64` has already passed and it's not a URL if scheme == 'Base64' and '://' not in decode_string: self.b64_once = True if self.b64_once and (scheme == 'Base64URL'): return # append results to the respective lists encoding_type.append(scheme) results.append(decode_string) if not self.api_call: if self.image_mode_call: print(colored('\n[-] Attempting Base: ', 'yellow')+colored(self.current_iter_base, 'red')) print(colored('\n[>] Decoding as {}: '.format(scheme), 'blue')+colored(decode_string, 'green')) # checking if input is valid in length if len(encoded_base) > 3: # decoding as base16 try: process_decode( base64.b16decode(encoded_base, casefold=False).decode('utf-8', 'replace'), 'Base16' ) except: pass # decoding as base32 try: process_decode( base64.b32decode(encoded_base, casefold=False, map01=None).decode('utf-8', 'replace'), 'Base32' ) except: pass # decoding as base36 try: process_decode( base36.dumps(int(encoded_base)), 'Base36' ) except: pass # decoding as base58 try: process_decode( base58.b58decode(encoded_base.encode()).decode('utf-8', 'replace'), 'Base58' ) except: pass # decoding as base62 try: process_decode( base62.decodebytes(encoded_base).decode('utf-8', 'replace'), 'Base62' ) except: pass # decoding as base64 try: process_decode( base64.b64decode(encoded_base).decode('utf-8', 'replace'), 'Base64' ) except: pass # decoding as base64url try: process_decode( base64.urlsafe_b64decode(encoded_base + '=' * (4 - len(encoded_base) % 4)).decode('utf-8', 'replace'), 'Base64URL' ) except: pass # decoding as base85 try: process_decode( base64.b85decode(encoded_base).decode('utf-8', 'replace'), 'Base85' ) except: pass # decoding as ascii85 try: process_decode( base64.a85decode(encoded_base).decode('utf-8', 'replace'), 'Ascii85' ) except: pass # decoding as base91 try: process_decode( base91.decode(encoded_base).decode('utf-8', 'replace'), 'Base91' ) except: pass # decoding as base92 try: process_decode( base92.decode(encoded_base), 'Base92' ) except: pass if not results and not self.api_call: if not self.image_mode_call: print(colored('\n[!] Not a valid encoding.\n', 'red')) if self.quit_after_fail: quit() # print/return the results for x in range(len(results)): if not self.api_call: print(colored('\n[-] The Encoding Scheme Is ', 'blue')+colored(encoding_type[x], 'green')) # generating the wordlist/output file with the decoded base if self.output != None: open(self.output, 'a').write(results[x]+'\n') else: return results[x], encoding_type[x] if self.image_mode_call and results: print(colored('\n{{<<', 'red')+colored('='*70, 'yellow')+colored('>>}}', 'red'))
def from_string(data: str) -> bytes: return base62.decodebytes(data)
def decode_base62(self, b62_encoded_text): return base62.decodebytes(b62_encoded_text).decode('ascii')
def decode_base(self, encoded_base): """ contains_replacement_char() checks whether the decoded base contains an unknown unicode, ie: invalid character. these are replaced with 'replacement character', which is '�' and 'U+FFFD' in unicode. """ def contains_replacement_char(res): return True if u'\ufffd' in res else False # to store the encoding schemes which haven't caused errors encoding_type = [] # to store the decoded results which haven't caused errors results = [] # checking if input is not empty if len(encoded_base) != 0: # decoding as base16 try: base16_decode = base64.b16decode(encoded_base, casefold=False).decode( 'utf-8', 'replace') if not contains_replacement_char(base16_decode): encoding_type.append('Base16') results.append(base16_decode) if not self.api_call: print( colored('\n[>] Decoding as Base16: ', 'blue') + colored(base16_decode, 'green')) except: pass # decoding as base32 try: base32_decode = base64.b32decode(encoded_base, casefold=False, map01=None).decode( 'utf-8', 'replace') if not contains_replacement_char(base32_decode): encoding_type.append('Base32') results.append(base32_decode) if not self.api_call: print( colored('\n[>] Decoding as Base32: ', 'blue') + colored(base32_decode, 'green')) except: pass # decoding as base36 try: base36_decode = base36.dumps(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base36_decode): encoding_type.append('Base36') results.append(base36_decode) if not self.api_call: print( colored('\n[>] Decoding as Base36: ', 'blue') + colored(base36_decode, 'green')) except: pass # decoding as base58 try: base58_decode = base58.b58decode(encoded_base.encode()).decode( 'utf-8', 'replace') if not contains_replacement_char(base58_decode): encoding_type.append('Base58') results.append(base58_decode) if not self.api_call: print( colored('\n[>] Decoding as Base58: ', 'blue') + colored(base58_decode, 'green')) except: pass # decoding as base62 try: base62_decode = base62.decodebytes(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base62_decode): encoding_type.append('Base62') results.append(base62_decode) if not self.api_call: print( colored('\n[>] Decoding as Base62: ', 'blue') + colored(base62_decode, 'green')) except: pass # decoding as base64 try: base64_decode = base64.b64decode(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base64_decode): encoding_type.append('Base64') results.append(base64_decode) if not self.api_call: print( colored('\n[>] Decoding as Base64: ', 'blue') + colored(base64_decode, 'green')) except: pass # decoding as base64url try: base64url_decode = base64.urlsafe_b64decode( encoded_base + '=' * (4 - len(encoded_base) % 4)).decode( 'utf-8', 'replace') if not contains_replacement_char(base64url_decode): encoding_type.append('Base64URL') results.append(base64url_decode) if not self.api_call: print( colored('\n[>] Decoding as Base64URL: ', 'blue') + colored(base64url_decode, 'green')) except: pass # decoding as base85 try: base85_decode = base64.b85decode(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base85_decode): encoding_type.append('Base85') results.append(base85_decode) if not self.api_call: print( colored('\n[>] Decoding as Base85: ', 'blue') + colored(base85_decode, 'green')) except: pass # decoding as ascii85 try: ascii85_decode = base64.a85decode(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(ascii85_decode): encoding_type.append('Ascii85') results.append(ascii85_decode) if not self.api_call: print( colored('\n[>] Decoding as Ascii85: ', 'blue') + colored(ascii85_decode, 'green')) except: pass # decoding as base91 try: base91_decode = base91.decode(encoded_base).decode( 'utf-8', 'replace') if not contains_replacement_char(base91_decode): encoding_type.append('Base91') results.append(base91_decode) if not self.api_call: print( colored('\n[>] Decoding as Base91: ', 'blue') + colored(base91_decode, 'green')) except: pass # decoding as base92 try: base92_decode = base92.decode(encoded_base) if not contains_replacement_char(base92_decode): encoding_type.append('Base92') results.append(base92_decode) if not self.api_call: print( colored('\n[>] Decoding as Base92: ', 'blue') + colored(base92_decode, 'green')) except: pass if not results and not self.api_call: quit(colored('\n[!] Not a valid encoding.\n', 'red')) # algorithm to identify which type of base encoding the input is for x in range(len(results)): """ It runs through all the results and compares them with a regex pattern of 'alphabets, numbers, and special characters' thus ending up with the right result as false results will contain invalid characters. """ if re.match('[A-Za-z0-9$&+,:;=?@#|\'<>.^*()%!_-]', results[x]): if not self.api_call: # printing the predicted encoding type print( colored('\n[-] The Encoding Scheme Is ', 'blue') + colored(encoding_type[x], 'green')) # generating the wordlist/output file with the decoded bases if self.output != None: open(self.output, 'a').write(results[x] + '\n') else: # return a tuple with the decoded base and encoding scheme if it's an api call return (results[x], encoding_type[x])
def test_decodebytes(s): assert base62.bytes_to_int(base62.decodebytes(s)) == base62.decode(s)
def BASE(): cypher_text = '' plain_text = '' #接收post的数据 data = request.get_data() data = data.decode('utf-8') data = json.loads(data) text = data['text'] #输入字符串 typed = data['typed'] #输入base(num),即base的类型 operator = data['operator'] #加密或者解密 # print(text) try: if text and typed and operator: if operator == 'encode': #加密算法 plain_text = text.encode(encoding='utf-8') if typed == 'BASE64': cypher_text = base64.b64encode(plain_text) elif typed == 'BASE32': cypher_text = base64.b32encode(plain_text) elif typed == 'BASE58': cypher_text = base58.b58encode(plain_text) elif typed == 'BASE91': cypher_text = base91.encode(plain_text) # elif num_of_base == '92': # cypher_text = base92.encode(plain_text) elif typed == 'BASE36': cypher_text = base36.loads(plain_text) # elif num_of_base=='16': # cypher_text = hex(plain_text) elif typed == 'BASE62': cypher_text = base62.encodebytes(plain_text) elif typed == 'BASE85': cypher_text = base64.a85encode(plain_text) if type(cypher_text) == bytes: resu = { 'code': 200, 'result': cypher_text.decode('utf-8'), 'length': len(cypher_text.decode('utf-8')) } #如果输出是字节流格式 else: resu = { 'code': 200, 'result': cypher_text, 'length': len(cypher_text) } #如果输出是字符串形式 return json.dumps(resu, ensure_ascii=False) elif operator == 'decode': #解密算法 cypher_text = text if typed == 'BASE64': plain_text = base64.b64decode(cypher_text) elif typed == 'BASE32': plain_text = base64.b32decode(cypher_text) elif typed == 'BASE58': plain_text = base58.b58decode(cypher_text) elif typed == 'BASE91': plain_text = base91.decode(cypher_text) # elif num_of_base == '92': # plain_text = base92.decode(cypher_text) elif typed == 'BASE36': plain_text = base36.dumps(cypher_text) # elif num_of_base=='16': # plain_text = int(cypher_text) elif typed == 'BASE62': plain_text = base62.decodebytes(cypher_text) elif typed == 'BASE85': plain_text = base64.a85decode(cypher_text) if type(plain_text) == bytes: resu = { 'code': 200, 'result': plain_text.decode('utf-8'), 'length': len(plain_text.decode('utf-8')) } # 如果输出是字节流格式 else: resu = { 'code': 200, 'result': plain_text, 'length': len(plain_text) } # 如果输出是字符串形式 #resu = {'code': 200, 'cypher_text':plain_text.decode('utf-8') } return json.dumps(resu, ensure_ascii=False) else: resu = {'code': 10001, 'result': '参数不能为空!'} return json.dumps(resu, ensure_ascii=False) except: resu = {'code': 10000, 'result': '输入字符集错误。'} return json.dumps(resu, ensure_ascii=False)
def rc4_decrypt(message, key): # message = bytes.decode(base64.b64decode(message.encode("utf-8"))) message = base62.decodebytes(message).decode("utf-8") result = rc4_process(message, rc4_init_vector(key)) return result
def test_decodebytes(s): assert base62.bytes_to_int(base62.decodebytes(s)) == base62.decode(s)
def decode_base(self, encoded_base): def contains_replacement_char(res): if u'\ufffd' in res: return True else: count = 0 for char in res: if ord(char) > 127: count += 1 return True if count > 0 else False encoding_type = [] results = [] def process_decode(decode_string, scheme): if len(decode_string) < 3: return if not contains_replacement_char(decode_string): if scheme == 'Base64' and '://' not in decode_string: self.b64_once = True if self.b64_once and (scheme == 'Base64URL'): return # append results to the respective lists encoding_type.append(scheme) results.append(decode_string) if not self.api_call: if self.image_mode_call: print( colored('\n[-] Attempting Base: ', 'yellow') + colored(self.current_iter_base, 'red')) print( colored('\n[>] Decoding as {}: '.format(scheme), 'blue') + colored(decode_string, 'green')) # checking if input is valid in length if len(encoded_base) > 3: # decoding as base16 try: process_decode( base64.b16decode(encoded_base, casefold=False).decode( 'utf-8', 'replace'), 'Base16') except: pass # decoding as base32 try: process_decode( base64.b32decode(encoded_base, casefold=False, map01=None).decode('utf-8', 'replace'), 'Base32') except: pass try: process_decode(base36.dumps(int(encoded_base)), 'Base36') except: pass try: process_decode( base58.b58decode(encoded_base.encode()).decode( 'utf-8', 'replace'), 'Base58') except: pass try: process_decode( base62.decodebytes(encoded_base).decode( 'utf-8', 'replace'), 'Base62') except: pass try: process_decode( base64.b64decode(encoded_base).decode('utf-8', 'replace'), 'Base64') except: pass try: process_decode( base64.urlsafe_b64decode( encoded_base + '=' * (4 - len(encoded_base) % 4)).decode( 'utf-8', 'replace'), 'Base64URL') except: pass # decoding as base85 try: process_decode( base64.b85decode(encoded_base).decode('utf-8', 'replace'), 'Base85') except: pass # decoding as ascii85 try: process_decode( base64.a85decode(encoded_base).decode('utf-8', 'replace'), 'Ascii85') except: pass # decoding as base91 try: process_decode( base91.decode(encoded_base).decode('utf-8', 'replace'), 'Base91') except: pass if not results and not self.api_call: if not self.image_mode_call: print(colored('\n[!] Not a valid encoding.\n', 'red')) if self.quit_after_fail: quit() for x in range(len(results)): if not self.api_call: print( colored('\n[-] The Encoding Scheme Is ', 'blue') + colored(encoding_type[x], 'green')) # generating the wordlist/output file with the decoded base if self.output != None: open(self.output, 'a').write(results[x] + '\n') else: return results[x], encoding_type[x] if self.image_mode_call and results: print( colored('\n{{<<', 'red') + colored('=' * 70, 'yellow') + colored('>>}}', 'red'))
def test_decodebytes_rtype(): """Make sure the return type of decodebytes() is bytes.""" decoded = base62.decodebytes("1234") assert isinstance(decoded, bytes)
def base_decode(n): m = '' flag = False try: if re.search('[a-e]', n): m = base64.b16decode(n, True) else: m = base64.b16decode(n) except binascii.Error: pass else: flag = True print("base16deocde:", m) return flag #''''''''''''''''''''''''''''''''' try: m = base64.b32decode(n) except binascii.Error: pass else: flag = True print("base32deocde:", m) return flag #''''''''''''''''''''''''''''''''' try: m = base58.b58decode(n) except ValueError: pass else: m = str(m)[2:-1] if '\\x' in m: pass else: flag = True print("base58deocde:", m) mm = str(base91.decode(n)) if '\\x' not in mm: print("maybe base91decode:", mm) return flag #''''''''''''''''''''''''''''''''' try: m = base62.decodebytes(n) except ValueError: pass else: m = str(m) if '\\x' in m: pass else: flag = True print("base62deocde:", m) return flag #''''''''''''''''''''''''''''''''' try: m = base64.b64decode(n) except binascii.Error: pass else: m = str(m) if '\\x' in m: pass else: flag = True print("base64deocde:", m) return flag #''''''''''''''''''''''''''''''''' try: m = base64.b85decode(n) except ValueError: pass else: m = str(m) if '\\x' in m: pass else: print("base_b85deocde:", m) flag = True return flag #''''''''''''''''''''''''''''''''' try: m = base64.a85decode(n) except ValueError: pass else: m = str(m) if '\\x' in m: pass else: print("base_a85deocde:", m) flag = True return flag #''''''''''''''''''''''''''''''''' try: m = base91.decode(n) except ValueError: pass else: m = str(m) if '\\x' in m: pass else: print("base91deocde:", m) flag = True return flag #''''''''''''''''''''''''''''''''' try: m = base92.decode(n) except ValueError: pass else: flag = True print("base92deocde:", m) return flag #''''''''''''''''''''''''''''''''' try: c = base36.loads(n) assert type(c) == int m = base36.dumps(c) except ValueError: pass else: flag = True print("base36deocde:", m) return flag # ''''''''''''''''''''''''''''''''' try: b128 = base128.base128(chars=None, chunksize=7) n_str = bytes(n, encoding="utf8") c = list(b128.encode(n_str)) m = b''.join(b128.decode(c)) except ValueError: pass else: flag = True print("base128deocde:", m) return flag return flag
def base_all(): cypher_text = '' plain_text = '' text = request.values.get('text') #输入字符串 num_of_base = request.values.get('num_of_base') #输入base(num),即base的类型 encode_or_decode = request.values.get('encode_or_decode') #加密或者解密 try: if text and num_of_base and encode_or_decode: if encode_or_decode == 'encode': #加密算法 plain_text = text.encode(encoding='utf-8') if num_of_base == '64': cypher_text = base64.b64encode(plain_text) elif num_of_base == '32': cypher_text = base64.b32encode(plain_text) elif num_of_base == '58': cypher_text = base58.b58encode(plain_text) elif num_of_base == '91': cypher_text = base91.encode(plain_text) # elif num_of_base == '92': # cypher_text = base92.encode(plain_text) elif num_of_base == '36': cypher_text = base36.loads(plain_text) # elif num_of_base=='16': # cypher_text = hex(plain_text) elif num_of_base == '62': cypher_text = base62.encodebytes(plain_text) elif num_of_base == '85': cypher_text = base64.a85encode(plain_text) if type(cypher_text) == bytes: resu = { 'code': 200, 'result': cypher_text.decode('utf-8'), 'length': len(cypher_text.decode('utf-8')) } #如果输出是字节流格式 else: resu = { 'code': 200, 'result': cypher_text, 'length': len(cypher_text) } #如果输出是字符串形式 return json.dumps(resu, ensure_ascii=False) elif encode_or_decode == 'decode': #解密算法 cypher_text = text if num_of_base == '64': plain_text = base64.b64decode(cypher_text) elif num_of_base == '32': plain_text = base64.b32decode(cypher_text) elif num_of_base == '58': plain_text = base58.b58decode(cypher_text) elif num_of_base == '91': plain_text = base91.decode(cypher_text) # elif num_of_base == '92': # plain_text = base92.decode(cypher_text) elif num_of_base == '36': plain_text = base36.dumps(cypher_text) # elif num_of_base=='16': # plain_text = int(cypher_text) elif num_of_base == '62': plain_text = base62.decodebytes(cypher_text) elif num_of_base == '85': plain_text = base64.a85decode(cypher_text) if type(plain_text) == bytes: resu = { 'code': 200, 'result': plain_text.decode('utf-8'), 'length': len(plain_text.decode('utf-8')) } # 如果输出是字节流格式 else: resu = { 'code': 200, 'result': plain_text, 'length': len(plain_text) } # 如果输出是字符串形式 #resu = {'code': 200, 'cypher_text':plain_text.decode('utf-8') } return json.dumps(resu, ensure_ascii=False) else: resu = {'code': 10001, 'message': '参数不能为空!'} return json.dumps(resu, ensure_ascii=False) except: resu = {'code': 10000, 'message': '输入字符集错误。'} return json.dumps(resu, ensure_ascii=False)
def decode_domain(data: str) -> bytes: """ s = data.split(".") m = map(lambda it: bytes.fromhex(it[1:]), s) return reduce(lambda a, b: a + b, list(m), b'')""" return base62.decodebytes( data[1:].replace(".x", "", 5) )