Examples of net.tomp2p.storage.Data

net.tomp2p.storage.Data
This class holds the data for the transport. The data is already serialized and a hash may be created. It is reasonable to create the hash on the remote peer, but not on the local peer. The remote peer uses the hash to tell the other peers, which version is stored and its used quite often. @author Thomas Bocek

    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");


    H2HTestData data = new H2HTestData(NetworkTestUtil.randomString());


    p2.put(lKey).setData(cKey, new Data(data)).setDomainKey(dKey).start().awaitUninterruptibly();


    FutureRemove futureRemove = p1.remove(lKey).from(new Number640(lKey, dKey, cKey, Number160.ZERO))
        .to(new Number640(lKey, dKey, cKey, Number160.MAX_VALUE)).start();
    futureRemove.awaitUninterruptibly();

View Full Code Here

        data.setBasedOnKey(content.get(i - 1).getVersionKey());
      }
      content.add(data);


      p2.put(Number160.createHash(locationKey))
          .setData(Number160.createHash(contentKey), new Data(data))
          .setVersionKey(data.getVersionKey()).start().awaitUninterruptibly();
    }


    FutureDigest futureDigest = p1
        .digest(Number160.createHash(locationKey))

View Full Code Here

        data.setBasedOnKey(content.get(i - 1).getVersionKey());
      }
      content.add(data);


      p2.put(Number160.createHash(locationKey))
          .setData(Number160.createHash(contentKey), new Data(data))
          .setVersionKey(data.getVersionKey()).start().awaitUninterruptibly();
    }


    for (H2HTestData data : content) {
      FutureDigest future = p1.digest(Number160.createHash(locationKey)).setDomainKey(Number160.ZERO)

View Full Code Here


    H2HTestData data = new H2HTestData(NetworkTestUtil.randomString());
    data.generateVersionKey();
    // data.setBasedOnKey(Number160.createHash(10));


    p2.put(Number160.createHash(locationKey)).setData(Number160.createHash(contentKey), new Data(data))
        .setVersionKey(data.getVersionKey()).start().awaitUninterruptibly();


    FutureGet futureGet = p2.get(Number160.createHash(locationKey))
        .setContentKey(Number160.createHash(contentKey)).setVersionKey(data.getVersionKey()).start();
    futureGet.awaitUninterruptibly();

View Full Code Here

  }


  public FuturePut putUnblocked(IParameters parameters) {
    logger.debug("Put. {}", parameters.toString());
    try {
      Data data = new Data(parameters.getData());
      data.ttlSeconds(parameters.getTTL()).basedOn(parameters.getData().getBasedOnKey());


      // check if data to put is content protected
      if (parameters.getProtectionKeys() != null) {
        data.setProtectedEntry().publicKey(parameters.getProtectionKeys().getPublic());


        // sign the data
        // data.sign(parameters.getProtectionKeys(), new RSASignatureFactory());
        // // check if hash creation is needed
        // if (parameters.getHashFlag()) {

View Full Code Here

  }


  public FuturePut changeProtectionKeyUnblocked(IParameters parameters) {
    logger.debug("Change content protection key. {}", parameters.toString());
    // create dummy object to change the protection key
    Data data = new Data().setProtectedEntry();
    // set new content protection keys
    data.publicKey(parameters.getNewProtectionKeys().getPublic());
    if (parameters.getTTL() != -1)
      data.ttlSeconds(parameters.getTTL());


    // // sign the data
    // try {
    // // encrypt hash with new key pair to get the new signature (without having the data object)
    // Cipher rsa = Cipher.getInstance("RSA");
    // rsa.init(Cipher.ENCRYPT_MODE, parameters.getNewProtectionKeys().getPrivate());
    // byte[] newSignature = rsa.doFinal(parameters.getHash());
    //
    // // create new data signature
    // data = data.signature(signatureCodec.decode(newSignature));
    // } catch (IOException | InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException
    // | IllegalBlockSizeException | BadPaddingException e) {
    // logger.error(String.format("Change protection key failed. %s exception = '%s'",
    // parameters.toString(), e.getMessage()));
    // return null;
    // }


    // create meta data
    data = data.duplicateMeta();


    // change the protection key through a put meta
    return getPeer().put(parameters.getLKey()).setDomainKey(parameters.getDKey()).putMeta()
        .setData(parameters.getCKey(), data).setVersionKey(parameters.getVersionKey())
        .keyPair(parameters.getProtectionKeys()).start();

View Full Code Here

    Number160 vKey = Number160.createHash("version");
    Number160 bKey = Number160.createHash("based on");
    int ttl = 10;


    // initial put with data signature and entry protection
    Data data = new Data("data1").setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair1, factory);
    // put using content protection key 1 to sign message
    FuturePut futureIntialPut = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futureIntialPut.awaitUninterruptibly();
    Assert.assertTrue(futureIntialPut.isSuccess());


    // verify put
    Data retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify data signature
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


    // change data signature to keys 2 using same data, sign with new key 2
    data = new Data("data1").ttlSeconds(ttl).setProtectedEntry().sign(keyPair2, factory);
    // change content protection keys to keys 2
    // data.publicKey(keyPair2.getPublic()); is already done with data.sign(...)
    // create meta data
    data.duplicateMeta();
    // put meta using content content protection key 1 to sign message
    FuturePut futurePutMeta = p1.put(lKey).setDomainKey(dKey).putMeta().setData(cKey, data)
        .setVersionKey(vKey).keyPair(keyPair1).start();
    futurePutMeta.awaitUninterruptibly();
    Assert.assertTrue(futurePutMeta.isSuccess());


    // verify change
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify new content protection keys 2
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    // verify new data signature
    Assert.assertTrue(retData.verify(keyPair2.getPublic(), factory));


    // try overwrite with content protection key 1 and data signature (expected to fail)
    data = new Data("data2").setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair2, factory);
    // put using content wrong protection keys 1 to sign message
    FuturePut futureOverwrite3 = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futureOverwrite3.awaitUninterruptibly();
    Assert.assertFalse(futureOverwrite3.isSuccess());


    // verify that nothing changed
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    // verify not changed signature
    Assert.assertTrue(retData.verify(keyPair2.getPublic(), factory));


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

    Number160 vKey = Number160.createHash("version");
    Number160 bKey = Number160.createHash("based on");
    int ttl = 10;


    // initial put with data signature and entry protection
    Data data = new Data("data1").setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair1, factory);
    // put using content protection key 1 to sign message
    FuturePut futureIntialPut = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futureIntialPut.awaitUninterruptibly();
    Assert.assertTrue(futureIntialPut.isSuccess());


    // verify put
    Data retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify content protection keys 1 is set
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify data signature
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


    // create signature with keys 1 having the data object
    byte[] signature1 = factory.sign(keyPair1.getPrivate(), data.buffer()).encode();


    // decrypt signature to get hash of the object
    Cipher rsa = Cipher.getInstance("RSA");
    rsa.init(Cipher.DECRYPT_MODE, keyPair1.getPublic());
    byte[] hash = rsa.doFinal(signature1);


    // encrypt hash with new key pair to get the new signature (without having the data object)
    rsa = Cipher.getInstance("RSA");
    rsa.init(Cipher.ENCRYPT_MODE, keyPair2.getPrivate());
    byte[] signatureNew = rsa.doFinal(hash);


    // change data signature to keys 2, assign the reused hash from signature
    data = new Data().ttlSeconds(ttl).signature(codec.decode(signatureNew)).setProtectedEntry();
    // don't forget to set signed flag
    data.signed(true);
    // change the content protection keys to 2
    data.publicKey(keyPair2.getPublic());
    // create meta data
    data.duplicateMeta();
    // put meta using content content protection key 1 to sign message
    FuturePut futurePutMeta = p1.put(lKey).setDomainKey(dKey).putMeta().setData(cKey, data)
        .setVersionKey(vKey).keyPair(keyPair1).start();
    futurePutMeta.awaitUninterruptibly();
    Assert.assertTrue(futurePutMeta.isSuccess());


    // verify change
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify change to content protection keys 2
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    // verify new data signature
    Assert.assertTrue(retData.verify(keyPair2.getPublic(), factory));


    // try overwrite with content protection key 1 and data signature (exptected to fail)
    data = new Data("data2").setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair2, factory);
    // put using content wrong protection keys 1 to sign message
    FuturePut futureOverwrite3 = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futureOverwrite3.awaitUninterruptibly();
    Assert.assertFalse(futureOverwrite3.isSuccess());


    // verify that nothing changed
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    // verify not changed signature
    Assert.assertTrue(retData.verify(keyPair2.getPublic(), factory));


    p1.shutdown().awaitUninterruptibly();
    p2.shutdown().awaitUninterruptibly();
  }

View Full Code Here

    Number160 lKey = Number160.createHash("location");
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");


    // put version 1 with protection keys 1
    Data data1 = new Data("data1").setProtectedEntry();
    Number160 vKey1 = Number160.ZERO;
    FuturePut futurePut1 = p1.put(lKey).setData(cKey, data1).setDomainKey(dKey).setVersionKey(vKey1)
        .keyPair(keyPair1).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());


    // verify put of version 1
    Data retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify content protection keys 1 is set
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    
    // try to overwrite version 1 without protection keys (expected to fail)
    Data data1A = new Data("data1A");
    FuturePut futurePut1A = p1.put(lKey).setData(cKey, data1A).setDomainKey(dKey).setVersionKey(vKey1)
        .start();
    futurePut1A.awaitUninterruptibly();
    assertFalse(futurePut1A.isSuccess());


    // verify that nothing changed
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());


    // try to overwrite version 1 with wrong protection keys 2 (expected to fail)
    Data data1B = new Data("data1B").setProtectedEntry();
    FuturePut futurePut1B = p1.put(lKey).setData(cKey, data1B).setDomainKey(dKey).setVersionKey(vKey1)
        .keyPair(keyPair2).start();
    futurePut1B.awaitUninterruptibly();
    assertFalse(futurePut1B.isSuccess());


    // verify that nothing changed
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());


    // overwrite version 1 with protection keys 1
    Data data1Overwrite = new Data("data1Overwrite").setProtectedEntry();
    FuturePut futurePutOverwrite = p1.put(lKey).setData(cKey, data1Overwrite).setDomainKey(dKey)
        .setVersionKey(vKey1).keyPair(keyPair1).start();
    futurePutOverwrite.awaitUninterruptibly();
    assertTrue(futurePutOverwrite.isSuccess());


    // verify overwrite
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1Overwrite", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());


    // try to put new version 2 (basing on version 1) with wrong protection keys 2 (expected to fail)
    Data data2 = new Data("data2").basedOn(vKey1).setProtectedEntry();
    // version 2 takes new version key
    Number160 vKey2 = Number160.createHash("version2");
    FuturePut futurePut2 = p1.put(lKey).setData(cKey, data2).setDomainKey(dKey).setVersionKey(vKey2)
        .keyPair(keyPair2).start();
    futurePut2.awaitUninterruptibly();
    assertFalse(futurePut2.isSuccess());


    // verify no put of version 2
    assertNull(p2.get(lKey).setContentKey(cKey).setVersionKey(vKey2).setDomainKey(dKey).start()
        .awaitUninterruptibly().getData());


    // put new version 3 (basing on version 1) with correct protection keys 1
    Data data3 = new Data("data3").basedOn(vKey1).setProtectedEntry();
    Number160 vKey3 = Number160.createHash("version3");
    FuturePut futurePut3 = p1.put(lKey).setData(cKey, data3).setDomainKey(dKey).setVersionKey(vKey3)
        .keyPair(keyPair1).start();
    futurePut3.awaitUninterruptibly();
    assertTrue(futurePut3.isSuccess());


    // verify put of version 3
    assertEquals("data3",
        (String) p2.get(lKey).setContentKey(cKey).setVersionKey(vKey3).setDomainKey(dKey).start()
            .awaitUninterruptibly().getData().object());
    
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey3).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data3", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());


    // try to put a version X in version key range of version 1 and 3 with wrong protection keys 2
    // (expected to fail)
    Data dataX = new Data("dataX").setProtectedEntry();
    Number160 vKeyX = Number160.createHash("versionX");
    FuturePut futurePut4 = p1.put(lKey).setData(cKey, dataX).setDomainKey(dKey).setVersionKey(vKeyX)
        .keyPair(keyPair2).start();
    futurePut4.awaitUninterruptibly();
    assertFalse(futurePut4.isSuccess());


    // verify no put of version X
    assertNull(p2.get(lKey).setContentKey(cKey).setVersionKey(vKeyX).setDomainKey(dKey).start()
        .awaitUninterruptibly().getData());


    // try to put random version Y in version key range of version 1 and 3 without protection keys
    // (expected to fail)
    Data dataY = new Data("dataY").setProtectedEntry();
    Number160 vKeyY = Number160.createHash("versionX");
    futurePut4 = p1.put(lKey).setData(cKey, dataY).setDomainKey(dKey).setVersionKey(vKeyY).start();
    futurePut4.awaitUninterruptibly();
    assertFalse(futurePut4.isSuccess());

View Full Code Here

    Number160 lKey = Number160.createHash("location");
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");


    // put version 1 with protection keys 1
    Data data1 = new Data("data1").setProtectedEntry();
    Number160 vKey1 = Number160.ZERO;
    FuturePut futurePut1 = p1.put(lKey).setData(cKey, data1).setDomainKey(dKey).setVersionKey(vKey1)
        .keyPair(keyPair1).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());


    // put new version 2 (basing on version 1) with protection keys 1
    Data data2 = new Data("data2").basedOn(vKey1).setProtectedEntry();
    // version 2 takes new version key
    Number160 vKey2 = Number160.createHash("version2");
    FuturePut futurePut2 = p1.put(lKey).setData(cKey, data2).setDomainKey(dKey).setVersionKey(vKey2)
        .keyPair(keyPair1).start();
    futurePut2.awaitUninterruptibly();
    assertTrue(futurePut2.isSuccess());


    // change protection key on version 1 with a put meta
    Data dataMeta = new Data().setProtectedEntry().publicKey(keyPair2.getPublic()).duplicateMeta();
    // use the old protection key 1 to sign the message
    FuturePut futurePutMeta = p1.put(lKey).setDomainKey(dKey).setVersionKey(vKey1).putMeta()
        .setData(cKey, dataMeta).keyPair(keyPair1).start();
    futurePutMeta.awaitUninterruptibly();
    assertTrue(futurePutMeta.isSuccess());


    // verify change at version 1
    Data retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1", (String) retData.object());
    // verify change of content protection keys to 2
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    
    // verify change at version 2
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey2).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data2", (String) retData.object());
    // verify change of content protection keys to 2
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());    // <==== is keypair1 but should be keypair2


    // overwrite version 1 with protection keys 2
    Data data1Overwrite = new Data("data1Overwrite").setProtectedEntry();
    FuturePut futurePut1Overwrite = p1.put(lKey).setData(cKey, data1Overwrite).setDomainKey(dKey)
        .setVersionKey(vKey1).keyPair(keyPair2).start();
    futurePut1Overwrite.awaitUninterruptibly();
    assertTrue(futurePut1Overwrite.isSuccess());
    
    // verify overwrite version 1
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey1).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data1Overwrite", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());


    // overwrite version 2 with protection keys 2
    Data data2Overwrite = new Data("data2Overwrite").setProtectedEntry();
    FuturePut futurePut2Overwrite = p1.put(lKey).setData(cKey, data2Overwrite).setDomainKey(dKey)
        .setVersionKey(vKey2).keyPair(keyPair2).start();
    futurePut2Overwrite.awaitUninterruptibly();
    assertTrue(futurePut2Overwrite.isSuccess());


    // verify overwrite version 2
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey2).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data2Overwrite", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());
    
    // put new version 3 (basing on version 2) with protection keys 2
    Data data3 = new Data("data3").basedOn(vKey2).setProtectedEntry();
    Number160 vKey3 = Number160.createHash("version3");
    FuturePut futurePut3 = p1.put(lKey).setData(cKey, data3).setDomainKey(dKey).setVersionKey(vKey3)
        .keyPair(keyPair2).start();
    futurePut3.awaitUninterruptibly();
    assertTrue(futurePut3.isSuccess());
    
    // verify put version 3
    retData = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey3).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data3", (String) retData.object());
    Assert.assertEquals(keyPair2.getPublic(), retData.publicKey());


    // try to put a version X in version key range of version 1, 2 and 3 with wrong protection keys 1
    // (expected to fail)
    Data dataX = new Data("dataX").setProtectedEntry();
    Number160 vKeyX = Number160.createHash("versionX");
    FuturePut futurePut4 = p1.put(lKey).setData(cKey, dataX).setDomainKey(dKey).setVersionKey(vKeyX)
        .keyPair(keyPair1).start();
    futurePut4.awaitUninterruptibly();
    assertFalse(futurePut4.isSuccess());


    // verify no put of version X
    assertNull(p2.get(lKey).setContentKey(cKey).setVersionKey(vKeyX).setDomainKey(dKey).start()
        .awaitUninterruptibly().getData());


    // try to put random version Y in version key range of version 1, 2 and 3 without protection keys
    // (expected to fail)
    Data dataY = new Data("dataY").setProtectedEntry();
    Number160 vKeyY = Number160.createHash("versionX");
    futurePut4 = p1.put(lKey).setData(cKey, dataY).setDomainKey(dKey).setVersionKey(vKeyY).start();
    futurePut4.awaitUninterruptibly();
    assertFalse(futurePut4.isSuccess());

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of net.tomp2p.storage.Data

io.netty.buffer.ByteBuf

lupos.distributed.p2p.network.impl.TomP2P

net.tomp2p.connection.DSASignatureFactory

net.tomp2p.dht.AddBuilder

net.tomp2p.dht.PutBuilder

net.tomp2p.dht.StorageLayer

net.tomp2p.dht.StorageRPC

net.tomp2p.dht.TestAddUpdateTTL

net.tomp2p.dht.TestDHT

net.tomp2p.dht.TestH2H

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.