Пример #1
0
 def test_a85decode(self):
     eq = self.assertEqual
     tests = {b'': b'', b'GB\\6`E-ZP=Df.1GEb>': b'www.python.org',
         b'! ! * -\'"\n\t\t9eu\r\n7#  RL\x0bhG$k3[W&.oNg\'GVB"(`=52*$$(B+<_pR,UFcb-n-Vr/1iJ-0JP==1c70M3&s#]4?Ykm5X@_(6q\'R884cEH9MJ8X:f1+h<)lt#=BSg3>[:ZC?t!MSA7]@cBPD3sCi+\'.E,fo>FEMbNG^4U^I!pHnJ:W<)KS>/9Ll%"IN/`jYOHG]iPa.Q$R$jD4S=Q7DTV8*TUnsrdW2ZetXKAY/Yd(L?[\'d?O\\@K2_]Y2%o^qmn*`5Ta:aN;TJbg"GZd*^:jeCE.%f\\,!5gtgiEi8N\\UjQ5OekiqBum-X60nF?)@o_%qPq"ad`r;HT'
         : bytes(range(255)),
         b'@:E_WAS,RgBkhF"D/O92EH6,BF`qtRH$VbC6UX@47n?3D92&&T:Jand;cHat=\'/U/0JP==1c70M3&r-I,;<FN.OZ`-3]oSW/g+A(H[P'
         :
         b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#0^&*();:<>,. []{}'
         , b'DJpY:@:Wn_DJ(RS': b'no padding..', b'H=_,8+Cf>,E,oN2F(oQ1z':
         b'zero compression\x00\x00\x00\x00',
         b'H=_,8+Cf>,E,oN2F(oQ1!!!!': b'zero compression\x00\x00\x00',
         b'6>q!aA79M(3WK-[!!': b'Boundary:\x00\x00\x00\x00',
         b';fH/TAKYK$D/aMV+<VdL': b'Space compr:    ', b'rr': b'\xff',
         b's8N': b'\xff' * 2, b's8W*': b'\xff' * 3, b's8W-!': b'\xff' * 4}
     for data, res in tests.items():
         eq(base64.a85decode(data), res, data)
         eq(base64.a85decode(data, adobe=False), res, data)
         eq(base64.a85decode(data.decode('ascii'), adobe=False), res, data)
         eq(base64.a85decode(b'<~' + data + b'~>', adobe=True), res, data)
         eq(base64.a85decode(data + b'~>', adobe=True), res, data)
         eq(base64.a85decode('<~%s~>' % data.decode('ascii'), adobe=True
             ), res, data)
     eq(base64.a85decode(b'yy', foldspaces=True, adobe=False), b' ' * 8)
     eq(base64.a85decode(b'y+<Vd', foldspaces=True, adobe=False), b' ' * 7)
     eq(base64.a85decode(b'y+<U', foldspaces=True, adobe=False), b' ' * 6)
     eq(base64.a85decode(b'y+9', foldspaces=True, adobe=False), b' ' * 5)
     self.check_other_types(base64.a85decode, b'GB\\6`E-ZP=Df.1GEb>',
         b'www.python.org')
Пример #2
0
def pair_faces_in_blocks():
    db = get_db()
    c = db.cursor()
    c.execute("select count(*) from pairs where distance is null")
    cnt = c.fetchone()[0]
    if cnt == 0: return (0, 0)
    chunk_size = 500
    c.execute(
        """select p.face1, p.face2, f1.encoding, f2.encoding
                        from pairs p inner join faces f1 on p.face1 = f1.id
                        inner join faces f2 on p.face2 = f2.id
                        where distance is null limit ?""", (chunk_size, ))
    pairs_updates = []
    while True:
        nxt = c.fetchone()
        if not nxt: break
        face1, face2, encoding_string1, encoding_string2 = nxt
        encoding1 = np.fromstring(base64.a85decode(encoding_string1))
        encoding2 = np.fromstring(base64.a85decode(encoding_string2))
        distance = np.linalg.norm(encoding1 - encoding2)
        pairs_updates.append({
            "face1": face1,
            "face2": face2,
            "distance": distance
        })
    c.executemany(
        "UPDATE pairs SET distance=:distance WHERE face1=:face1 AND face2=:face2",
        pairs_updates)
    db.commit()
    return len(pairs_updates), cnt
Пример #3
0
    def decode(bytes_in: bytes) -> bytes:
        """
        Decodes data encoded in an ASCII base-85 representation
        """
        exceptions_to_throw = []

        # trivial case
        if len(bytes_in) == 0:
            return bytes_in

        # trimming
        if bytes_in[-1] == 10 and bytes_in[-2] == 13:
            bytes_in = bytes_in[0:-2]
        if bytes_in[-1] == 10:
            bytes_in = bytes_in[0:-1]
        if bytes_in[-1] == 13:
            bytes_in = bytes_in[0:-1]

        # normal decode
        try:
            return base64.a85decode(bytes_in)
        except Exception as e:
            exceptions_to_throw.append(e)
            pass

        # adobe decode
        try:
            return base64.a85decode(bytes_in, adobe=True)
        except Exception as e:
            exceptions_to_throw.append(e)
            pass

        # we should not be here
        raise exceptions_to_throw[0]
Пример #4
0
def get_private_key():
    """ Retrieves my private key from cache or the datastore """
    global _PRIVATE_KEY
    if _PRIVATE_KEY is None:
        entity = storage.retrieve("config", "bunq_private_key_1")
        private_1 = base64.a85decode(entity["value"])
        entity = storage.retrieve("config", "bunq_private_key_2")
        private_2 = base64.a85decode(entity["value"])
        _PRIVATE_KEY = serialization.load_pem_private_key(
            private_1 + private_2, password=None, backend=default_backend())
    return _PRIVATE_KEY
Пример #5
0
 def test_a85_padding(self):
     eq = self.assertEqual
     eq(base64.a85encode(b'x', pad=True), b'GQ7^D')
     eq(base64.a85encode(b'xx', pad=True), b"G^'2g")
     eq(base64.a85encode(b'xxx', pad=True), b'G^+H5')
     eq(base64.a85encode(b'xxxx', pad=True), b'G^+IX')
     eq(base64.a85encode(b'xxxxx', pad=True), b'G^+IXGQ7^D')
     eq(base64.a85decode(b'GQ7^D'), b'x\x00\x00\x00')
     eq(base64.a85decode(b"G^'2g"), b'xx\x00\x00')
     eq(base64.a85decode(b'G^+H5'), b'xxx\x00')
     eq(base64.a85decode(b'G^+IX'), b'xxxx')
     eq(base64.a85decode(b'G^+IXGQ7^D'), b'xxxxx\x00\x00\x00')
Пример #6
0
 def test_a85decode_errors(self):
     illegal = (set(range(32)) | set(range(118, 256))) - set(b' \t\n\r\x0b')
     for c in illegal:
         with self.assertRaises(ValueError, msg=bytes([c])):
             base64.a85decode(b'!!!!' + bytes([c]))
         with self.assertRaises(ValueError, msg=bytes([c])):
             base64.a85decode(b'!!!!' + bytes([c]), adobe=False)
         with self.assertRaises(ValueError, msg=bytes([c])):
             base64.a85decode(b'<~!!!!' + bytes([c]) + b'~>', adobe=True)
     self.assertRaises(ValueError, base64.a85decode, b'malformed', adobe
         =True)
     self.assertRaises(ValueError, base64.a85decode,
         b'<~still malformed', adobe=True)
     self.assertRaises(ValueError, base64.a85decode, b'<~~>')
     self.assertRaises(ValueError, base64.a85decode, b'<~~>', adobe=False)
     base64.a85decode(b'<~~>', adobe=True)
     self.assertRaises(ValueError, base64.a85decode, b'abcx', adobe=False)
     self.assertRaises(ValueError, base64.a85decode, b'abcdey', adobe=False)
     self.assertRaises(ValueError, base64.a85decode, b'a b\nc', adobe=
         False, ignorechars=b'')
     self.assertRaises(ValueError, base64.a85decode, b's', adobe=False)
     self.assertRaises(ValueError, base64.a85decode, b's8', adobe=False)
     self.assertRaises(ValueError, base64.a85decode, b's8W', adobe=False)
     self.assertRaises(ValueError, base64.a85decode, b's8W-', adobe=False)
     self.assertRaises(ValueError, base64.a85decode, b's8W-"', adobe=False)
Пример #7
0
    def test_a85decode_errors(self):
        illegal = (set(range(32)) | set(range(118, 256))) - set(b' \t\n\r\v')
        for c in illegal:
            with self.assertRaises(ValueError, msg=bytes([c])):
                base64.a85decode(b'!!!!' + bytes([c]))
            with self.assertRaises(ValueError, msg=bytes([c])):
                base64.a85decode(b'!!!!' + bytes([c]), adobe=False)
            with self.assertRaises(ValueError, msg=bytes([c])):
                base64.a85decode(b'<~!!!!' + bytes([c]) + b'~>', adobe=True)

        self.assertRaises(ValueError, base64.a85decode,
                                      b"malformed", adobe=True)
        self.assertRaises(ValueError, base64.a85decode,
                                      b"<~still malformed", adobe=True)

        # With adobe=False (the default), Adobe framing markers are disallowed
        self.assertRaises(ValueError, base64.a85decode,
                                      b"<~~>")
        self.assertRaises(ValueError, base64.a85decode,
                                      b"<~~>", adobe=False)
        base64.a85decode(b"<~~>", adobe=True)  # sanity check

        self.assertRaises(ValueError, base64.a85decode,
                                      b"abcx", adobe=False)
        self.assertRaises(ValueError, base64.a85decode,
                                      b"abcdey", adobe=False)
        self.assertRaises(ValueError, base64.a85decode,
                                      b"a b\nc", adobe=False, ignorechars=b"")

        self.assertRaises(ValueError, base64.a85decode, b's', adobe=False)
        self.assertRaises(ValueError, base64.a85decode, b's8', adobe=False)
        self.assertRaises(ValueError, base64.a85decode, b's8W', adobe=False)
        self.assertRaises(ValueError, base64.a85decode, b's8W-', adobe=False)
        self.assertRaises(ValueError, base64.a85decode, b's8W-"', adobe=False)
    def test_a85_padding(self):
        eq = self.assertEqual

        eq(base64.a85encode(b"x", pad=True), b'GQ7^D')
        eq(base64.a85encode(b"xx", pad=True), b"G^'2g")
        eq(base64.a85encode(b"xxx", pad=True), b'G^+H5')
        eq(base64.a85encode(b"xxxx", pad=True), b'G^+IX')
        eq(base64.a85encode(b"xxxxx", pad=True), b'G^+IXGQ7^D')

        eq(base64.a85decode(b'GQ7^D'), b"x\x00\x00\x00")
        eq(base64.a85decode(b"G^'2g"), b"xx\x00\x00")
        eq(base64.a85decode(b'G^+H5'), b"xxx\x00")
        eq(base64.a85decode(b'G^+IX'), b"xxxx")
        eq(base64.a85decode(b'G^+IXGQ7^D'), b"xxxxx\x00\x00\x00")
Пример #9
0
    def test_a85decode_errors(self):
        illegal = (set(range(32)) | set(range(118, 256))) - set(b' \t\n\r\v')
        for c in illegal:
            with self.assertRaises(ValueError, msg=bytes([c])):
                base64.a85decode(b'!!!!' + bytes([c]))
            with self.assertRaises(ValueError, msg=bytes([c])):
                base64.a85decode(b'!!!!' + bytes([c]), adobe=False)
            with self.assertRaises(ValueError, msg=bytes([c])):
                base64.a85decode(b'<~!!!!' + bytes([c]) + b'~>', adobe=True)

        self.assertRaises(ValueError, base64.a85decode,
                                      b"malformed", adobe=True)
        self.assertRaises(ValueError, base64.a85decode,
                                      b"<~still malformed", adobe=True)

        # With adobe=False (the default), Adobe framing markers are disallowed
        self.assertRaises(ValueError, base64.a85decode,
                                      b"<~~>")
        self.assertRaises(ValueError, base64.a85decode,
                                      b"<~~>", adobe=False)
        base64.a85decode(b"<~~>", adobe=True)  # sanity check

        self.assertRaises(ValueError, base64.a85decode,
                                      b"abcx", adobe=False)
        self.assertRaises(ValueError, base64.a85decode,
                                      b"abcdey", adobe=False)
        self.assertRaises(ValueError, base64.a85decode,
                                      b"a b\nc", adobe=False, ignorechars=b"")

        self.assertRaises(ValueError, base64.a85decode, b's', adobe=False)
        self.assertRaises(ValueError, base64.a85decode, b's8', adobe=False)
        self.assertRaises(ValueError, base64.a85decode, b's8W', adobe=False)
        self.assertRaises(ValueError, base64.a85decode, b's8W-', adobe=False)
        self.assertRaises(ValueError, base64.a85decode, b's8W-"', adobe=False)
Пример #10
0
def decode(payload: Union[bytes, str]) -> bytes:
    print("Decoding Layer 5...")

    result: bytes = b''
    decoded = base64.a85decode(payload, adobe=True)

    # As per instruction:
    # First 32 bytes: The 256-bit key encrypting key (KEK).
    key_encryption_key = decoded[0:32]
    # Next 8 bytes: The 64-bit initialization vector (IV) for
    # the wrapped key.
    wrapped_key_init_vector = decoded[32:40]
    # Next 40 bytes: The wrapped (encrypted) key. When
    # decrypted, this will become the 256-bit encryption key.
    wrapped_key = decoded[40:80]
    # Next 16 bytes: The 128-bit initialization vector (IV) for
    # the encrypted payload.
    init_vector = decoded[80:96]
    # All remaining bytes: The encrypted payload.
    encrypted = decoded[96:]

    # The first step is to use the KEK and the 64-bit IV to unwrap the wrapped key.
    key = aes_key_unwrap(wrapped_key, key_encryption_key,
                         wrapped_key_init_vector)
    # print("key:", key)

    # The second step is to use the unwrapped key and the 128-bit IV to decrypt the rest of the payload.
    cipher = AES.new(key, AES.MODE_CTR, nonce=b'', initial_value=init_vector)
    result = cipher.decrypt(pad(encrypted, AES.block_size))

    with open("layer6", "wb+") as layer_file:
        layer_file.write(result)

    return result
Пример #11
0
 def func(self):
     try:
         index = 0
         _code_a = ''
         _code_b = ''
         _de_a = ''
         _de_b = ''
         while index < len(self.text):
             _code_a += self.text[index]
             index += 2
         index = 1
         while index < len(self.text):
             _code_b += self.text[index]
             index += 2
         try:
             _de_a += base64.a85decode(str.encode(_code_a)).decode('utf-8')
             _de_b += base64.b85decode(str.encode(_code_b)).decode('utf-8')
         except Exception as exc:
             print(exc)
             self.result['message'] = 'Строка повреждена'
             return True
         if _de_a == _de_b and _de_a != '':
             self.result['message'] = _de_a
         return True
     except Exception as e:
         self.result['message'] = str(e)
         return False
Пример #12
0
def bguess(encoded):
    try:
        print("[+] base91 : ->", base91.decode(encoded), "\n")
    except:
        print("[-] base91 : ->  Invalid\n")
    try:
        print("[+] base85 : ->", base64.b85decode(encoded), "\n")
    except:
        print("[-] base85 : ->  Invalid\n")
    try:
        print("[+] ASCII85 : -> ", base64.a85decode(encoded), "\n")
    except:
        print("[-] ASCII85 : ->  Invalid\n")
    try:
        print("[+] base64 : ->", base64.b64decode(encoded), "\n")
    except:
        print("[-] base64 : ->  Invalid\n")
    try:
        print("[+] base62 : ->", base62.decode(encoded), "\n")
    except:
        print("[-] base62 : ->  Invalid\n")
    try:
        print("[+] base58 : ->", base58.b58decode(encoded), "\n")
    except:
        print("[-] base58 : -> \n")
    try:
        print("[+] base32 : ->", base64.b32decode(encoded), "\n")
    except:
        print("[-] base32 : -> Invalid\n")
    try:
        print("[+] base16 : ->", base64.b16decode(encoded), "\n")
    except:
        print("[-] base16 : -> Invalid\n")
Пример #13
0
def layer5(payload):
    decoded = base64.a85decode(payload, adobe=True)
    key = aes_unwrap_key(decoded[:32], decoded[40:80],
                         int.from_bytes(decoded[32:40], byteorder='big'))
    cipher = AES.new(key, AES.MODE_CBC, iv=decoded[80:96])
    data = cipher.decrypt(decoded[96:])
    return data.decode()
Пример #14
0
def main():
    inp = input('->')
    encoded = inp.encode(
        'utf-8')  # encoded the input (we need a bytes like object)
    a85encoded = base64.a85encode(encoded)  # a85encoded the encoded string
    print(a85encoded)
    print(base64.a85decode(a85encoded).decode('utf-8'))  # decoded it
Пример #15
0
 def _sync(self):
     imap = self._chump.get_imap()
     typ, count = imap.select()
     count = count[0].decode()
     if count == '0':
         return
     typ, data = imap.fetch('1:*', '(UID RFC822)')
     messages = [ x
         for x in data
         if isinstance(x, tuple) ]
     offers = []
     for (mkey, mvalue) in messages:
         message = email.message_from_string(mvalue.decode())
         uid = re.search(rb'UID\s*(\d+)', mkey).group(1).decode()
         full_message = None
         try:
             # https://stackoverflow.com/questions/45124127/
             full_message = msgpack.unpackb(base64.a85decode(message.get_payload()), encoding='utf-8')
         except:
             # Just ignore seriously malformed messages
             pass
         if full_message is not None and 'key' in full_message:
             if full_message['key'] == '__answer':
                 self._chump.tcpdict[full_message['sender']].got_answer(full_message['body'])
                 self.doomed.put(uid)
             elif full_message['key'] == '__offer':
                 self.doomed.put(uid)
                 if (int(time()) - full_message['timestamp']) < 60:
                     self._chump.tcpdict[full_message['sender']].got_offer(full_message['offer'])
             else:
                 self._chump.queues[full_message['key']][uid] = full_message
         else:
             self.doomed.put(uid)
Пример #16
0
 async def decode_ascii85(self, ctx, *, input: str):
     """ Decode ASCII85 """
     try:
         await self.encryptout(ctx, "ASCII85 -> Text",
                               base64.a85decode(input.encode('UTF-8')))
     except Exception:
         await ctx.send("Invalid ASCII85...")
Пример #17
0
def main() -> None:
    inp = input("->")
    encoded = inp.encode(
        "utf-8")  # encoded the input (we need a bytes like object)
    a85encoded = base64.a85encode(encoded)  # a85encoded the encoded string
    print(a85encoded)
    print(base64.a85decode(a85encoded).decode("utf-8"))  # decoded it
Пример #18
0
def four():
    txt = open("./data/payload_4.txt", "r")
    txt_string = txt.read()
    txt_decode = base64.a85decode(txt_string, adobe=True)

    decoded = []

    start = 0

    while start < len(txt_decode):
        (size, source_ip, dest_ip, ipv4_valid) = ipv4_header(
            txt_decode[start : start + 20]
        )
        (dest_port, udp_valid) = udp_header(
            txt_decode[start + 20 : start + 28],
            txt_decode[start : start + 20],
            txt_decode[start + 28 : start + size],
        )

        if (
            source_ip == "10.1.1.10"
            and dest_ip == "10.1.1.200"
            and dest_port == 42069
            and ipv4_valid
            and udp_valid
        ):
            decoded.extend(txt_decode[start + 28 : start + size])

        start = start + size

    five = open("./decrypted/5.txt", "w")
    five.write(bytes(decoded).decode("utf8"))
    five.close()
Пример #19
0
def decrypt85(value85):
    try:
        decode85 = base64.a85decode(value85)
        dec85 = decode85.decode("UTF-8")
        print("Decoded with Base85: " + dec85)
    except:
        print("Value is not Base85.")
Пример #20
0
def decode(payload: Union[bytes, str]) -> bytes:
    print("Decoding Layer 2...")

    result: bytes = b''
    data_group: str = ''
    i = 0
    for byte in base64.a85decode(payload, adobe=True):
        # print("---")
        # print("byte:",byte)
        first_seven_bits = format(byte, '08b')[:7]
        # print("first_seven_bits:",first_seven_bits)
        parity_bit = byte & 0b00000001
        # print("parity_bit:",parity_bit)
        num_one_bits = first_seven_bits.count('1')
        # print("num_one_bits:",num_one_bits)
        if (num_one_bits % 2) == parity_bit:
            data_group += first_seven_bits
            i += 1
            # print("i:", i)
            if i % 8 == 0:
                # print(data_group)
                for j in range(7):
                    # print("j:", j)
                    data_byte = int(data_group[j * 8:(j + 1) * 8], 2)
                    # print("data_group[j*8:(j+1)*8]:",data_group[j*8:(j+1)*8])
                    result += data_byte.to_bytes(1, 'big')
                data_group = str()

    with open("layer3", "wb+") as layer_file:
        layer_file.write(result)

    return result
Пример #21
0
def decrypt(arguments):
    """Decrypt the input file"""
    if arguments.input_file:
        source_data = arguments.input_file.read_bytes()
    else:
        source_data = sys.stdin.buffer.read()
    #
    try:
        source_data = base64.a85decode(source_data)
    except ValueError:
        pass
    #
    decryption_password = getpass.getpass(
        'Enter decryption password: '******'utf-8')
    scrypt_file = pyscrypt.ScryptFile(io.BytesIO(source_data),
                                      password=decryption_password)
    try:
        decrypted_data = scrypt_file.read()
    except pyscrypt.file.InvalidScryptFileFormat as error:
        logging.error('Error while decrypting input: %s', error)
        return False
    #
    decompressed_data = lzma.decompress(XZ_HEADER + decrypted_data)
    if arguments.output_file:
        arguments.output_file.write_bytes(decompressed_data)
    else:
        sys.stdout.buffer.write(decompressed_data)
    #
    return True
Пример #22
0
def ascii2uuid(s: str) -> str:
    """
    Convert an ASCII string to an UUID hexadecimal string
    :param s: an ASCII string
    :return: an UUID hexadecimal string
    """
    return str(uuid.UUID(bytes=base64.a85decode(s)))
Пример #23
0
 def parse_packet(self, packet: bytes):
     data = None
     try:
         id, command, data = packet.split(b':', 2)
     except ValueError:
         try:
             id, command = packet.split(b':')
         except ValueError:
             return None
     id = int(id)
     retval = None
     try:
         if command == b'fullscreen':
             pygame.display.toggle_fullscreen()
         elif command == b'setframerate':
             self.framerate = int(data)
         elif command == b'resize':
             x, y = data.split(b'x')
             x = int(x)
             y = int(y)
             self.display = pygame.display.set_mode((x, y))
         elif command == b'img':
             x, y, encoding, compression, imagestr = data.split(b':', 4)
             x = int(x)
             y = int(y)
             encoding = encoding.decode()
             compression = compression.decode()
             if compression == 'gzip':
                 imagestr = gzip.decompress(imagestr)
             elif compression == 'base64':
                 imagestr = base64.b64decode(imagestr)
             elif compression == 'base32':
                 imagestr = base64.b32decode(imagestr)
             elif compression == 'base85':
                 imagestr = base64.a85decode(imagestr)
             elif compression == 'base16':
                 imagestr = base64.b16decode(imagestr)
             elif compression == 'none':
                 pass
             else:
                 raise ValueError(
                     'compression method `{}` not supported'.format(
                         compression))
             self.surface = pygame.image.fromstring(imagestr, (x, y),
                                                    encoding)
         elif command == b'exec':
             code = data.decode()
             exec(code)
         elif command == b'eval':
             code = data.decode()
             retval = eval(code)
         elif command == b'ping':
             pass
         else:
             raise ValueError('command {} not supported'.format(command))
         self.ack(id, retval)
     except:
         exc = traceback.format_exc().split('\n')[-2]
         self.nak(id, exc)
Пример #24
0
    async def decode_ascii85(self, ctx, *, input: commands.clean_content = None):
        if not input:
            input = await self.detect_file(ctx)

        try:
            await self.encryptout(ctx, "ASCII85 -> Text", base64.a85decode(input.encode('UTF-8')))
        except Exception:
            await ctx.send("Invalid ASCII85...")
Пример #25
0
def _convert_payloads(raw_payloads):
    payloads = []
    for item in raw_payloads:
        try:
            payloads.append(a85decode(item, adobe=True))
        except Exception as e:
            logging.error('Could not decode payload: {} - {}'.format(sys.exc_info()[0].__name__, e))
    return payloads
Пример #26
0
def six():
    txt = open("./data/payload_6.txt", "r")
    txt_string = txt.read()
    txt_decode = base64.a85decode(txt_string, adobe=True)

    # vm = Vm(bytes.fromhex('50 48 c2 02 a8 4d 00 00 00 4f 02 50 09 c4 02 02 e1 01 4f 02 c1 22 1d 00 00 00 48 30 02 58 03 4f 02 b0 29 00 00 00 48 31 02 50 0c c3 02 aa 57 48 02 c1 21 3a 00 00 00 48 32 02 48 77 02 48 6f 02 48 72 02 48 6c 02 48 64 02 48 21 02 01 65 6f 33 34 2c'))
    vm = Vm(bytearray(txt_decode))
    vm.run()
Пример #27
0
def _convert_payloads(raw_payloads):
    payloads = []
    for item in raw_payloads:
        try:
            payloads.append(a85decode(item, adobe=True))
        except binascii.Error as error_message:
            logging.error('Could not decode payload: {}'.format(error_message))
    return payloads
Пример #28
0
    def test_decode(self):
        for phrase in self.phrases_to_decode:
            phrase = phrase.encode("utf-8")

            actual = ascii85.decode(phrase)
            expected = base64.a85decode(phrase, adobe=True)

            self.assertEqual(actual, expected)
Пример #29
0
def step_decode(text_string: str):
    encoded_bytes = bytes(text_string, encoding="ascii")
    logging.debug(f"Sanity : {encoded_bytes}")
    decoded_bytes_array = [_steps_down(byte) for byte in encoded_bytes]
    decoded_bytes = bytes(decoded_bytes_array)
    logging.debug(f"Decoded + unshifted : {decoded_bytes}")
    text_bytes = a85decode(decoded_bytes)
    return str(text_bytes, encoding="ascii")
Пример #30
0
def start():
    txt = open("./data/payload.txt", "r")
    txt_string = txt.read()
    txt_decode = base64.a85decode(txt_string, adobe=True)

    one = open("./decrypted/1.txt", "w")
    one.write(txt_decode.decode("UTF-8"))
    one.close()
Пример #31
0
    async def decode_ascii85(self, ctx, *, _input: clean_content = None):
        """ Decode in ASCII85 """
        if not _input:
            _input = await detect_file(ctx)

        try:
            await encrypt_out(ctx, "ASCII85 -> Text", base64.a85decode(_input.encode('UTF-8')))
        except Exception:
            await ctx.send("Invalid ASCII85...")
Пример #32
0
def b85(text, encode=False):
    import base64
    text = bytes(text, "utf-8")
    if encode:
        return SUCCESS % base64.a85encode(text).decode("utf-8")
    try:
        return SUCCESS % str(base64.a85decode(text))[2:-1]
    except:
        return FAIL % "Invalid base85 input"
Пример #33
0
    def test_a85decode(self):
        eq = self.assertEqual

        tests = {
            b'': b'',
            b'GB\\6`E-ZP=Df.1GEb>': b'www.python.org',
            b"""! ! * -'"\n\t\t9eu\r\n7#  RL\vhG$k3[W&.oNg'GVB"(`=52*$$"""
               b"""(B+<_pR,UFcb-n-Vr/1iJ-0JP==1c70M3&s#]4?Ykm5X@_(6q'R884cE"""
               b"""H9MJ8X:f1+h<)lt#=BSg3>[:ZC?t!MSA7]@cBPD3sCi+'.E,fo>FEMbN"""
               b"""G^4U^I!pHnJ:W<)KS>/9Ll%"IN/`jYOHG]iPa.Q$R$jD4S=Q7DTV8*TU"""
               b"""nsrdW2ZetXKAY/Yd(L?['d?O\\@K2_]Y2%o^qmn*`5Ta:aN;TJbg"GZd"""
               b"""*^:jeCE.%f\\,!5gtgiEi8N\\UjQ5OekiqBum-X60nF?)@o_%qPq"ad`"""
               b"""r;HT""": bytes(range(255)),
            b"""@:E_WAS,RgBkhF"D/O92EH6,BF`qtRH$VbC6UX@47n?3D92&&T:Jand;c"""
                b"""Hat='/U/0JP==1c70M3&r-I,;<FN.OZ`-3]oSW/g+A(H[P""":
                b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234'
                b'56789!@#0^&*();:<>,. []{}',
            b'DJpY:@:Wn_DJ(RS': b'no padding..',
            b'H=_,8+Cf>,E,oN2F(oQ1z': b'zero compression\x00\x00\x00\x00',
            b'H=_,8+Cf>,E,oN2F(oQ1!!!!': b'zero compression\x00\x00\x00',
            b'6>q!aA79M(3WK-[!!': b"Boundary:\x00\x00\x00\x00",
            b';fH/TAKYK$D/aMV+<VdL': b'Space compr:    ',
            b'rr': b'\xff',
            b's8N': b'\xff'*2,
            b's8W*': b'\xff'*3,
            b's8W-!': b'\xff'*4,
            }

        for data, res in tests.items():
            eq(base64.a85decode(data), res, data)
            eq(base64.a85decode(data, adobe=False), res, data)
            eq(base64.a85decode(data.decode("ascii"), adobe=False), res, data)
            eq(base64.a85decode(b'<~' + data + b'~>', adobe=True), res, data)
            eq(base64.a85decode(data + b'~>', adobe=True), res, data)
            eq(base64.a85decode('<~%s~>' % data.decode("ascii"), adobe=True),
               res, data)

        eq(base64.a85decode(b'yy', foldspaces=True, adobe=False), b' '*8)
        eq(base64.a85decode(b'y+<Vd', foldspaces=True, adobe=False), b' '*7)
        eq(base64.a85decode(b'y+<U', foldspaces=True, adobe=False), b' '*6)
        eq(base64.a85decode(b'y+9', foldspaces=True, adobe=False), b' '*5)

        self.check_other_types(base64.a85decode, b'GB\\6`E-ZP=Df.1GEb>',
                               b"www.python.org")
Пример #34
0
 def read_from_source(self, n):
     out_data = b''
     while len(out_data) < n:
         in_data = self._source.read(n)
         in_data = self.rest + in_data.translate(None, ASCII_WHITESPACE)
         if not in_data:
             self.rest = b''
             break
         eod_index = in_data.find(b'~')
         if eod_index > 0:
             assert in_data[eod_index:] == b'~>'
             out_data += a85decode(in_data[:eod_index])
             self.rest = b''
             break
         rest_len = len(in_data) % 5
         if rest_len:
             input, self.rest = in_data[:-rest_len], in_data[-rest_len:]
         else:
             input, self.rest = in_data, b''
         out_data += a85decode(input)
     return out_data
def read_game_data(username):

    filename = "savefile_" + username + ".txt"

    with open(filename, "rb") as f:
        data = f.read()

    data = data[:data.rindex(b';')]

    utf8_decoded_data = a85decode(data).decode("utf-8")
    print('utf8_decoded_data:', utf8_decoded_data)

    return game_model.GameState(utf8_decoded_data.split("_"))
Пример #36
0
	def decodebase(encoder): #Functions for decode for all base's
		decode = {} 
		try: 
			decode["Base64"] = str(base64.b64decode(encoder), "utf-8")
		except:
			decode["Base64"] = "Not is Base64"
		try:
			decode["Base32"] = str(base64.b32decode(encoder), "utf-8")
		except:
			decode["Base31"] = "Not is Base32"
		try:
			decode["Base16"] = str(base64.b16decode(encoder), "utf-8")
		except:
			decode["Base16"] = "Not is Base16"
		try:
			decode["a85"] = str(base64.a85decode(encoder), "utf-8")
		except:
			decode["a85"] = "Not is a85"
		return decode
Пример #37
0
def a85encode(data, **kwargs):
    return base64.a85decode(data)
Пример #38
0
    def _handle_client(self, client_reader, client_writer, address):
        """
        This method actually does the work to handle the requests for a specific client. The protocol is byte AND line
        oriented, the command is read first (8 bytes) and matched against available commands, the complete line (up to
        64k) is read into memory and must end with newline character. The received data is verified against the received
        user id's public key. Once verified, the matched command is executed.

        @param client_reader: StreamReader object
        @param client_writer: StreamWriter object
        """
        while True:
            # recevied incoming data time stamp
            stamp = int(time())
            # read command first, only take first 8 bytes
            cmd = yield from client_reader.readexactly(COMMAND_LENGTH)

            if not cmd:
                # nothing received from client
                break

            ################
            # Data checking
            ################

            # check received command is valid
            try:
                command = Commands[int(cmd)]
            except ValueError:
                logging.info("\t".join(("Invalid Command Provided By Client",
                                        "IP: {!r}".format(address),
                                        "Command: {!r}".format(cmd))))
                yield from self._close_connection(client_writer, INVALID_COMMAND)
                return

            try:
                # use of encoded data allows for direct readline()
                data = yield from client_reader.readline()

            except asyncio.futures.TimeoutError:
                yield from self._close_connection(client_writer, TIMEOUT)
                return

            # clear up data before proceeding (i.e newline char)
            data = data.strip()

            ################
            # Authorisation
            ################
            if command != friendAcceptance:
                try:
                    data = a85decode(data, foldspaces=True)
                except ValueError:
                    logging.info("Invalid data received, unable to decode as ASCII85")
                    yield from self._close_connection(client_writer, INVALID_COMMAND)
                    return

                # verify data integrity
                try:
                    # using getAuthority hits the disk db
                    data = VerifyKey(getAuthority(self.safe, self.profileId, self.friendMasks[data[-36:]])[0],
                                     encoder=HexEncoder).verify(data)
                except (BadSignatureError, TypeError):
                    # signed data does not match stored public key for provided user id
                    logging.warning('\t'.join(("Unable to verify sent data",
                                               "IP: {!r}".format(address),
                                               "Data: {!r}".format(data),
                                               "Sent ID: {!r}".format(data[-36:]))))
                    yield from self._close_connection(client_writer, INVALID_DATA)
                    return

                # data received as: timestamp, hash chain hex, destination user id, data, sender user id
                tstamp, chain, dest, origin = data[:10], data[10:50], data[50:86], data[-36:]
                data = data[86:-36]

                ###########################
                # Message integrity checks
                ###########################
                integrity = True
                # validation checks
                if dest != self.uid:
                    logging.warning("Message Integrity Failure: User id destination {!r} differs from logged in user".format(dest))
                    integrity = False

                try:

                    if integrity and (stamp + LIMIT_MESSAGE_TIME) < int(tstamp) < (stamp - LIMIT_MESSAGE_TIME):
                        logging.warning("Message Integrity Failure: Message is either too old or in the future, current time '{}' received stamp '{}'".format(stamp, int(tstamp)))
                        integrity = False
                except ValueError:
                        logging.warning("Message Integrity Failure: Message time {!r} is invalid".format(tstamp))

                if integrity and isValidUUID(origin):
                    hchain = bytes(sha1(b''.join((self.hashchain[address], data))).hexdigest(), encoding='ascii')
                    if hchain != chain:
                        logging.warning("Message Integrity Failure: Provided hash chain {!r} does not match local {!r}".format(chain, hchain))
                        integrity = False
                else:
                    logging.warning("Message Integrity Failure: Invalid UUID provided by {!r}".format(origin))
                    integrity = False

                if not integrity:
                    yield from self._close_connection(client_writer, INVALID_COMMAND)
                    return

                try:
                    # ensure command integrity for authorised commands
                    assert Commands[int(data[-COMMAND_LENGTH:])] == command
                except (ValueError, AssertionError):
                    logging.info('\t'.join(("Client unsigned CMD data does not equal signed CMD",
                                            "IP: {!r}".format(address),
                                            "Unsigned Command: {!r}".format(cmd),
                                            "Signed Command: {!r}".format(data[-COMMAND_LENGTH:]))))
                    yield from self._close_connection(client_writer, INVALID_DATA)
                    return

                # all checks cleared, update hash chain
                self.hashchain[address] = hchain

                # data verified, execute command with data and origin user id
                returnData = yield from self._command_dispatch(client_reader, client_writer, command, b''.join((data, origin)))
            else:
                returnData, authToken = yield from friendAcceptance(client_reader, client_writer, self.safe, self.profileId, data)
                if authToken is not None:
                    self.auth.append(authToken)

            # send command result to client
            client_writer.write(returnData)

            # Flush buffer
            yield from client_writer.drain()
Пример #39
0
#!/usr/bin/env python3

import base64
import codecs

text = "HR7DYQ3ON4TC6U2AFAZDGJK3J44TYXZUNRCTATK2GEZDGJR5JJUC6ULUFQZEI5L6HY======"
print("\t" + text)

text = base64.b32decode(text)
print("B32:\t" + str(text)[2:-1])

text = base64.a85decode(text, adobe=True)
print("A85:\t" + str(text)[2:-1])

text = codecs.encode(str(text), "rot-13")
print("R13:\t" + str(text)[2:-1])
Пример #40
0
    def parse_str(self, encode_str, decode_method, m_list):
        if len(m_list) > self.max_depth:
            return False, encode_str

        # encode_str = deepcopy(encode_str)
        encode_str = utf8(encode_str)
        if decode_method in ['zlib']:
            encode_str = utf8(encode_str)
        else:
            encode_str = to_unicode(encode_str)

        raw_encode_str = deepcopy(encode_str)
        if len(encode_str) <= 0:
            return False, raw_encode_str

        try:
            if decode_method == 'base16':
                # 避免无限递归
                # base_list = ('base16', 'base32', 'base64', 'urlsafe_b64')
                # base_list = ()
                if len(encode_str) < 4:
                    return False, raw_encode_str

                encode_str = encode_str.upper()
                rex = re.compile('^[0-9A-F]+[=]*$', re.MULTILINE)
                if self.regex_match(rex, encode_str):
                    decode_str = partial_base16_decode(encode_str)
                else:
                    return False, raw_encode_str
            elif decode_method == 'base32':
                encode_str = encode_str.strip().replace(' ', '').replace('\n', '')
                # 避免无限递归
                # base_list = ('base16', 'base32', 'base64', 'urlsafe_b64')
                # base_list = ()
                if len(encode_str) < 4:
                    return False, raw_encode_str

                encode_str = encode_str.upper()
                rex = re.compile('^[A-Z2-7=]+$', re.MULTILINE)
                # 自动纠正填充
                if self.regex_match(rex, encode_str):
                    decode_str = partial_base32_decode(encode_str)
                else:
                    return False, raw_encode_str
            elif decode_method == 'base64':
                encode_str = encode_str.strip().replace(' ', '').replace('\n', '')

                # 避免无限递归
                # base_list = ('base16', 'base32', 'base64', 'urlsafe_b64')
                # base_list = ()
                if len(encode_str) < 4:
                    return False, raw_encode_str

                rex = re.compile('^[A-Za-z0-9+/=]+$', re.MULTILINE)
                # 自动纠正填充
                if self.regex_match(rex, encode_str):
                    decode_str = partial_base64_decode(encode_str)
                else:
                    return False, raw_encode_str
            elif decode_method == 'urlsafe_b64':
                encode_str = encode_str.strip().replace(' ', '').replace('\n', '')
                # base_list = ('base16', 'base32', 'base64', 'urlsafe_b64')
                # base_list = ()
                if len(encode_str) < 4:
                    return False, raw_encode_str
                rex = re.compile('^[A-Za-z0-9-_=]+$', re.MULTILINE)
                # 自动纠正填充
                if self.regex_match(rex, encode_str):
                    decode_str = urlsafe_b64decode(base_padding(encode_str, 4))
                else:
                    return False, raw_encode_str
            elif decode_method == 'ascii_85':
                if len(encode_str) < 7:
                    return False, raw_encode_str

                if PY2:
                    return False, raw_encode_str

                rex = re.compile('^[A-Za-z0-9!#$%&()*+\-;<=>?@^_`{|}~]+$', re.MULTILINE)
                if self.regex_match(rex, encode_str):
                    decode_str = a85decode(utf8(encode_str))
                else:
                    return False, encode_str
            elif decode_method == 'base85':
                if len(encode_str) < 7:
                    return False, raw_encode_str

                if PY2:
                    return False, raw_encode_str

                rex = re.compile('^[A-Za-z0-9!#$%&()*+\-;<=>?@^_`{|}~]+$', re.MULTILINE)
                if self.regex_match(rex, encode_str):
                    decode_str = b85decode(utf8(encode_str))
                else:
                    return False, encode_str
            elif decode_method == 'pawn_shop':
                try:
                    encode_str = encode_str.decode('gb2312')
                except:
                    pass

                encode_str = to_unicode(encode_str)
                encode_str = encode_str.replace(' ', '').strip()
                code_base = '口由中人工大王夫井羊'
                decode_str = []
                for t in encode_str:
                    if t in code_base:
                        i = code_base.index(t)
                        decode_str.append(str(i))
                    else:
                        return False, raw_encode_str
                decode_str = ''.join(decode_str)

                if len(decode_str) < 0:
                    return False, raw_encode_str
            elif decode_method == 'decimal':
                if len(encode_str) < 4:
                    return False, raw_encode_str

                rex = re.compile('^[0-9]+$', re.MULTILINE)
                if not self.regex_match(rex, encode_str):
                    return False, raw_encode_str
                # 解码后是 0xab1234,需要去掉前面的 0x
                decode_str = hex(int(encode_str))[2:].rstrip('L')
            elif decode_method == 'binary':
                rex = re.compile('^[0-1]+$', re.MULTILINE)
                if not self.regex_match(rex, encode_str):
                    return False, raw_encode_str

                # 不足8个的,在后面填充0
                padding_length = (8 - len(encode_str) % 8) % 8
                encode_str = '%s%s' % (encode_str, '0' * padding_length)
                # 解码后是 0xab1234,需要去掉前面的 0x
                decode_str = hex(int(encode_str, 2))[2:].rstrip('L')
            elif decode_method in ['octal', 'octal_ascii', 'octal_binary']:
                # 8进制转成16进制的数据
                rex = re.compile('^[0-7]+$', re.MULTILINE)
                if not self.regex_match(rex, encode_str):
                    return False, raw_encode_str

                rex = re.compile('^[0-1]+$', re.MULTILINE)
                if self.regex_match(rex, encode_str):
                    return False, raw_encode_str

                if len(encode_str) < 4:
                    return False, raw_encode_str

                if decode_method == 'octal':
                    # 解码后是 0xab1234,需要去掉前面的 0x
                    decode_str = hex(int(encode_str, 8))[2:].rstrip('L')
                elif decode_method == 'octal_ascii':
                    encode_str = encode_str.replace(' ', '').strip()
                    # 8 进制的 177 转成十进制后是 128
                    tmp_list = list(encode_str)
                    ascii_list = []
                    while len(tmp_list) > 0:
                        tmp_str = ''.join(tmp_list[:3])
                        if int(tmp_str, 8) > 127:
                            tmp_str = ''.join(tmp_list[:2])
                            tmp_list = tmp_list[2:]
                        else:
                            tmp_list = tmp_list[3:]
                        ascii_list.append(chr(int(tmp_str, 8)))
                    decode_str = ''.join(ascii_list)
                elif decode_method == 'octal_binary':
                    # 因为这里有补0的操作,要避免无限递归
                    if len(m_list) > 0 and \
                            (m_list[-1] in ('octal_binary', 'octal', 'binary')
                             or len(encode_str) < 8):
                        return False, raw_encode_str

                    # 将8进制直接转成16进制,也就是3个8进制数字转成2个16进制字符
                    # 先将每个8进制数字转成二进制,不足3个的前面补0
                    encode_str = encode_str.replace(' ', '').strip()
                    tmp_bin_list = ['%03d' % int(bin(int(t))[2:]) for t in list(encode_str)]
                    tmp_bin_list = [t for t in tmp_bin_list]
                    # logger.info(tmp_bin_list)
                    decode_str = ''.join(tmp_bin_list)
                else:
                    return False, raw_encode_str
            elif decode_method == 'decimal_ascii':
                if len(encode_str) < 4:
                    return False, raw_encode_str

                encode_str = encode_str.replace(' ', '').strip()
                rex = re.compile('^[0-9]+$', re.MULTILINE)
                if not self.regex_match(rex, encode_str):
                    return False, raw_encode_str

                # ascii 字符串,10进制最大127
                tmp_list = list(encode_str)
                ascii_list = []
                while len(tmp_list) > 0:
                    tmp_str = ''.join(tmp_list[:3])
                    if int(tmp_str) > 127:
                        tmp_str = ''.join(tmp_list[:2])
                        tmp_list = tmp_list[2:]
                    else:
                        tmp_list = tmp_list[3:]
                    ascii_list.append(chr(int(tmp_str)))
                decode_str = ''.join(ascii_list)
            elif decode_method in ['switch_case', 'reverse_alphabet', 'reverse']:
                # 如果这里不做限制,会无限递归下去
                if len(m_list) > 0 and m_list[-1] in ['switch_case', 'reverse_alphabet', 'reverse']:
                    return False, raw_encode_str

                # 一定要包含 ascii 字符
                tmp_data = [t for t in encode_str if t in string.ascii_letters]
                if len(tmp_data) <= 0:
                    return False, raw_encode_str

                # rex = re.compile('^[A-Za-z0-9+/=]$', re.MULTILINE)
                # if not self.regex_match(rex, encode_str):
                #     return False, raw_encode_str

                if decode_method == 'switch_case':
                    new_data = []
                    for t in encode_str:
                        if t in string.ascii_lowercase:
                            t = t.upper()
                        elif t in string.ascii_uppercase:
                            t = t.lower()
                        new_data.append(t)
                    decode_str = ''.join(new_data)
                elif decode_method == 'reverse_alphabet':
                    # 字母逆序,a->z, z->a
                    new_data = []
                    for t in encode_str:
                        if t in string.ascii_letters:
                            if t in string.ascii_lowercase:
                                t = ord(t) + (25 - (ord(t) - ord('a')) * 2)
                                t = chr(t)
                            else:
                                t = ord(t) + (25 - (ord(t) - ord('A')) * 2)
                                t = chr(t)
                        new_data.append(t)
                    decode_str = ''.join(new_data)
                elif decode_method == 'reverse':
                    # 逆序
                    decode_str = encode_str[::-1]
                else:
                    return False, raw_encode_str
            elif decode_method == 'urlencode':
                if len(encode_str) < 4:
                    return False, raw_encode_str

                decode_str = unquote_plus(encode_str)
            elif decode_method == 'hex':
                if len(encode_str) < 4:
                    return False, raw_encode_str

                encode_str = encode_str.lower()
                rex = re.compile('^[a-f0-9]+$', re.MULTILINE)
                if self.regex_match(rex, encode_str.lower()):
                    # 修正基数位数的16进制数据
                    if len(encode_str) % 2 != 0:
                        encode_str += '0'

                    decode_str = hex2str(encode_str)
                else:
                    return False, raw_encode_str
            elif decode_method == 'zlib':
                if len(encode_str) < 4:
                    return False, raw_encode_str

                try:
                    decode_str = zlib.decompress(utf8(encode_str))
                except:
                    return False, raw_encode_str
            else:
                decode_str = encode_str.decode(decode_method)

            if len(decode_str) <= 0:
                return False, raw_encode_str
            elif utf8(encode_str) == utf8(decode_str):
                return False, raw_encode_str
            else:

                # 解码的内容只有可打印字符,才认为合法
                if self.only_printable:
                    decode_str = to_unicode(decode_str)
                    if isinstance(decode_str, bytes):
                        return False, raw_encode_str
                    tmp_decode_str = list(decode_str)
                    printable_count = 0
                    for t in tmp_decode_str:
                        if str(t) in string.printable:
                            printable_count += 1

                    # 如果可打印字符低于一定的百分比,就认为解码失败
                    if printable_count * 1.0 / len(tmp_decode_str) < self.printable_percent:
                        return False, raw_encode_str

                return True, decode_str
        except Exception as e:
            if self.verbose:
                logger.exception(e)
            return False, raw_encode_str
Пример #41
0
## Py-supergolf.py

import sys, base64, codecs


with open(sys.argv[1]) as data_stream:
    exec(
        base64.a85decode(
                codecs.decode(
                    codecs.decode(
                        ''.join(data_stream.readlines()),
                        'zip'
                    ),
                    'bz2'
                )
            )
        )
    )
Пример #42
0
def main():
    inp = input('->')
    encoded = inp.encode('utf-8') #encoded the input (we need a bytes like object)
    a85encoded = base64.a85encode(encoded) #a85encoded the encoded string
    print(a85encoded)
    print(base64.a85decode(a85encoded).decode('utf-8'))#decoded it