From 59b38430d3d517bbf10633579e8ee63255977755 Mon Sep 17 00:00:00 2001 From: ChessNineeee <709030194@qq.com> Date: Thu, 15 Apr 2021 23:04:41 +0800 Subject: [PATCH] =?UTF-8?q?add:minsecurity=20security=E5=9F=BA=E5=87=86?= =?UTF-8?q?=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 12 ++ .../identity/persist/sqlite/Sqlite.java | 3 +- .../identity/IdentityBenchmark.java | 107 +++++++++++ .../identity/PersistBenchmark.java | 79 ++++++++ .../minsecurity/identity/TestPersist.java | 2 +- .../identity/sqlite/SqliteBenchmark.java | 34 ++++ .../security/IdentifyManagerBenchmark.java | 111 +++++++++++ src/test/java/security/KeychainBenchmark.java | 178 ++++++++++++++++++ 8 files changed, 523 insertions(+), 3 deletions(-) create mode 100644 src/test/java/minsecurity/identity/IdentityBenchmark.java create mode 100644 src/test/java/minsecurity/identity/PersistBenchmark.java create mode 100644 src/test/java/minsecurity/identity/sqlite/SqliteBenchmark.java create mode 100644 src/test/java/security/IdentifyManagerBenchmark.java create mode 100644 src/test/java/security/KeychainBenchmark.java diff --git a/pom.xml b/pom.xml index 0f59b56..c8b5ed9 100644 --- a/pom.xml +++ b/pom.xml @@ -106,6 +106,18 @@ sqlite-jdbc 3.35.4 + + + org.openjdk.jmh + jmh-core + 1.23 + + + org.openjdk.jmh + jmh-generator-annprocess + 1.23 + provided + diff --git a/src/main/java/minsecurity/identity/persist/sqlite/Sqlite.java b/src/main/java/minsecurity/identity/persist/sqlite/Sqlite.java index bc949d0..e87dee2 100644 --- a/src/main/java/minsecurity/identity/persist/sqlite/Sqlite.java +++ b/src/main/java/minsecurity/identity/persist/sqlite/Sqlite.java @@ -83,8 +83,7 @@ public class Sqlite { // 兼容sqlcipher c = DriverManager.getConnection("jdbc:sqlite:" + real_db_file, SQLiteMCSqlCipherConfig.getV4Defaults().withKey(passwd2HexKey()).toProperties()); stmt = c.createStatement(); - int res = stmt.executeUpdate(table_create); - System.out.println(res); + stmt.executeUpdate(table_create); stmt.close(); c.close(); }catch (Exception ex){ diff --git a/src/test/java/minsecurity/identity/IdentityBenchmark.java b/src/test/java/minsecurity/identity/IdentityBenchmark.java new file mode 100644 index 0000000..099cc89 --- /dev/null +++ b/src/test/java/minsecurity/identity/IdentityBenchmark.java @@ -0,0 +1,107 @@ +package minsecurity.identity; + +import com.fasterxml.jackson.core.JsonProcessingException; +import minsecurity.Common; +import minsecurity.certificate.cert.CertException; +import minsecurity.certificate.cert.CertUtils; +import minsecurity.certificate.cert.Certificate; +import minsecurity.crypto.AsymKeyException; +import minsecurity.crypto.sm2.SM2Base; +import minsecurity.crypto.sm2.SM2PrivateKey; +import minsecurity.crypto.sm2.SM2PublicKey; +import minsecurity.identity.sqlite.SqliteBenchmark; +import org.bouncycastle.crypto.AsymmetricCipherKeyPair; +import org.bouncycastle.crypto.CryptoException; +import org.bouncycastle.crypto.InvalidCipherTextException; +import org.bouncycastle.crypto.params.ECPrivateKeyParameters; +import org.bouncycastle.crypto.params.ECPublicKeyParameters; +import org.openjdk.jmh.annotations.*; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +import javax.crypto.BadPaddingException; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.NoSuchPaddingException; +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.security.NoSuchAlgorithmException; +import java.security.NoSuchProviderException; +import java.util.concurrent.TimeUnit; + +import static org.junit.Assert.assertArrayEquals; + +@BenchmarkMode(Mode.AverageTime) +@State(Scope.Thread) +@Fork(1) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Warmup(iterations = 3) +@Measurement(iterations = 5) +public class IdentityBenchmark { + private Identity createIdentity() throws Exception { + AsymmetricCipherKeyPair keyPair = SM2Base.generateKeyPairParameter(); + ECPrivateKeyParameters priKey = (ECPrivateKeyParameters) keyPair.getPrivate(); + ECPublicKeyParameters pubKey = (ECPublicKeyParameters) keyPair.getPublic(); + byte[] d = priKey.getD().toByteArray(); + // d = Arrays.copyOf(d,32); + byte[] x = pubKey.getQ().getAffineXCoord().getEncoded(); + byte[] y = pubKey.getQ().getAffineYCoord().getEncoded(); + // logger.debug("d.len = {}, x.len = {}, y.len = {}",d.length, x.length, y.length); + + // BigInteger bigInteger = priKey.getD(); + SM2PrivateKey sm2PrivateKey = new SM2PrivateKey(d); + SM2PublicKey sm2PublicKey = new SM2PublicKey(x,y); + KeyParam keyParam = new KeyParam(Common.SM2, Common.SM3withSM2); + Identity identity = new Identity("root",keyParam,sm2PrivateKey,sm2PublicKey, "123456", null, false); + Certificate certificate = new Certificate(1, 1, sm2PublicKey, null, + Common.SM3withSM2, Common.SM2, "root", "root", + System.currentTimeMillis() - 1000, System.currentTimeMillis() + 5000, + Common.CertSign, true, System.currentTimeMillis()); + CertUtils.signCert(certificate, sm2PrivateKey); + identity.setCert(certificate); + return identity; + } + @Benchmark + public void testSignAndVerify() throws Exception { + Identity id = createIdentity(); + String text = "2020-03-09"; + // test sign and verify + byte[] signature = id.sign(text.getBytes()); + boolean flag = id.verify(text.getBytes(), signature); + } + + @Benchmark + public void testEncAndDec() throws Exception { + Identity id = createIdentity(); + String text = "2020-03-09"; + // test enc and dec + byte[] cipher = id.encrypt(text.getBytes()); + byte[] bytesOfDec = id.decrypt(cipher); + // assertArrayEquals(bytesOfDec, text.getBytes()); + } + + @Benchmark + public void testDumpAndLoad() throws Exception { + Identity id = createIdentity(); + // test dump and load + byte[] bytesOfDump = id.dump(id.getPasswd()); + Identity idFromBytes = Identity.load(bytesOfDump, id.getPasswd()); + } + + @Benchmark + public void testDumpAndLoad2() throws Exception { + Identity id = createIdentity(); + // test dump and load without passwd + byte[] bytesOfDump = id.dump(null); + Identity idFromBytes = Identity.load(bytesOfDump, null); + } + + public static void main(String[] args) throws RunnerException { + Options opt = new OptionsBuilder() + .include(IdentityBenchmark.class.getSimpleName()) + .build(); + new Runner(opt).run(); + } +} + diff --git a/src/test/java/minsecurity/identity/PersistBenchmark.java b/src/test/java/minsecurity/identity/PersistBenchmark.java new file mode 100644 index 0000000..b7b66cf --- /dev/null +++ b/src/test/java/minsecurity/identity/PersistBenchmark.java @@ -0,0 +1,79 @@ +package minsecurity.identity; + +import minsecurity.Common; +import minsecurity.certificate.cert.CertUtils; +import minsecurity.certificate.cert.Certificate; +import minsecurity.crypto.sm2.SM2KeyPair; +import minsecurity.identity.persist.Persist; +import org.openjdk.jmh.annotations.*; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@State(Scope.Thread) +@Fork(1) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Warmup(iterations = 3) +@Measurement(iterations = 5) +public class PersistBenchmark { + /** + * 随机生成身份数据 + * @return Identity + */ + private Identity createRandomIdentity() throws Exception{ + // 测试PersistIdentity + SM2KeyPair pair = SM2KeyPair.generateKeyPair(); + Identity identity = new Identity(); + identity.setName("wzq"+Math.random()); + KeyParam keyParam = new KeyParam(); + keyParam.PublicKeyAlgorithm = 0; + keyParam.SignatureAlgorithm = 0; + identity.setKeyParam(keyParam); + identity.setPrikey(pair.getSm2PrivateKey()); + identity.setPubkey(pair.getSm2PublicKey()); + identity.setPasswd("2DD29CA851E7B56E4697B0E1F08507293D761A05CE4D1B628663F411A8086D99"); + // identity.lock("0123456789abcdef", Common.SM4ECB); + Certificate cert = new Certificate(); + cert.setVersion(1); + cert.setSerialNumber(1); + cert.setPublicKey(pair.getSm2PublicKey()); + cert.setSignatureAlgorithm(Common.SM3withSM2); // TODO 名字有误？ SM2withSM3? + cert.setPublicKeyAlgorithm(Common.SM2); + cert.setIssueTo("root"); + cert.setIssuer("root"); + long timestamp = System.currentTimeMillis() / 1000; + cert.setTimestamp(timestamp); // 10bit timestamp + cert.setNotAfter(timestamp); // 10bit timestamp + cert.setNotBefore(timestamp + 1000); // 10bit timestamp + cert.setKeyUsage(Common.CertSign); + cert.setCA(true); + CertUtils.signCert(cert, pair.getSm2PrivateKey()); + + identity.setCert(cert); + return identity; + } + + @Benchmark + public void testPersistAndDeleteIdentity() throws Exception { + Identity id = createRandomIdentity(); + Persist.persistIdentity(id); + Persist.deleteIdentityByNameFromStorage(id.getName()); + } + + @Benchmark + public void testSetIdentity() throws Exception { + String name = "wzq0.6597381351293033"; // 预先存储好的身份名 + Persist.setDefaultIdentityByNameInStorage(name); + } + + public static void main(String[] args) throws RunnerException { + Options opt = new OptionsBuilder() + .include(PersistBenchmark.class.getSimpleName()) + .build(); + new Runner(opt).run(); + } +} diff --git a/src/test/java/minsecurity/identity/TestPersist.java b/src/test/java/minsecurity/identity/TestPersist.java index 13a16a8..37e0e6d 100644 --- a/src/test/java/minsecurity/identity/TestPersist.java +++ b/src/test/java/minsecurity/identity/TestPersist.java @@ -52,7 +52,7 @@ public class TestPersist { identity.setPrikey(pair.getSm2PrivateKey()); identity.setPubkey(pair.getSm2PublicKey()); identity.setPasswd("2DD29CA851E7B56E4697B0E1F08507293D761A05CE4D1B628663F411A8086D99"); - identity.lock("0123456789abcdef", Common.SM4ECB); + // identity.lock("0123456789abcdef", Common.SM4ECB); Certificate cert = new Certificate(); cert.setVersion(1); cert.setSerialNumber(1); diff --git a/src/test/java/minsecurity/identity/sqlite/SqliteBenchmark.java b/src/test/java/minsecurity/identity/sqlite/SqliteBenchmark.java new file mode 100644 index 0000000..c71adf2 --- /dev/null +++ b/src/test/java/minsecurity/identity/sqlite/SqliteBenchmark.java @@ -0,0 +1,34 @@ +package minsecurity.identity.sqlite; + +import minsecurity.identity.persist.sqlite.Sqlite; +import org.openjdk.jmh.annotations.*; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@State(Scope.Thread) +@Fork(1) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Warmup(iterations = 3) +@Measurement(iterations = 5) +public class SqliteBenchmark { + /** + * Sqlite基准测试 + * @throws Exception + */ + @Benchmark + public void testOpenDefault() throws Exception { + Sqlite.getInstance().openDefault(); + } + + public static void main(String[] args) throws RunnerException { + Options opt = new OptionsBuilder() + .include(SqliteBenchmark.class.getSimpleName()) + .build(); + new Runner(opt).run(); + } +} diff --git a/src/test/java/security/IdentifyManagerBenchmark.java b/src/test/java/security/IdentifyManagerBenchmark.java new file mode 100644 index 0000000..89ec121 --- /dev/null +++ b/src/test/java/security/IdentifyManagerBenchmark.java @@ -0,0 +1,111 @@ +package security; + +import minsecurity.Common; +import minsecurity.certificate.cert.CertUtils; +import minsecurity.certificate.cert.Certificate; +import minsecurity.crypto.sm2.SM2KeyPair; +import minsecurity.identity.Identity; +import minsecurity.identity.IdentityBenchmark; +import minsecurity.identity.KeyParam; +import org.openjdk.jmh.annotations.*; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@State(Scope.Thread) +@Fork(1) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Warmup(iterations = 3) +@Measurement(iterations = 5) +public class IdentifyManagerBenchmark { + /** + * 随机生成身份数据 + * @return Identity + */ + private Identity createRandomIdentity() throws Exception{ + // 测试PersistIdentity + SM2KeyPair pair = SM2KeyPair.generateKeyPair(); + Identity identity = new Identity(); + identity.setName("wzq"+Math.random()); + KeyParam keyParam = new KeyParam(); + keyParam.PublicKeyAlgorithm = 0; + keyParam.SignatureAlgorithm = 0; + identity.setKeyParam(keyParam); + identity.setPrikey(pair.getSm2PrivateKey()); + identity.setPubkey(pair.getSm2PublicKey()); + identity.setPasswd("2DD29CA851E7B56E4697B0E1F08507293D761A05CE4D1B628663F411A8086D99"); + // identity.lock("0123456789abcdef", Common.SM4ECB); + Certificate cert = new Certificate(); + cert.setVersion(1); + cert.setSerialNumber(1); + cert.setPublicKey(pair.getSm2PublicKey()); + cert.setSignatureAlgorithm(Common.SM3withSM2); // TODO 名字有误？ SM2withSM3? + cert.setPublicKeyAlgorithm(Common.SM2); + cert.setIssueTo("root"); + cert.setIssuer("root"); + long timestamp = System.currentTimeMillis() / 1000; + cert.setTimestamp(timestamp); // 10bit timestamp + cert.setNotAfter(timestamp); // 10bit timestamp + cert.setNotBefore(timestamp + 1000); // 10bit timestamp + cert.setKeyUsage(Common.CertSign); + cert.setCA(true); + CertUtils.signCert(cert, pair.getSm2PrivateKey()); + + identity.setCert(cert); + return identity; + } + + @Benchmark + public void testIdentifyManagerInit(){ + IdentifyManager manager = new IdentifyManager(); + } + + @Benchmark + public void testGetIdentityByName(){ + IdentifyManager manager = new IdentifyManager(); + String name = "wzq0.6597381351293033"; // 预先存储好的身份名 + manager.getIdentityByName(name); + } + + @Benchmark + public void testSaveAndDelete() throws Exception { + IdentifyManager manager = new IdentifyManager(); + Identity id = createRandomIdentity(); + manager.saveIdentity(id, true, true); + manager.deleteIdentityByName(id.getName(), true); + } + + @Benchmark + public void testSetDefault() throws Exception { + IdentifyManager manager = new IdentifyManager(); + String name = "wzq0.6597381351293033"; // 预先存储好的身份名 + manager.setDefaultIdentity(manager.getIdentifies().get(name), true); + } + + @Benchmark + public void testExistIdentity(){ + IdentifyManager manager = new IdentifyManager(); + String name = "wzq0.6597381351293033"; // 预先存储好的身份名 + manager.existIdentity(name); + manager.existIdentity(name + "test"); + } + + @Benchmark + public void testCreateIdentityByNameAndDelete() throws Exception { + IdentifyManager manager = new IdentifyManager(); + String s = "wzq"+Math.random(); + manager.createIdentityByName(s, "1234", true); + manager.deleteIdentityByName(s, true); + } + + public static void main(String[] args) throws RunnerException { + Options opt = new OptionsBuilder() + .include(IdentifyManagerBenchmark.class.getSimpleName()) + .build(); + new Runner(opt).run(); + } +} diff --git a/src/test/java/security/KeychainBenchmark.java b/src/test/java/security/KeychainBenchmark.java new file mode 100644 index 0000000..44c9ff5 --- /dev/null +++ b/src/test/java/security/KeychainBenchmark.java @@ -0,0 +1,178 @@ +package security; + +import component.Identifier; +import component.TTL; +import encoding.VlInt; +import minsecurity.Common; +import minsecurity.certificate.cert.CertUtils; +import minsecurity.certificate.cert.Certificate; +import minsecurity.crypto.sm2.SM2KeyPair; +import minsecurity.identity.Identity; +import minsecurity.identity.KeyParam; +import org.openjdk.jmh.annotations.*; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; +import packet.CPacket; +import packet.Data; +import packet.Interest; + +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.AverageTime) +@State(Scope.Thread) +@Fork(1) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Warmup(iterations = 3) +@Measurement(iterations = 5) +public class KeychainBenchmark { + /** + * 随机生成身份数据 + * @return Identity + */ + private Identity createRandomIdentity() throws Exception{ + // 测试PersistIdentity + SM2KeyPair pair = SM2KeyPair.generateKeyPair(); + Identity identity = new Identity(); + identity.setName("wzq"+Math.random()); + KeyParam keyParam = new KeyParam(); + keyParam.PublicKeyAlgorithm = 0; + keyParam.SignatureAlgorithm = 0; + identity.setKeyParam(keyParam); + identity.setPrikey(pair.getSm2PrivateKey()); + identity.setPubkey(pair.getSm2PublicKey()); + identity.setPasswd("2DD29CA851E7B56E4697B0E1F08507293D761A05CE4D1B628663F411A8086D99"); + // identity.lock("0123456789abcdef", Common.SM4ECB); + Certificate cert = new Certificate(); + cert.setVersion(1); + cert.setSerialNumber(1); + cert.setPublicKey(pair.getSm2PublicKey()); + cert.setSignatureAlgorithm(Common.SM3withSM2); // TODO 名字有误？ SM2withSM3? + cert.setPublicKeyAlgorithm(Common.SM2); + cert.setIssueTo("root"); + cert.setIssuer("root"); + long timestamp = System.currentTimeMillis() / 1000; + cert.setTimestamp(timestamp); // 10bit timestamp + cert.setNotAfter(timestamp); // 10bit timestamp + cert.setNotBefore(timestamp + 1000); // 10bit timestamp + cert.setKeyUsage(Common.CertSign); + cert.setCA(true); + CertUtils.signCert(cert, pair.getSm2PrivateKey()); + + identity.setCert(cert); + return identity; + } + + @Benchmark + public void testCreateKeyChain() throws Exception { + KeyChain keyChain = new KeyChain(); + } + + @Benchmark + public void testInitialKeyChain() throws Exception { + // 测试设置新身份为当前身份 + KeyChain keyChain = new KeyChain(); + // Identity id = createRandomIdentity(); + // keyChain.getIdentifyManager().setDefaultIdentity(id, true); + // 输入密码用于解锁身份 + // keyChain.setCurrentIdentity(keyChain.getIdentifyManager().getDefaultIdentity(), "0123456789abcdef"); + } + + @Benchmark + public void testSignAndVerifyInterest() throws Exception { + // 测试设置新身份为当前身份 + KeyChain keyChain = new KeyChain(); + // Identity id = createRandomIdentity(); + // keyChain.getIdentifyManager().setDefaultIdentity(id, true); + // 输入密码用于解锁身份 + // keyChain.setCurrentIdentity(keyChain.getIdentifyManager().getDefaultIdentity(), "0123456789abcdef"); + + // 身份允许签名与验证签名 + Identifier id1 = new Identifier("/min/pku/sz"); + Identifier id2 = new Identifier("/install"); + + //////////////////// 构建兴趣包 //////////////////////// + Interest interest = new Interest(); + interest.minPacket.packetType = new VlInt(3); + interest.setName(id1); + interest.canBePrefix.setCanBePrefix(true); + interest.mustBeRefresh.setMustBeRefresh(true); + interest.nonce.setNonce(1234); + interest.hopLimit.setHopLimit(1234); + interest.congestionMark.setCongestionLevel(1234); + interest.ttl.setTtl(1234); + interest.payload.setValue(new byte[]{1, 2, 3, 4, 5}); + + + // 正常测试签名与验签 + keyChain.signInterest(interest); + keyChain.verifyInterest(interest); + } + + @Benchmark + public void testSignAndVerifyCPacket() throws Exception { + // 测试设置新身份为当前身份 + KeyChain keyChain = new KeyChain(); + // Identity id = createRandomIdentity(); + // keyChain.getIdentifyManager().setDefaultIdentity(id, true); + // 输入密码用于解锁身份 + // keyChain.setCurrentIdentity(keyChain.getIdentifyManager().getDefaultIdentity(), "0123456789abcdef"); + + // 身份允许签名与验证签名 + Identifier id1 = new Identifier("/min/pku/sz"); + Identifier id2 = new Identifier("/install"); + + CPacket cPacket = new CPacket(); + cPacket.minPacket.packetType = new VlInt(3); + cPacket.setSrcIdentifier(id1); + cPacket.setDstIdentifier(id2); + cPacket.setTtl(new TTL(16546418374324163L)); + cPacket.payload.setValue(new byte[]{1, 2, 3, 4, 6}); + + // 正常测试签名与验签 + keyChain.signCPacket(cPacket); + keyChain.verifyCPacket(cPacket); + } + + @Benchmark + public void testSignAndVerifyData() throws Exception { + // 测试设置新身份为当前身份 + KeyChain keyChain = new KeyChain(); + // Identity id = createRandomIdentity(); + // keyChain.getIdentifyManager().setDefaultIdentity(id, true); + // 输入密码用于解锁身份 + // keyChain.setCurrentIdentity(keyChain.getIdentifyManager().getDefaultIdentity(), "0123456789abcdef"); + //////////////////// 构建Data包 //////////////////////// + Data data = new Data(); + data.freshnessPeriod.setFreshnessPeriod(02346345465453L); + data.payload.setValue(new byte[]{1, 2, 3, 4, 5}); + data.congestionMark.setCongestionLevel(1234L); + Identifier id2 = new Identifier("/wzq"); + data.setName(id2); + data.minPacket.packetType = new VlInt(3); + // 正常测试签名与验签 + keyChain.signData(data); + keyChain.verifyData(data); + } + + @Benchmark + public void testExportAndImportSafeBag() throws Exception { + // 测试设置新身份为当前身份 + KeyChain keyChain = new KeyChain(); + // Identity id = createRandomIdentity(); + // keyChain.getIdentifyManager().setDefaultIdentity(id, true); + // 输入密码用于解锁身份 + // keyChain.setCurrentIdentity(keyChain.getIdentifyManager().getDefaultIdentity(), "0123456789abcdef"); + // 正常导入导出 通过 + Identity id2 = createRandomIdentity(); + SafeBag bag = keyChain.exportSafeBag(id2, "1234"); + keyChain.importSafeBag(bag, "1234", true); + } + public static void main(String[] args) throws RunnerException { + Options opt = new OptionsBuilder() + .include(KeychainBenchmark.class.getSimpleName()) + .build(); + new Runner(opt).run(); + } +}