[refactor] simplify en/decrypted size computation (#5658)

This commit replaces the en/decrypted size computation
with functions from the `sio` package.

Fixes #5657

cmd/encryption-v1.go

@@ -623,9 +623,9 @@ func DecryptBlocksRequest(client io.Writer, r *http.Request, startOffset, length
 	var partStartOffset = startOffset
 	// Skip parts until final offset maps to a particular part offset.
 	for i, part := range objInfo.Parts {
-		decryptedSize, err := decryptedSize(part.Size)
+		decryptedSize, err := sio.DecryptedSize(uint64(part.Size))
 		if err != nil {
-			return nil, -1, -1, err
+			return nil, -1, -1, errObjectTampered
 		}
 
 		partStartIndex = i
@@ -633,12 +633,12 @@ func DecryptBlocksRequest(client io.Writer, r *http.Request, startOffset, length
 		// Offset is smaller than size we have reached the
 		// proper part offset, break out we start from
 		// this part index.
-		if partStartOffset < decryptedSize {
+		if partStartOffset < int64(decryptedSize) {
 			break
 		}
 
 		// Continue to look for next part.
-		partStartOffset -= decryptedSize
+		partStartOffset -= int64(decryptedSize)
 	}
 
 	startSeqNum := partStartOffset / sseDAREPackageBlockSize
@@ -734,20 +734,6 @@ func (li *ListPartsInfo) IsEncrypted() bool {
 	return false
 }
 
-func decryptedSize(encryptedSize int64) (int64, error) {
-	if encryptedSize == 0 {
-		return encryptedSize, nil
-	}
-	size := (encryptedSize / (sseDAREPackageBlockSize + sseDAREPackageMetaSize)) * sseDAREPackageBlockSize
-	if mod := encryptedSize % (sseDAREPackageBlockSize + sseDAREPackageMetaSize); mod > 0 {
-		if mod < sseDAREPackageMetaSize+1 {
-			return -1, errObjectTampered // object is not 0 size but smaller than the smallest valid encrypted object
-		}
-		size += mod - sseDAREPackageMetaSize
-	}
-	return size, nil
-}
-
 // DecryptedSize returns the size of the object after decryption in bytes.
 // It returns an error if the object is not encrypted or marked as encrypted
 // but has an invalid size.
@@ -756,19 +742,22 @@ func (o *ObjectInfo) DecryptedSize() (int64, error) {
 	if !o.IsEncrypted() {
 		panic("cannot compute decrypted size of an object which is not encrypted")
 	}
-
-	return decryptedSize(o.Size)
+	size, err := sio.DecryptedSize(uint64(o.Size))
+	if err != nil {
+		err = errObjectTampered // assign correct error type
+	}
+	return int64(size), err
 }
 
 // EncryptedSize returns the size of the object after encryption.
 // An encrypted object is always larger than a plain object
 // except for zero size objects.
 func (o *ObjectInfo) EncryptedSize() int64 {
-	size := (o.Size / sseDAREPackageBlockSize) * (sseDAREPackageBlockSize + sseDAREPackageMetaSize)
-	if mod := o.Size % (sseDAREPackageBlockSize); mod > 0 {
-		size += mod + sseDAREPackageMetaSize
+	size, err := sio.EncryptedSize(uint64(o.Size))
+	if err != nil {
+		panic(err) // Since AWS S3 allows parts to be 5GB at most this cannot happen - sio max. size is 256 TB
 	}
-	return size
+	return int64(size)
 }
 
 // DecryptCopyObjectInfo tries to decrypt the provided object if it is encrypted.

cmd/encryption-v1_test.go

@@ -275,59 +275,6 @@ func TestParseSSECopyCustomerRequest(t *testing.T) {
 	}
 }
 
-var encryptedSizeTests = []struct {
-	size, encsize int64
-}{
-	{size: 0, encsize: 0},                                                                   // 0
-	{size: 1, encsize: 33},                                                                  // 1
-	{size: 1024, encsize: 1024 + 32},                                                        // 2
-	{size: 2 * sseDAREPackageBlockSize, encsize: 2 * (sseDAREPackageBlockSize + 32)},        // 3
-	{size: 100*sseDAREPackageBlockSize + 1, encsize: 100*(sseDAREPackageBlockSize+32) + 33}, // 4
-	{size: sseDAREPackageBlockSize + 1, encsize: (sseDAREPackageBlockSize + 32) + 33},       // 5
-	{size: 5 * 1024 * 1024 * 1024, encsize: 81920 * (sseDAREPackageBlockSize + 32)},         // 6
-}
-
-func TestEncryptedSize(t *testing.T) {
-	for i, test := range encryptedSizeTests {
-		objInfo := ObjectInfo{Size: test.size}
-		if size := objInfo.EncryptedSize(); test.encsize != size {
-			t.Errorf("Test %d: got encrypted size: #%d want: #%d", i, size, test.encsize)
-		}
-	}
-}
-
-var decryptSSECustomerObjectInfoTests = []struct {
-	encsize, size int64
-	err           error
-}{
-	{encsize: 0, size: 0, err: nil},                                                                   // 0
-	{encsize: 33, size: 1, err: nil},                                                                  // 1
-	{encsize: 1024 + 32, size: 1024, err: nil},                                                        // 2
-	{encsize: 2 * (sseDAREPackageBlockSize + 32), size: 2 * sseDAREPackageBlockSize, err: nil},        // 3
-	{encsize: 100*(sseDAREPackageBlockSize+32) + 33, size: 100*sseDAREPackageBlockSize + 1, err: nil}, // 4
-	{encsize: (sseDAREPackageBlockSize + 32) + 33, size: sseDAREPackageBlockSize + 1, err: nil},       // 5
-	{encsize: 81920 * (sseDAREPackageBlockSize + 32), size: 5 * 1024 * 1024 * 1024, err: nil},         // 6
-	{encsize: 0, size: 0, err: nil},                                                                   // 7
-	{encsize: sseDAREPackageBlockSize + 32 + 31, size: 0, err: errObjectTampered},                     // 8
-}
-
-func TestDecryptedSize(t *testing.T) {
-	for i, test := range decryptSSECustomerObjectInfoTests {
-		objInfo := ObjectInfo{Size: test.encsize}
-		objInfo.UserDefined = map[string]string{
-			ServerSideEncryptionSealAlgorithm: SSESealAlgorithmDareSha256,
-		}
-
-		size, err := objInfo.DecryptedSize()
-		if err != test.err || (size != test.size && err == nil) {
-			t.Errorf("Test %d: decryption returned: %v want: %v", i, err, test.err)
-		}
-		if err == nil && size != test.size {
-			t.Errorf("Test %d: got decrypted size: #%d want: #%d", i, size, test.size)
-		}
-	}
-}
-
 var encryptRequestTests = []struct {
 	header   map[string]string
 	metadata map[string]string