Patent Publication Number: US-2019182251-A1

Title: Count-based challenge-response credential pairs for client/server request validation

Description:
BENEFIT CLAIM 
     This application claims the benefit as a Continuation of application Ser. No. 15/249,133, filed Aug. 26, 2016, which claims the benefit of provisional application 62/342,824, filed May 27, 2016, the entire contents of which are hereby incorporated by reference as if fully set forth herein. The applicant(s) hereby rescind any disclaimer of claim scope in the parent application or the prosecution history thereof and advise the USPTO that the claims in this application may be broader than any claim in the parent application(s). 
    
    
     FIELD OF THE DISCLOSURE 
     The present disclosure generally relates to security techniques applicable to client/server systems, and relates more specifically to techniques for improving the security of client computers interacting with server computers through an intermediary computer using morphing credentials. SUGGESTED GROUP ART UNIT: 2437; SUGGESTED CLASSIFICATION: 726/008. 
     BACKGROUND 
     The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section. 
     Browsers are powerful computer program applications that may request and execute instructions received from a web server to generate complex user interfaces that are presented to a user through one or more devices, such as a monitor or speakers. In response to input from a user, such as a mouse click indicating that the user selected a link, a browser may send a request based on the selected link to the web server. The request may be a request for data and/or include data to be processed by the web server. 
     A malicious user may use software, often referred to as a “bot”, which imitates a browser by receiving instructions from a web server and generating requests based on those instructions. For example, a bot may receive a web page, and generate a request based on a link defined in the web page, as if the link was selected by a user. Also for example, a bot generate and send a request with data assigned to one or more parameters to simulate a user submitting data to a web server through a browser. 
     Malicious users may use bots to commit many types of unauthorized acts, crimes or computer fraud, such as content scraping, ratings manipulation, fake account creation, reserving rival goods attacks, ballot stuffing attacks, password snooping, web site scraping attacks, vulnerability assessments, and stack fingerprinting attacks. As a specific example, a malicious user may cause a bot to traverse through pages of a web site and collect private and/or proprietary data, such as who is connected with whom on a particular social networking web site. 
     Web server administrators may wish to prevent malicious users from attacking the site, while allowing legitimate users to use the site as intended. However, determining which requests are generated by a legitimate user using a web browser and a malicious user using a bot may be difficult. 
     SUMMARY 
     The appended claims may serve as a summary of the invention. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       In the drawings: 
         FIG. 1  illustrates functional units of a web browser. 
         FIG. 2  illustrates a computer system comprising a browser, an intermediary computer, and a web infrastructure in an example embodiment. 
         FIG. 3  illustrates detailed view of an intermediary computer in an example embodiment. 
         FIG. 4  illustrates a process for validating requests from browsers, and filtering out requests from bots, using one or more count-based dynamic credentials in an example embodiment. 
         FIG. 5  illustrates a process for updating a credential over time in an example embodiment. 
         FIG. 6  illustrates a process for generating a seed value and sending the seed value to the client computer to generate one or more new credentials in an example embodiment. 
         FIG. 7  illustrates a process for validating requests from browsers, and filtering out requests from bots, using one or more dynamic, challenge-response credential pairs, in an example embodiment. 
         FIG. 8  illustrates a computer system upon which an embodiment may be implemented. 
     
    
    
     While each of the drawing figures illustrates a particular embodiment for purposes of illustrating a clear example, other embodiments may omit, add to, reorder, and/or modify any of the elements shown in the drawing figures. For purposes of illustrating clear examples, one or more figures may be described with reference to one or more other figures, but using the particular arrangement illustrated in the one or more other figures is not required in other embodiments. For example, intermediary computer  230  in  FIG. 2  may be described with reference to several components illustrated in  FIG. 3  and discussed in detail below, but using the particular arrangement illustrated in  FIG. 3  is not required in other embodiments. Furthermore, while the instructions discussed in many example embodiments are HTML, JavaScript, and CSS instructions, in other embodiments, the instructions intercepted and generated may be any other standard and/or proprietary instructions configured to be executed by a client computer. 
     DETAILED DESCRIPTION 
     In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the present invention. 
     Embodiments are described herein according to the following outline:
         1.0 General Overview   2.0 Differences Between Browsers and Bots
           2.1 Example Browser Anatomy   2.2 Example Bot Anatomy   
           3.0 Network Topology
           3.1 Web Infrastructure   3.2 Intermediary Computer
               3.2.1 Protocol Client Module   3.2.2 Processing Engine   3.2.3 Forward Transformer   3.2.4 Protocol Server Module   3.2.5 Credential Validation Module   3.2.6 Reverse Transformer   3.2.7 Configurations   3.2.8 Storage   
               3.3 Browser   
           4.0 Process Overview
           4.1 Intercepting Instructions from a Content Server Computer   4.2 Modifying Instructions which Causes a Browser to Submit a Credential with One or More Requests
               4.2.1 Causing a Browser to Submit a Credential with one or more Requests using a Browser Cookie   
               4.3 Rendering a Second Set of Instructions Comprising Credential-Morphing Instructions   4.4 Sending the Modified and Credential-Morphing Instructions to the Client Computer   4.5 Updating the Credential Over Time   4.6 Validating a Credential
               4.6.1 Implied Parameters   4.6.2 Express Parameters   
               4.7 Generating a New Credential
               4.7.1 Generating a First Credential   
               4.8 Sending a New Credential
               4.8.1 Sending a Seed Value from which the New Credential may be Generated   
               4.9 Updating a Credential Over Time   4.10 Validating a Request for Data   4.11 Performing a Negative Responsive Action   4.12 Forwarding the Request to a Server Computer   
           5.0 Process Overview using Challenge-Response Credential Pairs
           5.1 Generating a Challenge-Response Credential Pair
               5.1.1 Deterministically Generating a Challenge Credential   5.1.2 Generating a Response Credential for the Challenge-Response Credential Pair   5.1.3 Deterministically Generating a Challenge-Response Credential Pair   5.1.4 Storing a Challenge-Response Credential Pair   
               5.2 Rendering one or more Dynamic-Credential Instructions   5.3 Sending the Modified set of Instructions to the Client Computer   5.4 Determining Whether a Response Credential in a Challenge-Response Credential Pair is Valid
               5.4.1 Determining Whether a Deterministically Generated Challenge Credential is Valid   5.4.2 Determining Whether a Deterministically Generated Response Credential is Valid   
               5.5 Determining Whether a Count-Based Challenge-Response Credential Pair is Valid   5.6 Updating a Challenge-Response Credential Pair Over Time   5.7 Responding to a Test Challenge-Response Credential Pair   
           6.0 Implementation Mechanisms—Hardware Overview   7.0 Other Aspects of Disclosure       

     1.0 General Overview 
     A “computer” may be one or more physical computers, virtual computers, or computing devices. As an example, a computer may be one or more server computers, cloud-based computers, cloud-based cluster of computers, virtual machine instances or virtual machine computing elements such as virtual processors, storage and memory, data centers, storage devices, desktop computers, laptop computers, mobile devices, or any other special-purpose computing devices. Any reference to “a computer” herein may mean one or more computers, unless expressly stated otherwise. 
     A server computer may be a computer that receives requests for data and responds with data. For example, a web server computer may be an HTTP-based computer that receives HTTP requests and responds with data comprising HTML, CSS, and/or JavaScript instructions. Additionally or alternatively, a server computer may respond with data that references data on other server computers in, and/or outside of, web infrastructure  205 . 
     2.0 Differences Between Browsers and BOTS 
     A web browser may be a tool through which application programs can provide client computers with content in a dynamic, custom UI. For example, in response to receiving a request for data from a web browser, a web server responds with a set of instructions and/or data. The instructions may define one or more objects that include data and/or other objects. The instructions may also define how the data and/or objects may be presented in a UI to enable human/computer interaction. 
     In contrast, bots traverse web pages and/or web sites to retrieve data from, and/or submit data to, one or more web servers with little, if any, human/computer interaction. For example, in response to receiving a request for data from a bot, a web server responds with a set of instructions. As discussed above, the instructions may define one or more objects that include data and/or other objects. The instructions may also define how the data and/or objects may be presented in a UI. However, a bot may parse the instructions looking for particular data to store and/or use to make subsequent requests. A bot need not execute the instructions because the bot is built to operate with little, if any, human/computer interaction. The bot may simply look for data by parsing the one or more data structures defined in the instructions. Thus, a bot may be a functionally limited browser. 
     A server computer that requires a browser to use one or more parsers and/or execution environments may filter out requests from bots. For purposes of illustrating a clear example, assume a browser includes a JavaScript parser or JavaScript execution engine, and a bot does not include a JavaScript parser or JavaScript execution engine. Also assume that a server computer may include one or more JavaScript instructions in a web page, which if executed, may cause a browser to request, receive, generate, and/or update a dynamic credential. A dynamic credential may be a credential that is updated over time. Accordingly, the browser may parse and execute the one or more JavaScript instructions, which cause the browser to request, receive, generate, and/or update the credential over time and include a valid dynamic credential in a subsequent request. 
     In contrast, a bot, which does not include a JavaScript parser and/or JavaScript execution environment, may not request, receive, generate, and/or update the dynamic credential over time. Thus, the bot may not include a valid dynamic credential in a subsequent request. 
     If a server computer receives a request for a web page with a valid dynamic credential from a browser, then the server computer may send the requested web page to the browser. However, if the server computer receives a request without a valid dynamic credential from the bot, then the server computer may perform a negative action, such as terminating the request or ignoring one or more future requests from the bot. 
     2.1 Example Browser Anatomy 
       FIG. 1  illustrates functional units of a web browser. Browser  100  may be a browser that is executed on a personal computer, used to communicate with or otherwise conceptually visit a web server, and operated by a user using the personal computer. Browser  100  is communicatively coupled with operating system (“OS”) system application programming interface (“API”) layer  150  and OS frontend API layer  160 . Other embodiments may use other protocols, modules, and/or parsers. 
     Browser  100  comprises protocol module  102 , domain name server (“DNS”) module  104 , local storage module  106 , image parser  108 , CSS parser  110 , HTML parser  112 , JavaScript parser  114 , extension execution environment  116 , document object model (“DOM”) module  118 , and JavaScript execution environment  120 . Protocol module  102 , DNS module  104 , and local storage module  106  may send and/or receive data through OS System API layer  150 . For example, protocol module  102  may send and/or receive data over any protocol, such as HTTP, to/from a server computer through OS system API layer  150 . Data received through protocol module  102  may reference data sources by one or more domain names. DNS module  104  may resolve the one or more domain names referenced by interfacing with one or more remote domain name servers through OS system API layer  150 . Local storage module may store and/or recall data from memory through OS system API layer  150 . 
     Image parser  108 , CSS Parser  110 , HTML parser  112 , and JavaScript parser  114  may parse data received through protocol module  102 . HTML parser  112  may parse HTML data. CSS parser  110  may parse CSS data. JavaScript parser  114  may parse JavaScript data. Image parser  108  may parse image data. Each parser may generate and/or update objects in a DOM maintained by DOM module  118 . 
     Browser  100  may comprise sets of program logic implementing one or more programmable engines, such as extension execution environment  116  and JavaScript execution environment  120 . Extensions may be written one or more programming languages include JavaScript, Python, Ruby, and/or any other language. Each programmable engine may have access to DOM module  118  and may operate on one or more objects from a DOM maintained by DOM module  118 . For example, JavaScript execution environment  120  may execute JavaScript parsed by JavaScript parser  114  and in response, create, update, and/or delete one or more objects managed by DOM module  118 , and/or one or more aspects of a UI presenting the one or more objects. 
     Browser  100  comprises rendering engine  122 , interactivity module  124 , and user interface  126 . Each of the components may cause, through OS frontend API layer  160 , one or more objects to be presented to a user using a client computer. Rendering engine  122  may determine how objects are presented to a user. For example, rendering engine  122  may determine the color, shape, orientation, position, and/or any other visual and/or audio attribute of an image, text field, button, and/or any other object defined by a set of received instructions. Furthermore, rendering engine  122  may cause a button to be displayed on a monitor coupled to a client computer through OS frontend API layer  160 . 
     User interface  126  may determine what may be presented to a user. For example, user interface  126  may determine that a “submit” button should be hidden until data has been entered in one or more text fields. After data has been entered in the one or more text fields, user interface  126  may notify rendering engine  122  to render the “submit” button accordingly. 
     Interactivity module  124  may receive one or more inputs through OS Frontend API layer  160 . For example, in response to a user pressing a button on a mouse coupled to a client computer  299 , the OS running on the client computer may send a message to interactivity module  124 , through OS frontend API layer  160 , to indicate that a user pressed a button on a mouse. Interactivity module  124  may determine that a user selected a particular button currently presented on a monitor. Interactivity module  124  may notify user interface  126  and/or rendering engine  122  to update the UI accordingly. 
     2.2 Example BOT Anatomy 
     A bot may include a subset of the modules and/or features included in browser  100 . For example, a bot may include protocol module  102 , DNS module  104 , local storage module  106 , and HTML parser  112 . A bot need not support a UI; thus, a bot need not include rendering engine  122 , interactivity module  124 , and user interface  126 . 
     To increase processing time and speed of development, a bot need not include one or more parsers and/or execution environments. For example, a bot may be configured to look for data embedded in a DOM defined in one or more HTML documents. Therefore, a bot may include an HTML parser. However, a bot need not include one or more parsers or execution environments, such as image parser  108 , CSS parser  110 , JavaScript parser  114 , extension execution environment  116 , and/or JavaScript execution environment  120 . 
     3 Network Topology 
       FIG. 2  illustrates a computer system comprising a browser, an intermediary computer, and a web infrastructure in an example embodiment. Referring first to  FIG. 2 , system  200  includes web infrastructure  205 , client computer  299 , intermediary computer  230 , storage  240 , and configuration  232  distributed across a plurality of interconnected networks. 
     While each of the components listed above is illustrated as if running on a separate, remote computer from each other, one or more of the components listed above may be part of and/or executed on the same computer. For example, intermediary computer  230 , configuration  232 , storage  240 , and/or web infrastructure  205  may be executed on the same computer, local area, and/or wide area network. Additionally or alternatively, intermediary computer  230  may be a proxy server and/or layer for web infrastructure  205 . Additionally or alternatively, intermediary computer  230  may be in line between a router and web infrastructure  205 , such that intermediary computer  230  may intercept all network data sent to, and/or sent from, web infrastructure  205  over one or more protocols. Additionally or alternatively, intermediary computer  230 , and/or one or more modules comprising intermediary computer  230  discussed herein, may be a software layer between, and/or executed on, web infrastructure  205  and/or a component of web infrastructure  205 . Additionally or alternatively, intermediary computer  230 , and/or one or more modules comprising intermediary computer  230  discussed herein, may be part of a server-side application that responds to requests over one or more standard and/or proprietary protocols, such as HTTP and/or any other protocol. 
     3.1 Web Infrastructure 
     Web infrastructure  205  may comprise one or more server computers that receive requests for data from users through one or more computers, such as client computer  299  and/or intermediary computer  230 . Web infrastructure  205  may respond by sending data to the browser that sent the request. As illustrated in  FIG. 2 , the data sent from web infrastructure  205  may include instructions: HTML, JavaScript, and CSS  210 . The one or more computers in web infrastructure  205  may, but need not, be owned and/or managed by one or more independent entities and may span across one or more computer networks. 
     3.2 Intermediary Computer 
     Intermediary computer  230  may be an intermediary that may intercept instructions sent from web infrastructure  205 , parse and/or execute one or more of the intercepted instructions, modify the intercepted instructions, generate and/or add new instructions, and send the modified and/or new instructions to a client computer. For example, intermediary computer  230  may intercept HTML, JavaScript, and CSS  210 , generate modified HTML, JavaScript, and CSS  290 , and send modified HTML, JavaScript, and CSS  290  to browser  295 . Intermediary computer  230  may intercept a request from browser  295 , generate a new and/or modified request, and send the new and/or modified request to web infrastructure  205 . 
     Intermediary computer  230  may be an HTTP or SPDY intermediary that intercepts, parses, executes, and/or processes HTML, JavaScript, and CSS instructions. Intercepting may mean receiving. Additionally or alternatively, intermediary computer  230  may intercept requests for data and/or instructions from a client application, generate a new HTTP request, and send the newly generated HTTP request to one or more HTTP and/or SPDY-based web servers. Additionally or alternatively, intermediary computer  230  may be an intermediary for any other standard and/or proprietary protocol. Furthermore, each of the components discussed herein, which intermediary computer  230  is comprised of, may be configured to perform any of the processes and/or methods discussed herein for any standard and/or proprietary protocol. 
     Intermediary computer  230  may be a server computer that one or more domain name servers or other elements of the domain name system (“DNS”) identify in DNS records as a destination network address associated with one or more internet domain names. Accordingly, intermediary computer  230  and/or intermediary computer  230  may receive requests sent to the one or more domains from a browser or bot. Based on using DNS to resolve the domain name in a request to a network address, intermediary computer  230  may forward the request, or a modified request, to a server computer in web infrastructure  205 , such as original web server computer  302 . 
     In  FIG. 2 , intermediary computer  230  is programmed to send instructions to, and receive requests from, a particular type of client application: browser  295 . However, in an embodiment, intermediary computer  230  may be programmed to send instructions to, receive requests from, and/or open sockets with browsers, bots, and/or other application. 
       FIG. 3  illustrates detailed view of an intermediary computer in an example embodiment. In  FIG. 3 , intermediary computer  230  comprises protocol client module  332 , processing engine  334 , forward transformer  336 , protocol server module  338 , credential validation module  340 , and reverse transformer  342 . In an embodiment, each of the functional units of intermediary computer  230  may be implemented using any of the techniques further described herein in connection with  FIG. 8 ; for example, the intermediary computer  230  may comprise a general-purpose computer configured with one or more stored programs which when executed cause performing the functions described herein for the intermediary computer, or a special-purpose computer with digital logic that is configured to execute the functions, or digital logic that is used in other computing devices. While the figures include lines that indicate various devices and/or modules being communicatively coupled, each of the computers, devices, modules, storage, and configurations may be communicatively coupled with each other. 
     Each module illustrated in intermediary computer  230  may be software and/or hardware stored in, or coupled to, a memory and/or one or more processors on one or more computers. Additionally or alternatively, a module may comprise specialized circuitry. For example, a module, such as a protocol client module  332 , processing engine  334 , forward transformer  336 , protocol server module  338 , credential validation module  340 , and/or reverse transformer  342  may be hardwired and/or persistently programmed to support a set of instructions to, and/or that are useful to, perform the functions discussed herein, such as receiving instructions from web infrastructure  204 , processing and/or executing the instructions, modifying the instructions to generate and/or update one or more credentials, sending the modified instructions to a browser or bot on a client computer, receiving requests and determine whether the requests include valid credentials, and/or responding accordingly as discussed in detail herein. 
     3.2.1 Protocol Client Module 
     Protocol client module  332  may intercept data over any standard or proprietary protocol. For example, protocol client module  332  may intercept data over HTTP. 
     3.2.2 Processing Engine 
     Processing engine  334  may process instructions intercepted by protocol client module  332 , which causes processing engine  334  to generate one or more data structures. Processing one or more instructions may comprise parsing and/or executing the one or more instructions. After processing the instructions, processing engine  334  may notify forward transformer  336  to begin rendering instructions based on the one or more data structures created by processing engine  334  that are currently in memory. 
     Processing engine  334  may make requests for additional data. For example, if instructions received from protocol client module  332  reference additional instructions stored on another web server, then processing engine  334  may request the additional instructions through protocol client module  332 . 
     3.2.3 Forward Transformer 
     Forward transformer  336  may render a new set of instructions based on the one or more data structures in memory. Additionally or alternatively, forward transformer  336  may operate on the objects created by processing engine  334  and generate one or more credential-morphing instructions, which if executed are configured to cause a browser to request, receive, generate, and/or update one or more dynamic credentials. Forward transformer  336  may store the one or more dynamic credentials and/or data associated with one or more dynamic credentials such as a challenge credential, response credential, and/or a count, in storage  240 . Forward transformer  336  may operate on objects and/or render instructions based on one or more configurations specified in configuration  232 . Forward transformer  336  may send the rendered instructions to one or more client computers through protocol server module  338 . Instructions that are programmed and/or configured to generate and/or update a dynamic credential may be referred to herein as dynamic-credential instructions or credential-morphing instructions. 
     Forward transformer  336  may generate one or more dynamic-credential instructions, which if executed are configured to cause a browser to request, receive, generate, and/or update one or more challenge credentials. A challenge credential may be static or change over time. A response credential may be a credential that corresponds to one or more challenge credentials. A challenge-response credential pair is a challenge credential and a response credential, wherein the response credential corresponds to the challenge credential. Forward transformer  336  may store one or more challenge credentials, and/or data indicating which response credentials correspond to which challenge credentials, in storage  240 . Forward transformer  336  may send challenge credentials and/or dynamic-credential instructions to one or more client computers through protocol server module  338 . 
     Although a challenge-response credential pair refers to a challenge credential and a response credential that corresponds to the challenge credential, the response credential need not be generated or stored on the same computer or computer readable memory that stores the challenge credential. The response credential may be generated, on the fly, based on the challenge credential as discussed further herein. 
     A value associated with a challenge-response credential pair may mean a value that is stored or associated with, or derived from, the challenge credential and/or the response credential in the challenge-response credential pair. For purposes of illustrating a clear example, assume a challenge credential in a challenge-response credential pair is stored in storage  240  without the corresponding response credential, which may be deterministically generated based on one or more values in the challenge credential. A count and/or a timestamp may be stored in a data structure in storage  240  indicating that the count and/or timestamp are associated with the challenge credential. Although the response credential that corresponds to the challenge credential is not yet generated or stored, the count and/or the timestamp are associated with the challenge-response credential pair because the count and/or timestamp is associated with the challenge credential. 
     A challenge credential may comprise one or more values. For example, a challenge credential may include a timestamp, a nonce, a count, and/or a hash that was generated based on the timestamp, the nonce, and/or the count. A response credential may comprise may comprise one or more values, such as a value based on a corresponding challenge credential, a timestamp, and/or a count. The one or more values in a challenge credential and/or a response credential may be encrypted. In an embodiment, a key to encrypt and/or decrypt the one or more values may be associated with a challenge-response credential pair and/or stored in storage  240 . 
     3.2.4 Protocol Server Module 
     Protocol server module  338  may receive the instructions generated by forward transformer  336  and send the generated instructions to client computer  299 . Additionally or alternatively, protocol server module  338  may intercept requests from client computer  299  and forward the requests to credential validation module  340 . 
     3.2.5 Credential Validation Module 
     Credential validation module  340  may receive requests intercepted by protocol server module  338  from browser  295 . Credential validation module  340  may validate requests and/or credentials, and forward the requests for one or more pages to reverse transformer  342 . 
     Credential validation module  340  may generate one or more dynamic credentials. For example, forward transformer  336  may render a page and embed a dynamic credential received from credential validation module  340  into the page. Also for example, in response to a request from a client computer for a dynamic credential, credential validation module  340  may generate a new, valid dynamic credential and send the new dynamic credential to the client computer through protocol server module  338 . 
     Credential validation module  340  may generate one or more parameters associated with a challenge and/or a response credential. For example, credential validation module  340  may store a credential, a timestamp, a count, a minimum count, a maximum count, and an Internet Protocol (“IP”) address in storage  240  associated with a challenge and/or response credential. As discussed in detail herein, credential validation module  340  may validate a request with the stored credential based on the timestamp and the IP address associated with the stored credential. 
     Credential validation module  340  may generate one or more challenge credentials. If credential validation module  340  receives a response credential and a challenge credential, then credential validation module  340  may determine whether the response credential is valid based on the challenge credential. For example, if credential validation module  340  determines that a response credential, which belongs to a challenge-response credential pair, corresponds with a challenge credential in the challenge-response credential pair, then credential validation module  340  may determine that the response credential is valid; otherwise, credential validation module  340  may determine that the response credential is not valid. 
     Credential validation module  340  may authorize requests based on configuration  232 . For purposes of illustrating a clear example, assume that configuration  232  includes data indicating that a particular web page is public. In response to a request for the particular web page, which does not include a dynamic credential, credential validation module  340  may authorize the request based on configuration  232 . 
     3.2.6 Reverse Transformer 
     Reverse transformer  342  may translate requests intercepted by protocol server module  338 , which are based on instructions generated by forward transformer  336 , into requests that would have been generated by browser  295  had browser  295  received the original instructions sent from web infrastructure  205 . For example, if a request from browser  295  includes a dynamic credential generated by credential validation module  340 , then reverse transformer  342  may generate a new request that does not include the dynamic credential. Reverse transformer  342  may send the new request web infrastructure  205  through protocol client module  332  on behalf of browser  295 . 
     3.2.7 Configurations 
     Configuration  232  may be a database, a configuration file, and/or any other system that stores configurations: settings, preferences, and/or protocols. Configuration  232  may store more than one configuration for one or more web servers in web infrastructure  205 . For example, configuration  232  may include data that indicates requests to a particular server computer in web infrastructure  205  need not be validated. Additionally or alternatively, configuration  232  may include data that indicates requests for a particular web page need not be validated. Additionally or alternatively, configuration  232  may include data that indicates requests to submit data to a particular web site need not be validated. Also for example, configuration  232  may include data that indicates whether particular web pages should be processed by processing engine  334  and/or modified by forward transformer  336 . 
     Configuration  232  may be modified by a user and/or administrator through one or more computers, such intermediary computer  230 , a computer in web infrastructure  205 , and/or any other computer. The one or more computers may present the user with an interface that presents the user with a site map. The site map may comprise a graph, wherein the nodes correspond to pages and the edges between the nodes correspond to links. 
     The user may update configuration  232 , through the interface, by selecting which links and/or pages to be “public” (do not require a valid credential) and which links and/or pages are “private” (require a valid credential). For example, the interface may receive input from a user indicating that a page is public. Configuration  232  may be updated accordingly. When a request is received for the particular page, even if the request does not have a valid credential, intermediary computer  230  may pass the request to web infrastructure  205 . Also for example, the interface may receive input from a user indicating that a link, with a particular link identifier, is public. When intermediary computer  230  receives a request that includes a particular link identifier, then intermediary computer  230  may pass the request to web infrastructure  205  even if the request does not have a valid credential. 
     The user may update configuration  232 , through the interface, by selecting which links and/or pages to be “non-counting” (do not increment a count associated with a credential) and which links and/or pages are “counting” (increment a count associated with a credential). For example, the interface may receive input from a user indicating that a page is non-counting. Configuration  232  may be updated accordingly. When a request is received for the particular page with a credential that is associated with a count, intermediary computer  230  may pass the request to web infrastructure  205  without incrementing a count associated with the valid credential. Also for example, the interface may receive input from a user indicating that a link and/or reference with a particular identifier is non-counting. When a request is received that includes the particular identifier with a valid credential, intermediary computer  230  may pass the request to web infrastructure  205  without incrementing a count associated with the valid credential. Additionally or alternatively, a link and/or page that configuration  232  identifies as public may be non-counting. 
     3.2.8 Storage 
     Storage  240  may be a cache, a database, a configuration file, and/or any other system and/or data structure that stores data. In  FIG. 2 , storage  240  is illustrated as if a separate computer from intermediary computer  230 . Additionally or alternatively, storage  240  may be a data structure stored in memory on the one or more computers comprising intermediary computer  230 . Additionally or alternatively, storage  240  may, at least in part, be a data structure stored in shared memory between one or more intermediary computers. Additionally or alternatively, intermediary computer  230  may, at least in part, be stored in volatile and/or non-volatile memory. 
     3.3 Browser 
     Browser  295  may be a browser as described herein and executed on a client computer, such as client computer  299 . Additionally or alternatively, browser  295  may be a bot comprising one or more of the components traditionally found in a browser. 
     4.0 Process Overview 
     In an embodiment, a data processing method may be configured to intercept instructions from a server computer that are directed toward a browser, modify the intercepted instructions, include one or more credential-morphing instructions, render a second set of instructions comprising the modified set of instructions and one or more credential-morphing instructions. In an embodiment, a data processing method may be configured to receive requests from a browser for a new credential from a client application, validate the request using a previous credential, generate the new credential, and send the new credential to the browser. In an embodiment, a data processing method may be configured to receive requests from a client computer for data on a server computer, validate the request based on a dynamic credential. In an embodiment, if the request is valid, then the processing method may be configured to modify the request, send the modified request to a server computer, receive data from the server computer in response to the modified request, and/or send a response to a client computer. 
     In an embodiment, a credential may be associated with a count, and a credential may be determined to be invalid if the count associated with the credential satisfies a particular threshold. A threshold may be an exact threshold, and a value may satisfy the threshold if the value is equal to the threshold. Additionally or alternatively, a threshold may be an upper bound threshold, and a value may satisfy the threshold if the value is greater than the threshold. Additionally or alternatively, a threshold may be a lower bound threshold, and a value may satisfy the threshold if the value is less than the threshold. Additionally or alternatively, a threshold may be an equivalent threshold, and a value may satisfy the threshold if the value is equivalent to the threshold. Additionally or alternatively, a threshold may be one or more of the thresholds listed above. For example, a threshold may be an exact threshold and an upper bound threshold, and a value may satisfy the threshold if the value is equal to, or greater than, the threshold. 
     Various embodiments may use standard web protocols, such as HTTP, and/or standard web-based instructions, such as HTML, CSS, and/or JavaScript. Additionally or alternatively, other standard and/or proprietary protocols may be used. Additionally or alternatively, other standard and/or proprietary instructions may be used. 
     4.1 Intercepting Instructions from a Content Server Computer 
       FIG. 4  illustrates a process for validating requests from browsers, and filtering out requests from bots, using one or more count-based dynamic credentials in an example embodiment. In step  410 , an intermediary computer intercepts, from a first computer, a first set of instructions that define one or more original operations, which are configured to cause one or more requests to be sent if executed by a client computer. For example, protocol client module  332  may receive instructions from web infrastructure  205 . The instructions may comprise HTML, CSS, and/or JavaScript may define a web page. A web page may include data, such as objects, links, fields, forms, Uniform Resource Locators (“URLs”), that a browser may use to generate a request for additional data, such as another web page. A web page may be a sub-page of another page and/or include one or more other web pages. A browser may generate a request based on the data in the web page. 
     4.2 Modifying Instructions Which Cause a Browser to Submit a Credential with One or More Requests 
     In step  420 , the intermediary computer modifies the first set of instructions to produce a modified set of instructions, which if executed are configured to cause a credential associated with a count to be included in the one or more requests sent by the client computer. For purposes of illustrating a clear example, assume that the instructions received in the previous step comprise HTML, CSS, and JavaScript instructions that define a link, which a browser or bot may use to generate a request for additional data and/or instructions. Processing engine  334  may parse the instructions. Forward transformer  336  may identify the link processed by processing engine  334 . Forward transformer  336  may modify the instructions that define the link, such that if the link is selected by a user using a browser, then the browser executes a JavaScript callback that causes the browser to modify the URL, one or more parameters in the URL, and/or data submitted in a request based on the URL, to include a dynamic credential. The dynamic credential may include a count or be associated with a count that is stored in storage  280 . The count may be encrypted. Accordingly, when the browser generates the request based, at least in part on the URL, the request includes a dynamic credential. The foregoing is an example of a technique for modifying instructions to cause a browser to include a credential in a URL. Other embodiments may use one or more other techniques. 
     For purposes of illustrating another clear example, assume that the instructions received in the previous step define a form that is associated with a submit method. The submit method may be configured to collect data from one or more of the fields in the form and send the collected data in a request, such as an HTTP POST request, to a server computer. After processing engine  334  parses the instructions, forward transformer  336  may add a new field in the form that includes a dynamic credential that includes or is associated with a count. Accordingly, when the submit method is executed, the browser may generate a request that includes the credential stored in the added field with other data from other fields in the form. Additionally or alternatively, forward transformer may generate a wrapper for the previously defined submit method. The wrapper may be configured to call the previously defined submit method and tack on a credential in the payload of the request. 
     Additionally or alternatively, intermediary computer  230  may determine whether to parse and/or modify instructions based on configuration  232 . For example, if protocol client module  332  receives a set of original instructions in response to a request for a particular web page, and configuration  232  includes data that indicates the particular web page is a public page and/or should not be modified, then processing engine  334  and/or forward transformer  336  may send the original instructions to the intended client computer without processing or modifying the instructions. Also for example, if processing engine  334  and/or forward transformer  336  determine that a set of instructions define a particular link to a particular target page and/or URL, and if configuration  232  includes data that indicates the particular link and/or the particular target page and/or URL are protected, then forward transformer  336  may modify the instructions that define the particular link. Similarly, if processing engine  334  and/or forward transformer  336  determine that a set of instructions define a particular link to a particular target page and/or URL, and if configuration  232  includes data that indicates the particular link and/or the particular target page and/or URL are public, then forward transformer  336  may modify the instructions that define the particular link. 
     In the above examples, the modified instructions may be executed by a browser using one or more particular parsers and/or execution environments, such as JavaScript parser  114 , extension execution environment  116 , and/or JavaScript execution environment  120 . Thus, a bot without the particular parser(s) and/or execution environment(s) needed to parse and execute the modified instructions may not generate a request that includes a dynamic credential. Accordingly, a request for instructions and/or data from a bot may be dismissed, ignored, and/or otherwise responded to in a negative manner. 
     The modified instructions need not include a valid credential. The modified instructions may cause a credential to be included in one or more requests sent by the client computer. How a valid dynamic credential is requested, received, and/or generated is discussed in detail herein. 
     4.2.1 Causing a Browser to Submit a Credential with One or More Requests Using a Browser Cookie 
     In one or more of the examples above, instructions that define an object, such as a link, field, button, and/or form, are modified to cause a browser to include a credential in a subsequent request. In another embodiment, an intermediary computer may include one or more instructions that cause a browser to send one or more credentials in a subsequent request without modifying the instructions that define an object in a web page that the subsequent request is based on. For example, an intermediary computer may include one or more instructions that store a credential as a browser cookie. A browser cookie may include data, such as one or more credentials or credential parameters. A browser cookie may include one or more cookie parameters, such as a count, a timestamp, an expiration date and time, a domain, and/or path. If the browser makes a request and the one or more cookie parameters, if any, are satisfied, then the browser may include the data in the browser cookie, such as a credential, in the request. A browser cookie that includes one or more credentials, and/or one or more credential parameters, may be referred to herein as a credential cookie. A credential cookie may include a dynamic credential, a challenge credential, a response credential, and/or a challenge-response credential pair. 
     Instructions, which when executed by a browser may store a credential and/or credential parameters as one or more browser cookies, may be referred to herein as credential-cookie instructions. In various embodiments, credential-cookie instructions may comprise HTML and/or JavaScript instructions. Credential-cookie instructions may comprise, and/or be included in, dynamic-credential instructions and/or credential-morphing instructions. Credential-cookie instructions may store one or more credentials, and/or one or more credential parameters, as one or more credential cookies. 
     Credential-cookie instructions for a credential may be encoded as structured data, such as XML and/or HTML. The structured data may be included in a particular section in a document, such as a header section in an HTML document. A browser and/or a bot may parse the credential-cookie instructions comprising structured data and generate a credential cookie as discussed herein, without one or more instructions in a programming language that are configured to be executed in an execution environment. For example, forward transformer  336  may generate credential-cookie instructions that comprises a protocol header and/or structured data object that define a challenge credential as a credential cookie without including one or more JavaScript instructions configured to generate, process, and/or update the challenge credential. In an embodiment, the credential-cookie instructions may be a single line of structured data. 
     Additionally or alternatively, credential-cookie instructions may comprise executable instructions configured to be executed in an execution environment, which causes the execution environment in a browser to generate and/or update a credential as discussed herein. For example, forward transformer  336  may generate credential-cookie instructions that include dynamic-credential instructions that define, generate, and/or update a dynamic credential stored in a credential cookie. Accordingly, in an embodiment, a challenge credential may be generated by a browser and/or bot without executing one or more JavaScript instructions configured to generate, process, and/or update the challenge credential; however, a browser may execute one or more JavaScript instructions configured to generate, process, and/or update a dynamic credential for the same web page. If a bot does not include a JavaScript execution engine, then the bot may generate the challenge credential, but may not generate, process, and/or update a dynamic credential for the same web page. 
     Forward transformer  336  may include credential-cookie instructions into one or more files and/or instructions that define a web page, without modifying the instructions that define an object in the web page. Additionally or alternatively, forward transformer  336  may include credential-cookie instructions in a separate file, and include a reference to the separate file in the web page, without modifying the instructions that define an object in the web page. In an embodiment, forward transformer  336  may generate credential instructions that are configured to cause browser  295  to generate a credential after a web page has finished loading. For example, dynamic-credential instructions may be configured to be executed, at least partially, in response to browser  295  calling an “onload” page event and/or callback. In an embodiment, dynamic-credential instructions may comprise one or more credential-morphing instructions. 
     For purposes of illustrating a clear example of an intermediary computer performing step  420  using a credential cookie, assume that the instructions received in step  410  comprise HTML, CSS, and JavaScript instructions that define a web page with a link, which a browser or bot may use to generate a request for additional data. Forward transformer  336  may include credential-cookie instructions that define a cookie credential in the HTML, CSS, and JavaScript instructions received in the previous step. Accordingly, if the link is selected by a user using a browser, then the browser may generate a request based on the link, and the request may include one or more credentials, and/or credential parameters, stored in the cookie credential. 
     4.3 Rendering a Second Set of Instructions Comprising Credential-Morphing Instructions 
     In step  430 , the intermediary computer renders a second set of instructions comprising the modified set of instructions and one or more credential-morphing instructions. The one or more credential-morphing instructions may define one or more operations causing a browser with a particular parser and/or execution environment to request, receive, generate, and/or update a valid credential that changes over time. For example, forward transformer  336  may render a second set of instructions that include the modified instructions and credential morphing-instructions comprising one or more JavaScript instructions, which if parsed and/or executed are configured to cause a browser to request, receive, generate, and/or update a valid credential that changes over time. Additionally or alternatively, forward transformer  336  may include the credential-morphing instructions by including a reference to a file with credential-morphing instructions, such as an additional JavaScript file, in the rendered instructions. 
     If a bot does not have the particular parser and/or execution environment necessary to execute the credential-morphing instructions, then the bot may not have a valid dynamic credential to submit with a subsequent request. Accordingly, subsequent requests from bots may be dismissed, ignored, and/or otherwise negatively dealt with as discussed herein. However, requests from browsers may be processed as if uninterrupted by an intermediary. 
     4.4 Sending the Modified and Credential-Morphing Instructions to the Client Computer 
     In step  440 , the intermediary computer sends the second set of instructions, which comprise the modified instructions and the credential morphing-instructions to the client computer. For example, forward transformer  336  may send the modified instructions in step  420  and the credential-morphing instructions in step  430  to browser  295 . 
     4.5 Updating the Credential over Time 
     In step  450 , the client computer parses and/or executes the credential-morphing instructions and updates the credential over time. The credential-morphing instructions may cause the client computer, and/or browser executing on the client computer, to perform one or more methods to update a credential over time. In an embodiment, the credential may be stored in storage on a client computer, intermediary computer, and/or storage. The storage may, but need not be, non-volatile storage. When a new credential is received and/or generated, the old credential is deleted. Each newly received and/or generated credential may replace a previous credential at the particular address in memory that the previous credential was stored. 
       FIG. 5  illustrates a process for updating a credential over time in an example embodiment. In step  510 , the intermediary computer receives a request for a new credential. For purposes of illustrating a clear example, assume that browser  295  receives the second set of instructions sent in step  440 , and that the credential-morphing instructions, if executed, are configured to cause browser  295  to request a new credential from intermediary computer  230 . Accordingly, browser  295  may parse and/or execute the credential-morphing instructions using JavaScript parser  114  and JavaScript execution environment  120  to send a request for a new credential to intermediary computer  230 . If browser  295  has already received and/or generated a credential, then browser  295  may send one or more of the previously received and/or generated credential in the request. Protocol server module  338  may receive the request and forward the request to credential validation module  340 . 
     4.6 Validating a Credential 
     In step  520 , the intermediary computer determines whether the credential is valid. For example, credential validation module  340  may determine that the old credential is valid if it is stored in storage  240  and/or other storage device. Additionally or alternatively, credential validation module  340  may determine that a credential is valid based on one or more implied and/or express parameters. If credential validation module  340  determines that each of the parameters is satisfied, then control may pass to step  525 . Otherwise, control may pass to step  480 . For example, if a count is associated with the credential, and an “overused” threshold is defined in configuration  232  or associated with the credential, and the count satisfies the overused threshold, then control may proceed to step  480 ; otherwise, control may pass to step  525 . 
     Credential validation module  340  may delete a credential and/or one or more parameters associated with the credential after credential validation module  340  validates the credential. Thus, credential validation module  340  need not validate the same credential more than once. 
     Bots may request additional web pages quickly compared to a user viewing a page and selecting a link. To thwart and slow down one or more requests from bots, a credential may have a parameter that indicates the credential is invalid for a first amount of time before it becomes valid for a second period of time. Thus, if a bot is able to determine a valid credential and quickly sends a request with the credential to the intermediary computer, the intermediary computer may determine that the credential is invalid and pass to step  480 . 
     A credential may be associated and/or embedded with one or more implied and/or express parameters. For example, a credential may be, and/or be associated with, a count, a timestamp, a time range, an IP address, a subnet, a browser identifier, a username, a password, a keyword, a randomly generated value, and/or any other identifier and/or key that may be used to determine whether a credential is valid. For example, if credential validation module  340  determines that a timestamp represents an expiration time that is associated with the credential, and the current time is equal to, or greater than, the timestamp, then control may proceed to step  480 ; otherwise, control may pass to step  525 . Also for example, if credential validation module  340  determines that a timestamp represents a time at which the credential was created and/or last used is associated with the credential, and an “expiration time” threshold is defined in configuration  232  or associated with the credential, and the timestamp satisfies the expiration time threshold, then control may proceed to step  480 ; otherwise, control may pass to step  525 . 
     In step  525 , the intermediary computer determines whether the credential is associated with a count that satisfies an exhausted threshold. If so, then control may proceed to step  530 ; otherwise, control may proceed to step  526 . For example, if credential validation module  340  determines that a count is associated with the credential, and an “exhausted” threshold is defined in configuration  232  or associated with the credential, and the count satisfies the exhausted threshold, then control may proceed to step  530 ; otherwise, control may pass to step  526 . The exhausted threshold hold may be implied by the overused threshold. For example, the exhausted threshold may be one less than the overused threshold if the count is incremented after each use. The overused threshold may be implied by the exhausted threshold. For example, the overused threshold may be one greater than the exhausted threshold if the count is incremented after each use. 
     In step  526 , the intermediary computer determines whether the count associated with the credential should be incremented. If so, then control may pass to step  528 ; otherwise, control may pass to step  460 . For example, if credential validation module  340  determines a count is associated with a credential, the credential is valid, the credential has not been exhausted, and that the request is not a type of request that should cause credential validation module  340  to increment the count, then credential validation module  340  may proceed to step  460  without incrementing the count. If credential validation module  340  determines a count is associated with a credential, the credential is valid, the credential has not been exhausted, and the request is a type of request that should cause credential validation module  340  to increment the count, then credential validation module  340  may proceed to step  528 . 
     The type of request may be determined based on data in the request. For example, if a request is for an asset of a web page with a particular extension, such as “PNG”, “JPEG”, “CSS”, or “JS”, then credential validation module  340  may determine that the request is not the type of request that should increment the count associated with a valid credential. 
     Also for example, instructions, such as credential morphing instructions, may define one or more new operations that override one or more AJAX operations. The one or more new operations may cause one or more AJAX requests to include one or more parameters that indicate that the one or more AJAX requests are a type of request that should not cause credential validation module  340  to increment a count associated with a valid credential. Accordingly, in response to receiving a request with the one or more parameters that indicate that the request an AJAX request, credential validation module  340  may proceed to step  480  without incrementing the count. 
     In step  528 , the intermediary computer increments the count associated with the valid credential. For example, in response to receiving a request that is valid and associated with a count that should be incremented, credential validation module  340  may increment the count. Credential validation module  340  may increment a count by one or another value defined in configuration  232  or associated with the credential. In an embodiment, credential validation module  340  increments a count by a negative value, such as negative one. Accordingly, credential validation module  340  may determine that the count has been exhausted if the count is zero, and/or the count has been overused if the count is less than zero. After incrementing the count, control may proceed to step  460 . 
     4.6.1 Implied Parameters 
     An implied parameter may be a parameter that is inherent to the credential. For example, a credential may be based on time, and credential validation module  340  may determine the time from the credential. Credential validation module  340  may be configured to determine that a credential is valid if the determined time is within a particular amount of time from the current time. Similarly, credential validation module  340  may be configured to determine that a credential is invalid if the determined timestamp identifies a time that is outside a particular amount of time from the current time. 
     4.6.2 Express Parameters 
     An express parameter may be a parameter that is associated with, and/or embedded in, a credential. For example, a credential may be associated with a count stored in storage  240  or encrypted in the credential. Also for example, a credential may be associated with a parameter stored in storage  240 , which indicates the time at which the credential is no longer valid. Credential validation module  340  may query for the parameter stored in storage  240  based on the credential. If the current time is less than the time retrieved from storage  240 , then credential validation module  340  may determine that the old credential is valid. Otherwise, credential validation module  340  may determine that the credential is invalid. 
     A credential need not expressly be associated with a count. However, if a valid credential is not associated with a count, then credential validation module  340 , in step  520 , may generate a new count with an initial value preprogrammed into credential validation module  340  or stored in storage  240  or configuration  232 . 
     Additionally or alternatively, a credential may include one or more encrypted parameters. Instead of storing one or more parameters in storage  240 , credential validation module  340  may generate a credential that comprises one or more encrypted parameters. Credential validation module  340  may validate the credential by decrypting the one or more encrypted parameters and determining whether each of the decrypted parameters is satisfied. If so, then credential validation module  340  may determine the credential is valid. Otherwise, credential validation module  340  may determine the credential is invalid. 
     4.7 Generating a New Credential 
     In step  530 , the intermediary computer generates a new credential. For example, credential validation module  340  may generate a new credential with one or more implied and/or express parameters. The one or more parameters may include any of the parameters discussed above, and/or any other value, identifier, and/or key that may be used to determine whether the new credential is valid. Credential validation module  340  may store the new credential and/or the one or more parameters in storage  240 . For example, credential validation module  340  may generate a new credential and store a new count associated with the new credential in storage  240 . Additionally or alternatively, credential validation module  340  may embed one or more parameters in the new credential. 
     4.7.1 Generating a First Credential 
     Intermediary computer  230  may not have an old credential to validate. For example, when a browser, such as browser  295 , requests a page and/or credential from intermediary computer  230  for the first time, browser  295  may not have an old credential for intermediary computer  230  to validate. If intermediary computer  230  receives a request for a new credential without an old credential to validate, then intermediary computer  230  may generate a credential as discussed in detail herein. Additionally, the credential may be an “initialization credential”, which may be used by the browser, and/or the credential-morphing instructions, to request a new valid credential. In an embodiment, an initialization credential may be associated with a count, an overused threshold, and/or exhausted threshold. 
     If intermediary computer  230  receives a request from browser  295  for a new credential with an initialization credential and determines the initialization credential is valid, then intermediary computer  230  may respond with a valid new credential as discussed herein. However, if intermediary computer  230  receives a request from browser  295  for a web page from web infrastructure  205  with an initialization credential, then control may pass to step  480 . 
     In an embodiment, forward transformer  336  may include a credential with the credential morphing-instructions. The credential may be an initialization credential. However, in an embodiment, forward transformer  336  need not include a credential with the credential morphing-instructions. 
     4.8 Sending a New Credential 
     In step  540 , the intermediary computer may send the new credential to the client computer. For example, credential validation module  340  may send the credential to browser  295  through protocol server module  338 . 
     In an embodiment, credential validation module  340  may send the new credential to forward transformer  336 . Forward transformer  336  may generate one or more new credential-morphing instructions which when executed operate on the credential and/or request a new credential. For example, if executed, the one or more instructions may be configured to replace the previous credential in memory on the client computer. Additionally or alternatively, if executed, the one or more instructions may be configured to indicate when the client computer and/or browser should send a new request for a new credential. Additionally or alternatively, if executed, the one or more instructions may be configured to generate a new credential. 
     4.8.1 Sending a Seed Value from Which the New Credential may be Generated 
     Forward transformer may generate a seed value from a new credential generated by credential validation module, which may be used to generate the new credential by the client computer.  FIG. 6  illustrates a process for generating a seed value and sending the seed value to the client computer to generate one or more new credentials in an example embodiment. In step  610 , the intermediary computer  230  generates a seed. For purposes of illustrating a clear example, assume forward transformer  336  receives a new credential from credential validation module  340  to be sent to a browser. Forward transformer  336  may generate a seed value based on the new credential. The seed value may be a timestamp and/or nonce. The seed value may be a challenge credential. 
     In step  620 , the intermediary computer sends the seed value to the client computer. For example, forward transformer  336  sends the seed value to browser  295 . 
     In step  630 , the client computer generates a new credential based on the seed or a previous credential. For example, browser  295  may execute one or more credential-morphing instructions, which may be configured to generate a valid credential based on a seed received from intermediary computer  230 . The valid credential generated by the one or more credential-morphing instructions and based on the seed may be referred to as a dynamic credential. In an embodiment, over time, browser  295  may execute the credential-morphing instructions again to generate a new valid credential based on one or more previously generated valid credentials and/or seeds. 
     4.9 Updating a Credential over Time 
     The intermediary computer may repeat step  450  according to the credential-morphing instructions. For example, the credential morphing-instructions may define a time period, after which a browser should request, receive, generate, and/or update a new credential as discussed in detail herein. 
     Forward transformer  336  may render and send one or more new credential morphing-instructions with each credential and/or a seed, which if executed, may be configured to cause the client computer and/or browser to request and/or generate a new credential. The one or more new credential-morphing instructions may be different than one or more previously sent credential-morphing instructions. 
     4.10 Validating a Request for Data 
     Returning now to  FIG. 4 , in step  460 , the intermediary intercepts a request for data. For example, protocol server module  338  may receive a request from browser  295  for data and/or instructions, such as a web page, from web infrastructure  205 . 
     In step  470 , the intermediary computer determines whether the request is valid by determining if the credential included in the request, if any, is valid. For example, protocol server module  338  may forward the request to credential validation module  340 . Credential validation module  340  may determine whether the credential is valid based on one or more of the methods discussed herein. If credential validation module  340  determines the credential is valid, then control passes to step  490 . Otherwise, control passes to step  480 . If credential validation module  340  determines that the request does not include a credential and the request is for a private page and/or based on a private link and/or reference, then control may pass to step  480 . If credential validation module  340  determines that the request for data includes an initializing credential, then control may pass to step  480 . 
     If configuration  232  includes data indicating that the data requested is public, such as a home page of a web site, then credential validation module  340  may determine that the request is valid, even though the request did not include a credential. In response, control may pass to step  490 . If, however, configuration  232  includes data indicating that the data requested is public, but the request includes an invalid credential, then control may pass to step  480 . 
     4.11 Performing a Negative Responsive Action 
     In step  480 , the intermediary computer performs a negative responsive action. For example, credential validation module  340  may terminate the request. Additionally or alternatively, credential validation module  340  may treat the request as a request for an initializing credential, and in response, generate and send the initializing credential and/or seed value to browser  295  via forward transformer  336 , as discussed herein in detail. Additionally or alternatively, the intermediary computer  230  may respond with a message defined by a user and/or administrator through a client computer and/or the intermediary computer. Additionally or alternatively, intermediary computer  230  may respond with one or more standard and/or proprietary error codes and/or messages. For example, intermediary computer may return HTTP error code  400  and a message “Bad Request” to browser  295  and/or client computer  299 . Intermediary computer may send a configurable response that indicates the request was invalid; the configurable response may be selected by an administrator and/or stored in configuration  232 . 
     4.12 Forwarding the Request to a Server Computer 
     In step  490 , the intermediary computer forwards the request for data to the server computer. For example, credential validation module  340  may pass the request to reverse transformer  342 . Reverse transformer  342  may strip out data relating to the credential and produce a new request that would have been generated by browser  295  had the original instructions been received by browser  295 . Reverse transformer  342  may send the new request to web infrastructure  205  through protocol client module  332 . 
     If web infrastructure  205  responds to a forwarded request with data and/or instructions, then intermediary computer  230  may repeat one or more of the steps discussed herein. For example, intermediary computer  230  may perform step  410  in response to receiving the new data and/or instructions from web infrastructure  205 . 
     5.0 Process Overview Using Challenge-Response Credential Pairs 
     In an embodiment, an intermediary computer may be configured to inject one or more challenge-response credential pairs into one or more instructions that define a web page, a portion of a web page, and/or data to be included in a web page, and send the one or more instructions with the one or more challenge-response credential pairs to a client computer. Each challenge-response credential pair may be a dynamic credential. In response to a request from the client computer, the intermediary may be configured to receive the request, and determine whether the request includes a valid response credential based on a corresponding challenge credential. If the intermediary determines that the response credential is valid, then the intermediary computer may forward the request to a server computer; otherwise, the intermediary may perform one or more negative responsive actions. 
       FIG. 7  illustrates a process for validating requests from browsers, and filtering out requests from bots, using one or more dynamic, challenge-response credential pairs, in an example embodiment. In step  710 , an intermediary computer intercepts, from an application server computer, a first set of instructions that define one or more original operations, which are configured to cause one or more requests to be sent if executed by a client computer. For example, protocol client module  332  may receive instructions from web infrastructure  205 . The instructions may comprise HTML, CSS, and/or JavaScript that define a web page. A server computer included in web infrastructure, and/or a server computer that hosts one or more instructions that comprise a web page, may be referred to herein as an application server computer. 
     5.1 Generating a Challenge-Response Credential Pair 
     In step  720 , the intermediary computer generates a challenge credential in a challenge-response credential pair. For purposes of illustrating a clear example, assume configuration  232  includes data that indicates a challenge credential should be a random value selected from a particular distribution, such as a uniform distribution or a Gaussian distribution with a particular mean, variance, maximum and minimum. Forward transformer  336  may request a challenge credential from credential validation module  340 . Credential validation module  340  may select a value according to the Gaussian distribution and send the value to forward transformer  336 . Forward transformer  336  may render credential-cookie instructions that cause the challenge credential to be included in a cookie. 
     In an embodiment, credential validation module  340  may generate a challenge credential that comprises a nonce, a timestamp, one or more other values, and/or one or more hashes based on the nonce, the timestamp, and/or the one or more other values. The one or more values may comprise, among other things, a count, an overused threshold, an exhausted threshold, and/or an expiration timestamp. 
     5.1.1 Deterministically Generating a Challenge Credential 
     In an embodiment, credential validation module  340  may generate a challenge credential deterministically. For example, credential validation module  340  may generate a first timestamp that represents a current time since epoch and a first nonce that is generated from a deterministic pseudo-random number generator using the first timestamp as a seed value. 
     A deterministic process is a process that generates the same output for the same input using one or more operations. For example, a process that adds 20 to any number given as input is a deterministic process. If 10 is the input, then this deterministic process will produce 30 as the result. This deterministic process will always return 30 if 10 is the input. 
     Credential validation module  340  may comprise a deterministic pseudo-random number generator that generates a nonce deterministically from a timestamp and/or other value(s), such that credential validation module  340  will produce the same nonce in response to receiving the same timestamp and/or other value(s) as input. The input may be referred to as a seed. However, a deterministic pseudo-random number generator may generate a first number in response to a first seed and a second number in response to a second seed, and the first number and the second number may be different. 
     Credential validation module  340  may generate one or more first hashes that are based on the first nonce, the first timestamp, a secret key, and/or the one or more other values. Each hash may be generated using a deterministic hashing function, such as an MD5 hash generator or SHA1 hash generator. Accordingly, the first challenge credential in a first challenge-response credential pair may comprise the first nonce, the first timestamp, one or more other first values, and/or the one or more first hashes based on the first nonce, the first timestamp, one or more other first values. The secret key may be preprogrammed into credential validation module  340  and/or stored in memory coupled to credential validation module  340 . 
     Generating a nonce may be a deterministic process comprising one or more operations. 
     5.1.2 Generating a Response Credential for the Challenge-Response Credential Pair 
     A challenge-response credential pair comprises a challenge credential and a response credential, wherein the response credential is based on, or associated with, the challenge credential. In an embodiment, credential validation module  340  may generate a response credential comprising one or more values that are based on one or more features in a challenge credential and/or one or more operations. Accordingly, credential validation module  340  may generate a challenge-response credential pair by generating a first challenge credential and a corresponding first response credential. 
     There are many ways that credential validation module  340  may generate a response credential that corresponds to, and/or is based on, the challenge credential. For purposes of illustrating a clear example, assume the challenge credential is an integer, and configuration  232  includes data that indicates a valid response credential should be the result of an operation based on the challenge credential, such as the product of the challenge credential, a prime number, and/or a current number of seconds since an epoch. Credential validation module  340  may generate a challenge-response credential pair, wherein the response credential is a multiple of the challenge credential generated in the previous step, the prime number, and/or the current number of seconds since the epoch. 
     For purposes of illustrating another clear example, assume configuration  232  includes data that indicates a response credential should be a random value selected from a particular distribution, such as a uniform distribution ranging from a minimum value to a maximum value. Credential validation module  340  may generate a response credential with a random value selected according to the uniform distribution. 
     5.1.3 Deterministically Generating a Challenge-Response Credential Pair 
     In an embodiment, credential validation module  340  may deterministically generate a response credential based on one or more values in a challenge credential and one or more operations. Accordingly, to deterministically generate a challenge-response credential pair, credential validation module  340  may generate a challenge credential, but need not generate or store the response credential, because credential validation module  340  can determine the correct response credential that corresponds to a challenge credential if credential validation module  340  is given the challenge credential. 
     Deterministically generating a challenge-response credential pair may be useful for many reasons. For example, credential validation module  340  may store the challenge-response credential pair in storage  240  by storing the challenge credential without generating or storing the corresponding response credential. Additionally or alternatively, a first intermediary computer may validate a test challenge-response credential pair received from a client computer without querying storage  240  for a particular challenge-response credential pair that matches the test challenge-response credential pair or receiving the particular challenge-response credential pair from a different intermediary computer that generated the particular challenge-response credential pair. The intermediary computer that generated the particular challenge-response credential pair need not send the particular response credential in the particular challenge-response credential pair to a client computer or another intermediary computer. 
     5.1.4 Storing a Challenge-Response Credential Pair 
     Credential validation module  340  may store a challenge-response credential pair in storage  240 . Credential validation module  340  may store a challenge-response credential pair in storage  240  by storing a challenge credential and a response credential with data, and/or in a data structure, that indicates the challenge credential and the response credential are a challenge-response credential pair. If credential validation module  340  deterministically generates a response credential based on a challenge credential and one or more deterministic processes, then credential validation module  340  may store the challenge-response credential pair in storage  240  by storing the challenge credential in the challenge-response credential pair, without generating or storing the corresponding response credential. 
     Credential validation module  340  may store, in storage  240 , data that is associated with the challenge-response credential pair. The data that is associated with the challenge-response credential pair may, but need not, be included in the challenge credential and/or the response credential in the challenge-response credential pair. For example, credential validation module  340  may store a count, a timestamp, and/or one or more other values in storage  240  with data, and/or in a data structure, that associates the count, the timestamp, and/or the one or more other values with the challenge-response credential pair. 
     5.2 Rendering One or More Dynamic-Credential Instructions 
     In step  730 , the intermediary computer renders one or more dynamic-credential instructions, which when executed by the client computer, cause the client computer to generate the response credential in the challenge-response credential pair and to include the challenge-response credential pair in the one or more requests from the client computer. For purposes of illustrating a clear example, assume the following:
         Forward transformer  336  requests, from credential validation module  340 , a first challenge-response credential pair;   Credential validation module  340  is configured to generate response credentials deterministically based on challenge credentials and one or more deterministic operations or processes;   Credential validation module  340  generates a first challenge credential, and stores the first challenge credential as the first challenge-response credential pair, which generating or storing the corresponding response credential;   The first challenge credential comprises a first timestamp, a first nonce, and a first hash generated from the first timestamp, the first nonce, and a secret key;   The first challenge-response credential pair comprises and/or is associated with a first count set to an initial value, which in this example is zero;   The one or more deterministic operations or processes deterministically generate the first response credential in the first challenge-response credential pair based on performing one or more operations on the first timestamp, and the first nonce;   Forward transformer  336  receives, from credential validation module  340 , the first challenge-response credential pair comprising the first challenge credential, but not the corresponding first response credential.       

     Forward transformer  336  may render one or more dynamic-credential instructions, which when executed by the client computer, cause the client computer to define the one or more deterministic operations or processes and execute the one or more deterministic operators or processes to generate the first response credential in the first challenge-response credential pair based on the first timestamp, the first nonce, and/or one or more other values in the first challenge credential. The one or more dynamic-credential instructions, when executed, may cause the first challenge credential and the corresponding first response credential in the first challenge-response credential pair to be included in one or more requests. The one or more dynamic-credential instructions may comprise, and/or be included in, one or more credential-cookie instructions that cause the first challenge credential and the corresponding first response credential in the first challenge-response credential pair to be included in one or more browser cookies. As discussed herein, the one or more dynamic-credential instructions may include one or more instructions that identify requests that can be made using a valid challenge-response credential pair that cause the credential validation module  340  to not increment a count associated with the valid challenge-response credential pair. 
     In step  740 , the intermediary computer modifies the first set of instructions to produce a second set of instructions that include the challenge credential and the one or more dynamic-credential instructions. For example, forward transformer  336  may add the one or more dynamic-credential instructions generated in step  740  to the one or more instructions received in step  710  to produce a first set of modified instructions that define a web page with the first challenge-response credential pair. As discussed herein, the first challenge-response credential pair may, but need not include the response credential. This step may be performed before credential validation module  340  generates or stores the first response credential in the first challenge-response credential pair. 
     5.3 Sending the Modified Set of Instructions to the Client Computer 
     In step  750 , the intermediary computer sends the second set of instructions to the client computer. For example, forward transformer  336  may send, to browser  295  through protocol server module  338 , the first set of modified instructions comprising protocol headers, structured data, and/or executable instructions, which when executed by a browser generate the first challenge-response credential pair stored in one or more credential cookies. 
     5.4 Determining Whether a Response Credential in a Challenge-Response Credential Pair is Valid 
     In step  760 , the intermediary computer receives a request for data. For example, browser  295  may execute one or more instructions sent in step  750 . Accordingly, the browser may generate the first response credential that corresponds to the first challenge credential in the first challenge-response credential pair. Browser  295  may receive input indicating that a user selected a particular link in the web page sent to browser  295  in step  750 . In response, browser  295  may generate a request based on the particular link and include the first challenge credential and/or the first response credential in the first challenge-response credential pair. Credential validation module  340  may receive the request through protocol server module  338 . 
     In step  770 , the intermediary computer may determine whether the challenge-response credential pair, if included in the request, is valid. If so, then control may pass to step  790 ; otherwise, control may pass to stop  780 . For example, if the request includes a test challenge credential, but not a test response credential, then credential validation module  340  may determine browser  295  is a bot and/or control may pass to step  780 . Similarly, if the request includes a test response credential, but not a test challenge credential, then credential validation module  340  may determine browser  295  is a bot and/or control may pass to step  780 . 
     If the request includes a challenge credential and a response credential, then credential validation module  340  may determine whether the response credential corresponds with the challenge credential to form a valid challenge-response credential pair. For example, credential validation module  340  may determine whether a mapping in storage  240  associates the challenge credential to the response credential in the request. If so, then credential validation module  340  may determine that the response credential corresponds with the challenge credential, browser  295  is a legitimate browser, browser  295  is not a bot, and/or control may pass to step  790 ; otherwise, credential validation module  340  may determine that the response credential does not correspond with the challenge credential, browser  295  is not a legitimate browser, browser  295  is a bot, and/or control may pass to step  780 . 
     5.4.1 Determining Whether a Deterministically Generated Challenge Credential is Valid 
     Credential validation module  340  may determine whether a deterministically produce challenge credential is valid many ways. Continuing with the example discussed above in steps  720  through  760 , credential validation module  340  may receive a test challenge-response credential pair, and determine whether the challenge credential includes one or more values to generate a valid deterministically challenge credential. For purposes of illustrating a clear example, assume that the one or more values are timestamp, a nonce, and a hash that generated based on the timestamp and the nonce. Credential validation module  340  may generate an expected hash based on a secret key (discussed herein), and the timestamp and nonce in the test challenge credential. If credential validation module  340  determines that the expected hash and the hash in the test challenge credential are the same, then credential validation module  340  may determine that the test challenge credential is a valid test challenge credential; otherwise, control may pass to step  780 . 
     In an embodiment, and as discussed herein, a challenge credential can include a timestamp, a nonce, and/or one or more other values and one or more hashes that are based on the timestamp, nonce, and/or one or more other values. Accordingly, credential validation module  340  can generate one or more expected hashes and determine whether the one or more expected hashes match the one or more hashes in a test challenge-response credential pair, respectively. If so, the credential validation module  340  may determine the test challenge credential is valid; otherwise, control may pass to step  780 . 
     5.4.2 Determining Whether a Deterministically Generated Response Credential is Valid 
     Credential validation module  340  may determine whether a deterministically produced response credential in a challenge-response credential pair is valid many ways. Continuing with the current example, and for purposes of illustrating a clear example, assume that credential validation module  340  is configured to generate deterministically generate response credentials for a particular challenge-response credential pair based on one or more values in the challenge credential in the particular challenge-response credential pair. Credential validation module  340  may generate an expected response credential based on the valid test challenge credential in the test challenge-response credential pair. If credential validation module  340  determines that the expected response credential matches response credential in the test challenge-response credential, then credential validation module  340  may determine that the response credential is valid; otherwise, credential validation module  340  may determine that the response credential is invalid and control may pass to step  780 . In an embodiment, credential validation module  340  may determine whether one or more values in the expected response credential matches one or more corresponding values in the response credential in the test credential. 
     Additionally or alternatively, credential validation module  340  may determine whether the challenge credential and/or response credential is valid based on or more other values in the challenge credential and/or response credential as discussed herein. For example, if the challenge credential is associated with an expiration timestamp, and the current time is passed the expiration timestamp, then credential validation module  340  may determine that the challenge credential and/or the response credential is invalid, and control may pass to step  780 . Also for example, if the challenge credential is associated with a timestamp, and the time satisfies an expiration threshold, then credential validation module  340  may determine that the challenge credential and/or the response credential is invalid, and control may pass to step  780 . 
     5.5 Determining Whether a Count-Based Challenge-Response Credential Pair is Valid 
     Credential validation module  340  may determine whether count-based challenge-response credential pair is valid in many ways. Continuing with the current example, and for purposes of illustrating a clear example, assume the following:
         The challenge credential in the first challenge-response credential pair generated in step  720  is the same as the test challenge credential in the test challenge credential received in step  760 ;   Accordingly, the test challenge-response credential pair is valid;   Credential validation module  340  generated a count is associated with the first challenge-response credential.       

     In response to determining that the test response credential is valid, credential validation module  340  may determine whether a count is associated with the test challenge credential. For example, credential validation module  340  may determine whether the test challenge credential, the test response credential, or data associated with the test challenge-response credential pair includes a count. If not, then credential validation module  340  may determine that a count has not been created for the test challenge-response credential pair, generate a new count with an initial value, and associate the new count with the test challenge-response credential pair. 
     For purposes of illustrating a clear example, assume that a credential validation module  340  stored a count associated with the first challenge response in the first challenge-response credential pair in storage  240 . Accordingly, in this example, and as discussed herein, credential validation module  340  may determine whether the count satisfies an overused threshold. If so, then credential validation module  340  may determine that the test challenge-response credential pair is invalid, and control may pass to step  780 . Otherwise, credential validation module  340  may determine that the test challenge-response credential is valid, and control may pass to step  790 . Additionally or alternatively, credential validation module  340  may increment the count unless credential validation module  340  determines the request is a type of request that should not cause credential validation module  340  to increment the count as discussed herein. 
     Additionally or alternatively, in response to credential validation module  340  determining that the test challenge-response credential is valid, credential validation module  340  may determine whether the count satisfies an exhausted threshold. If so, then credential validation module  340  may generate a new challenge-response credential and a new count associated with the new challenge-response. Credential validation module  340  may send the new challenge-response credential to browser  295 , using one or more of the systems and/or methods discussed herein. The dynamic-credential morphing instructions, which were already sent to browser  295 , may cause browser  295  to receive the new challenge-response credential pair and generate one or more responses that include the new challenge credential and the new response credential in the new challenge-response credential pair in one or more subsequent requests from browser  295  using one or more of the method and system discussed herein. Additionally or alternatively, a new set of dynamic-credential morphing instructions may be generated for the new challenge-response credential pair. The new set of dynamic-credential morphing instructions may be sent to browser  295  on client computer  290 . Accordingly, the new set of dynamic-credential morphing instructions, when executed cause browser  295  to generate the new challenge-response credential pair and include the new challenge-response credential pair in one or more subsequent requests using one or more of the method and system discussed herein. 
     A count may be associated with a challenge-response credential pair by being include included in a value in the challenge-response credential pair and/or one or more particular credentials in the challenge-response credential pair. Additionally or alternatively, a count may be associated with a challenge-response credential pair by being stored in storage  240  with data, or in a data structure, that associates the count with the challenge-response credential pair and/or one or more particular credentials in the challenge-response credential pair. 
     In an embodiment, for a response-challenge credential that is not count-based, if credential validation module  340  determines a response credential in a test challenge-response credential is valid, then credential validation module  340  may determine that the test challenge-response credential is valid; otherwise, credential validation module  340  may determine that the test challenge-response credential is invalid and control may pass to step  780 . 
     5.6 Updating a Challenge-Response Credential Pair Over Time 
     A response credential in a challenge-response credential pair may be updated over time according to one or more of the methods discussed herein. For example, browser  295  may execute one or more instructions that cause browser  295  to send a request for a new dynamic credential, which in this example is a count-based challenge-response credential pair, to intermediary computer  230 . The request may include a first test challenge-response credential pair. Credential validation module  340  may validate the first test challenge-response credential pair, generate a new challenge-response credential pair, and send the new challenge-response credential pair to the client computer using one or more of the methods and/or systems discussed herein. 
     5.7 Responding to a Test Challenge-Response Credential Pair 
     In step  780 , the intermediary computer may perform a negative responsive action, such as the one or more responsive actions discussed herein. In step  790 , the intermediary computer may forward the request to a server computer as discussed herein. 
     6.0 Implementation Mechanisms—Hardware Overview 
     According to one embodiment, the techniques described herein are implemented by one or more special-purpose computing devices. The special-purpose computing devices may be hard-wired to perform the techniques, or may include digital electronic devices such as one or more application-specific integrated circuits (ASICs) or field programmable gate arrays (FPGAs) that are persistently programmed to perform the techniques, or may include one or more general purpose hardware processors programmed to perform the techniques pursuant to program instructions in firmware, memory, other storage, or a combination. Such special-purpose computing devices may also combine custom hard-wired logic, ASICs, or FPGAs with custom programming to accomplish the techniques. The special-purpose computing devices may be desktop computer systems, portable computer systems, handheld devices, networking devices or any other device that incorporates hard-wired and/or program logic to implement the techniques. 
     For example,  FIG. 8  is a block diagram that illustrates a computer system  800  upon which an embodiment of the invention may be implemented. Computer system  800  includes a bus  802  or other communication mechanism for communicating information, and a hardware processor  804  coupled with bus  802  for processing information. Hardware processor  804  may be, for example, a general purpose microprocessor. 
     Computer system  800  also includes a main memory  806 , such as a random access memory (RAM) or other dynamic storage device, coupled to bus  802  for storing information and instructions to be executed by processor  804 . Main memory  806  also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor  804 . Such instructions, when stored in non-transitory storage media accessible to processor  804 , render computer system  800  into a special-purpose machine that is customized to perform the operations specified in the instructions. 
     Computer system  800  further includes a read only memory (ROM)  808  or other challenge storage device coupled to bus  802  for storing challenge information and instructions for processor  804 . A storage device  810 , such as a magnetic disk or optical disk, is provided and coupled to bus  802  for storing information and instructions. 
     Computer system  800  may be coupled via bus  802  to a display  812 , such as a cathode ray tube (CRT), for displaying information to a computer user. An input device  814 , including alphanumeric and other keys, is coupled to bus  802  for communicating information and command selections to processor  804 . Another type of user input device is cursor control  816 , such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor  804  and for controlling cursor movement on display  812 . This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane. 
     Computer system  800  may implement the techniques described herein using customized hard-wired logic, one or more ASICs or FPGAs, firmware and/or program logic which in combination with the computer system causes or programs computer system  800  to be a special-purpose machine. According to one embodiment, the techniques herein are performed by computer system  800  in response to processor  804  executing one or more sequences of one or more instructions contained in main memory  806 . Such instructions may be read into main memory  806  from another storage medium, such as storage device  810 . Execution of the sequences of instructions contained in main memory  806  causes processor  804  to perform the process steps described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions. 
     The term “storage media” as used herein refers to any non-transitory media that store data and/or instructions that cause a machine to operation in a specific fashion. Such storage media may comprise non-volatile media and/or volatile media. Non-volatile media includes, for example, optical or magnetic disks, such as storage device  810 . Volatile media includes dynamic memory, such as main memory  806 . Common forms of storage media include, for example, a floppy disk, a flexible disk, hard disk, solid state drive, magnetic tape, or any other magnetic data storage medium, a CD-ROM, any other optical data storage medium, any physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, NVRAM, any other memory chip or cartridge. 
     Storage media is distinct from but may be used in conjunction with transmission media. Transmission media participates in transferring information between storage media. For example, transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus  802 . Transmission media can also take the form of acoustic or light waves, such as those generated during radio-wave and infra-red data communications. 
     Various forms of media may be involved in carrying one or more sequences of one or more instructions to processor  804  for execution. For example, the instructions may initially be carried on a magnetic disk or solid state drive of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system  800  can receive the data on the telephone line and use an infra-red transmitter to convert the data to an infra-red signal. An infra-red detector can receive the data carried in the infra-red signal and appropriate circuitry can place the data on bus  802 . Bus  802  carries the data to main memory  806 , from which processor  804  retrieves and executes the instructions. The instructions received by main memory  806  may optionally be stored on storage device  810  either before or after execution by processor  804 . 
     Computer system  800  also includes a communication interface  818  coupled to bus  802 . Communication interface  818  provides a two-way data communication coupling to a network link  820  that is connected to a local network  822 . For example, communication interface  818  may be an integrated services digital network (ISDN) card, cable modem, satellite modem, or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface  818  may be a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links may also be implemented. In any such implementation, communication interface  818  sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information. 
     Network link  820  typically provides data communication through one or more networks to other data devices. For example, network link  820  may provide a connection through local network  822  to a host computer  824  or to data equipment operated by an Internet Service Provider (ISP)  826 . ISP  826  in turn provides data communication services through the world wide packet data communication network now commonly referred to as the “Internet”  828 . Local network  822  and Internet  828  both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link  820  and through communication interface  818 , which carry the digital data to and from computer system  800 , are example forms of transmission media. 
     Computer system  800  can send messages and receive data, including program code, through the network(s), network link  820  and communication interface  818 . In the Internet example, a server  830  might transmit a requested code for an application program through Internet  828 , ISP  826 , local network  822  and communication interface  818 . 
     The received code may be executed by processor  804  as it is received, and/or stored in storage device  810 , or other non-volatile storage for later execution. 
     7.0 Other Aspects of Disclosure 
     Using the networked computer arrangements, intermediary computer, and/or processing methods described herein, security in client-server data processing may be significantly increased. Dynamic credential techniques discussed herein effectively reduce automated attacks. Consequently, one or more various attacks, such as a denial of service (“DOS”) attack, credential stuffing, fake account creation, ratings or results manipulation, man in the browser attacks, reserving rival goods or services, scanning for vulnerabilities, and/or exploitation of vulnerabilities, are frustrated because requests are accompanied by a credential that changes over time. 
     In the foregoing specification, embodiments of the invention have been described with reference to numerous specific details that may vary from implementation to implementation. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense. The sole and exclusive indicator of the scope of the invention, and what is intended by the applicants to be the scope of the invention, is the literal and equivalent scope of the set of claims that issue from this application, in the specific form in which such claims issue, including any subsequent correction.