The present invention generally relates to the field of memory architectures, hardware and software, and methods for operating on, manipulating and/or processing encrypted and/or hidden information (e.g., software code and/or data). More specifically, embodiments of the present invention pertain to a processor memory architecture and method for interpreting, translating, performing operations on and/or executing hidden and/or encrypted code and/or data.
Embodiments of the present invention relate to a processor memory architecture, system and method for operating on encrypted and/or hidden information. (In general, the phrases “operating on” and/or “performing [an] operation[s] on” refer to standard and/or conventional methods of operating on, manipulating, executing and/or processing code or data, and the term “encrypted” refers to standard and/or conventional techniques and/or software programs for encrypting, ciphering, transmuting, translating, converting and/or scrambling information from a plain text or conventionally recognizable graphics or other common form into a form designed, adapted or configured to prevent, deter, hinder or inhibit interception, deciphering, reading; comprehension and/or understanding by unauthorized parties.) In one embodiment of the present invention, the architecture enables storing encrypted information (e.g., software code and/or data) in unprotected (e.g., user-accessible) memory, while operating on an unencrypted form of this information only in protected (e.g., user-inaccessible) memory. In a further exemplary embodiment, the present invention provides a scheme for efficiently hiding proprietary information in a system, architecture and/or process that converts information from a non-proprietary format or ISA into a proprietary format or ISA.
The present invention advantageously allows manufacturers of peripheral devices, electronic systems, etc. (e.g., original equipment manufacturers, or OEMs), to extend their shipping systems with encrypted code (e.g., x86-compatible instructions), and/or extend their systems with hidden proprietary intellectual property (e.g., binary code, data, etc.). Some OEMs, for example, have x86-compatible software that has value as a trade secret. In some cases, the OEMs embed their algorithm(s) in a custom chip (e.g., an ASIC, a ROM, flash memory, etc.). It is therefore desirable to keep proprietary code hidden from unprotected (e.g., x86) memory space.
Another advantage of the invention includes providing an ability to perform operations on hidden proprietary information, so that it is not visible to other non-proprietary (e.g., x86-compatible) processes in plain text form during normal system operations, and so that it does not appear in plain text form in unprotected or accessible (e.g., x86) memory/memory space or on disk. These and other advantages of the present invention will become readily apparent from the detailed description of preferred embodiments below.
Reference will now be made in detail to the preferred embodiments of the invention, examples of which are illustrated in the accompanying drawings. While the invention will be described in conjunction with the preferred embodiments, it will be understood that they are not intended to limit the invention to these embodiments. On the contrary, the invention is intended to cover alternatives, modifications and equivalents, which may be included within the spirit and scope of the invention as defined by the appended claims. Furthermore, in the following detailed description of the present invention, numerous specific details are set forth in order to provide a thorough understanding of the present invention. However, it will be readily apparent to one skilled in the art that the present invention may be practiced without these specific details. In other instances, well-known methods, procedures, components, and circuits have not been described in detail so as not to unnecessarily obscure aspects of the present invention.
Some portions of the detailed descriptions which follow are presented in terms of procedures, logic blocks, processing, and other symbolic representations of operations on data bits within a computer, processor, controller and/or memory. These descriptions and representations are the means generally used by those skilled in data processing arts to effectively convey the substance of their work to others skilled in the art. A procedure, logic block, process, etc., is herein, and is generally, conceived to be a self-consistent sequence of steps or instructions leading to a desired result. The steps include physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical, magnetic, optical, or quantum signals capable of being stored, transferred, combined, compared, and otherwise manipulated in a computer system. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.
It should be borne in mind, however, that all of these and similar terms are associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the following discussions, it is appreciated that throughout the present application, discussions utilizing terms such as “processing,” “operating,” “computing,” “calculating,” “determining,” “displaying” or the like, refer to the action and processes of a computer system, or similar processing device (e.g., an electrical, optical, or quantum computing device), that manipulates and transforms data represented as physical (e.g., electronic) quantities. The terms refer to actions and processes of the processing devices that manipulate or transform physical quantities within a computer system's component (e.g., registers, memories, other such information storage, transmission or display devices, etc.) into other data similarly represented as physical quantities within other components.
The present invention concerns an architecture, method and system for manipulating, hiding, executing and/or operating on hidden and/or encrypted information (e.g., code and/or data). In one aspect of the invention, the architecture comprises an unprotected memory space configured to store encrypted information, a first protected memory space configured to store at least part of a set of operating system instructions, and a second protected memory space configured to store a plain text (decrypted) version of the encrypted information, wherein the operating system instructions in the first protected memory space operate on the decrypted information in the second protected memory space.
In another aspect of the invention, the system comprises a processor and the above memory architecture, where the processor is configured to execute the operating system instructions.
In a further aspect of the invention, the method comprises the steps of (a) transferring encrypted and/or hidden information to a first protected memory address inaccessible to a user-accessible software program, but accessible to an operating system instruction set; (b) decrypting the encrypted information to form a decrypted version thereof; and (c) storing the first protected memory address in a second protected memory address inaccessible to a user-accessible software program, but accessible to an operating system instruction set, where the second protected memory address is linked to an original location of the encrypted and/or hidden information.
The invention further relates to hardware and/or software implementations of the present architecture, method and system. The invention, in its various aspects, will be explained in greater detail below with regard to preferred embodiments.
Still referring to
In certain preferred embodiments, the processor 11 executes software that translates and/or interprets instructions and/or code (hereinafter, “code”) from a first conventional and/or non-proprietary instruction set architecture (“ISA”) or format (e.g., x86 or CISC, RISC, SPARC, etc.) into a second, optionally proprietary, ISA or format (e.g., a Very Long Instruction Word format employed in certain CRUSOE® processors, commercially available from Transmeta Corporation, Santa Clara, Calif.). One conventional tool for such instruction interpretation and translation is CODE MORPHING™ software, or CMS™, tool and/or architecture (also available from Transmeta Corporation, Santa Clara, Calif. on certain of its CRUSOE® processors). Consequently, a further aspect of the invention relates to a software tool configured to manage memory resources in system/architecture 10, preferably one having an ability to programmably allocate and/or partition memory resources to various different functions (e.g., unprotected/accessible memory, protected memory in which information is hidden to user-accessible programs and/or object code, private memory as described herein, etc.) within memory space 100 in system/architecture 10, such as that in the CMS tool. Thus, the size of each of the various memories within memory space 100 may be programmable and may be changed according to changes in design or performance criteria. The present invention provides particular advantage in systems and/or architectures employing instruction and/or code interpretation and/or translation and/or memory management.
In general, encrypted and or proprietary information may be stored in any part of memory 100. Preferably, however, proprietary information is stored in unencrypted form only in protected memory 104. Also, preferably, encrypted information in unprotected memory 102 is unencrypted, then stored in protected memory 104 prior to execution and/or operation on it by processor 11.
In some cases, it is more desirable to hide proprietary data than to hide the code that operates on such data. The present invention advantageously provides a mechanism for hiding proprietary data in protected memory (e.g., memory the addresses of which are protected [preferably by hardware] from user and/or software access), so that it is not visible either (a) in plain text or recognizable form from unprotected memory, or (b) to non-proprietary, conventional and/or untranslated software-controlled processes. The proprietary data may be stored in a protected buffer (e.g., register bank having an address requiring authorization or authentication before access thereto is allowed), and it may be accessed through instructions to load the proprietary information from (or store it to) a form of protected memory, identified herein as “private” memory. (In the present application, “memory” also refers to addressable memory space, regardless of the physical form such memory space takes.) In general, only authorized processes may execute instructions to load or store information (preferably encrypted and/or proprietary) in or from private memory. In one embodiment, an unauthorized process (e.g., instruction execution) will perform a “no operation,” or NOP, instruction in place of any unauthorized load or store operation that attempts to access private memory.
Referring back to
In one embodiment, the invention further includes new “load x” and “store x” instructions that proved authorized access to encrypted and/or proprietary information. These “load x” and “store x” instructions read from and write to a plaintext copy of proprietary (or otherwise decrypted) information stored in a protected memory buffer. “Load x” and “store x” instructions can execute only in an authorized process; unauthorized execution will perform a “no operation,” or NOP, instruction in place of an unauthorized “load x” or “store x” operation that attempts to access protected memory where the plaintext copy is stored (preferably, in private memory 200).
Referring to both
As shown in
At the time of manufacture, an OEM generally encrypts the table 300 and stores it in a ROM (e.g., ROM 12 in
After booting the system, an unprotected program (e.g., including a driver in unprotected memory 102) loads the encrypted data file 202 (or page[s] thereof) into protected memory 106 using an MSR interface (i.e., standard “Model Specific Registers,” which may be used to extend an x86 architecture as is known in the art). Alternatively, instructions may be added to the operating system for performing this function, or one or more virtual devices may be added to the north bridge of system/architecture 10 (not shown) to perform this function.
Operating system software (e.g., for interpreting and/or translating information in unprotected memory, such as the CMS tool from Transmeta Corp.) checks the encrypted data to determine whether the message digest matches a message digest in the configuration table(s). If so, decryption software (which may be stored in unprotected or protected memory) decrypts the data using the decryption key stored in protected memory or on ROM by the OEM, and stores the plain text version in a buffer 206 allocated in private memory 200. Alternatively, the configuration table and/or trusted page list can be encrypted, stored on disk and brought into protected memory 104 after boot in the same manner described above for protected proprietary data. Authorized “load x” (e.g., LDX) and/or “store x” (e.g., STX) instructions (e.g., instruction 204 stored within file 202) access the buffer 206. Unauthorized LDX/STX instructions (i.e., an LDX/STX instruction in a file for which no key is present in a configuration table and/or trusted page list) perform NOPs instead of LDX/STX instructions.
In the simplest implementation, pages of programs containing authorized “load x” and/or “store x” instructions are authorized using a one-way hash (e.g., SHA-1 hashing). However, any unique identifier (within statistical significance) for the page, or even the entire program, may be used to authorize the page and/or program. Although the term “page” is used extensively herein to refer to a unit of memory of known size and configuration (e.g., depth and width), any similar term or configuration of memory may be applied to the present invention (e.g., block, number of bytes, packet, etc.). Code from one (or more, but preferably just one page) of such program pages is compiled, hashed and linked so that it loads at a fixed or known address in private memory 200. In one example, the page size is 4 kb, and the SHA-1 hash is about 160 bits long. However, within design criteria and/or constraints (e.g., the size and allocations of ROM memory), the invention is implementable with any memory unit or page size (but preferably ≧1 kb and ≦1 Mb) and any hash length that is sufficiently long to render it infeasible for another page to hash to the same value (and that is, e.g., ≧16 bits and ≦100 bytes long).
Alternatively, one may hash the first X bytes of an encrypted page (where X is a number of from 1 to 2q, preferably from 2m to 2n, where q is an integer of from 5 to 10, m is an integer of from 2 to 4, and n is an integer of from 4 to 8) and determine whether that partial hash matches the corresponding portion of any of the keys in table 300 (in which case table 300 should also include a field for storing partial page hashes). If so, the hash for the entire encrypted page may be taken, and key matching performed as described above. This technique may reduce the overhead associated with full hashing of entire pages of encrypted information. Also, the hash for the entire proprietary program may be taken and stored to authorize the entire program, but one may trade off higher key granularity (preferable where only a certain subset of pages of the program are used extensively) for fewer hashing and decrypting operations. Furthermore, one may take a hash for one or more pages of proprietary information within a proprietary program may function as a key for the entire program, but this is less preferred due to the potential for uncertainty among various versions of the same program.
Preferably, the pages containing LDX/STX operations are read-only, are not modified at load time, and are stored in unprotected memory at a fixed or known address. However, it is certainly within the scope of the invention to encompass applications including self-modifying code, updated code and/or code that may be moved or transferred from a first address to a second (or further) address according to application criteria.
In this embodiment, the pages to be authorized have their SHA-1 hash recorded at manufacturing. The SHA-1 hashes are saved on disk and encrypted using the key. At boot, the SHA-1 hashes are passed to decrypting, interpreting and/or translating software, decrypted, and stored in protected memory (preferably in ROM 12). The operating system (e.g., interpreter/translator) software verifies that any instance of LDX/STX is on a page the SHA-1 hash of which appears in the authorized page list in protected memory.
To hide proprietary code, the present invention is adapted to support direct execution of encrypted code from unprotected memory space. Code pages to be stored in unprotected memory space 102 will be encrypted using an appropriate key at the time of manufacturing. As described above, in one embodiment, encrypted pages will be identified by a list of their SHA-1 hashes (see
During execution, when processor 11 fetches an encrypted page (or system 10 “enters” the page) from unprotected memory 102, its SHA-1 hash will be looked up in table 300. If the hash 302 is found, but the decrypted information pointer 304 (i.e., the address/location in protected and/or private memory where the decrypted information can be found) is vacant, the page is decrypted, its plain text version is stored in protected and/or private memory, and the SHA-1 entry is marked present and associated with the plain text page at its address in protected memory. Execution (e.g., interpretation, translation and/or other operations) continues on the plain text copy stored in protected and/or private memory. (In a preferred embodiment, decrypted information is stored in private memory 200, then the operating system interprets and translates the decrypted information into a proprietary format or ISA and stores the interpreted and translated information in translation cache 108, before the information is further operated on.) Consequently, two sets of interpreting software may be necessary (one for interpreting code in unprotected memory, the other for interpreting code in protected memory).
As is known in the art and as described above, one may do partial or full hashing. For example, one may hash the first X bytes of code and/or data in an encrypted page in unprotected memory 102 (where X is as described above; in one embodiment, X is 16). If the partial hash matches a partial-hash entry in table 300, the remainder of the encrypted page can be fully hashed, and if the full hash matches a full-hash entry in table 300, the encrypted page can be loaded into protected memory, decrypted, and operated on. Partial hashing may require an appropriate set of software tools for implementation; e.g., in addition to the above, a tool that prohibits instructions that cross page boundaries (e.g., to avoid mixing encrypted and plain text code or data), etc.
Alternatively, one may simply store the hash of the encrypted page in a known location or encrypt a portion of a page (e.g., substantially all of the page except for its [unencrypted] hash), rather than take the hash of each page of encrypted information each time it is accessed. For example, the SHA-1 hash for a 4 Kbytes page is 20 bytes long. If the first 20 bytes of the page is its SHA-1 hash, and the remaining (4K−20) bytes are encrypted, then the hashing operation can be avoided when the page is accessed. One may simply try to match the first 20 bytes of a 4K page with entries in the table. If no match is found, the page does not contain encrypted code or data. If a match is found, to avoid potential errors such as false positives, one should still hash the remaining (4K−20) bytes and verify that the hash matches the first 20 bytes in the page. This alternative embodiment may also require appropriate software rules, such as a rule prohibiting instructions across page boundaries.
Advantageously, however, operating system software (and preferably, translation and/or interpretation code) rules further include, when operating on encrypted and/or hidden code, (i) disabling instruction breakpoints and (ii) disabling execution of single steps. These rules render single stepping through encrypted information impossible, thereby further inhibiting software (and certain types of hardware) accesses to the encrypted information.
In addition, one may employ a page locating mechanism conceptually similar to the hashing scheme described above. When an encrypted page authorized to perform LDX/STX instructions is accessed (e.g., in the TLB miss path or other point in the system memory hierarchy when a page access is performed) for the first time after boot up, rather than hashing the encrypted page, the encrypted page is simply decrypted and stored in private memory 200. The address of the decrypted (plain text) page in private memory 200 is stored in the “Pointer” column of table 300, and is linked to the address of the encrypted page in unprotected memory 102 stored in the “SHA-1” column of table 300, so that the operating system of system/architecture 10 can locate and operate on the plain text code and/or data in protected memory. (In such an embodiment, the “SHA-1” column would be appropriately relabeled “Encrypted Information Address,” “Disk Address,” etc.) Thereafter, in further accesses of the authorized encrypted page, the operating system looks up the address(es) in table 300, then operates directly on the decrypted/hidden information stored in protected memory identified in table 300. This embodiment retains the essence of the other embodiments described above, in which a unique identifier links, or is otherwise associated with, both encrypted information in unprotected memory and a location or address in protected memory for the corresponding decrypted and/or hidden information.
The present invention also enables combining hidden code and data, so that hidden data can only be accessed from encrypted pages.
Constraints on the present scheme include a maximum size of encrypted pages that must fit in protected memory 106. A typical upper-bound on this size is 16 MB, but of course, this size can be adjusted or even programmed, according to design. Furthermore, encrypted pages should be read-only and should not be modified during load operations. Furthermore, encrypted code and data should always load at the same linear address. In addition, encrypted pages of code preferably should not contain data, since there may be inefficiencies in existing software tools to redirect a load operation from an encrypted page to the plain text copy stored in protected memory.
Including and/or incorporating the encrypted proprietary information, the encrypted or unencrypted configuration table/trusted page list, and decryption key in system/architecture 10 generally comprise steps 415 and 420 of
In step 425, system/architecture 10 determines whether it is to operate on the encrypted information stored in unprotected memory 102. If not, the operating system in system/architecture 10 in step 435 determines whether loading and/or storing instructions are being executed. If such instructions are not being executed (and/or are not in an instruction queue for execution), the architecture/system 10 and operating system continue normal processing in step 440, as encrypted information is not being operated on.
However, if load x and/or store x instructions are being executed (and/or are in a queue to be executed), the operating system then calculates the page hash for the encrypted page associated with the loading and/or storing instructions being executed. In step 450, that hash is compared with the hashes in a corresponding configuration table that stores authorized hashes for that encrypted information. If the calculated hash matches an authorized hash, in step 460, the load x/store x instruction is allowed to execute and to access the plaintext version of the encrypted data stored (in one embodiment) in protected buffer 206, and the system/architecture 10 and operating system continue normal processing in step 440. If the calculated hash does not match any authorized hash, the operating system executes a “no operation” instruction, effectively aborting the load/store instructions.
Referring back to step 425 in
Decryption could happen as early as when encrypted information pages are first loaded into unprotected memory (e.g., by keeping a shadow plain text copy in protected and/or private memory), or as late as when bytes are fetched by an appropriate operating system tool (such as an interpreter or [pre]fetcher; this may be considered to be an “on demand” scheme). In one implementation, decryption is performed on demand when pages are first accessed by an operating system tool, instruction and/or operation (and in a preferred embodiment, the tool is an interpreter), and a cache of the corresponding plain text pages is kept in protected memory.
Although specific steps are disclosed in process 400 of
In
The once-XORed, encrypted proprietary information 506a, 506b and/or 506c (“506x”) may then be stored in unprotected memory 102 (preferably on disk 510), and there may be as many pages of encrypted proprietary information stored in unprotected memory 102 as may fit therein. A configuration table (similar to that shown in
A once-XORed, encrypted page 506x is decrypted by a subsequent XOR operation with the corresponding random bit page 504x to obtain decrypted proprietary information 508x (which is identical to the original proprietary information 502x). To avoid any need to store a plain text version of the encrypted page, the second XOR operation may be done on demand by XORing the encrypted bytes with the associated bytes located at the same offset within the page of random bits 504x corresponding to the current encrypted page 506x. This decryption operation occurs before (preferably as soon as possible before) execution of decrypted proprietary information 508x in private memory 200 and/or protected memory 104. Thus, pages of random bits 504x serve as a decryption tool, much like the hash or decryption key described above.
Thus, the present invention provides a convenient, simple and efficient architecture, method and system for operating on hidden and/or encrypted information. If and/or when combined with an effective technique for preventing and/or inhibiting physical access to decrypted and/or hidden code (e.g., by removing a ROM, cache memory, or microprocessor IC from its board, removing the cap/top packaging materials, delayering the device, and using known reverse engineering techniques to determine the states of various memory bits/circuits thereon), one may completely prevent or effectively inhibit access to hidden code and/or plain text versions of encrypted code and/or data (which, as described herein, is kept hidden from software access by the present method, system and memory architecture).
The foregoing descriptions of specific embodiments of the present invention have been presented for purposes of illustration and description. They are not intended to be exhaustive or to limit the invention to the precise forms disclosed, and obviously many modifications and variations are possible in light of the above teaching. The embodiments were chosen and described in order to best explain the principles of the invention and its practical application, to thereby enable others skilled in the art to best utilize the invention and various embodiments with various modifications as are suited to the particular use contemplated. It is intended that the scope of the invention be defined by the Claims appended hereto and their equivalents.
Number | Name | Date | Kind |
---|---|---|---|
4634804 | Spalding | Jan 1987 | A |
4634807 | Chorley et al. | Jan 1987 | A |
4941176 | Matyas et al. | Jul 1990 | A |
5034980 | Kubota | Jul 1991 | A |
5343524 | Mu et al. | Aug 1994 | A |
5511123 | Adams | Apr 1996 | A |
5530753 | Easter et al. | Jun 1996 | A |
5563950 | Easter et al. | Oct 1996 | A |
5623637 | Jones et al. | Apr 1997 | A |
5696823 | Blaze | Dec 1997 | A |
5748744 | Levy et al. | May 1998 | A |
5774544 | Lee et al. | Jun 1998 | A |
5835594 | Albrecht et al. | Nov 1998 | A |
5878210 | Kong | Mar 1999 | A |
5896522 | Ward et al. | Apr 1999 | A |
5933497 | Beetcher et al. | Aug 1999 | A |
5991399 | Graunke et al. | Nov 1999 | A |
6011908 | Wing et al. | Jan 2000 | A |
6023506 | Ote et al. | Feb 2000 | A |
6031992 | Cmelik et al. | Feb 2000 | A |
6038320 | Miller | Mar 2000 | A |
6044157 | Uesaka et al. | Mar 2000 | A |
6061449 | Candelore et al. | May 2000 | A |
6172990 | Deb et al. | Jan 2001 | B1 |
6175896 | Bui | Jan 2001 | B1 |
6199152 | Kelly et al. | Mar 2001 | B1 |
6249782 | Wildgrube et al. | Jun 2001 | B1 |
6292874 | Barnett | Sep 2001 | B1 |
6327660 | Patel | Dec 2001 | B1 |
6363486 | Knapton, III | Mar 2002 | B1 |
6401208 | Davis et al. | Jun 2002 | B2 |
6408376 | Ganapathy et al. | Jun 2002 | B1 |
6415379 | Keppel et al. | Jul 2002 | B1 |
6453233 | Kato | Sep 2002 | B1 |
6457171 | Mann et al. | Sep 2002 | B1 |
6463535 | Drews | Oct 2002 | B1 |
6507904 | Ellison | Jan 2003 | B1 |
6510521 | Albrecht et al. | Jan 2003 | B1 |
6523118 | Buer | Feb 2003 | B1 |
6587949 | Steinberg | Jul 2003 | B1 |
6587979 | Kraus et al. | Jul 2003 | B1 |
6598165 | Galasso | Jul 2003 | B1 |
6633963 | Ellison et al. | Oct 2003 | B1 |
6675298 | Folmsbee | Jan 2004 | B1 |
6704872 | Okada | Mar 2004 | B1 |
6802006 | Bodrov | Oct 2004 | B1 |
6910094 | Eslinger et al. | Jun 2005 | B1 |
6983374 | Hashimoto et al. | Jan 2006 | B2 |
6986052 | Mittal | Jan 2006 | B1 |
7062769 | Ma et al. | Jun 2006 | B1 |
7082615 | Ellison et al. | Jul 2006 | B1 |
7096370 | Klein | Aug 2006 | B1 |
7185192 | Kahn | Feb 2007 | B1 |
7191344 | Lin et al. | Mar 2007 | B2 |
7225333 | Peinado et al. | May 2007 | B2 |
7236956 | Ogg et al. | Jun 2007 | B1 |
7360097 | Rothstein | Apr 2008 | B2 |
20010019559 | Handler et al. | Sep 2001 | A1 |
20020002654 | Tomohiro | Jan 2002 | A1 |
20020040436 | Davis et al. | Apr 2002 | A1 |
20020107856 | Scheussler et al. | Aug 2002 | A1 |
20020157015 | Gilbert et al. | Oct 2002 | A1 |
20030021417 | Vasic et al. | Jan 2003 | A1 |
20030041221 | Okada | Feb 2003 | A1 |
20030056092 | Edgett et al. | Mar 2003 | A1 |
20030061598 | Karp et al. | Mar 2003 | A1 |
20030120745 | Katagishi et al. | Jun 2003 | A1 |
20030126453 | Glew et al. | Jul 2003 | A1 |
20030126454 | Glew et al. | Jul 2003 | A1 |
20030142554 | Green et al. | Jul 2003 | A1 |
20030172265 | Vu et al. | Sep 2003 | A1 |
20030177373 | Moyer et al. | Sep 2003 | A1 |
20030182569 | Matsuzaki et al. | Sep 2003 | A1 |
20040005061 | Buer et al. | Jan 2004 | A1 |
20040015694 | DeTreville | Jan 2004 | A1 |
20040026036 | Shimeno et al. | Feb 2004 | A1 |
20040039925 | McMillan et al. | Feb 2004 | A1 |
20040098591 | Fahrny | May 2004 | A1 |
20040107344 | Minemura et al. | Jun 2004 | A1 |
20040243823 | Moyer et al. | Dec 2004 | A1 |
20050025091 | Patel et al. | Feb 2005 | A1 |
20050055311 | Kosaki | Mar 2005 | A1 |
20050071651 | Aguilar, Jr. et al. | Mar 2005 | A1 |
20050180752 | Nakagawa | Aug 2005 | A1 |
Number | Date | Country |
---|---|---|
03029939 | Apr 2003 | WO |