content: /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License 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.
   */
  package org.apache.camel.quarkus.component.ssh.runtime;
  
  import java.security.*;
  import java.security.spec.InvalidKeySpecException;
  import java.security.spec.X509EncodedKeySpec;
  
  import com.oracle.svm.core.annotate.Alias;
  import com.oracle.svm.core.annotate.Substitute;
  import com.oracle.svm.core.annotate.TargetClass;
  import net.i2p.crypto.eddsa.EdDSAEngine;
  import net.i2p.crypto.eddsa.EdDSAKey;
  import net.i2p.crypto.eddsa.EdDSAPublicKey;
  
  /**
   * We're substituting those offending methods that would require the presence of
   * net.i2p.crypto:eddsa library which is not supported by Camel SSH component
   */
  @TargetClass(EdDSAEngine.class)
  final class SubstituteEdDSAEngine {
  
      @Alias
      private MessageDigest digest;
  
      @Alias
      private EdDSAKey key;
  
      @Alias
      private void reset() {
      }
  
      @Substitute
      protected void engineInitVerify(PublicKey publicKey) throws InvalidKeyException {
          reset();
          if (publicKey instanceof EdDSAPublicKey) {
              key = (EdDSAPublicKey) publicKey;
  
              if (digest == null) {
                  // Instantiate the digest from the key parameters
                  try {
                      digest = MessageDigest.getInstance(key.getParams().getHashAlgorithm());
                  } catch (NoSuchAlgorithmException e) {
                      throw new InvalidKeyException(
                              "cannot get required digest " + key.getParams().getHashAlgorithm() + " for private key.");
                  }
              } else if (!key.getParams().getHashAlgorithm().equals(digest.getAlgorithm()))
                  throw new InvalidKeyException("Key hash algorithm does not match chosen digest");
          } //following line differs from the original method
          else if (publicKey.getFormat().equals("X.509")) {
              // X509Certificate will sometimes contain an X509Key rather than the EdDSAPublicKey itself; the contained
              // key is valid but needs to be instanced as an EdDSAPublicKey before it can be used.
              EdDSAPublicKey parsedPublicKey;
              try {
                  parsedPublicKey = new EdDSAPublicKey(new X509EncodedKeySpec(publicKey.getEncoded()));
              } catch (InvalidKeySpecException ex) {
                  throw new InvalidKeyException("cannot handle X.509 EdDSA public key: " + publicKey.getAlgorithm());
              }
              engineInitVerify(parsedPublicKey);
          } else {
              throw new InvalidKeyException("cannot identify EdDSA public key: " + publicKey.getClass());
          }
      }
  }
  