481 lines
18 KiB
Python
481 lines
18 KiB
Python
|
|
# Copyright: (c) 2020, Jordan Borean (@jborean93) <jborean93@gmail.com>
|
||
|
|
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
|
||
|
|
|
||
|
|
import base64
|
||
|
|
import logging
|
||
|
|
import struct
|
||
|
|
import typing
|
||
|
|
|
||
|
|
import spnego
|
||
|
|
from spnego._context import (
|
||
|
|
IOV,
|
||
|
|
ContextProxy,
|
||
|
|
ContextReq,
|
||
|
|
GSSMech,
|
||
|
|
IOVUnwrapResult,
|
||
|
|
IOVWrapResult,
|
||
|
|
SecPkgContextSizes,
|
||
|
|
UnwrapResult,
|
||
|
|
WinRMWrapResult,
|
||
|
|
WrapResult,
|
||
|
|
)
|
||
|
|
from spnego._credential import Credential, unify_credentials
|
||
|
|
from spnego._gss import GSSAPIProxy
|
||
|
|
from spnego._spnego import (
|
||
|
|
NegState,
|
||
|
|
NegTokenInit,
|
||
|
|
NegTokenResp,
|
||
|
|
pack_mech_type_list,
|
||
|
|
unpack_token,
|
||
|
|
)
|
||
|
|
from spnego._sspi import SSPIProxy
|
||
|
|
from spnego.channel_bindings import GssChannelBindings
|
||
|
|
from spnego.exceptions import (
|
||
|
|
BadMechanismError,
|
||
|
|
InvalidTokenError,
|
||
|
|
NegotiateOptions,
|
||
|
|
NoContextError,
|
||
|
|
)
|
||
|
|
|
||
|
|
log = logging.getLogger(__name__)
|
||
|
|
|
||
|
|
|
||
|
|
class NegotiateProxy(ContextProxy):
|
||
|
|
"""A context wrapper for a Python managed SPNEGO context.
|
||
|
|
|
||
|
|
This is a context that can be used on Linux to generate SPNEGO tokens based on the raw Kerberos or NTLM tokens
|
||
|
|
generated by gssapi or our Python NTLM provider This is used as a fallback if gssapi is not available or cannot
|
||
|
|
generate SPNEGO tokens.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(
|
||
|
|
self,
|
||
|
|
username: typing.Optional[typing.Union[str, Credential, typing.List[Credential]]] = None,
|
||
|
|
password: typing.Optional[str] = None,
|
||
|
|
hostname: typing.Optional[str] = None,
|
||
|
|
service: typing.Optional[str] = None,
|
||
|
|
channel_bindings: typing.Optional[GssChannelBindings] = None,
|
||
|
|
context_req: ContextReq = ContextReq.default,
|
||
|
|
usage: str = "initiate",
|
||
|
|
protocol: str = "negotiate",
|
||
|
|
options: NegotiateOptions = NegotiateOptions.none,
|
||
|
|
**kwargs: typing.Any,
|
||
|
|
) -> None:
|
||
|
|
credentials = unify_credentials(username, password)
|
||
|
|
super(NegotiateProxy, self).__init__(
|
||
|
|
credentials, hostname, service, channel_bindings, context_req, usage, protocol, options
|
||
|
|
)
|
||
|
|
|
||
|
|
self._credentials = credentials
|
||
|
|
self._complete = False
|
||
|
|
self._available_contexts: typing.Optional[typing.Dict[GSSMech, ContextProxy]] = kwargs.get(
|
||
|
|
"_negotiate_contexts", None
|
||
|
|
)
|
||
|
|
self._context_list: typing.Dict[GSSMech, typing.Tuple[ContextProxy, typing.Optional[bytes]]] = {}
|
||
|
|
self.__chosen_mech: typing.Optional[GSSMech] = None
|
||
|
|
self._mech_list: typing.List[str] = []
|
||
|
|
|
||
|
|
self._init_sent = False
|
||
|
|
self._mech_sent = False
|
||
|
|
self._mic_sent = False
|
||
|
|
self._mic_recv = False
|
||
|
|
# DCE will always send a MIC token, even for Kerberos.
|
||
|
|
self._mic_required = bool(self.context_req & ContextReq.dce_style)
|
||
|
|
|
||
|
|
@classmethod
|
||
|
|
def available_protocols(cls, options: typing.Optional[NegotiateOptions] = None) -> typing.List[str]:
|
||
|
|
# We always support Negotiate and NTLM as we have our builtin NTLM backend and only support kerberos if gssapi
|
||
|
|
# is present.
|
||
|
|
protocols = ["ntlm", "negotiate"]
|
||
|
|
|
||
|
|
# Make sure we add Kerberos first as the order is important.
|
||
|
|
if "kerberos" in GSSAPIProxy.available_protocols(
|
||
|
|
options=options
|
||
|
|
) or "kerberos" in SSPIProxy.available_protocols(options=options):
|
||
|
|
protocols.insert(0, "kerberos")
|
||
|
|
|
||
|
|
return protocols
|
||
|
|
|
||
|
|
@classmethod
|
||
|
|
def iov_available(cls) -> bool:
|
||
|
|
# If SSPI is available then IOV is available, otherwise it's dependent on whether GSSAPI exposes the functions.
|
||
|
|
if SSPIProxy.available_protocols() == []:
|
||
|
|
return GSSAPIProxy.iov_available()
|
||
|
|
else:
|
||
|
|
return True
|
||
|
|
|
||
|
|
@property
|
||
|
|
def client_principal(self) -> typing.Optional[str]:
|
||
|
|
return self._context.client_principal if self._context_list else None
|
||
|
|
|
||
|
|
@property
|
||
|
|
def complete(self) -> bool:
|
||
|
|
return self._complete
|
||
|
|
|
||
|
|
@property
|
||
|
|
def context_attr(self) -> ContextReq:
|
||
|
|
return self._context.context_attr if self._context_list else ContextReq.none
|
||
|
|
|
||
|
|
@property
|
||
|
|
def negotiated_protocol(self) -> typing.Optional[str]:
|
||
|
|
return self._context.negotiated_protocol if self._context_list else None
|
||
|
|
|
||
|
|
@property
|
||
|
|
def session_key(self) -> bytes:
|
||
|
|
return self._context.session_key if self._context_list else b""
|
||
|
|
|
||
|
|
def new_context(self) -> "NegotiateProxy":
|
||
|
|
return NegotiateProxy(
|
||
|
|
hostname=self._hostname,
|
||
|
|
service=self._service,
|
||
|
|
channel_bindings=self.channel_bindings,
|
||
|
|
context_req=self.context_req,
|
||
|
|
usage=self.usage,
|
||
|
|
protocol=self.protocol,
|
||
|
|
options=self.options,
|
||
|
|
_negotiate_contexts={m: c[0].new_context() for m, c in self._context_list.items()},
|
||
|
|
)
|
||
|
|
|
||
|
|
def step(
|
||
|
|
self,
|
||
|
|
in_token: typing.Optional[bytes] = None,
|
||
|
|
*,
|
||
|
|
channel_bindings: typing.Optional[GssChannelBindings] = None,
|
||
|
|
) -> typing.Optional[bytes]:
|
||
|
|
log.debug("SPNEGO step input: %s", base64.b64encode(in_token or b"").decode())
|
||
|
|
|
||
|
|
# Step 1. Process SPNEGO mechs.
|
||
|
|
mech_token_in, mech_list_mic, is_spnego = self._step_spnego_input(
|
||
|
|
in_token=in_token,
|
||
|
|
channel_bindings=channel_bindings,
|
||
|
|
)
|
||
|
|
|
||
|
|
mech_token_out = None
|
||
|
|
if mech_token_in or self.usage == "initiate":
|
||
|
|
# Step 2. Process the inner context tokens.
|
||
|
|
mech_token_out = self._step_spnego_token(in_token=mech_token_in, channel_bindings=channel_bindings)
|
||
|
|
|
||
|
|
out_token: typing.Optional[bytes] = None
|
||
|
|
if is_spnego:
|
||
|
|
# Step 3. Process / generate the mechListMIC.
|
||
|
|
out_mic = self._step_spnego_mic(in_mic=mech_list_mic)
|
||
|
|
|
||
|
|
# Step 4. Generate the output SPNEGO token.
|
||
|
|
out_token = self._step_spnego_output(out_token=mech_token_out, out_mic=out_mic)
|
||
|
|
|
||
|
|
else:
|
||
|
|
out_token = mech_token_out
|
||
|
|
self._complete = self._context.complete
|
||
|
|
|
||
|
|
if self.complete:
|
||
|
|
# Remove the leftover contexts if there are still others remaining.
|
||
|
|
self._context_list = {self._chosen_mech: (self._context, None)}
|
||
|
|
|
||
|
|
log.debug("SPNEGO step output: %s" % base64.b64encode(out_token or b"").decode())
|
||
|
|
|
||
|
|
return out_token
|
||
|
|
|
||
|
|
def _step_spnego_input(
|
||
|
|
self,
|
||
|
|
in_token: typing.Optional[bytes] = None,
|
||
|
|
channel_bindings: typing.Optional[GssChannelBindings] = None,
|
||
|
|
) -> typing.Tuple[typing.Optional[bytes], typing.Optional[bytes], bool]:
|
||
|
|
mech_list_mic = None
|
||
|
|
token = None
|
||
|
|
is_spnego = True
|
||
|
|
|
||
|
|
if in_token:
|
||
|
|
try:
|
||
|
|
in_token = unpack_token(in_token)
|
||
|
|
except struct.error as e:
|
||
|
|
raise InvalidTokenError(base_error=e, context_msg=f"Failed to unpack input token {e!s}")
|
||
|
|
|
||
|
|
if isinstance(in_token, NegTokenInit):
|
||
|
|
mech_list_mic = in_token.mech_list_mic
|
||
|
|
token = in_token.mech_token
|
||
|
|
|
||
|
|
# This is the first token of the exchange, we should build our context list based on the mechs the
|
||
|
|
# opposite end supports.
|
||
|
|
mech_list = self._rebuild_context_list(
|
||
|
|
mech_types=in_token.mech_types,
|
||
|
|
channel_bindings=channel_bindings,
|
||
|
|
)
|
||
|
|
|
||
|
|
if self.usage == "initiate":
|
||
|
|
# If initiate processes a NegTokenInit2 token that's just used as a hint, use the actually
|
||
|
|
# supported mechs as the true mech list.
|
||
|
|
self._mech_list = mech_list
|
||
|
|
|
||
|
|
else:
|
||
|
|
# If accept processes a NegTokenInit token we treat that as an actual init is sent so it does not
|
||
|
|
# send it's own and uses the initiate mech list as the true mech list.
|
||
|
|
self._init_sent = True
|
||
|
|
self._mech_list = in_token.mech_types
|
||
|
|
|
||
|
|
# If the preferred initiator token does not match the preferred acceptor token then the acceptor
|
||
|
|
# must send the request-mic negState.
|
||
|
|
preferred_mech = self._preferred_mech_list()[0]
|
||
|
|
if preferred_mech.value != in_token.mech_types[0]:
|
||
|
|
self._mic_required = True
|
||
|
|
|
||
|
|
elif isinstance(in_token, NegTokenResp):
|
||
|
|
mech_list_mic = in_token.mech_list_mic
|
||
|
|
token = in_token.response_token
|
||
|
|
|
||
|
|
# https://github.com/jborean93/smbprotocol/issues/137
|
||
|
|
# Some really old SPNEGO implementations have mechListMIC with the same value as responseToken. This is
|
||
|
|
# a bug but needs to be handled by blanking out the mechListMIC.
|
||
|
|
if token and mech_list_mic == token:
|
||
|
|
mech_list_mic = None
|
||
|
|
|
||
|
|
# If we have received the supported_mech then we don't need to send our own.
|
||
|
|
if in_token.supported_mech:
|
||
|
|
self.__chosen_mech = GSSMech.from_oid(in_token.supported_mech)
|
||
|
|
self._mech_sent = True
|
||
|
|
|
||
|
|
# Raise exception if we are rejected and have no error info (mechToken) that will give us more info.
|
||
|
|
if in_token.neg_state == NegState.reject and not token:
|
||
|
|
raise InvalidTokenError(context_msg="Received SPNEGO rejection with no token error message")
|
||
|
|
|
||
|
|
if in_token.neg_state == NegState.request_mic:
|
||
|
|
self._mic_required = True
|
||
|
|
elif in_token.neg_state == NegState.accept_complete:
|
||
|
|
self._complete = True
|
||
|
|
|
||
|
|
else:
|
||
|
|
# This usually indicates the token is a raw NTLM or Kerberos token, return as is.
|
||
|
|
is_spnego = False
|
||
|
|
token = in_token
|
||
|
|
|
||
|
|
self.__chosen_mech = GSSMech.ntlm if token and token.startswith(b"NTLMSSP\x00") else GSSMech.kerberos
|
||
|
|
|
||
|
|
if not self._context_list:
|
||
|
|
self._rebuild_context_list(
|
||
|
|
mech_types=[self.__chosen_mech.value],
|
||
|
|
channel_bindings=channel_bindings,
|
||
|
|
)
|
||
|
|
|
||
|
|
else:
|
||
|
|
self._mech_list = self._rebuild_context_list(
|
||
|
|
channel_bindings=channel_bindings,
|
||
|
|
)
|
||
|
|
|
||
|
|
return token, mech_list_mic, is_spnego
|
||
|
|
|
||
|
|
def _step_spnego_token(
|
||
|
|
self,
|
||
|
|
in_token: typing.Optional[bytes] = None,
|
||
|
|
*,
|
||
|
|
channel_bindings: typing.Optional[GssChannelBindings] = None,
|
||
|
|
) -> typing.Optional[bytes]:
|
||
|
|
chosen_mech = self._chosen_mech
|
||
|
|
context, generated_token = self._context_list[chosen_mech]
|
||
|
|
|
||
|
|
out_token: typing.Optional[bytes] = None
|
||
|
|
if not context.complete:
|
||
|
|
# When usage == 'initiate', the context_list may contain a pre-cached token which we use instead.
|
||
|
|
|
||
|
|
if generated_token:
|
||
|
|
out_token = generated_token
|
||
|
|
self._context_list[chosen_mech] = (context, None) # Clear the value as it's no longer required.
|
||
|
|
|
||
|
|
else:
|
||
|
|
out_token = context.step(in_token=in_token, channel_bindings=channel_bindings)
|
||
|
|
|
||
|
|
# NTLM has a special case where we need to tell it it's ok to generate the MIC and also determine if
|
||
|
|
# it actually did set the MIC as that controls the mechListMIC for the SPNEGO token.
|
||
|
|
if self._requires_mech_list_mic:
|
||
|
|
self._mic_required = True
|
||
|
|
|
||
|
|
return out_token
|
||
|
|
|
||
|
|
def _step_spnego_mic(self, in_mic: typing.Optional[bytes] = None) -> typing.Optional[bytes]:
|
||
|
|
if in_mic:
|
||
|
|
self.verify(pack_mech_type_list(self._mech_list), in_mic)
|
||
|
|
self._reset_ntlm_crypto_state(outgoing=False)
|
||
|
|
|
||
|
|
self._mic_required = True # If we received a mechListMIC we need to send one back.
|
||
|
|
self._mic_recv = True
|
||
|
|
|
||
|
|
if self._mic_sent:
|
||
|
|
self._complete = True
|
||
|
|
|
||
|
|
if self._context.complete and self._mic_required and not self._mic_sent:
|
||
|
|
out_mic = self.sign(pack_mech_type_list(self._mech_list))
|
||
|
|
self._reset_ntlm_crypto_state()
|
||
|
|
|
||
|
|
self._mic_sent = True
|
||
|
|
|
||
|
|
return out_mic
|
||
|
|
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _step_spnego_output(
|
||
|
|
self,
|
||
|
|
out_token: typing.Optional[bytes] = None,
|
||
|
|
out_mic: typing.Optional[bytes] = None,
|
||
|
|
) -> typing.Optional[bytes]:
|
||
|
|
final_token: typing.Optional[bytes] = None
|
||
|
|
|
||
|
|
if not self._init_sent:
|
||
|
|
self._init_sent = True
|
||
|
|
|
||
|
|
init_kwargs: typing.Dict[str, typing.Any] = {
|
||
|
|
"mech_token": out_token,
|
||
|
|
"mech_list_mic": out_mic,
|
||
|
|
}
|
||
|
|
if self.usage == "accept":
|
||
|
|
init_kwargs["hint_name"] = b"not_defined_in_RFC4178@please_ignore"
|
||
|
|
|
||
|
|
final_token = NegTokenInit(self._mech_list, **init_kwargs).pack()
|
||
|
|
|
||
|
|
elif not self.complete:
|
||
|
|
state = NegState.accept_incomplete
|
||
|
|
|
||
|
|
# As per RFC 4178 - 4.2.2: supportedMech should only be present in the first reply from the target.
|
||
|
|
# Also 'negState: request-mic' MUST only be in the first reply from the target if it is needed.
|
||
|
|
# https://tools.ietf.org/html/rfc4178#section-4.2.2
|
||
|
|
supported_mech = None
|
||
|
|
if not self._mech_sent:
|
||
|
|
supported_mech = self._chosen_mech.value
|
||
|
|
if self._mic_required:
|
||
|
|
state = NegState.request_mic
|
||
|
|
|
||
|
|
self._mech_sent = True
|
||
|
|
|
||
|
|
if self._context.complete and (not self._mic_required or (self._mic_sent and self._mic_recv)):
|
||
|
|
state = NegState.accept_complete
|
||
|
|
self._complete = True
|
||
|
|
|
||
|
|
final_token = NegTokenResp(
|
||
|
|
neg_state=state, supported_mech=supported_mech, response_token=out_token, mech_list_mic=out_mic
|
||
|
|
).pack()
|
||
|
|
|
||
|
|
return final_token
|
||
|
|
|
||
|
|
def query_message_sizes(self) -> SecPkgContextSizes:
|
||
|
|
if not self.complete:
|
||
|
|
raise NoContextError(context_msg="Cannot get message sizes until context has been established")
|
||
|
|
|
||
|
|
return self._context.query_message_sizes()
|
||
|
|
|
||
|
|
def wrap(self, data: bytes, encrypt: bool = True, qop: typing.Optional[int] = None) -> WrapResult:
|
||
|
|
return self._context.wrap(data, encrypt=encrypt, qop=qop)
|
||
|
|
|
||
|
|
def wrap_iov(
|
||
|
|
self,
|
||
|
|
iov: typing.Iterable[IOV],
|
||
|
|
encrypt: bool = True,
|
||
|
|
qop: typing.Optional[int] = None,
|
||
|
|
) -> IOVWrapResult:
|
||
|
|
return self._context.wrap_iov(iov, encrypt=encrypt, qop=qop)
|
||
|
|
|
||
|
|
def wrap_winrm(self, data: bytes) -> WinRMWrapResult:
|
||
|
|
return self._context.wrap_winrm(data)
|
||
|
|
|
||
|
|
def unwrap(self, data: bytes) -> UnwrapResult:
|
||
|
|
return self._context.unwrap(data)
|
||
|
|
|
||
|
|
def unwrap_iov(
|
||
|
|
self,
|
||
|
|
iov: typing.Iterable[IOV],
|
||
|
|
) -> IOVUnwrapResult:
|
||
|
|
return self._context.unwrap_iov(iov)
|
||
|
|
|
||
|
|
def unwrap_winrm(self, header: bytes, data: bytes) -> bytes:
|
||
|
|
return self._context.unwrap_winrm(header, data)
|
||
|
|
|
||
|
|
def sign(self, data: bytes, qop: typing.Optional[int] = None) -> bytes:
|
||
|
|
return self._context.sign(data, qop=qop)
|
||
|
|
|
||
|
|
def verify(self, data: bytes, mic: bytes) -> int:
|
||
|
|
return self._context.verify(data, mic)
|
||
|
|
|
||
|
|
@property
|
||
|
|
def _context(self) -> ContextProxy:
|
||
|
|
return self._context_list[self._chosen_mech][0]
|
||
|
|
|
||
|
|
@property
|
||
|
|
def _chosen_mech(self) -> GSSMech:
|
||
|
|
if self.__chosen_mech:
|
||
|
|
return self.__chosen_mech
|
||
|
|
|
||
|
|
return next(iter(self._context_list))
|
||
|
|
|
||
|
|
@property
|
||
|
|
def _context_attr_map(self) -> typing.List[typing.Tuple[ContextReq, int]]:
|
||
|
|
return [] # SPNEGO layer uses the generic commands, the underlying context has it's own specific map.
|
||
|
|
|
||
|
|
@property
|
||
|
|
def _requires_mech_list_mic(self) -> bool:
|
||
|
|
return self._context._requires_mech_list_mic
|
||
|
|
|
||
|
|
def _preferred_mech_list(self) -> typing.List[GSSMech]:
|
||
|
|
"""Get a list of mechs that can be used in priority order (highest to lowest)."""
|
||
|
|
available_protocols = [p for p in self.available_protocols(self.options) if p != "negotiate"]
|
||
|
|
return [getattr(GSSMech, p) for p in available_protocols]
|
||
|
|
|
||
|
|
def _rebuild_context_list(
|
||
|
|
self,
|
||
|
|
mech_types: typing.Optional[typing.List[str]] = None,
|
||
|
|
channel_bindings: typing.Optional[GssChannelBindings] = None,
|
||
|
|
) -> typing.List[str]:
|
||
|
|
"""Builds a new context list that are available to the client."""
|
||
|
|
available_contexts = self._available_contexts or {}
|
||
|
|
last_err = None
|
||
|
|
|
||
|
|
if not available_contexts:
|
||
|
|
context_kwargs: typing.Dict[str, typing.Any] = {
|
||
|
|
"hostname": self._hostname,
|
||
|
|
"service": self._service,
|
||
|
|
"channel_bindings": self.channel_bindings,
|
||
|
|
"context_req": self.context_req,
|
||
|
|
}
|
||
|
|
all_protocols = self._preferred_mech_list()
|
||
|
|
|
||
|
|
for mech in all_protocols:
|
||
|
|
if mech_types and mech.value not in mech_types:
|
||
|
|
continue
|
||
|
|
|
||
|
|
protocol = mech.name
|
||
|
|
try:
|
||
|
|
log.debug(f"Attempting to create {protocol} context when building SPNEGO mech list")
|
||
|
|
|
||
|
|
# Cannot use SSPI's NTLM as we need to reset the crypto state which SSPI does not expose.
|
||
|
|
options = self.options & ~NegotiateOptions.use_negotiate
|
||
|
|
if protocol == "ntlm" and "ntlm" in SSPIProxy.available_protocols(options=options):
|
||
|
|
options |= NegotiateOptions.use_ntlm
|
||
|
|
|
||
|
|
if self.usage == "accept":
|
||
|
|
context = spnego.server(protocol=protocol, options=options, **context_kwargs)
|
||
|
|
else:
|
||
|
|
context = spnego.client(self._credentials, protocol=protocol, options=options, **context_kwargs)
|
||
|
|
|
||
|
|
context._is_wrapped = True
|
||
|
|
available_contexts[mech] = context
|
||
|
|
except Exception as e:
|
||
|
|
last_err = e
|
||
|
|
log.debug("Failed to create context for SPNEGO protocol %s: %s", protocol, str(e))
|
||
|
|
continue
|
||
|
|
|
||
|
|
self._context_list = {}
|
||
|
|
mech_list = []
|
||
|
|
for mech, context in available_contexts.items():
|
||
|
|
try:
|
||
|
|
first_token = context.step(channel_bindings=channel_bindings) if self.usage == "initiate" else None
|
||
|
|
except Exception as e:
|
||
|
|
last_err = e
|
||
|
|
log.debug("Failed to create first token for SPNEGO protocol %s: %s", mech.name, str(e))
|
||
|
|
continue
|
||
|
|
|
||
|
|
self._context_list[mech] = (context, first_token)
|
||
|
|
mech_list.append(mech.value)
|
||
|
|
|
||
|
|
if not mech_list:
|
||
|
|
raise BadMechanismError(context_msg="Unable to negotiate common mechanism", base_error=last_err)
|
||
|
|
|
||
|
|
return mech_list
|
||
|
|
|
||
|
|
def _reset_ntlm_crypto_state(self, outgoing: bool = True) -> None:
|
||
|
|
self._context._reset_ntlm_crypto_state(outgoing=outgoing)
|