|
- // Copyright 2016 The Go Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style
- // license that can be found in the LICENSE file.
-
- package bpf_test
-
- import (
- "testing"
-
- "golang.org/x/net/bpf"
- )
-
- func TestVMALUOpAdd(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpAdd,
- Val: 3,
- },
- bpf.RetA{},
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 8, 2, 3,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 3, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpSub(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.TAX{},
- bpf.ALUOpX{
- Op: bpf.ALUOpSub,
- },
- bpf.RetA{},
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 1, 2, 3,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 0, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpMul(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpMul,
- Val: 2,
- },
- bpf.RetA{},
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 6, 2, 3, 4,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 4, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpDiv(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpDiv,
- Val: 2,
- },
- bpf.RetA{},
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 20, 2, 3, 4,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 2, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpDivByZeroALUOpConstant(t *testing.T) {
- _, _, err := testVM(t, []bpf.Instruction{
- bpf.ALUOpConstant{
- Op: bpf.ALUOpDiv,
- Val: 0,
- },
- bpf.RetA{},
- })
- if errStr(err) != "cannot divide by zero using ALUOpConstant" {
- t.Fatalf("unexpected error: %v", err)
- }
- }
-
- func TestVMALUOpDivByZeroALUOpX(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- // Load byte 0 into X
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.TAX{},
- // Load byte 1 into A
- bpf.LoadAbsolute{
- Off: 9,
- Size: 1,
- },
- // Attempt to perform 1/0
- bpf.ALUOpX{
- Op: bpf.ALUOpDiv,
- },
- // Return 4 bytes if program does not terminate
- bpf.LoadConstant{
- Val: 12,
- },
- bpf.RetA{},
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 0, 1, 3, 4,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 0, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpOr(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 2,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpOr,
- Val: 0x01,
- },
- bpf.RetA{},
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 0x00, 0x10, 0x03, 0x04,
- 0x05, 0x06, 0x07, 0x08,
- 0x09, 0xff,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 9, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpAnd(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 2,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpAnd,
- Val: 0x0019,
- },
- bpf.RetA{},
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 0xaa, 0x09,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 1, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpShiftLeft(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpShiftLeft,
- Val: 0x01,
- },
- bpf.JumpIf{
- Cond: bpf.JumpEqual,
- Val: 0x02,
- SkipTrue: 1,
- },
- bpf.RetConstant{
- Val: 0,
- },
- bpf.RetConstant{
- Val: 9,
- },
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 0x01, 0xaa,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 1, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpShiftRight(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpShiftRight,
- Val: 0x01,
- },
- bpf.JumpIf{
- Cond: bpf.JumpEqual,
- Val: 0x04,
- SkipTrue: 1,
- },
- bpf.RetConstant{
- Val: 0,
- },
- bpf.RetConstant{
- Val: 9,
- },
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 0x08, 0xff, 0xff,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 1, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpMod(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpMod,
- Val: 20,
- },
- bpf.RetA{},
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 30, 0, 0,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 2, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpModByZeroALUOpConstant(t *testing.T) {
- _, _, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpMod,
- Val: 0,
- },
- bpf.RetA{},
- })
- if errStr(err) != "cannot divide by zero using ALUOpConstant" {
- t.Fatalf("unexpected error: %v", err)
- }
- }
-
- func TestVMALUOpModByZeroALUOpX(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- // Load byte 0 into X
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.TAX{},
- // Load byte 1 into A
- bpf.LoadAbsolute{
- Off: 9,
- Size: 1,
- },
- // Attempt to perform 1%0
- bpf.ALUOpX{
- Op: bpf.ALUOpMod,
- },
- // Return 4 bytes if program does not terminate
- bpf.LoadConstant{
- Val: 12,
- },
- bpf.RetA{},
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 0, 1, 3, 4,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 0, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpXor(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpXor,
- Val: 0x0a,
- },
- bpf.JumpIf{
- Cond: bpf.JumpEqual,
- Val: 0x01,
- SkipTrue: 1,
- },
- bpf.RetConstant{
- Val: 0,
- },
- bpf.RetConstant{
- Val: 9,
- },
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 0x0b, 0x00, 0x00, 0x00,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 1, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
-
- func TestVMALUOpUnknown(t *testing.T) {
- vm, done, err := testVM(t, []bpf.Instruction{
- bpf.LoadAbsolute{
- Off: 8,
- Size: 1,
- },
- bpf.ALUOpConstant{
- Op: bpf.ALUOpAdd,
- Val: 1,
- },
- // Verify that an unknown operation is a no-op
- bpf.ALUOpConstant{
- Op: 100,
- },
- bpf.JumpIf{
- Cond: bpf.JumpEqual,
- Val: 0x02,
- SkipTrue: 1,
- },
- bpf.RetConstant{
- Val: 0,
- },
- bpf.RetConstant{
- Val: 9,
- },
- })
- if err != nil {
- t.Fatalf("failed to load BPF program: %v", err)
- }
- defer done()
-
- out, err := vm.Run([]byte{
- 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff,
- 1,
- })
- if err != nil {
- t.Fatalf("unexpected error while running program: %v", err)
- }
- if want, got := 1, out; want != got {
- t.Fatalf("unexpected number of output bytes:\n- want: %d\n- got: %d",
- want, got)
- }
- }
|