Use own implementation of hex encoding instead of Guava

This implementation is also consistently faster than Guava's, as
measured by `BinaryUtilBenchmark`:

```
Benchmark                             Mode  Cnt        Score       Error  Units  Impl
BinaryUtilBenchmark.fromHexLong1024  thrpt   50   301818.344 ±  1823.327  ops/s  BEFORE
BinaryUtilBenchmark.fromHexLong1024  thrpt   50   436189.249 ±  7222.349  ops/s  AFTER

BinaryUtilBenchmark.fromHexLong128   thrpt   50  2547578.209 ± 36429.270  ops/s  BEFORE
BinaryUtilBenchmark.fromHexLong128   thrpt   50  3424637.978 ± 74009.099  ops/s  AFTER

BinaryUtilBenchmark.fromHexLong2048  thrpt   50   155698.523 ±  1851.933  ops/s  BEFORE
BinaryUtilBenchmark.fromHexLong2048  thrpt   50   213877.472 ±  6278.015  ops/s  AFTER

BinaryUtilBenchmark.fromHexLong256   thrpt   50  1263837.915 ± 15008.090  ops/s  BEFORE
BinaryUtilBenchmark.fromHexLong256   thrpt   50  1755787.013 ± 34779.702  ops/s  AFTER

BinaryUtilBenchmark.fromHexLong512   thrpt   50   612113.541 ±  9002.875  ops/s  BEFORE
BinaryUtilBenchmark.fromHexLong512   thrpt   50   865881.718 ± 20505.584  ops/s  AFTER

BinaryUtilBenchmark.fromHexShort     thrpt   50  1684110.673 ± 13361.998  ops/s  BEFORE
BinaryUtilBenchmark.fromHexShort     thrpt   50  3068635.083 ± 19792.031  ops/s  AFTER

BinaryUtilBenchmark.toHexLong1024    thrpt   50   123499.030 ±  1958.386  ops/s  BEFORE
BinaryUtilBenchmark.toHexLong1024    thrpt   50   489521.929 ±  8109.498  ops/s  AFTER

BinaryUtilBenchmark.toHexLong128     thrpt   50  1262978.123 ± 78118.670  ops/s  BEFORE
BinaryUtilBenchmark.toHexLong128     thrpt   50  4992184.518 ± 54967.597  ops/s  AFTER

BinaryUtilBenchmark.toHexLong2048    thrpt   50    60673.623 ±   954.492  ops/s  BEFORE
BinaryUtilBenchmark.toHexLong2048    thrpt   50   261067.839 ±  5633.761  ops/s  AFTER

BinaryUtilBenchmark.toHexLong256     thrpt   50   508383.710 ±  5657.270  ops/s  BEFORE
BinaryUtilBenchmark.toHexLong256     thrpt   50  2190927.893 ± 16407.648  ops/s  AFTER

BinaryUtilBenchmark.toHexLong512     thrpt   50   252395.165 ±  2757.667  ops/s  BEFORE
BinaryUtilBenchmark.toHexLong512     thrpt   50  1008894.819 ±  7572.435  ops/s  AFTER

BinaryUtilBenchmark.toHexShort       thrpt   50  1205170.498 ± 11219.835  ops/s  BEFORE
BinaryUtilBenchmark.toHexShort       thrpt   50  2579415.167 ± 13612.182  ops/s  AFTER
```

Author: emlun

webauthn-server-demo/src/main/java/com/yubico/webauthn/attestation/matcher/ExtensionMatcher.java

@@ -69,9 +69,7 @@ public boolean matches(X509Certificate attestationCertificate, JsonNode paramete
           }
         } catch (IOException e) {
           log.error(
-              "Failed to parse extension value as ASN1: {}",
-              new ByteArray(extensionValue),
-              e);
+              "Failed to parse extension value as ASN1: {}", new ByteArray(extensionValue), e);
         }
       }
     }

yubico-util/build.gradle.kts

@@ -25,7 +25,6 @@ dependencies {
   implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-cbor")
   implementation("com.fasterxml.jackson.datatype:jackson-datatype-jdk8")
   implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310")
-  implementation("com.google.guava:guava")
   implementation("com.upokecenter:cbor")
   implementation("org.slf4j:slf4j-api")
 

yubico-util/src/main/java/com/yubico/internal/util/BinaryUtil.java

@@ -24,7 +24,6 @@
 
 package com.yubico.internal.util;
 
-import com.google.common.io.BaseEncoding;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.ByteBuffer;
@@ -40,15 +39,33 @@ public static byte[] copy(byte[] bytes) {
   /**
    * @param bytes Bytes to encode
    */
-  public static String toHex(byte[] bytes) {
-    return BaseEncoding.base16().encode(bytes).toLowerCase();
+  public static String toHex(final byte[] bytes) {
+    final char[] digits = new char[bytes.length * 2];
+    for (int i = 0; i < bytes.length; ++i) {
+      final int i2 = i * 2;
+      digits[i2] = Character.forDigit((bytes[i] >> 4) & 0x0f, 16);
+      digits[i2 + 1] = Character.forDigit(bytes[i] & 0x0f, 16);
+    }
+    return new String(digits);
   }
 
   /**
    * @param hex String of hexadecimal digits to decode as bytes.
    */
-  public static byte[] fromHex(String hex) {
-    return BaseEncoding.base16().decode(hex.toUpperCase());
+  public static byte[] fromHex(final String hex) {
+    if (hex.length() % 2 != 0) {
+      throw new IllegalArgumentException("Length of hex string is not even: " + hex);
+    }
+
+    final byte[] result = new byte[hex.length() / 2];
+    for (int i = 0; i < hex.length(); ++i) {
+      final int d = Character.digit(hex.charAt(i), 16);
+      if (d < 0) {
+        throw new IllegalArgumentException("Invalid hex digit at index " + i + " in: " + hex);
+      }
+      result[i / 2] |= d << (((i + 1) % 2) * 4);
+    }
+    return result;
   }
 
   /**