forked from mtusi2026/mtusi2026lab6
227 lines
9.5 KiB
Go
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
|
|
}
|