4660db3fde652d53849a337bbe40395a07c4fcf4
[samba.git] / source4 / scripting / bin / rpcclient
1 #!/usr/bin/env python3
2
3 import sys, os, string
4
5 # Find right directory when running from source tree
6 sys.path.insert(0, "bin/python")
7
8 from cmd import Cmd
9 from optparse import OptionParser
10 from pprint import pprint
11
12 import dcerpc, samr
13
14 def swig2dict(obj):
15     """Convert a swig object to a dictionary."""
16
17     result = {}
18
19     for attr in filter(lambda x: type(x) == str, dir(obj)):
20
21         if attr[:2] == '__' and attr[-2:] == '__':
22             continue
23
24         if attr == 'this' or attr == 'thisown':
25             continue
26
27         result[attr] = getattr(obj, attr)
28
29     return result
30
31 class rpcclient(Cmd):
32
33     prompt = 'rpcclient$ '
34
35     def __init__(self, server, cred):
36         Cmd.__init__(self)
37         self.server = server
38         self.cred = cred
39
40     def emptyline(self):
41
42         # Default for empty line is to repeat last command - yuck
43
44         pass
45
46     def onecmd(self, line):
47
48         # Override the onecmd() method so we can trap error returns
49
50         try:
51             Cmd.onecmd(self, line)
52         except dcerpc.NTSTATUS as arg:
53             print 'The command returned an error: %s' % arg[1]
54
55     # Command handlers
56
57     def do_help(self, line):
58         """Displays on-line help for rpcclient commands."""
59         Cmd.do_help(self, line)
60
61     def do_shell(self, line):
62
63         status = os.system(line)
64
65         if os.WIFEXITED(status):
66             if os.WEXITSTATUS(status) != 0:
67                 print 'Command exited with code %d' % os.WEXITSTATUS(status)
68         else:
69             print 'Command exited with signal %d' % os.WTERMSIG(status)
70
71     def do_EOF(self, line):
72         """Exits rpcclient."""
73         print
74         sys.exit(0)
75
76     # SAMR pipe commands
77
78     def do_SamrEnumDomains(self, line):
79         """Enumerate domain names."""
80
81         usage = 'usage: SamrEnumDomains'
82
83         if line != '':
84             print usage
85             return
86
87         pipe = dcerpc.pipe_connect(
88             'ncacn_np:%s' % self.server,
89             dcerpc.DCERPC_SAMR_UUID, int(dcerpc.DCERPC_SAMR_VERSION),
90             self.cred)
91
92         connect_handle = samr.Connect(pipe)
93
94         for i in connect_handle.EnumDomains():
95             print i
96
97     def do_SamrLookupDomain(self, line):
98         """Return the SID for a domain."""
99
100         usage = 'SamrLookupDomain DOMAIN'
101
102         parser = OptionParser(usage)
103         options, args = parser.parse_args(string.split(line))
104
105         if len(args) != 1:
106             print 'usage:', usage
107             return
108
109         pipe = dcerpc.pipe_connect(
110             'ncacn_np:%s' % self.server,
111             dcerpc.DCERPC_SAMR_UUID, int(dcerpc.DCERPC_SAMR_VERSION),
112             self.cred)
113
114         connect_handle = samr.Connect(pipe)
115
116         print connect_handle.LookupDomain(args[0])
117
118     def do_SamrQueryDomInfo(self, line):
119         """Return information about a domain designated by its SID."""
120
121         usage = 'SamrQueryDomInfo DOMAIN_SID [info_level]'
122
123         parser = OptionParser(usage)
124         options, args = parser.parse_args(string.split(line))
125
126         if (len(args) == 0) or (len(args) > 2):
127             print 'usage:', usage
128             return
129
130         pipe = dcerpc.pipe_connect(
131             'ncacn_np:%s' % self.server,
132             dcerpc.DCERPC_SAMR_UUID, int(dcerpc.DCERPC_SAMR_VERSION),
133             self.cred)
134
135         connect_handle = samr.Connect(pipe)
136         domain_handle = connect_handle.OpenDomain(args[0])
137
138         if (len(args) == 2):
139             result = domain_handle.QueryDomainInfo(int(args[1]))
140         else:
141             result = domain_handle.QueryDomainInfo()
142
143         pprint(swig2dict(result))
144
145     def do_SamrQueryDomInfo2(self, line):
146         """Return information about a domain designated by its SID.
147         (Windows 2000 and >)"""
148
149         usage = 'SamrQueryDomInfo2 DOMAIN_SID [info_level] (Windows 2000 and >)'
150         parser = OptionParser(usage)
151         options, args = parser.parse_args(string.split(line))
152
153         if len(args) == 0 or len(args) > 2:
154             print 'usage:', usage
155             return
156
157         pipe = dcerpc.pipe_connect(
158             'ncacn_np:%s' % self.server,
159             dcerpc.DCERPC_SAMR_UUID, int(dcerpc.DCERPC_SAMR_VERSION),
160             self.cred)
161
162         connect_handle = samr.Connect(pipe)
163         domain_handle = connect_handle.OpenDomain(args[0])
164
165         if (len(args) == 2):
166             result = domain_handle.QueryDomainInfo2(int(args[1]))
167         else:
168             result = domain_handle.QueryDomainInfo2()
169
170         pprint(swig2dict(result))
171
172     def do_SamrEnumDomainGroups(self, line):
173         """Return the list of groups of a domain designated by its SID."""
174
175         usage = 'SamrEnumDomainGroups DOMAIN_SID'
176
177         parser = OptionParser(usage)
178         options, args = parser.parse_args(string.split(line))
179
180         if len(args) != 1:
181             print 'usage:', usage
182             return
183
184         pipe = dcerpc.pipe_connect(
185             'ncacn_np:%s' % self.server,
186             dcerpc.DCERPC_SAMR_UUID, int(dcerpc.DCERPC_SAMR_VERSION),
187             self.cred)
188
189         connect_handle = samr.Connect(pipe)
190         domain_handle = connect_handle.OpenDomain(args[0])
191
192         result = domain_handle.EnumDomainGroups()
193
194         pprint(result)
195
196     def do_SamrEnumDomainAliases(self, line):
197         """Return the list of aliases (local groups) of a domain designated
198         by its SID."""
199
200         usage = 'SamrEnumDomainAliases DOMAIN_SID'
201
202         parser = OptionParser(usage)
203         options, args = parser.parse_args(string.split(line))
204
205         if len(args) != 1:
206             print 'usage:', usage
207             return
208
209         pipe = dcerpc.pipe_connect(
210             'ncacn_np:%s' % self.server,
211             dcerpc.DCERPC_SAMR_UUID, int(dcerpc.DCERPC_SAMR_VERSION),
212             self.cred)
213
214         connect_handle = samr.Connect(pipe)
215         domain_handle = connect_handle.OpenDomain(args[0])
216
217         result = domain_handle.EnumDomainAliases()
218
219         pprint(result)
220
221     def do_SamrEnumDomainUsers(self, line):
222         """Return the list of users of a domain designated by its SID."""
223
224         usage = 'SamrEnumDomainUsers DOMAIN_SID [user_account_flags]'
225
226         parser = OptionParser(usage)
227         options, args = parser.parse_args(string.split(line))
228
229         if (len(args) == 0) or (len(args) > 2):
230             print 'usage:', usage
231             return
232
233         pipe = dcerpc.pipe_connect(
234             'ncacn_np:%s' % self.server,
235             dcerpc.DCERPC_SAMR_UUID, int(dcerpc.DCERPC_SAMR_VERSION),
236             self.cred)
237
238         connect_handle = samr.Connect(pipe)
239         domain_handle = connect_handle.OpenDomain(args[0])
240
241         if (len(args) == 2):
242             result = domain_handle.EnumDomainUsers(int(args[1]))
243         else:
244             result = domain_handle.EnumDomainUsers()
245
246         pprint(result)
247
248 if __name__ == '__main__':
249
250     # Parse command line
251
252     usage = 'rpcclient SERVER [options]'
253
254     if len(sys.argv) == 1:
255         print usage
256         sys.exit(1)
257
258     server = sys.argv[1]
259     del(sys.argv[1])
260
261     parser = OptionParser(usage)
262
263     parser.add_option('-U', '--username', action='store', type='string',
264                       help='Use given credentials when connecting',
265                       metavar='DOMAIN\\username%password',
266                       dest='username')
267
268     parser.add_option('-c', '--command', action='store', type='string',
269                       help='Execute COMMAND', dest='command')
270
271     options, args = parser.parse_args()
272
273     # Break --username up into domain, username and password
274
275     cred = None
276
277     if not options.username:
278         options.username = '%'
279
280     domain = ''
281     if options.username.find('\\') != -1:
282         domain, options.username = string.split(options.username, '\\')
283
284     password = ''
285     if options.username.find('%') != -1:
286         options.username, password  = string.split(options.username, '%')
287
288     username = options.username
289
290     if username != '':
291         cred = (domain, username, password)
292
293     # Run command loop
294
295     c = rpcclient(server, cred)
296
297     if options.command:
298         c.onecmd(options.command)
299         sys.exit(0)
300
301     while 1:
302         try:
303             c.cmdloop()
304         except KeyboardInterrupt:
305             print 'KeyboardInterrupt'