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 lKey = Number160.createHash("location");
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");


    String testData = "data";
    Data data = new Data(testData).setProtectedEntry();


    // put with protection key
    FuturePut futurePut1 = p1.put(lKey).setData(cKey, data).setDomainKey(dKey).keyPair(keyPair).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());


    // verify put from peer 1
    FutureGet futureGet1a = p1.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet1a.awaitUninterruptibly();
    assertTrue(futureGet1a.isSuccess());
    Data retData = futureGet1a.getData();
    assertEquals(testData, (String) retData.object());
    assertEquals(keyPair.getPublic(), retData.publicKey());


    // verify put from peer 2
    FutureGet futureGet1b = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet1b.awaitUninterruptibly();
    assertTrue(futureGet1b.isSuccess());
    retData = futureGet1b.getData();
    assertEquals(testData, (String) retData.object());
    assertEquals(keyPair.getPublic(), retData.publicKey());


    // try a put without a protection key (through peer 2)
    Data data2 = new Data("data2");
    FuturePut futurePut2 = p2.put(lKey).setData(cKey, data2).setDomainKey(dKey).start();
    futurePut2.awaitUninterruptibly();
    assertFalse(futurePut2.isSuccess());


    // verify that nothing changed from peer 1
    FutureGet futureGet2a = p1.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet2a.awaitUninterruptibly();
    assertTrue(futureGet2a.isSuccess());
    retData = futureGet2a.getData();
    // should have been not modified
    assertEquals(testData, (String) retData.object());
    assertEquals(keyPair.getPublic(), retData.publicKey());


    // verify that nothing changed from peer 2
    FutureGet futureGet2b = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet2b.awaitUninterruptibly();
    assertTrue(futureGet2b.isSuccess());
    retData = futureGet2b.getData();
    // should have been not modified
    assertEquals(testData, (String) retData.object());
    assertEquals(keyPair.getPublic(), retData.publicKey());


    // overwrite
    String newTestData = "new data";
    data = new Data(newTestData).setProtectedEntry();
    // sign put message with protection keys
    FuturePut futurePut4 = p1.put(lKey).setData(cKey, data).keyPair(keyPair).setDomainKey(dKey).start();
    futurePut4.awaitUninterruptibly();
    Assert.assertTrue(futurePut4.isSuccess());

View Full Code Here

    Number160 cKey = Number160.createHash("content");
    Number160 vKey = Number160.createHash("version");
    Number160 bKey = Number160.createHash("based on");


    String testData = "data";
    Data data = new Data(testData).setProtectedEntry().sign(keyPair, factory);
    data.ttlSeconds(10000).basedOn(bKey);


    FuturePut futurePut1 = p1.put(lKey).setData(cKey, data).setDomainKey(dKey).setVersionKey(vKey)
        .keyPair(keyPair).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());


    FutureGet futureGet1a = p1.get(lKey).setContentKey(cKey).setDomainKey(dKey).setVersionKey(vKey)
        .start();
    futureGet1a.awaitUninterruptibly();
    assertTrue(futureGet1a.isSuccess());
    Data retData = futureGet1a.getData();
    assertEquals(testData, (String) retData.object());
    assertTrue(retData.verify(keyPair.getPublic(), factory));
    assertEquals(keyPair.getPublic(), retData.publicKey());


    FutureGet futureGet1b = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).setVersionKey(vKey)
        .start();
    futureGet1b.awaitUninterruptibly();
    assertTrue(futureGet1b.isSuccess());
    retData = futureGet1b.getData();
    assertEquals(testData, (String) retData.object());
    assertTrue(retData.verify(keyPair.getPublic(), factory));
    assertEquals(keyPair.getPublic(), retData.publicKey());


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

View Full Code Here

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


    // initial put using content protection keys 1
    String testData1 = "data1";
    Data data = new Data(testData1).setProtectedEntry();
    FuturePut futurePut1 = p1.put(lKey).setData(cKey, data).setDomainKey(dKey).keyPair(keyPair1).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());


    FutureGet futureGet1a = p1.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet1a.awaitUninterruptibly();
    assertTrue(futureGet1a.isSuccess());
    Data retData = futureGet1a.getData();
    assertEquals(testData1, (String) retData.object());
    assertEquals(keyPair1.getPublic(), retData.publicKey());


    FutureGet futureGet1b = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet1b.awaitUninterruptibly();
    assertTrue(futureGet1b.isSuccess());
    retData = futureGet1b.getData();
    assertEquals(testData1, (String) retData.object());
    assertEquals(keyPair1.getPublic(), retData.publicKey());


    // try to put with wrong content protection keys 2
    String testData2 = "data2";
    Data data2 = new Data(testData2).setProtectedEntry().sign(keyPair2, factory);
    FuturePut futurePut2 = p2.put(lKey).setData(cKey, data2).setDomainKey(dKey).keyPair(keyPair2).start();
    futurePut2.awaitUninterruptibly();
    assertFalse(futurePut2.isSuccess());


    FutureGet futureGet2a = p1.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();

View Full Code Here

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


    // put with content protection keys 1
    String testData1 = "data1";
    Data data = new Data(testData1).setProtectedEntry();
    FuturePut futurePut1 = p1.put(lKey).setData(cKey, data).keyPair(keyPair1).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());


    // try to remove without content protection keys

View Full Code Here

    Number160 cKey = Number160.createHash("content");
    Number160 vKey = Number160.createHash("version");


    // put with content protection keys 1
    String testData1 = "data1";
    Data data = new Data(testData1).setProtectedEntry();
    FuturePut futurePut1 = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(key1).start();
    futurePut1.awaitUninterruptibly();
    assertTrue(futurePut1.isSuccess());

View Full Code Here

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


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


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

View Full Code Here

    Number160 lKey = Number160.createHash(2); // same like node 2
    Number160 dKey = Number160.createHash("domain");
    Number160 cKey = Number160.createHash("content");


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


    // change protection keys to protection keys 2, create meta data
    Data data3 = new Data().setProtectedEntry().publicKey(keyPair2.getPublic()).duplicateMeta();
    // use the old protection key 1 to sign the message
    FuturePut futurePut3 = p1.put(lKey).setDomainKey(dKey).putMeta().setData(cKey, data3)
        .keyPair(keyPair1).start();
    futurePut3.awaitUninterruptibly();
    assertTrue(futurePut3.isSuccess());


    // verify that nothing changed
    FutureGet futureGet = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start()
        .awaitUninterruptibly();
    assertEquals("data1", (String) futureGet.getData().object());
    // verify new content protection keys 2
    assertEquals(keyPair2.getPublic(), futureGet.getData().publicKey());


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


    // verify overwrite
    futureGet = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start()
        .awaitUninterruptibly();
    assertEquals("data4", (String) futureGet.getData().object());
    assertEquals(keyPair2.getPublic(), futureGet.getData().publicKey());


    // try to overwrite without protection keys (expected to fail)
    Data data5A = new Data("data5A");
    FuturePut futurePut5A = p1.put(lKey).setData(cKey, data5A).setDomainKey(dKey).start();
    futurePut5A.awaitUninterruptibly();
    assertFalse(futurePut5A.isSuccess());


    // verify that nothing changed
    futureGet = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start()
        .awaitUninterruptibly();
    assertEquals("data4", (String) futureGet.getData().object());
    assertEquals(keyPair2.getPublic(), futureGet.getData().publicKey());


    // try to overwrite with wrong protection keys 1 (expected to fail)
    Data data5B = new Data("data5B").setProtectedEntry();
    FuturePut futurePut5B = p1.put(lKey).setData(cKey, data5B).setDomainKey(dKey).keyPair(keyPair1)
        .start();
    futurePut5B.awaitUninterruptibly();
    assertFalse(futurePut5B.isSuccess());

View Full Code Here

    Number160 cKey = Number160.createHash("content");
    Number160 vKey = Number160.createHash("version");
    Number160 bKey = Number160.createHash("based on");


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


    // overwrite with protection keys 1
    Data data2 = new Data("data2").basedOn(bKey).setProtectedEntry();
    FuturePut futurePut2 = p1.put(lKey).setData(cKey, data2).setDomainKey(dKey).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futurePut2.awaitUninterruptibly();
    assertTrue(futurePut2.isSuccess());


    // verify overwrite
    FutureGet futureGet = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).setVersionKey(vKey).start()
        .awaitUninterruptibly();
    assertEquals("data2", (String) futureGet.getData().object());
    assertEquals(keyPair1.getPublic(), futureGet.getData().publicKey());


    // try to overwrite without protection keys (expected to fail)
    Data data2A = new Data("data2A").basedOn(bKey);
    FuturePut futurePut2A = p1.put(lKey).setData(cKey, data2A).setDomainKey(dKey).setVersionKey(vKey)
        .start();
    futurePut2A.awaitUninterruptibly();
    assertFalse(futurePut2A.isSuccess());


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


    // try to overwrite with wrong protection keys 2 (expected to fail)
    Data data2B = new Data("data2B").basedOn(bKey).setProtectedEntry();
    FuturePut futurePut2B = p1.put(lKey).setData(cKey, data2B).setDomainKey(dKey).setVersionKey(vKey)
        .keyPair(keyPair2).start();
    futurePut2B.awaitUninterruptibly();
    assertFalse(futurePut2B.isSuccess());


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


    // change protection keys to protection keys 2, create meta data
    Data data3 = new Data().setProtectedEntry().publicKey(keyPair2.getPublic()).duplicateMeta();
    // use the old protection key 1 to sign the message
    FuturePut futurePut3 = p1.put(lKey).setDomainKey(dKey).setVersionKey(vKey).putMeta()
        .setData(cKey, data3).keyPair(keyPair1).start();
    futurePut3.awaitUninterruptibly();
    assertTrue(futurePut3.isSuccess());


    // verify change
    futureGet = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).setVersionKey(vKey).start()
        .awaitUninterruptibly();
    // data stays the same
    assertEquals("data2", (String) futureGet.getData().object());
    // should be new protection key
    assertEquals(keyPair2.getPublic(), futureGet.getData().publicKey());


    // overwrite with protection keys 2
    Data data4 = new Data("data4").basedOn(bKey).setProtectedEntry();
    FuturePut futurePut4 = p1.put(lKey).setData(cKey, data4).setDomainKey(dKey).setVersionKey(vKey)
        .keyPair(keyPair2).start();
    futurePut4.awaitUninterruptibly();
    assertTrue(futurePut4.isSuccess());


    // verify overwrite
    futureGet = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).setVersionKey(vKey).start()
        .awaitUninterruptibly();
    assertEquals("data4", (String) futureGet.getData().object());
    assertEquals(keyPair2.getPublic(), futureGet.getData().publicKey());


    // try to overwrite without protection keys (expected to fail)
    Data data5A = new Data("data5A").basedOn(bKey);
    FuturePut futurePut5A = p1.put(lKey).setData(cKey, data5A).setDomainKey(dKey).setVersionKey(vKey)
        .start();
    futurePut5A.awaitUninterruptibly();
    assertFalse(futurePut5A.isSuccess());


    // verify that nothing changed
    futureGet = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).setVersionKey(vKey).start()
        .awaitUninterruptibly();
    assertEquals("data4", (String) futureGet.getData().object());
    assertEquals(keyPair2.getPublic(), futureGet.getData().publicKey());
    
    // try to overwrite with wrong protection keys 1 (expected to fail)
    Data data5B = new Data("data5B").basedOn(bKey).setProtectedEntry();
    FuturePut futurePut5B = p1.put(lKey).setData(cKey, data5B).setDomainKey(dKey).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futurePut5B.awaitUninterruptibly();
    assertFalse(futurePut5B.isSuccess());

View Full Code Here

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


    // initial put with keys 1 and data signature
    Data data = new Data("data").sign(keyPair1, factory);
    data.ttlSeconds(ttl).basedOn(bKey);
    FuturePut futurePut = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey).start();
    futurePut.awaitUninterruptibly();
    Assert.assertTrue(futurePut.isSuccess());


    // 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);


    // verify data signature
    Assert.assertTrue(p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData().verify(keyPair1.getPublic(), factory));


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


    // verify new data signature
    Data retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    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 intialData = new Data("data").setProtectedEntry();
    intialData.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, intialData)
        .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("data", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify data signature
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


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


    // verify that nothing changed
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify that data signature is still the same
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


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


    // verify that nothing changed
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify that data signature is still the same
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


    // try to overwrite without content protection and without data signature (expected to fail)
    data = new Data("dataC");
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair1, factory);
    // put using wrong content protection keys 2 to sign message
    futureTryOverwrite = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey).start();
    futureTryOverwrite.awaitUninterruptibly();
    Assert.assertFalse(futureTryOverwrite.isSuccess());


    // verify that nothing changed
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify that data signature is still the same
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


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


    // verify that nothing changed
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify that data signature is still the same
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


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


    // verify overwrite
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data2", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify no signature
    Assert.assertNull(retData.signature());


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


    // verify overwrite
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data3", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify that data signature is still the same
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


    // create signature with keys 1 having the data object
    byte[] signature1 = factory.sign(keyPair1.getPrivate(), intialData.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, create meta data
    data.signed(true).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("data3", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify new data signature
    Assert.assertTrue(retData.verify(keyPair2.getPublic(), factory));


    // overwrite with content protection key 1 and data signature
    data = new Data("data4").setProtectedEntry();
    data.ttlSeconds(ttl).basedOn(bKey).sign(keyPair1, factory);
    // put using content content protection key 1 to sign message
    FuturePut futureOverwrite3 = p1.put(lKey).setDomainKey(dKey).setData(cKey, data).setVersionKey(vKey)
        .keyPair(keyPair1).start();
    futureOverwrite3.awaitUninterruptibly();
    Assert.assertTrue(futureOverwrite3.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.