Method, system and apparatus for generating wireless communication parameters based on dynamic security roots

Abstract

The application discloses a wireless communication parameter generation method, system and device based on a dynamic security root, and belongs to the technical field of wireless communication. The core of the method is that: the two communication parties share a security key (K_sec) in advance, and independently obtain or evolve a consistent time-varying parameter (S) based on a predetermined mechanism; the two parties independently generate the same communication parameter (Param) through the same cryptographic function based on K_sec and S, and realize zero signaling collaboration. The predetermined mechanism is preferably a protocol security state machine based on a dynamic security root (DSF), and the DSF is composed of K_sec, an initial anchor point and a state transition rule (Rule_ID). Rule_ID defines three configurable rules: rule A uses broadcast timing, rule B is based on a hash chain, and rule C is based on a logical epoch, which are respectively suitable for short-time high robustness, continuous high performance and continuous high energy efficiency scenes. Based on this unified paradigm, the application further realizes security pilot bearing, scheduling-free access, zero signaling switching, high-precision positioning and synchronization recovery and the like, systematically solves the problems of large signaling overhead, poor synchronization robustness, disconnection between security and process in the traditional scheme, and provides a complete solution of endogenous security and full-stack zero signaling for the next generation of wireless communication systems.

Description

Technical Field

[0001] This invention belongs to the field of wireless communication technology, specifically relating to access, transmission, mobility management, and intrinsic security technologies for next-generation wireless communication systems (such as 5G-Advanced and 6G). More specifically, this invention provides a systematic method for dynamically generating communication parameters based on a protocol-secure state machine, a complete communication system for implementing this method, and resource management, mobility support, and fault-tolerant recovery mechanisms inherent in this system. Background Technology

[0002] Cross-reference to related applications This application claims priority to the following Chinese patent applications, the entire contents of which are incorporated herein by reference: - Application No.: 2025108837722, Invention Title: Wireless Bearer System Based on Secure Full-Duplex Pilot Sequence, Application Date: June 30, 2025; - Application No.: 2025109607446, Invention Title: A Positioning Method Based on Safety Pilot Bearing, Application Date: June 30, 2025; - Application No.: 2025111957715, Invention Title: Scheduling-Free Secure Access Method, Apparatus and System Based on Dynamic Resource Commitment, Application Date: August 26, 2025; - Application No.: 2025115862220, Invention Title: Zero Signaling Allocation Method and System for Communication Parameters Based on Dynamic Security Foundation, Application Date: November 1, 2025.

[0003] To support critical tasks such as industrial automation, telemedicine, autonomous driving, and extended reality, next-generation wireless communication networks need to simultaneously achieve extreme performance metrics: sub-millisecond end-to-end latency, reliability exceeding 99.9999%, and forward security to withstand future quantum computing threats. However, traditional communication paradigms based on dynamic signaling scheduling (such as downlink control information (DCI)) introduce significant overhead and random latency in their protocol stack processing, signaling interaction, and encryption processes, becoming a fundamental bottleneck for performance improvement.

[0004] "Implicit collaboration" or "scheduling-free" communication is considered the core direction for breaking through the above bottlenecks. Its ideal goal is that the two communicating parties can independently and synchronously generate all the parameters required for communication (such as pilot sequences, physical resource locations, session keys, protocol process identifiers, etc.) without any real-time signaling interaction, based on some pre-shared or deducible consensus, thereby achieving "intrinsic security" and "zero signaling" transmission.

[0005] However, existing technological approaches have fundamental limitations or systemic deficiencies in achieving "implicit synergy": The first type of limitation is the strong dependence on physical layer timing and the risk of losing synchronization.

[0006] Currently, the mainstream approach in the industry to achieve scheduling-free or reduced signaling overhead relies on semi-static configuration of physical layer resources using higher-layer signaling (such as Radio Resource Control (RRC) signaling) and directly uses physical layer timing information (such as System Frame Number (SFN) and Slot Index) as dynamic input during operation. For example, the "Configured Grant" access mechanism defined by 3GPP in standards such as TR 38.913. While this approach reduces dynamic scheduling signaling, its synchronization and security mechanisms remain essentially no different from traditional methods. Its core flaw lies in the fact that the synchronization basis relied upon by both communicating parties is a physical clock with inherent errors and continuous drift. In scenarios such as high-speed movement, deep sleep wake-up, or inter-base station handover, microsecond-level clock deviations are sufficient to cause inconsistencies in the two parties' judgments of the SFN / Slot Index at the same physical moment, rendering any collaborative computation based on this timing fundamentally ineffective and exhibiting poor robustness.

[0007] The second limitation is the lack of a systematic solution that deeply integrates security and synchronization.

[0008] In the realm of physical layer security, while techniques such as key generation based on channel characteristics exist, their effectiveness heavily relies on channel reciprocity and real-time measurement. They fail in asymmetric or static scenarios and are difficult to integrate with protocol layer processes such as access, scheduling, and handover. At the cryptographic application level, existing solutions typically treat security (e.g., key `K`) and synchronization (e.g., counter `C`) as two independent modules. The industry has yet to propose a systematic technical solution that creatively binds the secure key to a robust, clock-decoupled synchronization state machine, forming a unified "dynamic generation foundation" from which all communication parameters are deterministically derived. This makes it impossible for existing solutions to simultaneously meet the stringent requirements of forward security, resistance to quantum attacks, high robustness, and zero signaling across the entire protocol stack.

[0009] The series of prior applications filed by the inventor (i.e., the four patents claiming priority in this application) breaks through the aforementioned limitations for the first time. The core inventive idea of ​​this series of applications lies in the pioneering proposal and implementation of a novel paradigm: "using a secure key and a time-varying parameter, through predetermined cryptographic deterministic computation, to generate various parameters required for communication." In this paradigm, the secure key provides a long-term security foundation, the time-varying parameter provides dynamism and forward security, and the combination of the two guarantees the uniqueness, randomness, and consistency of the generated parameters through cryptographic functions.

[0010] Based on this core idea, the inventors explored different paths for obtaining "time-varying parameters": 1. Path One (Public Synchronization Parameter Path, corresponding to preceding applications 1-4): For one-off or short-term processes such as random access and handover, this approach innovatively proposes directly utilizing physical layer timing information broadcast by the network as time-varying parameters. This timing information includes, but is not limited to, slot indexes and system frame numbers (SFNs). SFNs, due to their longer period (e.g., 1024 frames), strong broadcast capability, and ease of obtaining consistent values ​​by terminals under coarse synchronization, exhibit unique robustness in addressing potential short-term timing deviations between terminals and the network, making them particularly suitable for cooperative operations that can be completed within a few frame periods. This scheme is direct and easy to standardize.

[0011] 2. Paths Two and Three (Protocol State Machine Path, corresponding application number: 2026100000841: application withdrawn, main content modified and improved in this application): Addressing the higher requirements for synchronization robustness and forward security in long-cycle continuous communication, a more general scheme is proposed to construct a "protocol synchronization state machine" to generate time-varying parameters. This state machine is decoupled from the instantaneous value of the physical clock, ensuring long-term consistency through initial anchor points and evolution rules. Specifically, it includes two implementation methods: hash chain and logical state machine, with its time-varying parameters initiated through an initial anchor point transmitted via a secure channel.

[0012] However, the preceding application has not yet incorporated the three technical paths mentioned above into a unified, hierarchical theoretical framework. While the three paths appear independent, they actually share the same core inventive idea and form a complementary and complete system in the acquisition of "time-varying parameters." The background section of application number 2026100000841 also fails to clearly demonstrate the fundamental breakthrough of this invention compared to existing technologies.

[0013] Therefore, this application aims to systematically summarize and elevate the aforementioned series of applications, and for the first time explicitly proposes a fundamental communication paradigm centered on a "protocol security state machine." This state machine deeply integrates security keys, synchronization states, and state transition rules to form a unified Dynamic Security Foundation (DSF). Based on this, a complete technical solution is systematically constructed, encompassing two main categories and three specific state transition rules: short-term broadcast synchronization (corresponding to path one) and long-term autonomous synchronization (corresponding to paths two and three). This not only provides optimal technical choices for different scenarios (such as one-time access vs. continuous transmission), forming a self-consistent and smoothly evolving communication system architecture, but also fundamentally establishes the foundational position of the core idea of ​​this invention, laying a solid foundation for the future evolution of wireless communication systems towards full-stack zero signaling and intrinsic security. Summary of the Invention

[0014] Addressing the fundamental limitations and systemic deficiencies of existing solutions in achieving "implicit collaboration" as pointed out in the background section, the present invention aims to provide a unified and systematic method, system, and apparatus for generating wireless communication parameters. This method, based on a "protocol security state machine" as its core paradigm, is the first to construct a complete technical system covering different application scenarios and robustness requirements.

[0015] To achieve the above objectives, the present invention adopts the following technical solution: I. Core Paradigm: A Unified Parameter Generation Model Based on Protocol-Secure State Machines This invention discloses and defines a fundamental operational paradigm for future wireless communication. The core of this paradigm is that any dynamic parameter (hereinafter referred to as "communication parameter") that requires the cooperation of both communicating parties and does not require real-time signaling interaction can be deterministically generated through a "protocol security state machine" shared by both parties.

[0016] The protocol security state machine is uniquely determined and initialized by a triplet, which is called the Dynamic Security Foundation (DSF). `DSF = (K_sec, Init_Anchor, Rule_ID)` - Security key (`K_sec`): A long-term security foundation obtained through authentication and key negotiation processes, providing identity binding and cryptographic strength.

[0017] - Initial Anchor (`Init_Anchor`): The initial state information and effective conditions required for the state machine to start (such as an absolute point in the future).

[0018] - State transition rule identifier (`Rule_ID`): Defines the type of the state machine, the internal state evolution algorithm, and the set of parameters for triggering state updates. `Rule_ID` is configurable, and its core parameter—update tick—defines the temporal granularity of state evolution, which can be decoupled from physical layer timing.

[0019] When establishing a connection, both communicating parties synchronize the `DSF` through a secure process. Subsequently, based on the same `DSF`, both parties independently and synchronously run their respective local protocol security state machines. Driven by `Rule_ID`, this state machine autonomously evolves over time or events, outputting a time-varying synchronization state variable, denoted as `S(t)`.

[0020] For any communication parameter `Param_x` that requires zero signaling coordination, its generation follows a unified formula: `Param_x = F( K_sec, S(t), Context_x )` in: - `F` is a cryptographic deterministic function (such as a hash function, HMAC, or KDF) known to both communicating parties.

[0021] > Explanation of the unified formula: The formula `Param_x = F( K_sec, S(t), Context_x )` is the core abstraction for parameter generation. In practical applications, depending on the `Rule_ID`, the role of `S(t)` in cryptographic computation can be specified in two modes: > 1. Secret Input Pattern (Applicable to Rule B): `S(t)` itself is a secret hash chain state, which can be directly used as a strong random source in the computation.

[0022] 2. Public Parameter Binding Mode (Applicable to Rules A and C): `S(t)` is a public or publicly available logical state (e.g., `SFN`, `(Epoch_ID, Counter)`). Its core function is to cryptographically bind with `K_sec`, ensuring that the generated `Param_x` is strongly associated with a specific logical moment. The function `F` must ensure that even if `S(t)` is public, `Param_x` cannot be derived without knowing `K_sec`. This mode is equivalent to first deriving a time-varying secret `D = G(K_sec, S(t))` from `K_sec` and `S(t)`, and then calculating `Param_x = F'(D, Context_x)`, where `G` and `F'` are predefined cryptographic functions.

[0023] - `Context_x` is optional context information used to distinguish different parameter types, users, or business flows.

[0025] II. Three specific implementations of the state transition rule (`Rule_ID`) The systematic contribution of this invention lies in its first explicit and complete definition of three specific state transition rules for protocol security state machines, forming a complete solution ranging from simple to complex, from short-term to long-term, and from public to secret. These three rules are identified and selected through different `Rule_ID` values.

[0026] Rule A: Broadcast clock driven rule (applicable to one-time / short-term robust collaboration) This rule applies to collaborative scenarios that are short in duration and can be completed within one or several system frame cycles, such as initial random access and handover execution.

[0027] > - State Definition and Evolution: The synchronization state `S(t)` is directly defined as the physical layer timing information decoded from network broadcast information, such as the system frame number `SFN` and the slot index `Slot_Index`. To meet the forward security requirements of longer-term collaborative scenarios, the synchronization state `S(t)` can be further defined as a long-period logical timing base `T_Base` constructed from the broadcast timing of each level, for example: `T_Base = A * Hyper_SFN + B * SFN + C * Slot_Index`, where `Hyper_SFN` is the extended superframe number, and `A`, `B`, and `C` are non-zero coefficients. This construction ensures that `T_Base` is globally unique and monotonically increasing during the validity period of the security key. The "evolution" of `S(t)` is triggered by the terminal listening to and decoding network broadcasts.

[0028] > - Consistency guarantee: Relying on the existing physical layer synchronization mechanism to achieve frame-level coarse synchronization between the terminal and the network, thereby ensuring that the broadcast timing information read by both parties or the calculated `T_Base` is consistent.

[0029] > - `Rule_ID` characteristics: The state update tick under this rule is determined by the network broadcast period (e.g., 10ms per frame) or the slot-level interval (e.g., 0.125ms). Its `Init_Anchor` is usually simplified to a target listening time (e.g., `Target_SFN / Slot` or target `T_Base` value). This rule is the simplest practice for implementing the core paradigm in scenarios with short-term, high-robust requirements, and its enhanced design (using `T_Base`) can also support longer-term collaboration with forward security requirements.

[0030] Rule B: Hash chain driven rule (suitable for continuous communication, prioritizing high performance and forward security) This rule applies to scenarios such as Ultra Reliable Low Latency Communication (URLLC) that require continuous, long-term communication and have extreme requirements for security update rate and latency.

[0031] - State Definition and Evolution: The synchronization state `S(t)` is a secret hash chain value, denoted as `T_State[n]`. Its evolution follows: `T_State[n] = H(K_sec || T_State[n-1] || “CHAIN_TAG”)`, where `H` is the hash function and `n` is the logical counter. State updates are triggered by configurable logical ticks `T_update` (e.g., 0.125ms, 0.5ms, 1ms) defined in `Rule_ID`, and `n` increments accordingly.

[0032] - Consistency Guarantee: Both communicating parties share the initial chain head `Seed_0` (contained in `Init_Anchor`) and the corresponding logical start time. Starting from this time, both parties independently advance the counter `n` and calculate the chain state based on the same `Rule_ID` (containing the hash function `H` and the tick `T_update`). The "silent calibration" mechanism described later absorbs physical clock drift, ensuring long-term consistency.

[0033] - `Rule_ID` characteristics: The state `S(t)` is a secret value, providing forward safety. Its update tick `T_update` can be configured to be slot-level or finer-grained, tightly coupled with physical resource scheduling, to achieve high performance.

[0034] Rule C: Logic epoch-driven rule (applicable to continuous communication, pursuing high robustness and energy efficiency) This rule applies to scenarios such as massive machine-type communication (mMTC) or high mobility that require long-term, robust synchronization and have high tolerance for clock drift and energy efficiency requirements.

[0035] - State Definition and Evolution: The synchronization state `S(t)` is a public logical state, denoted as `(Epoch_ID, Counter)`. Its evolution is triggered by the configurable logical ticks `T_logical` (e.g., 1ms, 10ms, 100ms) defined in `Rule_ID`: `Counter` increments sequentially, and after reaching the predetermined epoch length `L`, it carries over, `Epoch_ID` increments, and `Counter` is reset.

[0036] - Consistency Guarantee: Both communicating parties share the initial logical state `(Epoch_ID_0, Counter_0)` and its effective time (contained in `Init_Anchor`), and operate independently accordingly. The evolution of the state machine is completely bound to the local logical timer (with a period of `T_logical`), decoupled from the instantaneous value of the physical clock. Long-term frequency drift is addressed through periodic "silent calibration".

[0037] - `Rule_ID` characteristics: The state `S(t)` is a publicly disclosed logical value. Maximum decoupling from the physical layer is achieved through `T_logical` and `L` in `Rule_ID`, resulting in extremely high robustness. Very low energy consumption for synchronization maintenance can be achieved by configuring a larger `T_logical` or `L`.

[0038] III. Technical Effects Through the systematic design of the unified paradigm centered on the "protocol security state machine" and three configurable rules, this invention can bring the following synergistic benefits: 1. Fundamental theoretical unification and architectural innovation: For the first time, a protocol security state machine defined by `DSF = (K_sec, Init_Anchor,Rule_ID)` is proposed as the foundation for future communication, which deeply integrates security, synchronization and elasticity rules, and provides a unified theoretical model and system architecture for full-stack zero signaling collaboration.

[0039] 2. Achieving Intrinsic Security and Zero Signaling Transmission: The security key `K_sec` is deeply embedded in the state machine, and forward security is ensured through the time-varying nature of the state `S(t)`. Based on state synchronization using shared `DSF`, zero signaling generation and allocation from physical resources to higher-layer protocol parameters are achieved.

[0040] 3. Decoupling from the physical clock, resulting in a leap in robustness: Rules B and C achieve state evolution through configurable logical beats, fundamentally avoiding the mismatch risk of using imperfect physical instantaneous clock values ​​as collaborative inputs, making the system extremely resistant to out-of-sync issues.

[0041] 4. Provides ultimate performance flexibility and energy efficiency optimization: The configurability of the update tick (T_update / T_logical) in `Rule_ID` enables the same framework to support synchronous and secure update requirements from microseconds to seconds, seamlessly covering all business scenarios from URLLC to mMTC, and achieving global optimization of performance and energy efficiency.

[0042] 5. Supporting Smooth Network Evolution: Rule A is easily and quickly deployed on existing networks to enhance critical short processes; Rules B and C can be introduced as advanced features for the future. This design, based on a unified `DSF` framework and using `Rule_ID` configuration for functional differentiation, ensures backward compatibility and smooth evolution capabilities. Attached Figure Description

[0044] To more intuitively illustrate the technical solution of the present invention, the accompanying drawings used in the description of the embodiments will be briefly described below. It should be understood that the following drawings only show some embodiments of the present invention and therefore should not be regarded as a limitation on the scope of protection.

[0045] Figure 1 This is a schematic diagram of the core paradigm of this invention—a unified parameter generation model based on Dynamic Security Foundation (DSF).

[0046] Figure 2 This is a comparative diagram of the three state transition rules (Rule_A, Rule_B, Rule_C) of this invention.

[0047] Figure 3This is a timing diagram of an example of a scheduling-free random access process based on rule A (broadcast clock driven).

[0048] Figure 4 This is a schematic diagram of the hash chain evolution and silent calibration process in the state machine based on rule B (hash chain driven).

[0049] Figure 5 This is a schematic diagram of the logical state evolution process in a state machine based on rule C (logical epoch driven).

[0050] Figure 6 This is a schematic diagram of the initialization and transfer process of the Dynamic Security Foundation (DSF).

[0051] Figure 7 This is a flowchart of the frame structure and transmission / reception processing of the DSF-based safety pilot bearer.

[0052] Figure 8 This is a signaling flowchart of the zero-signaling handover process based on rule A and / or rule B / C.

[0053] Figure 9 This is a flowchart of a method for achieving high-precision positioning based on safety pilot signals.

[0054] Figure 10 This is a flowchart of the decision-making and execution process for the hierarchical recovery mechanism (L1 / L2 recovery) after synchronization failure.

[0055] Figure 11 This is a schematic diagram of a wireless communication system architecture for implementing the method of the present invention.

[0056] Figure 12 This is a functional block diagram of a network device (such as a base station) that implements the method of the present invention.

[0057] Figure 13 This is a functional block diagram of a user equipment that implements the method of the present invention. Detailed Implementation

[0059] To make the objectives, technical solutions, and advantages of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations. Therefore, the following detailed description of the embodiments of the present invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without inventive effort are within the scope of protection of the present invention.

[0060] General Implementation of Core Paradigm The implementation of the core paradigm described in this invention is premised on the successful establishment and synchronization of a dynamic security foundation (DSF) between the two communicating parties (e.g., user equipment (UE) and network device (gNB), that is, the two parties share the same `(K_sec, Init_Anchor, Rule_ID)`.

[0061] The establishment of DSF is usually completed during the access procedure. For example, after the scheduling-free access based on rule A (Example 1 described below) is completed, the network can encrypt and send the `Init_Anchor` and `Rule_ID` (such as rule B or C) for subsequent continuous communication to the UE in the confirmation message (such as MsgB), thereby completing the synchronization of DSF.

[0062] Based on DSF synchronization, the generation of any communication parameter requiring zero signaling coordination follows the general steps below (combined with...). Figure 1 ): Step S101: Determine the state `S(t)` of the current protocol security state machine.

[0063] Both communicating parties run their local state machines independently based on the synchronized DSF.

[0064] - If `Rule_ID` indicates Rule A: The UE listens to system information broadcast by the gNB (such as MIB, SIB1), decodes it to obtain the current `SFN` or `Slot_Index` as `S(t)`. The gNB naturally knows its own broadcast timing.

[0065] - If `Rule_ID` indicates rule B: Both parties calculate the current hash chain state `T_State[n]` as `S(t)` based on the shared chain head `Seed_0` and logical counter `n`, according to the hash function defined by `Rule_ID` and the tick `T_update`.

[0066] - If `Rule_ID` indicates rule C: Both parties calculate the current logical state `(Epoch_ID, Counter)` as `S(t)` based on the shared initial logical state `(Epoch_ID_0, Counter_0)`, according to the beat `T_logical` defined by `Rule_ID` and the epoch length `L`.

[0067] Step S102: Construct context information `Context_x`.

[0068] Based on the parameter type to be generated, the service flow to which it belongs, or the user identity, construct the `Context_x` string according to predetermined rules. For example, "PILOT_UL" represents an uplink pilot, and "HARQ_LCID1" represents the HARQ process of logical channel 1.

[0069] Step S103: Calculate the communication parameter `Param_x`.

[0070] Perform the calculation: `Param_x = F( K_sec, S(t), Context_x )`.

[0071] Here, the function `F` is a cryptographic deterministic function known to both parties, such as HMAC-SHA256 or CMAC based on AES.

[0072] The sender and receiver independently execute steps S101-S103. Since their `K_sec`, `Rule_ID`, and `Init_Anchor` are identical, the calculated `S(t)` will necessarily be identical, and consequently, the calculated `Param_x` will also necessarily be identical. The receiver uses this `Param_x` for signal demodulation, decoding, or protocol processing, thereby achieving zero-signaling coordination.

[0074] Example 1: Scheduling-free random access based on rule A (combined with...) Figure 3 ) This embodiment demonstrates how to apply rule A to establish a connection and initially synchronize the security context in an initial access scenario, laying the foundation for the possible subsequent activation of rules B / C.

[0075] System pre-configuration: 1. gNB broadcasts its digital signature public key `PK_gNB` via the Master Message Block (MIB).

[0076] 2. In the System Information Block (SIB), the gNB broadcasts an access commitment. This commitment includes: a future target frame number `Target_SFN`, a random number `Nonce`, and a signature `Sig` of `M_commit = (Target_SFN ||Nonce || “GFRA”)` using the gNB's private key.

[0077] Detailed process: Step S201: Terminal verification and resource calculation.

[0078] UEs with access requirements listen for and decode the SIB.

[0079] 1. The UE uses `PK_gNB` to verify the signature `Sig`, confirming the validity of the network commitment.

[0080] 2. The UE generates a local random number `R_UE` and calculates the contention flag `C = R_UE mod M` (where M is the contention space size).

[0081] 3. (Application Rule A) The UE waits until the system frame number determined by its local physical layer synchronization is equal to `Target_SFN`. At this point, the UE determines the synchronization state `S(t) = Target_SFN`.

[0082] 4. UE-dedicated uplink resources: - Calculate the common root: `Root = H(Sig || Target_SFN || PCI)`.

[0083] - Calculate the UE-specific resource index: `Resource_Index = H(Root || C || UE_ID)`. Map this index to a specific preamble sequence and physical resource block (PRB).

[0084] The above resource calculation process is a specific implementation of the unified paradigm `Param_x = F(K_sec, S(t),Context_x)` established in this invention under rule A. Wherein: > - `K_sec` can be viewed as a temporary secure trust foundation consisting of the network public key `PK_gNB` and the commitment signature `Sig` during this initial access phase.

[0085] > - The synchronization state `S(t)` is the target frame number `Target_SFN`.

[0086] > - Context information `Context_x` contains the physical cell identifier `PCI`, contention identifier `C`, and user identifier `UE_ID`, used to distinguish between cells, contention instances, and users.

[0087] > - The specific implementation of function `F` is reflected in two-level hash calculations `H(Sig || Target_SFN || PCI)` and `H( Root || C || UE_ID)`, and the subsequent resource mapping rules.

[0088] As can be seen from the above mapping, the terminal and the network independently calculate a completely consistent dedicated resource (Param_x) based on a consistent understanding of `Target_SFN` (`S(t)`) and a shared context, without any dynamic signaling indicating the location of the resource.

[0089] Step S202: MsgA transmission and detection.

[0090] On the resources calculated within the `Target_SFN` frame, the UE transmits MsgA containing the preamble. In the `Target_SFN` frame, the gNB calculates the `Root` using the same `Sig`, `Target_SFN`, and `PCI`, and performs blind detection within the corresponding resource window. The gNB can identify the transmitting UE by matching the `C` value.

[0091] Step S203: Access complete and initial synchronization with DSF.

[0092] The gNB responds to the UE in the MsgB, assigning a temporary identifier. Crucially, the MsgB can carry DSF initialization information for subsequent continuous communication: an encrypted Init_Anchor (such as a hash chain seed or logical state) and a specified Rule_ID (such as "Rule_B"). At this point, both parties have not only completed the access process but also synchronized the complete DSF for the next stage of communication.

[0094] Example 2: Hash Chain State Machine Operation and Silent Calibration Based on Rule B (Combined with Rule B) Figure 4 ) This embodiment details the operation of the state machine, parameter generation, and the silent calibration mechanism for maintaining synchronization when using rule B for continuous communication.

[0095] 1. DSF Initialization: Assume that after the access is completed, both parties synchronize the following DSF via a secure channel: - `K_sec`: Session root key.

[0096] - `Init_Anchor = (Seed_0, T_activate)`: `Seed_0` is the initial chain head, and `T_activate` is the absolute system time point for activating the chain (e.g., `(SFN_a, Slot_a)`).

[0097] - `Rule_ID = (Type="Rule_B", H=SHA-256, T_update=0.5ms)`.

[0098] 2. State machine operation and parameter generation: 1. At time `T_activate`, both parties set their local logic counter `n` to 0, and the state `S(0) = T_State[0] = Seed_0`.

[0099] 2. After that, every time `T_update=0.5ms` (which is a logical tick maintained by a local high-precision timer, rather than strictly dependent on physical time slot boundaries), `n = n + 1`, and calculate the new state: `S(t) = T_State[n] =SHA-256(K_sec || T_State[n-1] || “CHAIN”)`.

[0100] 3. When an uplink security pilot sequence needs to be generated, the UE executes: `P_UL = PRG( K_sec, S(t), “UL_PILOT”)`. The gNB synchronously performs the same calculation for receiving and demodulating.

[0101] 3. Silent calibration mechanism: To counteract the gradual misalignment of `n` caused by slight frequency offsets in the local timers of both sides, silent calibration is introduced: 1. Network-side broadcast synchronization auxiliary information: The gNB periodically (e.g., every 100ms) broadcasts a synchronization beacon in the system information, which includes: - The current absolute physical timeslot of the gNB, `(SFN_net, Slot_net)`.

[0102] - A short verification token `Token = Truncate( SHA-256( T_State[n_net] || "SYNC") ), 16 bits`, where `n_net` is the logical counter value of gNB at this moment.

[0103] 2. Terminal-side calibration: After the UE receives this beacon: a. Estimate the corresponding physical time (SFN_est, Slot_est) based on the local `n_local` and `T_update`.

[0104] b. Calculate the deviation `Δ` from the broadcast value. Within a preset tolerance window (e.g., ±4 `T_update`), generate a set of candidate values ​​`n_candidate = n_local + Δ + k`.

[0105] c. For each candidate `n_candidate`, calculate the expected `Token_candidate` using the local `K_sec` and chain rules.

[0106] d. If a unique match `n_candidate` is found, the local `n_local` is silently updated to that value. This process requires no uplink signaling feedback.

[0107] e. False Alterance Mechanism: To prevent miscalibration due to channel errors or accidental factors, a matching threshold can be set. For example, the final `n_local` update can only be performed after two or more consecutive successful matches of periodic synchronization beacons. Furthermore, the length of the `Token` (e.g., 16 bits) provides sufficient distinguishability, making the probability of two different `n_candidates` producing the same `Token` within the fault tolerance window extremely low.

[0109] Example 3: Logical State Machine Execution and Business Flow Derivation Based on Rule C (Combined with...) Figure 5 ) This embodiment demonstrates how rule C provides robust, low-power synchronization for services such as mMTC and supports multi-service stream derivation.

[0110] 1. DSF Initialization: The DSF for synchronizing a certain mMTC device is as follows: - `K_sec`: Device-specific root key.

[0111] - `Init_Anchor = (Epoch_ID_0=0, Counter_0=0, T_start)`: `T_start` is a future superframe number.

[0112] - `Rule_ID = (Type="Rule_C", T_logical=10ms, L=1024)`. This means the logical epoch length is 10.24 seconds.

[0113] 2. State machine operation: At time `T_start`, both state machines are started, `S(t) = (Epoch_ID=0, Counter=0)`.

[0114] Every 10ms (`T_logical`), `Counter` is incremented by 1. When `Counter` reaches 1023, `Epoch_ID` is incremented by 1 in the next tick, and `Counter` is reset to 0.

[0115] At each logical tick, the device can generate a key based on the current `S(t)`: `Data_Key = KDF( K_sec,Epoch_ID || Counter, “DATA”)`, which is used to encrypt the sensor data uploaded during the current cycle.

[0116] 3. Business Process Derivatives: The same device may have multiple service flows with different QoS. The network can configure a pair of derived parameters `(G, O)` for each service flow through higher-layer signaling.

[0117] - Derivation factor `G`: For example, for a low-priority monitoring stream, setting `G=10` means that its security context is updated every 10 logical ticks (100ms).

[0118] - Dedicated offset `O`: A secret value used for cryptographic isolation.

[0119] The derived state used by this business flow is: `S_derived(t) = (Epoch_ID, floor(Counter / G))`.

[0120] Its derived computational basis is: `D_derived = KDF( K_sec, S_derived(t) || O, “DERIVED”)`.

[0121] Furthermore, the pilot signals, resources, and other parameters of this service flow are generated using `D_derived`. In this way, service branches with different update frequencies and cryptographic isolation are derived from a unified DSF.

[0122] The business flow derivation mechanism based on the derivation factor `G` and the dedicated offset `O` also applies to rule B. For rule B, the derived state can be defined as `S_derived(t) = T_State[ floor(n / G) ]`, and the derivation computation basis is `D_derived = H( K_sec || S_derived(t) || O || “DERIVE” )`. This further demonstrates the extended flexibility based on the DSF framework.

[0124] Example 4: DSF-based safety pilot bearer system (combined with) Figure 7 ) This embodiment is the core application of rule B or C in the user plane data transmission layer, realizing zero signaling and ultra-low latency transmission of user plane data.

[0125] 1. Safety-duplex pilot signal generation: Based on the current DSF state `S(t)` (the chain state of rule B or the logical state of rule C), the communicating parties generate a base sequence: `P_base = PRG( K_sec, S(t), “BASE_PILOT” )`.

[0126] definition: - Uplink pilot: `P_UL = P_base` - Downlink pilot: `P_DL = conj(P_base)` The receiver can determine the demodulation sequence based solely on its own role.

[0127] 2. Safety pilot frame structure and processing: The security pilot frame fuses the pilot and data at the baseband symbol level.

[0128] - Frame header: Consists of a short sequence of `P_base`, used for timing synchronization and coarse channel estimation.

[0129] - Encrypted Data Area: After encryption and encoding, the upper-layer data is directly modulated using `P_UL` or `P_DL`. Encryption can be achieved using a stream cipher generated based on `K_sec` and `S(t)`.

[0130] - MAC tag: Calculates the message authentication code for the entire frame, providing integrity protection.

[0131] - Empty frame indication: When there is no data, an "empty frame" filled with a pseudo-random sequence is sent. The receiver still performs decryption and verification to maintain state synchronization, but discards the data.

[0132] 3. Zero-signaling transmission and reception process: - Sender: Generates pilot sequence and constructs safe pilot frame based on the current `S(t)`. The precise time-frequency resources for transmission are also determined by `Resource = Map( K_sec, S(t), “DATA_RESOURCE” )`.

[0133] - Receiver: At the expected resource location, joint channel estimation and data demodulation are performed using paired pilot sequences (or `P_DL` if it is the receiver), the modulated symbol stream is recovered in one step, and then the MAC is decrypted and verified to obtain the service data. No scheduling signaling is required throughout the entire process.

[0135] Example 5: Zero Signaling Handover (combined with...) Figure 8 ) This embodiment demonstrates how to achieve seamless handover using DSF in a mobility scenario.

[0136] 1. Switchover Preparation: - The source gNB (gNB_S) determines the UE to hand over to the target gNB (gNB_T).

[0137] - gNB_S securely passes the UE's current DSF context (`K_sec`, current `Init_Anchor` or state snapshot, `Rule_ID`) to gNB_T via the core network interface.

[0138] - gNB_T confirms and generates a dedicated synchronization anchor `HO_Anchor` (e.g., a future absolute time point) and replies via the core network.

[0139] 2. Switch execution: - gNB_S sends a handover command to the UE, which includes `HO_Anchor`, the target cell ID, and optional temporary key derivation information.

[0140] - After the UE synchronizes with the downlink signal of the target cell, it waits until the time indicated by `HO_Anchor`.

[0141] - (Applying rule A or B / C) At this moment, the UE calculates its own uplink resource / pilot sequence based on its maintained DSF (or the temporary DSF updated according to the command) and sends a handover confirmation message.

[0142] - gNB_T performs blind detection on the expected resources and receives confirmation. Since gNB_T possesses the UE's DSF context, its calculations are completely consistent with the UE's.

[0144] Example 6: High-precision positioning based on safety pilots (combined with...) Figure 9 ) This embodiment demonstrates "integrated communication and sensing", which uses multiplexing service signals to achieve positioning.

[0145] 1. Single base station ranging: - The UE normally transmits uplink security pilot frames (based on DSF).

[0146] - The serving gNB receives the frame. Crucially, because the gNB shares the DSF with the UE, the gNB can accurately know the expected transmission time of the pilot frame (determined by the protocol state machine logic, not the physical clock).

[0147] - The gNB measures the actual arrival time of the signal, calculates the propagation delay `τ`, and thus obtains the distance.

[0148] - Positioning can be achieved by combining beam direction.

[0149] 2. Multi-base station (TRP) cooperative positioning: - The uplink pilot frame sent by the UE is received by the serving gNB and multiple cooperating gNBs.

[0150] - Each gNB independently measures arrival time `τ_i`.

[0151] - The collaborative gNB reports the encrypted `τ_i` and its own location to the location server.

[0152] - The location server uses the Time Difference of Arrival (TDOA) algorithm to calculate the UE's precise location.

[0153] The positioning results can be used to generate high-precision timing advance (TA) and distributed to the UE via downlink security pilot frames (control frames).

[0155] Example 7: Tiered Fast Synchronization Recovery Mechanism (combined with) Figure 10 ) This embodiment provides the ability to restore endogenous fertility after DSF loss of synchronization.

[0156] 1. Loss of synchronization detection: - Multiple consecutive (e.g., N=5) DSF-based transmission failures (e.g., security pilot frame decryption failure).

[0157] 2. Level 1 recovery (active resynchronization): - Applicable to rule B where the hash chain state is severely misaligned.

[0158] - The UE sends a recovery request on a predefined recovery channel (whose position is calculated by the long-term `K_sec` and the fixed `Recovery_Context`, regardless of the out-of-synchronization state), along with a hash commitment of the local chain state.

[0159] - gNB responds to the new `Init_Anchor_new` (new chainhead and new anchor slot).

[0160] - Reset the UE state machine to complete a fast recovery.

[0161] 3. Level 2 recovery (silent calibration): - Applicable to logical state drift in rule C or predictable deviation in rule B.

[0162] - The UE listens for synchronization beacons (logical synchronization beacons or hash chain synchronization auxiliary information) periodically broadcast by the network.

[0163] - Within the estimated time window, try decoding the beacon using different local state candidate values.

[0164] - After a successful match, the local state is silently adjusted without uplink signaling.

[0165] 4. Fallback mechanism: If all of the above fail, traditional contention-based random access (RACH) is triggered.

[0166] Example 8: Zero-signaling allocation method for communication parameters 8.1 Core Principles Based on the synchronized Dynamic Security Foundation (DSF), both communicating parties can independently generate any high-level protocol parameters that require collaborative use through the following unified model: `Param_X = F( K_sec, S(t), Context_X ) mod N_X` in: - `F`: Predefined cryptographic deterministic function (such as HMAC-SHA256).

[0167] - `S(t)`: The current state of the protocol security state machine, determined by `Rule_ID` (A / B / C).

[0168] - `Context_X`: Parameter context, a string used to uniquely identify the parameter type and associated entity (e.g., "HARQ"||Logical Channel ID||Transport Block Index).

[0169] - `mod N_X`: Maps the function output to the valid range of values ​​`[0, N_X-1]` for the parameter `Param_X`.

[0170] Key innovation: The design of `Context_X` achieves cryptographic isolation, ensuring that even if different users, different business flows, and different types of parameters are calculated simultaneously based on the same `S(t)`, the results will be different and unpredictable. The dynamic nature of the parameters stems from the time-varying nature of `S(t)`, and the security is rooted in the confidentiality of `K_sec`.

[0171] 8.2 Example of Key Communication Parameter Allocation 1) Dynamic allocation of HARQ process IDs - Existing problem: Indicating via DCI signaling is costly and has a fixed pattern.

[0172] - Method of the present invention: `HARQ_ID = HMAC-SHA256( K_sec, S(t) || “HARQ_PROC” || LCID || TB_Index )[0:3] mod 16` - `LCID`: Logical Channel ID, used to distinguish service flows.

[0173] - `TB_Index`: Transport block index, determined by the MAC layer scheduler.

[0174] - Workflow: The sender calculates and binds the `HARQ_ID` during packet assembly; the receiver independently calculates the `HARQ_ID` based on the same input at the expected reception time, which is used to identify the soft buffer. No signaling interaction is required throughout the process.

[0175] 2) Dynamic switching of received beam identifier - Existing problems: Beam management signaling is complex, and fixed beams are susceptible to interference.

[0176] - Method of the present invention: `Beam_ID = HMAC-SHA256( K_sec, S(t) || “BEAM_ID” || PCI )[0:5] mod64` - `PCI`: Physical Cell Identifier.

[0177] - Workflow: gNB and UE independently calculate the transmit / receive beam identifier to be used in each time slot (or the clock defined by `Rule_ID`), so as to realize the secure and dynamic switching of the beam and enhance the anti-interference capability.

[0178] 3) Slot Format Indicator (SFI) - Existing issue: The configuration is inflexible via the DCI format 2_0 directive.

[0179] - Method of the present invention: `SFI = HMAC-SHA256( K_sec, S(t) || “SLOT_FORMAT” || Duplex_Mode )[0:5] mod 56` - Workflow: In a TDD system, the uplink and downlink symbol allocation for a time slot is determined by both communicating parties before the time slot begins, without the need for SFI signaling.

[0180] 4) Fine-tuning of transmit power control - Existing issue: TPC command stepping is fixed, and power mode may be analyzed.

[0181] - Method of the present invention: `Δ_TPC = (HMAC-SHA256( K_sec, S(t) || “POWER_CTRL” )[0:4] mod (2*Δ_max+1)) - Δ_max` - Workflow: Based on the base power determined by open-loop power control, a time-slot-level pseudo-random fine-tuning quantity generated by DSF is superimposed to make the transmit power exhibit noise characteristics and resist fingerprint analysis.

[0182] 5) Antenna port mapping to DMRS - Existing issue: Port mapping to DMRS sequence is relatively fixed.

[0183] - Method of the present invention: `Port_ID = HMAC-SHA256( K_sec, S(t) || “ANT_PORT” || LCID || Layer_ID )[0:2] mod 8` - Workflow: Dynamically allocate antenna ports and corresponding DMRS resources for each layer of MIMO to improve the confidentiality of air interface transmission.

[0184] 8.3 Parameter Consistency Verification and Conflict Resolution - Implicit verification: The correctness of most parameters (such as HARQ_ID, Beam_ID) will be naturally verified during communication through demodulation performance, ACK feedback, etc.

[0185] - Explicit verification (optional): A short verification code can be periodically calculated and exchanged based on DSF.

[0186] - Conflict resolution: For competition-based parameters (such as initial access resources), traditional conflict detection and retransmission mechanisms are relied upon. Deterministic computation based on DSF itself has greatly reduced the probability of conflicts.

[0187] Example 9: Comprehensive Application Example: Autonomous Mobile Robots in Intelligent Manufacturing (This example aims to integrate and display rules A, B, C, and all core applications.) Scene Overview: In smart manufacturing workshops, autonomous mobile robots (AMRs) require: 1) millisecond-level access and recovery; 2) sub-millisecond-level motion control command transmission (URLLC); 3) periodic status reporting (mMTC); 4) centimeter-level real-time positioning; and 5) seamless switching during movement.

[0188] Closed-loop technology process: 1. Initial Access and DSF Establishment (Application Rule A) - Power on the AMR and listen for access commitments broadcast by the gNB (`Target_SFN`, `Sig`).

[0189] - After verifying `Sig`, at the `Target_SFN` time, calculate the dedicated resource based on rule A and send MsgA to complete the scheduling-free access.

[0190] - In MsgB, gNB issues a DSF for continuous communication: `(K_sec, Init_Anchor_B, Rule_ID="Rule_B")`, configuring `T_update=0.125ms` for the control flow; at the same time, it configures another DSF (or derived configuration) for the status reporting flow: `(K_sec, Init_Anchor_C, Rule_ID="Rule_C")`, where `T_logical=100ms`.

[0191] 2. Ultra-low latency control transmission (Application Rule B & Security Pilot Bearer) - Emergency commands from the central controller are transmitted using secure pilot frames via traffic flows configured with `Rule_B`.

[0192] - AMR and gNB are based on the frequently updated hash chain state `S(t)`, and synchronously update the pilot sequence and resources every 0.125ms to achieve sub-millisecond end-to-end transmission of instructions.

[0193] 3. High energy efficiency status reporting (Application rule C & business flow derivation) - AMR sensor data is reported via a service flow configured with `Rule_C`.

[0194] - The security context is updated using a slow tick of `T_logical=100ms`, and the key update frequency can be further reduced to 1 second by the derivation factor `G=10`, which greatly saves power consumption.

[0195] 4. High-precision positioning (multiplexing safety pilot signals) - Uplink pilot frames (based on `Rule_B`) sent by the AMR are received by multiple Location Receivers (TRPs).

[0196] - Each TRP determines the expected signal transmission time based on the shared DSF (synchronized during handover preparation), performs TOA / TDOA measurements, achieves centimeter-level positioning, and generates precise synchronization TA commands.

[0197] 5. Zero signaling handover (DSF context pass) When the AMR moves, the source gNB transmits the AMR's current DSF context to the target gNB via the core network.

[0198] - During handover, the AMR and the target gNB independently generate consistent resources and sequences based on the transmitted DSF, achieving seamless, zero-signaling handover. During the handover process, parameters such as the HARQ process and beam are generated with zero signaling using the method in Example 8.

[0199] 6. Rapid hibernation-wake recovery (tiered recovery mechanism) - After AMR wakes up from hibernation, it detects that the `Rule_B` state machine has lost its synchronization.

[0200] - Because its control flow is a critical service, it triggers L1 fast recovery: it requests and obtains a new `Init_Anchor` on a dedicated recovery channel determined by `K_sec`, and re-establishes synchronization within milliseconds.

[0201] Summary of the effects of the examples: This embodiment demonstrates that, through the unified Dynamic Security Foundation (DSF) framework and its three configurable rules (A / B / C) of this invention, diverse service requirements of ultra-low latency (Rule B), ultra-high energy efficiency (Rule C), and high robustness and short process (Rule A) can be simultaneously supported on a single device. Combined with secure pilots, zero signaling parameter allocation, high-precision positioning, and rapid recovery, a complete, efficient, secure, and flexibly configurable communication solution is formed, perfectly adaptable to complex future application scenarios.

[0203] System and Device Examples Example 10: Wireless Communication System (Combined with...) Figure 11 ) A wireless communication system includes at least one network device, at least one user equipment, and core network control plane functions. The system is characterized in that its entire lifecycle operation, from access, transmission, migration, and positioning, is driven by the Dynamic Security Foundation (DSF) framework and its three state transition rules.

[0204] The system's operating modes include: 1. Initialization and Access Phase: User equipment can execute the scheduling-free secure access process based on rule A to establish a connection with the network and synchronize the initial DSF.

[0205] 2. Connected-state communication phase: User equipment and network enable zero-signaling data transmission using secure pilot bearers based on synchronized DSF (rule B or C), and dynamically generate various higher-layer communication parameters.

[0206] 3. Mobility and handover phase: Zero signaling handover is achieved by transmitting DSF context or application rule A through the core network.

[0207] 4. Value-added service stage: reuse safety pilot signals and perform high-precision positioning functions as needed.

[0208] 5. Fault Tolerance Management Phase: The system monitors the DSF synchronization status and automatically triggers a tiered, rapid synchronization recovery process.

[0210] Example 11: Network device (combined with) Figure 12 ) A network device, such as a base station or transmit / receive point, includes a transceiver, a processor, a memory, and a core network interface. The processor executes a program to implement the following functional modules: - Dynamic Security Foundation Management Module: Responsible for generating, authorizing, storing, and updating user DSF `(K_sec,Init_Anchor, Rule_ID)`; managing business flow derived parameters `(G, O)`.

[0211] - Rule processing module: contains rule A / B / C processing units, used to perform scheduling-free access commitments and detection, maintain hash chains or logical state machines, and generate and broadcast synchronization beacons.

[0212] - Secure Pilot Communication Module: Generates secure pilot sequences based on DSF, constructs and sends downlink secure pilot frames, and receives and jointly processes uplink secure pilot frames.

[0213] - Zero signaling parameter allocation module: Calculates and applies parameters such as HARQ process number and beam identifier in real time based on DSF.

[0214] - Positioning and Co-processing Module: Measure signal propagation delay and perform or coordinate high-precision positioning.

[0215] - Fast Synchronization Recovery Control Module: Handles L1 recovery requests, broadcasts L2 synchronization beacons, and manages the recovery process.

[0217] Example 12: User Equipment (in combination) Figure 13 ) A user equipment includes a transceiver, a processor, a memory, and a user identity module interface. The processor executes a program to implement the following functional modules: - Dynamic Security Foundation Synchronization Module: Calculates and maintains the local DSF based on network authorization; manages business flow derivation.

[0218] - Rule processing module: contains rule A / B / C processing units, used to verify network commitments, maintain the local state machine, and perform silent calibration.

[0219] - Security Pilot Communication Module: Generates security pilot sequences, constructs and sends uplink security pilot frames, and receives and processes downlink security pilot frames.

[0220] - Zero Signaling Parameter Generation Module: Based on the local DSF, it independently generates communication parameters consistent with the network.

[0221] - Positioning signal processing module: sends pilot signals for positioning, receives and applies precise TA commands.

[0222] - Autonomous Synchronization Recovery Module: Detects out-of-synchronization and initiates an L1 recovery request or performs L2 silent calibration.

[0223] It should be noted that the above division of functional modules is logical. In actual implementation, the functions of some or all modules can be completed by the same physical entity or software process by executing the corresponding computer program instructions.

[0225] Summary of beneficial effects Compared with existing technologies, the wireless communication parameter generation method, system, and apparatus based on dynamic security foundation provided by this invention can bring the following significant and synergistic beneficial effects: 1. Fundamental theoretical unification and architectural innovation: For the first time, a protocol security state machine paradigm with `DSF = (K_sec, Init_Anchor, Rule_ID)` as its core was proposed and systematized, laying a unified theoretical foundation and an achievable system architecture for a full-stack, zero-signaling, intrinsically secure future communication system.

[0226] 2. Achieving Intrinsic Security and Zero Signaling Transmission: Security is deeply embedded in the state machine, and forward security is guaranteed through time-varying states. Based on deterministic computation using shared DSF, dynamic signaling overhead from physical resources to higher-layer protocol parameters is completely eliminated, resulting in a significant improvement in air interface efficiency.

[0227] 3. Decoupling of synchronization from physical clock, resulting in a leap in robustness: Through the configurable logical beats in the hash chain driving rules or logical epoch driving rules, the protocol synchronization layer is made independent of the imperfect physical clock, fundamentally solving the problem of loss of synchronization caused by clock deviation and drift in traditional solutions, achieving a fundamental breakthrough in system robustness.

[0228] 4. Provides ultimate performance flexibility and energy efficiency optimization capabilities: The configurability of the update tick in the state transition rule identifier enables the same framework to seamlessly support synchronous and secure update requirements from microsecond level (meeting URLLC) to second level (adapting to mMTC), achieving global optimization and on-demand allocation of performance and energy consumption.

[0229] 5. Highly efficient realization of integrated communication and sensing: High-precision positioning is achieved by reusing DSF-based safety pilot signals without occupying additional spectrum or dedicated signals, realizing resource symbiosis and efficiency multiplication of communication and sensing.

[0230] 6. Excellent system self-healing and evolution capabilities: The inherent hierarchical synchronous recovery mechanism ensures high reliability; based on the unified DSF framework and through the design of function differentiation through `Rule_ID` configuration, the network can smoothly evolve from enhancing existing processes (Rule A) to full-stack zero signaling (Rule B / C), with a clear technical path.

[0231] The above description is merely a preferred embodiment of the present invention and is not intended to limit the scope of protection of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for generating wireless communication parameters based on a protocol-secure state machine, characterized in that, include: The two communicating parties synchronize a dynamic security foundation DSF, which is uniquely determined by a triple `(K_sec, Init_Anchor, Rule_ID)`; where `K_sec` is the security key shared by both parties, `Init_Anchor` is the initial anchor information of the state machine, and `Rule_ID` is the set of parameters that identify the state transition rule; Based on the `Rule_ID`, both communicating parties independently run their local protocol security state machines to obtain a consistent time-varying state `S(t)` that is decoupled from the physical layer timing. Based on the security key `K_sec` and the consistent time-varying state `S(t)`, the two communicating parties independently generate at least one identical communication parameter `Param_x` using the same cryptographic deterministic function `F` and in conjunction with the parameter context information `Context_x`, where `Param_x = F( K_sec, S(t), Context_x )`.

2. The method according to claim 1, characterized in that, The `Rule_ID` includes at least a state transition rule type and an update tick parameter. The update tick parameter defines the time granularity of the evolution of the time-varying state `S(t)`, and the time granularity is a configurable logical time unit.

3. The method according to claim 2, characterized in that, The state transition rule type is a broadcast clock driven rule; The time-varying state `S(t)` is system timing information obtained from network broadcast information, or a long-period logical timing reference `T_Base` constructed from the system timing information.

4. The method according to claim 3, characterized in that, The long-cycle logical timing base `T_Base` is generated by a linear combination of the system-broadcast superframe number `Hyper_SFN`, the system frame number `SFN`, and the slot index `Slot_Index`, where A, B, and C are non-zero coefficients.

5. The method according to claim 2, characterized in that, The state transition rule type is a hash chain driven rule; The time-varying state `S(t)` is a secret hash chain state `T_State[n]`, whose evolution follows `T_State[n] = H( K_sec || T_State[n-1] || label)`, where `H` is the hash function and `n` is the logical counter; The update of the time-varying state `S(t)` is triggered by the update tick parameter `T_update`.

6. The method according to claim 5, characterized in that, It also includes a silent calibration step: The network side periodically broadcasts synchronization beacons, which contain verification tokens generated based on the current hash chain state `T_State[n_net]` on the network side; After receiving the synchronization beacon, the terminal calculates the expected token and performs matching verification using different local counter candidate values ​​within a preset time deviation window; If the matching verification is successful, the terminal silently updates its local logical counter to the matching candidate value without sending an acknowledgment signal to the network side.

7. The method according to claim 2, characterized in that, The state transition rule type is a logical epoch-driven rule; The time-varying state `S(t)` is a public logical state `(Epoch_ID, Counter)`; The evolution of the logical state `(Epoch_ID, Counter)` is triggered by the update tick parameter `T_logical`: `Counter` increments sequentially, and after reaching the predetermined epoch length `L`, it carries over, `Epoch_ID` increases, and `Counter` is reset.

8. The method according to claim 7, characterized in that, It also includes a silent calibration step: The network side periodically broadcasts synchronization beacons, which contain verification tokens generated based on the current logical state of the network side, `(Epoch_ID_net, Counter_net)`. After receiving the synchronization beacon, the terminal calculates the expected token and performs matching verification using different local logical state candidate values ​​within a preset time deviation window; If the matching verification is successful, the terminal silently updates its local logical state to the matching candidate value without sending an acknowledgment signal to the network side.

9. The method according to any one of claims 1 to 8, characterized in that, It also includes the business flow derivation steps: Configure derivation parameters for different service flows, wherein the derivation parameters include at least a derivation factor `G` and a dedicated offset `O`; Based on the dynamic security foundation DSF and the derived parameters, a derived time-varying state `S_derived(t)` and / or a derived computational basis `D_derived` are generated for each service flow; Communication parameters are generated for the service flow based on the `S_derived(t)` or `D_derived`.

10. The method according to claim 9, characterized in that, When the state transition rule type is a hash chain driven rule, the derived time-varying state `S_derived(t) = T_State[ floor(n / G) ]`; When the state transition rule type is a logical epoch-driven rule, the derived time-varying state `S_derived(t) = (Epoch_ID, floor(Counter / G))`.

11. The method according to claim 1, characterized in that, The generated communication parameter `Param_x` is equivalent to: First, a time-varying secret `D = G( K_sec, S(t) )` is derived from `K_sec` and `S(t)`, where `G` is a predefined cryptographic derivation function; Then calculate `Param_x = F'( D, Context_x )`, where `F'` is a predefined cryptographic function.

12. The method according to claim 1 or 11, characterized in that, The communication parameter `Param_x` includes at least two of the following parameters, distinguished by different context information `Context_x`: pilot sequence, physical resource block index, symbol index, hybrid automatic repeat request (HARQ) process identifier, receive beam identifier, slot format indicator (SFI), transmit power control (TPC) adjustment amount, and antenna port number.

13. A secure pilot communication method, characterized in that, include: The method according to any one of claims 1 to 12 generates communication parameters, wherein the generated communication parameters include a pair of secure full-duplex pilot sequences having a deterministic cross-relation relationship; The business data is encapsulated into a secure pilot frame, which includes at least an encrypted data area modulated and / or scrambled using the pilot sequence, and a message authentication code calculated from the frame content. Based on the time-varying state `S(t)`, the time-frequency resource location for sending the security pilot frame is determined and transmitted.

14. The method according to claim 13, characterized in that, The generation of a pair of secure full-duplex pilot sequences includes: Generate a base sequence `P_base`; Define `P_base` as the first direction pilot sequence `P_UL`, and define the complex conjugate of `P_base`, `conj(P_base)`, as the second direction pilot sequence `P_DL`.

15. The method according to claim 13 or 14, characterized in that, It also includes receiving and processing steps: At the receiving end, the received security pilot frame signal is processed using a pilot sequence paired with that of the transmitting end to synchronously complete channel estimation and data demodulation, and recover the modulation symbol stream.

16. The method according to claim 13, characterized in that: When there is no service data to send, the sender constructs and sends an empty secure pilot frame. The encrypted data area of ​​the empty secure pilot frame is filled with a pseudo-random sequence generated based on the security key `K_sec` and the time-varying state `S(t)`. The receiver performs decryption and verification operations on the empty security pilot frame to maintain cryptographic state synchronization and discards the decrypted content.

17. A scheduling-free access method, characterized in that, include: The network side broadcasts access commitment information, which includes an indication of a future target time and a network signature; The terminal verifies the network signature and, at the target time, determines the time-varying state `S(t)` as the system timing information or long-period logic timing reference corresponding to the target time. Based on the time-varying state `S(t)`, the network signature, and local information, the terminal side determines a dedicated uplink access resource through cryptographic calculation and sends an access request message on the dedicated resource. At the target time, the network side uses the same calculation method to determine the detection window and performs blind detection on the access request message to complete the access.

18. A switching method, characterized in that, include: The source network side securely transmits the current dynamic security foundation DSF context of the terminal to the target network side. The DSF context at least enables the target network side to deduce the time-varying state `S(t)` consistent with the terminal. Based on the DSF context, the terminal and the target network independently derive the consistent time-varying state `S(t)`. Based on the consistent time-varying state `S(t)`, the terminal calculates the resources or sequence for sending a handover confirmation signal to the target network side, and sends the handover confirmation signal. The target network side detects and receives the handover confirmation signal based on the consistent time-varying state `S(t)` at the expected resource location or using the expected sequence.

19. A wireless positioning method, characterized in that, include: The terminal transmits an uplink security pilot frame according to any one of claims 13 to 16; At least one network-side device receives the uplink security pilot frame; The network-side device determines the expected transmission logic time of the uplink security pilot frame based on the Dynamic Security Foundation (DSF) shared with the terminal. Based on the expected transmission logic time and the actual arrival time of the uplink security pilot frame, the propagation delay is calculated, and then the location of the terminal is determined.

20. A method for restoring a synchronization state, characterized in that, include: One of the communicating parties detects a series of communication failures based on the time-varying state `S(t)`; If the protocol security state machine is determined to be out of sync, the first level of recovery is executed: a resynchronization request is initiated on a dedicated recovery channel determined by the long-term security key to obtain a new initial anchor point `Init_Anchor_new` from the network side; Alternatively, perform a second-level recovery: silently calibrate the time-varying state `S(t)` locally by listening to the synchronization beacon periodically broadcast on the network side.

21. A communication device, characterized in that, It includes a processor and a memory, the memory storing a computer program, and the processor executing the program to implement the wireless communication parameter generation method according to any one of claims 1 to 12.

22. A network device, characterized in that, It includes a processor and a memory, the memory storing a computer program, and the processor executing the program to implement the method steps performed by the network side as described in claims 17, 18, 19, and 20.

23. A user equipment, characterized in that, It includes a processor and a memory, the memory storing a computer program, and when the processor executes the program, it is used to implement the method steps executed by the terminal side as described in claims 17, 18, 19, and 20.

24. A wireless communication system, characterized in that, This includes the network equipment as described in claim 22 and the user equipment as described in claim 23.

Images