@Override public Object deserialize(Binder binder, BiDeserializer deserializer) { try { return new PrivateKey(binder.getBinaryOrThrow("packed")); } catch (EncryptionError encryptionError) { return null; } }
/** * Given the .unikey-format byte array with the private key, create the {@link PrivateKey}. */ @Nullable public static PrivateKey fromUnikey(@NonNull byte[] bytes) { assert bytes != null; try { return new PrivateKey(bytes); } catch (Throwable e) { return null; } }
/** * Add private key from file to keys contract binary to be signed with when sealed next time. It is called before seal() * @param fileName path to file containing private key */ public void addSignerKeyFromFile(String fileName) throws IOException { addSignerKey(new PrivateKey(Do.read(fileName))); }
protected synchronized Set<PrivateKey> checkPayment_preparePrivateKeys() throws Exception { Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); return stepaPrivateKeys; }
static PrivateKey privateKey(int index) { byte[] src = Do.decodeBase64(binaryKeys[index]); try { return new PrivateKey(src); } catch (EncryptionError encryptionError) { throw new RuntimeException("failed to create test key", encryptionError); } }
public AbstractKey unpackKey(byte[] data) throws EncryptionError { switch (algorythm) { case RSAPublic: return new PublicKey(data, this); case RSAPrivate: return new PrivateKey(data, this); case AES256: return new SymmetricKey(data, this); } throw new EncryptionError("can't unpack key: " + this); }
static public PrivateKey privateKey(int index) throws EncryptionError { byte[] src = Do.decodeBase64(binaryKeys[index]); return new PrivateKey(src); }
@Test public void addWhiteListKeyTest() { Config config = new Config(); PrivateKey randomKey = new PrivateKey(4096); config.getKeysWhiteList().add(randomKey.getPublicKey()); assertTrue(config.getKeysWhiteList().contains(randomKey.getPublicKey())); }
@Test public void addWhiteListAddressTest() { Config config = new Config(); PrivateKey randomKey = new PrivateKey(4096); KeyAddress keyAddr = new KeyAddress(randomKey.getPublicKey(), 0, true); config.getAddressesWhiteList().add(keyAddr); assertTrue(config.getAddressesWhiteList().contains(keyAddr)); } }
protected synchronized Parcel registerWithNewParcel(TransactionPack tp) throws Exception { Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); Contract tu = getApprovedUContract(); // stepaPrivateKeys - is also U keys Parcel parcel = ContractsService.createParcel(tp, tu, 150, stepaPrivateKeys); System.out.println("-------------"); normalClient.registerParcelWithState(parcel.pack(),8000); synchronized (uContractLock) { uContract = parcel.getPaymentContract(); } return parcel; }
protected synchronized Parcel registerWithNewParcel(Contract c) throws Exception { Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); Parcel parcel = createParcelWithClassU(c, stepaPrivateKeys); System.out.println("register parcel: " + parcel.getId() + " " + parcel.getPaymentContract().getId() + " " + parcel.getPayloadContract().getId()); node.registerParcel(parcel); synchronized (uContractLock) { uContract = parcel.getPaymentContract(); } return parcel; }
protected synchronized Parcel registerWithNewParcel(Contract c) throws Exception { Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); Parcel parcel = createParcelWithClassU(c, stepaPrivateKeys); System.out.println("register parcel: " + parcel.getId() + " " + parcel.getPaymentContract().getId() + " " + parcel.getPayloadContract().getId()); normalClient.registerParcelWithState(parcel.pack(),8000); synchronized (uContractLock) { uContract = parcel.getPaymentContract(); } return parcel; }
public Contract createUnsPayment() throws IOException { PrivateKey ownerKey = new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey")); Set<PublicKey> keys = new HashSet(); keys.add(ownerKey.getPublicKey()); Contract stepaU = InnerContractsService.createFreshU(100000000, keys); Contract paymentDecreased = stepaU.createRevision(ownerKey); paymentDecreased.getStateData().set("transaction_units", stepaU.getStateData().getIntOrThrow("transaction_units") - 2000); paymentDecreased.seal(); return paymentDecreased; } }
public Contract createSlotPayment() throws IOException { PrivateKey ownerKey = new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey")); Set<PublicKey> keys = new HashSet(); keys.add(ownerKey.getPublicKey()); Contract stepaU = InnerContractsService.createFreshU(100000000, keys); Contract paymentDecreased = stepaU.createRevision(ownerKey); paymentDecreased.getStateData().set("transaction_units", stepaU.getStateData().getIntOrThrow("transaction_units") - 100); paymentDecreased.seal(); return paymentDecreased; } }
@Test public void testFromToUnikeyPublicMethods() throws Exception { final PrivateKey pk1 = new PrivateKey(pk1Bytes); assertArrayEquals(pk1Bytes, pk1.pack()); final PrivateKey pk2 = UnikeyFactory.fromUnikey(pk1Bytes); assertEquals(pk1, pk2); assertArrayEquals(pk1Bytes, UnikeyFactory.toUnikey(pk2)); } }
@Test public void serializationTest() throws Exception { byte[] packedPublicKey = Do.decodeBase64(publicKey64); PublicKey publicKey = new PublicKey(packedPublicKey); byte[] packedPublicKey2 = publicKey.pack(); assertArrayEquals(packedPublicKey, packedPublicKey2); byte[] packedPrivateKey = Do.decodeBase64(TestKeys.binaryKeys[3]); PrivateKey privateKey = new PrivateKey(packedPrivateKey); byte[] packedPrivateKey2 = privateKey.pack(); assertArrayEquals(packedPrivateKey, packedPrivateKey2); }
@Test public void checkTestnetKeyStrengthCriteria() throws Exception { PrivateKey key = new PrivateKey(Do.read(PRIVATE_KEY_PATH)); Contract contract = createCoin100apiv3(); contract.setExpiresAt(ZonedDateTime.now().plusMonths(1)); contract.addSignerKey(key); sealCheckTrace(contract, true); assertFalse(contract.isSuitableForTestnet()); // now set contract limited for testnet contract.setLimitedForTestnet(true); sealCheckTrace(contract, false); assertFalse(contract.isSuitableForTestnet()); }
@Test public void checkTestnetExpirationDateCriteria() throws Exception { PrivateKey key = new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey")); Contract contract = Contract.fromDslFile(rootPath + "LamborghiniTestDrive.yml"); contract.addSignerKey(key); sealCheckTrace(contract, true); contract.setExpiresAt(ZonedDateTime.now().plusMonths(13)); assertFalse(contract.isSuitableForTestnet()); // now set contract limited for testnet contract.setLimitedForTestnet(true); sealCheckTrace(contract, false); assertFalse(contract.isSuitableForTestnet()); }
@Test(timeout = 90000) public void checkPayment_wrongIssuer() throws Exception { Contract payment = checkPayment_preparePaymentContract(checkPayment_preparePrivateKeys()); PrivateKey manufactureFakePrivateKey = new PrivateKey(Do.read(ROOT_PATH + "keys/marty_mcfly.private.unikey")); SimpleRole issuerRole = new SimpleRole("issuer"); KeyRecord kr = new KeyRecord(manufactureFakePrivateKey.getPublicKey()); issuerRole.addKeyRecord(kr); payment.registerRole(issuerRole); boolean res = payment.paymentCheck(config.getUIssuerKeys()); payment.traceErrors(); assertFalse(res); }
@Test public void goodSmartContract() throws Exception { final PrivateKey key = new PrivateKey(Do.read(rootPath + "_xer0yfe2nn1xthc.private.unikey")); Contract smartContract = new NSmartContract(key); smartContract.seal(); smartContract.check(); smartContract.traceErrors(); assertTrue(smartContract.isOk()); assertEquals(NSmartContract.SmartContractType.N_SMART_CONTRACT.name(), smartContract.getDefinition().getExtendedType()); assertEquals(NSmartContract.SmartContractType.N_SMART_CONTRACT.name(), smartContract.get("definition.extended_type")); assertTrue(smartContract instanceof NSmartContract); assertTrue(smartContract instanceof NContract); }