Abstract:
A method, apparatus, and article of manufacture for protecting a shelled computer program with a startup code featuring multiple-route execution. In one embodiment, the startup code comprises a sequence of tasks, collectively executing a startup code, wherein one or more of the tasks is selectably performed by one of a plurality of task code variations as selected by a selection code associated with the task.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS  
       [0001]    This application claims benefit of U.S. Provisional Patent Application No. 60/449,911, entitled “SOFTWARE PROTECTION METHOD WITH MULTIPLE-ROUTE EXECUTION,” by Laszlo Elteto, filed Feb. 25, 2003, which application is hereby incorporated by reference herein. 
     
    
     
       BACKGROUND OF THE INVENTION  
         [0002]    1. Field of the Invention  
           [0003]    The present invention relates to systems and methods for protecting software from unauthorized copying and/or execution, and in particular to a system and method that protects software via multiple-route execution.  
           [0004]    2. Description of the Related Art  
           [0005]    Software piracy is a long-standing problem for software developers. Many techniques for discouraging software privacy have been developed. Products are available for those who lack either the time or the specialized expertise to secure their software applications from unauthorized copying and/or use (such products are available from RAINBOW TECHNOLOGIES, INC, the assignee of the present invention). Such products use software protection techniques that can be categorized into two forms: link-in object modules and shelling technology.  
           [0006]    Link-in modules require that the developer modify the software code to call specific functions that check for license conditions. Consequently, this technique is sometimes referred to as “manual” protection.  
           [0007]    Shelling does not require code changes, and is therefore easier for the software developer to implement. With the shelling technique, a shell process reads the application and produces a modified, new executable which contains an outer layer of protection code (with the original executable code usually encrypted inside). This method is often called “automatic” protection.  
           [0008]    The problem with shelling is that the software program is protected only by the outer layer of protection. Consequently, a hacker can gain access to the protected application “just” by cracking the outer layer of protection. Because this protection code executes before the original application code starts, it usually runs in a fixed, known pattern. A cracker can follow the code execution (for example, by running it under a debugger), and once the code execution sequence is understood, the cracker can modify the code (for example, by patching the executable) to bypass/disable license checking.  
           [0009]    What is needed is a software shelling technique that resists cracking. The present invention satisfies that need.  
         SUMMARY OF THE INVENTION  
         [0010]    To address the requirements described above, the present invention discloses a method, apparatus, article of manufacture for protecting a shelled computer program.  
           [0011]    In one embodiment, the startup code comprises a sequence of tasks, collectively executing a startup code, wherein one or more of the tasks is selectably performed by one of a plurality of task code variations as selected by a selection code associated with the task. In another embodiment, the startup code comprises a plurality N of startup code tasks T 1 , T 2 , . . . , T N  to be performed to execute the startup code; a plurality K of startup task code variations T i,1 , T i,2 , . . . , T i,K  for at least one T i  of the plurality startup code tasks T 1 , T 2 , . . . , T N ; and a selection routine S i  for the at least one T i  of the plurality of startup code tasks T 1 , T 2 , . . . , T N , the selection routine S i  for selecting at least one T i,j  of the K plurality of code variations T i,1 , T i,2 , . . . , T i,K  from among the plurality of code variations T i,1 , T i,2 , . . . , T i,K .  
           [0012]    The method comprises the steps of generating a plurality N of startup task routines T 1 , T 2 , . . . , T N  collectively forming the startup code; generating a plurality K of startup task routine variations T i,1 , T i,2 , . . . , T i,K  for a chosen startup task routine T i  of the startup task routines T 1 , T 2 , . . . , T N ; generating a selection routine S i  for the chosen startup task routine T i  of the startup task routines T 1 , T 2 , . . . , T N , each selection routine S i  for selecting at least one of the startup task code variations T i,1 , T i,2 , . . . , T i,K  to perform the chosen startup task routine T i ; and assembling the secure startup code as a combination of the plurality of task routines T 1 , T 2 , . . . , T N  for the unchosen ones of the plurality of task routines, and the selection routine S i  and plurality of task routine variations T i,1 , T i,2 , . . . , T i,K  for each of the chosen task routine T i  of the plurality task routines T 1 , T 2 , . . . , T N .  
           [0013]    In another embodiment, the method comprises the steps of selecting a startup task code variation from among a plurality of startup task code variations, each startup code task variation performing a startup code task differently than the other startup code task variations, the startup code task belonging to a sequence of startup code tasks collectively performing the startup code; and executing the selected startup task code variation.  
           [0014]    The article of manufacture comprises a data storage device tangibly embodying instructions to perform the methods described above.  
           [0015]    The foregoing creates multiple execution paths within the startup code, thus requiring a cracker to step through the startup code a large number of times to exercise each execution path so that the entire startup code can be characterized. Thus, the cracker must examine much more code and would have to disable multiple points of license checking. This greatly increases the time and effort that must be devoted to cracking the startup code, and will deter many crackers from tampering with protected programs. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0016]    Referring now to the drawings in which like reference numbers represent corresponding parts throughout:  
         [0017]    [0017]FIG. 1 is a block diagram showing an exemplary hardware environment for practicing the present invention;  
         [0018]    [0018]FIG. 2 is a diagram illustrating an exemplary shelling process used to protect a software application; and  
         [0019]    [0019]FIG. 3 is a diagram illustrating how a software application protected by the shelling process illustrated in FIG. 2 can be executed;  
         [0020]    [0020]FIG. 4 is a diagram presenting exemplary method steps used to generate a multiple-execution path startup code;  
         [0021]    [0021]FIG. 5 is a diagram illustrating an exemplary unprotected startup code;  
         [0022]    [0022]FIG. 6 is a diagram illustrating the operation and structure of one embodiment of the multiple execution path startup code;  
         [0023]    [0023]FIG. 7 is a flow chart illustrating another embodiment of the present invention, in which single decision points implemented by selection routines are avoided;  
         [0024]    [0024]FIG. 8 is a diagram illustrating the structure of the protected startup code created, for example, by performing the technique shown in FIG. 7; and  
         [0025]    [0025]FIG. 9 is a flow chart illustrating the operation of one embodiment of the completed startup code.  
     
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS  
       [0026]    In the following description, reference is made to the accompanying drawings which form a part hereof, and which is shown, by way of illustration, several embodiments of the present invention. It is understood that other embodiments may be utilized and structural changes may be made without departing from the scope of the present invention.  
       Hardware Environment  
       [0027]    [0027]FIG. 1 illustrates an exemplary computer system  100  that could be used to implement the present invention. The computer  102  comprises a processor  104  and a memory, such as random access memory (RAM)  106 . The computer  102  is operatively coupled to a display  122 , which presents images such as windows to the user on a graphical user interface  118 B. The computer  102  maybe coupled to other devices, such as a keyboard  114 , a mouse device  116 , a printer, etc. Of course, those skilled in the art will recognize that any combination of the above components, or any number of different components, peripherals, and other devices, maybe used with the computer  102 .  
         [0028]    Generally, the computer  102  operates under control of an operating system  108  stored in the memory  106 , and interfaces with the user to accept inputs and commands and to present results through a graphical user interface (GUI) module  118 A. Although the GUI module  118 A is depicted as a separate module, the instructions performing the GUI functions can be resident or distributed in the operating system  108 , the computer program  110 , or implemented with special purpose memory and processors. The computer  102  also implements a compiler  112  which allows an application program  110  written in a programming language such as COBOL, C++, FORTRAN, or other language to be translated into processor  104  readable code. After completion, the application  110  accesses and manipulates data stored in the memory  106  of the computer  102  using the relationships and logic that was generated using the compiler  112 . The computer  102  also optionally comprises an external communication device such as a modem, satellite link, Ethernet card, or other device for communicating with other computers.  
         [0029]    In one embodiment, instructions implementing the operating system  108 , the computer program  110 , and the compiler  112  are tangibly embodied in a computer-readable medium, e.g., data storage device  120 , which could include one or more fixed or removable data storage devices, such as a zip drive, floppy disc drive  124 , hard drive, CD-ROM drive, tape drive, etc. Further, the operating system  108  and the computer program  110  are comprised of instructions which, when read and executed by the computer  102 , causes the computer  102  to perform the steps necessary to implement and/or use the present invention. Computer program  110  and/or operating instructions may also be tangibly embodied in memory  106  and/or data communications devices  130 , thereby making a computer program product or article of manufacture according to the invention. As such, the terms “article of manufacture,” “program storage device” and “computer program product” as used herein are intended to encompass a computer program accessible from any computer readable device or media.  
         [0030]    In one embodiment, the computer system  100  includes removably coupleable a hardware security module (HSM) such as a dongle, or hardware key  140 . The HSM  140  is used to prevent unauthorized access to the computer  102  and/or the application programs  110 . This can be accomplished by one or more of a variety of software protection paradigms. These could include, for example, a challenge-response protocol or other software protection techniques known in the art, including those disclosed in U.S. Pat. No. 6,523,119, issued Feb. 18, 2003 to Pavlin et al, which application is hereby incorporated by reference herein.  
         [0031]    Those skilled in the art will recognize many modifications may be made to this configuration without departing from the scope of the present invention. For example, those skilled in the art will recognize that any combination of the above components, or any number of different components, peripherals, and other devices, may be used with the present invention.  
         [0032]    [0032]FIG. 2 is a diagram showing the generic shelling process. In the simplest form, a shelling process  206  accepts the original, unprotected executable file  202  and a startup code  204  and generates a new, protected executable file  208 . An exemplary shelling process is described in chapter seven of “Sentinel SuperPro—Developer&#39;s Guide,” published 2000-2001 by Rainbow Technologies Inc., which is also hereby incorporated by reference herein. The protected executable file  208  includes the startup code  210  and an encrypted version of the original executable code  212 .  
         [0033]    [0033]FIG. 3 is a diagram illustrating the execution of the protected executable file  208 . In block  302 , the execution of the protected executable  208  is started  302 . The startup code  210  is executed  304 . The startup code  210  performs one or more operations to determine whether execution of the protected executable is authorized. In one embodiment, this includes checking for a valid license condition from the HSM  140 , as shown in block  306 . If execution of the protected executable is not authorized (e.g. the HSM  140  is not present and/or provides an incorrect response to the challenge provided by the computer  102 ), the execution of the protected application  208  stops, as shown in blocks  308  and  316 . If execution of the protected executable is authorized (e.g. if the HSM  140  is present and provides the correct response to the challenge provided by the computer  102 ), the encrypted executable code  212  is decrypted to produce the original executable code  202 , as shown in block  312 . The original executable code  202  is then executed, as shown in block  314 . For WIN32-compatible executables, other housekeeping operations are performed, as shown in block  310 . Such operations can include, for example, relocating data link libraries (DLLs), and setting up import tables as required.  
         [0034]    [0034]FIG. 4 is a flow chart presenting illustrative method steps that can be used to practice one embodiment of the present invention. FIG. 4 will be described herein with reference to FIGS. 5 and 6. FIG. 5 is a diagram showing an exemplary embodiment of a startup code  204 . As illustrated, the startup code comprises a plurality of sequentially executed tasks/steps/subtasks, such as a anti-debug code, self-decrypting routine, several substeps for checking license condition(s), decrypting the original code, preparing it to run (relocation, resolving import/export tables). FIG. 6 is a diagram illustrating the structure of the protected startup code created, for example, by performing the method steps shown in FIG. 4.  
         [0035]    Referring to FIGS. 4, 5, and  6 , a plurality N of startup task routines T 1 , T 2 , . . . T N    502 A- 502 N are generated, as shown in block  402 . The plurality of startup task routines T 1 , T 2 , . . . T N    502 A- 502 N are generated collectively from the startup code  204 . For example, the startup code  204  can comprise a series of sequentially executed task routines, as shown in FIG. 5. In this case, the startup code  204  can be separated into a first task routine T 1    504 A which performs a first task, a second task routine T 2    504 B, which performs a second task sequentially performed after the first task and a series of further task routines, up to and including an N th  task routine T N    504 N. The code developer can now choose one or more task routines T 1 , T 2 , . . . T N    502 A- 502 N that are to be implemented with a variety of functionally equivalent but computationally differing startup task code variations. Such task routines are referred to hereinafter as the “chosen” startup tasks, while those startup tasks that are not chosen to be variably implemented are referred to as “unchosen” startup tasks.  
         [0036]    Referring again to FIG. 4, a plurality K of startup task routine variations T N,K  are generated for a chosen startup task T i  of the startup task routines T 1 , T 2 , . . . T N    502 A- 502 N. This is illustrated in block  404 . An exemplary embodiment of the startup task routines T 1 , T 2 , . . . T N    502 A- 502 N and startup task routine variations T 1,1 , . . . , T N,K  are shown in FIG. 6. In this example, K startup task variations T 1,1 ,  502 AA, T 1,2    502 AB, . . . , T 1,K    502 AK are generated for startup task T 1    502 A, K startup task variations T 2,1    502 BA, T 2,2    502 BB, . . . , T 2,K    502 BK are generated for startup task T 2    502 B, and K startup task variations T N,1    502 NA, T N,2    502 NB, . . . , T N,K    502 NK are generated for startup task T N    502 N. Each of the startup task variations T N,1 , T N,2  . . . T N,K  perform the startup task T N , but each does so using differently designed code. Preferably, the differences in code variations T N,1 , T N,2  . . . T N,K  are sufficient so that someone attempting to crack the startup code must crack each of the startup code variations to crack the startup code itself, and information gleaned from cracking one of the startup code variations is of little or no use in cracking the remaining startup codes. These task code variations can be generated using the random code generation method described in U.S. Pat. No. 6,463,538 “Method of Software Protection Using a Random Code Generator”, which is hereby incorporated by reference herein.  
         [0037]    Returning to FIG. 4, a selection routine S i  is generated for the chosen startup task routine T i , as shown in block  406 . Each selection routine S i  selects at least one of the startup task code variations T i,K  to perform the chosen startup task routine T i . For example, supposing the selected startup task routine is T 2 , selection routine S 2    602 B selects one of the startup code task variations T 2,2 , . . . , T 2,K    502 BB- 502 BK.  
         [0038]    Finally, the secure startup code  210  is assembled as a combination of the plurality of task routines T N    502  for the unchosen one ones of the plurality of task routines, the selection routines S N    602 , and the plurality of task code variations T N,K    502  associated with each of the chosen one of the task routines, as shown in block  408 .  
         [0039]    An exemplary assemblage is shown in FIG. 6. In this embodiment, the startup code  204  has been separated into a plurality of task routines T 1 , T 2 , . . . T N   502 A- 502 N, and a plurality of task code variations T 1,1 , . . . , T N,K    502 AA- 502 NK have been generated for each of the plurality of task routines T 1 , T 2 , . . . T N   502 A- 502 N. A selection routine S 1 , S 2 , . . . , S N    602 A- 602 N has been generated for each generated task code variation T 1,1 , . . . , T N,K    502 AA- 502 NK. These elements have been assembled so that each of the tasks  502  are executed sequentially as they were in the original startup code shown in FIG. 5, and the selection routines  602  select which of the task code variations T i,j  are used to execute each particular task.  
         [0040]    For example, a first execution thread can comprise the execution of selection code S 1    602 A, task code variation T 1,2    502 AB, selection code S 2    602 , task code variation T 2,K   502 BK, selection routine S N    602 N, and task code variation T N,1 . A second execution thread can include selection routine S 1    602 A, task code variation T 1,1    502 AA, selection routine S 2    602 B, task code variation T 2,2    502 BB, selection code S N    602 N, and task code variation T N,K    502 NK. This process can continue, with each of the selection routines S N    602  selecting different task code variations T N,K , thus implementing the startup code  204  with randorly selected code. Such “random” selections are typically implemented by using an algorithmically-generated number. Although the numbers generated by such algorithms appear random, they are in fact reproducible, and therefore “pseudorandom” instead of truly “random.” In this disclosure, the terms “random” and “pseudorandom” are functionally synonymous, and refer to selections that may or may not be equally probable, and that are for practical purposes, random enough to achieve the objectives of the present invention.  
         [0041]    The number of task code variations T 1,1 -T N,K    502 AA- 502 NK that are generated for each subtask T 1 , T 2 , . . . , T N    502 A,  502 B, . . . ,  502 N is a sufficiently large number so that a software cracker would be faced with a sufficiently large number of different task code variations  502  and different execution threads. The actual number selected depends upon the level of security desired. Typically, 50-100 task code variations T i,j    502 AA- 502 NK are generated for each task code.  
         [0042]    As described above, all of the startup task routines T 1 , T 2 , . . . , T N    502 A,  502 B, . . . ,  502 N can be implemented by the same number (K, in the foregoing example) of task code variations T 1,1 -T N,K    502 AA- 502 NK. However, if desired, a different number of startup task code variations T N,K  can be generated for one or more of the startup tasks T N    502 . This adds another area of uncertainty, making it more difficult to crack the software code. Also, a particular startup task may be implemented with no variations (and hence, no selection routine is required to choose from among the startup code variations T N,K ). The selection routines S i    602  may select from among the associated startup task code variations T i,j  in a variety of ways. In one embodiment, the selection routine S i  pseudorandomly selects from among the associated startup code variations T i,j  (e.g. by generation of a random number). If desired, the probabilities of selecting any particular one(s) of the task code variations T i,j  is much less likely than others of the task code variations. This can make it quite difficult for the cracker to assure that each and every one of the task code variations have been cracked, making a cracked application much less marketable for purposes of software piracy.  
         [0043]    The startup code  204  may also include tasks that are performed in parallel instead of in series as shown in FIG. 5. In this situation, the related subtasks and associated selection routines may also be performed in parallel.  
         [0044]    In another embodiment, instead of randomly selecting the next T i,j  task variation at each point, task code variations are selected based on a function of time. For example, if the current time is t, the selection routine can use a selection function f(i, t)=x to select which of the task code variations T i,j  is selected. Using this technique, the selected sequence of task code variations will be T 1,x     1   ,T 2,x     2   , . . . , T N,x     N   . To increase resistance against cracking, some of the tasks perform a check, using the function f(i, t) and the knowledge of the current time t, to make sure that the proper task code variation T i,j  was selected. If the proper task was not selected (for example, if the cracker compromised or bypassed one or more of the selection routines) the startup code will abort.  
         [0045]    In yet another embodiment, instead of randomly selecting the next task, one or more selection routines can select the task code variation based on the computer configuration (for example, using computer-related information such as CPU type, hardware configurations, and/or other factors). To implement this embodiment the computer configuration information can be collected and condensed into a “computer fingerprint” or other value F p . A computer fingerprint is a unique computer identifier, analogous to a human fingerprint. The computer signature represents a unique digital signature for the computer and is typically generated by a pseudorandomly processed combination of the computer&#39;s hardware components or resident software components. One or more of the selection routines can implement a selection function be g(i, F p )=y. The selection routine can implement the startup code by executing a thread T 1,y     1   , T 2,y     2   , . . . , T N,y     N   . In this embodiment the selection routines S 1 , S 2 , . . . , S N    602 A- 602 N of FIG. 6 and the selection routines S 1 ,  802 A and S 2,1 -S N,K    802 BA- 802 NK can be performed by a single selection routine that enters the thread where appropriate to select the next task T i    502  or task variation T i,j    502  to be performed. In this case, on a given computer the protected program always runs the same way—so a cracker will patch only that one code path. When the cracked program is copied to another computer it will select a different code execution path and the crack will be ineffective, that is, the protected program will again check for the license condition. Moreover, since the execution path is computer dependent the cracker would need to test a cracked software on many computers—and probably will still miss all execution thread or path variations.  
         [0046]    A combination of the foregoing techniques can also be employed. For example, some of the task code variation selections can be made completely randomly, others may be time-based (and the selected routine checks that it is the one it should have been selected) and some task code variations selections based on the computer configuration (so the execution path will change only if the program is run on a different computer). Further, how such task code selections are made in each instance can itself be determined pseudorandomly.  
         [0047]    [0047]FIG. 7 is a flow chart illustrating another embodiment of the present invention. In this embodiment, single decision points are avoided. Instead of employing a single selection routine S i  after a task T i−1 , a plurality of selection routines S i,j  is appended and performed after each associated task T i,j . FIG. 8 is a diagram illustrating the structure of the protected startup code  204  created, for example, by performing the method steps shown in FIG. 7.  
         [0048]    Referring now to FIG. 7, a plurality of N startup task routines T 1 -T N    502 A- 502 N are generated. This is illustrated in block  702 . The startup task routines T 1 -T N    502 A- 502 N collectively form the startup code  204 . A plurality K of startup task routine variations T i,1 , T i,2 , . . . , T i,K  are generated for one or more chosen startup task routines of the plurality of startup task routines T 1 -T N    502 A- 502 N. This is illustrated in block  704 . In the embodiment illustrated in FIG. 8, K task code variations are generated for each of the startup task routines T 1 -T N    502 A- 502 N.  
         [0049]    In block  706 , a selection routine S i  is generated for the chosen startup task routines T i  of the startup task routines T 1 -T N    502 A- 502 N. Each selection routine S i  selects at least one of the startup task code variations T i,j  to perform the chosen startup task routine T i .  
         [0050]    In block  708 , a plurality of K second selection routines S i+1,1 , S i+1,2 , . . . , S i+1,K  are generated. Each of the K second selection routines S i+1,1 , S i+1,2 , . . . , S i+1,K  is associated with and executed after one of the plurality startup code variations T i,1 , T i,2 , . . . , T i,K . Also, each of the K second selection routines S i+1,1 , S i+1,2 , . . . , S i+1,K  selects at least one of a plurality L of second startup code variations T i+1,1 , T i+1,2 , . . . , T i+1,L  for a second startup task routine T i+1  of the plurality of startup task routines T 1 -T N    502 A- 502 N. In the embodiment illustrated in FIG. 8, the number of second startup code variations T i+1,1 , T i+1,2 , . . . , T i+1,L  is equal to the number of second selection routines S i+1,1 , S i+1,2 , . . . , S i+1,K  (e.g. L=K), however, this need not be the case.  
         [0051]    Finally, in block  710 , the secure startup code  204  is assembled as a combination of the plurality of task routines for the unchosen ones of the plurality of task routines T 1 , T 2 , . . . , T N , the selection routine S i  and plurality of task routine variations T i,1 , T i,2 , . . . , T i,L  for each of the chosen ones of the task routines T 1 , T 2 , . . . , T N , and the second selection routines S i+1,1 , S i+1,2 , . . . , S i+1,K  and second startup code variations T i+1,1 , T i+1,2 , .  
         [0052]    [0052]FIG. 8 presents an exemplary embodiment of the assembled secure startup code  204 . In this example, the chosen startup task is task T 1    502 A, and selection routine S 1    802 A will select a startup task code variation T 1,1 , T 1,2 , . . . , T 1,K . The selected startup task code variation T i  is executed, and the selection routine S i  associated with the startup task code variation T i  then selects one of the second startup code variations T i,1 , T i,2 , . . . , T i,L  to continue the thread.  
         [0053]    [0053]FIG. 9 is a flow chart illustrating the execution of a startup code  204 . Upon initial execution of the protected application, a startup code variation T i,j  is selected from the plurality of startup code variations T 1,1 -T N,K    502 AA- 502 NK, as shown in block  902 . As described above, the startup code tasks T 1 , T 2 , . . . , T N    502 A,  502 B, . . . ,  502 N collectively perform the startup code  204 , and each of the startup code task variations T 1,1 -T N,K    502 AA- 502 NK performs an associated startup code task T 1 , T 2 , . . . , T N    502 A,  502 B, . . . ,  502 N differently than the other associated startup task code variations.  
         [0054]    For example, referring to FIG. 6, after the protected application is started, as shown in block  302 , selection routine S 1    602 A selects one of the associated task code variations T 1,1 -T 1,K    502 AA- 502 AK to perform task T 1    502 A. The selected task code variation (e.g. for exemplary purposes, task code variation T 1,2    502 AB) is executed to perform task T 1    502 A. In the embodiment shown in FIG. 6, this process is repeated for each remaining startup code task T 2 , T 3 , . . . , T N    502 B,  502 C, . . . ,  502 N. In cases where the multiple task code variations are available to perform the related task, a selection routine selects which task code variation will perform the task, and in cases where the task is performed by a single task code (e.g. the software designer has not chosen to implement multiple task code variations for this particular task), the task code itself is executed.  
         [0055]    Referring back to FIG. 9, a second selection routine (e.g. task S 2    602 B) selects one of among a second plurality second task code variations (e.g. task code variations T 2,1 , T 2,2 , . . . , T 2,K    502 BA- 502 BK to perform startup task T 2    502 B, and the selected startup task code variation (e.g. task code variation T 2,1    502 BA) is executed to perform the task. This is illustrated in blocks  906  and  908 .  
         [0056]    [0056]FIG. 8 illustrates another embodiment of a startup code task  204 . In this case, a first selection routine S 1    802 A selects one of the startup task code variations T 1,1 , T 1,2 , . . . , T 1,K  to perform startup task T 1    502 A, and a second selection routine (e.g. one of selection routines S 2,1 , S 2,2 , . . . , S 2,K    802 BA- 802 BK) selects one of the second startup code task variations (e.g. T 2,1 , T 2,2 , . . . , T 2,K    502 BA- 502 BK). The selected second startup code task executes the startup code task variation to execute the task.  
         [0057]    In the embodiment shown in FIG. 6, the selection of the second startup code task variation is performed by executing a single selection routine S 2    602 B associated with each of the preceding startup code task variations T 1,1 , T 1,2 , . . . , T 1,K    502 AA- 502 AK and all of the following second startup code task variations T 2,1 , T 2,2 , . . . , T 2,K    502 BA- 502 BK. However, in the embodiment shown in FIG. 8, the selection of the second startup task code variation T 2,1 , T 2,2 , . . . , T 2,K    502 BA- 502 BK is performed by executing a selection routine associated with the selected startup task code variation and the second startup task code variations (e.g., if selection routine S 1    802 A selected startup code task variation T 1,2 ,  502 AB selection routine S 2,2    802 BB, which is associated with and executed after startup code task variation T 1,2    502 AB selects one of the following startup code task variations T 2,1 , T 2,2 , . . . , T 2,K    502 BA- 502 BK to perform task T 2    502 B).  
       CONCLUSION  
       [0058]    This concludes the description of the preferred embodiments of the present invention. The foregoing description of the preferred embodiment of the invention has been presented for the purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise form disclosed. Many modifications and variations are possible in light of the above teaching. It is intended that the scope of the invention be limited not by this detailed description, but rather by the claims appended hereto. The above specification, examples and data provide a complete description of the manufacture and use of the composition of the invention. Since many embodiments of the invention can be made without departing from the spirit and scope of the invention, the invention resides in the claims hereinafter appended.