public JSApiRole getOwner() { return JSApiRole.createJSApiRole(this.currentContract.getOwner()); }
if(!(contract.getOwner() instanceof ListRole)) { return false; ListRole owner = (ListRole) contract.getOwner(); if(owner.getQuorum() == 0 || owner.getQuorum() < owner.getRoles().size()-1) { return false; Set<PublicKey> ownerKeys = contract.getOwner().getKeys(); if(contractNodes.size() != ownerKeys.size() || !contractNodes.stream().allMatch(nodeInfo -> nodeInfo instanceof NodeInfo && ownerKeys.contains(((NodeInfo)nodeInfo).getPublicKey()))) { return false; if(!(permission.getRole() instanceof RoleLink) || ((RoleLink)permission.getRole()).getRole() != contract.getOwner()) return false; if(!(permission.getRole() instanceof RoleLink) || ((RoleLink)permission.getRole()).getRole() != contract.getOwner()) return false;
Role owner = contract.getOwner(); if (owner.isAllowedForKeys(getSealedByKeys())) return true;
boolean willBeMine = c.getOwner().isAllowedForKeys(keys);
public synchronized Contract finishSwap_wrongKey(Contract swapContract, Set<PrivateKey> keys, PrivateKey wrongKey) { List<Contract> swappingContracts = (List<Contract>) swapContract.getNew(); // looking for contract that will be own for (Contract c : swappingContracts) { boolean willBeMine = c.getOwner().isAllowedForKeys(keys); System.out.println("willBeMine: " + willBeMine + " " + c.getSealedByKeys().size()); if(willBeMine) { c.addSignatureToSeal(wrongKey); } } swapContract.seal(); return swapContract; }
System.out.println("DeLorean revoked ownership was belongs to Marty: " + delorean.getOwner().isAllowedForKeys(martyPublicKeys)); assertEquals(ItemState.REVOKED, deloreanResult.state); System.out.println("Lamborghini revoked ownership was belongs to Stepa: " + lamborghini.getOwner().isAllowedForKeys(stepaPublicKeys)); assertEquals(ItemState.REVOKED, lamborghiniResult.state); System.out.println("DeLorean ownership is now belongs to Stepa: " + newDelorean.getOwner().isAllowedForKeys(stepaPublicKeys)); assertEquals(ItemState.APPROVED, deloreanResult.state); assertTrue(newDelorean.getOwner().isAllowedForKeys(stepaPublicKeys)); System.out.println("Lamborghini ownership is now belongs to Marty: " + newLamborghini.getOwner().isAllowedForKeys(martyPublicKeys)); assertEquals(ItemState.APPROVED, lamborghiniResult.state); assertTrue(newLamborghini.getOwner().isAllowedForKeys(martyPublicKeys));
System.out.println("DeLorean revoked ownership still belongs to Marty: " + delorean.getOwner().isAllowedForKeys(martyPublicKeys)); assertEquals(ItemState.APPROVED, deloreanResult.state); System.out.println("Lamborghini revoked ownership still belongs to Stepa: " + lamborghini.getOwner().isAllowedForKeys(stepaPublicKeys)); assertEquals(ItemState.APPROVED, lamborghiniResult.state); System.out.println("DeLorean ownership should belongs to Stepa: " + newDelorean.getOwner().isAllowedForKeys(stepaPublicKeys)); assertEquals(ItemState.UNDEFINED, deloreanResult.state); assertTrue(newDelorean.getOwner().isAllowedForKeys(stepaPublicKeys)); System.out.println("Lamborghini ownership should belongs to Marty: " + newLamborghini.getOwner().isAllowedForKeys(martyPublicKeys)); assertEquals(ItemState.UNDEFINED, lamborghiniResult.state); assertTrue(newLamborghini.getOwner().isAllowedForKeys(martyPublicKeys));
public void prepareContractsForSwap( Set<PrivateKey> martyPrivateKeys, Set<PublicKey> martyPublicKeys, Set<PrivateKey> stepaPrivateKeys, Set<PublicKey> stepaPublicKeys, Contract delorean, Contract lamborghini) throws Exception { martyPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/marty_mcfly.private.unikey"))); for (PrivateKey pk : martyPrivateKeys) { martyPublicKeys.add(pk.getPublicKey()); } stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey"))); for (PrivateKey pk : stepaPrivateKeys) { stepaPublicKeys.add(pk.getPublicKey()); } PrivateKey manufacturePrivateKey = new PrivateKey(Do.read(ROOT_PATH + "_xer0yfe2nn1xthc.private.unikey")); delorean.addSignerKey(manufacturePrivateKey); delorean.seal(); System.out.println("DeLorean ownership contract is valid: " + delorean.check()); delorean.traceErrors(); registerAndCheckApproved(delorean); System.out.println("DeLorean ownership is belongs to Marty: " + delorean.getOwner().isAllowedForKeys(martyPublicKeys)); lamborghini.addSignerKey(manufacturePrivateKey); lamborghini.seal(); System.out.println("Lamborghini ownership contract is valid: " + lamborghini.check()); lamborghini.traceErrors(); registerAndCheckApproved(lamborghini); System.out.println("Lamborghini ownership is belongs to Stepa: " + lamborghini.getOwner().isAllowedForKeys(stepaPublicKeys)); }
@Override public boolean beforeUpdate(ImmutableEnvironment c) { boolean checkResult = false; // recalculate storing info without saving to state to get valid storing data calculatePrepaidKilobytesForDays(false); // check that payment was not hacked checkResult = prepaidKilobytesForDays == getStateData().getInt(PREPAID_KD_FIELD_NAME, 0); if(!checkResult) { addError(Errors.FAILED_CHECK, "Wrong [state.data." + PREPAID_KD_FIELD_NAME + "] value. " + "Should be sum of early paid U and paid U by current revision."); return checkResult; } if(getTrackingContract() != null) { // check for that last revision of tracking contract has same owner as creator of slot checkResult = getTrackingContract().getOwner().isAllowedForKeys(getEffectiveKeys()); if (!checkResult) { addError(Errors.FAILED_CHECK, "Slot-contract signing keys must has allowed keys for owner of tracking contract"); return checkResult; } } // and call common slot check checkResult = additionallySlotCheck(c); return checkResult; }
Contract contract1 = CLIMain.loadContract(basePath + "forRoleAnonymizing1_anonymized.unicon", true); assertFalse(contract1.getOwner().getKeys().contains(ownerKey.getPublicKey())); assertFalse(contract1.getIssuer().getKeys().contains(key.getPublicKey())); assertFalse(contract1.getCreator().getKeys().contains(key.getPublicKey())); assertFalse(anonPublishedContract1.getOwner().getKeys().contains(ownerKey.getPublicKey())); assertFalse(anonPublishedContract1.getIssuer().getKeys().contains(key.getPublicKey())); assertFalse(anonPublishedContract1.getCreator().getKeys().contains(key.getPublicKey())); assertFalse(contract2.getOwner().getKeys().contains(ownerKey.getPublicKey())); assertFalse(contract2.getIssuer().getKeys().contains(key.getPublicKey())); assertFalse(contract2.getCreator().getKeys().contains(key.getPublicKey())); assertFalse(anonPublishedContract2.getOwner().getKeys().contains(ownerKey.getPublicKey())); assertFalse(anonPublishedContract2.getIssuer().getKeys().contains(key.getPublicKey())); assertFalse(anonPublishedContract2.getCreator().getKeys().contains(key.getPublicKey()));
@Test public void anonymizeAllRoles() throws Exception { callMain2("-create", rootPath + "TokenDSLTemplate.yml", "--output", basePath + "forRoleAnonymizing.unicon", "-k", rootPath + "_xer0yfe2nn1xthc.private.unikey"); assertTrue (new File(basePath + "forRoleAnonymizing.unicon").exists()); callMain("-anonymize", basePath + "forRoleAnonymizing.unicon"); assertTrue (new File(basePath + "forRoleAnonymizing_anonymized.unicon").exists()); System.out.println(output); PrivateKey key = new PrivateKey(Do.read(rootPath + "_xer0yfe2nn1xthc.private.unikey")); PrivateKey ownerKey = new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey")); Contract contract = CLIMain.loadContract(basePath + "forRoleAnonymizing_anonymized.unicon", true); assertFalse(contract.getOwner().getKeys().contains(ownerKey.getPublicKey())); assertFalse(contract.getIssuer().getKeys().contains(key.getPublicKey())); assertFalse(contract.getCreator().getKeys().contains(key.getPublicKey())); Contract anonPublishedContract = new Contract(contract.getLastSealedBinary()); assertFalse(anonPublishedContract.getOwner().getKeys().contains(ownerKey.getPublicKey())); assertFalse(anonPublishedContract.getIssuer().getKeys().contains(key.getPublicKey())); assertFalse(anonPublishedContract.getCreator().getKeys().contains(key.getPublicKey())); assertFalse(anonPublishedContract.getSealedByKeys().contains(key.getPublicKey())); assertFalse(anonPublishedContract.getSealedByKeys().contains(ownerKey.getPublicKey())); }
assertTrue(c.check()); assertEquals(c, ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getContract()); Role cOwner = c.getOwner(); assertTrue (cOwner.isAllowedForKeys(new HashSet<>(Do.listOf(ownerKey1)))); assertTrue (!cOwner.isAllowedForKeys(new HashSet<>(Do.listOf(ownerKey2)))); assertNotEquals(c.getOwner(), c1.getOwner()); c1.seal(); c1.check(); assertEquals(c.getOwner(), ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getRole()); assertEquals(c2, ((RoleLink) c2.getPermissions().getFirst("change_owner").getRole()).getContract()); assertEquals(c, ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getContract()); c2.setOwnerKey(ownerKey3); assertNotEquals(c.getOwner(), c2.getOwner()); assertEquals(c.getOwner(), ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getRole());
notaryContract.traceErrors(); assertTrue(notaryContract.getOwner().isAllowedForKeys(ownerPublicKeys)); assertTrue(notaryContract.getIssuer().isAllowedForKeys(issuerPrivateKeys)); assertTrue(notaryContract.getCreator().isAllowedForKeys(issuerPrivateKeys)); assertFalse(notaryContract.getOwner().isAllowedForKeys(issuerPrivateKeys)); assertFalse(notaryContract.getIssuer().isAllowedForKeys(ownerPublicKeys)); assertFalse(notaryContract.getCreator().isAllowedForKeys(ownerPublicKeys));
@Test public void goodNotary() throws Exception { Set<PrivateKey> martyPrivateKeys = new HashSet<>(); Set<PrivateKey> stepaPrivateKeys = new HashSet<>(); Set<PublicKey> martyPublicKeys = new HashSet<>(); Set<PublicKey> stepaPublicKeys = new HashSet<>(); martyPrivateKeys.add(new PrivateKey(Do.read(rootPath + "keys/marty_mcfly.private.unikey"))); stepaPrivateKeys.add(new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey"))); for (PrivateKey pk : stepaPrivateKeys) stepaPublicKeys.add(pk.getPublicKey()); for (PrivateKey pk : martyPrivateKeys) martyPublicKeys.add(pk.getPublicKey()); Contract notaryContract = ContractsService.createNotaryContract(martyPrivateKeys, stepaPublicKeys); notaryContract.check(); notaryContract.traceErrors(); assertTrue(notaryContract.isOk()); assertTrue(notaryContract.getOwner().isAllowedForKeys(stepaPublicKeys)); assertTrue(notaryContract.getIssuer().isAllowedForKeys(martyPrivateKeys)); assertTrue(notaryContract.getCreator().isAllowedForKeys(martyPrivateKeys)); assertFalse(notaryContract.getOwner().isAllowedForKeys(martyPrivateKeys)); assertFalse(notaryContract.getIssuer().isAllowedForKeys(stepaPublicKeys)); assertFalse(notaryContract.getCreator().isAllowedForKeys(stepaPublicKeys)); assertTrue(notaryContract.getExpiresAt().isAfter(ZonedDateTime.now().plusMonths(3))); assertTrue(notaryContract.getCreatedAt().isBefore(ZonedDateTime.now())); assertTrue(notaryContract.isPermitted("revoke", stepaPublicKeys)); assertTrue(notaryContract.isPermitted("revoke", martyPublicKeys)); assertTrue(notaryContract.isPermitted("change_owner", stepaPublicKeys)); assertFalse(notaryContract.isPermitted("change_owner", martyPublicKeys)); }
@Test public void getStateWithNoLedgerCache() throws Exception { TestSpace testSpace = prepareTestSpace(TestKeys.privateKey(0)); testSpace.nodes.forEach(m -> m.config.setIsFreeRegistrationsAllowedFromYaml(true)); testSpace.nodes.forEach(m -> ((PostgresLedger)m.node.getLedger()).enableCache(false)); //SHUTDOWN LAST NODE testSpace.nodes.remove(testSpace.nodes.size()-1).shutdown(); Thread.sleep(4000); Contract rev1 = new Contract(TestKeys.privateKey(0)); rev1.getStateData().set("field1", 33); Permission permission = new ChangeNumberPermission(rev1.getOwner(), Binder.of("field_name", "field1")); rev1.addPermission(permission); rev1.seal(); ItemResult ir1 = testSpace.client.register(rev1.getPackedTransaction(), 5000); assertEquals(ItemState.APPROVED, ir1.state); Contract rev2 = rev1.createRevision(); rev2.getStateData().set("field1", 34); rev2.addSignerKey(TestKeys.privateKey(0)); rev2.seal(); ItemResult ir2 = testSpace.client.register(rev2.getPackedTransaction(), 5000); assertEquals(ItemState.APPROVED, ir2.state); ir1 = testSpace.client.register(rev1.getPackedTransaction(), 5000); assertEquals(ItemState.REVOKED, ir1.state); testSpace.nodes.forEach(m -> m.shutdown()); }
checkResult = getTrackingContract().getOwner().isAllowedForKeys(getEffectiveKeys()); if (!checkResult) { addError(Errors.FAILED_CHECK, "Slot-contract signing keys must has allowed keys for owner of tracking contract");
ModifyDataPermission perm = new ModifyDataPermission(contract.getOwner(), new Binder()); perm.addField("test_value", Arrays.asList("0", "1")); contract.addPermission(perm);
permParams.set("max_step", 1); permParams.set("field_name", "test_value"); ChangeNumberPermission perm = new ChangeNumberPermission(contract.getOwner(), permParams); contract.addPermission(perm); contract.getStateData().set("test_value", 11);