def get_laps(self, kwargs):
        """
        Return the LAPS passwords. If a target is specified, only retrieve the LAPS password for this one.

        Arguments:
            @verbose:bool
                Results will contain full information
            @computer:string
                Target computer where LAPS is set
        """
        computer = kwargs.get("computer", "*")
        verbose = kwargs.get("verbose", False)

        guid_map = {}
        schema_entries = self.engine.ldap.extend.standard.paged_search(
            self.engine.ldap.server.info.other["schemaNamingContext"][0],
            "(objectClass=*)",
            attributes=["name", "schemaidguid"],
        )
        for entry in schema_entries:
            name = entry["attributes"]["name"].lower()
            if (
                name in ("ms-laps-encryptedpassword", "ms-laps-password")
                and entry["attributes"]["schemaIDGUID"]
            ):
                guid = str(UUID(bytes_le=entry["attributes"]["schemaIDGUID"]))
                guid_map[name] = guid

        attributes = (
            ALL
            if verbose
            else ["dNSHostName", "ms-Mcs-AdmPwd", "ms-Mcs-AdmPwdExpirationTime"]
        )

        try:
            # LAPSv1
            entries = self.engine.query(self.engine.LAPS_FILTER(computer), attributes)
            if not verbose:
                for entry in entries:
                    cn = entry["dNSHostName"]
                    password = entry["ms-Mcs-AdmPwd"]
                    try:
                        epoch = (
                            int(str(entry["ms-Mcs-AdmPwdExpirationTime"])) / 10000000
                        ) - 11644473600
                        expiration_date = datetime.fromtimestamp(epoch).strftime(
                            "%m-%d-%Y"
                        )
                    except Exception:
                        expiration_date = entry["ms-Mcs-AdmPwdExpirationTime"]
                    print(f"{cn} {password} {expiration_date}")
            else:
                self.display(entries, verbose)
        except LDAPAttributeError:
            try:
                # LAPSv2
                attributes = (
                    ALL
                    if verbose
                    else [
                        "dNSHostName",
                        "msLAPS-EncryptedPassword",
                        "msLAPS-PasswordExpirationTime",
                        "nTSecurityDescriptor",
                    ]
                )
                entries = self.engine.query(
                    self.engine.LAPS2_FILTER(computer), attributes
                )
                computers = list(entries)
                computer_count = len(computers)
                if computer_count > 0:
                    print("LAPSv2 detected, password decryption is not implemented")
                    if not verbose:
                        for c in computers:
                            if c["msLAPS-EncryptedPassword"]:
                                print(
                                    f"{c['dNSHostName']}:::{b64encode(c['msLAPS-EncryptedPassword'])}"
                                )
                            else:
                                print(f"{c['dNSHostName']}")

                            readers = set()
                            for ace in c["nTSecurityDescriptor"]["DACL"]["ACEs"]:
                                if "GUID" in ace.keys():
                                    guid = ace["GUID"].strip("{}")
                                    if (
                                        guid == guid_map["ms-laps-encryptedpassword"]
                                        or guid == guid_map["ms-laps-password"]
                                    ):
                                        if ace["SID"] not in readers:
                                            if ace["SID"] == "S-1-5-10":
                                                name = "S-1-5-10 (self)"
                                            else:
                                                try:
                                                    res = next(
                                                        self.engine.resolve_sid(
                                                            ace["SID"]
                                                        )
                                                    )
                                                    if "group" in res["objectClass"]:
                                                        name = f"{res['sAMAccountName']} (group)"
                                                    else:
                                                        name = res["sAMAccountName"]
                                                except StopIteration:
                                                    name = ace["SID"]
                                            print(f"{c['dNSHostName']}:reader:{name}")
                                            readers.add(ace["SID"])
            except Exception as e:
                print(e)
                error("No LAPS related attribute has been detected")
        except Exception as e:
            error(f"{e}. No LAPS attribute or not enough permission to read it.")

        Return the LAPS passwords. If a target is specified, only retrieve the LAPS password for this one.

        Arguments:
            @verbose:bool
                Results will contain full information
            @computer:string
                Target computer where LAPS is set
        
ldeep/__main__.py