sandbox/linux/bpf_dsl/bpf_dsl.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "sandbox/linux/bpf_dsl/bpf_dsl.h"
   6
   7 #include <limits>
   8
   9 #include "base/logging.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "sandbox/linux/bpf_dsl/bpf_dsl_impl.h"
  12 #include "sandbox/linux/bpf_dsl/errorcode.h"
  13 #include "sandbox/linux/bpf_dsl/policy_compiler.h"
  14 #include "sandbox/linux/system_headers/linux_seccomp.h"
  15
  16 namespace sandbox {
  17 namespace bpf_dsl {
  18 namespace {
  19
  20 class AllowResultExprImpl : public internal::ResultExprImpl {
  21  public:
  22   AllowResultExprImpl() {}
  23
  24   CodeGen::Node Compile(PolicyCompiler* pc) const override {
  25     return pc->Return(SECCOMP_RET_ALLOW);
  26   }
  27
  28   bool IsAllow() const override { return true; }
  29
  30  private:
  31   ~AllowResultExprImpl() override {}
  32
  33   DISALLOW_COPY_AND_ASSIGN(AllowResultExprImpl);
  34 };
  35
  36 class ErrorResultExprImpl : public internal::ResultExprImpl {
  37  public:
  38   explicit ErrorResultExprImpl(int err) : err_(err) {
  39     CHECK(err_ >= ErrorCode::ERR_MIN_ERRNO && err_ <= ErrorCode::ERR_MAX_ERRNO);
  40   }
  41
  42   CodeGen::Node Compile(PolicyCompiler* pc) const override {
  43     return pc->Return(SECCOMP_RET_ERRNO + err_);
  44   }
  45
  46   bool IsDeny() const override { return true; }
  47
  48  private:
  49   ~ErrorResultExprImpl() override {}
  50
  51   int err_;
  52
  53   DISALLOW_COPY_AND_ASSIGN(ErrorResultExprImpl);
  54 };
  55
  56 class KillResultExprImpl : public internal::ResultExprImpl {
  57  public:
  58   KillResultExprImpl() {}
  59
  60   CodeGen::Node Compile(PolicyCompiler* pc) const override {
  61     return pc->Return(SECCOMP_RET_KILL);
  62   }
  63
  64   bool IsDeny() const override { return true; }
  65
  66  private:
  67   ~KillResultExprImpl() override {}
  68
  69   DISALLOW_COPY_AND_ASSIGN(KillResultExprImpl);
  70 };
  71
  72 class TraceResultExprImpl : public internal::ResultExprImpl {
  73  public:
  74   TraceResultExprImpl(uint16_t aux) : aux_(aux) {}
  75
  76   CodeGen::Node Compile(PolicyCompiler* pc) const override {
  77     return pc->Return(SECCOMP_RET_TRACE + aux_);
  78   }
  79
  80  private:
  81   ~TraceResultExprImpl() override {}
  82
  83   uint16_t aux_;
  84
  85   DISALLOW_COPY_AND_ASSIGN(TraceResultExprImpl);
  86 };
  87
  88 class TrapResultExprImpl : public internal::ResultExprImpl {
  89  public:
  90   TrapResultExprImpl(TrapRegistry::TrapFnc func, const void* arg, bool safe)
  91       : func_(func), arg_(arg), safe_(safe) {
  92     DCHECK(func_);
  93   }
  94
  95   CodeGen::Node Compile(PolicyCompiler* pc) const override {
  96     return pc->Trap(func_, arg_, safe_);
  97   }
  98
  99   bool HasUnsafeTraps() const override { return safe_ == false; }
 100
 101   bool IsDeny() const override { return true; }
 102
 103  private:
 104   ~TrapResultExprImpl() override {}
 105
 106   TrapRegistry::TrapFnc func_;
 107   const void* arg_;
 108   bool safe_;
 109
 110   DISALLOW_COPY_AND_ASSIGN(TrapResultExprImpl);
 111 };
 112
 113 class IfThenResultExprImpl : public internal::ResultExprImpl {
 114  public:
 115   IfThenResultExprImpl(const BoolExpr& cond,
 116                        const ResultExpr& then_result,
 117                        const ResultExpr& else_result)
 118       : cond_(cond), then_result_(then_result), else_result_(else_result) {}
 119
 120   CodeGen::Node Compile(PolicyCompiler* pc) const override {
 121     // We compile the "then" and "else" expressions in separate statements so
 122     // they have a defined sequencing.  See https://crbug.com/529480.
 123     CodeGen::Node then_node = then_result_->Compile(pc);
 124     CodeGen::Node else_node = else_result_->Compile(pc);
 125     return cond_->Compile(pc, then_node, else_node);
 126   }
 127
 128   bool HasUnsafeTraps() const override {
 129     return then_result_->HasUnsafeTraps() || else_result_->HasUnsafeTraps();
 130   }
 131
 132  private:
 133   ~IfThenResultExprImpl() override {}
 134
 135   BoolExpr cond_;
 136   ResultExpr then_result_;
 137   ResultExpr else_result_;
 138
 139   DISALLOW_COPY_AND_ASSIGN(IfThenResultExprImpl);
 140 };
 141
 142 class ConstBoolExprImpl : public internal::BoolExprImpl {
 143  public:
 144   ConstBoolExprImpl(bool value) : value_(value) {}
 145
 146   CodeGen::Node Compile(PolicyCompiler* pc,
 147                         CodeGen::Node then_node,
 148                         CodeGen::Node else_node) const override {
 149     return value_ ? then_node : else_node;
 150   }
 151
 152  private:
 153   ~ConstBoolExprImpl() override {}
 154
 155   bool value_;
 156
 157   DISALLOW_COPY_AND_ASSIGN(ConstBoolExprImpl);
 158 };
 159
 160 class MaskedEqualBoolExprImpl : public internal::BoolExprImpl {
 161  public:
 162   MaskedEqualBoolExprImpl(int argno,
 163                           size_t width,
 164                           uint64_t mask,
 165                           uint64_t value)
 166       : argno_(argno), width_(width), mask_(mask), value_(value) {}
 167
 168   CodeGen::Node Compile(PolicyCompiler* pc,
 169                         CodeGen::Node then_node,
 170                         CodeGen::Node else_node) const override {
 171     return pc->MaskedEqual(argno_, width_, mask_, value_, then_node, else_node);
 172   }
 173
 174  private:
 175   ~MaskedEqualBoolExprImpl() override {}
 176
 177   int argno_;
 178   size_t width_;
 179   uint64_t mask_;
 180   uint64_t value_;
 181
 182   DISALLOW_COPY_AND_ASSIGN(MaskedEqualBoolExprImpl);
 183 };
 184
 185 class NegateBoolExprImpl : public internal::BoolExprImpl {
 186  public:
 187   explicit NegateBoolExprImpl(const BoolExpr& cond) : cond_(cond) {}
 188
 189   CodeGen::Node Compile(PolicyCompiler* pc,
 190                         CodeGen::Node then_node,
 191                         CodeGen::Node else_node) const override {
 192     return cond_->Compile(pc, else_node, then_node);
 193   }
 194
 195  private:
 196   ~NegateBoolExprImpl() override {}
 197
 198   BoolExpr cond_;
 199
 200   DISALLOW_COPY_AND_ASSIGN(NegateBoolExprImpl);
 201 };
 202
 203 class AndBoolExprImpl : public internal::BoolExprImpl {
 204  public:
 205   AndBoolExprImpl(const BoolExpr& lhs, const BoolExpr& rhs)
 206       : lhs_(lhs), rhs_(rhs) {}
 207
 208   CodeGen::Node Compile(PolicyCompiler* pc,
 209                         CodeGen::Node then_node,
 210                         CodeGen::Node else_node) const override {
 211     return lhs_->Compile(pc, rhs_->Compile(pc, then_node, else_node),
 212                          else_node);
 213   }
 214
 215  private:
 216   ~AndBoolExprImpl() override {}
 217
 218   BoolExpr lhs_;
 219   BoolExpr rhs_;
 220
 221   DISALLOW_COPY_AND_ASSIGN(AndBoolExprImpl);
 222 };
 223
 224 class OrBoolExprImpl : public internal::BoolExprImpl {
 225  public:
 226   OrBoolExprImpl(const BoolExpr& lhs, const BoolExpr& rhs)
 227       : lhs_(lhs), rhs_(rhs) {}
 228
 229   CodeGen::Node Compile(PolicyCompiler* pc,
 230                         CodeGen::Node then_node,
 231                         CodeGen::Node else_node) const override {
 232     return lhs_->Compile(pc, then_node,
 233                          rhs_->Compile(pc, then_node, else_node));
 234   }
 235
 236  private:
 237   ~OrBoolExprImpl() override {}
 238
 239   BoolExpr lhs_;
 240   BoolExpr rhs_;
 241
 242   DISALLOW_COPY_AND_ASSIGN(OrBoolExprImpl);
 243 };
 244
 245 }  // namespace
 246
 247 namespace internal {
 248
 249 bool ResultExprImpl::HasUnsafeTraps() const {
 250   return false;
 251 }
 252
 253 bool ResultExprImpl::IsAllow() const {
 254   return false;
 255 }
 256
 257 bool ResultExprImpl::IsDeny() const {
 258   return false;
 259 }
 260
 261 uint64_t DefaultMask(size_t size) {
 262   switch (size) {
 263     case 4:
 264       return std::numeric_limits<uint32_t>::max();
 265     case 8:
 266       return std::numeric_limits<uint64_t>::max();
 267     default:
 268       CHECK(false) << "Unimplemented DefaultMask case";
 269       return 0;
 270   }
 271 }
 272
 273 BoolExpr ArgEq(int num, size_t size, uint64_t mask, uint64_t val) {
 274   // If this is changed, update Arg<T>::EqualTo's static_cast rules
 275   // accordingly.
 276   CHECK(size == 4 || size == 8);
 277
 278   return BoolExpr(new const MaskedEqualBoolExprImpl(num, size, mask, val));
 279 }
 280
 281 }  // namespace internal
 282
 283 ResultExpr Allow() {
 284   return ResultExpr(new const AllowResultExprImpl());
 285 }
 286
 287 ResultExpr Error(int err) {
 288   return ResultExpr(new const ErrorResultExprImpl(err));
 289 }
 290
 291 ResultExpr Kill() {
 292   return ResultExpr(new const KillResultExprImpl());
 293 }
 294
 295 ResultExpr Trace(uint16_t aux) {
 296   return ResultExpr(new const TraceResultExprImpl(aux));
 297 }
 298
 299 ResultExpr Trap(TrapRegistry::TrapFnc trap_func, const void* aux) {
 300   return ResultExpr(
 301       new const TrapResultExprImpl(trap_func, aux, true /* safe */));
 302 }
 303
 304 ResultExpr UnsafeTrap(TrapRegistry::TrapFnc trap_func, const void* aux) {
 305   return ResultExpr(
 306       new const TrapResultExprImpl(trap_func, aux, false /* unsafe */));
 307 }
 308
 309 BoolExpr BoolConst(bool value) {
 310   return BoolExpr(new const ConstBoolExprImpl(value));
 311 }
 312
 313 BoolExpr operator!(const BoolExpr& cond) {
 314   return BoolExpr(new const NegateBoolExprImpl(cond));
 315 }
 316
 317 BoolExpr operator&&(const BoolExpr& lhs, const BoolExpr& rhs) {
 318   return BoolExpr(new const AndBoolExprImpl(lhs, rhs));
 319 }
 320
 321 BoolExpr operator||(const BoolExpr& lhs, const BoolExpr& rhs) {
 322   return BoolExpr(new const OrBoolExprImpl(lhs, rhs));
 323 }
 324
 325 Elser If(const BoolExpr& cond, const ResultExpr& then_result) {
 326   return Elser(nullptr).ElseIf(cond, then_result);
 327 }
 328
 329 Elser::Elser(cons::List<Clause> clause_list) : clause_list_(clause_list) {
 330 }
 331
 332 Elser::Elser(const Elser& elser) : clause_list_(elser.clause_list_) {
 333 }
 334
 335 Elser::~Elser() {
 336 }
 337
 338 Elser Elser::ElseIf(const BoolExpr& cond, const ResultExpr& then_result) const {
 339   return Elser(Cons(std::make_pair(cond, then_result), clause_list_));
 340 }
 341
 342 ResultExpr Elser::Else(const ResultExpr& else_result) const {
 343   // We finally have the default result expression for this
 344   // if/then/else sequence.  Also, we've already accumulated all
 345   // if/then pairs into a list of reverse order (i.e., lower priority
 346   // conditions are listed before higher priority ones).  E.g., an
 347   // expression like
 348   //
 349   //    If(b1, e1).ElseIf(b2, e2).ElseIf(b3, e3).Else(e4)
 350   //
 351   // will have built up a list like
 352   //
 353   //    [(b3, e3), (b2, e2), (b1, e1)].
 354   //
 355   // Now that we have e4, we can walk the list and create a ResultExpr
 356   // tree like:
 357   //
 358   //    expr = e4
 359   //    expr = (b3 ? e3 : expr) = (b3 ? e3 : e4)
 360   //    expr = (b2 ? e2 : expr) = (b2 ? e2 : (b3 ? e3 : e4))
 361   //    expr = (b1 ? e1 : expr) = (b1 ? e1 : (b2 ? e2 : (b3 ? e3 : e4)))
 362   //
 363   // and end up with an appropriately chained tree.
 364
 365   ResultExpr expr = else_result;
 366   for (const Clause& clause : clause_list_) {
 367     expr = ResultExpr(
 368         new const IfThenResultExprImpl(clause.first, clause.second, expr));
 369   }
 370   return expr;
 371 }
 372
 373 }  // namespace bpf_dsl
 374 }  // namespace sandbox
 375
 376 template class scoped_refptr<const sandbox::bpf_dsl::internal::BoolExprImpl>;
 377 template class scoped_refptr<const sandbox::bpf_dsl::internal::ResultExprImpl>;