5 files changed, 115 insertions, 100 deletions

diff --git a/src/cz/crcs/ectester/common/util/ECUtil.java b/src/cz/crcs/ectester/common/util/ECUtil.java
index 511f93f..75a75fc 100644
--- a/src/cz/crcs/ectester/common/util/ECUtil.java
+++ b/src/cz/crcs/ectester/common/util/ECUtil.java
@@ -9,12 +9,14 @@ import org.bouncycastle.asn1.DERSequence;
 import org.bouncycastle.asn1.DERSequenceParser;
 import org.bouncycastle.crypto.digests.SHA1Digest;
 
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
 import java.security.KeyPair;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
+import java.security.interfaces.ECKey;
 import java.security.interfaces.ECPrivateKey;
 import java.security.interfaces.ECPublicKey;
 import java.security.spec.*;
@@ -213,13 +215,13 @@ public class ECUtil {
         return toByteArray(priv, curve.getBits());
     }
 
-    private static ECPoint toPoint(EC_Params params) {
+    public static ECPoint toPoint(EC_Params params) {
         return new ECPoint(
                 new BigInteger(1, params.getParam(EC_Consts.PARAMETER_W)[0]),
                 new BigInteger(1, params.getParam(EC_Consts.PARAMETER_W)[1]));
     }
 
-    private static BigInteger toScalar(EC_Params params) {
+    public static BigInteger toScalar(EC_Params params) {
         return new BigInteger(1, params.getParam(EC_Consts.PARAMETER_S)[0]);
     }
 
@@ -290,4 +292,41 @@ public class ECUtil {
             return null;
         }
     }
+
+    public static EC_Params loadParams(short params, String named, String file) throws IOException {
+        EC_Params result = null;
+        if (file != null) {
+            result = new EC_Params(params);
+
+            FileInputStream in = new FileInputStream(file);
+            result.readCSV(in);
+            in.close();
+        } else {
+            if (params == EC_Consts.PARAMETER_W) {
+                result = EC_Store.getInstance().getObject(EC_Key.Public.class, named);
+            } else if (params == EC_Consts.PARAMETER_S) {
+                result = EC_Store.getInstance().getObject(EC_Key.Private.class, named);
+            }
+
+            if (result == null) {
+                result = EC_Store.getInstance().getObject(EC_Keypair.class, named);
+            }
+        }
+        return result;
+    }
+
+    public static ECKey loadKey(short params, String named, String file, ECParameterSpec spec) throws IOException {
+        if (params == EC_Consts.PARAMETERS_KEYPAIR) {
+            throw new IllegalArgumentException();
+        }
+        EC_Params param = loadParams(params, named, file);
+        if (param != null) {
+            if (params == EC_Consts.PARAMETER_W) {
+                return new RawECPublicKey(toPoint(param), spec);
+            } else if (params == EC_Consts.PARAMETER_S) {
+                return new RawECPrivateKey(toScalar(param), spec);
+            }
+        }
+        return null;
+    }
 }
diff --git a/src/cz/crcs/ectester/reader/command/Command.java b/src/cz/crcs/ectester/reader/command/Command.java
index b5b9393..1789451 100644
--- a/src/cz/crcs/ectester/reader/command/Command.java
+++ b/src/cz/crcs/ectester/reader/command/Command.java
@@ -3,11 +3,10 @@ package cz.crcs.ectester.reader.command;
 import cz.crcs.ectester.applet.ECTesterApplet;
 import cz.crcs.ectester.applet.EC_Consts;
 import cz.crcs.ectester.common.ec.EC_Curve;
-import cz.crcs.ectester.common.ec.EC_Key;
-import cz.crcs.ectester.common.ec.EC_Keypair;
 import cz.crcs.ectester.common.ec.EC_Params;
 import cz.crcs.ectester.common.util.ByteUtil;
 import cz.crcs.ectester.common.util.CardUtil;
+import cz.crcs.ectester.common.util.ECUtil;
 import cz.crcs.ectester.data.EC_Store;
 import cz.crcs.ectester.reader.CardMngr;
 import cz.crcs.ectester.reader.ECTesterReader;
@@ -60,12 +59,12 @@ public abstract class Command implements Cloneable {
         return (Command) super.clone();
     }
 
-    public static EC_Curve findCurve(EC_Store dataStore, ECTesterReader.Config cfg, short keyLength, byte keyClass) throws IOException {
+    public static EC_Curve findCurve(ECTesterReader.Config cfg, short keyLength, byte keyClass) throws IOException {
         if (cfg.customCurve) {
             byte curveId = EC_Consts.getCurve(keyLength, keyClass);
-            return dataStore.getObject(EC_Curve.class, "secg", CardUtil.getCurveName(curveId));
+            return EC_Store.getInstance().getObject(EC_Curve.class, "secg", CardUtil.getCurveName(curveId));
         } else if (cfg.namedCurve != null) {
-            EC_Curve curve = dataStore.getObject(EC_Curve.class, cfg.namedCurve);
+            EC_Curve curve = EC_Store.getInstance().getObject(EC_Curve.class, cfg.namedCurve);
             if (curve == null) {
                 throw new IOException("Curve could no be found.");
             }
@@ -96,14 +95,14 @@ public abstract class Command implements Cloneable {
      * @return a Command to send in order to prepare the curve on the keypairs.
      * @throws IOException if curve file cannot be found/opened
      */
-    public static Command prepareCurve(CardMngr cardManager, EC_Store dataStore, ECTesterReader.Config cfg, byte keyPair, short keyLength, byte keyClass) throws IOException {
+    public static Command prepareCurve(CardMngr cardManager, ECTesterReader.Config cfg, byte keyPair, short keyLength, byte keyClass) throws IOException {
         if (cfg.customCurve) {
             // Set custom curve (one of the SECG curves embedded applet-side)
             short domainParams = keyClass == KeyPair.ALG_EC_FP ? EC_Consts.PARAMETERS_DOMAIN_FP : EC_Consts.PARAMETERS_DOMAIN_F2M;
             return new Command.Set(cardManager, keyPair, EC_Consts.getCurve(keyLength, keyClass), domainParams, null);
         }
 
-        EC_Curve curve = findCurve(dataStore, cfg, keyLength, keyClass);
+        EC_Curve curve = findCurve(cfg, keyLength, keyClass);
         if ((curve == null || curve.flatten() == null) && (cfg.namedCurve != null || cfg.curveFile != null)) {
             if (cfg.namedCurve != null) {
                 throw new IOException("Couldn't read named curve data.");
@@ -117,7 +116,11 @@ public abstract class Command implements Cloneable {
 
 
     /**
-     * @param keyPair which keyPair/s to set the key params on
+     * @param cardManager
+     * @param dataStore
+     * @param cfg
+     * @param keyPair       which keyPair/s to set the key params on
+     * @param allowedParams
      * @return a CommandAPDU setting params loaded on the keyPair/s
      * @throws IOException if any of the key files cannot be found/opened
      */
@@ -127,16 +130,7 @@ public abstract class Command implements Cloneable {
 
         if (cfg.key != null || cfg.namedKey != null) {
             params |= EC_Consts.PARAMETERS_KEYPAIR;
-            EC_Params keypair;
-            if (cfg.key != null) {
-                keypair = new EC_Params(EC_Consts.PARAMETERS_KEYPAIR);
-
-                FileInputStream in = new FileInputStream(cfg.key);
-                keypair.readCSV(in);
-                in.close();
-            } else {
-                keypair = dataStore.getObject(EC_Keypair.class, cfg.namedKey);
-            }
+            EC_Params keypair = ECUtil.loadParams(EC_Consts.PARAMETERS_KEYPAIR, cfg.namedKey, cfg.key);
             if (keypair == null) {
                 throw new IOException("KeyPair not found.");
             }
@@ -147,21 +141,9 @@ public abstract class Command implements Cloneable {
             }
         }
 
-        if ((cfg.publicKey != null || cfg.namedPublicKey != null) && ((allowedParams & EC_Consts.PARAMETER_W )!= 0)) {
+        if ((cfg.publicKey != null || cfg.namedPublicKey != null) && ((allowedParams & EC_Consts.PARAMETER_W) != 0)) {
             params |= EC_Consts.PARAMETER_W;
-            EC_Params pub;
-            if (cfg.publicKey != null) {
-                pub = new EC_Params(EC_Consts.PARAMETER_W);
-
-                FileInputStream in = new FileInputStream(cfg.publicKey);
-                pub.readCSV(in);
-                in.close();
-            } else {
-                pub = dataStore.getObject(EC_Key.Public.class, cfg.namedPublicKey);
-                if (pub == null) {
-                    pub = dataStore.getObject(EC_Keypair.class, cfg.namedPublicKey);
-                }
-            }
+            EC_Params pub = ECUtil.loadParams(EC_Consts.PARAMETER_W, cfg.namedPublicKey, cfg.publicKey);
             if (pub == null) {
                 throw new IOException("Public key not found.");
             }
@@ -172,21 +154,10 @@ public abstract class Command implements Cloneable {
             }
             data = pubkey;
         }
-        if ((cfg.privateKey != null || cfg.namedPrivateKey != null) && ((allowedParams & EC_Consts.PARAMETER_S )!= 0)) {
-            params |= EC_Consts.PARAMETER_S;
-            EC_Params priv;
-            if (cfg.privateKey != null) {
-                priv = new EC_Params(EC_Consts.PARAMETER_S);
 
-                FileInputStream in = new FileInputStream(cfg.privateKey);
-                priv.readCSV(in);
-                in.close();
-            } else {
-                priv = dataStore.getObject(EC_Key.Private.class, cfg.namedPrivateKey);
-                if (priv == null) {
-                    priv = dataStore.getObject(EC_Keypair.class, cfg.namedPrivateKey);
-                }
-            }
+        if ((cfg.privateKey != null || cfg.namedPrivateKey != null) && ((allowedParams & EC_Consts.PARAMETER_S) != 0)) {
+            params |= EC_Consts.PARAMETER_S;
+            EC_Params priv = ECUtil.loadParams(EC_Consts.PARAMETER_S, cfg.namedPrivateKey, cfg.privateKey);
             if (priv == null) {
                 throw new IOException("Private key not found.");
             }
diff --git a/src/cz/crcs/ectester/reader/response/Response.java b/src/cz/crcs/ectester/reader/response/Response.java
index 6232423..53a757b 100644
--- a/src/cz/crcs/ectester/reader/response/Response.java
+++ b/src/cz/crcs/ectester/reader/response/Response.java
@@ -376,6 +376,14 @@ public abstract class Response {
             parse(1, (export == ECTesterApplet.EXPORT_TRUE) ? 1 : 0);
         }
 
+        public short getTransformation() {
+            return transformation;
+        }
+
+        public byte getType() {
+            return type;
+        }
+
         public boolean hasSecret() {
             return hasParam(0);
         }
diff --git a/src/cz/crcs/ectester/reader/test/CardTestVectorSuite.java b/src/cz/crcs/ectester/reader/test/CardTestVectorSuite.java
index 690425d..3c4378a 100644
--- a/src/cz/crcs/ectester/reader/test/CardTestVectorSuite.java
+++ b/src/cz/crcs/ectester/reader/test/CardTestVectorSuite.java
@@ -163,14 +163,16 @@ public class CardTestVectorSuite extends CardTestSuite {
                     try {
                         ka.init(privKey);
                         ka.doPhase(pubKey, true);
-                        byte[] rawDerived = ka.generateSecret();
+                        byte[] derived = ka.generateSecret();
                         int fieldSize = (curve.getBits() + 7) / 8;
-                        if (rawDerived.length < fieldSize) {
+                        if (derived.length < fieldSize) {
                             byte[] padded = new byte[fieldSize];
-                            System.arraycopy(rawDerived, 0, padded, fieldSize - rawDerived.length, rawDerived.length);
-                            rawDerived = padded;
+                            System.arraycopy(derived, 0, padded, fieldSize - derived.length, derived.length);
+                            derived = padded;
+                        }
+                        if (ecdhData.getType() == EC_Consts.KeyAgreement_ALG_EC_SVDP_DH) {
+                            derived = md.digest(derived);
                         }
-                        byte[] derived = md.digest(rawDerived);
                         if (secret.length != derived.length) {
                             if (secret.length < derived.length) {
                                 return new Result(Value.FAILURE, String.format("Derived secret was shorter than expected: %d vs %d (expected).", secret.length, derived.length));
@@ -190,6 +192,7 @@ public class CardTestVectorSuite extends CardTestSuite {
                 }
             };
             Test ecdhTest = CommandTest.function(new Command.ECDH(this.card, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.KEYPAIR_REMOTE, ECTesterApplet.EXPORT_TRUE, EC_Consts.TRANSFORMATION_NONE, EC_Consts.KeyAgreement_ALG_EC_SVDP_DH), kaCallback);
+            Test ecdhRawTest = CommandTest.function(new Command.ECDH(this.card, ECTesterApplet.KEYPAIR_LOCAL, ECTesterApplet.KEYPAIR_REMOTE, ECTesterApplet.EXPORT_TRUE, EC_Consts.TRANSFORMATION_NONE, EC_Consts.KeyAgreement_ALG_EC_SVDP_DH_PLAIN), kaCallback);
             byte[] data = new byte[32];
             TestCallback<CommandTestable> sigCallback = new TestCallback<CommandTestable>() {
                 @Override
@@ -222,7 +225,7 @@ public class CardTestVectorSuite extends CardTestSuite {
                 }
             };
             Test ecdsaTest = CommandTest.function(new Command.ECDSA_sign(this.card, ECTesterApplet.KEYPAIR_LOCAL, EC_Consts.Signature_ALG_ECDSA_SHA, ECTesterApplet.EXPORT_TRUE, data), sigCallback);
-            testVector.add(CompoundTest.all(ExpectedValue.SUCCESS, "", ecdhTest, ecdsaTest));
+            testVector.add(CompoundTest.all(ExpectedValue.SUCCESS, "Test.", ecdhTest, ecdhRawTest, ecdsaTest));
             if (cfg.cleanup) {
                 testVector.add(CommandTest.expect(new Command.Cleanup(this.card), ExpectedValue.ANY));
             }
diff --git a/src/cz/crcs/ectester/standalone/ECTesterStandalone.java b/src/cz/crcs/ectester/standalone/ECTesterStandalone.java
index d61475c..35db7da 100644
--- a/src/cz/crcs/ectester/standalone/ECTesterStandalone.java
+++ b/src/cz/crcs/ectester/standalone/ECTesterStandalone.java
@@ -22,10 +22,9 @@
  */
 package cz.crcs.ectester.standalone;
 
+import cz.crcs.ectester.applet.EC_Consts;
 import cz.crcs.ectester.common.cli.*;
 import cz.crcs.ectester.common.ec.EC_Curve;
-import cz.crcs.ectester.common.ec.EC_Key;
-import cz.crcs.ectester.common.ec.EC_Keypair;
 import cz.crcs.ectester.common.output.TestWriter;
 import cz.crcs.ectester.common.test.TestException;
 import cz.crcs.ectester.common.util.ByteUtil;
@@ -41,10 +40,7 @@ import cz.crcs.ectester.standalone.output.XMLTestWriter;
 import cz.crcs.ectester.standalone.output.YAMLTestWriter;
 import cz.crcs.ectester.standalone.test.suites.StandaloneDefaultSuite;
 import cz.crcs.ectester.standalone.test.suites.StandaloneTestSuite;
-import org.apache.commons.cli.DefaultParser;
-import org.apache.commons.cli.Option;
-import org.apache.commons.cli.Options;
-import org.apache.commons.cli.ParseException;
+import org.apache.commons.cli.*;
 
 import javax.crypto.KeyAgreement;
 import javax.crypto.SecretKey;
@@ -153,7 +149,15 @@ public class ECTesterStandalone {
 
         Option namedCurve = Option.builder("nc").longOpt("named-curve").desc("Use a named curve, from CurveDB: <cat/id>").hasArg().argName("cat/id").optionalArg(false).build();
         Option namedPublic = Option.builder("npub").longOpt("named-public").desc("Use a named public key, from CurveDB: <cat/id>").hasArg().argName("cat/id").optionalArg(false).build();
+        Option filePublic = Option.builder("pub").longOpt("public").desc("Use a given public key from file.").hasArg().argName("pubkey").optionalArg(false).build();
+        OptionGroup publicKey = new OptionGroup();
+        publicKey.addOption(namedPublic);
+        publicKey.addOption(filePublic);
         Option namedPrivate = Option.builder("npriv").longOpt("named-private").desc("Use a named private key, from CurveDB: <cat/id>").hasArg().argName("cat/id").optionalArg(false).build();
+        Option filePrivate = Option.builder("priv").longOpt("private").desc("Use a given private key from file.").hasArg().argName("privkey").optionalArg(false).build();
+        OptionGroup privateKey = new OptionGroup();
+        privateKey.addOption(namedPrivate);
+        privateKey.addOption(filePrivate);
         Option curveName = Option.builder("cn").longOpt("curve-name").desc("Use a named curve, search from curves supported by the library: <name>").hasArg().argName("name").optionalArg(false).build();
         Option bits = Option.builder("b").longOpt("bits").hasArg().argName("n").optionalArg(false).desc("What size of curve to use.").build();
         Option output = Option.builder("o").longOpt("output").desc("Output into file <output_file>.").hasArgs().argName("output_file").optionalArg(false).build();
@@ -180,9 +184,9 @@ public class ECTesterStandalone {
         ecdhOpts.addOption(Option.builder("t").longOpt("type").desc("Set KeyAgreement object [type].").hasArg().argName("type").optionalArg(false).build());
         ecdhOpts.addOption(Option.builder().longOpt("key-type").desc("Set the key [algorithm] for which the key should be derived in KeyAgreements with KDF. Default is \"AES\".").hasArg().argName("algorithm").optionalArg(false).build());
         ecdhOpts.addOption(Option.builder("n").longOpt("amount").hasArg().argName("amount").optionalArg(false).desc("Do ECDH [amount] times.").build());
-        ecdhOpts.addOption(namedPrivate);
+        ecdhOpts.addOptionGroup(publicKey);
         ecdhOpts.addOption(Option.builder().longOpt("fixed-private").desc("Perform ECDH with fixed private key.").build());
-        ecdhOpts.addOption(namedPublic);
+        ecdhOpts.addOptionGroup(privateKey);
         ecdhOpts.addOption(Option.builder().longOpt("fixed-public").desc("Perform ECDH with fixed public key.").build());
         ParserOptions ecdh = new ParserOptions(new DefaultParser(), ecdhOpts, "Perform EC based KeyAgreement.");
         actions.put("ecdh", ecdh);
@@ -192,8 +196,8 @@ public class ECTesterStandalone {
         ecdsaOpts.addOption(namedCurve);
         ecdsaOpts.addOption(curveName);
         ecdsaOpts.addOption(output);
-        ecdsaOpts.addOption(namedPrivate);
-        ecdsaOpts.addOption(namedPublic);
+        ecdsaOpts.addOptionGroup(privateKey);
+        ecdsaOpts.addOptionGroup(publicKey);
         ecdsaOpts.addOption(Option.builder("t").longOpt("type").desc("Set Signature object [type].").hasArg().argName("type").optionalArg(false).build());
         ecdsaOpts.addOption(Option.builder("n").longOpt("amount").hasArg().argName("amount").optionalArg(false).desc("Do ECDSA [amount] times.").build());
         ecdsaOpts.addOption(Option.builder("f").longOpt("file").hasArg().argName("file").optionalArg(false).desc("Input [file] to sign.").build());
@@ -287,7 +291,7 @@ public class ECTesterStandalone {
     /**
      *
      */
-    private void ecdh() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeyException, FileNotFoundException {
+    private void ecdh() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeyException, IOException {
         ProviderECLibrary lib = cfg.selected;
 
         String algo = cli.getOptionValue("ecdh.type", "ECDH");
@@ -353,43 +357,31 @@ public class ECTesterStandalone {
         out.println("index;time[nano];pubW;privS;secret");
 
         KeyPair one = null;
-        if (cli.hasOption("ecdh.fixed-private") && !cli.hasOption("ecdh.named-private")) {
+        if (cli.hasOption("ecdh.fixed-private") && !cli.hasOption("ecdh.named-private") && !cli.hasOption("ecdh.private")) {
             one = kpg.genKeyPair();
         }
         KeyPair other = null;
-        if (cli.hasOption("ecdh.fixed-public") && !cli.hasOption("ecdh.named-public")) {
+        if (cli.hasOption("ecdh.fixed-public") && !cli.hasOption("ecdh.named-public") && !cli.hasOption("ecdh.public")) {
             other = kpg.genKeyPair();
         }
 
-        ECPrivateKey privkey = null;
-        if (cli.hasOption("ecdh.named-private")) {
-            privkey = ECUtil.toPrivateKey(EC_Store.getInstance().getObject(EC_Key.Private.class, cli.getOptionValue("ecdh.named-private")));
-            if (privkey == null) {
-                privkey = (ECPrivateKey) ECUtil.toKeyPair(EC_Store.getInstance().getObject(EC_Keypair.class, cli.getOptionValue("ecdh.named-private"))).getPrivate();
-            }
-        }
-        ECPublicKey pubkey = null;
-        if (cli.hasOption("ecdh.named-public")) {
-            pubkey = ECUtil.toPublicKey(EC_Store.getInstance().getObject(EC_Key.Public.class, cli.getOptionValue("ecdh.named-public")));
-            if (pubkey == null) {
-                pubkey = (ECPublicKey) ECUtil.toKeyPair(EC_Store.getInstance().getObject(EC_Keypair.class, cli.getOptionValue("ecdh.named-public"))).getPublic();
-            }
-        }
+        ECPrivateKey privkey = (ECPrivateKey) ECUtil.loadKey(EC_Consts.PARAMETER_S, cli.getOptionValue("ecdh.named-private"), cli.getOptionValue("ecdh.private"), (ECParameterSpec) spec);
+        ECPublicKey pubkey = (ECPublicKey) ECUtil.loadKey(EC_Consts.PARAMETER_W, cli.getOptionValue("ecdh.named-public"), cli.getOptionValue("ecdh.public"), (ECParameterSpec) spec);
 
         int amount = Integer.parseInt(cli.getOptionValue("ecdh.amount", "1"));
         for (int i = 0; i < amount; ++i) {
-            if (!cli.hasOption("ecdh.fixed-private") && !cli.hasOption("ecdh.named-private")) {
+            if (!cli.hasOption("ecdh.fixed-private") && !cli.hasOption("ecdh.named-private") && !cli.hasOption("ecdh.private")) {
                 one = kpg.genKeyPair();
             }
-            if (!cli.hasOption("ecdh.fixed-public") && !cli.hasOption("ecdh.named-public")) {
+            if (!cli.hasOption("ecdh.fixed-public") && !cli.hasOption("ecdh.named-public") && !cli.hasOption("ecdh.public")) {
                 other = kpg.genKeyPair();
             }
 
-            if (!cli.hasOption("ecdh.named-private")) {
+            if (!cli.hasOption("ecdh.named-private") && !cli.hasOption("ecdh.private")) {
                 privkey = (ECPrivateKey) one.getPrivate();
             }
 
-            if (!cli.hasOption("ecdh.named-public")) {
+            if (!cli.hasOption("ecdh.named-public") && !cli.hasOption("ecdh.public")) {
                 pubkey = (ECPublicKey) other.getPublic();
             }
 
@@ -510,20 +502,8 @@ public class ECTesterStandalone {
 
         out.println("index;signTime[nano];verifyTime[nano];data;pubW;privS;signature;nonce;verified");
 
-        ECPrivateKey privkey = null;
-        if (cli.hasOption("ecdsa.named-private")) {
-            privkey = ECUtil.toPrivateKey(EC_Store.getInstance().getObject(EC_Key.Private.class, cli.getOptionValue("ecdsa.named-private")));
-            if (privkey == null) {
-                privkey = (ECPrivateKey) ECUtil.toKeyPair(EC_Store.getInstance().getObject(EC_Keypair.class, cli.getOptionValue("ecdsa.named-private"))).getPrivate();
-            }
-        }
-        ECPublicKey pubkey = null;
-        if (cli.hasOption("ecdsa.named-public")) {
-            pubkey = ECUtil.toPublicKey(EC_Store.getInstance().getObject(EC_Key.Public.class, cli.getOptionValue("ecdsa.named-public")));
-            if (pubkey == null) {
-                pubkey = (ECPublicKey) ECUtil.toKeyPair(EC_Store.getInstance().getObject(EC_Keypair.class, cli.getOptionValue("ecdsa.named-public"))).getPublic();
-            }
-        }
+        ECPrivateKey privkey = (ECPrivateKey) ECUtil.loadKey(EC_Consts.PARAMETER_S, cli.getOptionValue("ecdsa.named-private"), cli.getOptionValue("ecdsa.private"), spec);
+        ECPublicKey pubkey = (ECPublicKey) ECUtil.loadKey(EC_Consts.PARAMETER_W, cli.getOptionValue("ecdsa.named-public"), cli.getOptionValue("ecdsa.public"), spec);
 
         int amount = Integer.parseInt(cli.getOptionValue("ecdsa.amount", "1"));
         for (int i = 0; i < amount; ++i) {
@@ -754,13 +734,27 @@ public class ECTesterStandalone {
 
             if (cli.hasOption("test.format")) {
                 String fmt = cli.getOptionValue("test.format");
-                String formats[] = new String[]{"text", "xml", "yaml", "yml"};
+                String[] formats = new String[]{"text", "xml", "yaml", "yml"};
                 if (!Arrays.asList(formats).contains(fmt.toLowerCase())) {
                     System.err.println("Invalid format specified.");
                     return false;
                 }
             }
 
+            if (cli.isNext("ecdh")) {
+                if ((cli.hasOption("ecdh.public") || cli.hasOption("ecdh.private")) && !cli.hasOption("ecdh.named-curve")) {
+                    System.err.println("Need to specify a named curve when specifying public/private key in file.");
+                    return false;
+                }
+            }
+
+            if (cli.isNext("ecdsa")) {
+                if ((cli.hasOption("ecdsa.public") || cli.hasOption("ecdsa.private")) && !cli.hasOption("ecdsa.named-curve")) {
+                    System.err.println("Need to specify a named curve when specifying public/private key in file.");
+                    return false;
+                }
+            }
+
             return true;
         }
     }