libgo/go/cmd/go/internal/work/security_test.go

   1 // Copyright 2018 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package work
   6
   7 import (
   8         "os"
   9         "testing"
  10 )
  11
  12 var goodCompilerFlags = [][]string{
  13         {"-DFOO"},
  14         {"-Dfoo=bar"},
  15         {"-F/Qt"},
  16         {"-I/"},
  17         {"-I/etc/passwd"},
  18         {"-I."},
  19         {"-O"},
  20         {"-O2"},
  21         {"-Osmall"},
  22         {"-W"},
  23         {"-Wall"},
  24         {"-fobjc-arc"},
  25         {"-fno-objc-arc"},
  26         {"-fomit-frame-pointer"},
  27         {"-fno-omit-frame-pointer"},
  28         {"-fpic"},
  29         {"-fno-pic"},
  30         {"-fPIC"},
  31         {"-fno-PIC"},
  32         {"-fpie"},
  33         {"-fno-pie"},
  34         {"-fPIE"},
  35         {"-fno-PIE"},
  36         {"-fsplit-stack"},
  37         {"-fno-split-stack"},
  38         {"-fstack-xxx"},
  39         {"-fno-stack-xxx"},
  40         {"-fsanitize=hands"},
  41         {"-g"},
  42         {"-ggdb"},
  43         {"-march=souza"},
  44         {"-mcpu=123"},
  45         {"-mfpu=123"},
  46         {"-mtune=happybirthday"},
  47         {"-mstack-overflow"},
  48         {"-mno-stack-overflow"},
  49         {"-mmacosx-version"},
  50         {"-mnop-fun-dllimport"},
  51         {"-pthread"},
  52         {"-std=c99"},
  53         {"-xc"},
  54         {"-D", "FOO"},
  55         {"-D", "foo=bar"},
  56         {"-I", "."},
  57         {"-I", "/etc/passwd"},
  58         {"-I", "世界"},
  59         {"-framework", "Chocolate"},
  60         {"-x", "c"},
  61 }
  62
  63 var badCompilerFlags = [][]string{
  64         {"-D@X"},
  65         {"-D-X"},
  66         {"-F@dir"},
  67         {"-F-dir"},
  68         {"-I@dir"},
  69         {"-I-dir"},
  70         {"-O@1"},
  71         {"-Wa,-foo"},
  72         {"-W@foo"},
  73         {"-g@gdb"},
  74         {"-g-gdb"},
  75         {"-march=@dawn"},
  76         {"-march=-dawn"},
  77         {"-std=@c99"},
  78         {"-std=-c99"},
  79         {"-x@c"},
  80         {"-x-c"},
  81         {"-D", "@foo"},
  82         {"-D", "-foo"},
  83         {"-I", "@foo"},
  84         {"-I", "-foo"},
  85         {"-framework", "-Caffeine"},
  86         {"-framework", "@Home"},
  87         {"-x", "--c"},
  88         {"-x", "@obj"},
  89 }
  90
  91 func TestCheckCompilerFlags(t *testing.T) {
  92         for _, f := range goodCompilerFlags {
  93                 if err := checkCompilerFlags("test", "test", f); err != nil {
  94                         t.Errorf("unexpected error for %q: %v", f, err)
  95                 }
  96         }
  97         for _, f := range badCompilerFlags {
  98                 if err := checkCompilerFlags("test", "test", f); err == nil {
  99                         t.Errorf("missing error for %q", f)
 100                 }
 101         }
 102 }
 103
 104 var goodLinkerFlags = [][]string{
 105         {"-Fbar"},
 106         {"-lbar"},
 107         {"-Lbar"},
 108         {"-fpic"},
 109         {"-fno-pic"},
 110         {"-fPIC"},
 111         {"-fno-PIC"},
 112         {"-fpie"},
 113         {"-fno-pie"},
 114         {"-fPIE"},
 115         {"-fno-PIE"},
 116         {"-fsanitize=hands"},
 117         {"-g"},
 118         {"-ggdb"},
 119         {"-march=souza"},
 120         {"-mcpu=123"},
 121         {"-mfpu=123"},
 122         {"-mtune=happybirthday"},
 123         {"-pic"},
 124         {"-pthread"},
 125         {"-Wl,-rpath,foo"},
 126         {"-Wl,-rpath,$ORIGIN/foo"},
 127         {"-Wl,--warn-error"},
 128         {"-Wl,--no-warn-error"},
 129         {"foo.so"},
 130         {"_世界.dll"},
 131         {"./x.o"},
 132         {"libcgosotest.dylib"},
 133         {"-F", "framework"},
 134         {"-l", "."},
 135         {"-l", "/etc/passwd"},
 136         {"-l", "世界"},
 137         {"-L", "framework"},
 138         {"-framework", "Chocolate"},
 139         {"-Wl,-framework", "-Wl,Chocolate"},
 140         {"-Wl,-framework,Chocolate"},
 141         {"-Wl,-unresolved-symbols=ignore-all"},
 142 }
 143
 144 var badLinkerFlags = [][]string{
 145         {"-DFOO"},
 146         {"-Dfoo=bar"},
 147         {"-W"},
 148         {"-Wall"},
 149         {"-fobjc-arc"},
 150         {"-fno-objc-arc"},
 151         {"-fomit-frame-pointer"},
 152         {"-fno-omit-frame-pointer"},
 153         {"-fsplit-stack"},
 154         {"-fno-split-stack"},
 155         {"-fstack-xxx"},
 156         {"-fno-stack-xxx"},
 157         {"-mstack-overflow"},
 158         {"-mno-stack-overflow"},
 159         {"-mnop-fun-dllimport"},
 160         {"-std=c99"},
 161         {"-xc"},
 162         {"-D", "FOO"},
 163         {"-D", "foo=bar"},
 164         {"-I", "FOO"},
 165         {"-L", "@foo"},
 166         {"-L", "-foo"},
 167         {"-x", "c"},
 168         {"-D@X"},
 169         {"-D-X"},
 170         {"-I@dir"},
 171         {"-I-dir"},
 172         {"-O@1"},
 173         {"-Wa,-foo"},
 174         {"-W@foo"},
 175         {"-g@gdb"},
 176         {"-g-gdb"},
 177         {"-march=@dawn"},
 178         {"-march=-dawn"},
 179         {"-std=@c99"},
 180         {"-std=-c99"},
 181         {"-x@c"},
 182         {"-x-c"},
 183         {"-D", "@foo"},
 184         {"-D", "-foo"},
 185         {"-I", "@foo"},
 186         {"-I", "-foo"},
 187         {"-l", "@foo"},
 188         {"-l", "-foo"},
 189         {"-framework", "-Caffeine"},
 190         {"-framework", "@Home"},
 191         {"-Wl,-framework,-Caffeine"},
 192         {"-Wl,-framework", "-Wl,@Home"},
 193         {"-Wl,-framework", "@Home"},
 194         {"-Wl,-framework,Chocolate,@Home"},
 195         {"-x", "--c"},
 196         {"-x", "@obj"},
 197         {"-Wl,-rpath,@foo"},
 198         {"../x.o"},
 199 }
 200
 201 func TestCheckLinkerFlags(t *testing.T) {
 202         for _, f := range goodLinkerFlags {
 203                 if err := checkLinkerFlags("test", "test", f); err != nil {
 204                         t.Errorf("unexpected error for %q: %v", f, err)
 205                 }
 206         }
 207         for _, f := range badLinkerFlags {
 208                 if err := checkLinkerFlags("test", "test", f); err == nil {
 209                         t.Errorf("missing error for %q", f)
 210                 }
 211         }
 212 }
 213
 214 func TestCheckFlagAllowDisallow(t *testing.T) {
 215         if err := checkCompilerFlags("TEST", "test", []string{"-disallow"}); err == nil {
 216                 t.Fatalf("missing error for -disallow")
 217         }
 218         os.Setenv("CGO_TEST_ALLOW", "-disallo")
 219         if err := checkCompilerFlags("TEST", "test", []string{"-disallow"}); err == nil {
 220                 t.Fatalf("missing error for -disallow with CGO_TEST_ALLOW=-disallo")
 221         }
 222         os.Setenv("CGO_TEST_ALLOW", "-disallow")
 223         if err := checkCompilerFlags("TEST", "test", []string{"-disallow"}); err != nil {
 224                 t.Fatalf("unexpected error for -disallow with CGO_TEST_ALLOW=-disallow: %v", err)
 225         }
 226         os.Unsetenv("CGO_TEST_ALLOW")
 227
 228         if err := checkCompilerFlags("TEST", "test", []string{"-Wall"}); err != nil {
 229                 t.Fatalf("unexpected error for -Wall: %v", err)
 230         }
 231         os.Setenv("CGO_TEST_DISALLOW", "-Wall")
 232         if err := checkCompilerFlags("TEST", "test", []string{"-Wall"}); err == nil {
 233                 t.Fatalf("missing error for -Wall with CGO_TEST_DISALLOW=-Wall")
 234         }
 235         os.Setenv("CGO_TEST_ALLOW", "-Wall") // disallow wins
 236         if err := checkCompilerFlags("TEST", "test", []string{"-Wall"}); err == nil {
 237                 t.Fatalf("missing error for -Wall with CGO_TEST_DISALLOW=-Wall and CGO_TEST_ALLOW=-Wall")
 238         }
 239
 240         os.Setenv("CGO_TEST_ALLOW", "-fplugin.*")
 241         os.Setenv("CGO_TEST_DISALLOW", "-fplugin=lint.so")
 242         if err := checkCompilerFlags("TEST", "test", []string{"-fplugin=faster.so"}); err != nil {
 243                 t.Fatalf("unexpected error for -fplugin=faster.so: %v", err)
 244         }
 245         if err := checkCompilerFlags("TEST", "test", []string{"-fplugin=lint.so"}); err == nil {
 246                 t.Fatalf("missing error for -fplugin=lint.so: %v", err)
 247         }
 248 }