Cleanup after recent changes

5 files changed, 49 insertions, 80 deletions

diff --git a/crypto/src/asn1/nist/KMACwithSHAKE128_params.cs b/crypto/src/asn1/nist/KMACwithSHAKE128_params.cs
index cd73ce2bc..a1fd8f403 100644
--- a/crypto/src/asn1/nist/KMACwithSHAKE128_params.cs
+++ b/crypto/src/asn1/nist/KMACwithSHAKE128_params.cs
@@ -10,50 +10,44 @@ namespace Org.BouncyCastle.Asn1.Nist
     ///     customizationString  OCTET STRING DEFAULT ''H
     /// } 
     /// </summary>
-public class KMACwithSHAKE128_params : Asn1Encodable
+public class KMacWithShake128Params : Asn1Encodable
 {
-
     private static readonly byte[] EMPTY_STRING = new byte[0];
     private static readonly int DEF_LENGTH = 256;
 
     private readonly int outputLength;
     private readonly byte[] customizationString;
 
-
-    public KMACwithSHAKE128_params(int outputLength)
+    public KMacWithShake128Params(int outputLength)
     {
         this.outputLength = outputLength;
         this.customizationString = EMPTY_STRING;
     }
 
-    public KMACwithSHAKE128_params(int outputLength, byte[] customizationString)
+    public KMacWithShake128Params(int outputLength, byte[] customizationString)
     {
         this.outputLength = outputLength;
         this.customizationString = Arrays.Clone(customizationString);
     }
 
-
-    public static KMACwithSHAKE128_params getInstance(Object o)
+    public static KMacWithShake128Params GetInstance(object o)
     {
-        if (o is KMACwithSHAKE128_params)
+        if (o is KMacWithShake128Params)
         {
-            return (KMACwithSHAKE128_params)o;
+            return (KMacWithShake128Params)o;
         }
         else if (o != null)
         {
-            return new KMACwithSHAKE128_params(Asn1Sequence.GetInstance(o));
+            return new KMacWithShake128Params(Asn1Sequence.GetInstance(o));
         }
 
         return null;
     }
 
-
-    private KMACwithSHAKE128_params(Asn1Sequence seq)
+    private KMacWithShake128Params(Asn1Sequence seq)
     {
         if (seq.Count > 2)
-        {
             throw new InvalidOperationException("sequence size greater than 2");
-        }
 
         if (seq.Count == 2)
         {
@@ -80,8 +74,6 @@ public class KMACwithSHAKE128_params : Asn1Encodable
         }
     }
 
-
-
     public int OutputLength
     {
         get { return outputLength; }
@@ -92,7 +84,6 @@ public class KMACwithSHAKE128_params : Asn1Encodable
         get { return Arrays.Clone(customizationString); }
     }
 
-
     public override Asn1Object ToAsn1Object()
     {
         Asn1EncodableVector v = new Asn1EncodableVector();
diff --git a/crypto/src/asn1/nist/KMACwithSHAKE256_params.cs b/crypto/src/asn1/nist/KMACwithSHAKE256_params.cs
index e70fc807d..fa7471913 100644
--- a/crypto/src/asn1/nist/KMACwithSHAKE256_params.cs
+++ b/crypto/src/asn1/nist/KMACwithSHAKE256_params.cs
@@ -9,50 +9,44 @@ namespace Org.BouncyCastle.Asn1.Nist
     ///     customizationString  OCTET STRING DEFAULT ''H
     /// } 
     /// </summary>
-public class KMACwithSHAKE256_params : Asn1Encodable
+public class KMacWithShake256Params : Asn1Encodable
 {
-
     private static readonly byte[] EMPTY_STRING = new byte[0];
     private static readonly int DEF_LENGTH = 512;
 
     private readonly int outputLength;
     private readonly byte[] customizationString;
 
-
-    public KMACwithSHAKE256_params(int outputLength)
+    public KMacWithShake256Params(int outputLength)
     {
         this.outputLength = outputLength;
         this.customizationString = EMPTY_STRING;
     }
 
-    public KMACwithSHAKE256_params(int outputLength, byte[] customizationString)
+    public KMacWithShake256Params(int outputLength, byte[] customizationString)
     {
         this.outputLength = outputLength;
         this.customizationString = Arrays.Clone(customizationString);
     }
 
-
-    public static KMACwithSHAKE256_params getInstance(Object o)
+    public static KMacWithShake256Params GetInstance(Object o)
     {
-        if (o is KMACwithSHAKE256_params)
+        if (o is KMacWithShake256Params)
         {
-            return (KMACwithSHAKE256_params)o;
+            return (KMacWithShake256Params)o;
         }
         else if (o != null)
         {
-            return new KMACwithSHAKE256_params(Asn1Sequence.GetInstance(o));
+            return new KMacWithShake256Params(Asn1Sequence.GetInstance(o));
         }
 
         return null;
     }
 
-
-    private KMACwithSHAKE256_params(Asn1Sequence seq)
+    private KMacWithShake256Params(Asn1Sequence seq)
     {
         if (seq.Count > 2)
-        {
             throw new InvalidOperationException("sequence size greater than 2");
-        }
 
         if (seq.Count == 2)
         {
@@ -79,8 +73,6 @@ public class KMACwithSHAKE256_params : Asn1Encodable
         }
     }
 
-
-
     public int OutputLength
     {
         get { return outputLength; }
@@ -91,7 +83,6 @@ public class KMACwithSHAKE256_params : Asn1Encodable
         get { return Arrays.Clone(customizationString); }
     }
 
-
     public override Asn1Object ToAsn1Object()
     {
         Asn1EncodableVector v = new Asn1EncodableVector();
diff --git a/crypto/src/crypto/digests/CSHAKEDigest.cs b/crypto/src/crypto/digests/CSHAKEDigest.cs
index 5c42b4171..c070a47c2 100644
--- a/crypto/src/crypto/digests/CSHAKEDigest.cs
+++ b/crypto/src/crypto/digests/CSHAKEDigest.cs
@@ -1,15 +1,13 @@
-using Org.BouncyCastle.Utilities;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System;
+
+using Org.BouncyCastle.Utilities;
 
 namespace Org.BouncyCastle.Crypto.Digests
 {
     /// <summary>
     /// Customizable SHAKE function.
     /// </summary>
-    public class CSHAKEDigest : ShakeDigest
+    public class CShakeDigest : ShakeDigest
     {
         private static readonly byte[] padding = new byte[100];
         private readonly byte[] diff;
@@ -20,7 +18,7 @@ namespace Org.BouncyCastle.Crypto.Digests
         /// <param name="bitLength">bit length of the underlying SHAKE function, 128 or 256.</param>
         /// <param name="N">the function name string, note this is reserved for use by NIST. Avoid using it if not required.</param>
         /// <param name="S">the customization string - available for local use.</param>
-        public CSHAKEDigest(int bitLength, byte[] N, byte[] S) : base(bitLength)
+        public CShakeDigest(int bitLength, byte[] N, byte[] S) : base(bitLength)
         {
             if ((N == null || N.Length == 0) && (S == null || S.Length == 0))
             {
@@ -28,12 +26,11 @@ namespace Org.BouncyCastle.Crypto.Digests
             }
             else
             {
-                diff = Arrays.ConcatenateAll(XofUtils.leftEncode(rate / 8), encodeString(N), encodeString(S));
+                diff = Arrays.ConcatenateAll(XofUtilities.LeftEncode(rate / 8), encodeString(N), encodeString(S));
                 DiffPadAndAbsorb();
             }
         }
 
-
         // bytepad in SP 800-185
         private void DiffPadAndAbsorb()
         {
@@ -61,13 +58,16 @@ namespace Org.BouncyCastle.Crypto.Digests
         {
             if (str == null || str.Length == 0)
             {
-                return XofUtils.leftEncode(0);
+                return XofUtilities.LeftEncode(0);
             }
 
-            return Arrays.Concatenate(XofUtils.leftEncode(str.Length * 8L), str);
+            return Arrays.Concatenate(XofUtilities.LeftEncode(str.Length * 8L), str);
         }
 
-        public override string AlgorithmName => "CSHAKE" + fixedOutputLength;
+        public override string AlgorithmName
+        {
+            get { return "CSHAKE" + fixedOutputLength; }
+        }
 
         public override int DoFinal(byte[] output, int outOff)
         {           
@@ -102,7 +102,7 @@ namespace Org.BouncyCastle.Crypto.Digests
             }
         }
 
-        public void Reset()
+        public override void Reset()
         {
             base.Reset();
 
diff --git a/crypto/src/crypto/digests/XofUtils.cs b/crypto/src/crypto/digests/XofUtils.cs
index e4c893e01..5c197e0e6 100644
--- a/crypto/src/crypto/digests/XofUtils.cs
+++ b/crypto/src/crypto/digests/XofUtils.cs
@@ -1,13 +1,10 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace Org.BouncyCastle.Crypto.Digests
 {
-    public class XofUtils
+    internal class XofUtilities
     {
-        public static byte[] leftEncode(long strLen)
+        internal static byte[] LeftEncode(long strLen)
         {
             byte n = 1;
 
@@ -29,7 +26,7 @@ namespace Org.BouncyCastle.Crypto.Digests
             return b;
         }
 
-        public static byte[] rightEncode(long strLen)
+        internal static byte[] RightEncode(long strLen)
         {
             byte n = 1;
 
diff --git a/crypto/src/crypto/macs/KMac.cs b/crypto/src/crypto/macs/KMac.cs
index 38697a9a9..889131d8c 100644
--- a/crypto/src/crypto/macs/KMac.cs
+++ b/crypto/src/crypto/macs/KMac.cs
@@ -1,19 +1,18 @@
-using Org.BouncyCastle.Crypto.Digests;
+using System;
+using System.Text;
+
+using Org.BouncyCastle.Crypto.Digests;
 using Org.BouncyCastle.Crypto.Parameters;
 using Org.BouncyCastle.Utilities;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace Org.BouncyCastle.Crypto.Macs
 {
-    public class KMac : IMac, IXof
+    public class KMac
+        : IMac, IXof
     {
-
         private static readonly byte[] padding = new byte[100];
 
-        private readonly CSHAKEDigest cshake;
+        private readonly CShakeDigest cshake;
         private readonly int bitLength;
         private readonly int outputLength;
 
@@ -21,23 +20,22 @@ namespace Org.BouncyCastle.Crypto.Macs
         private bool initialised;
         private bool firstOutput;
 
-
         public KMac(int bitLength, byte[] S)
         {
-            this.cshake = new CSHAKEDigest(bitLength, Encoding.ASCII.GetBytes("KMAC"),S);
+            this.cshake = new CShakeDigest(bitLength, Encoding.ASCII.GetBytes("KMAC"), S);
             this.bitLength = bitLength;
             this.outputLength = bitLength * 2 / 8;
         }
 
-
-        public string AlgorithmName => "KMAC" + cshake.AlgorithmName.Substring(6);
+        public string AlgorithmName
+        {
+            get { return "KMAC" + cshake.AlgorithmName.Substring(6); }
+        }
 
         public void BlockUpdate(byte[] input, int inOff, int len)
         {
             if (!initialised)
-            {
                 throw new InvalidOperationException("KMAC not initialized");
-            }
 
             cshake.BlockUpdate(input, inOff, len);
         }
@@ -47,11 +45,9 @@ namespace Org.BouncyCastle.Crypto.Macs
             if (firstOutput)
             {
                 if (!initialised)
-                {
                     throw new InvalidOperationException("KMAC not initialized");
-                }
 
-                byte[] encOut = XofUtils.rightEncode(GetMacSize() * 8);
+                byte[] encOut = XofUtilities.RightEncode(GetMacSize() * 8);
 
                 cshake.BlockUpdate(encOut, 0, encOut.Length);
             }
@@ -68,11 +64,9 @@ namespace Org.BouncyCastle.Crypto.Macs
             if (firstOutput)
             {
                 if (!initialised)
-                {
                     throw new InvalidOperationException("KMAC not initialized");
-                }
 
-                byte[] encOut = XofUtils.rightEncode(outLen * 8);
+                byte[] encOut = XofUtilities.RightEncode(outLen * 8);
 
                 cshake.BlockUpdate(encOut, 0, encOut.Length);
             }
@@ -89,11 +83,9 @@ namespace Org.BouncyCastle.Crypto.Macs
             if (firstOutput)
             {
                 if (!initialised)
-                {
                     throw new InvalidOperationException("KMAC not initialized");
-                }
 
-                byte[] encOut = XofUtils.rightEncode(0);
+                byte[] encOut = XofUtilities.RightEncode(0);
 
                 cshake.BlockUpdate(encOut, 0, encOut.Length);
 
@@ -147,7 +139,7 @@ namespace Org.BouncyCastle.Crypto.Macs
 
         private void bytePad(byte[] X, int w)
         {
-            byte[] bytes = XofUtils.leftEncode(w);
+            byte[] bytes = XofUtilities.LeftEncode(w);
             BlockUpdate(bytes, 0, bytes.Length);
             byte[] encX = encode(X);
             BlockUpdate(encX, 0, encX.Length);
@@ -168,15 +160,13 @@ namespace Org.BouncyCastle.Crypto.Macs
 
         private static byte[] encode(byte[] X)
         {
-            return Arrays.Concatenate(XofUtils.leftEncode(X.Length * 8), X);
+            return Arrays.Concatenate(XofUtilities.LeftEncode(X.Length * 8), X);
         }
 
         public void Update(byte input)
         {
             if (!initialised)
-            {
                 throw new InvalidOperationException("KMAC not initialized");
-            }
 
             cshake.Update(input);
         }