Examples of net.tomp2p.p2p.Peer

net.tomp2p.p2p.Peer
This is the main class to start DHT operations. This class makes use of the build pattern and for each DHT operation, a builder class is returned. The main operations can be initiated with {@link #put(Number160)}, {@link #get(Number160)}, {@link #add(Number160)}, {@link #addTracker(Number160)}, {@link #getTracker(Number160)}, {@link #remove(Number160)}, {@link #submit(Number160,Worker)}, {@link #send(Number160)}, {@link #sendDirect()}, {@link #broadcast(Number160)}. Each of those operations return a builder that offers more options. One of the main difference to a "regular" DHT is that TomP2P can store a map (key-values) instead of just values. To distinguish those, the keys are termed location key (for finding the right peer in the network), and content key (to store more than one value on a peer). For the put builder e.g. the following options can be set:
- {@link PutBuilder#setData(Number160,net.tomp2p.storage.Data)} - puts a content key with a value
- {@link PutBuilder#dataMap(Map) - puts multiple content key / values at once
- {@link PutBuilder#setPutIfAbsent() - only puts data if its not already on the peers
- ...
Furthermore, TomP2P also provides to store keys in different domains to avoid key collisions }( {@link PutBuilder#setDomainKey(Number160)).} @author Thomas Bocek

    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    SignatureFactory factory = new DSASignatureFactory();


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4838).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair = gen.generateKeyPair();


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

    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    SignatureFactory factory = new DSASignatureFactory();


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4838).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


    Number160 lKey = Number160.createHash("location");
    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();
    futureGet2a.awaitUninterruptibly();
    assertTrue(futureGet2a.isSuccess());
    // should have been not modified
    retData = futureGet2a.getData();
    assertEquals(testData1, (String) retData.object());
    assertEquals(keyPair1.getPublic(), retData.publicKey());


    FutureGet futureGet2b = p2.get(lKey).setContentKey(cKey).setDomainKey(dKey).start();
    futureGet2b.awaitUninterruptibly();
    assertTrue(futureGet2b.isSuccess());
    // should have been not modified
    retData = futureGet2b.getData();
    assertEquals(testData1, (String) retData.object());
    assertEquals(keyPair1.getPublic(), retData.publicKey());


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

View Full Code Here

  public void testRemoveWithWrongOrWrongContentProtectionKeys() throws NoSuchAlgorithmException,
      IOException, InvalidKeyException, SignatureException, ClassNotFoundException {
    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4836).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


    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
    FutureRemove futureRemove1 = p1.remove(lKey).contentKey(cKey).start();
    futureRemove1.awaitUninterruptibly();
    assertFalse(futureRemove1.isSuccess());


    // verify failed remove
    FutureGet futureGet2 = p1.get(lKey).setContentKey(cKey).start();
    futureGet2.awaitUninterruptibly();
    assertTrue(futureGet2.isSuccess());
    // should have been not modified
    assertEquals(testData1, (String) futureGet2.getData().object());
    assertEquals(keyPair1.getPublic(), futureGet2.getData().publicKey());


    // try to remove with wrong content protection keys 2
    FutureRemove futureRemove2 = p1.remove(lKey).contentKey(cKey).keyPair(keyPair2).start();
    futureRemove2.awaitUninterruptibly();
    assertFalse(futureRemove2.isSuccess());


    // verify failed remove
    FutureGet futureGet3 = p1.get(lKey).setContentKey(cKey).start();
    futureGet3.awaitUninterruptibly();
    assertTrue(futureGet3.isSuccess());
    // should have been not modified
    assertEquals(testData1, (String) futureGet3.getData().object());
    assertEquals(keyPair1.getPublic(), futureGet3.getData().publicKey());


    // remove with correct content protection keys
    FutureRemove futureRemove4 = p1.remove(lKey).contentKey(cKey).keyPair(keyPair1).start();
    futureRemove4.awaitUninterruptibly();
    assertTrue(futureRemove4.isSuccess());


    // verify remove from peer 1
    FutureGet futureGet4a = p1.get(lKey).setContentKey(cKey).start();
    futureGet4a.awaitUninterruptibly();
    assertFalse(futureGet4a.isSuccess());
    // should have been removed
    assertNull(futureGet4a.getData());


    // verify remove from peer 2
    FutureGet futureGet4b = p2.get(lKey).setContentKey(cKey).start();
    futureGet4b.awaitUninterruptibly();
    assertFalse(futureGet4b.isSuccess());
    // should have been removed
    assertNull(futureGet4b.getData());


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

View Full Code Here

  public void testRemoveWithFromToContentProtectedEntry() throws NoSuchAlgorithmException, IOException,
      InvalidKeyException, SignatureException, ClassNotFoundException {
    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4838).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair key1 = gen.generateKeyPair();
    KeyPair key2 = gen.generateKeyPair();


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


    // try to remove without content protection keys using from/to
    FutureRemove futureRemove1 = p1.remove(lKey).from(new Number640(lKey, dKey, cKey, Number160.ZERO))
        .to(new Number640(lKey, dKey, cKey, Number160.MAX_VALUE)).start();
    futureRemove1.awaitUninterruptibly();
    assertFalse(futureRemove1.isSuccess());


    // verify failed remove
    FutureGet futureGet2 = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey)
        .start();
    futureGet2.awaitUninterruptibly();
    assertTrue(futureGet2.isSuccess());
    // should have been not modified
    assertEquals(testData1, (String) futureGet2.getData().object());
    assertEquals(key1.getPublic(), futureGet2.getData().publicKey());


    // remove with wrong content protection keys 2 using from/to
    FutureRemove futureRemove2a = p1.remove(lKey).from(new Number640(lKey, dKey, cKey, Number160.ZERO))
        .to(new Number640(lKey, dKey, cKey, Number160.MAX_VALUE)).keyPair(key2).start();
    futureRemove2a.awaitUninterruptibly();
    assertFalse(futureRemove2a.isSuccess());


    // verify failed remove
    FutureGet futureGet3 = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey)
        .start();
    futureGet3.awaitUninterruptibly();
    assertTrue(futureGet3.isSuccess());
    // should have been not modified
    assertEquals(testData1, (String) futureGet3.getData().object());
    assertEquals(key1.getPublic(), futureGet3.getData().publicKey());


    // remove with correct content protection keys 1 using from/to
    FutureRemove futureRemove4 = p1.remove(lKey).from(new Number640(lKey, dKey, cKey, Number160.ZERO))
        .to(new Number640(lKey, dKey, cKey, Number160.MAX_VALUE)).keyPair(key1).start();
    futureRemove4.awaitUninterruptibly();
    assertTrue(futureRemove4.isSuccess());


    // verify remove
    FutureGet futureGet4 = p2.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey)
        .start();
    futureGet4.awaitUninterruptibly();
    // we did not find the data
    Assert.assertTrue(futureGet4.isFailed());
    // should have been removed
    assertNull(futureGet4.getData());


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

View Full Code Here

  public void testRemoveWithFromToSeveralVersionWithContentProtection() throws NoSuchAlgorithmException,
      IOException, InvalidKeyException, SignatureException, ClassNotFoundException {
    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4838).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair key = gen.generateKeyPair();


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


    // remove with correct content protection keys using from/to
    FutureRemove futureRemove = p1.remove(lKey).from(new Number640(lKey, dKey, cKey, Number160.ZERO))
        .to(new Number640(lKey, dKey, cKey, Number160.MAX_VALUE)).keyPair(key).start();
    futureRemove.awaitUninterruptibly();
    assertTrue(futureRemove.isSuccess());


    // verify remove of version 1
    FutureGet futureGet4a = p2.get(lKey).setContentKey(cKey).setVersionKey(vKey1).start();
    futureGet4a.awaitUninterruptibly();
    // we did not find the data
    Assert.assertTrue(futureGet4a.isFailed());
    // should have been removed
    assertNull(futureGet4a.getData());


    // verify remove of version 2
    FutureGet futureGet4b = p2.get(lKey).setContentKey(cKey).setVersionKey(vKey2).start();
    futureGet4b.awaitUninterruptibly();
    // we did not find the data
    Assert.assertTrue(futureGet4b.isFailed());
    // should have been removed
    assertNull(futureGet4b.getData());


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

View Full Code Here

  public void testChangeProtectionKeyWithoutDataSignature() throws IOException, ClassNotFoundException,
      NoSuchAlgorithmException, InvalidKeyException, SignatureException {
    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4838).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


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


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


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

View Full Code Here

  public void testChangeProtectionKeyWithVersionKeyWithoutDataSignature() throws NoSuchAlgorithmException,
      IOException, ClassNotFoundException, InvalidKeyException, SignatureException {
    KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4834).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


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


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


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

View Full Code Here

    clientConfig.signatureFactory(factory);
    ChannelServerConficuration serverConfig = PeerMaker.createDefaultChannelServerConfiguration();
    serverConfig.signatureFactory(factory);


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4834).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).channelClientConfiguration(clientConfig)
        .channelServerConfiguration(serverConfig).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).channelClientConfiguration(clientConfig)
        .channelServerConfiguration(serverConfig).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


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

    clientConfig.signatureFactory(factory);
    ChannelServerConficuration serverConfig = PeerMaker.createDefaultChannelServerConfiguration();
    serverConfig.signatureFactory(factory);


    KeyPair keyPairPeer1 = gen.generateKeyPair();
    Peer p1 = new PeerMaker(Number160.createHash(1)).ports(4834).keyPair(keyPairPeer1)
        .setEnableIndirectReplication(true).channelClientConfiguration(clientConfig)
        .channelServerConfiguration(serverConfig).makeAndListen();
    KeyPair keyPairPeer2 = gen.generateKeyPair();
    Peer p2 = new PeerMaker(Number160.createHash(2)).masterPeer(p1).keyPair(keyPairPeer2)
        .setEnableIndirectReplication(true).channelClientConfiguration(clientConfig)
        .channelServerConfiguration(serverConfig).makeAndListen();


    p2.bootstrap().setPeerAddress(p1.getPeerAddress()).start().awaitUninterruptibly();
    p1.bootstrap().setPeerAddress(p2.getPeerAddress()).start().awaitUninterruptibly();


    KeyPair keyPair1 = gen.generateKeyPair();
    KeyPair keyPair2 = gen.generateKeyPair();


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


    // verify change
    retData = p1.get(lKey).setDomainKey(dKey).setContentKey(cKey).setVersionKey(vKey).start()
        .awaitUninterruptibly().getData();
    Assert.assertEquals("data4", (String) retData.object());
    Assert.assertEquals(keyPair1.getPublic(), retData.publicKey());
    // verify that data signature wasn't changed
    Assert.assertTrue(retData.verify(keyPair1.getPublic(), factory));


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

View Full Code Here

          while(true){
              peer.send(Number160.createHash("client")).object("ping").start();
              Thread.sleep(1000);
          }
    } else {
      final Peer peer = new PeerBuilder(Number160.createHash("client")).ports(1235).start();
            List<PeerAddress> bootstrap = new ArrayList<PeerAddress>();
            bootstrap.add(new PeerAddress(Number160.createHash("master"), "localhost", 1234,1234));
            peer.bootstrap().bootstrapTo(bootstrap).start();


            peer.objectDataReply(new ObjectDataReply() {
                public Object reply(PeerAddress sender, Object request) throws Exception {
                    System.err.println("client received: " + request.toString());
                    return "pong";
                }
            });

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of net.tomp2p.p2p.Peer

lupos.distributed.p2p.network.impl.TomP2P

net.tomp2p.connection.ChannelCreator

net.tomp2p.connection.PeerConnection

net.tomp2p.dht.TestAddUpdateTTL

net.tomp2p.dht.TestDHT

net.tomp2p.dht.TestRealNetwork

net.tomp2p.dht.TestSend

net.tomp2p.dht.UtilsDHT2

net.tomp2p.examples.ExampleDiscover

net.tomp2p.examples.ExampleDST

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.