70 results about "Bytecode" patented technology

The application discloses a concurrent program vulnerability detection method based on fuzzy testing and static analysis, and comprises the following steps: compiling a to-be-detected program source code, obtaining a bytecode file according to the compiling, then performing static analysis to obtain a concurrent vulnerability pair; performing program insertion on the concurrent vulnerability pair to obtain a program binary file with inserted code; taking the program binary file with inserted code as a test program, adding an initial input file in an input queue, adding a concurrent vulnerability-oriented mechanism in AFL and adding a judgment mode of whether an input is interesting, and pruning unfeasible paths; performing fuzzy testing to realize vulnerability detection. The application can not only utilize the characteristics of concurrent program vulnerabilities, use an optimized redundant node static analysis technology to reduce the number of concurrent vulnerability detections, but also use a fuzzy testing technology to efficiently reproduce the occurrence process of the concurrent program vulnerabilities, so that more efficient and more intuitive concurrent vulnerability detection is realized.

The embodiments of the present specification provide a method for generating a bytecode, a method for generating a machine code, and a device. The method for generating a bytecode comprises: obtaining a target source code, and applying a first process to the target source code, the first process comprising: replacing a target statement used for an integer operation in the target source code with a preset objective function; on the basis of the target source code after the first processing, generating a target bytecode, the target bytecode comprising a bytecode instruction generated on the basis of a preset function, and the bytecode instruction instructing to perform the integer operation corresponding to the target statement by means of a preset machine instruction sequence, and to perform an overflow check for the integer operation.

This specification provide example Java bytecode injection methods, apparatuses and machine-readable storage media, which can be applied to a Javaagent framework deployed in a Java virtual machine. In an example, a to-be-injected Java bytecode submitted by a target service module in at least one service module is obtained, and a target implementation class corresponding to the to-be-injected Java bytecode is determined. A target injection point type corresponding to the target implementation class is determined, and the target injection point type is respectively matched with mapping relationships maintained in the Java virtual machine to determine a target injection mode corresponding to the target injection point type. A globally unique class transformer is invoked so that the class transformer injects, based on the target injection mode, the Java bytecode into a class file that corresponds to the target service module and that is to be loaded by the Java virtual machine.

The present application provides a Java application control method and a management platform. The method comprises: receiving an image inputted by a user, the image comprising bytecode corresponding to a Java application and a runtime dependency file of the Java application, the bytecode corresponding to the Java application being obtained by means of compiling a source code corresponding to the Java application; on the basis of an available Java local interface in the bytecode corresponding to the Java application, identifying an available system call set of the Java application in the runtime dependency file, the available Java local interface being a Java local interface that can be used when the Java application runs in a target container; and when the Java application runs in the target container, controlling a system call actually used by the Java application to be within the available system call set. The method can efficiently and accurately limit system calls that an application can use, without affecting the service of the application.

The present application relates to payment settlement technical field, disclose a kind of based on smart contract's scientific and technological achievement transaction fund automatic settlement method and system, the method includes: based on transaction intention to compile transaction parameter, obtain contract bytecode and deploy to block chain, obtain unique contract address.Buyer locks transaction fund to the contract account, while the achievement delivery file uploaded by seller is encrypted fragment, generates derivative data section.Derivative data section is distributed to distributed storage node, and the storage address returned by node and content hash value are combined into fragment index list according to agreed format.Extract the digital voucher information of delivery file from the list, carry out byte check with the seller digital voucher sample in transaction parameter, obtain content acceptance result.Finally, according to the settlement mark in acceptance result, the direction of the transfer of transaction funds of both parties is automatically determined;The present application can improve the efficiency of scientific and technological achievement transaction fund automatic settlement based on smart contract.

The present application relates to the technical field of Ethereum smart contract vulnerability detection, and discloses an operation code sequence generation method based on Ethereum transaction data replay, comprising the following steps: S1: Geth client plug-in stage, S2: data replay stage, S3: transaction operation code sequence acquisition stage, and S4: transaction operation code sequence storage stage. When executing in a virtual machine, the bytecode is converted into operation codes by using the API provided by Geth. Therefore, the process of calling a method in a smart contract is actually the process of executing the operation code sequence in the method, and thus it can be considered that the operation code sequence executed in the calling order constitutes a control flow path of a transaction execution. The operation code sequence generation method based on Ethereum transaction data replay collects the operation code sequence in the transaction execution process, is used for machine learning and deep learning model training, and can improve the accuracy of detecting known vulnerabilities and unknown vulnerabilities of a smart contract.

This application provides a method and system for detecting privacy permissions in game publishing access, including: extracting a permission declaration list and decompiled bytecode from the game publishing code product, identifying the degree of code obfuscation and hardening, and obtaining a symbol integrity retention identifier; determining the target tracing mode based on the symbol integrity retention identifier, the target tracing mode including a full-link tracing mode and a shallow tracing mode; using a bytecode tracing unit to traverse the decompiled bytecode according to the target tracing mode, locating the actual call location of each permission item, and obtaining a permission call mapping table; performing a difference operation on the permission declaration list and the permission call mapping table, filtering out permission items that are declared but not called, and obtaining a preliminary set of unused permissions; identifying the target tracing mode of the preliminary set of unused permissions, wherein the full-link tracing mode corresponds to high confidence and the shallow tracing mode corresponds to low confidence, and determining the confidence level of the result.

A source code annotation generation method and device, a storage medium and a computer device are provided. When automatically annotating source code, the source code to be annotated and the bytecode of the source code to be annotated are first obtained. The bytecode can identify source codes with the same function but different implementation manners. Then, based on a preset word embedding matrix, a text word vector of the source code to be annotated and a bytecode word vector of the bytecode are determined. The text word vector can capture the semantic and syntactic information between the strings of the source code to be annotated. After the text word vector and the bytecode word vector are determined, the text word vector and the bytecode word vector are spliced to form a spliced word vector. The spliced word vector is used to generate an annotation result of the source code to be annotated. In this way, the annotation of the codes with the same function but different implementation manners is constrained, confusion and ambiguity are avoided, and the accuracy of the annotation result is improved.

The application discloses a contract attack detection method and device based on symbolic execution and a graph neural network, comprising: obtaining deployment bytecode and runtime bytecode of a smart contract; performing symbolic execution on the runtime bytecode, extracting external calls and event information through depth-first search and taint tracking; constructing a contract call information graph and iteratively simplifying it; performing multi-dimensional feature coding on each node to generate a node feature vector; encoding on-chain metadata of a deployer into a deployer feature vector; constructing and training a graph embedding network and a classification network, the input of the graph embedding network being the simplified contract call information graph, the node feature vector and edge type information, and the output being a graph-level feature vector; the input of the classification network being a joint feature vector obtained by splicing the graph-level feature vector and the deployer feature vector, and the output being a contract classification result. The application can cover multiple attack types and realize attack contract identification with low false alarm rate by extracting contract execution logic structures for detection.

An application running method includes a first container that is in a first container group loads bytecode in a first JAVA archive to obtain a second JAVA archive of an application, where the second JAVA archive includes first bytecode of a to-be-enhanced class in the application, the first container runs a first enhancement component, and the first bytecode is obtained by modifying, by the first enhancement component, bytecode of the to-be-enhanced class in the first JAVA archive in a process in which the first container loads the bytecode in the first JAVA archive; a second container in the first container group loads bytecode in the second JAVA archive to obtain a first loading result; and the second container runs the application based on the first loading result.

This invention discloses a lightweight remote data query method for low-bandwidth networks, belonging to the field of computer networks and data communication. Specifically, for scenarios where a client requests a contact list from a server or queries contacts based on keywords, the client obtains a metadata index table supported by the server. Then, the user inputs query conditions, generating a JSON-formatted query data structure. The client defines a minimal query instruction set, and through encoding mapping, converts the query data structure into short bytecode for simplification. The simplified instruction set data is sent to the server, which reverse-parses it back to the query data structure and uses the restored query conditions to query actual contacts. The server converts the query results for actual contacts into a plain data stream and returns it to the client. The user parses the plain data stream using the metadata index table to obtain the contact person and their phone number. This invention reduces the amount of data communicated between the client and server, thereby improving query efficiency.

The application discloses a service capability tracking method based on compiling period bytecode analysis, belongs to the technical field of API calling management, and is used for solving the problem of insufficient perception of API calling conditions of a client by a server. The method comprises the following steps: a bytecode acquisition module acquires bytecode files in compiling products in a compiling process of a user-side application program and delivers the bytecode files to a bytecode analysis module; the bytecode analysis module performs iterative analysis on the bytecode files, identifies classes, methods and method calling instructions, analyzes calling behaviors of the client on API capabilities of the server from the bytecode level, extracts API service capability calling information, and delivers the API service capability calling information to a service capability recording module; and the service capability recording module arranges the API service capability calling information, and generates tracking data files used for representing corresponding relationships between the client and API service capabilities. Effects: the server can acquire calling information of various API capabilities of the client, and thus effective perception and management of API using conditions can be realized.

Disclosed are systems, apparatuses, methods, and computer-readable media for extending and standardizing heterogeneous network devices using instrumentation. A method includes: receiving, by a client device using a first network interface, instrumentation bytecode to supplement with a data link layer from a management device, wherein a verifier of the client device verifies that the instructions of the bytecode are constrained for security based on a plurality of rules; in response to detecting a trigger at the client device, executing the instrumentation bytecode at the client device to perform at least one function associated with the trigger; and sending a response from the client device based on an execution result of the instrumentation bytecode.

The application relates to the technical field of testing, and discloses a test method for an application system, which comprises the following steps: acquiring a system configuration file, a local application program package and a corresponding local Java bytecode file of a local application system, and determining a target full-amount corresponding relationship of the local application system; acquiring different Java bytecode files of different versions of application program packages, and determining a program difference list; acquiring an outbound configuration file, and combining the target full-amount corresponding relationship and the program difference list to determine a first full-amount test range of the local application system and a plurality of second full-amount test ranges of a plurality of other application systems, and then testing the application system to obtain a target test result of the application system, which realizes bidirectional accurate analysis of a test range of a local program change on itself and other systems and of other system changes on the local system, comprehensively covers transaction interface and business function test requirements among multiple systems in an enterprise, and guarantees the overall operation stability of the application system.

Embodiments of the present application provide a bytecode type processing method and an electronic device. A first control flow is constructed for a bytecode file, the control flow including a plurality of code blocks, and each code block can include a plurality of instructions. Variables in each code block are initialized and scanned one by one, and a data type set of each variable is determined according to information of the instructions. A data type table is maintained, and the data type set of each variable is recorded and updated in the data type table. After the plurality of code blocks are scanned and processed, the sets corresponding to each variable are intersected based on the data type table to determine the data type of each variable, and a type inference process of the bytecode is completed. Through such a bytecode type processing method, the data type inference can be completed through only one scanning of the bytecode and a simple processing, so that the efficiency of the bytecode data type inference is effectively improved, and the process time is significantly shortened.

The invention relates to a method for executing a plurality of computer programs on a data processing system which has at least two separate computing units that share a common resource of the data processing system, wherein each computer program is executed by means of bytecode as program code means on one of the computing units of the data processing system, by converting the program code means of the respective computer program, which is present as bytecode, into the machine instructions relevant for the computing units by means of a code converter of the data processing system, characterized in that the code converter determines at least one interference value for each computer program as a function of a number of converted machine instructions per time step.

This invention discloses a smart contract vulnerability detection method based on opcode semantic enhancement and multi-instance learning. The method first compiles the smart contract into bytecode and disassembles it into an opcode sequence, constructing a control flow graph to extract multiple execution paths. Then, it achieves opcode-level semantic enhancement by classifying the operands following the opcode and concatenating them with the opcode, using a BERT pre-trained model for semantic encoding, and designing an attention pooling layer to aggregate path-level features. Finally, it employs a multi-instance learning framework, using a hybrid loss function and a periodic data update mechanism to achieve accurate vulnerability localization from contract-level labels to path-level vulnerabilities. Compared with existing static analysis tools and traditional machine learning methods, this method has significant advantages in detection accuracy, false positive rate, and interpretability, accurately identifying vulnerabilities and mapping them to their source code locations.

This application relates to the field of HVAC equipment control technology, and discloses a multi-protocol compatibility and edge computing method for HVAC equipment digital controllers. The method includes: parsing protocol bytecode to extract spatiotemporal metadata and establishing an instruction distribution table; executing instruction parsing data, calculating weights based on time consumption deviations and updating status words; filtering and writing to a buffer according to weights, or generating loss alarms by counting the number of discards; calculating the rolling variance representing fluctuations using a recursive algorithm based on an effective dataset; determining the trigger freeze signal based on comprehensive parameters, locking the buffer, and generating a fault snapshot. This invention achieves decoupling between the device communication protocol and the controller's underlying firmware by loading protocol bytecode containing spatiotemporal metadata and using a virtual machine engine for interpretation and execution. This allows the edge controller to adapt to HVAC equipment with different physical layer response characteristics and timing requirements without modifying the underlying code or recompiling the firmware, only by updating the protocol bytecode file.

The application relates to the field of information technology, and provides a visual online development method and device for risk control variables. In the prior art, the variable logic needs to be written in code by a developer, the risk control variable development process is long, the online period is long, real-time updating cannot be achieved, and the maintenance workload of the developer is large. The main scheme comprises the following steps: obtaining the value of a metadata field, a basic function and a logic operator; combining the value of the basic metadata field, the basic function and the logic operator to define a new risk control variable; testing and checking the risk control variable to obtain a variable rule well combined by front-end editing; saving the variable rule well combined by front-end editing, compiling to generate an executable bytecode file; finding all cached variable rule servers to sequentially notify the variable rule updating of the bytecode file obtained through step 4, and updating the variable rule loaded in the memory by the variable rule server.

The application provides a Web application system storage and calculation integration adaptation optimization method and device. The method comprises the following steps: determining a code module to be optimized in a Web application system, performing corresponding rewriting and compiling operations on the code module, obtaining WebAssembly bytecode corresponding to the code module, encapsulating the WebAssembly bytecode into a WebAssembly module, and then integrating the WebAssembly module into the Web application system; performing calculation adaptation optimization on the integrated Web application system based on a synchronous and asynchronous code decoupling mechanism and a virtual instruction set architecture of a corresponding WebAssembly virtual machine; and performing memory adaptation optimization on the integrated Web application system by using an in-place memory filling allocation mechanism based on topological sorting, so as to obtain an adapted and optimized Web application system. The method provided by the application can effectively improve the storage and calculation adaptation optimization effect of an application system, thereby improving the storage and calculation capabilities of the Web application system and the performance of Web services.

The application discloses a backstack method and device when a stackless interpreter executes an exception, and a storage medium. The method comprises the following steps: saving first information, second information, third information and fourth information in a native stack frame corresponding to a first interpreter which interprets and executes an entry program; and when an exception occurs in a current program which is interpreted and executed by a second interpreter, acquiring a first call chain corresponding to at least one bytecode file according to the first information, the second information, the third information and the fourth information. According to the scheme, when an exception occurs in a program of a virtual machine which is interpreted and executed by a stackless interpreter, relevant information can be saved in a native stack frame corresponding to a first interpreter which interprets and executes an entry program, and a call chain corresponding to bytecode files of each execution program of the virtual machine can be acquired according to the relevant information, so that the problem can be located conveniently, and the efficiency of solving the problem is improved.

This disclosure relates to a policy loading method, apparatus, electronic device, storage medium, and program product. The method includes: in response to a policy file change event, determining a changed policy file, the policy file including a policy logic description; converting the policy file into a bytecode array conforming to a preset syntax specification, the preset syntax specification allowing the bytecode array to be converted into a policy class object at runtime; converting the bytecode array into a policy class object; in response to a policy execution instruction, determining a target policy class object from the policy class objects based on the policy execution instruction, creating a target policy instance based on the target policy class object, and executing the target policy instance. Specifically, when a new policy file is uploaded, it can be loaded in real-time at runtime, thus eliminating the dependency chain of encoding, compilation, packaging, release, and restart, shortening the loading cycle of the new policy file, improving the loading response speed of the new policy file, and meeting the needs of business scenarios with high real-time requirements.

This disclosure provides embodiments of a bytecode-based thread safety monitoring method, apparatus, device, and readable medium. One specific implementation of the method includes: controlling a monitoring module within a thread safety monitoring system to monitor field access operations on a target thread in real time; performing access analysis processing on the field access operations to generate access analysis results; determining the thread type of the accessing thread; generating thread safety issue information corresponding to the field access operation; generating an access report and recording the stack information accessed by the field access operation; adding the stack information to the access report and sending the added access report to a target terminal for display; and terminating the target thread in response to receiving a stop command from the target terminal indicating a thread safety issue. This implementation can promptly terminate access operations when access anomalies occur, thereby protecting the RSM system and improving its operational security.

The application discloses a Solidity compiler defect detection method based on cross-component fuzz testing, obtains a seed program through data cleaning on historical defect data and test programs; data with the same defect component is screened from the historical defect data of the seed program, and defect features are extracted to obtain program generation prompts, and new test programs are generated according to the program generation prompts; bytecode and error information are generated by executing the new test programs through the compiler, the bytecode is executed through the Ethereum virtual machine to output execution logs, consistency comparison is performed according to the execution logs and the error information to determine logical defects, and a defect report is generated according to the logical defects; the program triggering the defect is used to guide program variation, and the program triggering the defect and the defect description are used to trigger the key features of the defect, so that the program triggering the compiler defect can be efficiently generated, and the problem that the generated test program cannot trigger the compiler defect is solved.

The application discloses a dynamic dotting method and device, wherein the method comprises the following steps: acquiring description information of a setting class file, checking the description information of the setting class file, and acquiring a setting method and the setting class file according to a method parameter, the name of the setting method and the name of the setting class file; intercepting and preprocessing the setting method to set the setting method to a state that can be dotted; calling an interface on a front position or a rear position of the setting method, and reporting dotting data to fill the dotting data to the front position or the rear position of the setting method; redefining the setting class file to obtain an enhanced setting class file; and sending the enhanced setting class file to a setting agent end to replace the setting class file with the enhanced setting class file through bytecode enhancement technology to realize dynamic dotting of a program; and the application implants dotting data when the program runs, thereby improving dotting efficiency and dotting accuracy of the program.

This invention discloses a method for recovering the control flow graph of Ethereum smart contract bytecode. The method includes: Step 1, preprocessing and basic block partitioning; Step 2, constructing the execution environment; Step 3, a control flow graph recovery algorithm based on valid paths, employing a segmented iterative expansion mechanism, dividing the control flow exploration into three stages: segment enumeration, execution, and coverage determination; Step 4, jump vector abstraction and stack element parsing; Step 5, iterative processing. This method can generate accurate and complete EVM bytecode control flow graphs, achieving extremely high basic block coverage. This invention demonstrates feasibility and robustness in handling large-scale, highly complex smart contracts.

The application relates to an assertion method and device, a computer device, a storage medium and a program product, and belongs to the technical field of artificial intelligence. The method comprises the following steps: intercepting and processing a message sent by a test script to a called interface to obtain first intercepted data; intercepting and processing the message received by the interface through a target bytecode file corresponding to the interface to obtain second intercepted data, wherein the target bytecode file is obtained by injecting an intercepted bytecode into initial bytecode obtained by compiling source code of the interface, and the intercepted bytecode is used for intercepting and processing the message; and performing interface assertion processing based on the first intercepted data and the second intercepted data. The method can reduce the workload of assertion and improve the stability of the called interface.

The present disclosure provides a microkernel-based event handling method and apparatus. A virtual machine is embedded in a microkernel, and the method includes: in response to detecting a preset trigger event during running of a target application program in a user mode, switching from the user mode to a kernel mode and acquiring a bytecode associated with the preset trigger event, where the bytecode is a functional code pre-written into a shared code region in the user mode, and the functional code is a code corresponding to partial functions in the target application program; and controlling the virtual machine to execute the bytecode, and writing an execution result of the preset trigger event into a shared data region, to make the execution result be read from the shared data region in the user mode after switching to the user mode. The method may improve handling efficiency of a microkernel system

This application discloses a code processing method, apparatus, terminal, and computer-readable storage medium. The method includes: acquiring initial front-end code; performing code analysis on the initial front-end code using a target code processing model to obtain code risk information; then, determining target risk code segments in the initial front-end code based on the code risk information; performing intermediate representation optimization processing on the target risk code segments using the code risk information to obtain target intermediate representations corresponding to the target risk code segments; then, generating target bytecode corresponding to the target intermediate representations; and replacing the target risk code segments in the initial front-end code based on the target bytecode to obtain target front-end code. This solves the technical problem of relying on manual code optimization when optimizing completed front-end code.

The application relates to a log content modification method and device, electronic equipment and a storage medium, the method comprising the following steps: starting a Java probe corresponding to a target application, and registering a class bytecode converter by using the Java probe; acquiring configuration data from a configuration center by using the Java probe, and supporting dynamic modification of to-be-inserted log content and an insertion position; in the case that the class bytecode converter detects that a currently loaded class in a Java virtual machine matches the configuration data, or in the case that the Java probe detects that configuration data in the configuration center is changed, modifying target class bytecode by using the class bytecode converter, so that the Java virtual machine generates modified log content based on the modified target class bytecode. In this way, the log content of the target application can be dynamically modified without modifying business code and restarting a background service, the log content modification time is shortened, and the modification efficiency of the log content is improved.