Script 'mail_helper' called by obssrc
Hello community,

here is the log from the commit of package python-ldapdomaindump for 
openSUSE:Factory checked in at 2023-01-06 17:06:09
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-ldapdomaindump (Old)
 and      /work/SRC/openSUSE:Factory/.python-ldapdomaindump.new.1563 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "python-ldapdomaindump"

Fri Jan  6 17:06:09 2023 rev:2 rq:1056361 version:0.9.4

Changes:
--------
--- 
/work/SRC/openSUSE:Factory/python-ldapdomaindump/python-ldapdomaindump.changes  
    2020-07-09 13:21:33.105683806 +0200
+++ 
/work/SRC/openSUSE:Factory/.python-ldapdomaindump.new.1563/python-ldapdomaindump.changes
    2023-01-06 17:06:53.984634256 +0100
@@ -1,0 +2,6 @@
+Thu Jan  5 19:57:29 UTC 2023 - Yogalakshmi Arunachalam <yarunacha...@suse.com>
+
+- Update to version 0.9.4 
+  * version bump for pypi
+
+-------------------------------------------------------------------

Old:
----
  ldapdomaindump-0.9.3.tar.gz

New:
----
  ldapdomaindump-0.9.4.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ python-ldapdomaindump.spec ++++++
--- /var/tmp/diff_new_pack.yz3ovN/_old  2023-01-06 17:06:54.384636502 +0100
+++ /var/tmp/diff_new_pack.yz3ovN/_new  2023-01-06 17:06:54.388636524 +0100
@@ -1,5 +1,7 @@
-# # spec file for package python-ldapdomaindump
 #
+# spec file for package python-ldapdomaindump
+#
+# Copyright (c) 2023 SUSE LLC
 # Copyright (c) 2020, Martin Hauke <mar...@gmx.de>
 #
 # All modifications and additions to the file contributed by third parties
@@ -11,12 +13,13 @@
 # license that conforms to the Open Source Definition (Version 1.9)
 # published by the Open Source Initiative.
 
-# Please submit bugfixes or comments via http://bugs.opensuse.org/
+# Please submit bugfixes or comments via https://bugs.opensuse.org/
+#
 
 
 %{?!python_module:%define python_module() python-%{**} python3-%{**}}
 Name:           python-ldapdomaindump
-Version:        0.9.3
+Version:        0.9.4
 Release:        0
 Summary:        Active Directory information dumper via LDAP
 License:        MIT

++++++ ldapdomaindump-0.9.3.tar.gz -> ldapdomaindump-0.9.4.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/ldapdomaindump-0.9.3/PKG-INFO 
new/ldapdomaindump-0.9.4/PKG-INFO
--- old/ldapdomaindump-0.9.3/PKG-INFO   2020-05-31 20:23:47.000000000 +0200
+++ new/ldapdomaindump-0.9.4/PKG-INFO   2022-12-13 14:33:22.674488300 +0100
@@ -1,10 +1,9 @@
-Metadata-Version: 1.0
+Metadata-Version: 2.1
 Name: ldapdomaindump
-Version: 0.9.3
+Version: 0.9.4
 Summary: Active Directory information dumper via LDAP
 Home-page: https://github.com/dirkjanm/ldapdomaindump/
 Author: Dirk-jan Mollema
 Author-email: dirk...@sanoweb.nl
-License: UNKNOWN
-Description: UNKNOWN
-Platform: UNKNOWN
+License: MIT
+License-File: LICENSE
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/ldapdomaindump-0.9.3/Readme.md 
new/ldapdomaindump-0.9.4/Readme.md
--- old/ldapdomaindump-0.9.3/Readme.md  2020-05-31 20:19:38.000000000 +0200
+++ new/ldapdomaindump-0.9.4/Readme.md  2022-11-28 18:05:31.000000000 +0100
@@ -1,109 +1,109 @@
-# LDAPDomainDump
-Active Directory information dumper via LDAP
-
-## Introduction
-In an Active Directory domain, a lot of interesting information can be 
retrieved via LDAP by any authenticated user (or machine).
-This makes LDAP an interesting protocol for gathering information in the recon 
phase of a pentest of an internal network.
-A problem is that data from LDAP often is not available in an easy to read 
format.
-
-ldapdomaindump is a tool which aims to solve this problem, by collecting and 
parsing information available via LDAP and outputting it in a human readable 
HTML format, as well as machine readable json and csv/tsv/greppable files.
-
-The tool was designed with the following goals in mind:
-- Easy overview of all users/groups/computers/policies in the domain
-- Authentication both via username and password, as with NTLM hashes (requires 
ldap3 >=1.3.1)
-- Possibility to run the tool with an existing authenticated connection to an 
LDAP service, allowing for integration with relaying tools such as impackets 
ntlmrelayx
-
-The tool outputs several files containing an overview of objects in the domain:
-- *domain_groups*: List of groups in the domain
-- *domain_users*: List of users in the domain
-- *domain_computers*: List of computer accounts in the domain
-- *domain_policy*: Domain policy such as password requirements and lockout 
policy
-- *domain_trusts*: Incoming and outgoing domain trusts, and their properties
-
-As well as two grouped files:
-- *domain_users_by_group*: Domain users per group they are member of
-- *domain_computers_by_os*: Domain computers sorted by Operating System
-
-## Dependencies and installation
-Requires [ldap3](https://github.com/cannatag/ldap3) > 2.0 and 
[dnspython](https://github.com/rthalley/dnspython)
-
-Both can be installed with `pip install ldap3 dnspython`
-
-The ldapdomaindump package can be installed with `python setup.py install` 
from the git source, or for the latest release with `pip install 
ldapdomaindump`.
-
-## Usage
-There are 3 ways to use the tool:
-- With just the source, run `python ldapdomaindump.py`
-- After installing, by running `python -m ldapdomaindump`
-- After installing, by running `ldapdomaindump`
-
-Help can be obtained with the -h switch:
-```
-usage: ldapdomaindump.py [-h] [-u USERNAME] [-p PASSWORD] [-at {NTLM,SIMPLE}]
-                         [-o DIRECTORY] [--no-html] [--no-json] [--no-grep]
-                         [--grouped-json] [-d DELIMITER] [-r] [-n DNS_SERVER]
-                         [-m]
-                         HOSTNAME
-
-Domain information dumper via LDAP. Dumps users/computers/groups and
-OS/membership information to HTML/JSON/greppable output.
-
-Required options:
-  HOSTNAME              Hostname/ip or ldap://host:port connection string to
-                        connect to (use ldaps:// to use SSL)
-
-Main options:
-  -h, --help            show this help message and exit
-  -u USERNAME, --user USERNAME
-                        DOMAIN\username for authentication, leave empty for
-                        anonymous authentication
-  -p PASSWORD, --password PASSWORD
-                        Password or LM:NTLM hash, will prompt if not specified
-  -at {NTLM,SIMPLE}, --authtype {NTLM,SIMPLE}
-                        Authentication type (NTLM or SIMPLE, default: NTLM)
-
-Output options:
-  -o DIRECTORY, --outdir DIRECTORY
-                        Directory in which the dump will be saved (default:
-                        current)
-  --no-html             Disable HTML output
-  --no-json             Disable JSON output
-  --no-grep             Disable Greppable output
-  --grouped-json        Also write json files for grouped files (default:
-                        disabled)
-  -d DELIMITER, --delimiter DELIMITER
-                        Field delimiter for greppable output (default: tab)
-
-Misc options:
-  -r, --resolve         Resolve computer hostnames (might take a while and
-                        cause high traffic on large networks)
-  -n DNS_SERVER, --dns-server DNS_SERVER
-                        Use custom DNS resolver instead of system DNS (try a
-                        domain controller IP)
-  -m, --minimal         Only query minimal set of attributes to limit memmory
-                        usage
-```
-
-## Options
-### Authentication
-Most AD servers support NTLM authentication. In the rare case that it does 
not, use --authtype SIMPLE.
-
-### Output formats
-By default the tool outputs all files in HTML, JSON and tab delimited output 
(greppable). There are also two grouped files (users_by_group and 
computers_by_os) for convenience. These do not have a greppable output. JSON 
output for grouped files is disabled by default since it creates very large 
files without any data that isn't present in the other files already.
-
-### DNS resolving
-An important option is the *-r* option, which decides if a computers 
DNSHostName attribute should be resolved to an IPv4 address. 
-While this can be very useful, the DNSHostName attribute is not automatically 
updated. When the AD Domain uses subdomains for computer hostnames, the 
DNSHostName will often be incorrect and will not resolve. Also keep in mind 
that resolving every hostname in the domain might cause a high load on the 
domain controller.
-
-### Minimizing network and memory usage
-By default ldapdomaindump will try to dump every single attribute it can read 
to disk in the .json files. In large networks, this uses a lot of memory (since 
group relationships are currently calculated in memory before being written to 
disk). To dump only the minimal required attributes (the ones shown by default 
in the .html and .grep files), use the `--minimal` switch.
-
-## Visualizing groups with BloodHound
-LDAPDomainDump includes a utility that can be used to convert ldapdomaindumps 
`.json` files to CSV files suitable for BloodHound. The utility is called 
`ldd2bloodhound` and is added to your path upon installation. Alternatively you 
can run it with `python -m ldapdomaindump.convert` or with `python 
ldapdomaindump/convert.py` if you are running it from the source.
-The conversion tool will take the users/groups/computers/trusts `.json` file 
and convert those to `group_membership.csv` and `trust.csv` which you can add 
to BloodHound. *Note that these files are only compatible with **BloodHound 
1.x** which is quite old. There are no plans to support the latest version as 
the [BloodHound.py project](https://github.com/fox-it/BloodHound.py) was made 
for this. With the DCOnly collection method this tool will also only talk to 
LDAP and collect more information than ldapdomaindump would*.
-
-## Visualizing dump with a pretty output like enum4linux
-LDAPDomainDump includes a utility that can be used to output ldapdomaindumps 
`.json` files to an enum4linux like output. The utility is called `ldd2pretty` 
and is added to your path upon installation. Alternatively you can run it with 
`python -m ldapdomaindump.pretty` or with `python ldapdomaindump/pretty.py` if 
you are running it from the source.
-
-## License
-MIT
+# LDAPDomainDump
+Active Directory information dumper via LDAP
+
+## Introduction
+In an Active Directory domain, a lot of interesting information can be 
retrieved via LDAP by any authenticated user (or machine).
+This makes LDAP an interesting protocol for gathering information in the recon 
phase of a pentest of an internal network.
+A problem is that data from LDAP often is not available in an easy to read 
format.
+
+ldapdomaindump is a tool which aims to solve this problem, by collecting and 
parsing information available via LDAP and outputting it in a human readable 
HTML format, as well as machine readable json and csv/tsv/greppable files.
+
+The tool was designed with the following goals in mind:
+- Easy overview of all users/groups/computers/policies in the domain
+- Authentication both via username and password, as with NTLM hashes (requires 
ldap3 >=1.3.1)
+- Possibility to run the tool with an existing authenticated connection to an 
LDAP service, allowing for integration with relaying tools such as impackets 
ntlmrelayx
+
+The tool outputs several files containing an overview of objects in the domain:
+- *domain_groups*: List of groups in the domain
+- *domain_users*: List of users in the domain
+- *domain_computers*: List of computer accounts in the domain
+- *domain_policy*: Domain policy such as password requirements and lockout 
policy
+- *domain_trusts*: Incoming and outgoing domain trusts, and their properties
+
+As well as two grouped files:
+- *domain_users_by_group*: Domain users per group they are member of
+- *domain_computers_by_os*: Domain computers sorted by Operating System
+
+## Dependencies and installation
+Requires [ldap3](https://github.com/cannatag/ldap3) > 2.0, 
[dnspython](https://github.com/rthalley/dnspython) and 
[future](https://python-future.org/). ldapdomaindump runs on both python 2 and 
3.
+
+Dependencies can be installed manually with `pip install ldap3 dnspython 
future`, but should in most cases be handled by pip when you install the main 
package either from git or pypi.
+
+The ldapdomaindump package can be installed with `python setup.py install` 
from the git source, or for the latest release with `pip install 
ldapdomaindump`.
+
+## Usage
+There are 3 ways to use the tool:
+- With just the source, run `python ldapdomaindump.py`
+- After installing, by running `python -m ldapdomaindump`
+- After installing, by running `ldapdomaindump`
+
+Help can be obtained with the -h switch:
+```
+usage: ldapdomaindump.py [-h] [-u USERNAME] [-p PASSWORD] [-at {NTLM,SIMPLE}]
+                         [-o DIRECTORY] [--no-html] [--no-json] [--no-grep]
+                         [--grouped-json] [-d DELIMITER] [-r] [-n DNS_SERVER]
+                         [-m]
+                         HOSTNAME
+
+Domain information dumper via LDAP. Dumps users/computers/groups and
+OS/membership information to HTML/JSON/greppable output.
+
+Required options:
+  HOSTNAME              Hostname/ip or ldap://host:port connection string to
+                        connect to (use ldaps:// to use SSL)
+
+Main options:
+  -h, --help            show this help message and exit
+  -u USERNAME, --user USERNAME
+                        DOMAIN\username for authentication, leave empty for
+                        anonymous authentication
+  -p PASSWORD, --password PASSWORD
+                        Password or LM:NTLM hash, will prompt if not specified
+  -at {NTLM,SIMPLE}, --authtype {NTLM,SIMPLE}
+                        Authentication type (NTLM or SIMPLE, default: NTLM)
+
+Output options:
+  -o DIRECTORY, --outdir DIRECTORY
+                        Directory in which the dump will be saved (default:
+                        current)
+  --no-html             Disable HTML output
+  --no-json             Disable JSON output
+  --no-grep             Disable Greppable output
+  --grouped-json        Also write json files for grouped files (default:
+                        disabled)
+  -d DELIMITER, --delimiter DELIMITER
+                        Field delimiter for greppable output (default: tab)
+
+Misc options:
+  -r, --resolve         Resolve computer hostnames (might take a while and
+                        cause high traffic on large networks)
+  -n DNS_SERVER, --dns-server DNS_SERVER
+                        Use custom DNS resolver instead of system DNS (try a
+                        domain controller IP)
+  -m, --minimal         Only query minimal set of attributes to limit memmory
+                        usage
+```
+
+## Options
+### Authentication
+Most AD servers support NTLM authentication. In the rare case that it does 
not, use --authtype SIMPLE.
+
+### Output formats
+By default the tool outputs all files in HTML, JSON and tab delimited output 
(greppable). There are also two grouped files (users_by_group and 
computers_by_os) for convenience. These do not have a greppable output. JSON 
output for grouped files is disabled by default since it creates very large 
files without any data that isn't present in the other files already.
+
+### DNS resolving
+An important option is the *-r* option, which decides if a computers 
DNSHostName attribute should be resolved to an IPv4 address. 
+While this can be very useful, the DNSHostName attribute is not automatically 
updated. When the AD Domain uses subdomains for computer hostnames, the 
DNSHostName will often be incorrect and will not resolve. Also keep in mind 
that resolving every hostname in the domain might cause a high load on the 
domain controller.
+
+### Minimizing network and memory usage
+By default ldapdomaindump will try to dump every single attribute it can read 
to disk in the .json files. In large networks, this uses a lot of memory (since 
group relationships are currently calculated in memory before being written to 
disk). To dump only the minimal required attributes (the ones shown by default 
in the .html and .grep files), use the `--minimal` switch.
+
+## Visualizing groups with BloodHound
+LDAPDomainDump includes a utility that can be used to convert ldapdomaindumps 
`.json` files to CSV files suitable for BloodHound. The utility is called 
`ldd2bloodhound` and is added to your path upon installation. Alternatively you 
can run it with `python -m ldapdomaindump.convert` or with `python 
ldapdomaindump/convert.py` if you are running it from the source.
+The conversion tool will take the users/groups/computers/trusts `.json` file 
and convert those to `group_membership.csv` and `trust.csv` which you can add 
to BloodHound. *Note that these files are only compatible with **BloodHound 
1.x** which is quite old. There are no plans to support the latest version as 
the [BloodHound.py project](https://github.com/fox-it/BloodHound.py) was made 
for this. With the DCOnly collection method this tool will also only talk to 
LDAP and collect more information than ldapdomaindump would*.
+
+## Visualizing dump with a pretty output like enum4linux
+LDAPDomainDump includes a utility that can be used to output ldapdomaindumps 
`.json` files to an enum4linux like output. The utility is called `ldd2pretty` 
and is added to your path upon installation. Alternatively you can run it with 
`python -m ldapdomaindump.pretty` or with `python ldapdomaindump/pretty.py` if 
you are running it from the source.
+
+## License
+MIT
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/ldapdomaindump-0.9.3/ldapdomaindump/__init__.py 
new/ldapdomaindump-0.9.4/ldapdomaindump/__init__.py
--- old/ldapdomaindump-0.9.3/ldapdomaindump/__init__.py 2020-05-31 
20:19:38.000000000 +0200
+++ new/ldapdomaindump-0.9.4/ldapdomaindump/__init__.py 2022-12-13 
12:53:59.000000000 +0100
@@ -48,6 +48,7 @@
              'ACCOUNT_LOCKED':0x00000010,
              'PASSWD_NOTREQD':0x00000020,
              'PASSWD_CANT_CHANGE': 0x00000040,
+             'PASSWORD_STORE_CLEARTEXT': 0x00000080,
              'NORMAL_ACCOUNT': 0x00000200,
              'WORKSTATION_ACCOUNT':0x00001000,
              'SERVER_TRUST_ACCOUNT': 0x00002000,
@@ -81,6 +82,7 @@
                'TREAT_AS_EXTERNAL':0x00000040,
                'USES_RC4_ENCRYPTION':0x00000080,
                'CROSS_ORGANIZATION_NO_TGT_DELEGATION':0x00000200,
+               'CROSS_ORGANIZATION_ENABLE_TGT_DELEGATION':0x00000800,
                'PIM_TRUST':0x00000400}
 
 # Domain trust direction
@@ -473,17 +475,17 @@
         if attr is None or attr.value is None:
             return outflags
         for flag, val in iteritems(flags_def):
-            if attr.value & val:
+            if int(attr.value) & val:
                 outflags.append(flag)
         return outflags
 
     #Parse bitwise trust direction - only one flag applies here, 0x03 overlaps
-    def parseTrustDirection(self, attr, flags_def):
+    def parseSingleFlag(self, attr, flags_def):
         outflags = []
         if attr is None:
             return outflags
         for flag, val in iteritems(flags_def):
-            if attr.value == val:
+            if int(attr.value) == val:
                 outflags.append(flag)
         return outflags
 
@@ -614,6 +616,8 @@
                 return self.formatGroupsHtml([self.dd.groups_dnmap[att.value]])
             except KeyError:
                 return 'NOT FOUND!'
+        if aname == 'description' and type(att.values) is list:
+             return " ".join(att.values)
         #Pwd flags
         if aname == 'pwdproperties':
             return ', '.join(self.parseFlags(att, pwd_flags))
@@ -624,9 +628,9 @@
             if  att.value == 0:
                 return 'DISABLED'
             else:
-                return ', '.join(self.parseTrustDirection(att, 
trust_directions))
+                return ', '.join(self.parseSingleFlag(att, trust_directions))
         if aname == 'trusttype':
-            return ', '.join(self.parseFlags(att, trust_type))
+            return ', '.join(self.parseSingleFlag(att, trust_type))
         if aname == 'securityidentifier':
             return format_sid(att.raw_values[0])
         if aname == 'minpwdage' or  aname == 'maxpwdage':
@@ -700,6 +704,8 @@
                 return self.formatGroupsGrep([self.dd.groups_dnmap[att.value]])
             except KeyError:
                 return 'NOT FOUND!'
+        if aname == 'description' and type(att.values) is list:
+            return " ".join(att.values)
         #Domain trust flags
         if aname == 'trustattributes':
             return ', '.join(self.parseFlags(att, trust_flags))
@@ -707,9 +713,9 @@
             if att.value == 0:
                 return 'DISABLED'
             else:
-                return ', '.join(self.parseTrustDirection(att, 
trust_directions))
+                return ', '.join(self.parseSingleFlag(att, trust_directions))
         if aname == 'trusttype':
-            return ', '.join(self.parseFlags(att, trust_type))
+            return ', '.join(self.parseSingleFlag(att, trust_type))
         if aname == 'securityidentifier':
             return format_sid(att.raw_values[0])
         #Pwd flags
@@ -790,60 +796,60 @@
         if self.config.outputhtml:
             html = self.generateHtmlTable(dd.users, self.userattributes, 
'Domain users')
             self.writeHtmlFile('%s.html' % self.config.usersfile, html)
-        if self.config.outputjson:
-            jsonout = self.generateJsonList(dd.users)
-            self.writeJsonFile('%s.json' % self.config.usersfile, jsonout)
         if self.config.outputgrep:
             grepout = self.generateGrepList(dd.users, self.userattributes)
             self.writeGrepFile('%s.grep' % self.config.usersfile, grepout)
+        if self.config.outputjson:
+            jsonout = self.generateJsonList(dd.users)
+            self.writeJsonFile('%s.json' % self.config.usersfile, jsonout)
 
     #Generate report with just a table of all computer accounts
     def generateComputersReport(self, dd):
         if self.config.outputhtml:
             html = self.generateHtmlTable(dd.computers, 
self.computerattributes, 'Domain computer accounts')
             self.writeHtmlFile('%s.html' % self.config.computersfile, html)
-        if self.config.outputjson:
-            jsonout = self.generateJsonList(dd.computers)
-            self.writeJsonFile('%s.json' % self.config.computersfile, jsonout)
         if self.config.outputgrep:
             grepout = self.generateGrepList(dd.computers, 
self.computerattributes)
             self.writeGrepFile('%s.grep' % self.config.computersfile, grepout)
+        if self.config.outputjson:
+            jsonout = self.generateJsonList(dd.computers)
+            self.writeJsonFile('%s.json' % self.config.computersfile, jsonout)
 
     #Generate report with just a table of all computer accounts
     def generateGroupsReport(self, dd):
         if self.config.outputhtml:
             html = self.generateHtmlTable(dd.groups, self.groupattributes, 
'Domain groups')
             self.writeHtmlFile('%s.html' % self.config.groupsfile, html)
-        if self.config.outputjson:
-            jsonout = self.generateJsonList(dd.groups)
-            self.writeJsonFile('%s.json' % self.config.groupsfile, jsonout)
         if self.config.outputgrep:
             grepout = self.generateGrepList(dd.groups, self.groupattributes)
             self.writeGrepFile('%s.grep' % self.config.groupsfile, grepout)
+        if self.config.outputjson:
+            jsonout = self.generateJsonList(dd.groups)
+            self.writeJsonFile('%s.json' % self.config.groupsfile, jsonout)
 
     #Generate policy report
     def generatePolicyReport(self, dd):
         if self.config.outputhtml:
             html = self.generateHtmlTable(dd.policy, self.policyattributes, 
'Domain policy')
             self.writeHtmlFile('%s.html' % self.config.policyfile, html)
-        if self.config.outputjson:
-            jsonout = self.generateJsonList(dd.policy)
-            self.writeJsonFile('%s.json' % self.config.policyfile, jsonout)
         if self.config.outputgrep:
             grepout = self.generateGrepList(dd.policy, self.policyattributes)
             self.writeGrepFile('%s.grep' % self.config.policyfile, grepout)
+        if self.config.outputjson:
+            jsonout = self.generateJsonList(dd.policy)
+            self.writeJsonFile('%s.json' % self.config.policyfile, jsonout)
 
     #Generate policy report
     def generateTrustsReport(self, dd):
         if self.config.outputhtml:
             html = self.generateHtmlTable(dd.trusts, self.trustattributes, 
'Domain trusts')
             self.writeHtmlFile('%s.html' % self.config.trustsfile, html)
-        if self.config.outputjson:
-            jsonout = self.generateJsonList(dd.trusts)
-            self.writeJsonFile('%s.json' % self.config.trustsfile, jsonout)
         if self.config.outputgrep:
             grepout = self.generateGrepList(dd.trusts, self.trustattributes)
             self.writeGrepFile('%s.grep' % self.config.trustsfile, grepout)
+        if self.config.outputjson:
+            jsonout = self.generateJsonList(dd.trusts)
+            self.writeJsonFile('%s.json' % self.config.trustsfile, jsonout)
 
 #Some quick logging helpers
 def log_warn(text):
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' 
old/ldapdomaindump-0.9.3/ldapdomaindump.egg-info/PKG-INFO 
new/ldapdomaindump-0.9.4/ldapdomaindump.egg-info/PKG-INFO
--- old/ldapdomaindump-0.9.3/ldapdomaindump.egg-info/PKG-INFO   2020-05-31 
20:23:47.000000000 +0200
+++ new/ldapdomaindump-0.9.4/ldapdomaindump.egg-info/PKG-INFO   2022-12-13 
14:33:22.000000000 +0100
@@ -1,10 +1,9 @@
-Metadata-Version: 1.0
+Metadata-Version: 2.1
 Name: ldapdomaindump
-Version: 0.9.3
+Version: 0.9.4
 Summary: Active Directory information dumper via LDAP
 Home-page: https://github.com/dirkjanm/ldapdomaindump/
 Author: Dirk-jan Mollema
 Author-email: dirk...@sanoweb.nl
-License: UNKNOWN
-Description: UNKNOWN
-Platform: UNKNOWN
+License: MIT
+License-File: LICENSE
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/ldapdomaindump-0.9.3/setup.py 
new/ldapdomaindump-0.9.4/setup.py
--- old/ldapdomaindump-0.9.3/setup.py   2020-05-31 20:19:38.000000000 +0200
+++ new/ldapdomaindump-0.9.4/setup.py   2022-12-13 12:54:16.000000000 +0100
@@ -1,13 +1,14 @@
-from setuptools import setup
-setup(name='ldapdomaindump',
-      version='0.9.3',
-      description='Active Directory information dumper via LDAP',
-      author='Dirk-jan Mollema',
-      author_email='dirk...@sanoweb.nl',
-      url='https://github.com/dirkjanm/ldapdomaindump/',
-      packages=['ldapdomaindump'],
-      install_requires=['dnspython', 'ldap3>=2.5,!=2.5.2,!=2.5.0,!=2.6', 
'future'],
-      package_data={'ldapdomaindump': ['style.css']},
-      include_package_data=True,
-      scripts=['bin/ldapdomaindump', 'bin/ldd2bloodhound', 'bin/ldd2pretty']
-      )
+from setuptools import setup
+setup(name='ldapdomaindump',
+      version='0.9.4',
+      description='Active Directory information dumper via LDAP',
+      author='Dirk-jan Mollema',
+      author_email='dirk...@sanoweb.nl',
+      url='https://github.com/dirkjanm/ldapdomaindump/',
+      packages=['ldapdomaindump'],
+      install_requires=['dnspython', 'ldap3>=2.5,!=2.5.2,!=2.5.0,!=2.6', 
'future'],
+      package_data={'ldapdomaindump': ['style.css']},
+      include_package_data=True,
+      scripts=['bin/ldapdomaindump', 'bin/ldd2bloodhound', 'bin/ldd2pretty'],
+      license="MIT",
+      )

Reply via email to