private void receiveMessage(ObjectMessage objectMessage) { requestedObjects.remove(objectMessage.getInventoryVector()); if (ctx.getInventory().contains(objectMessage)) { LOG.trace("Received object " + objectMessage.getInventoryVector() + " - already in inventory"); return; } try { listener.receive(objectMessage); cryptography().checkProofOfWork(objectMessage, NETWORK_NONCE_TRIALS_PER_BYTE, NETWORK_EXTRA_BYTES); ctx.getInventory().storeObject(objectMessage); // offer object to some random nodes so it gets distributed throughout the network: ctx.getNetworkHandler().offer(objectMessage.getInventoryVector()); lastObjectTime = UnixTime.now(); } catch (InsufficientProofOfWorkException e) { LOG.warn(e.getMessage()); // DebugUtils.saveToFile(objectMessage); // this line must not be committed active } catch (IOException e) { LOG.error("Stream " + objectMessage.getStream() + ", object type " + objectMessage.getType() + ": " + e.getMessage(), e); } finally { if (commonRequestedObjects.remove(objectMessage.getInventoryVector()) == null) { LOG.debug("Received object that wasn't requested."); } } }
private void tryToFindBroadcastsForAddress(BitmessageAddress address) { for (ObjectMessage object : ctx.getInventory().getObjects(address.getStream(), Broadcast.getVersion(address), ObjectType.BROADCAST)) { try { Broadcast broadcast = (Broadcast) object.getPayload(); broadcast.decrypt(address); listener.receive(broadcast.getPlaintext()); } catch (DecryptionFailedException ignore) { } catch (Exception e) { LOG.debug(e.getMessage(), e); } } }
/** * Removes expired objects from the inventory. You should call this method regularly, * e.g. daily and on each shutdown. */ public void cleanup() { ctx.getInventory().cleanup(); }
public void requestPubkey(BitmessageAddress contact) { long expires = UnixTime.now(+2 * DAY); LOG.info("Expires at " + expires); ObjectMessage response = new ObjectMessage.Builder() .stream(contact.getStream()) .expiresTime(expires) .payload(new GetPubkey(contact)) .build(); Security.doProofOfWork(response, proofOfWorkEngine, networkNonceTrialsPerByte, networkExtraBytes); inventory.storeObject(response); networkHandler.offer(response.getInventoryVector()); }
private void sendInventory() { List<InventoryVector> inventory = ctx.getInventory().getInventory(streams); for (int i = 0; i < inventory.size(); i += 50000) { sendingQueue.offer(new Inv.Builder() .inventory(inventory.subList(i, Math.min(inventory.size(), i + 50000))) .build()); } }
private void receiveMessage(GetData getData) { for (InventoryVector iv : getData.getInventory()) { ObjectMessage om = ctx.getInventory().getObject(iv); if (om != null) sendingQueue.offer(om); } }
private void receiveMessage(Inv inv) { int originalSize = inv.getInventory().size(); updateIvCache(inv.getInventory()); List<InventoryVector> missing = ctx.getInventory().getMissing(inv.getInventory(), streams); missing.removeAll(commonRequestedObjects.keySet()); LOG.trace("Received inventory with " + originalSize + " elements, of which are " + missing.size() + " missing."); send(new GetData.Builder().inventory(missing).build()); }
private void send(long stream, ObjectPayload payload, long timeToLive) { long expires = UnixTime.now(+timeToLive); LOG.info("Expires at " + expires); ObjectMessage object = new ObjectMessage.Builder() .stream(stream) .expiresTime(expires) .payload(payload) .build(); Security.doProofOfWork(object, ctx.getProofOfWorkEngine(), ctx.getNetworkNonceTrialsPerByte(), ctx.getNetworkExtraBytes()); ctx.getInventory().storeObject(object); ctx.getNetworkHandler().offer(object.getInventoryVector()); }
public void send(BitmessageAddress from, BitmessageAddress to, ObjectPayload payload, long timeToLive, long nonceTrialsPerByte, long extraBytes) { try { if (to == null) to = from; long expires = UnixTime.now(+timeToLive); LOG.info("Expires at " + expires); ObjectMessage object = new ObjectMessage.Builder() .stream(to.getStream()) .expiresTime(expires) .payload(payload) .build(); if (object.isSigned()) { object.sign(from.getPrivateKey()); } if (payload instanceof Broadcast) { ((Broadcast) payload).encrypt(); } else if (payload instanceof Encrypted) { object.encrypt(to.getPubkey()); } Security.doProofOfWork(object, proofOfWorkEngine, nonceTrialsPerByte, extraBytes); if (payload instanceof PlaintextHolder) { Plaintext plaintext = ((PlaintextHolder) payload).getPlaintext(); plaintext.setInventoryVector(object.getInventoryVector()); messageRepository.save(plaintext); } inventory.storeObject(object); networkHandler.offer(object.getInventoryVector()); } catch (IOException e) { throw new RuntimeException(e); } }
private void tryToFindBroadcastsForAddress(BitmessageAddress address) { for (ObjectMessage object : ctx.getInventory().getObjects(address.getStream(), Broadcast.getVersion(address), ObjectType.BROADCAST)) { try { Broadcast broadcast = (Broadcast) object.getPayload(); broadcast.decrypt(address); // This decrypts it twice, but on the other hand it doesn't try to decrypt the objects with // other subscriptions and the interface stays as simple as possible. ctx.getNetworkListener().receive(object); } catch (DecryptionFailedException ignore) { } catch (Exception e) { LOG.debug(e.getMessage(), e); } } }
public void sendPubkey(BitmessageAddress identity, long targetStream) { try { long expires = UnixTime.now(+28 * DAY); LOG.info("Expires at " + expires); ObjectMessage response = new ObjectMessage.Builder() .stream(targetStream) .expiresTime(expires) .payload(identity.getPubkey()) .build(); response.sign(identity.getPrivateKey()); response.encrypt(Security.createPublicKey(identity.getPublicDecryptionKey()).getEncoded(false)); Security.doProofOfWork(response, proofOfWorkEngine, networkNonceTrialsPerByte, networkExtraBytes); if (response.isSigned()) { response.sign(identity.getPrivateKey()); } if (response instanceof Encrypted) { response.encrypt(Security.createPublicKey(identity.getPublicDecryptionKey()).getEncoded(false)); } inventory.storeObject(response); networkHandler.offer(response.getInventoryVector()); // TODO: save that the pubkey was just sent, and on which stream! } catch (IOException e) { throw new RuntimeException(e); } }
private void tryToFindMatchingPubkey(BitmessageAddress address) { for (ObjectMessage object : ctx.getInventory().getObjects(address.getStream(), address.getVersion(), ObjectType.PUBKEY)) { try { Pubkey pubkey = (Pubkey) object.getPayload(); if (address.getVersion() == 4) { V4Pubkey v4Pubkey = (V4Pubkey) pubkey; if (Arrays.equals(address.getTag(), v4Pubkey.getTag())) { v4Pubkey.decrypt(address.getPublicDecryptionKey()); if (object.isSignatureValid(v4Pubkey)) { address.setPubkey(v4Pubkey); ctx.getAddressRepo().save(address); break; } else { LOG.debug("Found pubkey for " + address + " but signature is invalid"); } } } else { if (Arrays.equals(pubkey.getRipe(), address.getRipe())) { address.setPubkey(pubkey); ctx.getAddressRepo().save(address); break; } } } catch (Exception e) { LOG.debug(e.getMessage(), e); } } }
protected void receive(InventoryVector iv, Plaintext msg) { msg.setInventoryVector(iv); labeler.setLabels(msg); ctx.getMessageRepository().save(msg); listener.receive(msg); updatePubkey(msg.getFrom(), msg.getFrom().getPubkey()); if (msg.getType() == Plaintext.Type.MSG && msg.getTo().has(Pubkey.Feature.DOES_ACK)) { ObjectMessage ack = msg.getAckMessage(); if (ack != null) { ctx.getInventory().storeObject(ack); ctx.getNetworkHandler().offer(ack.getInventoryVector()); } } } }
address.setSubscribed(stored.isSubscribed()); for (ObjectMessage object : inventory.getObjects(address.getStream(), address.getVersion(), ObjectType.PUBKEY)) { try { Pubkey pubkey = (Pubkey) object.getPayload();
LOG.debug(e.getMessage(), e); ctx.getInventory().storeObject(object); ctx.getNetworkHandler().offer(object.getInventoryVector()); } else {