Preciso transforma um script complexo em Python Para Php

Converter um script, sou programador o trabalho não e facil o nao faz com chatgtp vou deixar o github do script e um exemplo da comand link de decrypt se vc conseguir fazer em php é isso que preciso:

#!/usr/bin/env python3.9
"""Dukpt des pin block utility for decryption

Specification: ANS X9.24-2004
Layout: Derived unique key per transaction
Cipher: TripleDes (ECB mode) / Des (ECB mode)
Pinblock format: iso-0 (iso 9564-1 format 0)
"""
import logging
from typing import tuple
from crypto.Cipher import DES, DES3  # pycryptodome library

def xor(first: bytes, second: bytes) -> bytes:
    assert len(first) == len(second), "xor elements must have the same size"
    return bytes([f ^ s for f, s in zip(first, second)])


class DukptDesPinBlock:
    """Dukpt Des pinblock (ANS X9.24-2004) implementation"""
    _c_mask = bytes.fromhex('C0C0C0C000000000C0C0C0C000000000')
    _pin_mask = bytes.fromhex('00000000000000FF00000000000000FF')

    def __init__(self, bdk: bytes, ksn: bytes):
        assert len(bdk) == 16, "Incorrect Bdk"
        assert len(ksn) in {8, 10}, "Incorrect Ksn"
        self._bdk: bytes = bdk
        self._ksn: bytearray = bytearray(ksn)

    def generate_pin(self, pinblock: bytes, pan: str) -> str:
        """Generate pin with given pinblock"""
        assert len(pinblock) == 8, "Incorrect Pinblock"
        assert 12 <= len(pan) <= 19 and pan.isdigit(), "Incorrect Pan"
        pin_key = self._generate_pin_key()
        clear_pinblock = DES3.new(pin_key, mode=DES3.MODE_ECB).decrypt(pinblock)
        pan_part = bytes.fromhex(pan[-min(13, len(pan)):-1].zfill(16))
        pin_part = xor(clear_pinblock, pan_part)
        try:
            pin_len = int(pin_part.hex()[:2])
            return pin_part.hex()[2:pin_len + 2]
        except Exception as _:
            raise ValueError(f"Can't decrypt pin (pin part: {pin_part.hex()})")

    def _generate_pin_key(self) -> bytes:
        """Generate derived pin key"""
        curkey = self._generate_ipek()
        r8 = self._ksn_with_zeroed_counter()[-8:]
        sr = 0x100000
        r3 = self._counter()
        while sr:
            if (sr & r3) != 0:
                srb = sr.to_bytes(8, byteorder="big")
                r8 = bytes([a | b for a, b in zip(r8, srb)])
                r8a = xor(curkey[8:], r8)
                r8a = DES.new(curkey[:8], mode=DES.MODE_ECB).encrypt(r8a)
                r8a = xor(r8a, curkey[8:])
                curkey = xor(curkey, self._c_mask)
                r8b = xor(curkey[8:], r8)
                r8b = DES.new(curkey[:8], mode=DES.MODE_ECB).encrypt(r8b)
                r8b = xor(curkey[8:], r8b)
                curkey = r8b + r8a
            sr >>= 1
        return xor(curkey, self._pin_mask)

    def _generate_ipek(self) -> bytes:
        """Generate initially loaded pin entry device key"""
        ksnr = self._ksn_with_zeroed_counter()[:8]
        left = DES3.new(self._bdk, DES3.MODE_ECB).encrypt(ksnr)
        right_key = xor(self._bdk, self._c_mask)
        right = DES3.new(right_key, DES3.MODE_ECB).encrypt(ksnr)
        return left + right

    def _counter(self) -> int:
        """Returns 21 bits counter of KSN as integer"""
        first = (self._ksn[-3] & 0x1F) * 0x10000
        return first + self._ksn[-2] * 0x100 + self._ksn[-1]

    def _ksn_with_zeroed_counter(self) -> bytes:
        """Generate ksn with zero filled counter"""
        return bytes([*self._ksn[:-3], self._ksn[-3] & 0xE0, 0x00, 0x00])


# Fixed parameters for decryption
pinblock = bytes.fromhex("63403010DA9289F5")
pan = "5361190990664121"
bdk = bytes.fromhex("DDA572FF90CA5CA33C65334414129F3A")
ksn = bytes.fromhex("20141125FF999900007D")

# Perform decryption
dukpt = DukptDesPinBlock(bdk, ksn)
pin = dukpt.generate_pin(pinblock, pan)
print(f"Decrypted PIN: {pin}")