DETAILED ACTION
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Response to Amendment
The amendment filed 11/10/2025 has been entered. Applicant has amended claims 1, 7 and 14. Claims 20 has been cancelled. Claim 21 has been added.
Response to Arguments
Applicant's arguments filed 11/10/2025 have been fully considered but they are not persuasive. Regarding the arguments concerning the independent claim, Examiner respectfully disagrees. The amended limitations
allowing the NFA instance to keep a record of number of times backtracking has occurred during the match attempt; and to ensure that malicious strinq matching does not result in a successful denial of service attack
merely recites the counter in a different manner than previously recited and functional language of the improvement of the counter. These limitations do not distinguish the claimed invention form the prior art.
Claim Rejections - 35 USC § 102
The following is a quotation of the appropriate paragraphs of 35 U.S.C. 102 that form the basis for the rejections under this section made in this Office action:
A person shall be entitled to a patent unless –
(a)(1) the claimed invention was patented, described in a printed publication, or in public use, on sale, or otherwise available to the public before the effective filing date of the claimed invention.
Claim(s) 1-19 and 21 is/are rejected under 35 U.S.C. 102(a)(1) as being anticipated by Goyal et al (US 2015/0066927).
Goyal discloses:
1. (Original) A method comprising: as part of a match attempt between a regular expression (regex) pattern and a payload, a non-deterministic finite automaton (NFA) instance executing instructions for an NFA graph having a plurality of nodes linked via arcs indicative of transitions among states of the NFA instance ([0090] Typically, content aware application processing uses either a deterministic finite automata (DFA) or a non-deterministic finite automata (NFA) to recognize a pattern in the content of a received packet. The DFA and NFA are both finite state machines, that is, models of computation each including a set of states, a start-state, an input alphabet (set of all possible symbols) and a transition function. Computation begins in the start-state and changes to new states dependent on the transition function.); during execution of the instructions for the NFA graph, using a backtrack- depth counter counting a number of times a current state of the NFA graph has been previously visited during the match attempt between the regex pattern and the payload allowing the NFA instance to keep a record of number of times backtracking has occurred during the match attempt; and to ensure that malicious strinq matching does not result in a successful denial of service attack ([0121] Upon loading Node N1 354, the graph walk engine interprets the node as a variable count node matching for the character class ‘b’ occurring from 0 to 5 times. From this node, the graph walk engine is configured to match for such a pattern in the payload, and then load the next node, Node N2 356. Node N2 356 then determines if the next segment of the payload is an ‘x.’ If so, the graph walk engine loads Node 3 358, a marked node, indicating that the pattern is a match. If not, the graph walk engine returns a nomatch. Specific details of the graph walk engine walking variable count nodes using the run stack are described below.); and upon the backtrack-depth counter for the NFA instance reaching or exceeding an adaptive backtracking depth limit for the NFA instance, terminating the match attempt between the regex pattern and the payload ([0127] On the other hand, if when processing Node N0 402, the graph walk engine processes the payload being an “A,” the graph walk engine loads Node 2 406. The graph walk engine then processes the next segment of the payload. If the payload is ‘b’, the graph walk engine loads Node N5 412, which is a marked node. If the payload is ‘B,’ the graph walk engine loads Node N6 414, which is also a marked node. Both marked nodes instruct the graph walk engine to return a match.).
2. (Original) The method of claim 1, further comprising: (1) during backtracking storing intermediate matches between the regex pattern and the payload, and (2) during a second match attempt, subsequent to a termination of the match attempt, backtracking only to a previous successful partial match between the regex pattern and the payload ([0126] The graph walk engine first processes Node N0 402. If the payload is “a,” the graph walk engine loads Node N1 404. The graph walk engine then processes the next segment of the payload. If the payload is ‘b’, the graph walk engine loads Node N3 408, which is a marked node. If the payload is ‘B,’ the graph walk engine loads Node N4 410, which is also a marked node. Both marked nodes instruct the graph walk engine to return a match.).
3. (Original) The method of claim 1, further comprising: (1) using a first instruction counter tracking a first number of the instructions executed by the NFA instance prior to a successful match between the regex pattern and the payload, (2) using a second instruction counter tracking a second number of instructions executed by the NFA instance prior to termination of the match attempt between the regex pattern and the payload. ([0130] When the graph walk engine is matching a payload segment to a character class, it can use the ASCII value of the payload as an index to the character class. For example, where the character class is [a-z], assume the graph walk engine is processing the letter “r,” which has an ASCII value of 114. The graph walk engine can access the 114th bit of the character class and determine whether it is set to determine whether it matches the character class. This can be expressed with the following logical statement: “if (CharacterClass[PayLoadASCIIValue] true), return match; else return nomatch,” where PayLoadASCIIValue is the ASCII value of the current segment of the payload, or in this case, 114.)
4. (Original) The method of claim 1, further comprising for each successful match attempt or a failed match attempt between a regex pattern and a payload storing a result. ([0131] A given pattern can also include multiple character classes. For example, the pattern “[a-z][0-9][̂\n][a-z]” has four character classes but only three unique character classes (i.e., [a-z], [0-9], and [̂\n]) because [a-z] is a repeated character class. So, compiler first determines the number of unique character classes present in the pattern(s). The compiler then assigns each character class a unique number (e.g., an index or identifier). For example, the compiler assigns [a-z] an index of 1, [0-9] an index of 2, and [̂\n] an index of 3. Even though it appears twice, the character class [a-z] is stored as a bitmap once, and can be accessed by its index of “1.”)
5. (Original) The method of claim 1, further comprising maintaining in a memory associated with the NFA instance: (1) stack entries for instructions being executed for the NFA graph and (2) a hash value for each of the stack entries. ([0131] A given pattern can also include multiple character classes. For example, the pattern “[a-z][0-9][̂\n][a-z]” has four character classes but only three unique character classes (i.e., [a-z], [0-9], and [̂\n]) because [a-z] is a repeated character class. So, compiler first determines the number of unique character classes present in the pattern(s). The compiler then assigns each character class a unique number (e.g., an index or identifier). For example, the compiler assigns [a-z] an index of 1, [0-9] an index of 2, and [̂\n] an index of 3. Even though it appears twice, the character class [a-z] is stored as a bitmap once, and can be accessed by its index of “1.”)
6. (Original) The method of claim 5, wherein counting the number of times the current state of the NFA graph has been previously visited during the match attempt between the regex pattern and the payload comprises counting a number of matches between a hash value for a given stack entry and any hash values of stack entries previously pushed to a top of a stack for instructions being executed by the NFA instance. ([0156] The graph walk engine, upon pushing the run stack entry, fetches the next node N1 504. The graph walk engine fetches the next byte of the payload corresponding to the payload offset of one, ‘y’, and tries to match it with the element of the node N1 504, the character class [zZ]. Since the byte does not match the character class, the graph walk engine pops the run stack entry. The graph walk engine then processes the same byte with popped stack entry which contains Node N0 502. The byte ‘y’ matches the character class [̂\n], so it delivers a match. The graph walk engine increments the payload offset by 1 and pushes a run stack entry containing Node N0 502)
7. (Original) A method comprising: as part of a match attempt between a regular expression (regex) pattern and a payload, a non-deterministic finite automaton (NFA) instance executing instructions for an NFA graph having a plurality of nodes linked via arcs indicative of transitions among states of the NFA instancev([0090] Typically, content aware application processing uses either a deterministic finite automata (DFA) or a non-deterministic finite automata (NFA) to recognize a pattern in the content of a received packet. The DFA and NFA are both finite state machines, that is, models of computation each including a set of states, a start-state, an input alphabet (set of all possible symbols) and a transition function. Computation begins in the start-state and changes to new states dependent on the transition function.); during execution of the instructions for the NFA graph, using a backtrack- depth counter counting a number of times a current state of the NFA graph has been previously visited during the match attempt between the regex pattern and the payload; upon the backtrack-depth counter for the NFA instance reaching or exceeding an adaptive backtracking depth limit for the NFA instance, terminating the match attempt between the regex pattern and the payloadallowing the NFA instance to keep a record of number of times backtracking has occurred during the match attempt; and to ensure that malicious strinq matching does not result in a successful denial of service attack; ([0121] Upon loading Node N1 354, the graph walk engine interprets the node as a variable count node matching for the character class ‘b’ occurring from 0 to 5 times. From this node, the graph walk engine is configured to match for such a pattern in the payload, and then load the next node, Node N2 356. Node N2 356 then determines if the next segment of the payload is an ‘x.’ If so, the graph walk engine loads Node 3 358, a marked node, indicating that the pattern is a match. If not, the graph walk engine returns a nomatch. Specific details of the graph walk engine walking variable count nodes using the run stack are described below.)and dynamically adjusting the adaptive backtracking depth limit for the NFA instance depending on an input size of the payload. ([0127] On the other hand, if when processing Node N0 402, the graph walk engine processes the payload being an “A,” the graph walk engine loads Node 2 406. The graph walk engine then processes the next segment of the payload. If the payload is ‘b’, the graph walk engine loads Node N5 412, which is a marked node. If the payload is ‘B,’ the graph walk engine loads Node N6 414, which is also a marked node. Both marked nodes instruct the graph walk engine to return a match.).
8. (Original) The method of claim 7, further comprising: (1) during backtracking storing intermediate matches between the regex pattern and the payload, and (2) during a second match attempt, subsequent to a termination of the match attempt, backtracking only to a previous successful partial match between the regex pattern and the payload. ([0126] The graph walk engine first processes Node N0 402. If the payload is “a,” the graph walk engine loads Node N1 404. The graph walk engine then processes the next segment of the payload. If the payload is ‘b’, the graph walk engine loads Node N3 408, which is a marked node. If the payload is ‘B,’ the graph walk engine loads Node N4 410, which is also a marked node. Both marked nodes instruct the graph walk engine to return a match.).
9. (Original) The method of claim 7, further comprising: (1) using a first instruction counter tracking a first number of the instructions executed by the NFA instance prior to a successful match between the regex pattern and the payload, (2) using a second instruction counter tracking a second number of instructions executed by the NFA instance prior to termination of the match attempt between the regex pattern and the payload. ([0130] When the graph walk engine is matching a payload segment to a character class, it can use the ASCII value of the payload as an index to the character class. For example, where the character class is [a-z], assume the graph walk engine is processing the letter “r,” which has an ASCII value of 114. The graph walk engine can access the 114th bit of the character class and determine whether it is set to determine whether it matches the character class. This can be expressed with the following logical statement: “if (CharacterClass[PayLoadASCIIValue] true), return match; else return nomatch,” where PayLoadASCIIValue is the ASCII value of the current segment of the payload, or in this case, 114.)
10. (Original) The method of claim 7, further comprising for each successful match attempt or a failed match attempt between a regex pattern and a payload storing a result. ([0131] A given pattern can also include multiple character classes. For example, the pattern “[a-z][0-9][̂\n][a-z]” has four character classes but only three unique character classes (i.e., [a-z], [0-9], and [̂\n]) because [a-z] is a repeated character class. So, compiler first determines the number of unique character classes present in the pattern(s). The compiler then assigns each character class a unique number (e.g., an index or identifier). For example, the compiler assigns [a-z] an index of 1, [0-9] an index of 2, and [̂\n] an index of 3. Even though it appears twice, the character class [a-z] is stored as a bitmap once, and can be accessed by its index of “1.”)
11. (Original) The method of claim 7, wherein dynamically adjusting the adaptive backtracking depth limit for the NFA instance comprises allowing for more backtracking for a payload with a smaller size relative to a payload with a larger size. ([0130] When the graph walk engine is matching a payload segment to a character class, it can use the ASCII value of the payload as an index to the character class. For example, where the character class is [a-z], assume the graph walk engine is processing the letter “r,” which has an ASCII value of 114. The graph walk engine can access the 114th bit of the character class and determine whether it is set to determine whether it matches the character class. This can be expressed with the following logical statement: “if (CharacterClass[PayLoadASCIIValue] true), return match; else return nomatch,” where PayLoadASCIIValue is the ASCII value of the current segment of the payload, or in this case, 114.)
12. (Original) The method of claim 7, further comprising maintaining in a memory associated with the NFA instance: (1) stack entries for instructions being executed for the NFA graph and (2) a hash value for each of the stack entries. ([0131] A given pattern can also include multiple character classes. For example, the pattern “[a-z][0-9][̂\n][a-z]” has four character classes but only three unique character classes (i.e., [a-z], [0-9], and [̂\n]) because [a-z] is a repeated character class. So, compiler first determines the number of unique character classes present in the pattern(s). The compiler then assigns each character class a unique number (e.g., an index or identifier). For example, the compiler assigns [a-z] an index of 1, [0-9] an index of 2, and [̂\n] an index of 3. Even though it appears twice, the character class [a-z] is stored as a bitmap once, and can be accessed by its index of “1.”)
13. (Original) The method of claim 12, wherein counting the number of times the current state of the NFA graph has been previously visited during the match attempt between the regex pattern and the payload comprises counting a number of matches between a hash value for a given stack entry and any hash values of stack entries previously pushed to a top of a stack for instructions being executed by the NFA instance. ([0131] A given pattern can also include multiple character classes. For example, the pattern “[a-z][0-9][̂\n][a-z]” has four character classes but only three unique character classes (i.e., [a-z], [0-9], and [̂\n]) because [a-z] is a repeated character class. So, compiler first determines the number of unique character classes present in the pattern(s). The compiler then assigns each character class a unique number (e.g., an index or identifier). For example, the compiler assigns [a-z] an index of 1, [0-9] an index of 2, and [̂\n] an index of 3. Even though it appears twice, the character class [a-z] is stored as a bitmap once, and can be accessed by its index of “1.”)
14. (Currently amended) A method comprising :deploying a regular expression (regex) accelerator to find matches between respective regex patterns and respective payloads associated with a storage or a network appliance, wherein the regex accelerator[[s]] comprises non-deterministic finite automaton (NFA) instances; as part of a first match attempt between a first regex pattern and a first payloadallowing the NFA instance to keep a record of number of times backtracking has occurred during the match attempt; and to ensure that malicious strinq matching does not result in a successful denial of service attack, a first non-deterministic finite automaton (NFA) instance executing instructions for a first NFA graph having a first plurality of nodes linked via arcs indicative of transitions among states of the first NFA instance; ([0090] Typically, content aware application processing uses either a deterministic finite automata (DFA) or a non-deterministic finite automata (NFA) to recognize a pattern in the content of a received packet. The DFA and NFA are both finite state machines, that is, models of computation each including a set of states, a start-state, an input alphabet (set of all possible symbols) and a transition function. Computation begins in the start-state and changes to new states dependent on the transition function.) as part of a second match attempt between a second regex pattern and a second payload, a second non-deterministic finite automaton (NFA) instance executing instructions for a second NFA graph having a second plurality of nodes linked via arcs indicative of transitions among states of the second NFA instance; ([0121] Upon loading Node N1 354, the graph walk engine interprets the node as a variable count node matching for the character class ‘b’ occurring from 0 to 5 times. From this node, the graph walk engine is configured to match for such a pattern in the payload, and then load the next node, Node N2 356. Node N2 356 then determines if the next segment of the payload is an ‘x.’ If so, the graph walk engine loads Node 3 358, a marked node, indicating that the pattern is a match. If not, the graph walk engine returns a nomatch. Specific details of the graph walk engine walking variable count nodes using the run stack are described below.)upon a first backtrack-depth counter for the first NFA instance reaching or exceeding a first adaptive backtracking depth limit for the first NFA instance, terminating the first match attempt between the first regex pattern and the first payload; and upon a second backtrack-depth counter for the second NFA instance reaching or exceeding a second adaptive backtracking depth limit for the second NFA instance, different form the first adaptive backtracking depth limit, terminating the second match attempt between the second regex pattern and the second payload. ([0127] On the other hand, if when processing Node N0 402, the graph walk engine processes the payload being an “A,” the graph walk engine loads Node 2 406. The graph walk engine then processes the next segment of the payload. If the payload is ‘b’, the graph walk engine loads Node N5 412, which is a marked node. If the payload is ‘B,’ the graph walk engine loads Node N6 414, which is also a marked node. Both marked nodes instruct the graph walk engine to return a match.).
15. (Original) The method of claim 14, further comprising controlling backtracking to prevent a service outage associated with a service offered by either the storage or the network appliance. ([0130] When the graph walk engine is matching a payload segment to a character class, it can use the ASCII value of the payload as an index to the character class. For example, where the character class is [a-z], assume the graph walk engine is processing the letter “r,” which has an ASCII value of 114. The graph walk engine can access the 114th bit of the character class and determine whether it is set to determine whether it matches the character class. This can be expressed with the following logical statement: “if (CharacterClass[PayLoadASCIIValue] true), return match; else return nomatch,” where PayLoadASCIIValue is the ASCII value of the current segment of the payload, or in this case, 114.)
16. (Original) The method of claim 14, further comprising dynamically adjusting the first adaptive backtracking depth limit for the first NFA instance depending on an input size of the first payload. ([0130] When the graph walk engine is matching a payload segment to a character class, it can use the ASCII value of the payload as an index to the character class. For example, where the character class is [a-z], assume the graph walk engine is processing the letter “r,” which has an ASCII value of 114. The graph walk engine can access the 114th bit of the character class and determine whether it is set to determine whether it matches the character class. This can be expressed with the following logical statement: “if (CharacterClass[PayLoadASCIIValue] true), return match; else return nomatch,” where PayLoadASCIIValue is the ASCII value of the current segment of the payload, or in this case, 114.)
17. (Original) The method of claim 16, further comprising dynamically adjusting the second adaptive backtracking depth limit for the second NFA instance depending on an input size of the second payload. ([0131] A given pattern can also include multiple character classes. For example, the pattern “[a-z][0-9][̂\n][a-z]” has four character classes but only three unique character classes (i.e., [a-z], [0-9], and [̂\n]) because [a-z] is a repeated character class. So, compiler first determines the number of unique character classes present in the pattern(s). The compiler then assigns each character class a unique number (e.g., an index or identifier). For example, the compiler assigns [a-z] an index of 1, [0-9] an index of 2, and [̂\n] an index of 3. Even though it appears twice, the character class [a-z] is stored as a bitmap once, and can be accessed by its index of “1.”)
18. (Original) The method of claim 17, wherein dynamically adjusting the first adaptive backtracking depth limit for the first NFA instance or the second adaptive backtracking depth limit for the second NFA instance comprises allowing for more backtracking for a payload with a smaller size relative to a payload with a larger size. ([0130] When the graph walk engine is matching a payload segment to a character class, it can use the ASCII value of the payload as an index to the character class. For example, where the character class is [a-z], assume the graph walk engine is processing the letter “r,” which has an ASCII value of 114. The graph walk engine can access the 114th bit of the character class and determine whether it is set to determine whether it matches the character class. This can be expressed with the following logical statement: “if (CharacterClass[PayLoadASCIIValue] true), return match; else return nomatch,” where PayLoadASCIIValue is the ASCII value of the current segment of the payload, or in this case, 114.)
19. (Original) The method of claim 14, further comprising for each successful match attempt or a failed match attempt between a regex pattern and a payload storing a result. ([0131] A given pattern can also include multiple character classes. For example, the pattern “[a-z][0-9][̂\n][a-z]” has four character classes but only three unique character classes (i.e., [a-z], [0-9], and [̂\n]) because [a-z] is a repeated character class. So, compiler first determines the number of unique character classes present in the pattern(s). The compiler then assigns each character class a unique number (e.g., an index or identifier). For example, the compiler assigns [a-z] an index of 1, [0-9] an index of 2, and [̂\n] an index of 3. Even though it appears twice, the character class [a-z] is stored as a bitmap once, and can be accessed by its index of “1.”)
21. (New) The method of claim 14, further comprising: (1) maintaining in a first memory associated with the first NFA instance a first set of stack entries for instructions being executed for the first NFA graph, and a hash value for each of the first set of stack entries, and (2) maintaining in a second memory associated with the second NFA instance a second set of stack entries for instructions being executed for the second NFA graph,and a hash value for each of the second set of stack entries. ([0126] The graph walk engine first processes Node N0 402. If the payload is “a,” the graph walk engine loads Node N1 404. The graph walk engine then processes the next segment of the payload. If the payload is ‘b’, the graph walk engine loads Node N3 408, which is a marked node. If the payload is ‘B,’ the graph walk engine loads Node N4 410, which is also a marked node. Both marked nodes instruct the graph walk engine to return a match.).
Conclusion
THIS ACTION IS MADE FINAL. Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to SAMUEL SHARPLESS whose telephone number is (571)272-1521. The examiner can normally be reached M-F 7:30 AM- 3:30 PM (ET).
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, ALEKSANDR KERZHNER can be reached at 571-270-1760. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/S.C.S./Examiner, Art Unit 2165
/ALEKSANDR KERZHNER/Supervisory Patent Examiner, Art Unit 2165