/// <summary> /// Append a timestamp component and a random value component to interest's /// name. This ensures that the timestamp is greater than the timestamp used in /// the previous call. Then use keyChain to sign the interest which appends a /// SignatureInfo component and a component with the signature bits. If the /// interest lifetime is not set, this sets it. /// </summary> /// /// <param name="interest">The interest whose name is append with components.</param> /// <param name="keyChain">The KeyChain for calling sign.</param> /// <param name="certificateName">The certificate name of the key to use for signing.</param> /// <param name="wireFormat"></param> public void generate(Interest interest, KeyChain keyChain, Name certificateName, WireFormat wireFormat) { double timestamp; lock (lastTimestampLock_) { timestamp = Math.Round(net.named_data.jndn.util.Common.getNowMilliseconds(),MidpointRounding.AwayFromZero); while (timestamp <= lastTimestamp_) timestamp += 1.0d; // Update the timestamp now while it is locked. In the small chance that // signing fails, it just means that we have bumped the timestamp. lastTimestamp_ = timestamp; } // The timestamp is encoded as a TLV nonNegativeInteger. TlvEncoder encoder = new TlvEncoder(8); encoder.writeNonNegativeInteger((long) timestamp); interest.getName().append(new Blob(encoder.getOutput(), false)); // The random value is a TLV nonNegativeInteger too, but we know it is 8 bytes, // so we don't need to call the nonNegativeInteger encoder. ByteBuffer randomBuffer = ILOG.J2CsMapping.NIO.ByteBuffer.allocate(8); // Note: SecureRandom is thread safe. net.named_data.jndn.util.Common.getRandom().nextBytes(randomBuffer.array()); interest.getName().append(new Blob(randomBuffer, false)); keyChain.sign(interest, certificateName, wireFormat); if (interest.getInterestLifetimeMilliseconds() < 0) // The caller has not set the interest lifetime, so set it here. interest.setInterestLifetimeMilliseconds(1000.0d); }
/// <summary> /// Create a component whose value is the marker appended with the /// nonNegativeInteger encoding of the number. /// </summary> /// /// <param name="number">The number to be encoded.</param> /// <param name="marker">The marker to use as the first byte of the component.</param> /// <returns>The component value.</returns> public static Name.Component fromNumberWithMarker(long number, int marker) { if (number < 0) number = 0; TlvEncoder encoder = new TlvEncoder(9); // Encode backwards. encoder.writeNonNegativeInteger(number); encoder.writeNonNegativeInteger((long) marker); return new Name.Component (new Blob(encoder.getOutput(), false)); }
/// <summary> /// Create a component whose value is the nonNegativeInteger encoding of the /// number. /// </summary> /// /// <param name="number">The number to be encoded.</param> /// <returns>The component value.</returns> public static Name.Component fromNumber(long number) { if (number < 0) number = 0; TlvEncoder encoder = new TlvEncoder(8); encoder.writeNonNegativeInteger(number); return new Name.Component (new Blob(encoder.getOutput(), false)); }
/// <summary> /// Encode this Schedule. /// </summary> /// /// <returns>The encoded buffer.</returns> public Blob wireEncode() { // For now, don't use WireFormat and hardcode to use TLV since the encoding // doesn't go out over the wire, only into the local SQL database. TlvEncoder encoder = new TlvEncoder(256); int saveLength = encoder.getLength(); // Encode backwards. // Encode the blackIntervalList. int saveLengthForList = encoder.getLength(); Object[] array = ILOG.J2CsMapping.Collections.Collections.ToArray(blackIntervalList_); System.Array.Sort(array); for (int i = array.Length - 1; i >= 0; --i) { RepetitiveInterval element = (RepetitiveInterval) array[i]; encodeRepetitiveInterval(element, encoder); } encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_BlackIntervalList, encoder.getLength() - saveLengthForList); // Encode the whiteIntervalList. saveLengthForList = encoder.getLength(); array = ILOG.J2CsMapping.Collections.Collections.ToArray(whiteIntervalList_); System.Array.Sort(array); for (int i_0 = array.Length - 1; i_0 >= 0; --i_0) { RepetitiveInterval element_1 = (RepetitiveInterval) array[i_0]; encodeRepetitiveInterval(element_1, encoder); } encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_WhiteIntervalList, encoder.getLength() - saveLengthForList); encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_Schedule, encoder.getLength() - saveLength); return new Blob(encoder.getOutput(), false); }
/// <summary> /// Encode signature as a SignatureInfo in NDN-TLV and return the encoding. /// </summary> /// /// <param name="signature">An object of a subclass of Signature to encode.</param> /// <returns>A Blob containing the encoding.</returns> public override Blob encodeSignatureInfo(Signature signature) { TlvEncoder encoder = new TlvEncoder(256); encodeSignatureInfo(signature, encoder); return new Blob(encoder.getOutput(), false); }
/// <summary> /// Encode the signatureValue in the Signature object as a SignatureValue (the /// signature bits) in NDN-TLV and return the encoding. /// </summary> /// /// <param name="signature"></param> /// <returns>A Blob containing the encoding.</returns> public override Blob encodeSignatureValue(Signature signature) { TlvEncoder encoder = new TlvEncoder(256); encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureValue, signature.getSignature().buf()); return new Blob(encoder.getOutput(), false); }
/// <summary> /// Encode interest using NDN-TLV and return the encoding. /// </summary> /// /// <param name="interest">The Interest object to encode.</param> /// <param name="signedPortionBeginOffset">name component and ends just before the final name component (which is assumed to be a signature for a signed interest).</param> /// <param name="signedPortionEndOffset">name component and ends just before the final name component (which is assumed to be a signature for a signed interest).</param> /// <returns>A Blob containing the encoding.</returns> public override Blob encodeInterest(Interest interest, int[] signedPortionBeginOffset, int[] signedPortionEndOffset) { TlvEncoder encoder = new TlvEncoder(); int saveLength = encoder.getLength(); // Encode backwards. encoder.writeOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.SelectedDelegation, interest.getSelectedDelegationIndex()); try { Blob linkWireEncoding = interest.getLinkWireEncoding(this); if (!linkWireEncoding.isNull()) // Encode the entire link as is. encoder.writeBuffer(linkWireEncoding.buf()); } catch (EncodingException ex) { throw new Exception(ex.Message); } encoder.writeOptionalNonNegativeIntegerTlvFromDouble( net.named_data.jndn.encoding.tlv.Tlv.InterestLifetime, interest.getInterestLifetimeMilliseconds()); // Encode the Nonce as 4 bytes. if (interest.getNonce().size() == 0) { // This is the most common case. Generate a nonce. ByteBuffer nonce = ILOG.J2CsMapping.NIO.ByteBuffer.allocate(4); random_.nextBytes(nonce.array()); encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Nonce, nonce); } else if (interest.getNonce().size() < 4) { ByteBuffer nonce_0 = ILOG.J2CsMapping.NIO.ByteBuffer.allocate(4); // Copy existing nonce bytes. nonce_0.put(interest.getNonce().buf()); // Generate random bytes for remaining bytes in the nonce. for (int i = 0; i < 4 - interest.getNonce().size(); ++i) nonce_0.put((byte) random_.Next()); nonce_0.flip(); encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Nonce, nonce_0); } else if (interest.getNonce().size() == 4) // Use the nonce as-is. encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Nonce, interest.getNonce().buf()); else { // Truncate. ByteBuffer nonce_1 = interest.getNonce().buf(); // buf() returns a new ByteBuffer, so we can change its limit. nonce_1.limit(nonce_1.position() + 4); encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Nonce, nonce_1); } encodeSelectors(interest, encoder); int[] tempSignedPortionBeginOffset = new int[1]; int[] tempSignedPortionEndOffset = new int[1]; encodeName(interest.getName(), tempSignedPortionBeginOffset, tempSignedPortionEndOffset, encoder); int signedPortionBeginOffsetFromBack = encoder.getLength() - tempSignedPortionBeginOffset[0]; int signedPortionEndOffsetFromBack = encoder.getLength() - tempSignedPortionEndOffset[0]; encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Interest, encoder.getLength() - saveLength); signedPortionBeginOffset[0] = encoder.getLength() - signedPortionBeginOffsetFromBack; signedPortionEndOffset[0] = encoder.getLength() - signedPortionEndOffsetFromBack; return new Blob(encoder.getOutput(), false); }
/// <summary> /// Encode name in NDN-TLV and return the encoding. /// </summary> /// /// <param name="name">The Name object to encode.</param> /// <returns>A Blob containing the encoding.</returns> public override Blob encodeName(Name name) { TlvEncoder encoder = new TlvEncoder(); encodeName(name, new int[1], new int[1], encoder); return new Blob(encoder.getOutput(), false); }
/// <summary> /// Encode the EncryptedContent in NDN-TLV and return the encoding. /// </summary> /// /// <param name="encryptedContent">The EncryptedContent object to encode.</param> /// <returns>A Blob containing the encoding.</returns> public override Blob encodeEncryptedContent(EncryptedContent encryptedContent) { TlvEncoder encoder = new TlvEncoder(256); int saveLength = encoder.getLength(); // Encode backwards. encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EncryptedPayload, encryptedContent .getPayload().buf()); encoder.writeOptionalBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_InitialVector, encryptedContent.getInitialVector().buf()); // Assume the algorithmType value is the same as the TLV type. encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EncryptionAlgorithm, encryptedContent.getAlgorithmType().getNumericType()); Tlv0_2WireFormat.encodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.KeyLocator, encryptedContent.getKeyLocator(), encoder); encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EncryptedContent, encoder.getLength() - saveLength); return new Blob(encoder.getOutput(), false); }
/// <summary> /// Encode delegationSet as a sequence of NDN-TLV Delegation, and return the /// encoding. Note that the sequence of Delegation does not have an outer TLV /// type and length because it is intended to use the type and length of a Data /// packet's Content. /// </summary> /// /// <param name="delegationSet">The DelegationSet object to encode.</param> /// <returns>A Blob containing the encoding.</returns> public override Blob encodeDelegationSet(DelegationSet delegationSet) { TlvEncoder encoder = new TlvEncoder(256); // Encode backwards. for (int i = delegationSet.size() - 1; i >= 0; --i) { int saveLength = encoder.getLength(); encodeName(delegationSet.get(i).getName(), new int[1], new int[1], encoder); encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Link_Preference, delegationSet.get(i).getPreference()); encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Link_Delegation, encoder.getLength() - saveLength); } return new Blob(encoder.getOutput(), false); }
/// <summary> /// Encode data in NDN-TLV and return the encoding. /// </summary> /// /// <param name="data">The Data object to encode.</param> /// <param name="signedPortionBeginOffset">If you are not encoding in order to sign, you can call encodeData(data) to ignore this returned value.</param> /// <param name="signedPortionEndOffset">If you are not encoding in order to sign, you can call encodeData(data) to ignore this returned value.</param> /// <returns>A Blob containing the encoding.</returns> public override Blob encodeData(Data data, int[] signedPortionBeginOffset, int[] signedPortionEndOffset) { TlvEncoder encoder = new TlvEncoder(1500); int saveLength = encoder.getLength(); // Encode backwards. encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureValue, (data.getSignature()) .getSignature().buf()); int signedPortionEndOffsetFromBack = encoder.getLength(); encodeSignatureInfo(data.getSignature(), encoder); encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Content, data.getContent().buf()); encodeMetaInfo(data.getMetaInfo(), encoder); encodeName(data.getName(), new int[1], new int[1], encoder); int signedPortionBeginOffsetFromBack = encoder.getLength(); encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Data, encoder.getLength() - saveLength); signedPortionBeginOffset[0] = encoder.getLength() - signedPortionBeginOffsetFromBack; signedPortionEndOffset[0] = encoder.getLength() - signedPortionEndOffsetFromBack; return new Blob(encoder.getOutput(), false); }
/// <summary> /// Encode controlResponse in NDN-TLV and return the encoding. /// </summary> /// /// <param name="controlResponse">The ControlResponse object to encode.</param> /// <returns>A Blob containing the encoding.</returns> public override Blob encodeControlResponse(ControlResponse controlResponse) { TlvEncoder encoder = new TlvEncoder(256); int saveLength = encoder.getLength(); // Encode backwards. // Encode the body. if (controlResponse.getBodyAsControlParameters() != null) encodeControlParameters( controlResponse.getBodyAsControlParameters(), encoder); encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.NfdCommand_StatusText, new Blob( controlResponse.getStatusText()).buf()); encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.NfdCommand_StatusCode, controlResponse.getStatusCode()); encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.NfdCommand_ControlResponse, encoder.getLength() - saveLength); return new Blob(encoder.getOutput(), false); }
/// <summary> /// Encode controlParameters in NDN-TLV and return the encoding. /// </summary> /// /// <param name="controlParameters">The ControlParameters object to encode.</param> /// <returns>A Blob containing the encoding.</returns> public override Blob encodeControlParameters(ControlParameters controlParameters) { TlvEncoder encoder = new TlvEncoder(256); encodeControlParameters(controlParameters, encoder); return new Blob(encoder.getOutput(), false); }