Python crypto._enctype_table方法代码示例

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def toTGT(self):
        tgt_rep = AS_REP()
        tgt_rep['pvno'] = 5
        tgt_rep['msg-type'] = int(constants.ApplicationTagNumbers.AS_REP.value)
        tgt_rep['crealm'] = self['server'].realm['data']

        # Fake EncryptedData
        tgt_rep['enc-part'] = None
        tgt_rep['enc-part']['etype'] = 1 
        tgt_rep['enc-part']['cipher'] = '' 
        seq_set(tgt_rep, 'cname', self['client'].toPrincipal().components_to_asn1)
        ticket = types.Ticket()
        ticket.from_asn1(self.ticket['data'])
        seq_set(tgt_rep,'ticket', ticket.to_asn1)

        cipher = crypto._enctype_table[self['key']['keytype']]()

        tgt = dict()
        tgt['KDC_REP'] = encoder.encode(tgt_rep)
        tgt['cipher'] = cipher
        tgt['sessionKey'] = crypto.Key(cipher.enctype, str(self['key']['keyvalue']))
        return tgt 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def toTGT(self):
        tgt_rep = AS_REP()
        tgt_rep['pvno'] = 5
        tgt_rep['msg-type'] = int(constants.ApplicationTagNumbers.AS_REP.value)
        tgt_rep['crealm'] = self['server'].realm['data']

        # Fake EncryptedData
        tgt_rep['enc-part'] = noValue
        tgt_rep['enc-part']['etype'] = 1
        tgt_rep['enc-part']['cipher'] = '' 
        seq_set(tgt_rep, 'cname', self['client'].toPrincipal().components_to_asn1)
        ticket = types.Ticket()
        ticket.from_asn1(self.ticket['data'])
        seq_set(tgt_rep,'ticket', ticket.to_asn1)

        cipher = crypto._enctype_table[self['key']['keytype']]()

        tgt = dict()
        tgt['KDC_REP'] = encoder.encode(tgt_rep)
        tgt['cipher'] = cipher
        tgt['sessionKey'] = crypto.Key(cipher.enctype, str(self['key']['keyvalue']))
        return tgt 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def toTGT(self):
        tgt_rep = AS_REP()
        tgt_rep['pvno'] = 5
        tgt_rep['msg-type'] = int(constants.ApplicationTagNumbers.AS_REP.value)
        tgt_rep['crealm'] = self['server'].realm['data']

        # Fake EncryptedData
        tgt_rep['enc-part'] = noValue
        tgt_rep['enc-part']['etype'] = 1
        tgt_rep['enc-part']['cipher'] = '' 
        seq_set(tgt_rep, 'cname', self['client'].toPrincipal().components_to_asn1)
        ticket = types.Ticket()
        ticket.from_asn1(self.ticket['data'])
        seq_set(tgt_rep,'ticket', ticket.to_asn1)

        cipher = crypto._enctype_table[self['key']['keytype']]()

        tgt = dict()
        tgt['KDC_REP'] = encoder.encode(tgt_rep)
        tgt['cipher'] = cipher
        tgt['sessionKey'] = crypto.Key(cipher.enctype, self['key']['keyvalue'])
        return tgt 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def toTGT(self):
        tgt_rep = AS_REP()
        tgt_rep['pvno'] = 5
        tgt_rep['msg-type'] = int(constants.ApplicationTagNumbers.AP_REP.value)
        tgt_rep['crealm'] = self['server'].realm['data']

        # Fake EncryptedData
        tgt_rep['enc-part'] = None
        tgt_rep['enc-part']['etype'] = 1 
        tgt_rep['enc-part']['cipher'] = '' 
        seq_set(tgt_rep, 'cname', self['client'].toPrincipal().components_to_asn1)
        ticket = types.Ticket()
        ticket.from_asn1(self.ticket['data'])
        seq_set(tgt_rep,'ticket', ticket.to_asn1)

        cipher = crypto._enctype_table[self['key']['keytype']]()

        tgt = dict()
        tgt['KDC_REP'] = encoder.encode(tgt_rep)
        tgt['cipher'] = cipher
        tgt['sessionKey'] = crypto.Key(cipher.enctype, str(self['key']['keyvalue']))
        return tgt 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def toTGS(self):
        tgs_rep = TGS_REP()
        tgs_rep['pvno'] = 5
        tgs_rep['msg-type'] = int(constants.ApplicationTagNumbers.TGS_REP.value)
        tgs_rep['crealm'] = self['server'].realm['data']

        # Fake EncryptedData
        tgs_rep['enc-part'] = None
        tgs_rep['enc-part']['etype'] = 1 
        tgs_rep['enc-part']['cipher'] = '' 
        seq_set(tgs_rep, 'cname', self['client'].toPrincipal().components_to_asn1)
        ticket = types.Ticket()
        ticket.from_asn1(self.ticket['data'])
        seq_set(tgs_rep,'ticket', ticket.to_asn1)

        cipher = crypto._enctype_table[self['key']['keytype']]()

        tgs = dict()
        tgs['KDC_REP'] = encoder.encode(tgs_rep)
        tgs['cipher'] = cipher
        tgs['sessionKey'] = crypto.Key(cipher.enctype, str(self['key']['keyvalue']))
        return tgs 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def toTGS(self, newSPN=None):
        tgs_rep = TGS_REP()
        tgs_rep['pvno'] = 5
        tgs_rep['msg-type'] = int(constants.ApplicationTagNumbers.TGS_REP.value)
        tgs_rep['crealm'] = self['server'].realm['data']

        # Fake EncryptedData
        tgs_rep['enc-part'] = None
        tgs_rep['enc-part']['etype'] = 1 
        tgs_rep['enc-part']['cipher'] = '' 
        seq_set(tgs_rep, 'cname', self['client'].toPrincipal().components_to_asn1)
        ticket = types.Ticket()
        ticket.from_asn1(self.ticket['data'])
        if newSPN is not None:
            if newSPN.upper() != str(ticket.service_principal).upper():
                LOG.debug('Changing sname from %s to %s and hoping for the best' % (ticket.service_principal, newSPN) )
                ticket.service_principal = types.Principal(newSPN, type=int(ticket.service_principal.type))
        seq_set(tgs_rep,'ticket', ticket.to_asn1)

        cipher = crypto._enctype_table[self['key']['keytype']]()

        tgs = dict()
        tgs['KDC_REP'] = encoder.encode(tgs_rep)
        tgs['cipher'] = cipher
        tgs['sessionKey'] = crypto.Key(cipher.enctype, str(self['key']['keyvalue']))
        return tgs 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def toTGS(self, newSPN=None):
        tgs_rep = TGS_REP()
        tgs_rep['pvno'] = 5
        tgs_rep['msg-type'] = int(constants.ApplicationTagNumbers.TGS_REP.value)
        tgs_rep['crealm'] = self['server'].realm['data']

        # Fake EncryptedData
        tgs_rep['enc-part'] = noValue
        tgs_rep['enc-part']['etype'] = 1
        tgs_rep['enc-part']['cipher'] = '' 
        seq_set(tgs_rep, 'cname', self['client'].toPrincipal().components_to_asn1)
        ticket = types.Ticket()
        ticket.from_asn1(self.ticket['data'])
        if newSPN is not None:
            if newSPN.upper() != str(ticket.service_principal).upper():
                LOG.debug('Changing sname from %s to %s and hoping for the best' % (ticket.service_principal, newSPN) )
                ticket.service_principal = types.Principal(newSPN, type=int(ticket.service_principal.type))
        seq_set(tgs_rep,'ticket', ticket.to_asn1)

        cipher = crypto._enctype_table[self['key']['keytype']]()

        tgs = dict()
        tgs['KDC_REP'] = encoder.encode(tgs_rep)
        tgs['cipher'] = cipher
        tgs['sessionKey'] = crypto.Key(cipher.enctype, str(self['key']['keyvalue']))
        return tgs 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def toTGS(self, newSPN=None):
        tgs_rep = TGS_REP()
        tgs_rep['pvno'] = 5
        tgs_rep['msg-type'] = int(constants.ApplicationTagNumbers.TGS_REP.value)
        tgs_rep['crealm'] = self['server'].realm['data']

        # Fake EncryptedData
        tgs_rep['enc-part'] = noValue
        tgs_rep['enc-part']['etype'] = 1
        tgs_rep['enc-part']['cipher'] = '' 
        seq_set(tgs_rep, 'cname', self['client'].toPrincipal().components_to_asn1)
        ticket = types.Ticket()
        ticket.from_asn1(self.ticket['data'])
        if newSPN is not None:
            if newSPN.upper() != str(ticket.service_principal).upper():
                LOG.debug('Changing sname from %s to %s and hoping for the best' % (ticket.service_principal, newSPN) )
                ticket.service_principal = types.Principal(newSPN, type=int(ticket.service_principal.type))
        seq_set(tgs_rep,'ticket', ticket.to_asn1)

        cipher = crypto._enctype_table[self['key']['keytype']]()

        tgs = dict()
        tgs['KDC_REP'] = encoder.encode(tgs_rep)
        tgs['cipher'] = cipher
        tgs['sessionKey'] = crypto.Key(cipher.enctype, self['key']['keyvalue'])
        return tgs 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def fromTGT(self, tgt, oldSessionKey, sessionKey):
        self.headers = []
        header = Header()
        header['tag'] = 1
        header['taglen'] = 8
        header['tagdata'] = '\xff\xff\xff\xff\x00\x00\x00\x00'
        self.headers.append(header)

        decodedTGT = decoder.decode(tgt, asn1Spec = AS_REP())[0]

        tmpPrincipal = types.Principal()
        tmpPrincipal.from_asn1(decodedTGT, 'crealm', 'cname')
        self.principal = Principal()
        self.principal.fromPrincipal(tmpPrincipal)

        # Now let's add the credential
        cipherText = decodedTGT['enc-part']['cipher']

        cipher = crypto._enctype_table[decodedTGT['enc-part']['etype']]

        # Key Usage 3
        # AS-REP encrypted part (includes TGS session key or
        # application session key), encrypted with the client key
        # (Section 5.4.2)
        plainText = cipher.decrypt(oldSessionKey, 3, str(cipherText))

        encASRepPart = decoder.decode(plainText, asn1Spec = EncASRepPart())[0]

        credential = Credential()
        server = types.Principal()
        server.from_asn1(encASRepPart, 'srealm', 'sname')
        tmpServer = Principal()
        tmpServer.fromPrincipal(server)
        
        credential['client'] = self.principal
        credential['server'] = tmpServer
        credential['is_skey'] = 0

        credential['key'] = KeyBlock()
        credential['key']['keytype'] = int(encASRepPart['key']['keytype'])
        credential['key']['keyvalue'] = str(encASRepPart['key']['keyvalue'])
        credential['key']['keylen'] = len(credential['key']['keyvalue'])

        credential['time'] = Times()
        credential['time']['authtime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encASRepPart['authtime']))
        credential['time']['starttime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encASRepPart['starttime'])) 
        credential['time']['endtime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encASRepPart['endtime']))
        credential['time']['renew_till'] = self.toTimeStamp(types.KerberosTime.from_asn1(encASRepPart['renew-till'])) 

        flags = self.reverseFlags(encASRepPart['flags'])
        credential['tktflags'] = flags

        credential['num_address'] = 0
        credential.ticket = CountedOctetString()
        credential.ticket['data'] = encoder.encode(decodedTGT['ticket'].clone(tagSet=Ticket.tagSet, cloneValueFlag=True))
        credential.ticket['length'] = len(credential.ticket['data'])
        credential.secondTicket = CountedOctetString()
        credential.secondTicket['data'] = ''
        credential.secondTicket['length'] = 0
        self.credentials.append(credential) 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def fromTGS(self, tgs, oldSessionKey, sessionKey):
        self.headers = []
        header = Header()
        header['tag'] = 1
        header['taglen'] = 8
        header['tagdata'] = '\xff\xff\xff\xff\x00\x00\x00\x00'
        self.headers.append(header)

        decodedTGS = decoder.decode(tgs, asn1Spec = TGS_REP())[0]

        tmpPrincipal = types.Principal()
        tmpPrincipal.from_asn1(decodedTGS, 'crealm', 'cname')
        self.principal = Principal()
        self.principal.fromPrincipal(tmpPrincipal)

        # Now let's add the credential
        cipherText = decodedTGS['enc-part']['cipher']

        cipher = crypto._enctype_table[decodedTGS['enc-part']['etype']]

        # Key Usage 8
        # TGS-REP encrypted part (includes application session
        # key), encrypted with the TGS session key (Section 5.4.2)
        plainText = cipher.decrypt(oldSessionKey, 8, str(cipherText))

        encTGSRepPart = decoder.decode(plainText, asn1Spec = EncTGSRepPart())[0]

        credential = Credential()
        server = types.Principal()
        server.from_asn1(encTGSRepPart, 'srealm', 'sname')
        tmpServer = Principal()
        tmpServer.fromPrincipal(server)
        
        credential['client'] = self.principal
        credential['server'] = tmpServer
        credential['is_skey'] = 0 

        credential['key'] = KeyBlock()
        credential['key']['keytype'] = int(encTGSRepPart['key']['keytype'])
        credential['key']['keyvalue'] = str(encTGSRepPart['key']['keyvalue'])
        credential['key']['keylen'] = len(credential['key']['keyvalue'])

        credential['time'] = Times()
        credential['time']['authtime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encTGSRepPart['authtime']))
        credential['time']['starttime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encTGSRepPart['starttime'])) 
        credential['time']['endtime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encTGSRepPart['endtime']))
        credential['time']['renew_till'] = self.toTimeStamp(types.KerberosTime.from_asn1(encTGSRepPart['renew-till'])) 

        flags = self.reverseFlags(encTGSRepPart['flags'])
        credential['tktflags'] = flags

        credential['num_address'] = 0

        credential.ticket = CountedOctetString()
        credential.ticket['data'] = encoder.encode(decodedTGS['ticket'].clone(tagSet=Ticket.tagSet, cloneValueFlag=True))
        credential.ticket['length'] = len(credential.ticket['data'])
        credential.secondTicket = CountedOctetString()
        credential.secondTicket['data'] = ''
        credential.secondTicket['length'] = 0
        self.credentials.append(credential) 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def sessionSetupResp_KerberosMututal(self, smbPacket):
		# Pull the most recent keys from kerberos
		while not self.info['kerbPoppedKeys'].empty():
			nKey = self.info['kerbPoppedKeys'].get()
			self.info['smbKeyChain'][hash(nKey)] = copy.deepcopy(nKey)

		st 			= SMB2SessionSetup_Response(data = smbPacket['Data'])['Buffer']

	
		# See if we have the original KERBEROS_SESSION_KEY to decrypt this new Keberos ServiceSessionKey
		for keyHash in self.info['smbKeyChain'].keys():
			smbKey = self.info['smbKeyChain'][keyHash]
			if(smbKey.KERBEROS_SERVICE_SESSION_KEY == ""):
				print("NO KERB SERVICE SESSION KEY IN KEY: " + str(smbKey))
				continue

			# Make sure the keys were generated for this dialect
			smbKey.setDialect(self.SESSION_DIALECT)
			
			try:
				print("Trying key:")
				print(str(smbKey))
				k 			= st.find("\x6f\x81\x87\x30")
				apRep 		= decoder.decode(st[k:], asn1Spec = AP_REP())[0]
				cipher 		= _enctype_table[18]
				cipherText 	= str(apRep['enc-part']['cipher'])
				key 		= Key(18, smbKey.KERBEROS_SERVICE_SESSION_KEY)
				# Key Usage 12
				# AP-REP encrypted part (includes application session
				# subkey), encrypted with the application session key
				# (Section 5.5.2)
				plainText 		= cipher.decrypt(key, 12, cipherText)
				encAPRepPart 	= decoder.decode(plainText, asn1Spec = EncAPRepPart())[0]
				newSessionKey 	= Key(encAPRepPart['subkey']['keytype'], str(encAPRepPart['subkey']['keyvalue']))

				print("\t!!!Compromised SMB SessionBaseKey via Kerberos Mutual Auth!!!\t " + hexlify(newSessionKey.contents[:16]))
				self.KNOWN_KEY 	= SMBKey(sessionBaseKey = newSessionKey.contents[:16], dialect = self.SESSION_DIALECT, kerbSessionKey = smbKey.KERBEROS_SESSION_KEY, kerbServiceSessionKey = newSessionKey.contents)
				self.info['smbKeyChain'][hash(self.KNOWN_KEY)] = self.KNOWN_KEY
				break
			except Exception, e:
				# self.logger.info("FAILED TO POP MUTUAL AUTH WITH \n" + str(smbKey))
				# print(str(e))
				continue 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def parse_AS_REP(self, rawData):
		if(len(self.PREAUTH_ENCTYPES.keys()) == 0):
			return rawData
		# self.info['kerbSessionSalts_Lock'].acquire()
		# self.info['kerbSessionKeys_Lock'].acquire()
		try:
			cname_start = rawData.find('\xa1\x12\x30\x10') + 6
			cname_end 	= rawData.find('\xa5', cname_start)
			userInRep 	= rawData[cname_start:cname_end]
			#
			# self.info['poppedCredsDB_Lock'].acquire()
			#
			asRep 		= decoder.decode(rawData[4:], asn1Spec = AS_REP())[0]

			for user in self.info['poppedCredsDB'].keys():
				popped = self.info['poppedCredsDB'][user]
				if (str(asRep['cname']['name-string'][0]).lower() == popped.username.lower()):
					# Try to decrypt the KerberosSessionKey with the user's password
					enctype = int(constants.EncryptionTypes.aes256_cts_hmac_sha1_96.value)
					cipher 	= _enctype_table[enctype]

					for encType in self.PREAUTH_ENCTYPES[enctype]:
						try:
							# if(popped.nt_hash != ''):
							# 	self.logger.info("USING NT-HASH")
							# 	key = Key(cipher.enctype, popped.nt_hash)
							# else:
							key 	= cipher.string_to_key(popped.password, encType, None)

							
							cipherText 	= asRep['enc-part']['cipher']
							plainText 	= cipher.decrypt(key, 3, str(cipherText))

							encASRepPart 	= decoder.decode(plainText, asn1Spec = EncASRepPart())[0]
							sessionKey 		= Key(cipher.enctype, str(encASRepPart['key']['keyvalue']))

							# This is the user's Kerberos session key
							self.KERB_SESSION_KEYS.append(sessionKey)

							self.logger.info("\t!!! Popped a user's AS_REP !!! " + hexlify(sessionKey.contents))
							break
						except:
							continue

			# self.info['poppedCredsDB_Lock'].release()
		except Exception, e:
			self.logger.error("K2TKerb[parseServerResponse] Type 11 Error: " + str(e) + " " + traceback.format_exc())
		# self.info['kerbSessionSalts_Lock'].release()
		# self.info['kerbSessionKeys_Lock'].release()

	# Compromises the ServiceSessionKey and populates a new SMBKey in the SMBKeyChain shared dict 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def parse_TGS_REP(self, rawData):
		# mine = False
		# if not self.info['smbKeyChain_Lock'].locked():
		# 	self.info['smbKeyChain_Lock'].acquire()
		# 	mine = True
		try:
			enctype 	= int(constants.EncryptionTypes.aes256_cts_hmac_sha1_96.value)
			cipher 		= _enctype_table[enctype]
			tgs 		= decoder.decode(rawData[4:], 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)
			sk = None
			plainText = None
			kerbSessionKey = None
			for ksessionKey in self.KERB_SESSION_KEYS:
				try:
					plainText 		= cipher.decrypt(ksessionKey, 8, str(cipherText))
					kerbSessionKey 	= ksessionKey
					break
				except Exception, e:
					self.logger.info("Failed to decrypt TGS with " + hexlify(ksessionKey.contents))
					pass
			if plainText == None:
				# print("Failed to decrypt TGS ServiceSessionKey")
				return rawData

			encTGSRepPart 		= decoder.decode(plainText, asn1Spec = EncTGSRepPart())[0]
			ServiceSessionKey 	= Key(encTGSRepPart['key']['keytype'], str(encTGSRepPart['key']['keyvalue']))
			cipher 				= _enctype_table[encTGSRepPart['key']['keytype']]
			newKey 				= SMBKey(sessionBaseKey = ServiceSessionKey.contents[:16], kerbSessionKey = kerbSessionKey.contents, kerbServiceSessionKey = ServiceSessionKey.contents)

			# Load the popped key into the keychain
			# self.info['smbKeyChain'][hash(newKey)] = newKey
			# self.info['kerbPoppedKeys'].put(newKey) # For speed

			# if(mine):
				# self.info['smbKeyChain_Lock'].release()
			self.logger.info("[K2TKerb]\t !!!Compromised TGS ServiceSessionKey (SMB SessionBaseKey is first 16 bytes)!!! " + hexlify(newKey.KERBEROS_SERVICE_SESSION_KEY))

			# SMBKey(sessionBaseKey = ServiceSessionKey.contents[:16], dialect = self.SESSION_DIALECT, kerbSessionKey = smbKey.KERBEROS_SESSION_KEY, kerbServiceSessionKey = ServiceSessionKey.contents) 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def fromTGT(self, tgt, oldSessionKey, sessionKey):
        self.headers = []
        header = Header()
        header['tag'] = 1
        header['taglen'] = 8
        header['tagdata'] = b'\xff\xff\xff\xff\x00\x00\x00\x00'
        self.headers.append(header)

        decodedTGT = decoder.decode(tgt, asn1Spec = AS_REP())[0]

        tmpPrincipal = types.Principal()
        tmpPrincipal.from_asn1(decodedTGT, 'crealm', 'cname')
        self.principal = Principal()
        self.principal.fromPrincipal(tmpPrincipal)

        # Now let's add the credential
        cipherText = decodedTGT['enc-part']['cipher']

        cipher = crypto._enctype_table[decodedTGT['enc-part']['etype']]

        # Key Usage 3
        # AS-REP encrypted part (includes TGS session key or
        # application session key), encrypted with the client key
        # (Section 5.4.2)
        plainText = cipher.decrypt(oldSessionKey, 3, cipherText)

        encASRepPart = decoder.decode(plainText, asn1Spec = EncASRepPart())[0]
        credential = Credential()
        server = types.Principal()
        server.from_asn1(encASRepPart, 'srealm', 'sname')
        tmpServer = Principal()
        tmpServer.fromPrincipal(server)
        
        credential['client'] = self.principal
        credential['server'] = tmpServer
        credential['is_skey'] = 0

        credential['key'] = KeyBlock()
        credential['key']['keytype'] = int(encASRepPart['key']['keytype'])
        credential['key']['keyvalue'] = encASRepPart['key']['keyvalue'].asOctets()
        credential['key']['keylen'] = len(credential['key']['keyvalue'])

        credential['time'] = Times()
        credential['time']['authtime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encASRepPart['authtime']))
        credential['time']['starttime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encASRepPart['starttime'])) 
        credential['time']['endtime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encASRepPart['endtime']))
        credential['time']['renew_till'] = self.toTimeStamp(types.KerberosTime.from_asn1(encASRepPart['renew-till']))

        flags = self.reverseFlags(encASRepPart['flags'])
        credential['tktflags'] = flags

        credential['num_address'] = 0
        credential.ticket = CountedOctetString()
        credential.ticket['data'] = encoder.encode(decodedTGT['ticket'].clone(tagSet=Ticket.tagSet, cloneValueFlag=True))
        credential.ticket['length'] = len(credential.ticket['data'])
        credential.secondTicket = CountedOctetString()
        credential.secondTicket['data'] = b''
        credential.secondTicket['length'] = 0
        self.credentials.append(credential) 

# 需要导入模块: from impacket.krb5 import crypto [as 别名]
# 或者: from impacket.krb5.crypto import _enctype_table [as 别名]
def fromTGS(self, tgs, oldSessionKey, sessionKey):
        self.headers = []
        header = Header()
        header['tag'] = 1
        header['taglen'] = 8
        header['tagdata'] = b'\xff\xff\xff\xff\x00\x00\x00\x00'
        self.headers.append(header)

        decodedTGS = decoder.decode(tgs, asn1Spec = TGS_REP())[0]

        tmpPrincipal = types.Principal()
        tmpPrincipal.from_asn1(decodedTGS, 'crealm', 'cname')
        self.principal = Principal()
        self.principal.fromPrincipal(tmpPrincipal)

        # Now let's add the credential
        cipherText = decodedTGS['enc-part']['cipher']

        cipher = crypto._enctype_table[decodedTGS['enc-part']['etype']]

        # Key Usage 8
        # TGS-REP encrypted part (includes application session
        # key), encrypted with the TGS session key (Section 5.4.2)
        plainText = cipher.decrypt(oldSessionKey, 8, cipherText)

        encTGSRepPart = decoder.decode(plainText, asn1Spec = EncTGSRepPart())[0]

        credential = Credential()
        server = types.Principal()
        server.from_asn1(encTGSRepPart, 'srealm', 'sname')
        tmpServer = Principal()
        tmpServer.fromPrincipal(server)
        
        credential['client'] = self.principal
        credential['server'] = tmpServer
        credential['is_skey'] = 0 

        credential['key'] = KeyBlock()
        credential['key']['keytype'] = int(encTGSRepPart['key']['keytype'])
        credential['key']['keyvalue'] = encTGSRepPart['key']['keyvalue'].asOctets()
        credential['key']['keylen'] = len(credential['key']['keyvalue'])

        credential['time'] = Times()
        credential['time']['authtime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encTGSRepPart['authtime']))
        credential['time']['starttime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encTGSRepPart['starttime'])) 
        credential['time']['endtime'] = self.toTimeStamp(types.KerberosTime.from_asn1(encTGSRepPart['endtime']))
        credential['time']['renew_till'] = self.toTimeStamp(types.KerberosTime.from_asn1(encTGSRepPart['renew-till'])) 

        flags = self.reverseFlags(encTGSRepPart['flags'])
        credential['tktflags'] = flags

        credential['num_address'] = 0

        credential.ticket = CountedOctetString()
        credential.ticket['data'] = encoder.encode(decodedTGS['ticket'].clone(tagSet=Ticket.tagSet, cloneValueFlag=True))
        credential.ticket['length'] = len(credential.ticket['data'])
        credential.secondTicket = CountedOctetString()
        credential.secondTicket['data'] = b''
        credential.secondTicket['length'] = 0
        self.credentials.append(credential)