A method and system for secure retrieval and automatic verification of derived classified attributes of generative artificial intelligence large model RAG based on dense points.
By using a dense-point-level RAG vector library and multi-dimensional access control, combined with dense-point lineage tracing and automatic verification algorithms, the problems of coarse, multi-dimensional judgment and automatic verification in RAG retrieval permission control are solved, realizing fine-grained permission control and full lifecycle security management, reducing security risks and compliance risks.
Patent Information
- Application Number
- CN202611327908.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-31
- Publication Date
- 2026-11-10
AI Technical Summary
The existing RAG search permission control is not granular enough, lacks multi-dimensional access control judgment, cannot automatically verify the confidentiality attributes of RAG generated content, lacks secret lineage tracing, and lacks a closed loop between RAG search and derived confidentiality determination, resulting in security risks and compliance risks.
By constructing a key-level RAG vector library, implementing a user permission model, multi-dimensional access control, key-based lineage tracing, and automatic verification algorithms, key-level permission control, multi-dimensional judgment, and automated closed-loop security management are achieved.
It achieves the most granular RAG retrieval permission control in the industry, automatically detects the confidentiality attributes of generated content, and establishes full lifecycle confidentiality lineage tracking to ensure the security and compliance of RAG-generated content.
Smart Images

Figure CN123069431A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the intersection of information security and artificial intelligence, and in particular to a method and system for secure retrieval and automatic verification of derived classified attributes of a generative artificial intelligence large model based on key points (RAG). Background Technology
[0002] Retrieval-enhanced generation (RAG) is a technique that enhances the output quality of large language models (LLMs) by retrieving relevant information from external knowledge bases, effectively avoiding model illusion. With the increasing popularity of RAG technology, many organizations have begun deploying organization-wide, horizontal RAG systems.
[0003] In the field of classified information management, "key information points"—the crucial content that determines whether a matter possesses the essential attribute of a state secret, and which is the smallest independent unit of information that can be clearly distinguished from unclassified content and other key information points—have been introduced as the basic unit of fine-grained access control. Existing technologies include fine-grained access control methods based on key information point annotation. These methods generate hierarchical keys to encrypt each key information point in a file by annotating its classification level, effective time domain, and effective spatial domain. Other methods can set the classification level and access permissions of a document based on the sensitivity of different content within the document, allowing users with different classification levels to have different reading permissions for different paragraphs within the same document.
[0004] In the field of RAG security, existing solutions have proposed chunk-based access control and lineage tracing methods, which maintain document access permissions and exclude document blocks that users do not have permission to access during retrieval. Other solutions propose a user role-based RAG data security management method, which queries the vector indexes that users can access based on their role permissions. Still other solutions propose a knowledge-based RAG content generation method, which achieves security control by masking unauthorized knowledge during content generation.
[0005] The existing technology still has the following shortcomings: First, the granularity of access control in RAG retrieval is not fine enough. Existing RAG security solutions mainly rely on document-level or chunk-level access control. A chunk may contain multiple information fragments from different functional areas and with different security levels, and current technologies cannot achieve differentiated access control within the same chunk. Although keypoint annotation technology has been applied in the field of file access control, it has not yet been integrated with RAG retrieval technology, and keypoints are not used as the basic unit of RAG vector retrieval.
[0006] Second, RAG retrieval lacks multi-dimensional access control judgment. Existing methods typically rely solely on document-level permissions for binary judgment (allow / deny), or on a single role-based permission dimension. They fail to treat "business function boundaries" and "security level" as independent retrieval filtering dimensions, thus failing to achieve joint judgment based on "functional atom × security level."
[0007] Third, the classified nature of RAG-generated content lacks an automatic verification mechanism. According to the "Interim Measures for the Management of Classification of Derived State Secrets," government agencies and units must legally determine, modify, and declassify state secrets generated from the execution or handling of already classified matters. If a derived matter involves a classified point of an already classified matter, it should be classified as a state secret; the classification level of the derived state secret should be consistent with the classification level of the already classified matter, and if multiple points are involved, it should be consistent with the highest classification level of the involved points. However, the existing RAG system lacks an automatic detection and judgment mechanism to determine whether new content constitutes a derived state secret after users generate new content based on retrieved classified points. It cannot automatically identify whether the new content has classified attributes due to its derivation from classified points, nor can it automatically determine its classification level, scope of access, and other classified attributes. The classification of derived content still relies on manual judgment, posing significant risks of leakage and compliance.
[0008] Fourth, the lack of chunk-level lineage tracking in RAG scenarios. While existing technologies offer chunk-level data lineage tracking, they lack a chunk-level lineage tracking mechanism. When a user generates new content based on multiple chunks, the derivation relationship between the new content and the source chunks cannot be automatically recorded, nor can the permissions of the derived content be automatically updated when the source chunks change.
[0009] Fifth, there is a lack of a closed loop between RAG retrieval and derived key assignment. In existing technologies, access control, key point annotation, and derived key assignment in RAG retrieval are independent of each other, failing to form an automated closed loop of "retrieval → generation → judgment → annotation". After users obtain key points through RAG retrieval and generate new content based on the key points, the new content cannot automatically obtain key point annotation and access control protection, posing a security risk of "loss of control upon generation".
[0010] Therefore, a method and system for RAG security retrieval and automatic verification of derived classified attributes based on key points is needed to address the aforementioned deficiencies in the existing technology. Summary of the Invention
[0011] Purpose of the invention: This invention provides a method and system for secure retrieval of RAG based on key points and automatic verification of derived classified attributes, in order to solve the technical problems in the prior art, such as coarse granularity of RAG retrieval permission control, lack of multi-dimensional judgment, inability to automatically verify the classified attributes of RAG generated content, lack of key point lineage tracing, and lack of closed loop between RAG retrieval and derived classification, so as to realize full-link security management of classified information in the RAG scenario from "retrieval → generation → judgment → annotation".
[0012] Technical Solution: To solve the above-mentioned technical problems, according to one aspect of the present invention, more specifically, a method for secure retrieval and automatic verification of derived classified attributes of a generative artificial intelligence large model based on key points (RAG), comprising the following steps: S1, Construction of Dense-Level RAG Vector Library Step 1.1: Identification and Extraction of Classified Information. For documents to be entered into the database, candidate classified information is automatically identified from the documents based on pre-trained machine learning models or large language models. These are the key contents that determine whether a matter has the essential attributes of a state secret. They are the smallest independent information units that can be clearly distinguished from non-classified content and other classified information (such as a classified word or phrase, a set of classified data, a classified chart, or a classified paragraph). Alternatively, classified information can be manually marked by the person responsible for classifying the information.
[0013] Step 1.2: Binding multi-dimensional tags for dense dots. Label each dense dot as follows: Functional atomic label F: The business functional unit to which this key point belongs (e.g., POL-HR represents human resources, CMD-OP represents operations); Classification label C: Top Secret / Confidential / Secret; Dense point type tags: coordinate type / data type / word / phrase type / chart type / paragraph type, etc.
[0014] Step 1.3: Independent Vectorization and Storage of Key Points. Each key point is independently vectorized and stored in a vector library. Each key point is treated as an independent vector entry, carrying a complete multidimensional label. Different key points in the same file are stored as independent entries in the vector library, achieving physical isolation.
[0015] Step 1.4: Encryption at the Key Level. A hierarchical key system is generated according to the security level. Each key is encrypted independently using the national standard SM4 algorithm. The key and ciphertext are stored separately.
[0016] S2, User Permission Model Construction Establish a permission model for each user, including at least: Functional Atom Set The user's job title refers to one or more functional units; Security Classification This user has been granted the highest level of security (Secret / Confidential / Top Secret).
[0017] S3, RAG secure retrieval method with three-dimensional access control When a user initiates a RAG search request, the system performs the following steps: Step 3.1: Obtain user permission information. Obtain the current user's set of functional atoms. And the security level C_user.
[0018] Step 3.2: Multidimensional Tag Pre-filtering. The system pre-filters dense points in the vector library based on user permissions: Dimension 1 (Functional Atom Matching): Only retain functional atom tags. ∈ Dense points; Dimension Two (Security Level Matching): Only retain the security level. ≤ Dense points; (Optional) Dimension 3 (Secret Point-Level Precise Authorization): Only retain secret points whose secret point IDs are in the user's authorization list.
[0019] Step 3.3: Semantic Similarity Retrieval. In the pre-filtered set of dense points, calculate the similarity between the user query vector and each dense point vector, and retrieve the Top-K dense points by sorting them by similarity.
[0020] Step 3.4: Secondary permission verification. For each recalled key point, perform three-dimensional access control verification again to ensure that the recall results are 100% compliant with user permissions.
[0021] Step 3.5: Result Synthesis and Response. The validated key points are injected as context into the large language model to generate the final response. All information in the response content originates from key points that the user has permission to access.
[0022] Judgment rule: Access = True if and only if ∈ and ≤ And (optionally) the key point ID is in the authorization list.
[0023] S4. Automatic Algorithm for Derived Confidentiality Attributes Based on Close-knit Lineage After a user generates new content T based on the RAG search results, the system automatically performs the following three-level progressive derived confidentiality attribute checks: First layer: Derivation relationship detection algorithm (dual-channel verification) Algorithm objective: Determine whether T is derived from the set of self-involved dense points M.
[0024] Algorithm input: Text T to be tested The set of secret points is M = {m1, m2, ..., m} n} semantic similarity threshold Fingerprint matching threshold Algorithm output: Whether it is derived from M (Boolean), and a list of candidate derived dense points. Algorithm steps: Channel 1 (Semantic Similarity Coarse Screening): Step 1: Calculate the semantic vector V(T) of the text T to be tested; Step 2: For each dense point mᵢ in the set of dense points M, calculate the semantic similarity sim(V(T),V(mᵢ)). The semantic similarity is calculated using cosine similarity, with the formula: sim(V(T),V(mᵢ))=(V(T)·V(mᵢ)) / (||V(T)||×||V(mᵢ)||) Step 3: If Add mᵢ to the candidate list .
[0025] Channel Two (Dense Fingerprint Matching Fine Screening): Step 4: Extract the dense point fingerprint Fingerprint(T) of the text T to be examined, specifically including: Key term set K(T): Extracted by matching domain dictionary based on the scope of confidential matters; Named entity set E(T): Names of people, place names, military unit numbers, equipment models, etc., extracted based on the named entity recognition model; Numerical data set N(T): Coordinates, quantity, time, distance, etc. extracted based on regular expressions and semantic understanding.
[0026] Step 5: [Regarding...] For each dense point mᵢ, extract its dense point fingerprint Fingerprint(mᵢ), which contains the same three dimensions: K(mᵢ), E(mᵢ), and N(mᵢ).
[0027] Step 6: [Regarding...] For each dense point mᵢ, calculate the fingerprint matching degree. :
[0028] in , where w1 is the weighting coefficient for each fingerprint dimension (typical values: w1=0.4, w2=0.3, w3=0.3).
[0029] Step 7: If Add mᵢ to the final candidate list Candidate.
[0030] Step 8: If Candidate is not empty, return "is derived" and Candidate; otherwise, return "not derived".
[0031] Second layer: Derivative source identification and attribute aggregation algorithm Algorithm objective: To identify which dense points T specifically derives from and to aggregate their attributes.
[0032] Algorithm input: Candidate list of candidate derived dense points Candidate={m1,m2,...,m k} Algorithm output: Derived source attribute aggregation result Algorithm steps: Step 1: Extract the attributes of each dot mᵢ in the Candidate: Functional Atom Tag: F(mᵢ) Security Classification: C(mᵢ) Secret point ID: ID(mᵢ) Confidentiality period: Duration(mᵢ) Scope of knowledge: (mᵢ) Step 2: Calculate the derived weight w(mᵢ) for each candidate dense point:
[0033] Step 3: Normalize the derived weights:
[0034] Make .
[0035] Step 4: Grouping and aggregating by functional atomic tags: For each functional atom Fin{all occurring functional atoms}:
[0036] Step 5: Determine the valid functional atomic tags: like ≥threshold (Typical value: 0.15), then F is the effective functional atomic label of T.
[0037] Third layer: Algorithm for synthesizing and verifying classified attributes Algorithm objective: To comprehensively determine the final confidentiality attribute of T and generate an inspection report.
[0038] Algorithm input: Derived source attribute aggregation result Algorithm output: Result of determining the confidentiality attribute of T Algorithm steps: Step 1: Determine if it involves classified information: Step 2: Determine the security classification (if classified):
[0039] That is, take the highest classification level among all derived source secrets. According to the "Interim Measures for the Classification Management of Derived State Secrets", the classification level of derived secret documents shall not be lower than the highest classification level of the secrets involved.
[0040] Step 3: Determine the confidentiality period (if classified):
[0041] That is, take the longest confidentiality period among all derived source secrets.
[0042] Step 4: Determine the scope of knowledge (if classified):
[0043] That is: take the intersection of the known ranges of all derived source secret points to ensure the minimum necessary principle. When the intersection is empty, take the union of the known ranges as a conservative solution.
[0044] Step 5: Determine the functional atomic tag (if classified):
[0045] That is, the functional atomic label of T is the set of all valid derived source dense point functional atomic labels.
[0046] Step 6: Calculate the overall confidence level:
[0047] When the candidate list contains only one dense point .
[0048] Step 7: Generate close-point lineage records: Create a key record for T, containing: Key ID: Automatically generated (format: MID-YYYYMMDD-XXX) Derivative source list: [ID(m1),ID(m2),...,ID(m k )] Derivation type: "RAG generation derivation" Criteria for classifying information as classified: document name, document number, and classification level at each source location. Creation time, creator, creation context (user query, RAG retrieval records, etc.) Step 8: Output the inspection report: { "is_classified": true / false, "security_level": "Top Secret / Confidential / Secret / Non-Secret", "function_atoms": [F1, F2, ...], "scope": [List of users / roles], "duration": "YYYY-MM-DD", "derived_from": [ID1, ID2, ...], "confidence": 0.xx, "lineage": { "derived_from": [ID1, ID2, ...], "derivation_type": "RAG_generation", "creation_context": {...} } } Complete pseudocode of the algorithm class DerivedClassificationAlgorithm: "An Automatic Algorithm for Detecting Classified Attributes of RAG Derived from Close-Point Lineage" def __init__(self, secret_rag_db, sim_threshold=0.75, fp_threshold=0.6): self.db = secret_rag_db # Confidential RAG database (set of secret points) self.sim_threshold = sim_threshold # Semantic similarity threshold self.fp_threshold = fp_threshold # Fingerprint matching threshold self.weights = {'term': 0.4, 'entity': 0.3, 'number': 0.3} self.atom_threshold = 0.15 # Effective threshold for functional atoms def detect_derivation(self, text_T): """ First layer: Derivation relationship detection Returns: (is_derived, candidate_list) """ # 1. Calculate semantic vectors vec_T = self.embed(text_T) # 2. Semantic Similarity Coarse Screening candidates_sim = [] for midian in self.db.get_all(): sim = self.cosine_similarity(vec_T, midian.vector) if sim >= self.sim_threshold: candidates_sim.append((midian, sim)) #3. Fine fingerprint screening fp_T = self.extract_fingerprint(text_T) candidates = [] for midian, sim in candidates_sim: fp_m = self.extract_fingerprint(midian.content) fp_match = self.compute_fp_match(fp_m, fp_T,self.weights) if fp_match >= self.fp_threshold: candidates.append({ 'midian': midian, 'sim': sim, 'fp_match': fp_match, 'weight': self.normalize(sim * fp_match) }) return (len(candidates) > 0, candidates) def extract_fingerprint(self, text): """ Extracting the key fingerprint of the text Return: { 'terms': set, 'entities': set, 'numbers': set} """ return { 'terms': self.extract_key_terms(text), # Key terms 'entities': self.extract_named_entities(text), # Named entities 'numbers': self.extract_numeric_data(text) # Numeric data } def compute_fp_match(self, fp1, fp2, weights): """Calculate fingerprint matching score""" term_match = len(fp1['terms'] & fp2['terms']) / max(len(fp2['terms']), 1) entity_match = len(fp1['entities'] & fp2['entities']) / max(len(fp2['entities']), 1) number_match = len(fp1['numbers'] & fp2['numbers']) / max(len(fp2['numbers']), 1) return (weights['term'] * term_match + weights['entity'] * entity_match + weights['number'] * number_match) def classify_derived(self, text_T): """ Second Layer + Third Layer: Derivative Source Aggregation and Confidential Attribute Synthesis Returns: ClassificationResult """ is_derived, candidates = self.detect_derivation(text_T) if not is_derived: return ClassificationResult( is_classified=False, security_level='non-secret', confidence=1.0 ) # 1. Aggregate weights by functional atom grouping atom_weights = {} For candidate c: atom = c['midian'].function_atom atom_weights[atom] = atom_weights.get(atom, 0) + c['weight'] # Effective functional atoms: Weights exceed threshold effective_atoms = [a for a, w in atom_weights.items() if w >=self.atom_threshold] # 2. Security Level Synthesis (Highest Level Required) max_level = max(c['midian'].security_level for c incandidates) # 3. Combining known ranges (taking the intersection) scopes = [set(c['midian'].scope) for c in candidates] common_scope = set.intersection(*scopes) if scopes else set() # 4. Confidentiality period (longest one) max_duration = max(c['midian'].duration for c in candidates) # 5. Calculate the overall confidence level confidence = 1 - np.prod([1 - c['weight'] for c incandidates]) # 6. Generate bloodline records lineage = { 'derived_from': [c['midian'].id for c in candidates], 'derivation_type': 'RAG_generation', 'creation_context': self.get_current_context() } return ClassificationResult( is_classified=True, security_level=max_level, function_atoms=effective_atoms, scope=list(common_scope), duration=max_duration, derived_from=[c['midian'].id for c in candidates], confidence = confidence lineage=lineage ) S5, Secret Point Bloodline Tracking and Linked Update Mechanism Step 5.1: Lineage Graph Construction. The system constructs a global dense node lineage graph, where each dense node records all its derived source dense nodes, forming a directed acyclic graph structure.
[0049] Step 5.2: Source Security Point Change Linkage. When the security level of a source security point changes or it is decrypted, the system automatically executes: Search the close point lineage chart for all derived close points that are directly or indirectly dependent on the source close point; Generate an impact scope report (including the number of derived secret sites involved, their security classification, and the units to which they belong); The system will make decisions automatically based on preset rules or request review from the person responsible for classifying confidentiality. Automatically update the security level labels and access permissions for all affected derived key points; Send change notifications to relevant users and confidentiality management departments, and record a complete change audit log.
[0050] Step 5.3: Lineage Visualization Query. Supports forward tracing of all derived secret points from the source secret point (forward tracing), and reverse tracing of all source secret points from the derived secret point (reverse tracing).
[0051] S6. Full-process audit log recording Record complete information for each RAG retrieval and derivation test: User ID and permission information ( , ); Search query content; The list of recalled access points and the results of access determination; The generated new content summary; Derivative verification results (whether it involves classified information, classification level, functional atom, etc.); Timestamps and markers of abnormal behavior (unauthorized access attempts, high-frequency access, etc.).
[0052] According to one aspect of the present invention, and more specifically, a generative artificial intelligence large model RAG security retrieval and derived confidentiality attribute automatic verification system based on key points, comprising six core functional modules working collaboratively, each module's function corresponding one-to-one with the method steps described above, and the specific functional modules are as follows: The dense point-level vector library construction module corresponds to step S1, the dense point vector library construction process, and is responsible for automatic / manual identification of document dense points, multi-dimensional tag binding, independent vectorized storage of dense points, and hierarchical encryption using the national standard SM4; User permission management module: Corresponds to step S2 user permission model construction, stores all user function atomic sets and the highest authorization level, and provides a real-time permission query interface; The 3D security retrieval control module corresponds to step S3, the 3D permission retrieval process, and realizes 3D pre-filtering of functional atoms, security levels, and exclusive authorizations, semantic similarity retrieval, secondary permission verification of recalled secret points, and outputs compliant secret point context to the large language model. Automatic Derivative Classified Verification Module: Corresponds to the three-layer progressive derivation verification algorithm in step S4, with built-in dual-channel derivation relationship detection, derived source attribute aggregation, and classified attribute synthesis logic; it also has a built-in key point fingerprint extraction subunit, including a key term extraction unit, a named entity recognition unit, and a numerical data parsing unit. The Secret Point Lineage Map Management Module corresponds to step S5, Secret Point Lineage Tracking and Linked Update, constructing a global directed acyclic lineage map to realize source secret point changes linked to derived secret point permission updates, bidirectional lineage tracing, and link visualization; it also includes a change review sub-unit, which receives review instructions from the person responsible for setting secret points to complete batch permission synchronization and push change notifications. Full-process audit module: corresponding to step S6 full-process log recording, collecting and retrieving, generating, derivation verification, and key point change operation data of the entire chain, persistently storing and marking abnormal behaviors such as unauthorized access and high-frequency retrieval.
[0053] The data interaction logic between modules is as follows: the user permission management module pushes user permissions to the 3D security retrieval control module; the 3D security retrieval control module sends the retrieval context into the large model, generates text, and then passes it to the derived confidentiality automatic verification module; the derived confidentiality data generated by the verification is synchronized to the confidentiality lineage map management module; the full-process audit module collects the operation logs of all modules. This system can be deployed in military confidentiality office systems, government confidentiality knowledge bases, and enterprise trade secret AI office platforms to achieve automated security closed-loop management of "retrieval-generation-derived confidentiality determination-automatic confidentiality annotation". Beneficial effects: Critical point level search precision: The granularity of RAG search permission control has been reduced from "document level" and "Chunk level" to "critical point level", achieving the finest granularity of RAG search permission control in the industry.
[0054] Three-dimensional precise control: It realizes the three-dimensional joint judgment of "functional atom × security level × security point", and adds horizontal isolation of business functions on the basis of traditional vertical security level control.
[0055] Automatic verification of derived classified attributes: Through a dual-channel derivation relationship detection algorithm of "semantic similarity + secret point fingerprint matching" and an automatic classification attribute synthesis algorithm based on the "highest principle" and "minimum necessity principle", the statutory requirements of the "Interim Measures for the Management of Classification of Derived State Secrets" are combined with RAG technology for the first time, realizing the automatic detection and automatic classification of classified attributes of RAG generated content, transforming "post-event manual classification" into "in-event automatic classification".
[0056] Secret Point Lineage Tracking: A complete secret point lineage chain has been established, from user query to secret point recall to content generation to derivation determination, supporting full lifecycle tracing and linked updates.
[0057] The automated closed loop of RAG retrieval and derivation of key points: It realizes the full-link automated closed loop of "retrieval → generation → judgment → labeling", ensuring that the RAG generated content can automatically obtain key point labeling and access control protection.
[0058] Physical and logical dual isolation: The key points are physically isolated as independent entries in the vector library, and are logically filtered through multi-dimensional tags during retrieval, providing dual protection. Attached Figure Description
[0059] Figure 1 This is a flowchart of the method of the present invention; Figure 2 This is a schematic diagram illustrating the construction of the dense-point-level RAG vector library in this invention; Figure 3 This is a flowchart of the RAG secure retrieval process for three-dimensional access control in this invention; Figure 4 This is a flowchart of the automatic detection algorithm for derived confidential attributes based on close-point lineage in this invention (three-level progression: derivation relationship detection → derivation source aggregation → attribute synthesis). Figure 5 This is a schematic diagram of the close-point kinship map and linkage update mechanism in this invention; Figure 6 This is a system framework diagram of the present invention. Detailed Implementation
[0060] To make the technical solution of the present invention clearer, the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments.
[0061] Example 1: Construction of a dense-point-level RAG vector library In a classified knowledge base system of a certain military office domain, a classified RAG vector library at the level of classified points is constructed according to the following steps: Secret Point Identification. The system identified three secret points in the imported document "Political Work Instructions for the XX Exercise": Secret Point A: "XXX is appointed as the commander of the Red Team." (This involves personnel appointments) Secret Point B: "Strictly adhere to the propaganda line and do not release battle damage estimates." (Content involves propaganda guidelines) Point C: "The fuel supply point is located on the right side of Highway 3." (Content includes fuel supply coordinates) Multidimensional tag binding. The system binds multidimensional tags to each key point: Key Point A: {Functional Atom: POL-HR, Security Classification: Confidential, Type: Phrase / Sentence} Secret Point B: {Functional Atom: POL-PUB, Security Level: Secret, Type: Phrase / Sentence Type} Key Point C: {Functional Atom: LOG-QM, Security Classification: Secret, Type: Coordinate} Independent vectorization and storage. The system vectorizes the three key points separately and stores them as three independent vector entries in the vector library, each carrying its own independent label. The three key points in the same file are physically isolated in the vector library.
[0062] Example 2: RAG Secure Retrieval with Three-Dimensional Access Control Scenario: A propaganda officer (POL-PUB, classified) searches for "exercise propaganda guidelines" in the RAG system.
[0063] Step 1: Obtain user permissions. The system obtains... .
[0064] Step 2: Multidimensional label pre-filtering. The system pre-filters in the vector library: Dimension 1 (Functional Atomic Matching): Only retain dense nodes labeled POL-PUB or POL-NET; Dimension Two (Security Level Matching): Only retain secret points with a security level ≤ Confidential.
[0065] Step 3: Semantic retrieval. The search is performed within the pre-filtered set of key points. Key point B (POL-PUB + Secret) is recalled, key point A (POL-HR + Confidential) is filtered due to a mismatch in functional atoms, and key point C (LOG-QM + Secret) is also filtered due to a mismatch in functional atoms.
[0066] Step 4: Secondary Verification and Response. The system re-verifies that the label of key point B conforms to the user's permissions and injects it into the large language model to generate a response. The user can only see content related to the propaganda message; personnel appointments and fuel supply coordinates are completely invisible.
[0067] Example 3: Automatic verification of derived classified attributes (single-source derivation scenario) Scenario: Based on the secret point B (POL-PUB+Secret, "Strictly adhere to the propaganda line and do not release battle damage estimates") retrieved by RAG, the user generated new content T: "According to the exercise requirements, all propaganda reports must not release any battle damage estimates in advance." Step 1: Derivation Relationship Detection - Channel 1 (Semantic Similarity Coarse Screening).
[0068] The system calculates the semantic vector V(T) of T, and calculates the semantic similarity sim(V(T),V(mᵢ)) for each key point mᵢ in the classified RAG library. The similarity between T and key point B is 0.89. (Setting...) =0.75, 0.89≥0.75, add dense point B to the candidate list. .
[0069] Step 2: Derivation relationship detection - Channel 2 (Fine screening of dense fingerprint matching).
[0070] The system extracts the key fingerprint of T: Key terminology set K(T) = {propaganda stance, battle damage estimate} Named entity set E(T) = ∅ Numerical data set N(T) = ∅ Extract the dense point fingerprint of dense point B: Key term set K(B) = {propaganda stance, battle damage estimate} Named entity set E(B) = ∅ Numerical data set N(B) = ∅ Calculate the fingerprint matching score (w1=0.4, w2=0.3, w3=0.3):
[0071] (Take 1 when the denominator is 0)
[0072]
[0073] set up If the dense point B is added to the final candidate list Candidate, and Candidate is not empty, then it is determined that T is derived from the dense point B.
[0074] Step 3: Derivative source identification and attribute aggregation.
[0075] Candidate={Secret Dot B} The derived weight w(B) = 0.89 × 1.0 = 0.89, and after normalization, w_norm(B) = 1.0. Grouping by functional atom: weight_sum(POL-PUB)=1.0≥ (0.15), the effective functional atom is {POL-PUB} Step 4: Automatic synthesis of classified information attributes.
[0076] Security classification: C(T) = max{Secret} = Secret Confidentiality period: Duration(T) = max{confidentiality period of key point B} Scope of knowledge: Scope(T) = Scope(Secret point B) Functional atom: F(T) = {POL - PUB} Overall confidence level: confidence = 1 - (1 - 0.89 × 1.0) = 0.89 Step 5: Bloodline Recording and Output.
[0077] The system automatically creates a secret record for T, with secret record ID: MID-20260720-001 List of derived sources: [ID(B)] Derivation type: "RAG generation derivation" Criteria for classifying secrets: Criteria for classifying secret point B The output inspection report determines that T is classified as secret information and belongs to the POL-PUB functional atom. Example 4: Automatic verification of derived classified attributes (multi-source derivation scenario) Scenario: Based on secret point A (CMD-OP+Top Secret, "Deploy troops in the XX coordinate area") and secret point B (LOG-QM+Confidential, "Fuel supply point is located at YY coordinates") retrieved by RAG, the user generates new content T: "Deploy troops in the XX coordinate area, fuel supply point is located at YY coordinates." (This content combines the core information from the two secret points) Step 1: Derivation Relationship Detection - Channel 1 (Semantic Similarity Coarse Screening).
[0078] The system calculates the semantic similarity between T and each dense point: sim(V(T),V(dense point A))=0.92≥θ_sim(0.75), dense point A is added to Candidate_sim sim(V(T),V(dense point B))=0.88≥θ_sim(0.75), dense point B is added to Candidate_sim Step 2: Derivation relationship detection - Channel 2 (Fine screening of dense fingerprint matching).
[0079] Extracting the dense fingerprint of T: K(T) = {troop deployment, fuel supply, coordinates} E(T) = {XX coordinate region, YY coordinate region} N(T) = ∅ Fingerprint matching was performed with both key point A and key point B: Fingerprint matching degree with dense point A: Calculate the matching rate of each dimension. Fingerprint matching degree with dense point B: Calculate the matching rate of each dimension. Candidate = {Focus Point A, Focus Point B} Step 3: Derivative source identification and attribute aggregation.
[0080] Derived weights: Normalization: Grouped by functional atoms: The effective functional atoms are {CMD-OP, LOG-QM} Step 4: Automatic synthesis of classified information attributes.
[0081] Classification: C(T) = max{Top Secret, Confidential} = Top Secret (Basis: Derived classifications should be consistent with the highest classification of the relevant classified information) Scope of knowledge: Scope(T) = Scope(dense point A) ∩ Scope(dense point B) (taking the intersection, following the principle of minimum necessity) Confidentiality period: Duration(T) = max{Duration(confidential point A), Duration(confidential point B)} Functional Atoms: Overall confidence level: confidence = 1 - (1 - 0.52) × (1 - 0.48) = 1 - 0.48 × 0.52 = 0.7504 Step 5: Lineage Recording and Output. The system automatically creates a close-point record for T, with the record derived from close-points A and B, and outputs the test report.
[0082] Example 5: Verification of non-derived content (comparative verification) Scenario: A user generates new content T based on their personal knowledge: "Today's weather is suitable for outdoor training." Step 1: Derivation Relationship Detection - Channel 1 (Semantic Similarity Coarse Screening).
[0083] The system calculates the semantic similarity between T and each dense point. The maximum similarity is only 0.12, which is much lower than θ_sim=0.75. Candidate_sim is empty.
[0084] Step 2: Derivation Relationship Detection - Channel Two. If Candidate_sim is empty, fingerprint matching is not required.
[0085] Step 3: Determine the result. If Candidate is empty, determine that T is not a derived self-involved dense point.
[0086] Step 4: Output the inspection report.
[0087] { "is_classified":false, "security_level":"Non-private", "confidence": 1.0 } Example 6: Close-Point Bloodline Tracking and Linked Updates Scenario: One day, Secret Point A (CMD-OP+Top Secret) was declassified due to the end of the combat mission.
[0088] Step 1: Lineage Search. The system searches for all derived dense points that depend on dense point A in the dense point lineage map, and finds that T is derived from dense point A in Example 4.
[0089] Step 2: Impact Scope Analysis. The system generates an impact report: involving 1 derived key point T, 1 document, and 1 unit.
[0090] Step 3: Automatic permission update. After review and confirmation by the person responsible for classifying confidentiality, the system automatically downgrades the classification of T from Top Secret to Confidential (because T also involves confidential content of Confidential Point B), and simultaneously updates the access control system's permission policy.
[0091] Step 4: Notification and Auditing. The system sends change notifications to relevant users and confidentiality management departments, and records a complete change audit log.
[0092] Example 7: Specific Implementation of Fingerprint Extraction Scenario: The system extracts a fingerprint of new content T.
[0093] Key term extraction: The system matches T based on a dictionary of classified matters. The dictionary contains key terms in classified areas such as "troop deployment," "firepower coordination," "fuel pipelines," "propaganda statements," and "battle damage estimation." T contains "troop deployment" and "coordinates," and K(T) = {troop deployment, coordinates} is extracted.
[0094] Named Entity Extraction: The system extracts personal names, place names, military unit numbers, and equipment models from T based on a named entity recognition model. T contains "XX coordinate region" and "YY coordinates", and the extracted value is E(T) = {XX coordinate region, YY coordinates}.
[0095] Numerical data extraction: The system extracts coordinates, quantity, time, distance, etc. from T based on regular expressions and semantic understanding. T contains "Route 3", and N(T)={3} is extracted (as a numerical identifier).
[0096] The embodiments described above are merely illustrative of several implementations of the present invention, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of the present invention. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the present invention, and these modifications and improvements all fall within the scope of protection of the present invention. Therefore, the scope of protection of this patent should be determined by the appended claims.
Claims
1. A method for secure retrieval and automatic verification of derived classified attributes in a generative artificial intelligence large model (RAG) based on dense points, characterized in that, Includes the following steps: Construct a dense point-level RAG vector library: identify dense points in the information content, bind functional atomic tags and security level tags to each dense point, and independently vectorize and encrypt each dense point for storage; Establish a user permission model, which includes user identity identifier, the set of functional atoms to which the user belongs, and the security level granted to the user; Perform RAG security retrieval at the key point level: Based on the functional atomic set and security level in the user permission model, perform permission filtering on key points in the vector library, and only send compliant key points that have passed the permission verification as context into the big language model to generate response text; Perform derived confidentiality attribute verification on new texts output by large language models: detect the derivation relationship between the new text and source confidential points in the vector library; when a derivation relationship is determined, automatically deduce and determine the confidentiality attribute of the new text itself based on the confidentiality attribute of the source confidential points. Establish and maintain the lineage relationship of secret points: record the derived lineage relationship between new text and its corresponding source secret point; when the confidentiality level, scope of knowledge, and other confidential attributes of the source secret point change, retrieve all related derived content and update the access control permissions of the derived content synchronously. Full-process logging: Complete record of the entire operation log, including retrieval, content generation, derived confidentiality verification, and changes to confidentiality attributes.
2. A method for automatically verifying classified information attributes derived from generated content based on key points, characterized in that, Includes the following steps: Get new text generated by a large language model; Detect the derivation relationship between the new text and each source key in the pre-stored key set; If a new text is detected to have a derivation relationship with at least one source secret point, the secret attribute of the new text is automatically determined based on the secret attribute of the corresponding source secret point. Record the derivational lineage between the new text and the corresponding source key.
3. The method for secure retrieval and automatic verification of derived classified attributes of a generative artificial intelligence large model based on dense points according to claim 1, characterized in that, The steps for constructing the dense point-level RAG vector library specifically include: identifying all dense point units in the document; binding functional atomic tags and security level tags to each dense point individually; performing vector transformation independently on a single dense point; encrypting the vectorized dense point data and storing it in the vector library for isolated storage.
4. The method for secure retrieval and automatic verification of derived classified attributes of a generative artificial intelligence large model based on dense points according to claim 1, characterized in that, The specific steps for performing RAG security retrieval at the key point level include: performing pre-filtering operations on all key points in the vector library based on the user's functional atomic set and security level; retrieving relevant key points that semantically match the user's query statement from the key point set remaining after pre-filtering; performing permission verification again on each key point recalled by semantic retrieval; and using the key point data that passes the second verification as context input to the large language model to generate a response.
5. The method according to claim 1 or 2, characterized in that, The steps for detecting the derivation relationship between the new text and the source key points include: calculating the semantic similarity between the new text to be tested and each key point, and selecting key points whose semantic similarity meets the preset conditions as candidate key points; extracting the content feature sets of the new text to be tested and the candidate key points respectively, and finally determining whether there is a derivation relationship between the two based on the degree of matching of the content features of both parties.
6. The method according to claim 1 or 2, characterized in that, The steps for automatically determining the confidentiality attribute of new text based on the confidentiality attribute of source confidentiality points include: when it is determined that the new text is derived from at least one source confidentiality point, the confidentiality level of the new text is determined based on the confidentiality level of all associated source confidentiality points, the knowledge scope of the new text is determined based on the knowledge scope of all associated source confidentiality points, and the functional atomic tag corresponding to the new text is determined based on the functional atomic tag of all associated source confidentiality points.
7. The method according to claim 1 or 2, characterized in that, The steps for establishing and maintaining the lineage relationships of secret points include: storing and recording the derived lineage relationships between all secret points; when any source secret point undergoes a change in its confidentiality attribute, retrieving all text content derived from that source secret point based on the lineage relationship, and synchronously updating the access control permissions corresponding to all derived content.
8. The method for secure retrieval and automatic verification of derived classified attributes of a generative artificial intelligence large model based on dense points according to claim 1, characterized in that, The full-process log recording steps specifically include: recording all operation logs for user search requests, large model content generation process, derived confidentiality attribute verification results, confidentiality attribute changes, and permission synchronization.
9. A generative artificial intelligence large model RAG based on dense points, characterized in that, include: The dense point vector library module is used to store independent dense point vector data bound to functional atomic tags and security level tags; The user permission management module is used to store and maintain the identity identifier, functional atomic set, and security level granted to each user, and to build a user permission model. The retrieval control module is used to call the user permission model to complete key point permission filtering, semantic retrieval, and secondary permission verification, and output the permission-compliant key point context to the large language model. The derivation verification module is used to receive new text generated by the large language model, detect the derivation relationship between the new text and the source secret point, and automatically determine the confidentiality attribute of the new text when a derivation relationship exists; The lineage management module is used to store all derived lineage records between secret points, and to retrieve related derived content and synchronously update the access permissions of derived content when the confidentiality attribute of the source secret point changes. The audit module is used to collect and persistently store the entire operation log of retrieval, generation, derivation verification, and key point change.
10. The automatic verification system for secure retrieval and derived classified attributes of generative artificial intelligence large model RAG based on dense points as described in claim 9, characterized in that: The dense point vector library module performs dense point identification, dense point multidimensional label binding, single dense point independent vectorization, and dense point data encryption and isolated storage operations. The derived verification module realizes semantic similarity detection between new text and key points, text content feature matching, and automatic determination of the confidentiality attributes of derived text; The bloodline management module enables persistent recording of bloodline relationships derived from secret points and triggers permission updates for derived content when the source secret point changes.
11. An automatic verification system for classified information attributes derived from generated content based on key points, characterized in that, include: The derivation detection module is used to obtain new text output by the large language model and detect the derivation relationship between the new text and each source dense point in the dense point set. The attribute determination module, connected to the derivation detection module, is used to automatically calculate and output the complete confidential attributes of the new text based on the source confidentiality point confidentiality parameters when the derivation detection module determines that a derivation relationship exists. The lineage record module, connected to the derivation detection module and the attribute determination module, is used to persistently store the lineage association data between the new text and its derived source key points.
12. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements all the steps of the method for secure retrieval and automatic verification of derived classified attributes of generative artificial intelligence large model RAG based on key points, as described in any one of claims 1 to 8.
