Files
mtusi2026lab6/app/cmd/s3check/main.go
T

227 lines
9.5 KiB
Go

// s3check проверяет права в S3 мимо API: анонимный доступ, ограничения ключей API и очистителя,
// закрытые служебные операции. Создаёт объект и временный bucket, в конце убирает их за собой.
// Запуск: docker compose --env-file .env run --rm s3check
package main
import (
"bytes"
"context"
"fmt"
"io"
"net/http"
"net/url"
"os"
"strings"
"time"
"github.com/google/uuid"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
const publicPolicy = `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":"*","Action":["s3:GetObject"],"Resource":["arn:aws:s3:::%s/*"]}]}`
var failures int
func expect(name string, allowed bool, err error) {
// Отказом считается именно ответ сервера о правах: обрыв связи не доказывает, что доступа нет.
code := minio.ToErrorResponse(err).Code
denied := err != nil && (code == "AccessDenied" || code == "InvalidAccessKeyId" || code == "SignatureDoesNotMatch")
observed := "разрешено"
switch {
case denied:
observed = "запрещено (" + code + ")"
case err != nil:
observed = "ошибка: " + err.Error()
}
ok := (allowed && err == nil) || (!allowed && denied)
verdict := "ok "
if !ok {
verdict = "FAIL"
failures++
}
fmt.Printf("%s %-58s %s\n", verdict, name, observed)
}
func secret(name string) string {
b, err := os.ReadFile("/run/secrets/" + name)
if err != nil {
fmt.Fprintln(os.Stderr, "s3check:", err)
os.Exit(2)
}
return strings.TrimSpace(string(b))
}
func client(endpoint *url.URL, region, role string) *minio.Client {
c, err := minio.New(endpoint.Host, &minio.Options{
Creds: credentials.NewStaticV4(secret(role+"access_key_id"), secret(role+"secret_access_key"), ""),
Secure: endpoint.Scheme == "https",
Region: region,
BucketLookup: minio.BucketLookupPath,
})
if err != nil {
fmt.Fprintln(os.Stderr, "s3check:", err)
os.Exit(2)
}
return c
}
func put(ctx context.Context, c *minio.Client, bucket, key string) error {
body := []byte("s3check")
_, err := c.PutObject(ctx, bucket, key, bytes.NewReader(body), int64(len(body)), minio.PutObjectOptions{DisableMultipart: true})
return err
}
func get(ctx context.Context, c *minio.Client, bucket, key string) error {
object, err := c.GetObject(ctx, bucket, key, minio.GetObjectOptions{})
if err != nil {
return err
}
defer object.Close()
_, err = io.ReadAll(object)
return err
}
func list(ctx context.Context, c *minio.Client, bucket string) error {
for object := range c.ListObjects(ctx, bucket, minio.ListObjectsOptions{Recursive: true}) {
return object.Err
}
return nil
}
// anonymous делает запрос без подписи и возвращает код ответа.
func anonymous(ctx context.Context, method, target string) (int, error) {
req, err := http.NewRequestWithContext(ctx, method, target, nil)
if err != nil {
return 0, err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return 0, err
}
defer resp.Body.Close()
return resp.StatusCode, nil
}
func main() {
os.Exit(run())
}
// run возвращает код завершения: os.Exit не выполнил бы отложенную уборку.
func run() int {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
endpoint, err := url.Parse(os.Getenv("S3_ENDPOINT"))
if err != nil || endpoint.Host == "" {
fmt.Fprintln(os.Stderr, "s3check: S3_ENDPOINT is required")
return 2
}
region, bucket := os.Getenv("S3_REGION"), os.Getenv("S3_BUCKET")
admin := client(endpoint, region, "s3_admin_")
api := client(endpoint, region, "s3_")
cleaner := client(endpoint, region, "s3_janitor_")
// Настоящий префикс оригиналов: ключи API и очистителя ограничены им. Объект свежий, поэтому
// работающий очиститель его не тронет, а в конце проверка удаляет его сама.
probe := "originals/" + uuid.NewString()
outside := "s3check/" + uuid.NewString()
other := "s3check-" + uuid.NewString()
fmt.Println("== Ключ подготовки (admin)")
expect("создать временный чужой bucket", true, admin.MakeBucket(ctx, other, minio.MakeBucketOptions{}))
expect("записать объект в чужой bucket", true, put(ctx, admin, other, "probe"))
defer func() {
_ = admin.RemoveObject(context.Background(), other, "probe", minio.RemoveObjectOptions{})
_ = admin.RemoveBucket(context.Background(), other)
}()
fmt.Println("== Ключ API: только объекты своего bucket")
expect("PUT объекта в свой bucket", true, put(ctx, api, bucket, probe))
expect("GET объекта из своего bucket", true, get(ctx, api, bucket, probe))
expect("LIST своего bucket", false, list(ctx, api, bucket))
expect("PUT вне префикса originals/", false, put(ctx, api, bucket, outside))
expect("GET из чужого bucket", false, get(ctx, api, other, "probe"))
expect("PUT в чужой bucket", false, put(ctx, api, other, "api-probe"))
expect("DELETE из чужого bucket", false, api.RemoveObject(ctx, other, "probe", minio.RemoveObjectOptions{}))
expect("создать bucket", false, api.MakeBucket(ctx, "s3check-"+uuid.NewString(), minio.MakeBucketOptions{}))
expect("удалить bucket", false, api.RemoveBucket(ctx, other))
expect("сделать bucket публичным (policy)", false, api.SetBucketPolicy(ctx, bucket, fmt.Sprintf(publicPolicy, bucket)))
expect("прочитать policy bucket", false, func() error { _, err := api.GetBucketPolicy(ctx, bucket); return err }())
fmt.Println("== Ключ очистителя: листинг и удаление, без чтения содержимого")
expect("LIST своего bucket", true, list(ctx, cleaner, bucket))
expect("GET содержимого объекта", false, get(ctx, cleaner, bucket, probe))
expect("LIST чужого bucket", false, list(ctx, cleaner, other))
expect("PUT вне префикса originals/", false, put(ctx, cleaner, bucket, outside))
expect("сделать bucket публичным (policy)", false, cleaner.SetBucketPolicy(ctx, bucket, fmt.Sprintf(publicPolicy, bucket)))
expect("создать bucket", false, cleaner.MakeBucket(ctx, "s3check-"+uuid.NewString(), minio.MakeBucketOptions{}))
expect("удалить чужой bucket", false, cleaner.RemoveBucket(ctx, other))
expect("DELETE объекта в своём bucket", true, cleaner.RemoveObject(ctx, bucket, probe, minio.RemoveObjectOptions{}))
fmt.Println("== Политика bucket: не задана, доступ только по ключам")
policy, err := admin.GetBucketPolicy(ctx, bucket)
if err != nil && minio.ToErrorResponse(err).Code == "NoSuchBucketPolicy" {
err = nil
}
expect("прочитать политику ключом администратора", true, err)
verdict := "ok "
if policy != "" {
verdict = "FAIL"
failures++
}
fmt.Printf("%s %-58s %d байт\n", verdict, "политика пуста", len(policy))
fmt.Println("== Без подписи: приватность вне API")
if err := put(ctx, admin, bucket, probe); err != nil {
expect("подготовить объект", true, err)
}
defer func() { _ = admin.RemoveObject(context.Background(), bucket, probe, minio.RemoveObjectOptions{}) }()
base := strings.TrimRight(endpoint.String(), "/") + "/"
for _, request := range []struct{ name, method, target string }{
{"GET объекта", http.MethodGet, base + bucket + "/" + probe},
{"HEAD объекта", http.MethodHead, base + bucket + "/" + probe},
{"GET списка объектов", http.MethodGet, base + bucket + "/"},
{"GET списка bucket", http.MethodGet, base},
{"PUT объекта", http.MethodPut, base + bucket + "/" + probe + "-anon"},
{"DELETE объекта", http.MethodDelete, base + bucket + "/" + probe},
} {
status, err := anonymous(ctx, request.method, request.target)
verdict = "ok "
if err != nil || status != http.StatusForbidden {
verdict = "FAIL"
failures++
}
fmt.Printf("%s %-58s HTTP %d\n", verdict, request.name, status)
}
fmt.Println("== Служебные порты SeaweedFS из сети стенда (шлюз пропускает только 9000)")
host := endpoint.Hostname()
for _, port := range []string{"19000", "8888", "8080", "9333", "18888", "18080", "19333", "8333", "8111", "23646"} {
_, err := anonymous(ctx, http.MethodGet, "http://"+host+":"+port+"/")
verdict = "ok "
closed := "закрыт"
if err == nil {
verdict, closed = "FAIL", "ОТКРЫТ"
failures++
}
fmt.Printf("%s порт %-53s %s\n", verdict, port, closed)
}
// Имя настоящего сервера существует только во внутренней сети, куда входит лишь шлюз.
_, err = anonymous(ctx, http.MethodGet, "http://s3-storage:9000/")
verdict = "ok "
observed := "недоступен"
if err == nil {
verdict, observed = "FAIL", "ДОСТУПЕН"
failures++
}
fmt.Printf("%s %-58s %s\n", verdict, "SeaweedFS напрямую, минуя шлюз (s3-storage:9000)", observed)
if failures > 0 {
fmt.Printf("\nFAIL: %d проверок не прошли\n", failures)
return 1
}
fmt.Println("\nPASS: права S3 ограничены, bucket приватен, служебные порты закрыты")
return 0
}