Skip to content

Commit a766876

Browse files
qingyang-huqingyang-hu
authored
GODRIVER-3123 QE Range Protocol V2 (#1723)
1 parent 758291c commit a766876

File tree

105 files changed

+2009
-1417
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

105 files changed

+2009
-1417
lines changed

‎etc/install-libmongocrypt.sh

+4-4
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
# This script installs libmongocrypt into an "install" directory.
44
set -eux
55

6-
LIBMONGOCRYPT_TAG="1.8.2"
6+
LIBMONGOCRYPT_TAG="1.11.0"
77

88
# Install libmongocrypt based on OS.
99
if [ "Windows_NT" = "${OS:-}" ]; then
@@ -13,11 +13,11 @@ if [ "Windows_NT" = "${OS:-}" ]; then
1313
mkdir libmongocrypt-all
1414
cd libmongocrypt-all
1515
# The following URL is published from the upload-all task in the libmongocrypt Evergreen project.
16-
curl https://mciuploads.s3.amazonaws.com/libmongocrypt/all/$LIBMONGOCRYPT_TAG/libmongocrypt-all.tar.gz -o libmongocrypt-all.tar.gz
16+
curl -L https://github.com/mongodb/libmongocrypt/releases/download/$LIBMONGOCRYPT_TAG/libmongocrypt-windows-x86_64-$LIBMONGOCRYPT_TAG.tar.gz -o libmongocrypt-all.tar.gz
1717
tar -xf libmongocrypt-all.tar.gz
1818
cd ..
19-
cp libmongocrypt-all/windows-test/bin/mongocrypt.dll c:/libmongocrypt/bin
20-
cp libmongocrypt-all/windows-test/include/mongocrypt/*.h c:/libmongocrypt/include
19+
cp libmongocrypt-all/bin/mongocrypt.dll c:/libmongocrypt/bin
20+
cp libmongocrypt-all/include/mongocrypt/*.h c:/libmongocrypt/include
2121

2222
rm -rf libmongocrypt-all
2323
echo "fetching build for Windows ... end"

‎mongo/client_encryption.go

+7-3
Original file line numberDiff line numberDiff line change
@@ -204,7 +204,12 @@ func transformExplicitEncryptionOptions(opts ...*options.EncryptOptions) *mcopts
204204
if eo.RangeOptions.Precision != nil {
205205
transformedRange.Precision = eo.RangeOptions.Precision
206206
}
207-
transformedRange.Sparsity = eo.RangeOptions.Sparsity
207+
if eo.RangeOptions.Sparsity != nil {
208+
transformedRange.Sparsity = eo.RangeOptions.Sparsity
209+
}
210+
if eo.RangeOptions.TrimFactor != nil {
211+
transformedRange.TrimFactor = eo.RangeOptions.TrimFactor
212+
}
208213
transformed.SetRangeOptions(transformedRange)
209214
}
210215
return transformed
@@ -230,8 +235,7 @@ func (ce *ClientEncryption) Encrypt(ctx context.Context, val bson.RawValue,
230235
// 2. An Aggregate Expression of this form:
231236
// {$and: [{$gt: [<fieldpath>, <value1>]}, {$lt: [<fieldpath>, <value2>]}]
232237
// $gt may also be $gte. $lt may also be $lte.
233-
// Only supported for queryType "rangePreview"
234-
// Beta: The Range algorithm is experimental only. It is not intended for public use. It is subject to breaking changes.
238+
// Only supported for queryType "range"
235239
func (ce *ClientEncryption) EncryptExpression(ctx context.Context, expr interface{}, result interface{}, opts ...*options.EncryptOptions) error {
236240
transformed := transformExplicitEncryptionOptions(opts...)
237241

‎mongo/integration/client_side_encryption_prose_test.go

+107-34
Original file line numberDiff line numberDiff line change
@@ -2465,8 +2465,7 @@ func TestClientSideEncryptionProse(t *testing.T) {
24652465
}
24662466
})
24672467

2468-
// GODRIVER-3123. When we implement this feature, lower the min server version to 8.0.1
2469-
qeRunOpts22 := qeRunOpts.MaxServerVersion("7.99.99")
2468+
qeRunOpts22 := qeRunOpts.MinServerVersion("8.0")
24702469
mt.RunOpts("22. range explicit encryption", qeRunOpts22, func(mt *mtest.T) {
24712470
type testcase struct {
24722471
typeStr string
@@ -2480,6 +2479,8 @@ func TestClientSideEncryptionProse(t *testing.T) {
24802479
twoHundredOne bson.RawValue
24812480
}
24822481

2482+
trimFactor := int32(1)
2483+
sparsity := int64(1)
24832484
precision := int32(2)
24842485

24852486
d128_0, err := primitive.ParseDecimal128("0")
@@ -2499,7 +2500,8 @@ func TestClientSideEncryptionProse(t *testing.T) {
24992500
field: "encryptedDecimalNoPrecision",
25002501
typeBson: bson.TypeDecimal128,
25012502
rangeOpts: options.RangeOptions{
2502-
Sparsity: 1,
2503+
TrimFactor: &trimFactor,
2504+
Sparsity: &sparsity,
25032505
},
25042506
zero: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_0)},
25052507
six: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_6)},
@@ -2512,10 +2514,11 @@ func TestClientSideEncryptionProse(t *testing.T) {
25122514
field: "encryptedDecimalPrecision",
25132515
typeBson: bson.TypeDecimal128,
25142516
rangeOpts: options.RangeOptions{
2515-
Min: &bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_0)},
2516-
Max: &bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_200)},
2517-
Sparsity: 1,
2518-
Precision: &precision,
2517+
Min: &bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_0)},
2518+
Max: &bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_200)},
2519+
TrimFactor: &trimFactor,
2520+
Sparsity: &sparsity,
2521+
Precision: &precision,
25192522
},
25202523
zero: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_0)},
25212524
six: bson.RawValue{Type: bson.TypeDecimal128, Value: bsoncore.AppendDecimal128(nil, d128_6)},
@@ -2528,7 +2531,8 @@ func TestClientSideEncryptionProse(t *testing.T) {
25282531
field: "encryptedDoubleNoPrecision",
25292532
typeBson: bson.TypeDouble,
25302533
rangeOpts: options.RangeOptions{
2531-
Sparsity: 1,
2534+
TrimFactor: &trimFactor,
2535+
Sparsity: &sparsity,
25322536
},
25332537
zero: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 0)},
25342538
six: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 6)},
@@ -2541,10 +2545,11 @@ func TestClientSideEncryptionProse(t *testing.T) {
25412545
field: "encryptedDoublePrecision",
25422546
typeBson: bson.TypeDouble,
25432547
rangeOpts: options.RangeOptions{
2544-
Min: &bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 0)},
2545-
Max: &bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 200)},
2546-
Sparsity: 1,
2547-
Precision: &precision,
2548+
Min: &bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 0)},
2549+
Max: &bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 200)},
2550+
TrimFactor: &trimFactor,
2551+
Sparsity: &sparsity,
2552+
Precision: &precision,
25482553
},
25492554
zero: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 0)},
25502555
six: bson.RawValue{Type: bson.TypeDouble, Value: bsoncore.AppendDouble(nil, 6)},
@@ -2557,9 +2562,10 @@ func TestClientSideEncryptionProse(t *testing.T) {
25572562
field: "encryptedDate",
25582563
typeBson: bson.TypeDateTime,
25592564
rangeOpts: options.RangeOptions{
2560-
Min: &bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 0)},
2561-
Max: &bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 200)},
2562-
Sparsity: 1,
2565+
Min: &bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 0)},
2566+
Max: &bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 200)},
2567+
TrimFactor: &trimFactor,
2568+
Sparsity: &sparsity,
25632569
},
25642570
zero: bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 0)},
25652571
six: bson.RawValue{Type: bson.TypeDateTime, Value: bsoncore.AppendDateTime(nil, 6)},
@@ -2572,9 +2578,10 @@ func TestClientSideEncryptionProse(t *testing.T) {
25722578
field: "encryptedInt",
25732579
typeBson: bson.TypeInt32,
25742580
rangeOpts: options.RangeOptions{
2575-
Min: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 0)},
2576-
Max: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 200)},
2577-
Sparsity: 1,
2581+
Min: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 0)},
2582+
Max: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 200)},
2583+
TrimFactor: &trimFactor,
2584+
Sparsity: &sparsity,
25782585
},
25792586
zero: bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 0)},
25802587
six: bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 6)},
@@ -2587,9 +2594,10 @@ func TestClientSideEncryptionProse(t *testing.T) {
25872594
field: "encryptedLong",
25882595
typeBson: bson.TypeInt64,
25892596
rangeOpts: options.RangeOptions{
2590-
Min: &bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 0)},
2591-
Max: &bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 200)},
2592-
Sparsity: 1,
2597+
Min: &bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 0)},
2598+
Max: &bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 200)},
2599+
TrimFactor: &trimFactor,
2600+
Sparsity: &sparsity,
25932601
},
25942602
zero: bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 0)},
25952603
six: bson.RawValue{Type: bson.TypeInt64, Value: bsoncore.AppendInt64(nil, 6)},
@@ -2645,7 +2653,7 @@ func TestClientSideEncryptionProse(t *testing.T) {
26452653
// Insert 0, 6, 30, and 200.
26462654
coll := encryptedClient.Database("db").Collection("explicit_encryption")
26472655
eo := options.Encrypt().
2648-
SetAlgorithm("RangePreview").
2656+
SetAlgorithm("Range").
26492657
SetKeyID(key1ID).
26502658
SetContentionFactor(0).
26512659
SetRangeOptions(test.rangeOpts)
@@ -2692,7 +2700,7 @@ func TestClientSideEncryptionProse(t *testing.T) {
26922700
defer clientEncryption.Close(context.Background())
26932701
defer encryptedClient.Disconnect(context.Background())
26942702
eo := options.Encrypt().
2695-
SetAlgorithm("RangePreview").
2703+
SetAlgorithm("Range").
26962704
SetKeyID(key1ID).
26972705
SetContentionFactor(0).
26982706
SetRangeOptions(test.rangeOpts)
@@ -2708,10 +2716,10 @@ func TestClientSideEncryptionProse(t *testing.T) {
27082716
defer clientEncryption.Close(context.Background())
27092717
defer encryptedClient.Disconnect(context.Background())
27102718
eo := options.Encrypt().
2711-
SetAlgorithm("RangePreview").
2719+
SetAlgorithm("Range").
27122720
SetKeyID(key1ID).
27132721
SetContentionFactor(0).
2714-
SetQueryType("rangePreview").
2722+
SetQueryType("range").
27152723
SetRangeOptions(test.rangeOpts)
27162724

27172725
expr := bson.M{
@@ -2750,10 +2758,10 @@ func TestClientSideEncryptionProse(t *testing.T) {
27502758
defer clientEncryption.Close(context.Background())
27512759
defer encryptedClient.Disconnect(context.Background())
27522760
eo := options.Encrypt().
2753-
SetAlgorithm("RangePreview").
2761+
SetAlgorithm("Range").
27542762
SetKeyID(key1ID).
27552763
SetContentionFactor(0).
2756-
SetQueryType("rangePreview").
2764+
SetQueryType("range").
27572765
SetRangeOptions(test.rangeOpts)
27582766

27592767
expr := bson.M{
@@ -2792,10 +2800,10 @@ func TestClientSideEncryptionProse(t *testing.T) {
27922800
defer clientEncryption.Close(context.Background())
27932801
defer encryptedClient.Disconnect(context.Background())
27942802
eo := options.Encrypt().
2795-
SetAlgorithm("RangePreview").
2803+
SetAlgorithm("Range").
27962804
SetKeyID(key1ID).
27972805
SetContentionFactor(0).
2798-
SetQueryType("rangePreview").
2806+
SetQueryType("range").
27992807
SetRangeOptions(test.rangeOpts)
28002808

28012809
expr := bson.M{
@@ -2829,10 +2837,10 @@ func TestClientSideEncryptionProse(t *testing.T) {
28292837
defer clientEncryption.Close(context.Background())
28302838
defer encryptedClient.Disconnect(context.Background())
28312839
eo := options.Encrypt().
2832-
SetAlgorithm("RangePreview").
2840+
SetAlgorithm("Range").
28332841
SetKeyID(key1ID).
28342842
SetContentionFactor(0).
2835-
SetQueryType("rangePreview").
2843+
SetQueryType("range").
28362844
SetRangeOptions(test.rangeOpts)
28372845

28382846
expr := bson.M{
@@ -2868,7 +2876,7 @@ func TestClientSideEncryptionProse(t *testing.T) {
28682876
defer clientEncryption.Close(context.Background())
28692877
defer encryptedClient.Disconnect(context.Background())
28702878
eo := options.Encrypt().
2871-
SetAlgorithm("RangePreview").
2879+
SetAlgorithm("Range").
28722880
SetKeyID(key1ID).
28732881
SetContentionFactor(0).
28742882
SetRangeOptions(test.rangeOpts)
@@ -2882,7 +2890,7 @@ func TestClientSideEncryptionProse(t *testing.T) {
28822890
defer clientEncryption.Close(context.Background())
28832891
defer encryptedClient.Disconnect(context.Background())
28842892
eo := options.Encrypt().
2885-
SetAlgorithm("RangePreview").
2893+
SetAlgorithm("Range").
28862894
SetKeyID(key1ID).
28872895
SetContentionFactor(0).
28882896
SetRangeOptions(test.rangeOpts)
@@ -2909,7 +2917,7 @@ func TestClientSideEncryptionProse(t *testing.T) {
29092917
ro := test.rangeOpts
29102918
ro.SetPrecision(2)
29112919
eo := options.Encrypt().
2912-
SetAlgorithm("RangePreview").
2920+
SetAlgorithm("Range").
29132921
SetKeyID(key1ID).
29142922
SetContentionFactor(0).
29152923
SetRangeOptions(ro)
@@ -2921,6 +2929,71 @@ func TestClientSideEncryptionProse(t *testing.T) {
29212929
})
29222930
}
29232931
})
2932+
2933+
mt.RunOpts("22. range explicit encryption applies defaults", qeRunOpts22, func(mt *mtest.T) {
2934+
err := mt.Client.Database("keyvault").Collection("datakeys").Drop(context.Background())
2935+
assert.Nil(mt, err, "error on Drop: %v", err)
2936+
2937+
testVal := bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 123)}
2938+
2939+
keyVaultClient, err := mongo.Connect(context.Background(), options.Client().ApplyURI(mtest.ClusterURI()))
2940+
assert.Nil(mt, err, "error on Connect: %v", err)
2941+
2942+
ceo := options.ClientEncryption().
2943+
SetKeyVaultNamespace("keyvault.datakeys").
2944+
SetKmsProviders(fullKmsProvidersMap)
2945+
clientEncryption, err := mongo.NewClientEncryption(keyVaultClient, ceo)
2946+
assert.Nil(mt, err, "error on NewClientEncryption: %v", err)
2947+
2948+
dkOpts := options.DataKey()
2949+
keyID, err := clientEncryption.CreateDataKey(context.Background(), "local", dkOpts)
2950+
assert.Nil(mt, err, "error in CreateDataKey: %v", err)
2951+
2952+
eo := options.Encrypt().
2953+
SetAlgorithm("Range").
2954+
SetKeyID(keyID).
2955+
SetContentionFactor(0).
2956+
SetRangeOptions(options.RangeOptions{
2957+
Min: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 0)},
2958+
Max: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 1000)},
2959+
})
2960+
payloadDefaults, err := clientEncryption.Encrypt(context.Background(), testVal, eo)
2961+
assert.Nil(mt, err, "error in Encrypt: %v", err)
2962+
2963+
mt.Run("Case 1: uses libmongocrypt defaults", func(mt *mtest.T) {
2964+
trimFactor := int32(6)
2965+
sparsity := int64(2)
2966+
eo := options.Encrypt().
2967+
SetAlgorithm("Range").
2968+
SetKeyID(keyID).
2969+
SetContentionFactor(0).
2970+
SetRangeOptions(options.RangeOptions{
2971+
Min: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 0)},
2972+
Max: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 1000)},
2973+
TrimFactor: &trimFactor,
2974+
Sparsity: &sparsity,
2975+
})
2976+
payload, err := clientEncryption.Encrypt(context.Background(), testVal, eo)
2977+
assert.Nil(mt, err, "error in Encrypt: %v", err)
2978+
assert.Equalf(mt, len(payload.Data), len(payloadDefaults.Data), "the returned payload size is expected to be %d", len(payloadDefaults.Data))
2979+
})
2980+
2981+
mt.Run("Case 2: accepts trimFactor 0", func(mt *mtest.T) {
2982+
trimFactor := int32(0)
2983+
eo := options.Encrypt().
2984+
SetAlgorithm("Range").
2985+
SetKeyID(keyID).
2986+
SetContentionFactor(0).
2987+
SetRangeOptions(options.RangeOptions{
2988+
Min: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 0)},
2989+
Max: &bson.RawValue{Type: bson.TypeInt32, Value: bsoncore.AppendInt32(nil, 1000)},
2990+
TrimFactor: &trimFactor,
2991+
})
2992+
payload, err := clientEncryption.Encrypt(context.Background(), testVal, eo)
2993+
assert.Nil(mt, err, "error in Encrypt: %v", err)
2994+
assert.Greater(t, len(payload.Data), len(payloadDefaults.Data), "the returned payload size is expected to be greater than %d", len(payloadDefaults.Data))
2995+
})
2996+
})
29242997
}
29252998

29262999
func getWatcher(mt *mtest.T, streamType mongo.StreamType, cpt *cseProseTest) watcher {

0 commit comments

Comments
 (0)