Fine-grained geometric desensitization and virtual file system transparent reconstruction method

Abstract

The invention discloses a fine-grained geometric desensitization and virtual file system transparent reconstruction method which can be directly applied to a trusted data space, a smart city digital twin platform and a cross-enterprise design cooperation system. According to the technical scheme disclosed by the invention, fine-grained concealment and hierarchical authorization of component-level geometric data can be realized on the premise of not damaging an IFC standard file analysis structure, and meanwhile, the security risk caused by the fact that encrypted data must be decrypted when being used at a client can be avoided, so that on-demand streaming loading and transparent reconstruction of the data are realized.

Description

TECHNICAL FIELD

[0001] The present application relates to a kind of BIM (Building Information Modeling) data, in particular, semantic-geometry decoupling, hierarchical desensitization and transparent reconstruction technology based on virtual file system of IFC (Industry Foundation Classes) standard format, belong to planning design software data security and cross-domain collaboration technical field. BACKGROUND

[0002] In building engineering digital delivery, IFC (Industry Foundation Classes) is the international construction industry de facto engineering data exchange standard, its bottom uses ASCII (American Standard Code for Information Interchange) text-based STEP (Standard for the Exchange of Product Model Data) physical format. At present, the security protection of IFC data mainly depends on the whole encryption technology of file level, that is, AES (Advanced Encryption Standard) or RSA algorithm (Rivest-Shamir-Adleman) is used to perform binary confusion on the entire file.

[0003] This processing method, although it guarantees the confidentiality of data, but brings a fatal defect: the encrypted file completely destroys the HEADER (file header) and DATA (entity segment) structure of STEP format, so that the receiver cannot use BIM design software to preview or property view in any form before obtaining complete decryption permission, greatly hinders the collaboration efficiency. In addition, the existing lightweight technology often uses destructive geometry algorithm to directly modify the model to generate irreversible simplified version, which cannot meet the dynamic demand of different users to show different precision for the same data, and the traditional encryption scheme requires that the file must be decrypted to clear text file on the client side before being read by software, which makes high-value data easily copied or stolen illegally, and it is difficult to meet the security requirements of "data available but invisible" in trusted data space. SUMMARY

[0004] The technical problem to be solved by the present application is that the existing building information model data cannot be pre-audited due to file structure destruction caused by full encryption in the cross-domain circulation process, and the data sovereignty is out of control due to clear text landing.

[0005] To solve the above technical problems, the technical scheme of the present application is to disclose a fine-grained geometric desensitization and virtual file system transparent reconstruction method, which can be directly applied to trusted data space, smart city digital twin platform and cross-enterprise design collaboration system, characterized in that the semantic properties and geometric expressions of IFC files are separated at the physical storage level, the integrity of the file topology structure is maintained by using the lightweight proxy entities generated by the algorithm, and high-precision data is dynamically restored in the memory through the I / O interception technology at the operating system kernel level, including the following steps: The first step is STEP physical format analysis and object dependency graph construction: Read the IFC source file, perform lexical analysis based on ISO 10303-21 specification, identify entity lines indexed by "#" number, construct object dependency directed acyclic graph containing entity nodes and reference edges, and locate all component nodes and their pointed geometric expression sub-trees by using graph traversal algorithm; The second step is geometric feature extraction and multi-level proxy entity generation: Extract vertex data from the peeled geometric expression sub-tree, calculate the principal axis direction and extreme point of the geometric body by using principal component analysis algorithm, generate LOD-1 (level of details, LOD) level bounding box proxy entity containing space occupancy information and LOD-2 level convex hull proxy entity containing contour information; The third step is reference redirection and skeleton file solidification: Modify the pointer reference in the original IFC file to point to the generated bounding box proxy entity and convex hull proxy entity, serialize and encrypt the original high-precision geometric data, and generate a skeleton file that retains the complete file header, attribute set and hierarchical relationship but only contains low-precision geometry; The fourth step is virtual file system mounting and I / O stream reconstruction: Load the kernel-level file filtering driver on the client side, build a virtual device object; intercept the I / O request packet of the file system, perform real-time decryption and address remapping of the encrypted geometric data in the kernel memory buffer according to the dynamically constructed offset mapping table, and realize transparent data filling to the upper layer application.

[0006] Preferably, the first step includes the following steps: In the server preprocessing stage, start the STEP format analysis engine to load the target IFC source file; The analysis engine uses memory mapping file technology to perform stream-based lexical analysis, skips the HEADER segment of the file header, and locates to the DATA segment; For each row in the data segment, the parsing engine uses regular expression matching to extract the entity ID and entity type string from the entity definition starting with a "#" number. The system maintains an efficient index structure based on hash buckets in memory, recording the physical starting byte offset and length of each entity in the source file to establish a physical index of the file content. Based on the established physical index, an object dependency directed acyclic graph is constructed. A depth-first search is performed on the object dependency directed acyclic graph, recursively tracing along the Representation attribute edges, traversing the IfcProductDefinitionShape and IfcShapeRepresentation intermediate nodes, and finally locking the geometric description entities at the leaf nodes. All leaf nodes and their recursively included child nodes are marked as a complete geometric expression sub-tree.

[0007] Preferably, when constructing the object dependency directed acyclic graph, all component entities inherited from the IfcProduct base class are first screened out as root nodes. Then, for each root node, its attribute parameter list is parsed to construct edges.

[0008] Preferably, for each locked geometric expression sub-tree, the second step includes the following steps: Extract all three-dimensional vertex coordinate sets V in the geometric expression sub-tree; Calculate the covariance matrix of the three-dimensional vertex coordinate set V using principal component analysis and perform eigenvalue decomposition to solve three orthogonal eigenvectors, which define the principal axis direction of the component; In the local coordinate system constructed based on the three orthogonal eigenvectors, calculate the extreme points of each axis to determine the 8 corner point coordinates of the minimum volume direction bounding box; Transform the corner point coordinates back to the world coordinate system and encode them into a new IfcBoundingBox entity string according to the IFC STEP syntax as a LOD-1 level bounding box proxy entity or a LOD-2 level convex hull proxy entity.

[0009] Preferably, the third step includes the following steps: After generating the LOD-1 level bounding box proxy entity and the LOD-2 level convex hull proxy entity, the original high-precision geometric data is format-converted from IFC text format to compact binary serialized format; Generate a random session key and use the AES-256-GCM algorithm accelerated by the AES-NI instruction set to encrypt the binary data block, generate a ciphertext block, and store the ciphertext block in the distributed object storage system with the global unique identifier of the component as the index key. Traverse the object dependency directed acyclic graph in memory, find all parent node reference pointers pointing to the original high-precision geometry entity, and modify them to point to the proxy entity IDs of the LOD-1 level bounding box proxy entity and the LOD-2 level convex hull proxy entity; Physically remove the original geometry nodes that are broken into islands by reference; Recalculate the file checksum and serialize the modified object graph to write out as a skeleton file, which retains all semantic attributes and component hierarchical relationships, but the geometric expression has been replaced by a low-precision bounding box.

[0010] Preferably, the fourth step comprises the following steps: On the data consumption side, a kernel mode driver based on the micro-filter architecture is deployed; when the system starts, the driver is loaded in the kernel space and creates a virtual device object, and the driver registers a drive letter in the user space, which serves as an entry point to take over all I / O request packets sent to this path; the driver maintains a file control block structure in memory to map the virtual file to the local cached skeleton file path and the cloud encrypted data source.

[0011] The driver constructs a "dynamic offset correction table" in memory, recording tuples (VirtualOffset, SkeletonOffset, LengthDiff, IsEncrypted), where VirtualOffset is the file offset for the upper application, SkeletonOffset is the corresponding actual offset in the skeleton file, LengthDiff is the length difference generated by the geometry replacement for the current paragraph, and IsEncrypted is used to mark whether the current paragraph needs to trigger decryption logic; the driver initializes the "dynamic offset correction table" by pre-reading the skeleton file metadata to ensure that the true physical read address can be quickly calculated during subsequent random reading; When the BIM application initiates a ReadFile call, the operating system kernel generates an IRP_MJ_READ request packet. The driver intercepts the IRP, obtains its read position and length, and queries the constructed "dynamic offset correction table": If the request area falls in the non-encrypted segment, the driver converts the virtual offset to the skeleton file offset, directly reads data from the local skeleton file, and writes it to the buffer pointed to by the memory descriptor list of the IRP through DMA; If the request region covers the encrypted segment, the driver suspends the IRP and triggers the user-mode service process. After checking the user's authority, the service process extracts the binary block from the encryption library, uses the AES-NI instruction set for real-time decryption, and deserializes the binary into STEP format text; the driver writes the restored text into the user buffer and automatically fills in the subsequent data until the read length requirement is met; finally, the driver completes the IRP, and the upper-layer application immediately obtains the decrypted high-precision data, and the plaintext data in the memory is immediately marked as overwritable after the IRP is completed.

[0012] The technical solution disclosed by the application can realize fine-grained concealment and hierarchical authorization of component-level geometric data without destroying the IFC standard file parsing structure, and can avoid the security risks caused by the need to decrypt and land encrypted data when used on the client, thereby realizing on-demand streaming loading and transparent reconstruction of data, and compared with the prior art, has the following beneficial effects: Firstly, by generating a skeleton file conforming to the STEP syntax, the application realizes perfect unification of standard compatibility and privacy protection, ensures that unauthorized users or standard browsers can normally open the file to view the properties and model outline, and solves the problem of "not decryptable, not usable" caused by traditional encryption; Secondly, the memory-level transparent reconstruction realized by using the virtual file system technology completely eliminates the leakage risk caused by landing the plaintext file on the hard disk, and truly realizes the security goal of "data usability and invisibility"; thirdly, the application supports on-demand streaming loading, and the system only needs to decrypt the data of the components within the current view angle or selected by the user, rather than processing the entire GB-level file at one time, which significantly reduces the memory and CPU overhead of the client and greatly improves the browsing experience of large models; Finally, the independent encryption strategy based on the component ID enables the same data to display geometric information with different precisions from LOD100 to LOD500 for different users, providing strong technical support for fine collaboration across enterprises. BRIEF DESCRIPTION OF DRAWINGS

[0013] Figure 1 is the overall system architecture flowchart of the method proposed by the application, which shows the data interaction logic between the data preprocessing module of the server and the secure connector module of the client; Figure 2 is a principle diagram of IFC object reference redirection performed by the server, which shows the reference chain of IfcProduct pointing to IfcFacetedBrep (high-precision mesh) in the original IFC file on the left, and the reference chain pointing to IfcBoundingBox (proxy entity) after processing and the storage structure of the encrypted data block on the right. DETAILED DESCRIPTION

[0014] The application will be further described below in connection with specific embodiments. It should be understood that these embodiments are only used to illustrate the application and not used to limit the scope of the application. Furthermore, it should be understood that those skilled in the art can make various modifications or changes to the application after reading the content taught by the application, and these equivalent forms also fall within the scope defined by the appended claims of the application.

[0015] The embodiments of the application take a safe flow in a trusted data space of a BIM model (IFC format) containing a high-precision curtain wall node and sensitive internal pipeline layout as an example to further illustrate the fine-grained geometry desensitization and virtual file system transparent reconstruction method disclosed by the application. The method is cooperatively executed by a server preprocessing subsystem and a client security connector. The specific steps are as follows: Step 1: Lexical scanning and memory index construction of IFC physical file stream.

[0016] In the server preprocessing stage, the system starts the STEP format parser engine to load the target IFC source file. The parser uses the Memory-Mapped File technology to perform stream-based lexical analysis, skips the HEADER segment in the file header, and locates to the DATA segment. For each line in the data segment, the parser uses regular expression matching to match entity definitions starting with a "#" number, extracts entity ID (Entity ID) and entity type string. The system maintains an efficient index structure based on hash bucket in memory, records the physical starting byte offset and length of each entity in the source file, and establishes a physical index of the file content.

[0017] Step 2: Depth-first traversal of object dependency directed acyclic graph (DAG) and locking of geometric sub-tree.

[0018] Based on the index established in step 1, the system constructs an object dependency directed acyclic graph. The algorithm first filters out all component entities inherited from the IfcProduct base class as root nodes. For each root node, the system parses its attribute parameter list to construct edges. The system performs a depth-first search along the Representation attribute edge, recursively traces through the IfcProductDefinitionShape and IfcShapeRepresentation intermediate nodes, and finally locks the geometric description entity (such as IfcFacetedBrep) at the leaf node. The system marks these leaf nodes and all sub-nodes (such as IfcCartesianPoint) recursively contained as a complete "to-be-detached geometric sub-tree".

[0019] Step 3: Adaptive proxy model generation based on covariance matrix eigen decomposition.

[0020] For each locked geometry subtree, the system executes an adaptive lightweight proxy generation algorithm. The system first extracts all the 3D vertex coordinate sets V in the geometry subtree. To generate a bounding box with the smallest volume that fits the component pose, the system employs the principal component analysis (PCA) technique. The algorithm computes the covariance matrix of the point set V and performs eigenvalue decomposition to solve three orthogonal eigenvectors, which define the directions of the principal axes of inertia of the component. The system projects the original vertex set V into this local coordinate system and computes the extreme points on each axis to determine the 8 corner coordinates of the minimum-volume oriented bounding box (OBB). Finally, the system inverse-transforms these corner points back to the world coordinate system and encodes them as a new IfcBoundingBox entity string according to the IFC STEP syntax.

[0021] Step 4: Binary serialization and high-strength block encryption of original geometry data.

[0022] After generating the proxy entity, the system performs format conversion on the original high-precision geometry data. The system converts the locked geometry subtree from Step 2 from IFC text format to a compact binary serialized format (e.g., Protocol Buffers) to remove redundant ASCII characters. Subsequently, the system generates a random session key and uses the AES-256-GCM algorithm accelerated by the AES-NI instruction set to encrypt the binary data blocks, generating ciphertext blobs (Ciphertext Blob). The system stores the ciphertext blobs in a distributed object storage system and uses the component's globally unique identifier (GUID) as the index key.

[0023] Step 5: Atomic redirection of reference pointers and skeleton file reorganization and solidification.

[0024] The system performs core modification operations to generate the skeleton file. The system traverses the object dependency graph in memory and finds all parent node reference pointers pointing to the original high-precision geometry entity, modifying them to point to the proxy entity ID generated in Step 3. To maintain the integrity of the file's references, the system physically removes original geometry nodes that become isolated due to broken references. The system recalculates the file checksum and serializes the modified object graph as a "skeleton file." This file retains all semantic properties and component hierarchy relationships but replaces the geometry representation with a low-precision bounding box, conforming to the ISO 16739 standard.

[0025] Step 6: Loading of the kernel-level virtual file system filter driver and mounting of the device object.

[0026] On the data consumption side, this invention deploys a kernel-mode driver based on a minifilter architecture. Upon system startup, the driver loads in kernel space (Ring 0) and creates virtual device objects. The driver registers a drive letter (e.g., Z:) in user space, which serves as the entry point, handling all I / O request packets (IRPs) sent to that path. The driver maintains a file control block structure in memory, mapping virtual files to locally cached skeleton file paths and encrypted cloud data sources.

[0027] Step 7: Construction and maintenance of the dynamic offset correction table.

[0028] This is a crucial step in resolving the file length inconsistency issue. Since the length of the original high-precision geometric text is much larger than the length of the proxy geometric text in the skeleton file, direct replacement would cause file pointer misalignment. Therefore, the driver constructs a "dynamic offset correction table" in memory, recording tuples (VirtualOffset, SkeletonOffset, LengthDiff, IsEncrypted), where: •VirtualOffset: The file offset assumed by the upper-level application.

[0029] • SkeletonOffset: The actual offset in the skeleton file.

[0030] • LengthDiff: The length difference of this paragraph due to geometric replacement.

[0031] •IsEncrypted: Marks whether the paragraph needs to trigger decryption logic.

[0032] The driver initializes the table by pre-reading the skeleton file metadata, ensuring that the actual physical read address can be quickly calculated during subsequent random reads.

[0033] Step 8: Interception, immediate decryption, and memory descriptor list (MDL) population of I / O request packets (IRPs). When the BIM application initiates a ReadFile call, the operating system kernel generates an IRP_MJ_READ request packet. The driver intercepts this IRP, obtains its read location and length, and queries the correction table constructed in Step 7. • Scenario A (Attribute Reading): If the requested region falls in the unencrypted segment, the driver converts the virtual offset to a skeleton file offset, reads the data directly from the local skeleton file, and writes it to the buffer pointed to by the IRP's Memory Descriptor List (MDL) via DMA.

[0034] • Scenario B (Geometric Read): If the requested region covers the encrypted segment, the driver suspends the IRP and triggers the user-space service process. After verifying user permissions, the service process extracts the binary block from the encryption library, performs on-the-fly decryption using the AES-NI instruction set, and deserializes the binary into STEP format text. The driver writes the recovered text to the user buffer and automatically fills it with subsequent data until the read length requirement is met. Finally, the driver completes the IRP, and the upper-layer application immediately obtains the decrypted high-precision data. The plaintext data in memory is immediately marked as overwhelmable after the IRP is completed.

Claims

1. A fine-grained geometric desensitization and transparent reconstruction method for virtual file systems, which can be directly applied to trusted data spaces, smart city digital twin platforms, and cross-enterprise design collaboration systems, characterized in that... By separating the semantic attributes and geometric representation of IFC files at the physical storage level, lightweight proxy entities generated by algorithms maintain the integrity of the file topology, and high-precision data is dynamically restored in memory using operating system kernel-level I / O interception technology. The process includes the following steps: Step 1, STEP physical format parsing and object dependency graph construction: Read the IFC source file, perform lexical analysis based on the ISO 10303-21 standard, identify entity lines indexed by "#", construct an object dependency directed acyclic graph containing entity nodes and reference edges, and use a graph traversal algorithm to locate all component nodes and their pointed geometric representation subtrees; Step 2, geometric feature extraction and multi-level proxy entity generation: Extract vertex data from the extracted geometric representation subtrees, calculate the principal axis direction and extreme points of the geometry using principal component analysis, and generate LOD-1 level bounding box proxy entities containing spatial occupancy information and LOD-2 level convex hull proxy entities containing contour information; Step 3, reference redirection and skeleton file solidification: Modify... The pointer references in the original IFC file are redirected to the generated bounding box proxy entity and convex hull proxy entity. At the same time, the original high-precision geometric data is serialized and encrypted for storage, generating a skeleton file that retains the complete file header, attribute set, and hierarchical relationship but contains only low-precision geometry. The fourth step is virtual file system mounting and I / O streaming reconstruction: the kernel-level file filtering driver is loaded on the client to construct a virtual device object; by intercepting the file system's I / O request packets, the encrypted geometric data is decrypted and remapped in real time in the kernel memory buffer according to the dynamically constructed offset mapping table, realizing transparent data filling for upper-layer applications.

2. The fine-grained geometric desensitization and transparent reconstruction method for virtual file systems as described in claim 1, characterized in that, The first step includes the following steps: In the server-side preprocessing stage, the STEP format parsing engine is started to load the target IFC source file; the parsing engine uses memory-mapped file technology to perform streaming lexical analysis, skipping the HEADER segment in the file header and locating the DATA segment; for each line in the data segment, the parsing engine uses regular expressions to match entity definitions that start with "#" followed by a number, extracting the entity ID and entity type string; the system maintains an efficient index structure based on hash buckets in memory, recording the physical starting byte offset and length of each entity in the source file, thereby establishing a physical index of the file content; based on the established physical index, an object dependency directed acyclic graph is constructed; a depth-first search is performed on the object dependency directed acyclic graph, recursively tracing along the Representation attribute edge, traversing the intermediate nodes of IfcProductDefinitionShape and IfcShapeRepresentation, and finally locking the geometric description entity at the leaf node, marking these leaf nodes and all their recursively contained child nodes as a complete geometric representation subtree.

3. The fine-grained geometric desensitization and transparent reconstruction method for virtual file systems as described in claim 1, characterized in that, When constructing a directed acyclic graph of object dependencies, first select all component entities that inherit from the IfcProduct base class as root nodes, and then parse the attribute parameter list of each root node to construct the edges.

4. The fine-grained geometric desensitization and transparent reconstruction method for virtual file systems as described in claim 1, characterized in that, For each locked geometric representation subtree, the second step includes the following steps: extracting the set of three-dimensional vertex coordinates V in the geometric representation subtree; calculating the covariance matrix of the three-dimensional vertex coordinate set V using principal component analysis and performing eigenvalue decomposition to obtain three orthogonal eigenvectors, which define the direction of the component's principal axis of inertia; calculating the extreme points of each axis in the local coordinate system constructed based on the three orthogonal eigenvectors of the original three-dimensional vertex coordinate set V, and determining the coordinates of the eight corner points of the minimum volume direction bounding box; inversely transforming the corner point coordinates back to the world coordinate system and encoding them into a new IfcBoundingBox entity string according to the IFC STEP syntax as a LOD-1 level bounding box proxy entity or a LOD-2 level convex hull proxy entity.

5. The fine-grained geometric desensitization and transparent reconstruction method for virtual file systems as described in claim 1, characterized in that, The third step includes the following steps: After generating LOD-1 level bounding box proxy entities and LOD-2 level convex hull proxy entities, the original high-precision geometric data is format-converted, and the locked geometric representation subtree is converted from IFC text format to compact binary serialization format; a random session key is generated, and the binary data block is encrypted using the AES-256-GCM algorithm accelerated by the AES-NI instruction set to generate ciphertext blocks, which are stored in a distributed object storage system with the globally unique identifier of the component as the index key; the object dependency directed acyclic graph in memory is traversed to find all parent node reference pointers pointing to the original high-precision geometric entities, and these pointers are modified to point to the proxy entity IDs of the LOD-1 level bounding box proxy entities and LOD-2 level convex hull proxy entities; original geometric nodes that have become isolated due to broken references are physically removed; the file checksum is recalculated, and the modified object graph is serialized and written out as a skeleton file. The skeleton file retains all semantic attributes and component hierarchy relationships, but the geometric representation has been replaced with a low-precision bounding box.

6. The fine-grained geometric desensitization and transparent reconstruction method for virtual file systems as described in claim 1, characterized in that, The fourth step includes the following steps: On the data consumption end, deploy a kernel-mode driver based on a micro-filtering architecture; when the system starts, the driver loads in the kernel space and creates a virtual device object. The driver registers a drive letter in the user space, which serves as the entry point and takes over all I / O request packets sent to that path; the driver maintains a file control block structure in memory, mapping the virtual file to the locally cached skeleton file path and the cloud-encrypted data source; the driver constructs a "dynamic offset correction table" in memory, recording tuples (VirtualOffset, SkeletonOffset, LengthDiff, IsEncrypted), where VirtualOffset is the file offset from the upper-layer application, SkeletonOffset is the corresponding actual offset in the skeleton file, LengthDiff is the length difference of the current paragraph due to geometric replacement, and IsEncrypted is used to mark whether the current paragraph needs to trigger decryption logic; the driver initializes the "dynamic offset correction table" by pre-reading the skeleton file metadata to ensure that the real physical read address can be quickly calculated in subsequent random reads; when BIM When an application initiates a ReadFile call, the operating system kernel generates an IRP_MJ_READ request packet. The driver intercepts this IRP, obtains its read position and length, and queries the constructed "dynamic offset correction table": if the requested region falls within an unencrypted segment, the driver converts the virtual offset to a skeleton file offset, reads the data directly from the local skeleton file, and writes it to the buffer pointed to by the memory descriptor list of the IRP via DMA; if the requested region covers an encrypted segment, the driver suspends the IRP and triggers a user-mode service process; after verifying user permissions, the service process extracts binary blocks from the encryption library, performs on-the-fly decryption using the AES-NI instruction set, and deserializes the binary into STEP format text; the driver writes the recovered text to the user buffer and automatically fills in subsequent data until the read length requirement is met; finally, the driver completes the IRP, and the upper-layer application immediately obtains the decrypted high-precision data, while the plaintext data in memory is immediately marked as overwhelmable after the IRP is completed.

Images