Make SDK V4 preview version trimmable (#69)

normj · web-flow · commit 0eaed65584bc · 2024-10-24T13:35:10.000-07:00
diff --git a/.autover/changes/A37D7270-9F43-4933-9FAC-BFBBBC4670CB.json b/.autover/changes/A37D7270-9F43-4933-9FAC-BFBBBC4670CB.json
@@ -0,0 +1,12 @@
+{
+	"Projects": [
+    {
+      "Name": "Amazon.Extensions.S3.Encryption",
+      "Type": "Patch",
+      "ChangelogMessages": [
+        "Mark the assembly trimmable",
+        "Enable Source Link"
+      ]
+    }
+  ]	
+}
diff --git a/src/Amazon.Extensions.S3.Encryption.csproj b/src/Amazon.Extensions.S3.Encryption.csproj
@@ -19,8 +19,17 @@
         <AssemblyOriginatorKeyFile>..\public.snk</AssemblyOriginatorKeyFile>
         <PackageReadmeFile>README.md</PackageReadmeFile>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+
+        <EmbedUntrackedSources>true</EmbedUntrackedSources>
+        <PublishRepositoryUrl>true</PublishRepositoryUrl>
+        <IncludeSymbols>true</IncludeSymbols>
+        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    </PropertyGroup>
+
+    <PropertyGroup Condition="'$(TargetFramework)' == 'net8.0'">
+        <IsTrimmable>true</IsTrimmable>
     </PropertyGroup>
-    
+
     <PropertyGroup Condition="'$(TargetFramework)' == 'net472'">
         <AssemblyVersion>3.0.0</AssemblyVersion>
     </PropertyGroup>
@@ -36,6 +45,7 @@
         <PackageReference Include="AWSSDK.S3" Version="4.0.0-preview.4" />
         <PackageReference Include="AWSSDK.KeyManagementService" Version="4.0.0-preview.4" />
         <PackageReference Include="BouncyCastle.Cryptography" Version="2.4.0" />
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
     </ItemGroup>
 
     <!-- TODO: The dependency on Microsoft.Bcl.AsyncInterfaces should be removed once the issue causing it to be needed in the .NET SDK is fixed  -->
diff --git a/src/EncryptionUtils.cs b/src/EncryptionUtils.cs
@@ -19,11 +19,9 @@
 using Amazon.S3.Model;
 using Amazon.Runtime.Internal.Util;
 using Amazon.Runtime;
-using ThirdParty.Json.LitJson;
 using System.Collections.Generic;
 using System.Globalization;
 using Amazon.KeyManagementService;
-using Amazon.Runtime.SharedInterfaces;
 using Amazon.Extensions.S3.Encryption.Util;
 using Amazon.KeyManagementService.Model;
 
@@ -459,13 +457,13 @@ internal static EncryptionInstructions BuildInstructionsUsingInstructionFile(Get
         {
             using (TextReader textReader = new StreamReader(response.ResponseStream))
             {
-                JsonData jsonData = JsonMapper.ToObject(textReader);
+                var keyValuePairs = JsonUtils.ToDictionary(textReader.ReadToEnd());
 
-                var base64EncodedEncryptedEnvelopeKey = jsonData["EncryptedEnvelopeKey"];
+                var base64EncodedEncryptedEnvelopeKey = keyValuePairs["EncryptedEnvelopeKey"];
                 byte[] encryptedEnvelopeKey = Convert.FromBase64String((string)base64EncodedEncryptedEnvelopeKey);
                 byte[] decryptedEnvelopeKey = decryptNonKmsEnvelopeKey(encryptedEnvelopeKey, materials);
 
-                var base64EncodedIV = jsonData["IV"];
+                var base64EncodedIV = keyValuePairs["IV"];
                 byte[] IV = Convert.FromBase64String((string)base64EncodedIV);
 
                 return new EncryptionInstructions(materials.MaterialsDescription, decryptedEnvelopeKey, IV);
@@ -532,7 +530,7 @@ internal static void UpdateMetadataWithEncryptionInstructions(AmazonWebServiceRe
                 }
 
                 metadata.Add(XAmzIV, base64EncodedIV);
-                metadata.Add(XAmzMatDesc, JsonMapper.ToJson(instructions.MaterialsDescription));
+                metadata.Add(XAmzMatDesc, JsonUtils.ToJson(instructions.MaterialsDescription));
             }
         }
 
@@ -544,11 +542,13 @@ internal static PutObjectRequest CreateInstructionFileRequest(AmazonWebServiceRe
             byte[] IVToStoreInInstructionFile = instructions.InitializationVector;
             string base64EncodedIV = Convert.ToBase64String(IVToStoreInInstructionFile);
 
-            JsonData jsonData = new JsonData();
-            jsonData["EncryptedEnvelopeKey"] = base64EncodedEnvelopeKey;
-            jsonData["IV"] = base64EncodedIV;
+            var keyValuePairs = new Dictionary<string, string>
+            {
+                {"EncryptedEnvelopeKey", base64EncodedEnvelopeKey },
+                {"IV", base64EncodedIV }
+            };
 
-            var contentBody = jsonData.ToJson();
+            var contentBody = JsonUtils.ToJson(keyValuePairs);
 
             var putObjectRequest = request as PutObjectRequest;
             if (putObjectRequest != null)
diff --git a/src/EncryptionUtilsV2.cs b/src/EncryptionUtilsV2.cs
@@ -25,7 +25,6 @@
 using Amazon.KeyManagementService.Model;
 using Amazon.Runtime;
 using Amazon.S3.Model;
-using ThirdParty.Json.LitJson;
 
 namespace Amazon.Extensions.S3.Encryption
 {
@@ -276,7 +275,7 @@ internal static void UpdateMetadataWithEncryptionInstructionsV2(AmazonWebService
                 metadata.Add(XAmzKeyV2, base64EncodedEnvelopeKey);
                 metadata.Add(XAmzCekAlg, instructions.CekAlgorithm);
                 metadata.Add(XAmzIV, base64EncodedIv);
-                metadata.Add(XAmzMatDesc, JsonMapper.ToJson(instructions.MaterialsDescription));
+                metadata.Add(XAmzMatDesc, JsonUtils.ToJson(instructions.MaterialsDescription));
             }
         }
 
@@ -288,17 +287,17 @@ internal static PutObjectRequest CreateInstructionFileRequestV2(AmazonWebService
             var ivToStoreInInstructionFile = instructions.InitializationVector;
             var base64EncodedIv = Convert.ToBase64String(ivToStoreInInstructionFile);
 
-            var jsonData = new JsonData
+            var keyValuePairs = new Dictionary<string, string>()
             {
-                [XAmzTagLen] = DefaultTagBitsLength.ToString(),
-                [XAmzKeyV2] = base64EncodedEnvelopeKey,
-                [XAmzCekAlg] = instructions.CekAlgorithm,
-                [XAmzWrapAlg] = instructions.WrapAlgorithm,
-                [XAmzIV] = base64EncodedIv,
-                [XAmzMatDesc] = JsonMapper.ToJson(instructions.MaterialsDescription)
+                {XAmzTagLen,  DefaultTagBitsLength.ToString()},
+                {XAmzKeyV2,  base64EncodedEnvelopeKey},
+                {XAmzCekAlg,  instructions.CekAlgorithm},
+                {XAmzWrapAlg,  instructions.WrapAlgorithm},
+                {XAmzIV,  base64EncodedIv},
+                {XAmzMatDesc,  JsonUtils.ToJson(instructions.MaterialsDescription)},
             };
 
-            var contentBody = jsonData.ToJson();
+            var contentBody = JsonUtils.ToJson(keyValuePairs);
 
             var putObjectRequest = request as PutObjectRequest;
             if (putObjectRequest != null)
@@ -451,7 +450,7 @@ internal static Dictionary<string, string> GetMaterialDescriptionFromMetaData(Me
                 return new Dictionary<string, string>();
             }
 
-            var materialDescription = JsonMapper.ToObject<Dictionary<string, string>>(materialDescriptionJsonString);
+            var materialDescription = JsonUtils.ToDictionary(materialDescriptionJsonString);
             return materialDescription;
         }
 
@@ -492,45 +491,45 @@ internal static EncryptionInstructions BuildInstructionsUsingInstructionFileV2(G
         {
             using (TextReader textReader = new StreamReader(response.ResponseStream))
             {
-                var jsonData = JsonMapper.ToObject(textReader);
+                var keyValuePair = JsonUtils.ToDictionary(textReader.ReadToEnd());
 
-                if (jsonData[XAmzKeyV2] != null)
+                if (keyValuePair.ContainsKey(XAmzKeyV2))
                 {
                     // The envelope contains data in V2 format
-                    var encryptedEnvelopeKey = Base64DecodedDataValue(jsonData, XAmzKeyV2);
+                    var encryptedEnvelopeKey = Base64DecodedDataValue(keyValuePair, XAmzKeyV2);
                     var decryptedEnvelopeKey = DecryptNonKmsEnvelopeKeyV2(encryptedEnvelopeKey, materials);
 
-                    var initializationVector = Base64DecodedDataValue(jsonData, XAmzIV);
-                    var materialDescription = JsonMapper.ToObject<Dictionary<string, string>>((string)jsonData[XAmzMatDesc]);
+                    var initializationVector = Base64DecodedDataValue(keyValuePair, XAmzIV);
+                    var materialDescription = JsonUtils.ToDictionary((string)keyValuePair[XAmzMatDesc]);
 
-                    var cekAlgorithm = StringValue(jsonData, XAmzCekAlg);
-                    var wrapAlgorithm = StringValue(jsonData, XAmzWrapAlg);
+                    var cekAlgorithm = StringValue(keyValuePair, XAmzCekAlg);
+                    var wrapAlgorithm = StringValue(keyValuePair, XAmzWrapAlg);
 
                     var instructions = new EncryptionInstructions(materialDescription, decryptedEnvelopeKey, null,
                         initializationVector, wrapAlgorithm, cekAlgorithm);
 
                     return instructions;
                 }
-                else if (jsonData[XAmzKey] != null)
+                else if (keyValuePair.ContainsKey(XAmzKey))
                 {
                     // The envelope contains data in V1 format
-                    var encryptedEnvelopeKey = Base64DecodedDataValue(jsonData, XAmzKey);
+                    var encryptedEnvelopeKey = Base64DecodedDataValue(keyValuePair, XAmzKey);
                     var decryptedEnvelopeKey = DecryptNonKMSEnvelopeKey(encryptedEnvelopeKey, materials);
 
-                    var initializationVector = Base64DecodedDataValue(jsonData, XAmzIV);
-                    var materialDescription = JsonMapper.ToObject<Dictionary<string, string>>((string)jsonData[XAmzMatDesc]);
+                    var initializationVector = Base64DecodedDataValue(keyValuePair, XAmzIV);
+                    var materialDescription = JsonUtils.ToDictionary((string)keyValuePair[XAmzMatDesc]);
 
                     var instructions = new EncryptionInstructions(materialDescription, decryptedEnvelopeKey, null, initializationVector);
 
                     return instructions;
                 }
-                else if (jsonData[EncryptedEnvelopeKey] != null)
+                else if (keyValuePair.ContainsKey(EncryptedEnvelopeKey))
                 {
                     // The envelope contains data in older format
-                    var encryptedEnvelopeKey = Base64DecodedDataValue(jsonData, EncryptedEnvelopeKey);
+                    var encryptedEnvelopeKey = Base64DecodedDataValue(keyValuePair, EncryptedEnvelopeKey);
                     var decryptedEnvelopeKey = DecryptNonKMSEnvelopeKey(encryptedEnvelopeKey, materials);
 
-                    var initializationVector = Base64DecodedDataValue(jsonData, IV);
+                    var initializationVector = Base64DecodedDataValue(keyValuePair, IV);
 
                     return new EncryptionInstructions(materials.MaterialsDescription, decryptedEnvelopeKey, initializationVector);
                 }
@@ -541,24 +540,24 @@ internal static EncryptionInstructions BuildInstructionsUsingInstructionFileV2(G
             }
         }
 
-        private static byte[] Base64DecodedDataValue(JsonData jsonData, string key)
+        private static byte[] Base64DecodedDataValue(Dictionary<string, string> keyValuePairs, string key)
         {
-            var base64EncodedValue = jsonData[key];
-            if (base64EncodedValue == null)
+            if (!keyValuePairs.TryGetValue(key, out var base64EncodedValue))
             {
                 throw new ArgumentNullException(nameof(key));
             }
+
             return Convert.FromBase64String((string)base64EncodedValue);
         }
 
-        private static string StringValue(JsonData jsonData, string key)
+        private static string StringValue(Dictionary<string, string> keyValuePairs, string key)
         {
-            var stringValue = jsonData[key];
-            if (stringValue == null)
+            if (!keyValuePairs.TryGetValue(key, out var stringValue))
             {
                 throw new ArgumentNullException(nameof(key));
             }
-            return (string)stringValue;
+
+            return stringValue;
         }
     }
 }
diff --git a/src/Internal/SetupDecryptionHandlerV1.cs b/src/Internal/SetupDecryptionHandlerV1.cs
@@ -13,15 +13,12 @@
  * permissions and limitations under the License.
  */
 
-using System;
 using System.Collections.Generic;
-using Amazon.Runtime;
-using Amazon.S3.Model;
 using System.IO;
+using Amazon.S3;
+using Amazon.S3.Model;
 using Amazon.KeyManagementService.Model;
 using Amazon.Runtime.Internal.Util;
-using Amazon.S3;
-using ThirdParty.Json.LitJson;
 using Amazon.Extensions.S3.Encryption.Util;
 
 namespace Amazon.Extensions.S3.Encryption.Internal
@@ -55,27 +52,17 @@ private static string GetKmsKeyIdFromMetadata(MetadataCollection metadata)
             }
             else
             {
-                JsonData materialDescriptionJsonData;
+                Dictionary<string,string> materialDescriptionJsonData;
                 try
                 {
-                    materialDescriptionJsonData = JsonMapper.ToObject(materialDescriptionJsonString);
+                    materialDescriptionJsonData = JsonUtils.ToDictionary(materialDescriptionJsonString);
                 }
-                catch (JsonException e)
+                catch (InvalidDataException e)
                 {
                     throw new InvalidDataException($"{KMSKeyIDMetadataMessage} The key '{EncryptionUtils.XAmzMatDesc}' does not contain valid JSON.", e);
                 }
 
-                JsonData kmsKeyIDJsonData;
-                try
-                {
-                    kmsKeyIDJsonData = materialDescriptionJsonData[EncryptionUtils.KMSCmkIDKey];
-                }
-                catch (JsonException e)
-                {
-                    throw new InvalidDataException($"{KMSKeyIDMetadataMessage} The key '{EncryptionUtils.KMSCmkIDKey}' is does not contain valid JSON.", e);
-                }
-
-                if (kmsKeyIDJsonData == null)
+                if (!materialDescriptionJsonData.TryGetValue(EncryptionUtils.KMSCmkIDKey, out var kmsKeyIDJsonData))
                 {
                     throw new InvalidDataException($"{KMSKeyIDMetadataMessage} The key '{kmsKeyIDJsonData}' is missing from the material description.");
                 }
diff --git a/src/Util/JsonUtils.cs b/src/Util/JsonUtils.cs
@@ -0,0 +1,83 @@
+﻿/*
+* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+* 
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+* 
+*  http://aws.amazon.com/apache2.0
+* 
+* or in the "license" file accompanying this file. This file is distributed
+* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+* express or implied. See the License for the specific language governing
+* permissions and limitations under the License.
+*/
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Text.Json;
+
+namespace Amazon.Extensions.S3.Encryption.Util
+{
+    internal static class JsonUtils
+    {
+
+        internal static string ToJson(Dictionary<string, string> keyValuePairs)
+        {
+            var stream = new MemoryStream();
+            using (var writer = new Utf8JsonWriter(stream))
+            {
+                writer.WriteStartObject();
+                foreach (var kvp in keyValuePairs)
+                {
+                    writer.WriteString(kvp.Key, kvp.Value);
+                }
+                writer.WriteEndObject();
+            }
+
+            stream.Position = 0;
+            return new StreamReader(stream).ReadToEnd();
+        }
+
+        internal static Dictionary<string,string> ToDictionary(string json)
+        {
+            var dictionary = new Dictionary<string,string>();
+            byte[] bytes = Encoding.UTF8.GetBytes(json);
+            var reader = new Utf8JsonReader(new ReadOnlySpan<byte>(bytes));
+
+            reader.Read();
+            if (reader.TokenType != JsonTokenType.StartObject)
+                throw new InvalidDataException("Key value pair JSON must start with an object.");
+
+            // Read to the first property
+            reader.Read();
+
+            while(reader.TokenType != JsonTokenType.EndObject)
+            {
+                if (reader.TokenType != JsonTokenType.PropertyName)
+                    throw new InvalidDataException("Key value pair JSON missing property name.");
+
+                var key = reader.GetString();
+
+                reader.Read();
+                if (reader.TokenType != JsonTokenType.String)
+                    throw new InvalidDataException("Key value pair JSON must only have string values.");
+
+                var value = reader.GetString();
+
+                // To make the existence checks easier in this library don't include null values.
+                // That way rest of the library just needs to do ContainsKey check.
+                if (value != null)
+                {
+                    dictionary[key] = value;
+                }
+
+                // Move to the next property or end of object
+                reader.Read();
+            }
+
+            return dictionary;
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,6 @@`
`25`	`25`	`using Amazon.KeyManagementService.Model;`
`26`	`26`	`using Amazon.Runtime;`
`27`	`27`	`using Amazon.S3.Model;`
`28`		`-using ThirdParty.Json.LitJson;`
`29`	`28`
`30`	`29`	`namespace Amazon.Extensions.S3.Encryption`
`31`	`30`	`{`
`@@ -276,7 +275,7 @@ internal static void UpdateMetadataWithEncryptionInstructionsV2(AmazonWebService`
`276`	`275`	`metadata.Add(XAmzKeyV2, base64EncodedEnvelopeKey);`
`277`	`276`	`metadata.Add(XAmzCekAlg, instructions.CekAlgorithm);`
`278`	`277`	`metadata.Add(XAmzIV, base64EncodedIv);`
`279`		`- metadata.Add(XAmzMatDesc, JsonMapper.ToJson(instructions.MaterialsDescription));`
	`278`	`+ metadata.Add(XAmzMatDesc, JsonUtils.ToJson(instructions.MaterialsDescription));`
`280`	`279`	`}`
`281`	`280`	`}`
`282`	`281`
`@@ -288,17 +287,17 @@ internal static PutObjectRequest CreateInstructionFileRequestV2(AmazonWebService`
`288`	`287`	`var ivToStoreInInstructionFile = instructions.InitializationVector;`
`289`	`288`	`var base64EncodedIv = Convert.ToBase64String(ivToStoreInInstructionFile);`
`290`	`289`
`291`		`- var jsonData = new JsonData`
	`290`	`+ var keyValuePairs = new Dictionary<string, string>()`
`292`	`291`	`{`
`293`		`- [XAmzTagLen] = DefaultTagBitsLength.ToString(),`
`294`		`- [XAmzKeyV2] = base64EncodedEnvelopeKey,`
`295`		`- [XAmzCekAlg] = instructions.CekAlgorithm,`
`296`		`- [XAmzWrapAlg] = instructions.WrapAlgorithm,`
`297`		`- [XAmzIV] = base64EncodedIv,`
`298`		`- [XAmzMatDesc] = JsonMapper.ToJson(instructions.MaterialsDescription)`
	`292`	`+ {XAmzTagLen, DefaultTagBitsLength.ToString()},`
	`293`	`+ {XAmzKeyV2, base64EncodedEnvelopeKey},`
	`294`	`+ {XAmzCekAlg, instructions.CekAlgorithm},`
	`295`	`+ {XAmzWrapAlg, instructions.WrapAlgorithm},`
	`296`	`+ {XAmzIV, base64EncodedIv},`
	`297`	`+ {XAmzMatDesc, JsonUtils.ToJson(instructions.MaterialsDescription)},`
`299`	`298`	`};`
`300`	`299`
`301`		`- var contentBody = jsonData.ToJson();`
	`300`	`+ var contentBody = JsonUtils.ToJson(keyValuePairs);`
`302`	`301`
`303`	`302`	`var putObjectRequest = request as PutObjectRequest;`
`304`	`303`	`if (putObjectRequest != null)`
`@@ -451,7 +450,7 @@ internal static Dictionary<string, string> GetMaterialDescriptionFromMetaData(Me`
`451`	`450`	`return new Dictionary<string, string>();`
`452`	`451`	`}`
`453`	`452`
`454`		`- var materialDescription = JsonMapper.ToObject<Dictionary<string, string>>(materialDescriptionJsonString);`
	`453`	`+ var materialDescription = JsonUtils.ToDictionary(materialDescriptionJsonString);`
`455`	`454`	`return materialDescription;`
`456`	`455`	`}`
`457`	`456`
`@@ -492,45 +491,45 @@ internal static EncryptionInstructions BuildInstructionsUsingInstructionFileV2(G`
`492`	`491`	`{`
`493`	`492`	`using (TextReader textReader = new StreamReader(response.ResponseStream))`
`494`	`493`	`{`
`495`		`- var jsonData = JsonMapper.ToObject(textReader);`
	`494`	`+ var keyValuePair = JsonUtils.ToDictionary(textReader.ReadToEnd());`
`496`	`495`
`497`		`- if (jsonData[XAmzKeyV2] != null)`
	`496`	`+ if (keyValuePair.ContainsKey(XAmzKeyV2))`
`498`	`497`	`{`
`499`	`498`	`// The envelope contains data in V2 format`
`500`		`- var encryptedEnvelopeKey = Base64DecodedDataValue(jsonData, XAmzKeyV2);`
	`499`	`+ var encryptedEnvelopeKey = Base64DecodedDataValue(keyValuePair, XAmzKeyV2);`
`501`	`500`	`var decryptedEnvelopeKey = DecryptNonKmsEnvelopeKeyV2(encryptedEnvelopeKey, materials);`
`502`	`501`
`503`		`- var initializationVector = Base64DecodedDataValue(jsonData, XAmzIV);`
`504`		`- var materialDescription = JsonMapper.ToObject<Dictionary<string, string>>((string)jsonData[XAmzMatDesc]);`
	`502`	`+ var initializationVector = Base64DecodedDataValue(keyValuePair, XAmzIV);`
	`503`	`+ var materialDescription = JsonUtils.ToDictionary((string)keyValuePair[XAmzMatDesc]);`
`505`	`504`
`506`		`- var cekAlgorithm = StringValue(jsonData, XAmzCekAlg);`
`507`		`- var wrapAlgorithm = StringValue(jsonData, XAmzWrapAlg);`
	`505`	`+ var cekAlgorithm = StringValue(keyValuePair, XAmzCekAlg);`
	`506`	`+ var wrapAlgorithm = StringValue(keyValuePair, XAmzWrapAlg);`
`508`	`507`
`509`	`508`	`var instructions = new EncryptionInstructions(materialDescription, decryptedEnvelopeKey, null,`
`510`	`509`	`initializationVector, wrapAlgorithm, cekAlgorithm);`
`511`	`510`
`512`	`511`	`return instructions;`
`513`	`512`	`}`
`514`		`- else if (jsonData[XAmzKey] != null)`
	`513`	`+ else if (keyValuePair.ContainsKey(XAmzKey))`
`515`	`514`	`{`
`516`	`515`	`// The envelope contains data in V1 format`
`517`		`- var encryptedEnvelopeKey = Base64DecodedDataValue(jsonData, XAmzKey);`
	`516`	`+ var encryptedEnvelopeKey = Base64DecodedDataValue(keyValuePair, XAmzKey);`
`518`	`517`	`var decryptedEnvelopeKey = DecryptNonKMSEnvelopeKey(encryptedEnvelopeKey, materials);`
`519`	`518`
`520`		`- var initializationVector = Base64DecodedDataValue(jsonData, XAmzIV);`
`521`		`- var materialDescription = JsonMapper.ToObject<Dictionary<string, string>>((string)jsonData[XAmzMatDesc]);`
	`519`	`+ var initializationVector = Base64DecodedDataValue(keyValuePair, XAmzIV);`
	`520`	`+ var materialDescription = JsonUtils.ToDictionary((string)keyValuePair[XAmzMatDesc]);`
`522`	`521`
`523`	`522`	`var instructions = new EncryptionInstructions(materialDescription, decryptedEnvelopeKey, null, initializationVector);`
`524`	`523`
`525`	`524`	`return instructions;`
`526`	`525`	`}`
`527`		`- else if (jsonData[EncryptedEnvelopeKey] != null)`
	`526`	`+ else if (keyValuePair.ContainsKey(EncryptedEnvelopeKey))`
`528`	`527`	`{`
`529`	`528`	`// The envelope contains data in older format`
`530`		`- var encryptedEnvelopeKey = Base64DecodedDataValue(jsonData, EncryptedEnvelopeKey);`
	`529`	`+ var encryptedEnvelopeKey = Base64DecodedDataValue(keyValuePair, EncryptedEnvelopeKey);`
`531`	`530`	`var decryptedEnvelopeKey = DecryptNonKMSEnvelopeKey(encryptedEnvelopeKey, materials);`
`532`	`531`
`533`		`- var initializationVector = Base64DecodedDataValue(jsonData, IV);`
	`532`	`+ var initializationVector = Base64DecodedDataValue(keyValuePair, IV);`
`534`	`533`
`535`	`534`	`return new EncryptionInstructions(materials.MaterialsDescription, decryptedEnvelopeKey, initializationVector);`
`536`	`535`	`}`
`@@ -541,24 +540,24 @@ internal static EncryptionInstructions BuildInstructionsUsingInstructionFileV2(G`
`541`	`540`	`}`
`542`	`541`	`}`
`543`	`542`
`544`		`- private static byte[] Base64DecodedDataValue(JsonData jsonData, string key)`
	`543`	`+ private static byte[] Base64DecodedDataValue(Dictionary<string, string> keyValuePairs, string key)`
`545`	`544`	`{`
`546`		`- var base64EncodedValue = jsonData[key];`
`547`		`- if (base64EncodedValue == null)`
	`545`	`+ if (!keyValuePairs.TryGetValue(key, out var base64EncodedValue))`
`548`	`546`	`{`
`549`	`547`	`throw new ArgumentNullException(nameof(key));`
`550`	`548`	`}`
	`549`	`+`
`551`	`550`	`return Convert.FromBase64String((string)base64EncodedValue);`
`552`	`551`	`}`
`553`	`552`
`554`		`- private static string StringValue(JsonData jsonData, string key)`
	`553`	`+ private static string StringValue(Dictionary<string, string> keyValuePairs, string key)`
`555`	`554`	`{`
`556`		`- var stringValue = jsonData[key];`
`557`		`- if (stringValue == null)`
	`555`	`+ if (!keyValuePairs.TryGetValue(key, out var stringValue))`
`558`	`556`	`{`
`559`	`557`	`throw new ArgumentNullException(nameof(key));`
`560`	`558`	`}`
`561`		`- return (string)stringValue;`
	`559`	`+`
	`560`	`+ return stringValue;`
`562`	`561`	`}`
`563`	`562`	`}`
`564`	`563`	`}`