Skip to main content

krabka_client_admin/
users.rs

1//! `KafkaUser` admin RPCs.
2//!
3//! Five admin operations the `KafkaUser` reconciler drives:
4//! `AlterUserScramCredentials` (upsert + delete in a single call),
5//! `CreateAcls`, `DeleteAcls`, `DescribeAcls`.
6//!
7//! Wire `i8` discriminants stay private to this module. Callers use the typed
8//! Rust enums below. `crates/client-admin` depends on `krabka-metadata` for
9//! shared image types such as `DelegationToken`, but it stays free of
10//! `krabka-broker`, so out-of-process clients can use the crate. Unit tests
11//! cover the wire round-trip of the local enum copies.
12
13use 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
32/// KIP-554 wire byte for SCRAM-SHA-512. SHA-256 is byte `1`.
33const SCRAM_SHA_512_WIRE: i8 = 2;
34/// SCRAM mechanism byte for SCRAM-SHA-256 (1, KIP-554).
35/// Paired with the `*_sha256` builders/helpers below.
36const 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    /// A delegation token, named by its token id (KIP-48).
49    DelegationToken,
50    /// A user principal, for `CreateTokens` and `DescribeTokens` (KIP-373).
51    User,
52}
53
54#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
55pub enum PatternType {
56    /// Filter only: matches every stored pattern that applies to the filter's
57    /// resource name, the literal name, `*`, and every matching prefix, as
58    /// Kafka's `PatternType.MATCH` does. A stored ACL is never `Match`.
59    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    /// KIP-373: permission to create delegation tokens for other users.
84    CreateTokens,
85    /// KIP-373: permission to describe the delegation tokens of other users.
86    DescribeTokens,
87    /// KIP-939: 2PC participation permission on a `TransactionalId`.
88    TwoPhaseCommit,
89}
90
91/// A concrete, non-filter, ACL entry with every field populated. It matches
92/// the shape the broker stores in its metadata image.
93#[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/// Filter for `DescribeAcls` / `DeleteAcls`. Each `None` axis matches
105/// anything.
106#[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    /// Upserts SCRAM-SHA-512 credentials, deletes them, or both, in a single
164    /// call.
165    ///
166    /// `upsertions` carry plaintext passwords. The function generates a fresh
167    /// 16-byte salt per row and computes the KIP-554 wire `salted_password`
168    /// (PBKDF2-HMAC-SHA-512) client-side with
169    /// `krabka_security::pbkdf2_salted`. The broker never sees the raw
170    /// password.
171    ///
172    /// # Errors
173    /// Returns an error when configuration is invalid, protocol encoding fails, the broker rejects the request, or transport I/O fails.
174    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    /// SCRAM-SHA-256 sibling of
186    /// [`Self::alter_user_scram_credentials_sha512`].
187    ///
188    /// The iteration counts, the salt generation, and the salted-password
189    /// derivation are identical to the SHA-512 path. Only the mechanism wire
190    /// byte and the HMAC algorithm differ.
191    ///
192    /// # Errors
193    ///
194    /// Same as `_sha512`: returns [`AdminError::Protocol`] when the
195    /// system RNG fails, otherwise propagates the broker's
196    /// per-username outcome rows.
197    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    /// Lists ACLs that match `filter`.
209    ///
210    /// The broker's response is resource-grouped on the wire, with one block
211    /// per `(resource_type, resource_name, pattern_type)`. This method
212    /// flattens it back into `AclEntry` rows for the diff.
213    ///
214    /// # Errors
215    /// Returns an error when configuration is invalid, protocol encoding fails, the broker rejects the request, or transport I/O fails.
216    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    /// # Errors
225    /// Returns an error when configuration is invalid, protocol encoding fails, the broker rejects the request, or transport I/O fails.
226    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    /// Creates the supplied ACLs.
248    ///
249    /// # Errors
250    /// Returns [`AdminError::InvalidArgument`], before anything is sent, for
251    /// an entry whose pattern type is [`PatternType::Match`]: Kafka's
252    /// `ResourcePattern` refuses `patternType must not be MATCH`. Otherwise
253    /// returns an error when protocol encoding fails, the broker rejects the
254    /// request, or transport I/O fails.
255    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    /// Deletes every ACL that matches any of `filters`.
275    ///
276    /// Each filter's response surfaces the matched ACL set, so callers can
277    /// confirm that the deletion converged on the expected rows.
278    ///
279    /// # Errors
280    /// Returns an error when configuration is invalid, protocol encoding fails, the broker rejects the request, or transport I/O fails.
281    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                    // Per-row deletion error — bubble it up as the
303                    // filter-level error so the reconciler retries.
304                    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
344/// SCRAM-SHA-256 sibling of [`build_alter_scram_request_sha512`]. It shares
345/// [`build_alter_scram_request`], so the two helpers cannot drift.
346fn 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
496/// Refuses a stored ACL with the filter-only [`PatternType::Match`], with the
497/// message of Kafka's `ResourcePattern` constructor.
498fn 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
510/// Pure function. It serializes an `AclEntry` to the wire representation that
511/// `CreateAcls` expects.
512pub(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
525/// Pure function. It serializes an `AclEntryFilter` to the wire `DeleteAcls`
526/// filter. A `None` axis uses the wire ANY discriminant.
527pub(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
563// --- wire constants & enum encoding/decoding -----------------------------
564//
565// Kept private to this module; the broker has its own copy in
566// `krabka_broker::handlers::acl_wire`. Round-trip tests below lock the
567// encoding against the values Kafka's protocol-spec docs publish.
568
569/// Kafka `AclBindingFilter.ANY` discriminant. Filter requests use it as the
570/// "match anything" placeholder.
571const 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
617/// Decodes the pattern type of a stored ACL in a `DescribeAcls` or
618/// `DeleteAcls` response. `MATCH` (2) is a filter value that no stored ACL
619/// carries, so it is refused like ANY.
620fn 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            // KIP-939: TWO_PHASE_COMMIT (wire byte 15).
807            ("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        // ANY (1) is intentionally rejected on the concrete decoder so
831        // `DescribeAcls`/`DeleteAcls` responses can never silently
832        // claim an "any-type" match — Kafka never returns this in real
833        // responses.
834        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        // 1 == Kafka's `AclBindingFilter.ANY` discriminant (`WIRE_ANY`).
964        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, // SCRAM_SHA_512_WIRE, KIP-554
1144                    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        // 1 == Kafka's `AclBindingFilter.ANY` discriminant (`WIRE_ANY`).
1176        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}