1use bytes::Bytes;
14#[cfg(test)]
15use krabka_protocol::owned::alter_user_scram_credentials_response;
16#[cfg(test)]
17use krabka_protocol::owned::describe_user_scram_credentials_response;
18use krabka_protocol::owned::{
19 alter_user_scram_credentials_request::{
20 AlterUserScramCredentialsRequest, ScramCredentialDeletion, ScramCredentialUpsertion,
21 },
22 create_acls_request::{AclCreation, CreateAclsRequest},
23 delete_acls_request::{DeleteAclsFilter, DeleteAclsRequest},
24 describe_acls_request::DescribeAclsRequest,
25 describe_user_scram_credentials_request::{DescribeUserScramCredentialsRequest, UserName},
26};
27use krabka_security::SaslMechanism;
28use ring::rand::{SecureRandom, SystemRandom};
29
30use crate::{AdminClient, AdminError, KafkaError, kafka_error_if, kafka_error_name};
31
32const SCRAM_SHA_512_WIRE: i8 = 2;
34const SCRAM_SHA_256_WIRE: i8 = 1;
37
38pub use krabka_security::scram::{
39 DEFAULT_SCRAM_ITERATIONS, MAX_SCRAM_ITERATIONS, MIN_SCRAM_ITERATIONS, ScramIterations,
40};
41
42#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
43pub enum ResourceType {
44 Topic,
45 Group,
46 Cluster,
47 TransactionalId,
48 DelegationToken,
50 User,
52}
53
54#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
55pub enum PatternType {
56 Match,
60 Literal,
61 Prefixed,
62}
63
64#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
65pub enum PermissionType {
66 Allow,
67 Deny,
68}
69
70#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
71pub enum AclOperation {
72 All,
73 Read,
74 Write,
75 Create,
76 Delete,
77 Alter,
78 Describe,
79 ClusterAction,
80 DescribeConfigs,
81 AlterConfigs,
82 IdempotentWrite,
83 CreateTokens,
85 DescribeTokens,
87 TwoPhaseCommit,
89}
90
91#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
94pub struct AclEntry {
95 pub resource_type: ResourceType,
96 pub resource_name: String,
97 pub pattern_type: PatternType,
98 pub principal: String,
99 pub host: String,
100 pub operation: AclOperation,
101 pub permission_type: PermissionType,
102}
103
104#[derive(Debug, Clone, Default, PartialEq, Eq, bon::Builder)]
107pub struct AclEntryFilter {
108 pub resource_type: Option<ResourceType>,
109 #[builder(into)]
110 pub resource_name: Option<String>,
111 pub pattern_type: Option<PatternType>,
112 #[builder(into)]
113 pub principal: Option<String>,
114 #[builder(into)]
115 pub host: Option<String>,
116 pub operation: Option<AclOperation>,
117 pub permission_type: Option<PermissionType>,
118}
119
120#[derive(Debug, Clone)]
121pub struct ScramUpsertion {
122 pub username: String,
123 pub password: String,
124 pub iterations: i32,
125}
126
127#[derive(Debug, Clone)]
128pub struct ScramDeletion {
129 pub username: String,
130}
131
132#[derive(Debug, Clone)]
133pub struct ScramUserOutcome {
134 pub username: String,
135 pub error: Option<KafkaError>,
136}
137
138#[derive(Debug, Clone, PartialEq, Eq)]
139pub struct UserScramCredential {
140 pub mechanism: String,
141 pub iterations: i32,
142}
143
144#[derive(Debug, Clone, PartialEq, Eq)]
145pub struct UserScramCredentials {
146 pub username: String,
147 pub credentials: Vec<UserScramCredential>,
148 pub error: Option<KafkaError>,
149}
150
151#[derive(Debug, Clone)]
152pub struct CreateAclOutcome {
153 pub error: Option<KafkaError>,
154}
155
156#[derive(Debug, Clone)]
157pub struct DeleteAclFilterOutcome {
158 pub error: Option<KafkaError>,
159 pub matched: Vec<AclEntry>,
160}
161
162impl AdminClient {
163 pub async fn alter_user_scram_credentials_sha512(
175 &mut self,
176 upsertions: &[ScramUpsertion],
177 deletions: &[ScramDeletion],
178 ) -> Result<Vec<ScramUserOutcome>, AdminError> {
179 let rng = SystemRandom::new();
180 let req = build_alter_scram_request_sha512(upsertions, deletions, &rng)?;
181 let resp = self.conn.send(req).await?;
182 Ok(parse_alter_scram_results(resp))
183 }
184
185 pub async fn alter_user_scram_credentials_sha256(
198 &mut self,
199 upsertions: &[ScramUpsertion],
200 deletions: &[ScramDeletion],
201 ) -> Result<Vec<ScramUserOutcome>, AdminError> {
202 let rng = SystemRandom::new();
203 let req = build_alter_scram_request_sha256(upsertions, deletions, &rng)?;
204 let resp = self.conn.send(req).await?;
205 Ok(parse_alter_scram_results(resp))
206 }
207
208 pub async fn describe_acls(
217 &mut self,
218 filter: &AclEntryFilter,
219 ) -> Result<Vec<AclEntry>, AdminError> {
220 let resp = self.conn.send(filter_to_describe_request(filter)).await?;
221 parse_describe_acls(resp)
222 }
223
224 pub async fn describe_user_scram_credentials(
227 &mut self,
228 users: Option<&[String]>,
229 ) -> Result<Vec<UserScramCredentials>, AdminError> {
230 let req = DescribeUserScramCredentialsRequest {
231 users: users.map(|users| {
232 users
233 .iter()
234 .map(|name| UserName {
235 name: name.clone(),
236 ..Default::default()
237 })
238 .collect()
239 }),
240 ..Default::default()
241 };
242 let resp = self.conn.send(req).await?;
243
244 parse_describe_user_scram_credentials_response(resp)
245 }
246
247 pub async fn create_acls(
256 &mut self,
257 creations: &[AclEntry],
258 ) -> Result<Vec<CreateAclOutcome>, AdminError> {
259 check_concrete_patterns(creations)?;
260 let req = CreateAclsRequest {
261 creations: creations.iter().map(acl_to_creation).collect(),
262 ..Default::default()
263 };
264 let resp = self.conn.send(req).await?;
265 Ok(resp
266 .results
267 .into_iter()
268 .map(|r| CreateAclOutcome {
269 error: kafka_error_if(r.error_code, r.error_message),
270 })
271 .collect())
272 }
273
274 pub async fn delete_acls(
282 &mut self,
283 filters: &[AclEntryFilter],
284 ) -> Result<Vec<DeleteAclFilterOutcome>, AdminError> {
285 let req = DeleteAclsRequest {
286 filters: filters.iter().map(acl_filter_to_wire).collect(),
287 ..Default::default()
288 };
289 let resp = self.conn.send(req).await?;
290 let mut out = Vec::with_capacity(resp.filter_results.len());
291 for fr in resp.filter_results {
292 if let Some(err) = kafka_error_if(fr.error_code, fr.error_message) {
293 out.push(DeleteAclFilterOutcome {
294 error: Some(err),
295 matched: Vec::new(),
296 });
297 continue;
298 }
299 let mut matched = Vec::with_capacity(fr.matching_acls.len());
300 for m in fr.matching_acls {
301 if m.error_code != 0 {
302 return Err(AdminError::Broker {
305 api: "DeleteAcls",
306 code: m.error_code,
307 name: kafka_error_name(m.error_code),
308 message: m.error_message,
309 });
310 }
311 matched.push(AclEntry {
312 resource_type: wire_to_resource_type(m.resource_type)?,
313 resource_name: m.resource_name,
314 pattern_type: wire_to_stored_pattern_type(m.pattern_type)?,
315 principal: m.principal,
316 host: m.host,
317 operation: wire_to_operation(m.operation)?,
318 permission_type: wire_to_permission(m.permission_type)?,
319 });
320 }
321 out.push(DeleteAclFilterOutcome {
322 error: None,
323 matched,
324 });
325 }
326 Ok(out)
327 }
328}
329
330fn build_alter_scram_request_sha512(
331 upsertions: &[ScramUpsertion],
332 deletions: &[ScramDeletion],
333 rng: &SystemRandom,
334) -> Result<AlterUserScramCredentialsRequest, AdminError> {
335 build_alter_scram_request(
336 upsertions,
337 deletions,
338 rng,
339 SaslMechanism::ScramSha512,
340 SCRAM_SHA_512_WIRE,
341 )
342}
343
344fn build_alter_scram_request_sha256(
347 upsertions: &[ScramUpsertion],
348 deletions: &[ScramDeletion],
349 rng: &SystemRandom,
350) -> Result<AlterUserScramCredentialsRequest, AdminError> {
351 build_alter_scram_request(
352 upsertions,
353 deletions,
354 rng,
355 SaslMechanism::ScramSha256,
356 SCRAM_SHA_256_WIRE,
357 )
358}
359
360fn build_alter_scram_request(
361 upsertions: &[ScramUpsertion],
362 deletions: &[ScramDeletion],
363 rng: &SystemRandom,
364 mechanism: SaslMechanism,
365 wire_mechanism: i8,
366) -> Result<AlterUserScramCredentialsRequest, AdminError> {
367 let mut wire_upserts = Vec::with_capacity(upsertions.len());
368 for u in upsertions {
369 let mut salt = vec![0u8; 16];
370 rng.fill(&mut salt)
371 .map_err(|_| AdminError::Protocol("system RNG failure".into()))?;
372 let salted = krabka_security::pbkdf2_salted(
373 u.password.as_bytes(),
374 mechanism,
375 u32::try_from(u.iterations.max(0)).unwrap_or(0),
376 &salt,
377 );
378 wire_upserts.push(ScramCredentialUpsertion {
379 name: u.username.clone(),
380 mechanism: wire_mechanism,
381 iterations: u.iterations,
382 salt: Bytes::from(salt),
383 salted_password: Bytes::from(salted),
384 ..Default::default()
385 });
386 }
387 let wire_deletes = deletions
388 .iter()
389 .map(|d| ScramCredentialDeletion {
390 name: d.username.clone(),
391 mechanism: wire_mechanism,
392 ..Default::default()
393 })
394 .collect();
395 Ok(AlterUserScramCredentialsRequest {
396 upsertions: wire_upserts,
397 deletions: wire_deletes,
398 ..Default::default()
399 })
400}
401
402fn parse_alter_scram_results(
403 resp: <AlterUserScramCredentialsRequest as krabka_protocol::ProtocolRequest>::Response,
404) -> Vec<ScramUserOutcome> {
405 resp.results
406 .into_iter()
407 .map(|r| ScramUserOutcome {
408 username: r.user,
409 error: kafka_error_if(r.error_code, r.error_message),
410 })
411 .collect()
412}
413
414fn parse_describe_user_scram_credentials_response(
415 resp: <DescribeUserScramCredentialsRequest as krabka_protocol::ProtocolRequest>::Response,
416) -> Result<Vec<UserScramCredentials>, AdminError> {
417 if resp.error_code != 0 {
418 return Err(AdminError::Broker {
419 api: "DescribeUserScramCredentials",
420 code: resp.error_code,
421 name: kafka_error_name(resp.error_code),
422 message: resp.error_message,
423 });
424 }
425
426 Ok(resp
427 .results
428 .into_iter()
429 .map(|result| UserScramCredentials {
430 username: result.user,
431 credentials: result
432 .credential_infos
433 .into_iter()
434 .map(|credential| UserScramCredential {
435 mechanism: scram_mechanism_name(credential.mechanism).to_string(),
436 iterations: credential.iterations,
437 })
438 .collect(),
439 error: kafka_error_if(result.error_code, result.error_message),
440 })
441 .collect())
442}
443
444fn scram_mechanism_name(mechanism: i8) -> &'static str {
445 match mechanism {
446 SCRAM_SHA_256_WIRE => "SCRAM-SHA-256",
447 SCRAM_SHA_512_WIRE => "SCRAM-SHA-512",
448 _ => "UNKNOWN",
449 }
450}
451
452fn filter_to_describe_request(f: &AclEntryFilter) -> DescribeAclsRequest {
453 let wire = acl_filter_wire_fields(f);
454 DescribeAclsRequest {
455 resource_type_filter: wire.resource_type_filter,
456 resource_name_filter: wire.resource_name_filter,
457 pattern_type_filter: wire.pattern_type_filter,
458 principal_filter: wire.principal_filter,
459 host_filter: wire.host_filter,
460 operation: wire.operation,
461 permission_type: wire.permission_type,
462 ..Default::default()
463 }
464}
465
466fn parse_describe_acls(
467 resp: <DescribeAclsRequest as krabka_protocol::ProtocolRequest>::Response,
468) -> Result<Vec<AclEntry>, AdminError> {
469 if resp.error_code != 0 {
470 return Err(AdminError::Broker {
471 api: "DescribeAcls",
472 code: resp.error_code,
473 name: kafka_error_name(resp.error_code),
474 message: resp.error_message,
475 });
476 }
477 let mut out = Vec::new();
478 for resource in resp.resources {
479 let rt = wire_to_resource_type(resource.resource_type)?;
480 let pt = wire_to_stored_pattern_type(resource.pattern_type)?;
481 for desc in resource.acls {
482 out.push(AclEntry {
483 resource_type: rt,
484 resource_name: resource.resource_name.clone(),
485 pattern_type: pt,
486 principal: desc.principal,
487 host: desc.host,
488 operation: wire_to_operation(desc.operation)?,
489 permission_type: wire_to_permission(desc.permission_type)?,
490 });
491 }
492 }
493 Ok(out)
494}
495
496fn check_concrete_patterns(entries: &[AclEntry]) -> Result<(), AdminError> {
499 if entries
500 .iter()
501 .any(|entry| entry.pattern_type == PatternType::Match)
502 {
503 return Err(AdminError::InvalidArgument(
504 "patternType must not be MATCH".into(),
505 ));
506 }
507 Ok(())
508}
509
510pub(crate) fn acl_to_creation(e: &AclEntry) -> AclCreation {
513 AclCreation {
514 resource_type: resource_type_to_wire(e.resource_type),
515 resource_name: e.resource_name.clone(),
516 resource_pattern_type: pattern_type_to_wire(e.pattern_type),
517 principal: e.principal.clone(),
518 host: e.host.clone(),
519 operation: operation_to_wire(e.operation),
520 permission_type: permission_to_wire(e.permission_type),
521 ..Default::default()
522 }
523}
524
525pub(crate) fn acl_filter_to_wire(f: &AclEntryFilter) -> DeleteAclsFilter {
528 let wire = acl_filter_wire_fields(f);
529 DeleteAclsFilter {
530 resource_type_filter: wire.resource_type_filter,
531 resource_name_filter: wire.resource_name_filter,
532 pattern_type_filter: wire.pattern_type_filter,
533 principal_filter: wire.principal_filter,
534 host_filter: wire.host_filter,
535 operation: wire.operation,
536 permission_type: wire.permission_type,
537 ..Default::default()
538 }
539}
540
541struct AclFilterWireFields {
542 resource_type_filter: i8,
543 resource_name_filter: Option<String>,
544 pattern_type_filter: i8,
545 principal_filter: Option<String>,
546 host_filter: Option<String>,
547 operation: i8,
548 permission_type: i8,
549}
550
551fn acl_filter_wire_fields(f: &AclEntryFilter) -> AclFilterWireFields {
552 AclFilterWireFields {
553 resource_type_filter: f.resource_type.map_or(WIRE_ANY, resource_type_to_wire),
554 resource_name_filter: f.resource_name.clone(),
555 pattern_type_filter: f.pattern_type.map_or(WIRE_ANY, pattern_type_to_wire),
556 principal_filter: f.principal.clone(),
557 host_filter: f.host.clone(),
558 operation: f.operation.map_or(WIRE_ANY, operation_to_wire),
559 permission_type: f.permission_type.map_or(WIRE_ANY, permission_to_wire),
560 }
561}
562
563const WIRE_ANY: i8 = 1;
572
573macro_rules! acl_wire_enum {
574 ($to_wire:ident, $from_wire:ident, $ty:ty, $unknown:literal, {$($variant:path => $wire:literal),+ $(,)?}) => {
575 pub(crate) fn $to_wire(value: $ty) -> i8 {
576 match value {
577 $($variant => $wire,)+
578 }
579 }
580
581 pub(crate) fn $from_wire(value: i8) -> Result<$ty, AdminError> {
582 match value {
583 $($wire => Ok($variant),)+
584 _ => Err(AdminError::Protocol(format!(concat!($unknown, ": {}"), value))),
585 }
586 }
587 };
588}
589
590acl_wire_enum!(
591 resource_type_to_wire,
592 wire_to_resource_type,
593 ResourceType,
594 "unknown ACL resource_type discriminant",
595 {
596 ResourceType::Topic => 2,
597 ResourceType::Group => 3,
598 ResourceType::Cluster => 4,
599 ResourceType::TransactionalId => 5,
600 ResourceType::DelegationToken => 6,
601 ResourceType::User => 7,
602 }
603);
604
605acl_wire_enum!(
606 pattern_type_to_wire,
607 wire_to_pattern_type,
608 PatternType,
609 "unknown ACL pattern_type discriminant",
610 {
611 PatternType::Match => 2,
612 PatternType::Literal => 3,
613 PatternType::Prefixed => 4,
614 }
615);
616
617fn wire_to_stored_pattern_type(value: i8) -> Result<PatternType, AdminError> {
621 match wire_to_pattern_type(value)? {
622 PatternType::Match => Err(AdminError::Protocol(format!(
623 "unknown ACL pattern_type discriminant: {value}"
624 ))),
625 stored => Ok(stored),
626 }
627}
628
629acl_wire_enum!(
630 permission_to_wire,
631 wire_to_permission,
632 PermissionType,
633 "unknown ACL permission discriminant",
634 {
635 PermissionType::Deny => 2,
636 PermissionType::Allow => 3,
637 }
638);
639
640acl_wire_enum!(
641 operation_to_wire,
642 wire_to_operation,
643 AclOperation,
644 "unknown ACL operation discriminant",
645 {
646 AclOperation::All => 2,
647 AclOperation::Read => 3,
648 AclOperation::Write => 4,
649 AclOperation::Create => 5,
650 AclOperation::Delete => 6,
651 AclOperation::Alter => 7,
652 AclOperation::Describe => 8,
653 AclOperation::ClusterAction => 9,
654 AclOperation::DescribeConfigs => 10,
655 AclOperation::AlterConfigs => 11,
656 AclOperation::IdempotentWrite => 12,
657 AclOperation::CreateTokens => 13,
658 AclOperation::DescribeTokens => 14,
659 AclOperation::TwoPhaseCommit => 15,
660 }
661);
662
663#[cfg(test)]
664mod tests {
665 use std::sync::{Arc, Mutex};
666
667 use assert2::check;
668 use bytes::{Buf, BytesMut};
669 use krabka_client_core::MockBroker;
670 use krabka_protocol::{
671 Decode, Encode, UnknownTaggedFields,
672 owned::{
673 alter_user_scram_credentials_response::{
674 AlterUserScramCredentialsResponse, AlterUserScramCredentialsResult,
675 },
676 api_versions_request,
677 api_versions_response::{ApiVersion, ApiVersionsResponse},
678 create_acls_request,
679 create_acls_response::{AclCreationResult, CreateAclsResponse},
680 delete_acls_request,
681 delete_acls_response::{
682 DeleteAclsFilterResult, DeleteAclsMatchingAcl, DeleteAclsResponse,
683 },
684 },
685 };
686
687 use super::*;
688
689 #[test]
690 fn scram_iterations_match_broker_bounds() {
691 assert2::assert!(ScramIterations::default().into_value() == DEFAULT_SCRAM_ITERATIONS);
692 assert2::assert!(ScramIterations::new(4_096).is_ok());
693 assert2::assert!(ScramIterations::new(16_384).is_ok());
694 for invalid in [0, 4_095, 16_385, i32::MAX] {
695 assert2::assert!(ScramIterations::new(invalid).is_err());
696 }
697 assert2::assert!("8192".parse::<ScramIterations>().is_ok());
698 assert2::assert!("not-a-number".parse::<ScramIterations>().is_err());
699 }
700
701 fn encode_v0(resp: &impl Encode) -> Vec<u8> {
702 encode_at(resp, 0)
703 }
704
705 fn encode_at(resp: &impl Encode, version: i16) -> Vec<u8> {
706 let mut buf = BytesMut::new();
707 resp.encode(&mut buf, version).unwrap();
708 buf.to_vec()
709 }
710
711 fn api_versions_response(api_key: i16, version: i16) -> Vec<u8> {
712 encode_v0(&ApiVersionsResponse {
713 api_keys: vec![
714 ApiVersion {
715 api_key: api_versions_request::API_KEY,
716 min_version: 0,
717 max_version: 0,
718 ..Default::default()
719 },
720 ApiVersion {
721 api_key,
722 min_version: version,
723 max_version: version,
724 ..Default::default()
725 },
726 ],
727 ..Default::default()
728 })
729 }
730
731 fn request_body_after_header(mut body: &[u8], flexible_header: bool) -> &[u8] {
732 let client_id_len = body.get_i16();
733 assert2::assert!(client_id_len >= 0);
734 body.advance(usize::try_from(client_id_len).expect("client id length is non-negative"));
735 if flexible_header {
736 assert2::assert!(body.get_u8() == 0);
737 }
738 body
739 }
740
741 fn sample_entry() -> AclEntry {
742 AclEntry {
743 resource_type: ResourceType::Topic,
744 resource_name: "orders".into(),
745 pattern_type: PatternType::Literal,
746 principal: "User:alice".into(),
747 host: "*".into(),
748 operation: AclOperation::Read,
749 permission_type: PermissionType::Allow,
750 }
751 }
752
753 #[test]
754 fn resource_type_round_trips() {
755 for (_name, rt) in [
756 ("topic", ResourceType::Topic),
757 ("group", ResourceType::Group),
758 ("cluster", ResourceType::Cluster),
759 ("transactional id", ResourceType::TransactionalId),
760 ("delegation token", ResourceType::DelegationToken),
761 ("user", ResourceType::User),
762 ] {
763 assert2::assert!(wire_to_resource_type(resource_type_to_wire(rt)).unwrap() == rt);
764 }
765 }
766
767 #[test]
768 fn pattern_type_round_trips() {
769 for (_name, pt) in [
770 ("match", PatternType::Match),
771 ("literal", PatternType::Literal),
772 ("prefixed", PatternType::Prefixed),
773 ] {
774 assert2::assert!(wire_to_pattern_type(pattern_type_to_wire(pt)).unwrap() == pt);
775 }
776 }
777
778 #[test]
779 fn permission_round_trips() {
780 for (_name, permission) in [
781 ("allow", PermissionType::Allow),
782 ("deny", PermissionType::Deny),
783 ] {
784 assert2::assert!(
785 wire_to_permission(permission_to_wire(permission)).unwrap() == permission
786 );
787 }
788 }
789
790 #[test]
791 fn operation_round_trips() {
792 for (_name, operation) in [
793 ("all", AclOperation::All),
794 ("read", AclOperation::Read),
795 ("write", AclOperation::Write),
796 ("create", AclOperation::Create),
797 ("delete", AclOperation::Delete),
798 ("alter", AclOperation::Alter),
799 ("describe", AclOperation::Describe),
800 ("cluster action", AclOperation::ClusterAction),
801 ("describe configs", AclOperation::DescribeConfigs),
802 ("alter configs", AclOperation::AlterConfigs),
803 ("idempotent write", AclOperation::IdempotentWrite),
804 ("create tokens", AclOperation::CreateTokens),
805 ("describe tokens", AclOperation::DescribeTokens),
806 ("two phase commit", AclOperation::TwoPhaseCommit),
808 ] {
809 assert2::assert!(wire_to_operation(operation_to_wire(operation)).unwrap() == operation);
810 }
811 }
812
813 #[test]
814 fn a_stored_acl_never_decodes_as_match() {
815 for (wire, expected) in [
816 (2, None),
817 (3, Some(PatternType::Literal)),
818 (4, Some(PatternType::Prefixed)),
819 ] {
820 check!(wire_to_stored_pattern_type(wire).ok() == expected);
821 }
822 }
823
824 #[test]
825 fn wire_to_unknown_resource_type_errors() {
826 assert2::assert!(matches!(
827 wire_to_resource_type(99),
828 Err(AdminError::Protocol(_))
829 ));
830 assert2::assert!(matches!(
835 wire_to_resource_type(1),
836 Err(AdminError::Protocol(_))
837 ));
838 }
839
840 #[test]
841 fn a_match_pattern_cannot_be_stored() {
842 let cases = [
843 (PatternType::Literal, Ok(())),
844 (PatternType::Prefixed, Ok(())),
845 (
846 PatternType::Match,
847 Err("patternType must not be MATCH".to_owned()),
848 ),
849 ];
850 for (pattern_type, expected) in cases {
851 let entry = AclEntry {
852 pattern_type,
853 ..sample_entry()
854 };
855 let actual =
856 check_concrete_patterns(&[sample_entry(), entry]).map_err(|error| match error {
857 AdminError::InvalidArgument(message) => message,
858 other => format!("{other:?}"),
859 });
860 check!(actual == expected);
861 }
862 }
863
864 #[test]
865 fn acl_to_creation_matches_discriminants() {
866 let e = AclEntry {
867 pattern_type: PatternType::Prefixed,
868 ..sample_entry()
869 };
870 let c = acl_to_creation(&e);
871 assert2::assert!(
872 c == AclCreation {
873 resource_type: 2,
874 resource_name: "orders".to_string(),
875 resource_pattern_type: 4,
876 principal: "User:alice".to_string(),
877 host: "*".to_string(),
878 operation: 3,
879 permission_type: 3,
880 unknown_tagged_fields: UnknownTaggedFields(vec![]),
881 }
882 );
883 }
884
885 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
886 async fn create_acls_maps_non_empty_broker_results() {
887 let seen_request = Arc::new(Mutex::new(None));
888 let captured_request = Arc::clone(&seen_request);
889 let mock = MockBroker::start(move |api_key, version, _corr_id, body| {
890 if api_key == api_versions_request::API_KEY {
891 return Some(api_versions_response(create_acls_request::API_KEY, 1));
892 }
893 if api_key == create_acls_request::API_KEY {
894 let mut body =
895 request_body_after_header(body, version >= create_acls_request::FLEXIBLE_MIN);
896 let request = CreateAclsRequest::decode(&mut body, version)
897 .expect("create ACLs request decodes");
898 assert2::assert!(body.is_empty());
899 *captured_request.lock().expect("request capture lock") = Some(request);
900 return Some(encode_at(
901 &CreateAclsResponse {
902 results: vec![AclCreationResult {
903 error_code: 36,
904 error_message: Some("acl exists".into()),
905 ..Default::default()
906 }],
907 ..Default::default()
908 },
909 1,
910 ));
911 }
912 None
913 })
914 .await;
915 let mut admin = AdminClient::connect(&[mock.addr.to_string()])
916 .await
917 .expect("admin connects to mock broker");
918 let creation = AclEntry {
919 pattern_type: PatternType::Prefixed,
920 ..sample_entry()
921 };
922
923 let outcomes = admin
924 .create_acls(&[creation])
925 .await
926 .expect("create ACL response maps");
927
928 let error = outcomes[0]
929 .error
930 .as_ref()
931 .expect("broker error is surfaced");
932 assert2::assert!(
933 (outcomes.len(), error.code, error.message.as_deref()) == (1, 36, Some("acl exists"))
934 );
935 let request = seen_request
936 .lock()
937 .expect("request capture lock")
938 .take()
939 .expect("create ACLs request was captured");
940 assert2::assert!(
941 request
942 == CreateAclsRequest {
943 creations: vec![AclCreation {
944 resource_type: resource_type_to_wire(ResourceType::Topic),
945 resource_name: "orders".into(),
946 resource_pattern_type: pattern_type_to_wire(PatternType::Prefixed),
947 principal: "User:alice".into(),
948 host: "*".into(),
949 operation: operation_to_wire(AclOperation::Read),
950 permission_type: permission_to_wire(PermissionType::Allow),
951 ..Default::default()
952 }],
953 ..Default::default()
954 }
955 );
956 mock.stop();
957 }
958
959 #[test]
960 fn acl_filter_to_wire_uses_any_for_none_axes() {
961 let f = AclEntryFilter::builder().build();
962 let w = acl_filter_to_wire(&f);
963 assert2::assert!(
965 w == DeleteAclsFilter {
966 resource_type_filter: 1,
967 resource_name_filter: None,
968 pattern_type_filter: 1,
969 principal_filter: None,
970 host_filter: None,
971 operation: 1,
972 permission_type: 1,
973 unknown_tagged_fields: UnknownTaggedFields(vec![]),
974 }
975 );
976 }
977
978 #[test]
979 fn acl_filter_to_wire_passes_concrete_axes_through() {
980 let f = AclEntryFilter::builder()
981 .resource_type(ResourceType::Topic)
982 .resource_name("orders")
983 .pattern_type(PatternType::Literal)
984 .principal("User:alice")
985 .host("10.0.0.0")
986 .operation(AclOperation::Read)
987 .permission_type(PermissionType::Allow)
988 .build();
989 let w = acl_filter_to_wire(&f);
990 assert2::assert!(
991 w == DeleteAclsFilter {
992 resource_type_filter: 2,
993 resource_name_filter: Some("orders".to_string()),
994 pattern_type_filter: 3,
995 principal_filter: Some("User:alice".to_string()),
996 host_filter: Some("10.0.0.0".to_string()),
997 operation: 3,
998 permission_type: 3,
999 unknown_tagged_fields: UnknownTaggedFields(vec![]),
1000 }
1001 );
1002 }
1003
1004 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
1005 async fn delete_acls_maps_non_empty_matched_acls() {
1006 let seen_request = Arc::new(Mutex::new(None));
1007 let captured_request = Arc::clone(&seen_request);
1008 let mock = MockBroker::start(move |api_key, version, _corr_id, body| {
1009 if api_key == api_versions_request::API_KEY {
1010 return Some(api_versions_response(delete_acls_request::API_KEY, 1));
1011 }
1012 if api_key == delete_acls_request::API_KEY {
1013 let mut body =
1014 request_body_after_header(body, version >= delete_acls_request::FLEXIBLE_MIN);
1015 let request = DeleteAclsRequest::decode(&mut body, version)
1016 .expect("delete ACLs request decodes");
1017 assert2::assert!(body.is_empty());
1018 *captured_request.lock().expect("request capture lock") = Some(request);
1019 return Some(encode_at(
1020 &DeleteAclsResponse {
1021 filter_results: vec![DeleteAclsFilterResult {
1022 matching_acls: vec![DeleteAclsMatchingAcl {
1023 resource_type: resource_type_to_wire(ResourceType::Topic),
1024 resource_name: "orders".into(),
1025 pattern_type: pattern_type_to_wire(PatternType::Literal),
1026 principal: "User:alice".into(),
1027 host: "*".into(),
1028 operation: operation_to_wire(AclOperation::Read),
1029 permission_type: permission_to_wire(PermissionType::Allow),
1030 ..Default::default()
1031 }],
1032 ..Default::default()
1033 }],
1034 ..Default::default()
1035 },
1036 1,
1037 ));
1038 }
1039 None
1040 })
1041 .await;
1042 let mut admin = AdminClient::connect(&[mock.addr.to_string()])
1043 .await
1044 .expect("admin connects to mock broker");
1045 let filter = AclEntryFilter::builder()
1046 .resource_type(ResourceType::Topic)
1047 .resource_name("orders")
1048 .build();
1049
1050 let outcomes = admin
1051 .delete_acls(&[filter])
1052 .await
1053 .expect("delete ACL response maps");
1054
1055 assert2::assert!(
1056 (
1057 outcomes.len(),
1058 outcomes[0].error.as_ref(),
1059 outcomes[0].matched.as_slice()
1060 ) == (1, None, [sample_entry()].as_slice())
1061 );
1062 let request = seen_request
1063 .lock()
1064 .expect("request capture lock")
1065 .take()
1066 .expect("delete ACLs request was captured");
1067 assert2::assert!(
1068 request
1069 == DeleteAclsRequest {
1070 filters: vec![DeleteAclsFilter {
1071 resource_type_filter: resource_type_to_wire(ResourceType::Topic),
1072 resource_name_filter: Some("orders".into()),
1073 pattern_type_filter: WIRE_ANY,
1074 principal_filter: None,
1075 host_filter: None,
1076 operation: WIRE_ANY,
1077 permission_type: WIRE_ANY,
1078 ..Default::default()
1079 }],
1080 ..Default::default()
1081 }
1082 );
1083 mock.stop();
1084 }
1085
1086 #[test]
1087 fn parse_alter_scram_results_preserves_usernames_and_errors() {
1088 let outcomes = parse_alter_scram_results(AlterUserScramCredentialsResponse {
1089 results: vec![AlterUserScramCredentialsResult {
1090 user: "alice".into(),
1091 error_code: 42,
1092 error_message: Some("bad credentials".into()),
1093 ..Default::default()
1094 }],
1095 ..Default::default()
1096 });
1097
1098 let error = outcomes[0].error.as_ref().expect("error is preserved");
1099 assert2::assert!(
1100 (
1101 outcomes.len(),
1102 outcomes[0].username.as_str(),
1103 error.code,
1104 error.message.as_deref()
1105 ) == (1, "alice", 42, Some("bad credentials"))
1106 );
1107 }
1108
1109 #[test]
1110 fn scram_request_carries_pbkdf2_intermediate_not_password() {
1111 let rng = SystemRandom::new();
1112 let upserts = [ScramUpsertion {
1113 username: "alice".into(),
1114 password: "hunter2".into(),
1115 iterations: 4096,
1116 }];
1117 let req = build_alter_scram_request_sha512(&upserts, &[], &rng).unwrap();
1118 let u = &req.upsertions[0];
1119 check!(
1120 (
1121 req.upsertions.len(),
1122 u.name.as_str(),
1123 u.mechanism,
1124 u.iterations,
1125 u.salt.len(),
1126 u.salted_password.len(),
1127 u.salted_password.as_ref() != b"hunter2",
1128 ) == (1, "alice", 2, 4096, 16, 64, true)
1129 );
1130 }
1131
1132 #[test]
1133 fn scram_request_deletions_use_sha512_mechanism() {
1134 let rng = SystemRandom::new();
1135 let dels = [ScramDeletion {
1136 username: "alice".into(),
1137 }];
1138 let req = build_alter_scram_request_sha512(&[], &dels, &rng).unwrap();
1139 assert2::assert!(
1140 req == AlterUserScramCredentialsRequest {
1141 deletions: vec![ScramCredentialDeletion {
1142 name: "alice".to_string(),
1143 mechanism: 2, unknown_tagged_fields: UnknownTaggedFields(vec![]),
1145 }],
1146 upsertions: vec![],
1147 unknown_tagged_fields: UnknownTaggedFields(vec![]),
1148 }
1149 );
1150 }
1151
1152 #[test]
1153 fn scram_request_two_upserts_get_distinct_salts() {
1154 let rng = SystemRandom::new();
1155 let upserts = [
1156 ScramUpsertion {
1157 username: "alice".into(),
1158 password: "p".into(),
1159 iterations: 4096,
1160 },
1161 ScramUpsertion {
1162 username: "bob".into(),
1163 password: "p".into(),
1164 iterations: 4096,
1165 },
1166 ];
1167 let req = build_alter_scram_request_sha512(&upserts, &[], &rng).unwrap();
1168 assert2::assert!(req.upsertions[0].salt != req.upsertions[1].salt);
1169 }
1170
1171 #[test]
1172 fn describe_request_uses_any_for_unspecified_axes() {
1173 let f = AclEntryFilter::builder().principal("User:alice").build();
1174 let r = filter_to_describe_request(&f);
1175 assert2::assert!(
1177 r == DescribeAclsRequest {
1178 resource_type_filter: 1,
1179 resource_name_filter: None,
1180 pattern_type_filter: 1,
1181 principal_filter: Some("User:alice".to_string()),
1182 host_filter: None,
1183 operation: 1,
1184 permission_type: 1,
1185 unknown_tagged_fields: UnknownTaggedFields(vec![]),
1186 }
1187 );
1188 }
1189
1190 #[test]
1191 fn users_describe_scram_top_level_error_returns_broker_error() {
1192 let resp = describe_user_scram_credentials_response::DescribeUserScramCredentialsResponse {
1193 error_code: 31,
1194 error_message: Some("cluster auth denied".to_string()),
1195 ..Default::default()
1196 };
1197
1198 let err = parse_describe_user_scram_credentials_response(resp)
1199 .expect_err("top-level SCRAM describe errors must fail the request");
1200
1201 match err {
1202 AdminError::Broker {
1203 api,
1204 code,
1205 name,
1206 message,
1207 } => {
1208 check!(
1209 (api, code, name, message.as_deref())
1210 == (
1211 "DescribeUserScramCredentials",
1212 31,
1213 "CLUSTER_AUTHORIZATION_FAILED",
1214 Some("cluster auth denied"),
1215 )
1216 );
1217 }
1218 other => panic!("expected broker error, got {other:?}"),
1219 }
1220 }
1221
1222 #[test]
1223 fn users_describe_scram_preserves_credential_iterations() {
1224 let resp = describe_user_scram_credentials_response::DescribeUserScramCredentialsResponse {
1225 results: vec![
1226 describe_user_scram_credentials_response::DescribeUserScramCredentialsResult {
1227 user: "alice".to_string(),
1228 credential_infos: vec![
1229 describe_user_scram_credentials_response::CredentialInfo {
1230 mechanism: 1,
1231 iterations: 4096,
1232 ..Default::default()
1233 },
1234 describe_user_scram_credentials_response::CredentialInfo {
1235 mechanism: 2,
1236 iterations: 8192,
1237 ..Default::default()
1238 },
1239 ],
1240 ..Default::default()
1241 },
1242 ],
1243 ..Default::default()
1244 };
1245
1246 let users = parse_describe_user_scram_credentials_response(resp)
1247 .expect("valid SCRAM describe response should parse");
1248
1249 check!(
1250 (
1251 users.len(),
1252 users[0].username.as_str(),
1253 users[0].credentials.as_slice(),
1254 ) == (
1255 1,
1256 "alice",
1257 [
1258 UserScramCredential {
1259 mechanism: "SCRAM-SHA-256".to_string(),
1260 iterations: 4096,
1261 },
1262 UserScramCredential {
1263 mechanism: "SCRAM-SHA-512".to_string(),
1264 iterations: 8192,
1265 },
1266 ]
1267 .as_slice(),
1268 )
1269 );
1270 }
1271
1272 #[test]
1273 fn users_describe_scram_unknown_user_preserves_resource_not_found_name() {
1274 let resp = describe_user_scram_credentials_response::DescribeUserScramCredentialsResponse {
1275 results: vec![
1276 describe_user_scram_credentials_response::DescribeUserScramCredentialsResult {
1277 user: "ghost".to_string(),
1278 error_code: 91,
1279 error_message: Some("no such SCRAM user".to_string()),
1280 ..Default::default()
1281 },
1282 ],
1283 ..Default::default()
1284 };
1285
1286 let users = parse_describe_user_scram_credentials_response(resp)
1287 .expect("per-user SCRAM describe errors should parse into rows");
1288
1289 check!(
1290 (
1291 users.len(),
1292 users[0].username.as_str(),
1293 users[0].error.as_ref()
1294 ) == (
1295 1,
1296 "ghost",
1297 Some(&KafkaError {
1298 code: 91,
1299 name: "RESOURCE_NOT_FOUND",
1300 message: Some("no such SCRAM user".to_string()),
1301 })
1302 )
1303 );
1304 }
1305
1306 #[test]
1307 fn users_describe_scram_duplicate_user_preserves_duplicate_resource_name() {
1308 let resp = describe_user_scram_credentials_response::DescribeUserScramCredentialsResponse {
1309 results: vec![
1310 describe_user_scram_credentials_response::DescribeUserScramCredentialsResult {
1311 user: "alice".to_string(),
1312 error_code: 92,
1313 error_message: Some("duplicate user".to_string()),
1314 ..Default::default()
1315 },
1316 ],
1317 ..Default::default()
1318 };
1319
1320 let users = parse_describe_user_scram_credentials_response(resp)
1321 .expect("per-user SCRAM describe errors should parse into rows");
1322
1323 check!(
1324 (
1325 users.len(),
1326 users[0].username.as_str(),
1327 users[0].error.as_ref()
1328 ) == (
1329 1,
1330 "alice",
1331 Some(&KafkaError {
1332 code: 92,
1333 name: "DUPLICATE_RESOURCE",
1334 message: Some("duplicate user".to_string()),
1335 })
1336 )
1337 );
1338 }
1339
1340 #[test]
1341 fn users_alter_scram_preserves_scram_error_names() {
1342 let resp = alter_user_scram_credentials_response::AlterUserScramCredentialsResponse {
1343 results: vec![
1344 alter_user_scram_credentials_response::AlterUserScramCredentialsResult {
1345 user: "alice".to_string(),
1346 error_code: 33,
1347 error_message: Some("unknown mechanism".to_string()),
1348 ..Default::default()
1349 },
1350 alter_user_scram_credentials_response::AlterUserScramCredentialsResult {
1351 user: "bob".to_string(),
1352 error_code: 93,
1353 error_message: Some("too many iterations".to_string()),
1354 ..Default::default()
1355 },
1356 ],
1357 ..Default::default()
1358 };
1359
1360 let users = parse_alter_scram_results(resp);
1361
1362 check!(
1363 (
1364 users.len(),
1365 users[0].error.as_ref(),
1366 users[1].error.as_ref(),
1367 ) == (
1368 2,
1369 Some(&KafkaError {
1370 code: 33,
1371 name: "UNSUPPORTED_SASL_MECHANISM",
1372 message: Some("unknown mechanism".to_string()),
1373 }),
1374 Some(&KafkaError {
1375 code: 93,
1376 name: "UNACCEPTABLE_CREDENTIAL",
1377 message: Some("too many iterations".to_string()),
1378 }),
1379 )
1380 );
1381 }
1382
1383 #[test]
1384 fn describe_request_passes_resource_name_and_host_filters_through() {
1385 let f = AclEntryFilter::builder()
1386 .resource_type(ResourceType::Topic)
1387 .resource_name("orders")
1388 .pattern_type(PatternType::Literal)
1389 .principal("User:alice")
1390 .host("10.0.0.0")
1391 .operation(AclOperation::Read)
1392 .permission_type(PermissionType::Allow)
1393 .build();
1394
1395 let r = filter_to_describe_request(&f);
1396
1397 assert2::assert!(
1398 r == DescribeAclsRequest {
1399 resource_type_filter: 2,
1400 resource_name_filter: Some("orders".to_string()),
1401 pattern_type_filter: 3,
1402 principal_filter: Some("User:alice".to_string()),
1403 host_filter: Some("10.0.0.0".to_string()),
1404 operation: 3,
1405 permission_type: 3,
1406 unknown_tagged_fields: UnknownTaggedFields(vec![]),
1407 }
1408 );
1409 }
1410}