130 results about "Verified procedure" patented technology

Described is a system and method in which a system and method in which a device manufacturer or software image provider controls which devices are allowed to install or to run a software image. An image keying mechanism uses package data and UUID associated with the device or class of devices to key an image. Because the UUID is used in the key, an installer verifier and/or boot-time verifier can ensure that the device is authorized to install and/or run the image. Any package, including existing device packages or the package for which installation is requested can demand that keying be enforced. An installer mechanism checks whether the device is allowed to install the image. A boot-time enforcement mechanism prevents an improperly installed image from operating by halting the boot process if a demanded key is invalid or missing.

A technique verifies a compound software code using a modularized architecture. The compound software code may be divided into smaller components or modules that provide various functions (e.g., services) of the code. A set of properties may be defined for the modules, such that the verification technique may be used to verify that the modules manifest those properties, wherein at least one property may be security related and the remaining properties may be related to the services of the modules. The compound software code is divided into smaller modules to facilitate verification of the properties related to the services provided by the modules. Properties of the modules may be verified in accordance with an enhanced verification procedure to demonstrate that the modules manifest those properties and transform those modules into verified code bases (VCBs). The services of the VCBs may then be combined to provide functionality of the compound software code using well-defined interfaces, such as application programming interfaces (APIs).

A method for authenticating and deciphering an encrypted program file for execution by a secure element includes receiving the program file and a digital certificate that is associated with the program file from an external device. The method stores the program file and the associated certificate in a secure random access memory disposed in the secure element and hashes the program file to obtain a hash. The method authenticates the program file by comparing the obtained hash with a checksum that is stored in the certificate. Additionally, the method writes runtime configuration information stored in the certificate to corresponding configuration registers disposed in the secure element. The method further generates an encryption key using a seed value stored in the certificate and a unique identifier disposed in the secure element and deciphers the program file using the generated encryption key.

A method and system for detecting authorized programs within a data processing system. The present invention creates a validation structure for validating a program. The validation structure is embedded in the program and in response to an initiation of the program, a determination is made as to whether the program is an authorized program. The determination is made using the validation structure.

A server transmits a message from a sender to a destination address. During transmission, the server and the destination address have a dialog constituting an attachment, via a particular one of SMTP and ESMTP protocols, concerning the message, the server and the destination address. The message passes through servers between the server and the destination address. This passage is included in the attachment. Verifiers are provided for the message and for the attachments. The verifiers may constitute encrypted hashes of the message and of the attachment. The sender receives the message, the attachments and the verifications from the server before authentication and transmits the message, the attachments and the verifiers to the server to obtain authentication by the server. The server operates on the message and the message verifier to authenticate the message and operates on the attachments and the attachments' verifier to verify the attachments.

The invention relates generally to data security and to data memory technologies, and more specifically provides a method for storing and updating digital certificates in a flash memory, and provides further a flash memory and an electronic apparatus exploiting said method. The method according to the invention is applicable for a flash memory (110) having predefined erase-write blocks and write-read blocks, for enhancing the tampering proof characteristics of said flash memory (110), said certificates authenticating a computer program and being verified by a verification program associated with the computer program, said method comprising the steps of:

• • (230) defining a plurality of memory slots within said at least one erased erase-write block wherein each memory slot have a commencing address comprising a binary “0”- or a binary “1” bit pattern,
  • (240) writing a first and second digital certificate in a first and second one of said memory slots,
  • (250) defining a certificate slot address pointer,
  • (260) updating said certificate slot address pointer by replacing said “0”- or “1”-bit pattern of said pointer with a “1”-or a “0” bit pattern, respectively.

The invention relates to a method and apparatus for performing state-table driven regression testing. More particularly, the invention relates to an application wherein a release build is used without the use of a debug build, which ensures release of the same code that was tested with the exception of the device driver. In a third embodiment, the tested code is the same as the release code, thereby enhancing quality control, quality assurance, verification, and/or validation procedures are maintained. In one embodiment of the invention, at least one state table is used in testing release code. In another embodiment, the test code is developed using a first platform and the release code is used on a second, distinct platform. In yet another embodiment, the invention relates to regression testing using simulated faults as monitored through log files.

A mechanism for protected operating system boot that prevents rogue components from being loaded with the operating system, and thus prevents divulgence of the system key under inappropriate circumstances. After a portion of the machine startup procedure has occurred, the operating system loader is run, the loader is validated, and a correct machine state is either verified to exist and/or created. Once the loader has been verified to be a legitimate loader, and the machine state under which it is running is verified to be correct, the loader's future behavior is known to protect against the loading of rogue components that could cause divulgence of the system key. With the loader's behavior being known to be safe for the system key, the validator may unseal the system key and provides it to the loader.

An automated routine verifies the medical necessity of a procedure. When a procedure is scheduled, the routine searches for, captures and archives patient and clinical information in an audit file, to evidence medical necessity of the procedure. If the audit file lacks one or more pieces of information, medical personnel will be visually alerted to the shortcoming and what is lacking. The user may then activate one or more objects of a user interface, to search resources that contain the required information, so that the audit file may be updated, as necessary, so as to comply with requirements of the Center for Medicare/Medicaid Services.

A method for validating user identification includes the steps of: guiding a user to input a user ID through a login interface; comparing the user ID with original identifications stored in a database (40) and determining whether the user ID matches one of the original identifications; sending validation information to a mobile phone number corresponding to the original identification; updating an original password, corresponding to the original identification, according to the validation information; running a validation program, installed in a mobile phone having the mobile phone number, to decrypt the validation information, and generating a validation result as a login password; inputting the login password through the login interface, and transmitting the inputted login password to an application server (30); and determining whether the inputted login password is the same as the updated password. A system for validating user identification is also provided.

In a mass flow controller verifying system, there are provided a verifying gas line arranged in parallel to influent flow gas lines and joined into a post-confluent flow gas line, a reference volume calculating portion adapted to calculate a reference volume determined for a specified piping of a gas piping system, a verifying parameter calculating portion adapted to calculate a verifying parameter based on time series data of a measurement pressure measured by a pressure measurement unit during a control of a flow rate by a mass flow controller to be verified, and a comparing portion adapted to compare a reference parameter set based on the reference volume and the verifying parameter, whereby the verifying system can be introduced into an existing gas piping system used in a semiconductor manufacturing process and so forth at a low cost and is capable of verifying a mass flow controller quickly and accurately.

A method and system usable in sensor networks for handling memory faults is disclosed. In order to protect the operating system of a sensor node, coarse-grained memory protection is provided by creating and enforcing an application fault domain in the data memory address space of the sensor node. The data memory accessed by the application modules is restricted to the region (which defines the application fault domain) within the data memory address space. The application modules are prevented from accessing memory outside the application fault domain through software-based run-time checks. The state belonging to the operations system is maintained outside of the application fault domain, and is thus protected from memory corruption from any application module. In order to ensure that an application module does not operate on a corrupted state, fine-grained error detection and recovery is provided within the application fault domain. Any corruption of memory within the application fault domain is detected by a run-time memory integrity verifier implemented in the operating system kernel. Recovery involves purging the corrupted state and restarting only the affected application module to operate on an uncorrupted state.

A method for protecting an item of software, wherein at least one challenge is associated with the protected item of software, and at least one response accesses one private keying material. The challenge has no access to the private keying material. The challenge and the response are generating shared secret information, respectively, in accordance with an asymmetric confidentiality scheme. The response proves that it discovered the shared secret and the challenge validates the proof. The challenge proof validation procedure uses the public keying material that corresponds to the response private keying material.

A method and apparatus are used in accordance with the present invention in concurrent program analysis for detecting potential race conditions such as data races in computer programs. A feature of the method and apparatus of the present invention is verifying annotations of addressable resources in a program. The present invention verifies annotations by checking if thread-local resources are indeed thread-local, and that thread-shared data spaces are not in fact thread-local. In accordance with the purpose of the invention, the method provides for detecting potential race conditions, such as data races, in a computer program. The computer program can spawn a plurality of threads that are capable of being executed concurrently. The method includes receiving a source code of the computer program. The source code includes an element annotated as either thread-local or thread-shared. The method also includes verifying the validity of the thread-local annotation if the element is annotated in the computer program as thread-local, wherein an invalid thread-local annotation may cause a race condition. The method can further include indicating a potential race condition if upon verifying the validity of the thread-local annotation it is determined that the element or a portion thereof is visible from more than one, rather than one and only one, of the plurality of threads. In further accordance with the purpose of the invention, the apparatus for concurrent program analysis includes means for receiving source code of the computer program. The source code includes an element annotated as either thread-local or thread-shared. The apparatus also includes means for type checking the source code; and means for thread-local checking located either inside or in series with the type checking means. The means for thread-local checking includes means for verifying the validity of the thread-local annotation if the element is annotated in the computer program as thread-local, where an invalid thread-local annotation may cause a race condition such as a data race. The apparatus can further include means for parsing the source code; and means for creating from the source code an abstract syntax tree. Accordingly, the present invention beneficially provides for a more effective concurrent program analysis.

A program verification apparatus includes a storing which stores a plurality of statements in correspondence with values of respective risk levels of the statements. Referring to a signature included in a signed module, a value indicating a risk level of the signed module is obtained. A to-be-verified program including a plurality of statements or signed modules is input to the apparatus. Values of first risk levels of the statements included in the to-be-verified program are determined by referring to the storing device. Values of second risk levels of the signed modules included in the to-be-verified program are also determined. Then, a maximum value of a risk level of the to-be-verified program is calculated from the values of the first risk levels and the values of the second risk levels. A verification result including the maximum value of the risk level is outputted accordingly.

The invention provides a correctness verifying method of a cache consistency protocol. After a computer enters an operating system, the complexity of a core and the application of the operating system is higher; the action of a processor is not easy to control accurately; therefore, in order to keep verification correctness, a verifying program for the cache consistency protocol is necessary to embed in a systematic procedure; the program is embedded in a BIOS (basic input/output system) code; after the initialization of a memory subsystem is completed at the initialization initial stage of the system, the verifying program is started to be executed; the verifying program needs to be capable of accurately controlling actions of each processor of the system, supports a user to select a verification item to be particularly executed, and feeds back a verification result to the user; by using the method, the verification of the correctness of the cache consistency protocol is realized at a system level; all application scenes of a real system can be completely covered; the disadvantages that a conventional verifying method based on an analog way is low in efficiency and poor in verification coverage rate are made up; the design period and the verifying period of an inter-domain cache consistency chip of the processor can be shortened; the one-time taping-out mission success rate of the chip can be guaranteed effectively; and therefore, the correctness verifying method has an extremely wide development prospect and an extremely high technical value.