import java.math.*;

import java.util.Optional;

import sun.security.util.ArrayUtil;

import sun.security.util.math.*;

import sun.security.ec.point.*;

    // public key, non-null between doPhase() & generateSecret() only

    private ECPublicKey publicKey;

        publicKey = null;

        if (publicKey != null) {

        this.publicKey = (ECPublicKey) key;

        ECParameterSpec params = publicKey.getParams();

    private static void validateCoordinate(BigInteger c, BigInteger mod) {

        if (c.compareTo(BigInteger.ZERO) < 0) {

            throw new ProviderException("invalid coordinate");

        }

        if (c.compareTo(mod) >= 0) {

            throw new ProviderException("invalid coordinate");

        }

    }

    /*

     * Check whether a public key is valid. Throw ProviderException

     * if it is not valid or could not be validated.

     */

    private static void validate(ECOperations ops, ECPublicKey key) {

        // ensure that integers are in proper range

        BigInteger x = key.getW().getAffineX();

        BigInteger y = key.getW().getAffineY();

        BigInteger p = ops.getField().getSize();

        validateCoordinate(x, p);

        validateCoordinate(y, p);

        // ensure the point is on the curve

        EllipticCurve curve = key.getParams().getCurve();

        BigInteger rhs = x.modPow(BigInteger.valueOf(3), p).add(curve.getA()

            .multiply(x)).add(curve.getB()).mod(p);

        BigInteger lhs = y.modPow(BigInteger.valueOf(2), p).mod(p);

        if (!rhs.equals(lhs)) {

            throw new ProviderException("point is not on curve");

        }

        // check the order of the point

        ImmutableIntegerModuloP xElem = ops.getField().getElement(x);

        ImmutableIntegerModuloP yElem = ops.getField().getElement(y);

        AffinePoint affP = new AffinePoint(xElem, yElem);

        byte[] order = key.getParams().getOrder().toByteArray();

        ArrayUtil.reverse(order);

        Point product = ops.multiply(affP, order);

        if (!ops.isNeutral(product)) {

            throw new ProviderException("point has incorrect order");

        }

    }

        if ((privateKey == null) || (publicKey == null)) {

        Optional<byte[]> resultOpt = deriveKeyImpl(privateKey, publicKey);

        byte[] result = resultOpt.orElseGet(

            () -> deriveKeyNative(privateKey, publicKey)

        );

        publicKey = null;

        return result;

                + " bytes, only " + (sharedSecret.length - offset)

                + " available");

    private static

    Optional<byte[]> deriveKeyImpl(ECPrivateKey priv, ECPublicKey pubKey) {

        ECParameterSpec ecSpec = priv.getParams();

        EllipticCurve curve = ecSpec.getCurve();

        Optional<ECOperations> opsOpt = ECOperations.forParameters(ecSpec);

        if (opsOpt.isEmpty()) {

            return Optional.empty();

        }

        ECOperations ops = opsOpt.get();

        if (! (priv instanceof ECPrivateKeyImpl)) {

            return Optional.empty();

        }

        ECPrivateKeyImpl privImpl = (ECPrivateKeyImpl) priv;

        byte[] sArr = privImpl.getArrayS();

        // to match the native implementation, validate the public key here

        // and throw ProviderException if it is invalid

        validate(ops, pubKey);

        IntegerFieldModuloP field = ops.getField();

        // convert s array into field element and multiply by the cofactor

        MutableIntegerModuloP scalar = field.getElement(sArr).mutable();

        SmallValue cofactor =

            field.getSmallValue(priv.getParams().getCofactor());

        scalar.setProduct(cofactor);

        int keySize = (curve.getField().getFieldSize() + 7) / 8;

        byte[] privArr = scalar.asByteArray(keySize);

        ImmutableIntegerModuloP x =

            field.getElement(pubKey.getW().getAffineX());

        ImmutableIntegerModuloP y =

            field.getElement(pubKey.getW().getAffineY());

        AffinePoint affPub = new AffinePoint(x, y);

        Point product = ops.multiply(affPub, privArr);

        if (ops.isNeutral(product)) {

            throw new ProviderException("Product is zero");

        }

        AffinePoint affProduct = product.asAffine();

        byte[] result = affProduct.getX().asByteArray(keySize);

        ArrayUtil.reverse(result);

        return Optional.of(result);

    }

    private static

    byte[] deriveKeyNative(ECPrivateKey privateKey, ECPublicKey publicKey) {

        ECParameterSpec params = privateKey.getParams();

        byte[] s = privateKey.getS().toByteArray();

        byte[] encodedParams =                   // DER OID

            ECUtil.encodeECParameterSpec(null, params);

        byte[] publicValue;

        if (publicKey instanceof ECPublicKeyImpl) {

            ECPublicKeyImpl ecPub = (ECPublicKeyImpl) publicKey;

            publicValue = ecPub.getEncodedPublicValue();

        } else { // instanceof ECPublicKey

            publicValue =

                ECUtil.encodePoint(publicKey.getW(), params.getCurve());

        }

        try {

            return deriveKey(s, publicValue, encodedParams);

        } catch (GeneralSecurityException e) {

            throw new ProviderException("Could not derive key", e);

        }

    }