docs: def S4U2self(self, user_to_impersonate, supp_enc_methods = [EncryptionType.DES_CBC_CRC,EncryptionType.DES_CBC_MD4,EncryptionType.DES_CBC_MD5,EncryptionType.DES3_CBC_SHA1,EncryptionType.ARCFOUR_HMAC_MD5,EncryptionType.AES256_CTS_HMAC_SHA1_96,EncryptionType.AES128_CTS_HMAC_SHA1_96]):
  	#def S4U2self(self, user_to_impersonate, spn_user, supp_enc_methods = [EncryptionType.DES_CBC_CRC,EncryptionType.DES_CBC_MD4,EncryptionType.DES_CBC_MD5,EncryptionType.DES3_CBC_SHA1,EncryptionType.ARCFOUR_HMAC_MD5,EncryptionType.AES256_CTS_HMAC_SHA1_96,EncryptionType.AES128_CTS_HMAC_SHA1_96]):
  		"""
  		user_to_impersonate : KerberosTarget class
  		"""
  		
  		if not self.kerberos_TGT:
  			logger.debug('S4U2self invoked, but TGT is not available! Fetching TGT...')
  			self.get_TGT()
  		
  		supp_enc = self.usercreds.get_preferred_enctype(supp_enc_methods)
  		auth_package_name = 'Kerberos'
  		now = datetime.datetime.utcnow() 
  		
  		
  		###### Calculating authenticator data
  		authenticator_data = {}
  		authenticator_data['authenticator-vno'] = krb5_pvno
  		authenticator_data['crealm'] = Realm(self.kerberos_TGT['crealm'])
  		authenticator_data['cname'] = self.kerberos_TGT['cname']
  		authenticator_data['cusec'] = now.microsecond
  		authenticator_data['ctime'] = now
  		
  		authenticator_data_enc = self.kerberos_cipher.encrypt(self.kerberos_session_key, 7, Authenticator(authenticator_data).dump(), None)
  		
  		ap_req = {}
  		ap_req['pvno'] = krb5_pvno
  		ap_req['msg-type'] = MESSAGE_TYPE.KRB_AP_REQ.value
  		ap_req['ap-options'] = APOptions(set())
  		ap_req['ticket'] = Ticket(self.kerberos_TGT['ticket'])
  		ap_req['authenticator'] = EncryptedData({'etype': self.kerberos_cipher_type, 'cipher': authenticator_data_enc})
  		
  		pa_data_auth = {}
  		pa_data_auth['padata-type'] = PaDataType.TGS_REQ.value
  		pa_data_auth['padata-value'] = AP_REQ(ap_req).dump()
  		
  		###### Calculating checksum data
  		
  		S4UByteArray = NAME_TYPE.PRINCIPAL.value.to_bytes(4, 'little', signed = False)
  		S4UByteArray += user_to_impersonate.username.encode()
  		S4UByteArray += user_to_impersonate.domain.encode()
  		S4UByteArray += auth_package_name.encode()
  		logger.debug('S4U2self: S4UByteArray: %s' % S4UByteArray.hex())
  		logger.debug('S4U2self: S4UByteArray: %s' % S4UByteArray)
  		
  		chksum_data = _HMACMD5.checksum(self.kerberos_session_key, 17, S4UByteArray)
  		logger.debug('S4U2self: chksum_data: %s' % chksum_data.hex())
  		
  		
  		chksum = {}
  		chksum['cksumtype'] = int(CKSUMTYPE('HMAC_MD5'))
  		chksum['checksum'] = chksum_data
  
  		
  		###### Filling out PA-FOR-USER data for impersonation
  		pa_for_user_enc = {}
  		pa_for_user_enc['userName'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': user_to_impersonate.get_principalname()})
  		pa_for_user_enc['userRealm'] = user_to_impersonate.domain
  		pa_for_user_enc['cksum'] = Checksum(chksum)
  		pa_for_user_enc['auth-package'] = auth_package_name
  		
  		pa_for_user = {}
  		pa_for_user['padata-type'] = int(PADATA_TYPE('PA-FOR-USER'))
  		pa_for_user['padata-value'] = PA_FOR_USER_ENC(pa_for_user_enc).dump()
  	
  		###### Constructing body
  		
  		krb_tgs_body = {}
  		krb_tgs_body['kdc-options'] = KDCOptions(set(['forwardable','renewable','canonicalize']))
  		krb_tgs_body['sname'] = PrincipalName({'name-type': NAME_TYPE.UNKNOWN.value, 'name-string': [self.usercreds.username]})
  		krb_tgs_body['realm'] = self.usercreds.domain.upper()
  		krb_tgs_body['till'] = now + datetime.timedelta(days=1)
  		krb_tgs_body['nonce'] = secrets.randbits(31)
  		krb_tgs_body['etype'] = [supp_enc.value] #selecting according to server's preferences
  		
  		
  		krb_tgs_req = {}
  		krb_tgs_req['pvno'] = krb5_pvno
  		krb_tgs_req['msg-type'] = MESSAGE_TYPE.KRB_TGS_REQ.value
  		krb_tgs_req['padata'] = [pa_data_auth, pa_for_user]
  		krb_tgs_req['req-body'] = KDC_REQ_BODY(krb_tgs_body)
  		
  		req = TGS_REQ(krb_tgs_req)
  		
  		logger.debug('Sending S4U2self request to server')
  		try:
  			reply = self.ksoc.sendrecv(req.dump())
  		except KerberosError as e:
  			if e.errorcode.value == 16:
  				logger.error('S4U2self: Failed to get S4U2self! Error code (16) indicates that delegation is not enabled for this account! Full error: %s' % e)
  			
  			raise e
  		
  		logger.debug('Got S4U2self reply, decrypting...')
  		tgs = reply.native
  		
  		encTGSRepPart = EncTGSRepPart.load(self.kerberos_cipher.decrypt(self.kerberos_session_key, 8, tgs['enc-part']['cipher'])).native
  		key = Key(encTGSRepPart['key']['keytype'], encTGSRepPart['key']['keyvalue'])
  		
  		self.ccache.add_tgs(tgs, encTGSRepPart)
  		logger.debug('Got valid TGS reply')
  		self.kerberos_TGS = tgs
  		return tgs, encTGSRepPart, key