storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/docs/security/README.md (about) 1 # MinIO Security Overview [](https://slack.min.io) 2 3 ## Server-Side Encryption 4 5 MinIO supports two different types of server-side encryption ([SSE](#sse)): 6 - **SSE-C**: The MinIO server en/decrypts an object with a secret key provided by the S3 client as part of the HTTP request headers. Therefore, [SSE-C](#ssec) requires TLS/HTTPS. 7 - **SSE-S3**: The MinIO server en/decrypts an object with a secret key managed by a KMS. Therefore, MinIO requires a valid KMS configuration for [SSE-S3](#sses3). 8 9 ### Server-Side Encryption - Preliminaries 10 11 #### Secret Keys 12 13 The MinIO server uses an unique, randomly generated secret key per object also known as, Object Encryption Key ([OEK](#oek)). Neither the client-provided SSE-C key nor the KMS-managed key is directly used to en/decrypt an object. Instead, the OEK is stored as part of the object metadata next to the object in an encrypted form. To en/decrypt the OEK another secret key is needed also known as, Key Encryption Key ([KEK](#kek)). 14 15 The MinIO server runs a key-derivation algorithm to generate the KEK using a pseudo-random function ([PRF](#prf)): 16 `KEK := PRF(EK, IV, context_values)` where: 17 18 - [EK](#ek): is the external key. In case of SSE-C this is the client-provided key. In case of SSE-S3 this is secret key generated by the KMS. For further details see [SSE-C](#Server-Side-Encryption-with-client-provided-Keys) or [SSE-S3](#Server-Side-Encryption-with-a-KMS). 19 - [IV](#iv): is a randomly generated initialization vector. It is public and part of the object metadata. 20 - `context_values`: are values like the bucket and object name and other information which should be cryptographically bound to the KEK. 21 22 To summarize for any encrypted object there exists (at least) three different keys: 23 24 - [OEK](#oek): A secret and unique key used to encrypted the object, stored in an encrypted form as part of the object metadata and only loaded to RAM in plaintext during en/decrypting the object. 25 - [KEK](#kek): A secret and unique key used to en/decrypt the OEK and never stored anywhere. It is(re-)generated whenever en/decrypting an object using an external secret key and public parameters. 26 - [EK](#ek): An external secret key - either the SSE-C client-provided key or a secret key generated by the KMS. 27 28 #### Content Encryption 29 30 The MinIO server uses an authenticated encryption scheme ([AEAD](#aead)) to en/decrypt and authenticate the object content. The AEAD is combined with some state to build a *Secure Channel*. A *Secure Channel* is a cryptographic construction that ensures confidentiality and integrity of the processed data. In particular the *Secure Channel* splits the plaintext content into fixed size chunks and en/decrypts each chunk separately using an unique key-nonce combination. 31 32 ``` 33 plaintext := chunk_0 || chunk_1 || chunk_2 || ... 34 | | | 35 | | | 36 AEAD <- key, nonce + 0 AEAD <- key, nonce + 1 AEAD <- key, nonce + 2 ... 37 | | | 38 | | | 39 ciphertext := sealed_chunk_0 || sealed_chunk_1 || sealed_chunk_2 || ... 40 ``` 41 <center>Figure 1 - Secure Channel construction</center> 42 43 In case of a S3 multi-part operation each part is en/decrypted with the scheme shown in Figure 1. However, for each part an unique secret key is derived from the OEK and the part number using a PRF. So in case of multi-part not the OEK but the output of `PRF(OEK, part_id)` is used as secret key. 44 45 #### Cryptographic Primitives 46 47 The SSE schemes described in [Secret Keys](#Secret-Keys) and [Content Encryption](#Content-Encryption) are generic over the cryptographic primitives. However, the MinIO server uses the following cryptographic primitive implementations: 48 49 - [PRF](#prf): HMAC-SHA-256 50 - [AEAD](#aead): AES-256-GCM if the CPU supports AES-NI, ChaCha20-Poly1305 otherwise. More specifically AES-256-GCM is only selected for X86-64 CPUs with AES-NI extension. 51 52 Further any secret key (apart from the KMS-generated ones) is 256 bits long. The KMS-generated keys may be 256 bits but this depends on the KMS capabilities and configuration. 53 54 The *Secure Channel* splits the object content into chunks of a fixed size of `65536` bytes. The last chunk may be smaller to avoid adding additional overhead and is treated specially to prevent truncation attacks. The nonce value is 96 bits long and generated randomly per object / multi-part part. The *Secure Channel* supports plaintexts up to `65536 * 2^32 = 256 TiB`. 55 56 #### Randomness 57 58 The MinIO server generates unique keys and other cryptographic values using a cryptographically secure pseudo-random number generator ([CSPRNG](#csprng)). However, in the context of SSE, the MinIO server does not require that the CSPRNG generates values that are indistinguishable from truly random bit strings. Instead, it is sufficient if the generated values are unique - which is a weaker requirement. Nevertheless other parts - for example the TLS-stack - may require that CSPRNG-generated values are indistinguishable from truly random bit strings. 59 60 ### Server-Side Encryption with client-provided Keys 61 62 SSE-C allows an S3 client to en/decrypt an object at the MinIO server. Therefore the S3 client sends a secret key as part of the HTTP request. This secret key is **never** stored by the MinIO server and only resides in RAM during the en/decryption process. 63 64 MinIO does not assume or require that the client-provided key is unique. It may be used for multiple objects or buckets. Especially a single client-provided key may be used for all objects - even though all objects must be treated as compromised if that key is ever compromised. 65 66 #### Key rotation 67 68 S3 clients can change the client-provided key of an existing object. Therefore an S3 client must perform a S3 COPY operation where the copy source and destination are equal. Further the COPY request headers must contain the current and the new client key: 69 70 - `X-Amz-Server-Side-Encryption-Customer-Key`: Base64 encoded new key. 71 - `X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key`: Base64 encoded current key. 72 73 Such a special COPY request is also known as S3 SSE-C key rotation. 74 75 ### Server-Side Encryption with a KMS 76 77 SSE-S3 allows an S3 client to en/decrypt an object at the MinIO server using a KMS. The MinIO 78 server only assumes that the KMS provides two services: 79 80 - `GenerateKey`: Takes a key ID and generates a new data key from a master key referenced by the key ID. It returns the new data key in two different forms: The plain data key and the data key encrypted using the master key. 81 82 - `DecryptKey`: Takes a key ID and an encrypted data key and returns the plain data key - the decryption of the encrypted data key using the master key referenced by the key ID - on success or an error otherwise. 83 84 More details about supported KMS implementations and configuration can be found at the [KMS guide](https://github.com/minio/minio/blob/master/docs/kms/README.md). 85 86 The MinIO server requests a new data key from the KMS for each uploaded object and uses that data key as EK. Additionally it stores the encrypted form of the data key and the master key ID as part of the object metadata. The plain data only resides in RAM during the en/decryption process. The MinIO server does not store any SSE-related key at the KMS. Instead the KMS is treated as trusted component that performs key sealing/unsealing operations to build a key hierarchy: 87 88 ``` 89 CMK (master key) 90 | 91 +-----------------------------------+-----------------------------------+ 92 | | | 93 +-------+----------------+ +-------+----------------+ ... 94 | EK_1 | EK_1_encrypted | | EK_2 | EK_2_encrypted | 95 +---+----------+---------+ +---+----------+---------+ 96 | | | | 97 | | | | 98 +---+---+ | +---+---+ | 99 | KEK_1 | | | KEK_2 | | 100 +---+---+ | +---+---+ | 101 | | | | 102 | | | | 103 +---+---+ | +---+---+ | 104 | OEK_1 | | | OEK_2 | | 105 +---+---+ | +---+---+ | 106 | | 107 | | 108 | | 109 +---------+---------+ +---------+---------+ 110 | object_metadata_1 | | object_metadata_2 | 111 +-------------------+ +-------------------+ 112 ``` 113 <center>Figure 2 - KMS key hierarchy</center> 114 115 116 #### Key rotation - Basic Operation 117 118 The MinIO server supports key rotation for SSE-S3 encrypted objects. The minio server decrypts the OEK using the current encrypted data key and the master key ID of the object metadata. If this succeeds, the server requests a new data key from the KMS using the master key ID of the **current MinIO KMS configuration** and re-wraps the *OEK* with a new *KEK* derived from the new data key / EK: 119 120 ``` 121 object metadata KMS 122 | | 123 | +----------------+ 1a | +-------+ 124 |-------------------->| EK_1_encrypted |-----------|->| CMK_1 | 125 | +----------------+ | +---+---+ 126 | | | 127 | +---------------+ +------+ 1b | | 128 |------------->| OEK_encrypted | | EK_1 |<---|------+ 129 | +-------+-------+ +------+ | 130 | \ / | 131 | \___ 2 ___/ | 132 | \___/ | 133 | | | 134 | +--+--+ | 135 | | OEK | | +-------+ 136 | +--+--+ | | CMK_2 | 137 | | | +---+---+ 138 | | | | 139 | 5 +----------------+ |4 +------+ 3a | | 140 |<------| OEK_encrypted' |<----+-------| EK_2 |<---|------+ 141 | +----------------+ +------+ | | 142 | +----------------+ 3b | | 143 |<-------------------| EK_2_encrypted |<-----------|------+ 144 | +----------------+ | 145 | | 146 147 148 1a) Send encrypted data key and master key ID to KMS. 149 1b) Receive decrypted data key. 150 2) Decrypt encrypted object key with the KEK derived from the data key. 151 3a) Receive new plain data key from the KMS using the master key ID of the server config. 152 3b) Receive encrypted form of the data key from the KMS. 153 4) Derive a new KEK from the new data key and re-encrypt the OEK with it. 154 5) Store the encrypted OEK encrypted data key and master key ID in object metadata. 155 ``` 156 <center>Figure 3 - KMS data key rotation</center> 157 158 Only the root/admin user can perform an SSE-S3 key rotation using the Admin-API via [mc](https://github.com/minio/mc). For more details about how to perform key management operations using the CLI refer to [mc admin guide](https://github.com/minio/mc/blob/master/docs/minio-admin-complete-guide.md) or run `mc admin kms key`. 159 160 #### Secure Erasure and Locking 161 162 The MinIO server requires an available KMS to en/decrypt SSE-S3 encrypted objects. Therefore it is possible to erase or lock some or all encrypted objects. For example in case of a detected attack or other emergency situations the following actions can be taken: 163 164 - Seal the KMS such that it cannot be accessed by MinIO server anymore. That will lock **all** SSE-S3 encrypted objects protected by master keys stored on the KMS. All these objects can not be decrypted as long as the KMS is sealed. 165 - Seal/Unmount one/some master keys. That will lock all SSE-S3 encrypted objects protected by these master keys. All these objects can not be decrypted as long as the key(s) are sealed. 166 - Delete one/some master keys. From a security standpoint, this is equal to erasing all SSE-S3 encrypted objects protected by these master keys. All these objects are lost forever as they cannot be decrypted. Especially deleting all master keys at the KMS is equivalent to secure erasing all SSE-S3 encrypted objects. 167 168 ## Acronyms 169 170 - <a name="aead"></a>**AEAD**: Authenticated Encryption with Associated Data 171 - <a name="csprng"></a>**CSPRNG**: Cryptographically Secure Pseudo Random Number Generator 172 - <a name="ek"></a>**EK**: External Key 173 - <a name="iv"></a>**IV**: Initialization Vector 174 - <a name="kek"></a>**KEK**: Key Encryption Key 175 - <a name="oek"></a>**OEK**: Object Encryption Key 176 - <a name="prf"></a>**PRF**: Pseudo Random Function 177 - <a name="sse"></a>**SSE**: Server-Side Encryption 178 - <a name="ssec"></a>**SSE-C**: Server-Side Encryption with client-provided Keys 179 - <a name="sses3"></a>**SSE-S3**: Server-Side Encryption with a KMS