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