Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Reject malformed key encodings as bad requests

Neeraj Gupta7ef65c09c81b
diff --git a/server/ente/user_test.go b/server/ente/user_test.go
index 1e90ae1ce6..2fe3ddbea5 100644
--- a/server/ente/user_test.go
+++ b/server/ente/user_test.go
@@ -72,10 +72,10 @@ func TestKeyAttributeValidation(t *testing.T) {
t.Run(field.name+"/"+invalid.name, func(t *testing.T) {
request := valid
*field.value(&request.KeyAttributes) = invalid.value
- require.EqualError(t, request.Validate(), invalid.message)
+ assertBadRequestMessage(t, request.Validate(), invalid.message)
if field.update {
update := testUpdateKeysRequest(request.KeyAttributes)
- require.EqualError(t, update.Validate(), invalid.message)
+ assertBadRequestMessage(t, update.Validate(), invalid.message)
}
})
}
@@ -102,23 +102,30 @@ func TestRecoveryKeyValidation(t *testing.T) {
t.Run(field.name+"/"+invalid.name, func(t *testing.T) {
request := valid
*field.value(&request) = invalid.value
- require.EqualError(t, request.Validate(), invalid.message)
+ assertBadRequestMessage(t, request.Validate(), invalid.message)
setup := testSetAttributesRequest(request)
- require.EqualError(t, setup.Validate(), invalid.message)
+ assertBadRequestMessage(t, setup.Validate(), invalid.message)
})
}
}
}
func invalidBase64Values(size int) []struct{ name, value, message string } {
+ valid := base64.StdEncoding.EncodeToString(make([]byte, size))
values := []struct{ name, value, message string }{
- {"empty", "", "invalid decoded length"},
+ {"empty", "", "invalid length"},
{"invalid base64", strings.Repeat("!", base64.StdEncoding.EncodedLen(size)), "invalid base64"},
- {"short", base64.StdEncoding.EncodeToString(make([]byte, size-1)), "invalid decoded length"},
- {"long", base64.StdEncoding.EncodeToString(make([]byte, size+1)), "invalid decoded length"},
+ {"short", base64.StdEncoding.EncodeToString(make([]byte, size-1)), "invalid length"},
+ {"long", base64.StdEncoding.EncodeToString(make([]byte, size+1)), "invalid length"},
+ {"carriage return", valid[:4] + "\r" + valid[4:], "invalid length"},
+ {"newline", valid[:4] + "\n" + valid[4:], "invalid length"},
}
if size%3 != 0 {
- values = append(values, struct{ name, value, message string }{"missing padding", base64.RawStdEncoding.EncodeToString(make([]byte, size)), "invalid base64"})
+ lastSymbol := strings.IndexByte(valid, '=') - 1
+ values = append(values,
+ struct{ name, value, message string }{"missing padding", base64.RawStdEncoding.EncodeToString(make([]byte, size)), "invalid length"},
+ struct{ name, value, message string }{"padding bits", valid[:lastSymbol] + "B" + valid[lastSymbol+1:], "invalid base64"},
+ )
}
return values
}
@@ -174,8 +181,8 @@ func TestUpdateSRPAndKeysRequestValidation(t *testing.T) {
request.UpdateAttributes.OpsLimit = validArgonOpsLimit
require.NoError(t, request.Validate())
- request.UpdateAttributes.EncryptedKey = "invalid"
- require.EqualError(t, request.Validate(), "invalid base64")
+ request.UpdateAttributes.EncryptedKey = strings.Repeat("!", base64.StdEncoding.EncodedLen(48))
+ assertBadRequestMessage(t, request.Validate(), "invalid base64")
}
func assertBadRequestMessage(t *testing.T, err error, wantMessage string) {
diff --git a/server/ente/validation.go b/server/ente/validation.go
index 0b7f30ef25..247beca768 100644
--- a/server/ente/validation.go
+++ b/server/ente/validation.go
@@ -1,17 +1,17 @@
package ente
-import (
- "encoding/base64"
- "errors"
-)
+import "encoding/base64"
func ValidateBase64Length(value string, size int) error {
- decoded, err := base64.StdEncoding.DecodeString(value)
+ if len(value) != base64.StdEncoding.EncodedLen(size) {
+ return NewBadRequestWithMessage("invalid length")
+ }
+ decoded, err := base64.StdEncoding.Strict().DecodeString(value)
if err != nil {
- return errors.New("invalid base64")
+ return NewBadRequestWithMessage("invalid base64")
}
if len(decoded) != size {
- return errors.New("invalid decoded length")
+ return NewBadRequestWithMessage("invalid length")
}
return nil
}
diff --git a/server/pkg/api/collection_test.go b/server/pkg/api/collection_test.go
index c799e993cc..07944a3731 100644
--- a/server/pkg/api/collection_test.go
+++ b/server/pkg/api/collection_test.go
@@ -46,7 +46,10 @@ func TestCollectionHandlersRejectInvalidKeys(t *testing.T) {
request.Header.Set("X-Auth-User-ID", "1")
recorder := httptest.NewRecorder()
router.ServeHTTP(recorder, request)
- require.Equal(t, http.StatusInternalServerError, recorder.Code, recorder.Body.String())
+ require.Equal(t, http.StatusBadRequest, recorder.Code, recorder.Body.String())
+ var response ente.ApiError
+ require.NoError(t, json.Unmarshal(recorder.Body.Bytes(), &response))
+ require.Equal(t, ente.BadRequest, response.Code)
})
}
}
diff --git a/server/pkg/api/user_test.go b/server/pkg/api/user_test.go
index 797d5b1c64..80d4248a4a 100644
--- a/server/pkg/api/user_test.go
+++ b/server/pkg/api/user_test.go
@@ -18,16 +18,39 @@ import (
"github.com/stretchr/testify/require"
)
-func TestSetRecoveryKeyRejectsInvalidAttributes(t *testing.T) {
+func TestUserKeyHandlersRejectInvalidAttributes(t *testing.T) {
gin.SetMode(gin.TestMode)
- recorder := httptest.NewRecorder()
- ctx, _ := gin.CreateTestContext(recorder)
- ctx.Request = httptest.NewRequest(http.MethodPut, "/users/recovery-key", strings.NewReader(`{}`))
- ctx.Request.Header.Set("Content-Type", "application/json")
-
- (&UserHandler{}).SetRecoveryKey(ctx)
-
- require.Equal(t, http.StatusInternalServerError, recorder.Code)
+ handler := &UserHandler{UserController: &usercontroller.UserController{}}
+ for _, test := range []struct {
+ name string
+ body string
+ handle gin.HandlerFunc
+ }{
+ {"recovery key", `{}`, handler.SetRecoveryKey},
+ {"password keys", `{
+ "setupID":"00000000-0000-0000-0000-000000000001",
+ "srpM1":"proof",
+ "updatedKeyAttr":{
+ "kekSalt":"AAAAAAAAAAAAAAAAAAAAAA==",
+ "encryptedKey":"invalid",
+ "keyDecryptionNonce":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+ "memLimit":134217728,"opsLimit":32
+ }
+ }`, handler.UpdateSrpAndKeyAttributes},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ recorder := httptest.NewRecorder()
+ ctx, _ := gin.CreateTestContext(recorder)
+ ctx.Request = httptest.NewRequest(http.MethodPut, "/", strings.NewReader(test.body))
+ ctx.Request.Header.Set("Content-Type", "application/json")
+ test.handle(ctx)
+ require.Equal(t, http.StatusBadRequest, recorder.Code)
+ var response ente.ApiError
+ require.NoError(t, json.Unmarshal(recorder.Body.Bytes(), &response))
+ require.Equal(t, ente.BadRequest, response.Code)
+ require.Equal(t, "invalid length", response.Message)
+ })
+ }
}
func TestGetPublicKeyHandlerUsesEmailLookup(t *testing.T) {
diff --git a/server/pkg/controller/collections/key_validation.go b/server/pkg/controller/collections/key_validation.go
index a108068422..fca0a8860c 100644
--- a/server/pkg/controller/collections/key_validation.go
+++ b/server/pkg/controller/collections/key_validation.go
@@ -1,11 +1,6 @@
package collections
-import (
- "encoding/base64"
- "errors"
-
- "github.com/ente/museum/ente"
-)
+import "github.com/ente/museum/ente"
const (
collectionKeyBytes = 32
@@ -17,14 +12,14 @@ const (
)
func validateOwnedCollectionKey(encryptedKey string, keyDecryptionNonce string) error {
- if err := validateBase64DecodedLength(encryptedKey, encryptedCollectionKeyLen); err != nil {
+ if err := ente.ValidateBase64Length(encryptedKey, encryptedCollectionKeyLen); err != nil {
return err
}
- return validateBase64DecodedLength(keyDecryptionNonce, secretboxNonceBytes)
+ return ente.ValidateBase64Length(keyDecryptionNonce, secretboxNonceBytes)
}
func validateSealedCollectionKey(encryptedKey string) error {
- return validateBase64DecodedLength(encryptedKey, sealedCollectionKeyLen)
+ return ente.ValidateBase64Length(encryptedKey, sealedCollectionKeyLen)
}
func validateCollectionFileItems(files []ente.CollectionFileItem) error {
@@ -33,15 +28,8 @@ func validateCollectionFileItems(files []ente.CollectionFileItem) error {
return ente.NewBadRequestWithMessage("file ID is required")
}
if err := validateOwnedCollectionKey(file.EncryptedKey, file.KeyDecryptionNonce); err != nil {
- return ente.NewBadRequestWithMessage(err.Error())
+ return err
}
}
return nil
}
-
-func validateBase64DecodedLength(value string, expected int) error {
- if len(value) != base64.StdEncoding.EncodedLen(expected) {
- return errors.New("invalid encoded length")
- }
- return ente.ValidateBase64Length(value, expected)
-}
diff --git a/server/pkg/controller/collections/share.go b/server/pkg/controller/collections/share.go
index 9b9f1e5e80..1a4c669b99 100644
--- a/server/pkg/controller/collections/share.go
+++ b/server/pkg/controller/collections/share.go
@@ -81,7 +81,7 @@ func (c *CollectionController) BatchShare(ctx *gin.Context, shares []ente.AlterS
resolvedShares := make([]repo.CollectionShareItem, 0, len(shares))
for _, share := range shares {
if err := validateSealedCollectionKey(share.EncryptedKey); err != nil {
- return nil, ente.NewBadRequestWithMessage(err.Error())
+ return nil, err
}
role := ente.VIEWER
if share.Role != nil {