Improve Code Quality (#301)

iamcarbon · web-flow · commit 2643470094ae · 2022-06-28T13:59:49.000-04:00
* Configure await

* Presize lists

* Use Ordinal comparer to check string equality

* Use singleton for True &amp; False CborBoolean

* Fix private variable name

* Parse double using invariant culture

* Format AuthenticatorGetAssertionCommand

* Use Array.Empty&lt;byte&gt;()

* Add missing parenthes
diff --git a/Src/Fido2.Ctap2/Commands/AuthenticatorGetAssertionCommand.cs b/Src/Fido2.Ctap2/Commands/AuthenticatorGetAssertionCommand.cs
@@ -77,11 +77,10 @@ public AuthenticatorGetAssertionCommand(
         var cbor = new CborMap
         {
             { 0x01, RpId },
-            { 0x02, ClientDataHash }
+            { 0x02, ClientDataHash },
+            { 0x03, AllowList.ToCborArray() } // allowList
         };
 
-        cbor.Add(0x03, AllowList.ToCborArray()); // allowList
-
         if (Extensions != null)
         {
             cbor.Add(0x04, Extensions);
@@ -102,7 +101,6 @@ public AuthenticatorGetAssertionCommand(
     }
 }
 
-
 public sealed class AuthenticatorGetAssertionOptions
 {
     /// <summary>
diff --git a/Src/Fido2.Ctap2/Devices/FidoAuthenticator.cs b/Src/Fido2.Ctap2/Devices/FidoAuthenticator.cs
@@ -158,7 +158,7 @@ public async ValueTask<NegotiateSharedSecretResult> NegotiateSharedSecretAsync()
     {
         var command = new AuthenticatorClientPinCommand(pinProtocol: 0x01, subCommand: AuthenticatorClientPinSubCommand.GetKeyAgreement);
 
-        var result = await ExecuteClientPinCommandAsync(command);
+        var result = await ExecuteClientPinCommandAsync(command).ConfigureAwait(false);
 
         var authenticatorKey = result.KeyAgreement!;
 
diff --git a/Src/Fido2.Models/CredentialCreateOptions.cs b/Src/Fido2.Models/CredentialCreateOptions.cs
@@ -78,7 +78,7 @@ public static CredentialCreateOptions Create(Fido2Configuration config, byte[] c
                 Rp = new PublicKeyCredentialRpEntity(config.ServerDomain, config.ServerName, config.ServerIcon),
                 Timeout = config.Timeout,
                 User = user,
-                PubKeyCredParams = new List<PubKeyCredParam>()
+                PubKeyCredParams = new List<PubKeyCredParam>(10)
                 {
                     // Add additional as appropriate
                     PubKeyCredParam.ES256,
diff --git a/Src/Fido2/AttestationFormat/AndroidSafetyNet.cs b/Src/Fido2/AttestationFormat/AndroidSafetyNet.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IdentityModel.Tokens.Jwt;
 using System.Linq;
 using System.Security.Cryptography;
@@ -126,7 +127,7 @@ public override (AttestationType, X509Certificate2[]) Verify()
                 }
                 if (claim is { Type: "timestampMs", ValueType: "http://www.w3.org/2001/XMLSchema#integer64" })
                 {
-                    timestamp = DateTimeOffset.UnixEpoch.AddMilliseconds(double.Parse(claim.Value));
+                    timestamp = DateTimeOffset.UnixEpoch.AddMilliseconds(double.Parse(claim.Value, CultureInfo.InvariantCulture));
                 }
             }
 
diff --git a/Src/Fido2/Cbor/CborBoolean.cs b/Src/Fido2/Cbor/CborBoolean.cs
@@ -2,8 +2,11 @@
 
 namespace Fido2NetLib.Cbor
 {
-    internal sealed class CborBoolean : CborObject
+    public sealed class CborBoolean : CborObject
     {
+        public static readonly CborBoolean True  = new(true);
+        public static readonly CborBoolean False = new(false);
+
         public CborBoolean(bool value)
         {
             Value = value;
@@ -17,5 +20,9 @@ public override int GetHashCode()
         {
             return HashCode.Combine(Type, Value);
         }
+
+        public static explicit operator CborBoolean(bool value) => value ? True : False;
+
+        public static implicit operator bool(CborBoolean value) => value.Value;
     }
 }
diff --git a/Src/Fido2/Cbor/CborMap.cs b/Src/Fido2/Cbor/CborMap.cs
@@ -9,27 +9,27 @@ namespace Fido2NetLib.Cbor
 {
     public sealed class CborMap : CborObject, IReadOnlyDictionary<CborObject, CborObject>
     {
-        private readonly List<KeyValuePair<CborObject, CborObject>> items;
+        private readonly List<KeyValuePair<CborObject, CborObject>> _items;
 
         public CborMap()
         {
-            items = new();
+            _items = new();
         }
 
         public CborMap(int capacity)
         {
-            items = new(capacity);
+            _items = new(capacity);
         }
 
         public override CborType Type => CborType.Map;
 
-        public int Count => items.Count;
+        public int Count => _items.Count;
 
         public IEnumerable<CborObject> Keys
         {
             get
             {
-                foreach (var item in items)
+                foreach (var item in _items)
                 {
                     yield return item.Key;
                 }
@@ -40,7 +40,7 @@ public IEnumerable<CborObject> Values
         {
             get
             {
-                foreach (var item in items)
+                foreach (var item in _items)
                 {
                     yield return item.Value;
                 }
@@ -49,82 +49,82 @@ public IEnumerable<CborObject> Values
 
         public void Add(string key, CborObject value)
         {
-            items.Add(new (new CborTextString(key), value));
+            _items.Add(new (new CborTextString(key), value));
         }
 
         public void Add(string key, bool value)
         {
-            items.Add(new(new CborTextString(key), new CborBoolean(value)));
+            _items.Add(new(new CborTextString(key), (CborBoolean)value));
         }
 
         public void Add(long key, CborObject value)
         {
-            items.Add(new (new CborInteger(key), value));
+            _items.Add(new (new CborInteger(key), value));
         }
 
         public void Add(long key, byte[] value)
         {
-            items.Add(new(new CborInteger(key), new CborByteString(value)));
+            _items.Add(new(new CborInteger(key), new CborByteString(value)));
         }
 
         public void Add(long key, string value)
         {
-            items.Add(new(new CborInteger(key), new CborTextString(value)));
+            _items.Add(new(new CborInteger(key), new CborTextString(value)));
         }
 
         public void Add(long key, long value)
         {
-            items.Add(new(new CborInteger(key), new CborInteger(value)));
+            _items.Add(new(new CborInteger(key), new CborInteger(value)));
         }
 
         public void Add(string key, int value)
         {
-            items.Add(new(new CborTextString(key), new CborInteger(value)));
+            _items.Add(new(new CborTextString(key), new CborInteger(value)));
         }
 
         public void Add(string key, string value)
         {
-            items.Add(new(new CborTextString(key), new CborTextString(value)));
+            _items.Add(new(new CborTextString(key), new CborTextString(value)));
         }
 
         public void Add(string key, byte[] value)
         {
-            items.Add(new(new CborTextString(key), new CborByteString(value)));
+            _items.Add(new(new CborTextString(key), new CborByteString(value)));
         }
 
         internal void Add(CborObject key, CborObject value)
         {
-            items.Add(new (key, value));
+            _items.Add(new (key, value));
         }
 
         internal void Add(string key, COSE.Algorithm value)
         {
-            items.Add(new(new CborTextString(key), new CborInteger((int)value)));
+            _items.Add(new(new CborTextString(key), new CborInteger((int)value)));
         }
 
         internal void Add(COSE.KeyCommonParameter key, COSE.KeyType value)
         {
-            items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));
+            _items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));
         }
 
         internal void Add(COSE.KeyCommonParameter key, COSE.Algorithm value)
         {
-            items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));
+            _items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));
         }
 
         internal void Add(COSE.KeyTypeParameter key, COSE.EllipticCurve value)
         {
-            items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));
+            _items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));
         }
 
         internal void Add(COSE.KeyTypeParameter key, byte[] value)
         {
-            items.Add(new(new CborInteger((int)key), new CborByteString(value)));
+            _items.Add(new(new CborInteger((int)key), new CborByteString(value)));
         }
 
         public bool ContainsKey(CborObject key)
         {
-            foreach (var (k, _) in items)
+            foreach (var (k, _) in _items)
             {
                 if (k.Equals(key))
                     return true;
@@ -142,12 +142,12 @@ public bool TryGetValue(CborObject key, [MaybeNullWhen(false)] out CborObject va
 
         public IEnumerator<KeyValuePair<CborObject, CborObject>> GetEnumerator()
         {
-            return items.GetEnumerator();
+            return _items.GetEnumerator();
         }
 
         IEnumerator IEnumerable.GetEnumerator()
         {
-            return items.GetEnumerator();
+            return _items.GetEnumerator();
         }
 
         internal CborObject this[COSE.KeyCommonParameter key] => GetValue((long)key);
@@ -160,7 +160,7 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public CborObject GetValue(long key)
         {
-            foreach (var item in items)
+            foreach (var item in _items)
             {
                 if (item.Key is CborInteger integerKey && integerKey.Value == key)
                 {
@@ -177,7 +177,7 @@ public CborObject? this[CborObject key]
 #pragma warning disable CS8766
             get
             {
-                foreach (var item in items)
+                foreach (var item in _items)
                 {
                     if (item.Key.Equals(key))
                     {
@@ -194,7 +194,7 @@ public override CborObject? this[string name]
         {
             get
             {
-                foreach (var item in items)
+                foreach (var item in _items)
                 {
                     if (item.Key is CborTextString keyText && keyText.Value.Equals(name, StringComparison.Ordinal))
                     {
@@ -208,11 +208,11 @@ public override CborObject? this[string name]
 
         internal void Remove(string key)
         {
-            for (int i = 0; i < items.Count; i++)
+            for (int i = 0; i < _items.Count; i++)
             {
-                if (items[i].Key is CborTextString textKey && textKey.Value.Equals(key, StringComparison.Ordinal))
+                if (_items[i].Key is CborTextString textKey && textKey.Value.Equals(key, StringComparison.Ordinal))
                 {
-                    items.RemoveAt(i);
+                    _items.RemoveAt(i);
 
                     return;
                 }
@@ -221,17 +221,17 @@ internal void Remove(string key)
 
         internal void Set(string key, CborObject value)
         {
-            for (int i = 0; i < items.Count; i++)
+            for (int i = 0; i < _items.Count; i++)
             {
-                if (items[i].Key is CborTextString textKey && textKey.Value.Equals(key, StringComparison.Ordinal))
+                if (_items[i].Key is CborTextString textKey && textKey.Value.Equals(key, StringComparison.Ordinal))
                 {
-                    items[i] = new KeyValuePair<CborObject, CborObject>(new CborTextString(key), value);
+                    _items[i] = new KeyValuePair<CborObject, CborObject>(new CborTextString(key), value);
 
                     return;
                 }
             }
 
-            items.Add(new(new CborTextString(key), value));
+            _items.Add(new(new CborTextString(key), value));
         }
     }
 }
diff --git a/Src/Fido2/Cbor/CborObject.cs b/Src/Fido2/Cbor/CborObject.cs
@@ -65,7 +65,7 @@ private static CborObject Read(CborReader reader)
                 CborReaderState.StartMap        => ReadMap(reader),
                 CborReaderState.StartArray      => ReadArray(reader),
                 CborReaderState.TextString      => new CborTextString(reader.ReadTextString()),
-                CborReaderState.Boolean         => new CborBoolean(reader.ReadBoolean()),
+                CborReaderState.Boolean         => (CborBoolean)reader.ReadBoolean(),
                 CborReaderState.ByteString      => new CborByteString(reader.ReadByteString()),
                 CborReaderState.UnsignedInteger => new CborInteger(reader.ReadInt64()),
                 CborReaderState.NegativeInteger => new CborInteger(reader.ReadInt64()),
diff --git a/Src/Fido2/CryptoUtils.cs b/Src/Fido2/CryptoUtils.cs
@@ -113,7 +113,7 @@ public static bool ValidateTrustChain(X509Certificate2[] trustPath, X509Certific
                         if (chain.ChainElements
                             .Cast<X509ChainElement>()
                             .Skip(1)
-                            .Any(x => x.Certificate.Thumbprint == attestationRootCertificate.Thumbprint))
+                            .Any(x => x.Certificate.Thumbprint.Equals(attestationRootCertificate.Thumbprint, StringComparison.Ordinal)))
                             return true;
                     }
                 }
diff --git a/Src/Fido2/Metadata/ConformanceMetadataRepository.cs b/Src/Fido2/Metadata/ConformanceMetadataRepository.cs
@@ -145,7 +145,7 @@ public async Task<MetadataBLOBPayload> DeserializeAndValidateBlob(string rawBLOB
 
             var rootCert = GetX509Certificate(ROOT_CERT);
             var blobCertificates = new X509Certificate2[blobCertStrings.Length]; 
-            var blobPublicKeys = new List<SecurityKey>();
+            var blobPublicKeys = new List<SecurityKey>(blobCertStrings.Length);
 
             for (int i = 0; i < blobCertStrings.Length; i++)
             {
@@ -207,7 +207,7 @@ public async Task<MetadataBLOBPayload> DeserializeAndValidateBlob(string rawBLOB
                 }
 
                 // otherwise we have to manually validate that the root in the chain we are testing is the root we downloaded
-                if (rootCert.Thumbprint == certChain.ChainElements[^1].Certificate.Thumbprint &&
+                if (rootCert.Thumbprint.Equals(certChain.ChainElements[^1].Certificate.Thumbprint, StringComparison.Ordinal) &&
                     // and that the number of elements in the chain accounts for what was in x5c plus the root we added
                     certChain.ChainElements.Count == (blobCertStrings.Length + 1) &&
                     // and that the root cert has exactly one status listed against it
diff --git a/Test/AuthenticatorResponse.cs b/Test/AuthenticatorResponse.cs
@@ -375,7 +375,7 @@ public void TestAuthenticatorAttestationResponseInvalidType()
                     AttestationObject = new CborMap {
                         { "fmt", "testing" },
                         { "attStmt", new CborMap() },
-                        { "authData", new byte[0] }
+                        { "authData", Array.Empty<byte>() }
                     }.Encode(),
                     ClientDataJson = clientDataJson
                 },

Original file line number	Diff line number	Diff line change
`@@ -77,11 +77,10 @@ public AuthenticatorGetAssertionCommand(`
`77`	`77`	`var cbor = new CborMap`
`78`	`78`	`{`
`79`	`79`	`{ 0x01, RpId },`
`80`		`- { 0x02, ClientDataHash }`
	`80`	`+ { 0x02, ClientDataHash },`
	`81`	`+ { 0x03, AllowList.ToCborArray() } // allowList`
`81`	`82`	`};`
`82`	`83`
`83`		`- cbor.Add(0x03, AllowList.ToCborArray()); // allowList`
`84`		`-`
`85`	`84`	`if (Extensions != null)`
`86`	`85`	`{`
`87`	`86`	`cbor.Add(0x04, Extensions);`
`@@ -102,7 +101,6 @@ public AuthenticatorGetAssertionCommand(`
`102`	`101`	`}`
`103`	`102`	`}`
`104`	`103`
`105`		`-`
`106`	`104`	`public sealed class AuthenticatorGetAssertionOptions`
`107`	`105`	`{`
`108`	`106`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ public async ValueTask<NegotiateSharedSecretResult> NegotiateSharedSecretAsync()`
`158`	`158`	`{`
`159`	`159`	`var command = new AuthenticatorClientPinCommand(pinProtocol: 0x01, subCommand: AuthenticatorClientPinSubCommand.GetKeyAgreement);`
`160`	`160`
`161`		`- var result = await ExecuteClientPinCommandAsync(command);`
	`161`	`+ var result = await ExecuteClientPinCommandAsync(command).ConfigureAwait(false);`
`162`	`162`
`163`	`163`	`var authenticatorKey = result.KeyAgreement!;`
`164`	`164`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public static CredentialCreateOptions Create(Fido2Configuration config, byte[] c`
`78`	`78`	`Rp = new PublicKeyCredentialRpEntity(config.ServerDomain, config.ServerName, config.ServerIcon),`
`79`	`79`	`Timeout = config.Timeout,`
`80`	`80`	`User = user,`
`81`		`- PubKeyCredParams = new List<PubKeyCredParam>()`
	`81`	`+ PubKeyCredParams = new List<PubKeyCredParam>(10)`
`82`	`82`	`{`
`83`	`83`	`// Add additional as appropriate`
`84`	`84`	`PubKeyCredParam.ES256,`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Globalization;`
`3`	`4`	`using System.IdentityModel.Tokens.Jwt;`
`4`	`5`	`using System.Linq;`
`5`	`6`	`using System.Security.Cryptography;`
`@@ -126,7 +127,7 @@ public override (AttestationType, X509Certificate2[]) Verify()`
`126`	`127`	`}`
`127`	`128`	`if (claim is { Type: "timestampMs", ValueType: "http://www.w3.org/2001/XMLSchema#integer64" })`
`128`	`129`	`{`
`129`		`- timestamp = DateTimeOffset.UnixEpoch.AddMilliseconds(double.Parse(claim.Value));`
	`130`	`+ timestamp = DateTimeOffset.UnixEpoch.AddMilliseconds(double.Parse(claim.Value, CultureInfo.InvariantCulture));`
`130`	`131`	`}`
`131`	`132`	`}`
`132`	`133`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,11 @@`
`2`	`2`
`3`	`3`	`namespace Fido2NetLib.Cbor`
`4`	`4`	`{`
`5`		`- internal sealed class CborBoolean : CborObject`
	`5`	`+ public sealed class CborBoolean : CborObject`
`6`	`6`	`{`
	`7`	`+ public static readonly CborBoolean True = new(true);`
	`8`	`+ public static readonly CborBoolean False = new(false);`
	`9`	`+`
`7`	`10`	`public CborBoolean(bool value)`
`8`	`11`	`{`
`9`	`12`	`Value = value;`
`@@ -17,5 +20,9 @@ public override int GetHashCode()`
`17`	`20`	`{`
`18`	`21`	`return HashCode.Combine(Type, Value);`
`19`	`22`	`}`
	`23`	`+`
	`24`	`+ public static explicit operator CborBoolean(bool value) => value ? True : False;`
	`25`	`+`
	`26`	`+ public static implicit operator bool(CborBoolean value) => value.Value;`
`20`	`27`	`}`
`21`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,27 +9,27 @@ namespace Fido2NetLib.Cbor`
`9`	`9`	`{`
`10`	`10`	`public sealed class CborMap : CborObject, IReadOnlyDictionary<CborObject, CborObject>`
`11`	`11`	`{`
`12`		`- private readonly List<KeyValuePair<CborObject, CborObject>> items;`
	`12`	`+ private readonly List<KeyValuePair<CborObject, CborObject>> _items;`
`13`	`13`
`14`	`14`	`public CborMap()`
`15`	`15`	`{`
`16`		`- items = new();`
	`16`	`+ _items = new();`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`public CborMap(int capacity)`
`20`	`20`	`{`
`21`		`- items = new(capacity);`
	`21`	`+ _items = new(capacity);`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public override CborType Type => CborType.Map;`
`25`	`25`
`26`		`- public int Count => items.Count;`
	`26`	`+ public int Count => _items.Count;`
`27`	`27`
`28`	`28`	`public IEnumerable<CborObject> Keys`
`29`	`29`	`{`
`30`	`30`	`get`
`31`	`31`	`{`
`32`		`- foreach (var item in items)`
	`32`	`+ foreach (var item in _items)`
`33`	`33`	`{`
`34`	`34`	`yield return item.Key;`
`35`	`35`	`}`
`@@ -40,7 +40,7 @@ public IEnumerable<CborObject> Values`
`40`	`40`	`{`
`41`	`41`	`get`
`42`	`42`	`{`
`43`		`- foreach (var item in items)`
	`43`	`+ foreach (var item in _items)`
`44`	`44`	`{`
`45`	`45`	`yield return item.Value;`
`46`	`46`	`}`
`@@ -49,82 +49,82 @@ public IEnumerable<CborObject> Values`
`49`	`49`
`50`	`50`	`public void Add(string key, CborObject value)`
`51`	`51`	`{`
`52`		`- items.Add(new (new CborTextString(key), value));`
	`52`	`+ _items.Add(new (new CborTextString(key), value));`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`public void Add(string key, bool value)`
`56`	`56`	`{`
`57`		`- items.Add(new(new CborTextString(key), new CborBoolean(value)));`
	`57`	`+ _items.Add(new(new CborTextString(key), (CborBoolean)value));`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`public void Add(long key, CborObject value)`
`61`	`61`	`{`
`62`		`- items.Add(new (new CborInteger(key), value));`
	`62`	`+ _items.Add(new (new CborInteger(key), value));`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`public void Add(long key, byte[] value)`
`66`	`66`	`{`
`67`		`- items.Add(new(new CborInteger(key), new CborByteString(value)));`
	`67`	`+ _items.Add(new(new CborInteger(key), new CborByteString(value)));`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`public void Add(long key, string value)`
`71`	`71`	`{`
`72`		`- items.Add(new(new CborInteger(key), new CborTextString(value)));`
	`72`	`+ _items.Add(new(new CborInteger(key), new CborTextString(value)));`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`public void Add(long key, long value)`
`76`	`76`	`{`
`77`		`- items.Add(new(new CborInteger(key), new CborInteger(value)));`
	`77`	`+ _items.Add(new(new CborInteger(key), new CborInteger(value)));`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`public void Add(string key, int value)`
`81`	`81`	`{`
`82`		`- items.Add(new(new CborTextString(key), new CborInteger(value)));`
	`82`	`+ _items.Add(new(new CborTextString(key), new CborInteger(value)));`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`public void Add(string key, string value)`
`86`	`86`	`{`
`87`		`- items.Add(new(new CborTextString(key), new CborTextString(value)));`
	`87`	`+ _items.Add(new(new CborTextString(key), new CborTextString(value)));`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`public void Add(string key, byte[] value)`
`91`	`91`	`{`
`92`		`- items.Add(new(new CborTextString(key), new CborByteString(value)));`
	`92`	`+ _items.Add(new(new CborTextString(key), new CborByteString(value)));`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`internal void Add(CborObject key, CborObject value)`
`96`	`96`	`{`
`97`		`- items.Add(new (key, value));`
	`97`	`+ _items.Add(new (key, value));`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`internal void Add(string key, COSE.Algorithm value)`
`101`	`101`	`{`
`102`		`- items.Add(new(new CborTextString(key), new CborInteger((int)value)));`
	`102`	`+ _items.Add(new(new CborTextString(key), new CborInteger((int)value)));`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`internal void Add(COSE.KeyCommonParameter key, COSE.KeyType value)`
`106`	`106`	`{`
`107`		`- items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));`
	`107`	`+ _items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`internal void Add(COSE.KeyCommonParameter key, COSE.Algorithm value)`
`111`	`111`	`{`
`112`		`- items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));`
	`112`	`+ _items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`internal void Add(COSE.KeyTypeParameter key, COSE.EllipticCurve value)`
`116`	`116`	`{`
`117`		`- items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));`
	`117`	`+ _items.Add(new(new CborInteger((int)key), new CborInteger((int)value)));`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`internal void Add(COSE.KeyTypeParameter key, byte[] value)`
`121`	`121`	`{`
`122`		`- items.Add(new(new CborInteger((int)key), new CborByteString(value)));`
	`122`	`+ _items.Add(new(new CborInteger((int)key), new CborByteString(value)));`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`public bool ContainsKey(CborObject key)`
`126`	`126`	`{`
`127`		`- foreach (var (k, _) in items)`
	`127`	`+ foreach (var (k, _) in _items)`
`128`	`128`	`{`
`129`	`129`	`if (k.Equals(key))`
`130`	`130`	`return true;`
`@@ -142,12 +142,12 @@ public bool TryGetValue(CborObject key, [MaybeNullWhen(false)] out CborObject va`
`142`	`142`
`143`	`143`	`public IEnumerator<KeyValuePair<CborObject, CborObject>> GetEnumerator()`
`144`	`144`	`{`
`145`		`- return items.GetEnumerator();`
	`145`	`+ return _items.GetEnumerator();`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`IEnumerator IEnumerable.GetEnumerator()`
`149`	`149`	`{`
`150`		`- return items.GetEnumerator();`
	`150`	`+ return _items.GetEnumerator();`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`internal CborObject this[COSE.KeyCommonParameter key] => GetValue((long)key);`
`@@ -160,7 +160,7 @@ IEnumerator IEnumerable.GetEnumerator()`
`160`	`160`
`161`	`161`	`public CborObject GetValue(long key)`
`162`	`162`	`{`
`163`		`- foreach (var item in items)`
	`163`	`+ foreach (var item in _items)`
`164`	`164`	`{`
`165`	`165`	`if (item.Key is CborInteger integerKey && integerKey.Value == key)`
`166`	`166`	`{`
`@@ -177,7 +177,7 @@ public CborObject? this[CborObject key]`
`177`	`177`	`#pragma warning disable CS8766`
`178`	`178`	`get`
`179`	`179`	`{`
`180`		`- foreach (var item in items)`
	`180`	`+ foreach (var item in _items)`
`181`	`181`	`{`
`182`	`182`	`if (item.Key.Equals(key))`
`183`	`183`	`{`
`@@ -194,7 +194,7 @@ public override CborObject? this[string name]`
`194`	`194`	`{`
`195`	`195`	`get`
`196`	`196`	`{`
`197`		`- foreach (var item in items)`
	`197`	`+ foreach (var item in _items)`
`198`	`198`	`{`
`199`	`199`	`if (item.Key is CborTextString keyText && keyText.Value.Equals(name, StringComparison.Ordinal))`
`200`	`200`	`{`
`@@ -208,11 +208,11 @@ public override CborObject? this[string name]`
`208`	`208`
`209`	`209`	`internal void Remove(string key)`
`210`	`210`	`{`
`211`		`- for (int i = 0; i < items.Count; i++)`
	`211`	`+ for (int i = 0; i < _items.Count; i++)`
`212`	`212`	`{`
`213`		`- if (items[i].Key is CborTextString textKey && textKey.Value.Equals(key, StringComparison.Ordinal))`
	`213`	`+ if (_items[i].Key is CborTextString textKey && textKey.Value.Equals(key, StringComparison.Ordinal))`
`214`	`214`	`{`
`215`		`- items.RemoveAt(i);`
	`215`	`+ _items.RemoveAt(i);`
`216`	`216`
`217`	`217`	`return;`
`218`	`218`	`}`
`@@ -221,17 +221,17 @@ internal void Remove(string key)`
`221`	`221`
`222`	`222`	`internal void Set(string key, CborObject value)`
`223`	`223`	`{`
`224`		`- for (int i = 0; i < items.Count; i++)`
	`224`	`+ for (int i = 0; i < _items.Count; i++)`
`225`	`225`	`{`
`226`		`- if (items[i].Key is CborTextString textKey && textKey.Value.Equals(key, StringComparison.Ordinal))`
	`226`	`+ if (_items[i].Key is CborTextString textKey && textKey.Value.Equals(key, StringComparison.Ordinal))`
`227`	`227`	`{`
`228`		`- items[i] = new KeyValuePair<CborObject, CborObject>(new CborTextString(key), value);`
	`228`	`+ _items[i] = new KeyValuePair<CborObject, CborObject>(new CborTextString(key), value);`
`229`	`229`
`230`	`230`	`return;`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`
`234`		`- items.Add(new(new CborTextString(key), value));`
	`234`	`+ _items.Add(new(new CborTextString(key), value));`
`235`	`235`	`}`
`236`	`236`	`}`
`237`	`237`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ public static bool ValidateTrustChain(X509Certificate2[] trustPath, X509Certific`
`113`	`113`	`if (chain.ChainElements`
`114`	`114`	`.Cast<X509ChainElement>()`
`115`	`115`	`.Skip(1)`
`116`		`- .Any(x => x.Certificate.Thumbprint == attestationRootCertificate.Thumbprint))`
	`116`	`+ .Any(x => x.Certificate.Thumbprint.Equals(attestationRootCertificate.Thumbprint, StringComparison.Ordinal)))`
`117`	`117`	`return true;`
`118`	`118`	`}`
`119`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ public async Task<MetadataBLOBPayload> DeserializeAndValidateBlob(string rawBLOB`
`145`	`145`
`146`	`146`	`var rootCert = GetX509Certificate(ROOT_CERT);`
`147`	`147`	`var blobCertificates = new X509Certificate2[blobCertStrings.Length];`
`148`		`- var blobPublicKeys = new List<SecurityKey>();`
	`148`	`+ var blobPublicKeys = new List<SecurityKey>(blobCertStrings.Length);`
`149`	`149`
`150`	`150`	`for (int i = 0; i < blobCertStrings.Length; i++)`
`151`	`151`	`{`
`@@ -207,7 +207,7 @@ public async Task<MetadataBLOBPayload> DeserializeAndValidateBlob(string rawBLOB`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`// otherwise we have to manually validate that the root in the chain we are testing is the root we downloaded`
`210`		`- if (rootCert.Thumbprint == certChain.ChainElements[^1].Certificate.Thumbprint &&`
	`210`	`+ if (rootCert.Thumbprint.Equals(certChain.ChainElements[^1].Certificate.Thumbprint, StringComparison.Ordinal) &&`
`211`	`211`	`// and that the number of elements in the chain accounts for what was in x5c plus the root we added`
`212`	`212`	`certChain.ChainElements.Count == (blobCertStrings.Length + 1) &&`
`213`	`213`	`// and that the root cert has exactly one status listed against it`