Настройка шифрования

1
aws s3api get-bucket-encryption --bucket <имя бакета>

1
import boto3
2
import json
3

4
session = boto3.session.Session(profile_name='default')
5
s3 = session.client(
6
    service_name='s3',
7
    endpoint_url='https://storage.mwsapis.ru/'
8
)
9

10
response = s3.get_bucket_encryption(
11
    Bucket='<имя бакета>'
12
)
13

14
# Извлекает данные из ответа
15
rules = response['ServerSideEncryptionConfiguration']['Rules'][0]
16
encryption = rules['ApplyServerSideEncryptionByDefault']
17
algorithm = encryption['SSEAlgorithm']
18

19
print(f"Bucket: kms-encryption-test")
20
print(f"Encryption status: ENABLED")
21
print(f"SSE Algorithm: {algorithm}")
22

23
# Если есть пользовательский ключ, выводит его ID
24
if 'KMSMasterKeyID' in encryption:
25
    print(f"KMS Key ID: {encryption['KMSMasterKeyID']}")
26
else: # Если пользовательского ключа нет, выводит информацию об использовании системного ключа
27
    print("System key is used for encryption")

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
8

9
    "github.com/aws/aws-sdk-go-v2/aws"
10
    "github.com/aws/aws-sdk-go-v2/config"
11
    "github.com/aws/aws-sdk-go-v2/service/s3"
12
)
13

14
func main() {
15
    // Получает имя бакета из аргумента командной строки
16
    bucketName := flag.String("b", "", "The name of the bucket")
17
    flag.Parse()
18

19
    if *bucketName == "" {
20
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
21
        return
22
    }
23

24
    // Подгружает конфигурацию из ~/.aws/*
25
    cfg, err := config.LoadDefaultConfig(context.TODO())
26
    if err != nil {
27
        log.Fatal(err)
28
    }
29

30
    // Создает клиент для подключения Object Storage
31
    client := s3.NewFromConfig(cfg)
32

33
    // Получает конфигурацию шифрования
34
    result, err := client.GetBucketEncryption(context.TODO(), &s3.GetBucketEncryptionInput{
35
        Bucket: aws.String(*bucketName),
36
    })
37
    if err != nil {
38
        log.Fatal(err)
39
    }
40

41
    // Извлекает данные из ответа
42
    if len(result.ServerSideEncryptionConfiguration.Rules) > 0 {
43
        rule := result.ServerSideEncryptionConfiguration.Rules[0]
44
        encryption := rule.ApplyServerSideEncryptionByDefault
45

46
        fmt.Printf("Bucket: %s\n", *bucketName)
47
        fmt.Printf("Encryption status: ENABLED\n")
48
        fmt.Printf("SSE Algorithm: %s\n", encryption.SSEAlgorithm)
49

50
        // Если есть пользовательский ключ, выводит его
51
        if encryption.KMSMasterKeyID != nil {
52
            fmt.Printf("KMS Key ID: %s\n", *encryption.KMSMasterKeyID)
53
        } else {  // Если пользовательского ключа нет, выводит информацию об использовании системного ключа
54
            fmt.Println("System key is used for encryption")
55
        }
56
    }
57
 }

1
aws s3api put-bucket-encryption \
2
    --bucket <имя бакета> \
3
    --server-side-encryption-configuration '{
4
        "Rules": [
5
            {
6
                "ApplyServerSideEncryptionByDefault": {
7
                    "SSEAlgorithm": "aws:kms",
8
                    "KMSMasterKeyID": "kms/projects/<имя проекта>/cryptoKeys/<имя ключа>"
9
                }
10
            }
11
        ]
12
    }'

1
import boto3
2

3
# Создаем клиент для подключения к Object Storage
4
s3 = boto3.client('s3')
5

6
# Имя бакета
7
bucket_name = '<имя бакета>'
8

9
# Определяет настройки шифрования
10
server_side_encryption_configuration = {
11
    'Rules': [
12
        {
13
            'ApplyServerSideEncryptionByDefault': {
14
                'SSEAlgorithm': 'aws:kms',
15
                'KMSMasterKeyID': 'kms/projects/<имя проекта>/cryptoKeys/<имя ключа>' #ID пользовательского ключа в сервисе KMS
16
            }
17
        }
18
    ]
19
}
20

21
# Устанавливает конфигурацию шифрования
22
s3.put_bucket_encryption(
23
    Bucket=bucket_name,
24
    ServerSideEncryptionConfiguration=server_side_encryption_configuration
25
)
26

27
# Сообщает, что конфигурация шифрования успешно применена
28
print("The bucket is encrypted with the specified user key")

1
package main
2

3
import (
4
    "context"
5
    "fmt"
6
    "log"
7
    "github.com/aws/aws-sdk-go-v2/aws"
8
    "github.com/aws/aws-sdk-go-v2/config"
9
    "github.com/aws/aws-sdk-go-v2/service/s3"
10
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
11
)
12

13
func main() {
14
    // Подгружает конфигурацию из ~/.aws/*
15
    cfg, err := config.LoadDefaultConfig(context.TODO())
16
    if err != nil {
17
        log.Fatal(err)
18
    }
19

20
    // Создает клиент для доступа к Object Storage
21
    client := s3.NewFromConfig(cfg)
22

23
    // Имя бакета
24
    bucketName := "<имя бакета>"
25

26
    //ID ключа
27
    keyID := "kms/projects/<имя проекта/cryptoKeys/<имя ключа>"
28

29
    // Создает конфигурацию шифрования
30
    encryptionConfig := &types.ServerSideEncryptionConfiguration{
31
        Rules: []types.ServerSideEncryptionRule{
32
            {
33
                ApplyServerSideEncryptionByDefault: &types.ServerSideEncryptionByDefault{
34
                    SSEAlgorithm: types.ServerSideEncryptionAwsKms,
35
                    KMSMasterKeyID: aws.String(keyID),
36
                },
37
            },
38
        },
39
    }
40

41
    // Применяет  конфигурацию шифрования к бакету
42
    _, err = client.PutBucketEncryption(context.TODO(), &s3.PutBucketEncryptionInput{
43
        Bucket: aws.String(bucketName),
44
        ServerSideEncryptionConfiguration: encryptionConfig,
45
    })
46

47
    if err != nil {
48
        log.Fatalf("Failed to enable encryption: %v", err)
49
    }
50

51
    fmt.Printf("Encryption successfully enabled for bucket: %s\n", bucketName)
52
    fmt.Printf("Encrypted with user key: %s\n", keyID)
53
    fmt.Printf("SSE Algorithm: %s\n", types.ServerSideEncryptionAwsKms)
54
}

1
aws s3api delete-bucket-encryption --bucket <имя бакета>

1
import boto3
2
from botocore.exceptions import ClientError
3

4
def disable_encryption(bucket_name):
5
    try:
6
        # Создает клиент для подключения к Object Storage
7
        s3_client = boto3.client('s3')
8

9
        # Отменяет шифрование пользовательским ключом
10
        s3_client.delete_bucket_encryption(Bucket=bucket_name)
11

12
        print(f"Encryption with user key successfully disabled for bucket: {bucket_name}. The system key is used for encryption.")
13

14
    except ClientError as e:
15
        print(f"Error disabling encryption: {e}")
16
        raise
17
    except Exception as e:
18
        print(f"Unexpected error: {e}")
19
        raise
20

21
# Использование функции
22
try:
23
    bucket_name = "<имя бакета>"
24
    disable_encryption(bucket_name)
25
except Exception as e:
26
    print(f"Failed to disable user key encryption: {e}")

1
package main
2

3
import (
4
    "context"
5
    "fmt"
6
    "log"
7

8
    "github.com/aws/aws-sdk-go-v2/aws"
9
    "github.com/aws/aws-sdk-go-v2/config"
10
    "github.com/aws/aws-sdk-go-v2/service/s3"
11
)
12

13
func main() {
14
    // Подгружает конфигурацию из ~/.aws/*
15
    cfg, err := config.LoadDefaultConfig(context.TODO())
16
    if err != nil {
17
        log.Fatal(err)
18
    }
19

20
    // Создает клиент для доступа к Object Storage
21
    client := s3.NewFromConfig(cfg)
22

23
    // Имя бакета
24
    bucketName := "<имя бакета>"
25

26
    // Отменяет шифрование пользовательским ключом для бакета
27
    _, err = client.DeleteBucketEncryption(context.TODO(), &s3.DeleteBucketEncryptionInput{
28
        Bucket: aws.String(bucketName),
29
    })
30

31
    if err != nil {
32
        log.Fatalf("Failed to disable encryption: %v", err)
33
    }
34

35
    fmt.Printf("Encryption with user key successfully disabled for bucket: %s.\nThe system key is used for encryption.\n", bucketName)
36

37
}

1
aws s3 cp <путь к объекту> s3://<имя бакета>/<имя объекта> --sse aws:kms  --sse-kms-key-id kms/projects/<имя проекта>/cryptoKeys/<имя ключа>

1
import boto3
2

3
session = boto3.session.Session(profile_name='default')
4
s3 = session.client(
5
    service_name='s3',
6
    endpoint_url='https://storage.mwsapis.ru/'
7
)
8

9
s3.upload_file(
10
    '<имя файла в локальной системе>',
11
    '<имя бакета>',
12
    '<имя объекта в Object Storage>',
13
    ExtraArgs={
14
        'ServerSideEncryption': 'aws:kms',           # Шифрует данные указанным пользовательским ключом
15
        'SSEKMSKeyId': 'kms/projects/<имя проекта>/cryptoKeys/<имя ключа>'  # ID пользовательского ключа в сервисе KMS
16
    }
17
)

1
package main
2

3
import (
4
    "context"
5
    "flag"
6
    "fmt"
7
    "log"
8
    "os"
9
    "path/filepath"
10

11
    "github.com/aws/aws-sdk-go-v2/aws"
12
    "github.com/aws/aws-sdk-go-v2/config"
13
    "github.com/aws/aws-sdk-go-v2/service/s3"
14
    "github.com/aws/aws-sdk-go-v2/service/s3/types"
15
)
16

17
func main() {
18
    // Получает из аргументов командной строки имя бакета, путь к файлу в локальной системе, ID ключа
19
    bucketName := flag.String("b", "", "The name of the bucket")
20
    filePath := flag.String("f", "", "Path to the file to upload")
21
    kmsKeyID := flag.String("k", "", "user key ID for server-side encryption")
22

23
    flag.Parse()
24

25
    if *bucketName == "" {
26
        fmt.Println("You must supply the name of a bucket (-b BUCKET)")
27
        return
28
    }
29

30
    if *filePath == "" {
31
        fmt.Println("You must supply the path to a file (-f FILE)")
32
        return
33
    }
34

35
    // Подгружает конфигурацию из ~/.aws
36
    cfg, err := config.LoadDefaultConfig(context.TODO())
37
    if err != nil {
38
        log.Fatal(err)
39
    }
40

41
    // Создает клиент для подключения к Object Storage
42
    client := s3.NewFromConfig(cfg)
43

44
    file, err := os.Open(*filePath)
45
    if err != nil {
46
        log.Fatalf("Unable to open file %q, %v", *filePath, err)
47
    }
48
    defer file.Close()
49

50
    // Задает параметры загрузки объекта
51
    uploadInput := &s3.PutObjectInput{
52
        Bucket: aws.String(*bucketName),
53
        Key:    aws.String(filepath.Base(*filePath)),
54
        Body:   file,
55
    }
56

57
    // Если указан пользовательский ключ, добавляет параметры шифрования
58
    if *kmsKeyID != "" {
59
        uploadInput.ServerSideEncryption = types.ServerSideEncryptionAwsKms
60
        uploadInput.SSEKMSKeyId = aws.String(*kmsKeyID)
61
        fmt.Printf("Using KMS key: %s for encryption\n", *kmsKeyID)
62
    } else {
63
        fmt.Println("No user key provided, uploading without server-side encryption.")
64
    }
65
        // В этом случае объект будет зашифрован с помощью системного ключа
66

67
    // Загружает объект
68
    _, err = client.PutObject(context.TODO(), uploadInput)
69
    if err != nil {
70
        log.Fatalf("Unable to upload %q to %q, %v", *filePath, *bucketName, err)
71
    }
72

73
    fmt.Printf("Successfully uploaded %q to %q\n", *filePath, *bucketName)
74
}