validator_ragel: Use different actions for different types of commands

src/trusted/validator_ragel/unreviewed/validator-x86_64.rl

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <assert.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ skipping 70 matching lines @@
   action rel16_operand {
     assert(FALSE);
   }
   action rel32_operand {
     int32_t offset =
            (uint32_t) (p[-3] + 256U * (p[-2] + 256U * (p[-1] + 256U * (p[0]))));
     size_t jump_dest = offset + (p - data);
     check_jump_dest;
   }
 
-  include decode_x86_64 "validator-x86_64-instruction.rl";
-
-  action process_normal_instruction {
+  action process_0_operands {
     /* Restricted %rsp or %rbp must be processed by appropriate nacl-special
        instruction, not with regular instruction.  */
     if (restricted_register == REG_RSP) {
+      PrintError("Incorrectly modified register %%rsp\n", begin - data);
+      result = 1;
+      goto error_detected;
+    } else if (restricted_register == REG_RBP) {
+      PrintError("Incorrectly modified register %%rbp\n", begin - data);
+      result = 1;
+      goto error_detected;
+    }
+    restricted_register = kNoRestrictedReg;
+  }
+
+  action process_1_operands {
+    /* Restricted %rsp or %rbp must be processed by appropriate nacl-special
+       instruction, not with regular instruction.  */
+    if (restricted_register == REG_RSP) {
       PrintError("Incorrectly modified register %%rsp\n", begin - data);
       result = 1;
       goto error_detected;
     } else if (restricted_register == REG_RBP) {
       PrintError("Incorrectly modified register %%rbp\n", begin - data);
       result = 1;
       goto error_detected;
     }
     /* If Sandboxed Rsi is destroyed then we must note that.  */

[pasko-google - do not use, 2012/05/12 13:54:31]

s/note/detect/

[khim, 2012/05/12 14:32:16]

Done.

     if (restricted_register == kSandboxedRsi) {
       if (CHECK_OPERAND(0, REG_RSI, OperandSandboxRestricted) ||
+          CHECK_OPERAND(0, REG_RSI, OperandSandboxUnrestricted)) {
+        restricted_register = kNoRestrictedReg;
+      }
+    }
+    if (restricted_register == kSandboxedRsi) {
+      if (CHECK_OPERAND(0, REG_RDI, OperandSandboxRestricted)) {
+        sandboxed_rsi_restricted_rdi = begin;
+        restricted_register = kSandboxedRsiRestrictedRdi;
+      }
+    }
+    if (restricted_register != kSandboxedRsiRestrictedRdi) {
+      restricted_register = kNoRestrictedReg;
+      if (CHECK_OPERAND(0, REG_R15, OperandSandbox8bit) ||
+          CHECK_OPERAND(0, REG_R15, OperandSandboxRestricted) ||
+          CHECK_OPERAND(0, REG_R15, OperandSandboxUnrestricted)) {
+        PrintError("Incorrectly modified register %%r15\n", begin - data);
+        result = 1;
+        goto error_detected;
+      } else if ((CHECK_OPERAND(0, REG_RBP, OperandSandbox8bit) &&
+                  GET_REX_PREFIX()) ||
+                 CHECK_OPERAND(0, REG_RBP, OperandSandboxUnrestricted)) {
+        PrintError("Incorrectly modified register %%rbp\n", begin - data);
+        result = 1;
+        goto error_detected;
+      } else if ((CHECK_OPERAND(0, REG_RSP, OperandSandbox8bit) &&
+                  GET_REX_PREFIX()) ||
+                 CHECK_OPERAND(0, REG_RSP, OperandSandboxUnrestricted)) {
+        PrintError("Incorrectly modified register %%rsp\n", begin - data);
+        result = 1;
+        goto error_detected;
+      } else if ((operand_states & 0x70) == (OperandSandboxRestricted << 5)) {
+        restricted_register = operand_states & 0x0f;

[pasko-google - do not use, 2012/05/12 13:54:31]

copy the proposed comment above this line too

[khim, 2012/05/12 14:32:16]

Done.

+      }
+    }
+  }
+
+  action process_2_operands {
+    /* Restricted %rsp or %rbp must be processed by appropriate nacl-special
+       instruction, not with regular instruction.  */
+    if (restricted_register == REG_RSP) {
+      PrintError("Incorrectly modified register %%rsp\n", begin - data);
+      result = 1;
+      goto error_detected;
+    } else if (restricted_register == REG_RBP) {
+      PrintError("Incorrectly modified register %%rbp\n", begin - data);
+      result = 1;
+      goto error_detected;
+    }
+    /* If Sandboxed Rsi is destroyed then we must note that.  */

[pasko-google - do not use, 2012/05/12 13:54:31]

ditto

[khim, 2012/05/12 14:32:16]

Done.

+    if (restricted_register == kSandboxedRsi) {
+      if (CHECK_OPERAND(0, REG_RSI, OperandSandboxRestricted) ||
           CHECK_OPERAND(0, REG_RSI, OperandSandboxUnrestricted) ||
           CHECK_OPERAND(1, REG_RSI, OperandSandboxRestricted) ||
           CHECK_OPERAND(1, REG_RSI, OperandSandboxUnrestricted)) {
         restricted_register = kNoRestrictedReg;
       }
     }
     if (restricted_register == kSandboxedRsi) {
       if (CHECK_OPERAND(0, REG_RDI, OperandSandboxRestricted) ||
           CHECK_OPERAND(1, REG_RDI, OperandSandboxRestricted)) {
         sandboxed_rsi_restricted_rdi = begin;
@@ skipping 23 matching lines @@
       } else if ((CHECK_OPERAND(0, REG_RSP, OperandSandbox8bit) &&
                   GET_REX_PREFIX()) ||
                  CHECK_OPERAND(0, REG_RSP, OperandSandboxUnrestricted) ||
                  (CHECK_OPERAND(1, REG_RSP, OperandSandbox8bit) &&
                   GET_REX_PREFIX()) ||
                  CHECK_OPERAND(1, REG_RSP, OperandSandboxUnrestricted)) {
         PrintError("Incorrectly modified register %%rsp\n", begin - data);
         result = 1;
         goto error_detected;
       } else if ((operand_states & 0x70) == (OperandSandboxRestricted << 5)) {
         restricted_register = operand_states & 0x0f;

[pasko-google - do not use, 2012/05/12 13:54:31]

/* Take 2 bits of operand type from "operand_states" as restricted_register,
make sure operand_states denotes a register (4th bit == 0). */

[khim, 2012/05/12 14:32:16]

Done.

       } else if ((operand_states & 0x7000) ==
                                         (OperandSandboxRestricted << (5 + 8))) {

[pasko-google - do not use, 2012/05/12 13:54:31]

align with shiftwidth=4

[khim, 2012/05/12 14:32:16]

Done.

         restricted_register = (operand_states & 0x0f00) >> 8;
       }
     }
   }
 
+  include decode_x86_64 "validator-x86_64-instruction.rl";
+
   # Remove special instructions which are only allowed in special cases.
-  normal_instruction = (one_instruction - (
+  normal_instruction = one_instruction - (
     (0x48 0x89 0xe5)             | # mov %rsp,%rbp
     (0x48 0x89 0xec)             | # mov %rbp,%rsp
     (0x48 0x81 0xe4 any{4})      | # and $XXX,%rsp
     (0x48 0x83 0xe4 any)         | # and $XXX,%rsp
     (0x4c 0x01 0xfd)             | # add %r15,%rbp
     (0x49 0x8d 0x2c 0x2f)        | # lea (%r15,%rbp,1),%rbp
     (0x4a 0x8d 0x6c 0x3d any)    | # lea 0x0(%rbp,%r15,1),%rbp
     (0x48 0x81 0xe5 any{4})      | # and $XXX,%rsp
     (0x48 0x83 0xe5 any)         | # and $XXX,%rsp
     (0x4c 0x01 0xfc)             | # add %r15,%rsp
     (0x4a 0x8d 0x24 0x3c)        | # lea (%rsp,%r15,1),%rsp
     (0x49 0x8d 0x34 0x37)        | # lea (%r15,%rsi,1),%rsi
     (0x49 0x8d 0x3c 0x3f)          # lea (%r15,%rdi,1),%rdi
-  )) @process_normal_instruction;
+  );
 
   data16condrep = (data16 | condrep data16 | data16 condrep);
   data16rep = (data16 | rep data16 | data16 rep);
 
   special_instruction =
     (0x48 0x89 0xe5)                       | # mov %rsp,%rbp
     (0x48 0x81 0xe4 any{3} (0x80 .. 0xff)) | # and $XXX,%rsp
     (0x48 0x83 0xe4 (0x80 .. 0xff))          # and $XXX,%rsp
     @{ if (restricted_register == REG_RSP) {
          PrintError("Incorrectly modified register %%rsp\n", begin - data);
@@ skipping 387 matching lines @@
     }
   }
 
   if (CheckJumpTargets(valid_targets, jump_dests, size)) {
     return 1;
   }
 
 error_detected:
   return result;
 }