Patent Publication Number: US-10771494-B2

Title: Runtime protection of web services

Description:
BACKGROUND 
     The present invention relates to runtime protection of Web services, and more particularly to automatically instrumenting Web service application code to detect potential vulnerabilities. 
     Perfect enforcement of a security specification, for example to avoid all possible instances of an injection vulnerability like SQL injection, is a hard problem. This is true in general, and specifically when the person responsible for implementing the security defenses is a software engineer without any special background in application security. 
     This problematic situation is the reason for many reports of severe security attacks against Web sites owned by banks, corporations and governments. In response, a variety of testing and analysis tools have been developed to detect potential security vulnerabilities. These include algorithms for static security verification like IBM AppScanSrc, as well as black-box and glass-box security testing products like IBM AppScanStd. IBM is a registered trademark of International Business Machines Corporation in the US and/or other countries. 
     While automated tools assist the developer in discovering potential security problems, the responsibility for fixing these problems ultimately remains in the hands of the developer. This means that if the security fix the developer has applied is wrong, or partial, then the application is still released in a vulnerable state. 
     Another related serious problem is that the quality of the analysis performed by the automated algorithm critically depends on how comprehensive and accurate the algorithm&#39;s configuration is. One example is the need by the user to input all sanitizer and validator methods appearing in the application&#39;s scope when using tools like IBM AppScanSrc. If the user inputs a wrong or broken defense, then this can result in false negatives. If, on the other hand, the user forgets to include a correct defense, then false positives are likely. 
     BRIEF SUMMARY 
     Embodiments of the present invention disclose a method, computer program product, and system for protecting a runtime Web service application. A web service application is instrumented to log its operation and allow recreation of its execution trace. Trace point vulnerabilities are identified using one or more data payloads. Candidate trace point operations associated with the trace point vulnerabilities are identified. Supplementary candidate operations are computed based on the existing trace point operations and the one or more data payloads, and the Web service application is further instrumented with the one or more supplementary candidate operations. 
     A supplementary candidate operation is one type of software fix for a trace point vulnerability. A trace point vulnerability (also known as a hypothesized trusted boundary) is a point in an operation when good data (data that can be trusted) can change into bad data or vulnerable data (data that cannot be trusted). It is envisaged that other types of software fixes could correct trace point vulnerabilities. In the preferred embodiment, hypothesized trusted boundaries of the application are inferred based on inspection of a finite number of execution traces (for example resulting from testing), and security defenses are enforced on every transition into trusted areas. 
     Various advantages may be realized. The user need not provide a specification as this is inferred by the algorithm. Also, the system is robust against user mistakes in the implementation of security defenses, compensating for the missing defense logic automatically. These two advantages show how the preferred embodiment may overcome the inherent limitations of existing analysis and testing approaches. 
     In various embodiments, defenses implemented by the user or developer may be improved. Defenses implemented by the user or developer may address intended trust boundaries, while embodiments of the invention may implement automatic enforcement of defenses along extracted trust boundaries. The preferred embodiment detects which defenses are enforced and which defenses are still missing, as well as where to insert additional security checks. 
     In various embodiments of the invention, the code of a Web service is modified by the embodiment such that the Web service application operates in a new way, which may lead to an increase in the reliability of the Web service application. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       Preferred embodiments of the present invention will now be described, by way of example only, with reference to the following drawings in which: 
         FIG. 1  is a deployment diagram of the preferred embodiment; 
         FIG. 2  is a component diagram of the preferred embodiment; 
         FIG. 3  is a flow diagram of a process of the preferred embodiment; 
         FIG. 4A  is an example application before performance of the preferred embodiment; and 
         FIG. 4B  is the example application after performance of the preferred embodiment. 
     
    
    
     DETAILED DESCRIPTION 
     Referring to  FIG. 1 , the deployment of a preferred embodiment in computer processing system  10  is described. Computer processing system  10  is operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of well-known computing processing systems, environments, and/or configurations that may be suitable for use with computer processing system  10  include, but are not limited to, personal computer systems, server computer systems, thin clients, thick clients, hand-held or laptop devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, network PCs, minicomputer systems, mainframe computer systems, and distributed cloud computing environments that include any of the above systems or devices. 
     Computer processing system  10  may be described in the general context of computer system-executable instructions, such as program modules, being executed by a computer processor. Generally, program modules may include routines, programs, objects, components, logic, and data structures that perform particular tasks or implement particular abstract data types. Computer processing system  10  may be embodied in distributed cloud computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed cloud computing environment, program modules may be located in both local and remote computer system storage media including memory storage devices. 
     Computer processing system  10  includes general-purpose computer server  12  and one or more input devices  14  and output devices  16  directly attached to the computer server  12 . Computer processing system  10  is connected to a network  20 . Computer processing system  10  communicates with a user  18  using input devices  14  and output devices  16 . Input devices  14  include one or more of a keyboard, a scanner, a mouse, trackball or another pointing device. Output devices  16  include one or more of a display or a printer. Computer processing system  10  communicates with network devices (not shown) over network  20 . Network  20  can be a local area network (LAN), a wide area network (WAN), or the Internet. 
     Computer server  12  includes central processing unit (CPU)  22 , network adapter  24 , device adapter  26 , bus  28 , and memory  30 . 
     CPU  22  loads machine instructions from memory  30  and performs machine operations in response to the instructions. Such machine operations include incrementing or decrementing a value in a register, transferring a value from memory  30  to a register or vice versa, branching to a different location in memory if a condition is true or false (also known as a conditional branch instruction), and adding or subtracting the values in two different registers and loading the result in another register. A typical CPU can perform many different machine operations. A set of machine instructions is called a machine code program. The machine instructions are written in a machine code language, which is referred to as a low level language. A computer program written in a high level language needs to be compiled to a machine code program before it can be run. Alternatively, a machine code program such as a virtual machine or an interpreter can interpret a high level language in terms of machine operations. 
     Network adapter  24  is connected to bus  28  and network  20  for enabling communication between the computer server  12  and network devices. Device adapter  26  is connected to bus  28 , input devices  14 , and output devices  16  for enabling communication between computer server  12  and input devices  14  and output devices  16 . 
     Bus  28  couples the main system components together. Bus  28  represents one or more types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnects (PCI) bus. 
     Memory  30  includes computer system readable media in the form of volatile memory  32  and non-volatile or persistent memory  34 . Examples of volatile memory  32  are random access memory (RAM)  36  and cache memory  38 . Generally, volatile memory is used because it is faster and generally non-volatile memory is used because it will hold the data for longer. Computer processing system  10  may further include other removable and/or non-removable, volatile and/or non-volatile computer system storage media. By way of example only, persistent memory  34  can be provided for reading from and writing to a non-removable, non-volatile magnetic media (not shown and typically a magnetic hard disk or solid-state drive). Although not shown, further storage media may be provided, including an external port for removable, non-volatile solid-state memory, an optical disk drive for reading from or writing to a removable, non-volatile optical disk such as a compact disk (CD), digital video disk (DVD) or Blu-ray. In such instances, each can be connected to bus  28  by one or more data media interfaces. 
     Computer processing system  10  communicates with at least one network  20 , such as a local area network (LAN), a general wide area network (WAN), and/or a public network like the Internet, via network adapter  24 . Network adapter  24  communicates with the other components of computer server  12  via bus  28 . It should be understood that although not shown, other hardware and/or software components may be used in conjunction with computer processing system  10 . Examples, include, but are not limited to, microcode, device drivers, redundant processing units, external disk drive arrays, redundant array of independent disks (RAID), tape drives, and data archival storage systems. 
     As will be further depicted and described below, memory  30  includes application A, application A′, and Web service protection module  200  configured to carry out the functions of the preferred embodiment of the invention. Further program modules that support the preferred embodiment but are not shown include firmware, boot strap programs, operating systems, Web servers, and support applications. Each of the operating system, support applications, other program modules, and program data, or some combination thereof, may include an implementation of a networking environment. In the preferred embodiment, application A is the Web service application for input to Web service protection module  200 , and application A′ is the instrumented version of application A featuring self-protection capabilities of the preferred embodiment. 
     Referring to  FIG. 2 , Web service protection module  200  includes data payloads p 1  to pN, trace instrumenter  202 , vulnerability detector  204 , security rules  205 , taint analyzer  206 , string analyzer  208 , defensive instrumenter  210 , and Web service protection method  300 . 
     Data payloads p 1  to pN are example sets of data to test different payloads through the application A and protection application A′. 
     Trace instrumenter  202  operates to instrument a Web service application such that the Web service application is enabled to log its operation and allowing creation of its execution trace. 
     Vulnerability detector  204  operates to identify trace point vulnerabilities using one or more data payloads and using one or more security rules  205 . A vulnerability is a test that fails against one of the security rules. 
     Security rules  205  define the nature of data output. For instance, an example security rule is that a data output from an input field on a Web page must not include the characters ‘&lt;’ or ‘&gt;’ or any JavaScript. 
     Taint analyzer  206  operates to check data flow through an application from application input (source) to output (sink) using one of data payloads p 1  to pN and to specify one or more security rules to define which input data must not reach the output. 
     String analyzer  208  operates to compute supplementary trace point operations by approximating the possible variants of existing trace point operations. 
     Defensive instrumenter  210  operates to instrument the application with the supplementary trace point operations. 
     Web service protection method  300  performs the preferred embodiment of the invention using the above components. and is described in more detail below. 
     Referring to  FIG. 3 , web service protection method  300  includes logical process steps  301  to  307 . 
     Step  301  instruments application A to log its operations, allowing recreation of its execution trace. 
     Step  302  tests application A for one or more vulnerabilities by applying payloads p 1  . . . pN and using one or more security rules  205 . If a vulnerability is identified then step  302 A is executed. If a vulnerability is not identified then step  303  is executed. 
     Step  302 A reports a vulnerability to user  18  and provides an opportunity for a fix in the form of a user applied trace point operation. If a fix is provided then all payload testing is rerun at step  302 . Otherwise, the remainder of payloads are tested at step  302 . 
     If a vulnerability is not identified in step  302 , then step  303  identifies candidate trace point operations near to trace point vulnerabilities where payload values have been rejected by a validator or been sanitized by a sanitizer. Step  303  performs traces t 1  to tN corresponding to payloads p 1  to pN. Trace point vulnerabilities denote transitions across trust boundaries. 
     Consider trace S=[s 1  . . . sN] due to some payload p. For this particular trace, let Src(S) be the source statements along S—that is, the statements that read user-provided, and thus untrusted, data—and let Snk(S) be the statements that perform security-sensitive operations. For each pair of statements (src,snk) in Src(S) X Snk(S), the existence of data flow from src to snk is checked statistically using taint analyzer  206 . If there is data flow then security rules  205  using taint analyzer  206  specify which data values emanating from src must not reach snk. 
     Step  304  computes supplementary trace point operations based on existing candidate trace point operations and vulnerabilities, in light of the security rules, for the data values participating in the flow from src to snk. String analysis is applied to approximate the possible string values that each data value may assume at each of the program points s 1  . . . sN. Since the flow is safe, there necessarily exists a (first) point si along the flow from src to snk starting from which all string values are safe. This form of analysis can now be repeated for multiple traces (each due to a different payload pi). All the candidate points&#39; si can now be collected, and a search may be performed in the neighborhood of each statement si (that is a bounded number of trace points before/after si) for candidate sanitizers (for example by using the heuristics). 
     The string analysis uses built-in specifications for which string formats are allowed per a given security rule. On the other hand, the transformation applied by the candidate sanitizer can be approximated given some arbitrary string. The delta between the desired transformation and the transformation enforced by the candidate sanitizer can be deduced. Missing transformations can be compensated for by synthesizing appropriate code. 
     Step  305  instruments application A with supplementary trace point operations. 
     Step  306  tests for further trace point vulnerabilities. If the vulnerability is an existing vulnerability that has not been fixed in step  302 A, then the process continues to step  307 . Otherwise, the process returns to step  303  in order to further reduce the vulnerability. 
     Step  307  is the end of the process where the protected application A′ is output. 
     Referring to  FIG. 4A , an example Web service application portion (application A) in Java syntax (with additional line numbering) prior to protection processing is shown and described below. 
     
       
         
           
               
               
             
               
                   
                   
               
             
            
               
                   
                 401 String name = request.getParameter(“name”); // source 
               
               
                   
                 402 String sanitized = sanitizeXSS(name); 
               
               
                   
                 403 response.getWriter( ).write(“Hello “ + sanitized + “!”); // sink 
               
               
                   
                 404 static String sanitizeXSS(String value) { 
               
            
           
           
               
               
            
               
                   
                 value = value.replace(“&lt;”,””).replace(“&gt;”,””); 
               
            
           
           
               
               
            
               
                   
                  } 
               
               
                   
                   
               
            
           
         
       
     
     Analysis of a trace through the code above would indicate data flow between getParameter( ) (line  401 ) and response.getWriter( ).write( ) (line  403 ), which corresponds to a cross-site scripting (XSS) security rule. As shown at line  404 , the application&#39;s existing protection operation disallows strings containing ‘&lt;’, ‘&gt;’ and replaces them with null characters. However the cross-site scripting (XSS) security rule disallows ‘&lt;’, ‘&gt;’ and any JavaScript (“JavaScript:*”). Disallowing JavaScript is not defined in the existing application A code. 
     Furthermore, according to the algorithm above, the call site of sanitizeXSS( ) will likely be marked as a trust boundary for the flow above. The next step is to approximate the transformation applied by sanitizeXSS via string analysis where the result, in the syntax of regular expressions, would be any of the following characters *=&gt;^{&lt;,&gt;}*. 
     The preferred embodiment determines that application A has a vulnerability that leaves open the possibility of an attack via “JavaScript:*”, identifies the vulnerable candidate trace point operation santizeXSS(name), computes a supplementary trace point operation santizeXSS1( ), and instruments the application with supplementary trace point operation santizeXSS1( ). 
     Referring to  FIG. 4B , the example Web service protected application portion (application A′) is shown after protection processing. In this example the underlined code has been added to transform the Web service application A into protected Web service application A′: 
     
       
         
           
               
               
             
               
                   
                   
               
             
            
               
                   
                 401 String name = request.getParameter(“name”); // source 
               
               
                   
                 402’ String sanitized = sanitizeXSS1(sanitizeXSS(name)); 
               
               
                   
                 403 response.getWriter( ).write(“Hello “ + sanitized + “!”); // sink 
               
               
                   
                 404 static String sanitizeXSS(String value) { 
               
            
           
           
               
               
            
               
                   
                 value = value.replace(“&lt;”,””).replace(“&gt;”,””); 
               
            
           
           
               
               
            
               
                   
                  } 
               
               
                   
                 405 static String sanitizeXSS1(String value) { 
               
            
           
           
               
               
            
               
                   
                 value = value.replace(“javascript:”,””); 
               
            
           
           
               
               
            
               
                   
                 } 
               
               
                   
                   
               
            
           
         
       
     
     Line  402  has been enhanced to line  402 ′ and now includes the existing operation sanitizeXSS( ) and the newly inserted sanitizeXXS1( ) operation (underlined in step  402 ′ and  405 ). The new sanitizeXXS1( ) operation is defined in line  405  with the function of replacing any code preceded by a “javascript:” identifier with a null string. This enables a revolutionary and powerful approach to application security, which acknowledges the practical setting where this problem is to be solved, whereby developers may have limited security knowledge, and may find it hard to reason about complex end cases when implementing security defenses. 
     Applying this approach to protection of Web services appears promising. Experience suggests that Web services often perform only partial checking on incoming data, which may leave open certain attack scenarios. These may be exploited in practice by seasoned hackers. With the preferred embodiment, it may be possible to block such scenarios, where the ability exists to (i) instrument Web services, and (ii) test Web services with dynamic security payloads. 
     Further embodiments of the invention are now described. It will be clear to one of ordinary skill in the art that all or part of the logical process steps of the preferred embodiment may be alternatively embodied in a logic apparatus, or a plurality of logic apparatus, including logic elements arranged to perform the logical process steps of the method and that such logic elements may include hardware components, firmware components or a combination thereof. 
     It will be equally clear to one of skill in the art that all or part of the logic components of the preferred embodiment may be alternatively embodied in logic apparatus including logic elements to perform the steps of the method, and that such logic elements may include components such as logic gates in, for example a programmable logic array or application-specific integrated circuit. Such a logic arrangement may further be embodied in enabling elements for temporarily or permanently establishing logic structures in such an array or circuit using, for example, a virtual hardware descriptor language, which may be stored and transmitted using fixed or transmittable carrier media. 
     In a further alternative embodiment, the present invention may be realized in the form of a computer implemented method of deploying a service comprising steps of deploying computer program code operable to, when deployed into a computer infrastructure and executed thereon, cause the computer system to perform all the steps of the method. 
     It will be appreciated that the method and components of the preferred embodiment may alternatively be embodied fully or partially in a parallel computing system comprising two or more processors for executing parallel software. 
     A further embodiment of the invention is a computer program product defined in terms of a system and method. The computer program product may include a computer-readable storage medium (or media) having computer-readable program instructions thereon for causing a processor to carry out aspects of the present invention. 
     The computer-readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (for example, light pulses passing through a fibre-optic cable), or electrical signals transmitted through a wire. 
     Computer-readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may include copper transmission cables, optical transmission fibres, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer readable storage medium within the respective computing/processing device. 
     Computer-readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++ or the like, and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The computer readable program instructions may execute entirely on the user&#39;s computer, partly on the user&#39;s computer, as a stand-alone software package, partly on the user&#39;s computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user&#39;s computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention. 
     Aspects of the embodiments are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer-readable program instructions. 
     These computer-readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer-readable program instructions may also be stored in a computer-readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer-readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks. 
     The computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks. 
     The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions.