THIS IS A TEST INSTANCE. ALL YOUR CHANGES WILL BE LOST!!!!
| Table of Contents |
|---|
Status
Current state: Under DiscussionAdopted (in 2.2)
Discussion thread: here
JIRA: KAFKA-7352
...
The adoption of KIP-255: OAuth Authentication via SASL/OAUTHBEARER in release 2.0.0 creates the possibility of using information in the bearer token to make authorization decisions. Unfortunately, however, Kafka connections are long-lived, so there is no ability to change the bearer token associated with a particular connection. Allowing SASL connections to periodically re-authenticate would resolve this. In addition to this motivation there are two others that are security-related. First, to eliminate access to Kafka for connected clients, the current requirement is to remove all authorizations (i.e. remove all ACLs). This is necessary because of the long-lived nature of the connections. It is operationally simpler to shut off access at the point of authentication, and with the release of KIP-86: Configurable SASL Callback Handlers it is going to become more and more likely that installations will authenticate users against external directories (e.g. via LDAP). The ability to stop Kafka access by simply disabling an account in an LDAP directory (for example) is desirable. The second motivating factor for re-authentication related to security is that the use of short-lived tokens is a common OAuth security recommendation, but issuing a short-lived token to a Kafka client (or a broker when OAUTHBEARER is the inter-broker protocol) currently has no benefit because once a client is connected to a broker the client is never challenged again and the connection may remain intact beyond the token expiration time (and may remain intact indefinitely under perfect circumstances). This KIP proposes adding the ability for SASL clients (and brokers when a SASL mechanism is the inter-broker protocol) to re-authenticate their connections to brokers . If OAUTHBEARER is the SASL mechanism then a new bearer token will appear on the session, replacing the old one. This KIP also proposes to add the ability for and for brokers to close connections that continue to use expired sessions.
...
This KIP has no impact on non-SASL connections (e.g. connections that use the PLAINTEXT or SSL security protocols) – no such connection will be re-authenticated, and no such connection will be closed.
Public Interfaces
This KIP proposes the addition of a configuration option to enable the proposes the addition of two configuration options to enable the client-side re-authentication and server-side expired-connection-kill features feature (both the option defaults result default results in no functionality change, of course, so there is no change to existing behavior in the absence of an explicit opt-insin). This KIP also proposes bumping the version number for the SASL_AUTHENTICATE API to 1 (with no a change in wire format since the payload is a flexible byte buffer already) so that servers brokers can indicate the session expiration time to clients via an additional value on the last round-trip / response. Clients also can use the max SASL_AUTHENTICATE version number supported by the server to determine if they are connected to a broker that supports re-authentication (true if version > 0). This KIP also adds new metrics as described below.
The configuration option this KIP proposes to add to enable clientserver-side reexpired-connection-authentication kill is 'saslconnections.loginmax.refreshreauth.reauthenticate.enable' – it defaults to false, and when explicitly set to true in the context of a client (including a broker when it acts as an inter-broker client) the client-side re-authentication feature will be enabled for any SASL connection. As mentioned above, the SASL_AUTHENTICATE API will have its version number bumped so that any client with the above configuration value set to true will not try to re-authenticate to a broker that has not been upgraded to the necessary version and therefore does not support responding to such requests.ms' (not required to be prefixed with listener prefix or SASL mechanism name – such a value would be used across the cluster – but it may be as mentioned below). For example, "connections.max.reauth.ms=3600000". The value represents the maximum value that could potentially be communicated as part of the new V1 SaslAuthenticateResponse. The default value is 0, which means there is effectively no maximum communicated (0 will be sent, meaning "none"), server-side kill of expired connections is disabled, clients are not required to re-authenticate, and whether clients re-authenticate or not and at what interval is entirely up to them. Existing SASL clients upgraded to v2.2.0 will be coded to not re-authenticate in this scenario. The default value of 0 therefore results in no change whatsoever.
When The configuration option this KIP proposes to add to enable server-side expired-connection-kill is 'connections.max.reauth.ms' – it must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, "sasl_ssl.oauthbearer.connections.max.reauth.ms=3600000". The value defaults to 0. When explicitly set to a non-zero value the server will reject any authentication or re-authentication attempt from a client that presents a bearer token whose remaining lifetime exceeds the time at which the (re-)authentication occurs plus a number of milliseconds equal to the absolute value of the configured value (for example, the remaining token lifetime at the time of (re-)authentication must not exceed one hour if the configured value is either -3600000 or +3600000). When explicitly set to a positive number, in addition to the lifetime check for SASL/OAUTHBEARER, the server will disconnect any SASL connection that does not re-authenticate and subsequently uses the connection for any purpose other than re-authentication at any point beyond the expiration point. For example, if the configured value is 3600000 and the remaining token lifetime at the time of authentication is 45 minutes, is explicitly set to a positive number the server will disconnect any SASL connection that does not re-authenticate and subsequently uses the connection for any purpose other than re-authentication at any point beyond the communicated expiration point (which will not exceed the configured maximum value). For example, if the configured value is 3600000 (1 hour) and the remaining lifetime of a bearer token presented at the time of authentication is 45 minutes, then 45 minutes is communicated back to the client and the server would kill the connection if it is not re-authenticated within 45 minutes and it is then actively used for anything other than re-authentication. As a further example, if the configured value is 3600000 and the credential lifetime is either unspecified or greater than 1 hour then 1 hour would be communicated to the client and the server would kill the connection if it is not re-authenticated within 45 minutes 1 hour and it is then actively used for anything other than re-authentication. As a further example, if the configured value is 3600000 and the mechanism is not OAUTHBEARER (e.g. it is PLAIN, SCRAM-related, or GSSAPI) then the server would kill the connection if it is not re-authenticated within 1 hour and it is then actively used for anything other than re-authentication.
The 'connections.max.reauth.ms' configuration option supports positive and negative values to facilitate migration; typically the value will first be set to a negative value and then it will be converted to its absolute value to fully enable the feature once metrics indicate all clients are upgraded and re-authenticating (see Migration Plan for details).
Older clients will of course not have the session expiration time communicated to them since they will use a version 0 SaslAuthenticateRequest and will receive the existing version 0 SaslAuthenticateResponse. The broker will disconnect these connections upon session expiration regardless of the fact that the client is an older one. Such connections will be captured via a metric (described below) to help with migration.
The 'connections.max.reauth.ms' configuration option will not be dynamically changeable; restarts will be required if the value is to be changed. However, if a new listener is dynamically added, the value could be set for that listener at that time (and the configuration key would be prefixed in that case); this dynamic capability will be addressed as a separate ticket and may not be delivered with the initial KIP implementationNeither of the above configuration options will be dynamically changeable; restarts will be required if either value is to be changed.
From a behavior perspective on the client side (again, including the broker when it is acting as an inter-broker client), when the client-side re-authentication option is enabled and a a v2.2.0-or-later SASL client connects to a v2.2.0 or later broker that supports re-authentication, the broker will communicate the session expiration time as part of the authentication "dance". The client will then final SASL_AUTHENTICATE response. If this value is positive, then the client will automatically re-authenticate on or after that point before sending anything else unrelated to re-authentication is sent beyond that expiration point. If the re-authentication attempt fails then the connection will be closed by the broker; retries are not supported. If re-authentication succeeds then any requests received responses that queued up during re-authentication along with the Send that triggered the re-authentication to occur in the first place will subsequently be able to flow through , and (back to the client and along to the broker, respectively), and eventually the connection will re-authenticate again, etc. Note also that the client cannot queue up additional send requests beyond the one that triggers re-authentication to occur until re-authentication succeeds and the triggering one is sent.
From a behavior perspective on the server (broker) side, when the broker-side expired-connection-kill feature is fully enabled with a positive value the broker will communicate a session time via SASL_AUTHENTICATE and will close a connection authenticated via the indicated SASL mechanism when the connection is used past the expiration time and the specific API request is not directly related to re-authentication (ApiVersionsRequest, SaslHandshakeRequest, and and SaslAuthenticateRequest). In other words, if a connection sits idle, it will not be closed – something unrelated to re-authentication must traverse the connection before a disconnect will occur.
Metrics documenting re-authentications will be maintained in the Selector code. They SOme will mirror existing metrics that document authentications. For example: failed-reauthentication-{rate,total} and successful-reauthentication-{rate,total}.A broker metric will be created that documents the number of API requests unrelated to re-authentication that are made over a connection that is considered expired. This metric may be non-zero only when the configuration value is negative. It helps operators ensure that There will also be separate successful-authentication-no-reauth-{rate,total} metrics to indicate the subset of clients that successfully authenticate with a V0 SaslAuthenticateRequest (or no such request, which can happen with very old clients) These metrics are helpful during migration (see Migration Plan for details) as they will identify if/when all clients are properly upgraded and re-authenticating before fully turning on server-side expired-connection-kill functionality (by changing the negative configuration value to its absolute value)is enabled: the rate metric will be unchanging zero across all brokers when it is safe appropriate to fully enable the feature with the absolute value.
A broker metric will be created that documents the number connections killed by the server-side expired-connection-kill functionality. This metric may be non-zero only when the configuration value is positive, and it indicates that a client is connecting to the broker with re-authentication either unavailable (i.e. an older client) or disabled.
A client metric will be created that documents the latency imposed by re-authentication. It is unclear if this latency will be problematic, and the data collected via this metric , and the total metric will be unchanging (zero after a restart). There will also be reauthentication-latency-{avg,max} metrics that document the latency imposed by re-authentication. It is unclear if this latency will be problematic, and the data collected via these metrics may be useful as we consider this issue in the future.
Proposed Changes
Implementation Overview
The description of this KIP is actually quite straightforward from a behavior perspective – turn the feature on with the configuration options in both the client and the broker and it just works. From an implementation perspective, though, the KIP is not so straightforward; a description of how it works therefore follows below. Note that this description applies to the implementation only – none of this is part of the public API.
This implementation works at a very low level in the Kafka stack, at the level of the network code. It is therefore transparent to all clients – it just works with no knowledge or accommodation required on their part. When a client makes a request to a broker the request is intercepted at the level of the Selector class and a check is done to see if re-authentication is enabled; if it is, and the broker supports re-authentication, then the connection is re-authenticated at that point before the request is allowed to flow through. The solution is elegant because it re-uses existing code paths while requiring no code changes higher up in the stack.
This KIP transparently adds re-authentication support for all uses, which at this point includes the following:
An additional metric ExpiredConnectionsKilledCount will be created and maintained by the server-side Processor code to count the number of such events. It should remain at zero if all clients and brokers are upgraded to v2.2.0 or later. If it is non-zero then either an older client is connecting (which would be evidenced in the successful-authentication-no-reauth metrics mentioned above) or a newer client is not re-authenticating correctly (which would indicate a bug).
Proposed Changes
Implementation Overview
The description of this KIP is actually quite straightforward from a behavior perspective – turn the feature on with the configuration option in the broker and it just works. From an implementation perspective, though, the KIP is not so straightforward; a description of how it works therefore follows below. Note that this description applies to the implementation only – none of this is part of the public API.
This implementation works at a very low level in the Kafka stack, at the level of the network code. It is therefore transparent to all clients – it just works with no knowledge or accommodation required on their part. When a client makes a request to a broker the request is intercepted at the level of the Selector class and a check is done to see if re-authentication is enabled; if it is, and the broker supports re-authentication, then the connection is re-authenticated at that point before the request is allowed to flow through. The solution is elegant because it re-uses existing code paths while requiring no code changes higher up in the stack.
This KIP transparently adds re-authentication support for all uses, which at this point includes the following:
org.apache.kafka.clients.consumer.internals.ConsumerNetworkClientorg.apache.kafka.clients.consumer.
org.apache.kafka.clients.consumer.internals.ConsumerNetworkClientorg.apache.kafka.clients.consumer.KafkaConsumerorg.apache.kafka.connect.runtime.distributed.WorkerGroupMember.WorkerGroupMember
kafka.controller.ControllerChannelManagerorg.apache.kafka.clients.admin.KafkaAdminClientorg.apache.kafka.clients.producer.KafkaProducerkafka.coordinator.transaction.TransactionMarkerChannelManagerkafka.server.ReplicaFetcherBlockingSend (kafka.server.ReplicaFetcherThread)kafka.controlleradmin.ControllerChannelManagerAdminClientorgkafka.apachetools.ReplicaVerificationToolkafka.clientsserver.admin.KafkaAdminClientKafkaServerorg.apache.kafka.clientstrogdor.producerworkload.KafkaProducerkafka.coordinator.transaction.TransactionMarkerChannelManagerkafka.server.ReplicaFetcherBlockingSend (kafka.server.ReplicaFetcherThread)kafka.admin.AdminClientkafka.tools.ReplicaVerificationToolkafka.server.KafkaServerorg.apache.kafka.trogdor.workload.ConnectionStressWorker
The final issue to describe is how/when a KafkaChannel instance (each of which corresponds to a unique network connection) is told to re-authenticate. Each KafkaChannel instance will remember the session expiration time communicated during (re-)authentication (if any); the code in the Selector class will check to see if that time has passed and will start the re-authentication process if so.
...
ConnectionStressWorker
The final issue to describe is how/when a KafkaChannel instance (each of which corresponds to a unique network connection) is told to re-authenticate. Each KafkaChannel instance will remember the session expiration time communicated during (re-)authentication (if any); the code in the Selector class will check to see if that time has passed and will start the re-authentication process if so.
Compatibility, Deprecation, and Migration Plan
| Anchor | ||||
|---|---|---|---|---|
|
With respect to compatibility, there is no impact to existing installations because the default is for the server-side connection kill feature to be turned off, older clients never try to re-authenticate because they don't support it, and newer clients that connect to older brokers will know that the broker does not support re-authentication and will therefore not attempt it.
With respect to migration, the approach would be as follows:
- Upgrade all brokers to v2.2.0 or later at whatever rate is desired with '
connections.max.reauth.ms' allowed to default to 0. If SASL is used for the inter-broker protocol then brokers will check the SASL_AUTHENTICATE API version and use a V1 request when communicating to a broker that has been upgraded to 2.2.0, but the client will see the "0" session max lifetime and will not re-authenticate. Their connections will not be killed. - In parallel with (1) above, upgrade non-broker clients to v2.2.0 or later at whatever rate is desired. SASL clients will check the SASL_AUTHENTICATE API version and use a V1 request when communicating to a broker that has been upgraded to 2.2.0, but the client will see the "0" session max lifetime and will not re-authenticate. Their connections will not be killed.
- After (1) and (2) are complete, perform a rolling restart of all brokers and check the metrics
successful-authentication-no-reauth-{rate,total}to confirm that they remain at zero. This gives confidence that (1) and (2) are indeed complete. - Update '
connections.max.reauth.ms' to a positive value and perform a rolling restart of brokers again. - Monitor the
successful-authentication-no-reauth-{rate,total}metrics – they will remain at 0 unless an older client connects to the broker.
Rejected Alternatives
Delaying Support for Brokers Killing Connections
It was initially proposed that we defer adding the ability for brokers to kill connections using expired credentials to a future KIP. This functionality is actually easier to add than re-authentication, and re-authentication without this feature doesn't really improve security (because it can't be enforced). Adding the ability to kill connections using an expired bearer token without the ability for the client to re-authenticate also does not make sense as a general feature – it forces the client to essentially "recover" from what looks like a network error on a periodic basis. So we will implement both features at the same time.
Delaying Support for non-OAUTHBEARER SASL Mechanisms
It was initially proposed that we defer adding the ability for SASL clients to re-authenticate when using a non-OAUTHBEARER mechanism (e.g. PLAIN, GSSAPI, and SCRAM-related). We were able to identify how all mechanisms could be readily and easily supported.
Creating a Configuration Option to Disable Client-side Re-Authentication
It was initially proposed that we would create a client-side configuration option to disable the use of re-authentication on the client. This may have been necessary when we were contemplating not including support for non-OAUTHBEARER SASL mechanisms and/or when we had not decided to bump the SASL_AUTHENTICATE version number, but it because unnecessary given these decisions. There is no need to disable the feature if the client and the server both support it.
Validating the Token Lifetime as Part of Re-Authentication
It was initially proposed that we would have the broker reject (re-)authentications that occurred with a credential having a lifetime longer than the maximum allowed. This was decided to be unnecessary here because the same thing can be done as part of token validation
...
With respect to compatibility, there is no impact to existing installations because the default is for the feature to be completely turned off on both the client and server.
With respect to migration, the approach would be as follows:
- Upgrade all brokers to v2.1.0 or later
- After (1) is complete, turn on re-authentication for brokers (as inter-broker clients, via '
sasl.login.refresh.reauthenticate.enable') at whatever rate is desired -- just eventually, at some point, get the client-side feature turned on for all brokers so that inter-broker connections are re-authenticating. (Skip this step and consider it complete if SASL/OAUTHBEARER is not used for inter-broker communication.) - After (2) is complete, partially enable the server-side kill functionality with a negative value for '
[listener].[mechanism].connections.max.reauth.ms' on all brokers. The metric documenting the number of API requests made over expired connections will begin to increase until the next step (4) is completed. No connections will be killed. - In parallel with (1), (2), and (3) above, upgrade non-broker clients to v2.1.0 or later and turn their re-authentication feature on. SASL clients will check the SASL_AUTHENTICATE API version and only re-authenticate to a broker that has been upgraded to 2.1.0 or later (note that the ability of a broker to respond to a re-authentication cannot be turned off -- it is always on beginning with version 2.1.0, and it just sits there doing nothing if it isn't exercised by an enabled client).
- After (3) and (4) are complete, check the broker metric documenting the number of API requests made over expired connections to confirm that it is no longer increasing. Once you are satisfied that (1), (2), (3), and (4) are indeed complete you can fully enable the server-side expired-connection-kill feature on each broker by changing the '
[listener].[mechanism].connections.max.reauth.ms' value from its negative value to its absolute value and restarting the broker. - Monitor the metric that documents the number of killed connections – it will remain at 0 unless an older client or one that does not have re-authentication enabled connects to the broker via the SASL mechanism.
Rejected Alternatives
Delaying Support for Brokers Killing Connections
It was initially proposed that we defer adding the ability for brokers to kill connections using expired credentials to a future KIP. This functionality is actually easier to add than re-authentication, and re-authentication without this feature doesn't really improve security (because it can't be enforced). Adding the ability to kill connections using an expired bearer token without the ability for the client to re-authenticate also does not make sense as a general feature – it forces the client to essentially "recover" from what looks like a network error on a periodic basis. So we will implement both features at the same time.
Delaying Support for non-OAUTHBEARER SASL Mechanisms
It was initially proposed that we defer adding the ability for SASL clients to re-authenticate when using a non-OAUTHBEARER mechanism (e.g. PLAIN, GSSAPI, and SCRAM-related). We were able to identify how all mechanisms could be readily and easily supported.
Highest-Level Approach: Inserting Requests into Clients' Queues
...
It was initially proposed that we make an existing, non-public ExpiringCredential interface part of the public API and leverage the background login refresh thread's refresh event to kick-start re-authentication on the client side for the refreshed credential. This is unnecessary due to the combination a couple of a few factors. First, the server (broker) indicates to the client what the expiration time is, and the low-level mechanism we have chosen on the client side can insert itself into the flow at the correct time – it does not ned an need an external mechanism; and second, the server will chose the token expiration time as the session expiration time if does not exceed the maximum allowable value, which means the refresh thread on the client side will have already refreshed the token (or, if it hasn't, the client can't make new connections anyway); third, . We had at one time considered that the server will reject rejecting tokens whose remaining lifetime exceeds the maximum allowable session time was a third factor, but that functionality was rejected because it can be done as part of token validation as mentioned above.
Authenticating a Separate Connection and Transferring Credentials
...