EthSecpArtifactSigner to use compressed identifier or public key

Consensys · Oct 23, 2024 · 92108da · 92108da
1 parent 20daaad
commit 92108da
Show file tree

Hide file tree

Showing 12 changed files with 79 additions and 54 deletions.
diff --git a/...java/tech/pegasys/web3signer/tests/bulkloading/SecpV3KeystoresBulkLoadAcceptanceTest.java b/...java/tech/pegasys/web3signer/tests/bulkloading/SecpV3KeystoresBulkLoadAcceptanceTest.java
@@ -60,7 +60,8 @@ static void initV3Keystores() throws IOException, GeneralSecurityException, Ciph
     publicKeys = new ArrayList<>();
     for (int i = 0; i < 4; i++) {
       final ECKeyPair ecKeyPair = Keys.createEcKeyPair();
-      final ECPublicKey ecPublicKey = EthPublicKeyUtils.createPublicKey(ecKeyPair.getPublicKey());
+      final ECPublicKey ecPublicKey =
+          EthPublicKeyUtils.createPublicKeyFromBigInt(ecKeyPair.getPublicKey());
       final String publicKeyHex =
           IdentifierUtils.normaliseIdentifier(EthPublicKeyUtils.toHexString(ecPublicKey));
       publicKeys.add(publicKeyHex);

diff --git a/...sts/src/test/java/tech/pegasys/web3signer/tests/publickeys/YubiHsmKeysAcceptanceTest.java b/...sts/src/test/java/tech/pegasys/web3signer/tests/publickeys/YubiHsmKeysAcceptanceTest.java
@@ -121,7 +121,7 @@ private void createConfigurationFiles(final Set<Integer> opaqueDataIds, final Ke
   private String getPublicKey(final String key) {
     return normaliseIdentifier(
         EthPublicKeyUtils.toHexString(
-            EthPublicKeyUtils.createPublicKey(
+            EthPublicKeyUtils.createPublicKeyFromBigInt(
                 Credentials.create(key).getEcKeyPair().getPublicKey())));
   }
 }
diff --git a/...-tests/src/test/java/tech/pegasys/web3signer/tests/signing/SecpSigningAcceptanceTest.java b/...-tests/src/test/java/tech/pegasys/web3signer/tests/signing/SecpSigningAcceptanceTest.java
@@ -194,7 +194,8 @@ void verifySignature(final Bytes signature, final String publicKeyHex) {
     final byte[] s = signature.slice(32, 32).toArray();
     final byte[] v = signature.slice(64).toArray();
     final BigInteger messagePublicKey = recoverPublicKey(new SignatureData(v, r, s));
-    assertThat(EthPublicKeyUtils.createPublicKey(messagePublicKey)).isEqualTo(expectedPublicKey);
+    assertThat(EthPublicKeyUtils.createPublicKeyFromBigInt(messagePublicKey))
+        .isEqualTo(expectedPublicKey);
   }
 
   private BigInteger recoverPublicKey(final SignatureData signature) {

diff --git a/...ava/tech/pegasys/web3signer/core/service/http/handlers/commitboost/ProxyKeyGenerator.java b/...ava/tech/pegasys/web3signer/core/service/http/handlers/commitboost/ProxyKeyGenerator.java
@@ -62,7 +62,7 @@ public ArtifactSigner generateECProxyKey(final String identifier)
     final ECKeyPair ecKeyPair = Keys.createEcKeyPair(secureRandom);
     final Path ecWalletFile = createECWalletFile(ecKeyPair, identifier);
     LOG.debug("Created proxy EC wallet file {} for identifier: {}", ecWalletFile, identifier);
-    return new EthSecpArtifactSigner(new CredentialSigner(Credentials.create(ecKeyPair)));
+    return new EthSecpArtifactSigner(new CredentialSigner(Credentials.create(ecKeyPair)), true);
   }
 
   public ArtifactSigner generateBLSProxyKey(final String identifier) throws UncheckedIOException {

diff --git a/...va/tech/pegasys/web3signer/core/service/jsonrpc/EthSignTransactionResultProviderTest.java b/...va/tech/pegasys/web3signer/core/service/jsonrpc/EthSignTransactionResultProviderTest.java
@@ -108,7 +108,8 @@ public void ifAddressIsNotUnlockedExceptionIsThrownWithSigningNotUnlocked() {
   public void signatureHasTheExpectedFormat() {
     final Credentials cs =
         Credentials.create("0x1618fc3e47aec7e70451256e033b9edb67f4c469258d8e2fbb105552f141ae41");
-    final ECPublicKey key = EthPublicKeyUtils.createPublicKey(cs.getEcKeyPair().getPublicKey());
+    final ECPublicKey key =
+        EthPublicKeyUtils.createPublicKeyFromBigInt(cs.getEcKeyPair().getPublicKey());
     final String addr = Keys.getAddress(EthPublicKeyUtils.toHexString(key));
 
     final BigInteger v = BigInteger.ONE;
@@ -169,7 +170,8 @@ public void returnsExpectedSignatureForEip1559Transaction() {
   private String executeEthSignTransaction(final JsonObject params) {
     final Credentials cs =
         Credentials.create("0x1618fc3e47aec7e70451256e033b9edb67f4c469258d8e2fbb105552f141ae41");
-    final ECPublicKey key = EthPublicKeyUtils.createPublicKey(cs.getEcKeyPair().getPublicKey());
+    final ECPublicKey key =
+        EthPublicKeyUtils.createPublicKeyFromBigInt(cs.getEcKeyPair().getPublicKey());
     final String addr = Keys.getAddress(EthPublicKeyUtils.toHexString(key));
 
     doAnswer(

diff --git a/signing/src/main/java/tech/pegasys/web3signer/signing/EthSecpArtifactSigner.java b/signing/src/main/java/tech/pegasys/web3signer/signing/EthSecpArtifactSigner.java
@@ -22,15 +22,23 @@
 
 public class EthSecpArtifactSigner implements ArtifactSigner {
   private final Signer signer;
+  private final boolean isCompressed;
 
   public EthSecpArtifactSigner(final Signer signer) {
     this.signer = signer;
+    this.isCompressed = false;
+  }
+
+  public EthSecpArtifactSigner(final Signer signer, final boolean isCompressed) {
+    this.signer = signer;
+    this.isCompressed = isCompressed;
   }
 
   @Override
   public String getIdentifier() {
-    return IdentifierUtils.normaliseIdentifier(
-        EthPublicKeyUtils.toHexString(signer.getPublicKey()));
+    final String hexString =
+        EthPublicKeyUtils.getEncoded(signer.getPublicKey(), isCompressed, false).toHexString();
+    return IdentifierUtils.normaliseIdentifier(hexString);
   }
 
   @Override

diff --git a/.../src/main/java/tech/pegasys/web3signer/signing/bulkloading/SecpV3KeystoresBulkLoader.java b/.../src/main/java/tech/pegasys/web3signer/signing/bulkloading/SecpV3KeystoresBulkLoader.java
@@ -36,6 +36,11 @@ public class SecpV3KeystoresBulkLoader {
 
   public static MappedResults<ArtifactSigner> loadV3KeystoresUsingPasswordFileOrDir(
       final Path keystoresPath, final Path pwrdFileOrDirPath) {
+    return loadV3KeystoresUsingPasswordFileOrDir(keystoresPath, pwrdFileOrDirPath, false);
+  }
+
+  public static MappedResults<ArtifactSigner> loadV3KeystoresUsingPasswordFileOrDir(
+      final Path keystoresPath, final Path pwrdFileOrDirPath, final boolean isCompressed) {
     if (!Files.exists(pwrdFileOrDirPath)) {
       LOG.error("Password file or directory doesn't exist.");
       return MappedResults.errorResult();
@@ -67,12 +72,12 @@ public static MappedResults<ArtifactSigner> loadV3KeystoresUsingPasswordFileOrDi
     }
 
     return keystoresFiles.parallelStream()
-        .map(keystoreFile -> createSecpArtifactSigner(keystoreFile, passwordReader))
+        .map(keystoreFile -> createSecpArtifactSigner(keystoreFile, passwordReader, isCompressed))
         .reduce(MappedResults.newSetInstance(), MappedResults::merge);
   }
 
   private static MappedResults<ArtifactSigner> createSecpArtifactSigner(
-      final Path v3KeystorePath, final PasswordReader passwordReader) {
+      final Path v3KeystorePath, final PasswordReader passwordReader, final boolean isCompressed) {
     try {
       final String fileNameWithoutExt =
           FilenameUtils.removeExtension(v3KeystorePath.getFileName().toString());
@@ -82,7 +87,7 @@ private static MappedResults<ArtifactSigner> createSecpArtifactSigner(
       final Credentials credentials =
           WalletUtils.loadCredentials(password, v3KeystorePath.toFile());
       final EthSecpArtifactSigner artifactSigner =
-          new EthSecpArtifactSigner(new CredentialSigner(credentials));
+          new EthSecpArtifactSigner(new CredentialSigner(credentials), isCompressed);
       return MappedResults.newInstance(Set.of(artifactSigner), 0);
     } catch (final IOException | CipherException | RuntimeException e) {
       LOG.error("Error loading v3 keystore {}", v3KeystorePath, e);

diff --git a/...g/src/main/java/tech/pegasys/web3signer/signing/config/DefaultArtifactSignerProvider.java b/...g/src/main/java/tech/pegasys/web3signer/signing/config/DefaultArtifactSignerProvider.java
@@ -77,41 +77,44 @@ public Future<Void> load() {
                 if (!keystoreParameter.isEnabled()) {
                   return;
                 }
-                signers.forEach(
-                    (identifier, __) -> {
-                      final Path identifierPath =
-                          keystoreParameter.getKeystoresPath().resolve(identifier);
-                      if (identifierPath.toFile().canRead()
-                          && identifierPath.toFile().isDirectory()) {
-                        final Path v4Dir = identifierPath.resolve("v4");
-
-                        if (v4Dir.toFile().canRead() && v4Dir.toFile().isDirectory()) {
-                          // load v4 proxy signers
-                          final BlsKeystoreBulkLoader v4Loader = new BlsKeystoreBulkLoader();
-                          final MappedResults<ArtifactSigner> blsSignersResult =
-                              v4Loader.loadKeystoresUsingPasswordFile(
-                                  v4Dir, keystoreParameter.getKeystoresPasswordFile());
-                          final Collection<ArtifactSigner> blsSigners =
-                              blsSignersResult.getValues();
-                          proxySigners
-                              .computeIfAbsent(identifier, k -> new ArrayList<>())
-                              .addAll(blsSigners);
-                        }
-
-                        final Path v3Dir = identifierPath.resolve("v3");
-                        if (v3Dir.toFile().canRead() && v3Dir.toFile().isDirectory()) {
-                          // load v3 proxy signers
-                          final MappedResults<ArtifactSigner> secpSignersResults =
-                              SecpV3KeystoresBulkLoader.loadV3KeystoresUsingPasswordFileOrDir(
-                                  v3Dir, keystoreParameter.getKeystoresPasswordFile());
-                          final Collection<ArtifactSigner> secpSigners =
-                              secpSignersResults.getValues();
-                          proxySigners
-                              .computeIfAbsent(identifier, k -> new ArrayList<>())
-                              .addAll(secpSigners);
-                        }
-                      }
-                    });
+
+                signers
+                    .keySet()
+                    .forEach(
+                        identifier -> {
+                          final Path identifierPath =
+                              keystoreParameter.getKeystoresPath().resolve(identifier);
+                          if (identifierPath.toFile().canRead()
+                              && identifierPath.toFile().isDirectory()) {
+                            final Path v4Dir = identifierPath.resolve("v4");
+
+                            if (v4Dir.toFile().canRead() && v4Dir.toFile().isDirectory()) {
+                              // load v4 proxy signers
+                              final BlsKeystoreBulkLoader v4Loader = new BlsKeystoreBulkLoader();
+                              final MappedResults<ArtifactSigner> blsSignersResult =
+                                  v4Loader.loadKeystoresUsingPasswordFile(
+                                      v4Dir, keystoreParameter.getKeystoresPasswordFile());
+                              final Collection<ArtifactSigner> blsSigners =
+                                  blsSignersResult.getValues();
+                              proxySigners
+                                  .computeIfAbsent(identifier, k -> new ArrayList<>())
+                                  .addAll(blsSigners);
+                            }
+
+                            final Path v3Dir = identifierPath.resolve("v3");
+                            if (v3Dir.toFile().canRead() && v3Dir.toFile().isDirectory()) {
+                              // load v3 proxy signers (compressed pub key).
+                              final MappedResults<ArtifactSigner> secpSignersResults =
+                                  SecpV3KeystoresBulkLoader.loadV3KeystoresUsingPasswordFileOrDir(
+                                      v3Dir, keystoreParameter.getKeystoresPasswordFile(), true);
+                              final Collection<ArtifactSigner> secpSigners =
+                                  secpSignersResults.getValues();
+                              proxySigners
+                                  .computeIfAbsent(identifier, k -> new ArrayList<>())
+                                  .addAll(secpSigners);
+                            }
+                          }
+                        });
               });
 
           LOG.info("Total signers (keys) currently loaded in memory: {}", signers.size());

diff --git a/signing/src/main/java/tech/pegasys/web3signer/signing/secp256k1/EthPublicKeyUtils.java b/signing/src/main/java/tech/pegasys/web3signer/signing/secp256k1/EthPublicKeyUtils.java
@@ -128,7 +128,7 @@ private static ECPublicKey createPublicKeyFromPoint(final ECPoint point) {
    * @return The created ECPublicKey
    * @throws IllegalArgumentException if the input is invalid
    */
-  public static ECPublicKey createPublicKey(final BigInteger publicKeyValue) {
+  public static ECPublicKey createPublicKeyFromBigInt(final BigInteger publicKeyValue) {
     if (publicKeyValue == null) {
       throw new IllegalArgumentException("Public key value cannot be null");
     }

diff --git a/...g/src/main/java/tech/pegasys/web3signer/signing/secp256k1/filebased/CredentialSigner.java b/...g/src/main/java/tech/pegasys/web3signer/signing/secp256k1/filebased/CredentialSigner.java
@@ -31,7 +31,8 @@ public class CredentialSigner implements Signer {
 
   public CredentialSigner(final Credentials credentials, final boolean needToHash) {
     this.credentials = credentials;
-    this.publicKey = EthPublicKeyUtils.createPublicKey(credentials.getEcKeyPair().getPublicKey());
+    this.publicKey =
+        EthPublicKeyUtils.createPublicKeyFromBigInt(credentials.getEcKeyPair().getPublicKey());
     this.needToHash = needToHash;
   }
 

diff --git a/...c/test/java/tech/pegasys/web3signer/signing/config/DefaultArtifactSignerProviderTest.java b/...c/test/java/tech/pegasys/web3signer/signing/config/DefaultArtifactSignerProviderTest.java
@@ -143,15 +143,15 @@ void proxySignersAreLoadedCorrectly() throws IOException {
     assertThat(key1ProxyPublicKeys.get(KeyType.BLS))
         .containsExactlyInAnyOrder(getPublicKeysArray(key1ProxyKeyPairs));
     assertThat(key1ProxyPublicKeys.get(KeyType.SECP256K1))
-        .containsExactlyInAnyOrder(getSecpPublicKeysArray(key1SecpKeyPairs));
+        .containsExactlyInAnyOrder(getCompressedSecpPublicKeysArray(key1SecpKeyPairs));
 
     final Map<KeyType, List<String>> key2ProxyPublicKeys =
         signerProvider.getProxyIdentifiers(PUBLIC_KEY2);
 
     assertThat(key2ProxyPublicKeys.get(KeyType.BLS))
         .containsExactlyInAnyOrder(getPublicKeysArray(key2ProxyKeyPairs));
     assertThat(key2ProxyPublicKeys.get(KeyType.SECP256K1))
-        .containsExactlyInAnyOrder(getSecpPublicKeysArray(key2SecpKeyPairs));
+        .containsExactlyInAnyOrder(getCompressedSecpPublicKeysArray(key2SecpKeyPairs));
   }
 
   @Test
@@ -223,12 +223,16 @@ private static String[] getPublicKeysArray(final List<BLSKeyPair> blsKeyPairs) {
         .toArray(String[]::new);
   }
 
-  private static String[] getSecpPublicKeysArray(final List<ECKeyPair> ecKeyPairs) {
+  private static String[] getCompressedSecpPublicKeysArray(final List<ECKeyPair> ecKeyPairs) {
+    // compressed public keys
     return ecKeyPairs.stream()
         .map(
             keyPair ->
-                EthPublicKeyUtils.toHexString(
-                    EthPublicKeyUtils.createPublicKey(keyPair.getPublicKey())))
+                EthPublicKeyUtils.getEncoded(
+                        EthPublicKeyUtils.createPublicKeyFromBigInt(keyPair.getPublicKey()),
+                        true,
+                        false)
+                    .toHexString())
         .toList()
         .toArray(String[]::new);
   }

diff --git a/signing/src/test/java/tech/pegasys/web3signer/signing/secp256k1/EthPublicKeyUtilsTest.java b/signing/src/test/java/tech/pegasys/web3signer/signing/secp256k1/EthPublicKeyUtilsTest.java
@@ -60,7 +60,7 @@ public void createsPublicKeyFromBytes() {
   @Test
   public void createsPublicKeyFromBigInteger() {
     final BigInteger publicKey = Numeric.toBigInt(PUBLIC_KEY);
-    final ECPublicKey ecPublicKey = EthPublicKeyUtils.createPublicKey(publicKey);
+    final ECPublicKey ecPublicKey = EthPublicKeyUtils.createPublicKeyFromBigInt(publicKey);
 
     final Bytes expectedPublicKeyBytes = Bytes.fromHexString(PUBLIC_KEY);
     final ECPoint expectedEcPoint = createEcPoint(expectedPublicKeyBytes);