public I2PRouterInfo(
I2PRouterIdentity identity,
I2PDate publisheddate,
I2PRouterAddress[] adresses,
I2PMapping options,
I2PSigningPrivateKey privskey)
{
Identity = identity;
PublishedDate = publisheddate;
Adresses = adresses;
Options = options;
var dest = new BufRefStream();
Identity.Write(dest);
PublishedDate.Write(dest);
dest.Write((byte)Adresses.Length);
foreach (var addr in Adresses)
{
addr.Write(dest);
}
dest.Write(0); // Always zero
Options.Write(dest);
Data = new BufLen(dest.ToArray());
Signature = new I2PSignature(new BufRefLen(I2PSignature.DoSign(privskey, Data)), privskey.Certificate);
}
private static ZipArchive GetRouterInfoFiles(BufLen data)
{
try
{
var reader = new BufRefLen(data);
var header = new I2PSU3Header(reader);
if (header.FileType != I2PSU3Header.SU3FileTypes.Zip)
{
throw new ArgumentException($"Unknown FileType in SU3: {header.FileType}");
}
if (header.ContentType != I2PSU3Header.SU3ContentTypes.SeedData)
{
throw new ArgumentException($"Unknown ContentType in SU3: {header.ContentType}");
}
// TODO: Verify signature
var s = new BufRefStream();
s.Write(reader);
return(new ZipArchive(s));
}
catch (Exception ex)
{
Logging.Log(ex);
}
return(null);
}
public void Write(BufRefStream dest)
{
Delivery.Write(dest);
dest.Write((BufRefLen)BufUtils.Flip32BL(CloveId));
Expiration.Write(dest);
dest.Write(ThreeZero);
}
public override void Write(BufRefStream dest)
{
dest.Write((BufRefLen)BufUtils.Flip16BL(SessionId));
dest.Write(TwentyBytes);
PrivateKey.Write(dest);
Leases.Write(dest);
}
public byte[] ToByteArray()
{
var buf = new BufRefStream();
Write(buf);
return(buf.ToArray());
}
public override void Write(BufRefStream dest)
{
dest.Write(BufUtils.Flip32B(3));
dest.Write((byte)MessageType);
dest.Write(BitConverter.GetBytes(SessionId));
dest.Write((byte)SessionState);
}
internal static BufLen Send(DHHandshakeContext context)
{
context.TimestampA = (uint)Math.Ceiling((DateTime.UtcNow - I2PDate.RefDate).TotalSeconds);
var cleartext = new BufRefStream();
var ri = RouterContext.Inst.MyRouterIdentity.ToByteArray();
cleartext.Write(BufUtils.Flip16B((ushort)ri.Length));
cleartext.Write(ri);
cleartext.Write(BufUtils.Flip32B(context.TimestampA));
#if LOG_ALL_TRANSPORT
Logging.LogTransport("SessionConfirmA send TimestampA: " + (I2PDate.RefDate.AddSeconds(context.TimestampA).ToString()));
Logging.LogTransport("SessionConfirmA send TimestampB: " + (I2PDate.RefDate.AddSeconds(context.TimestampB).ToString()));
#endif
var sign = I2PSignature.DoSign(RouterContext.Inst.PrivateSigningKey,
context.X.Key,
context.Y.Key,
context.RemoteRI.IdentHash.Hash,
BufUtils.Flip32BL(context.TimestampA),
BufUtils.Flip32BL(context.TimestampB));
var padsize = BufUtils.Get16BytePadding((int)(sign.Length + cleartext.Length));
cleartext.Write(BufUtils.Random(padsize));
cleartext.Write(sign);
var buf = new BufLen(cleartext.ToArray());
context.Encryptor.ProcessBytes(buf);
return(buf);
}
public void Write(BufRefStream dest)
{
Destination.Write(dest);
Info.PublicKey.Write(dest);
Info.PublicSigningKey.Write(dest);
var cnt = (byte)Leases.Count;
if (cnt > 16)
{
throw new OverflowException("Max 16 leases per I2PLeaseSet");
}
var signfields = new List <BufLen>();
signfields.Add(new BufLen(Destination.ToByteArray()));
signfields.Add(Info.PublicKey.Key);
signfields.Add(Info.PublicSigningKey.Key);
signfields.Add((BufLen)cnt);
lock ( Leases )
{
dest.Write((byte)Leases.Count);
foreach (var lease in Leases)
{
var buf = lease.ToByteArray();
dest.Write(buf);
signfields.Add(new BufLen(buf));
}
}
dest.Write(I2PSignature.DoSign(Info.PrivateSigningKey, signfields.ToArray()));
}
public void TestAESBlock()
{
for (int runs = 0; runs < 10; ++runs)
{
var buf = new BufLen(new byte[30000]);
var writer = new BufRefLen(buf);
var data = BufUtils.RandomBytes(1 + BufUtils.RandomInt(45));
var datar = new BufRefLen(data);
var tags = new List <I2PSessionTag>();
for (int i = 0; i < BufUtils.RandomInt(5); ++i)
{
tags.Add(new I2PSessionTag());
}
var newsession = BufUtils.RandomDouble(1.0) < 0.3 ? new I2PSessionKey() : null;
var b1 = new GarlicAESBlock(writer, tags, newsession, datar);
var bldata = new BufLen(buf, 0, writer - buf).Clone();
var b2 = new GarlicAESBlock(new BufRefLen(bldata));
var b1ar = new BufLen(b1.ToByteArray());
var b2ar = new BufLen(b2.ToByteArray());
Assert.IsTrue(b1ar == b2ar);
var bufs = new BufRefStream();
b1.Write(bufs);
var b3 = new GarlicAESBlock(new BufRefLen(bufs.ToByteArray()));
var b3ar = new BufLen(b3.ToByteArray());
Assert.IsTrue(b1ar == b3ar);
}
}
public void Write(BufRefStream dest)
{
Delivery.Write(dest);
dest.Write((BufRefLen)(BufLen)CloveId);
Expiration.Write(dest);
dest.Write(0);
dest.Write(0);
dest.Write(0);
}
public override void Write(BufRefStream dest)
{
var header = new byte[6];
var writer = new BufRefLen(header);
writer.WriteFlip16(SessionId);
writer.WriteFlip32(MessageId);
dest.Write(header);
}
public override void Write(BufRefStream dest)
{
base.Write(dest);
if ((Flag & (byte)DeliveryFlags.Delay) != 0)
{
dest.Write(BufUtils.Flip32B(0));
}
dest.Write((BufRefLen)Message.CreateHeader16.HeaderAndPayload);
}
public override void Write(BufRefStream dest)
{
Version.Write(dest);
if (Mapping != null)
{
Mapping.Write(dest);
}
}
public override void Write(BufRefStream dest)
{
var header = new byte[3];
var writer = new BufRefLen(header);
writer.WriteFlip16(SessionId);
writer.Write8((byte)SessionState);
dest.Write(header);
}
public void Write(BufRefStream dest)
{
if (SignedData == null)
{
throw new InvalidOperationException("No signed data available");
}
dest.Write(SignedData);
dest.Write(Hash);
}
public void Write(BufRefStream dest)
{
var l = (byte)Math.Min(255, Str.Length);
var v = new byte[System.Text.Encoding.UTF8.GetMaxByteCount(l) + 1];
v[0] = l;
var bytes = System.Text.Encoding.UTF8.GetBytes(Str, 0, l, v, 1);
dest.Write(v, 0, bytes + 1);
}
public override void Write(BufRefStream dest)
{
if (Destination != null)
{
Destination.Write(dest);
return;
}
Ident.Write(dest);
}
public void Write(BufRefStream dest)
{
Id.Write(dest);
LastSeen.Write(dest);
Created.Write(dest);
dest.Write(BufUtils.RandomBytes(52)); // Reserved space
var mapping = CreateMapping();
mapping.Write(dest);
}
public override void Write(BufRefStream dest)
{
var header = new byte[10];
var writer = new BufRefLen(header);
writer.WriteFlip16(SessionId);
writer.WriteFlip32(MessageId);
writer.WriteFlip32((uint)Payload.Length);
dest.Write(header);
dest.Write((BufRefLen)Payload);
}
public override void Write(BufRefStream dest)
{
var header = new byte[15];
var writer = new BufRefLen(header);
writer.WriteFlip16(SessionId);
writer.WriteFlip32(MessageId);
writer.Write8((byte)MessageStatus);
writer.WriteFlip32(AvailableMessageSize);
writer.WriteFlip32(ClientNonce);
dest.Write(header);
}
public void WriteMessage(BufRefStream dest, params I2PType[] fields)
{
var buf = new BufRefStream();
foreach (var field in fields)
{
field.Write(buf);
}
dest.Write(BufUtils.Flip32B((uint)buf.Length));
dest.Write((byte)MessageType);
dest.Write(buf);
}
public void Write(BufRefStream dest)
{
// Routers MUST set this (expire) field to all zeros. As of release 0.9.12,
// a non-zero expiration field is again recognized, however we must
// wait several releases to use this field, until the vast majority
// of the network recognizes it.
// TODO: Hmmm?
dest.Write(Cost);
Expiration.Write(dest);
TransportStyle.Write(dest);
Options.Write(dest);
}
public void Write(BufRefStream dest)
{
var dest2 = new BufRefStream();
Destination.Write(dest2);
Map.Write(dest2);
Date.Write(dest2);
var dest2data = dest2.ToArray();
var sig = new I2PSignature(new BufRefLen(I2PSignature.DoSign(PrivateSigningKey, new BufLen(dest2data))), PrivateSigningKey.Certificate);
dest.Write(dest2data);
sig.Write(dest);
}
public override void Write(BufRefStream dest)
{
var header = new byte[3];
var writer = new BufRefLen(header);
writer.WriteFlip16(SessionId);
writer.Write8((byte)Leases.Count);
dest.Write(header);
for (int i = 0; i < Leases.Count; ++i)
{
Leases[i].Write(dest);
}
}
public override void Write(BufRefStream dest)
{
var header = new byte[7];
var writer = new BufRefLen(header);
writer.WriteFlip16(SessionId);
writer.WriteFlip32(RequestId);
writer.Write8((byte)ResultCode);
dest.Write(header);
if (ResultCode == HostLookupResults.Success)
{
Destination.Write(dest);
}
}
public override void Write( BufRefStream dest )
{
var buf = new byte[3];
var writer = new BufRefLen( buf );
writer.WriteFlip16( SessionId );
writer.Write8( (byte)Leases.Count );
dest.Write( buf );
for ( int i = 0; i < Leases.Count; ++i )
{
Leases[i].TunnelGw.Write( dest );
Leases[i].TunnelId.Write( dest );
}
new I2PDate( DateTime.UtcNow.AddMinutes( 9 ) ).Write( dest );
}
public void Write(BufRefStream dest)
{
var buf = new BufRefStream();
foreach (var one in Mappings)
{
one.Key.Write(buf);
buf.Write((byte)'=');
one.Value.Write(buf);
buf.Write((byte)';');
}
dest.Write(BufUtils.Flip16B((ushort)buf.Length));
dest.Write(buf);
}
static void MyDestination_DataReceived(ClientDestination dest, BufLen data)
{
Logging.LogInformation($"Program {PublishedDestination}: data received {data:15}");
var reader = new BufRefLen(data);
var unzip = LZUtils.BCGZipDecompressNew((BufLen)reader);
var packet = new StreamingPacket((BufRefLen)unzip);
Logging.LogInformation($"Program {PublishedDestination}: {packet} {packet.Payload}");
PublishedDestination.LookupDestination(packet?.From.IdentHash, (hash, ls, tag) =>
{
if (ls is null)
{
Logging.LogInformation($"Program {PublishedDestination}: Failed to lookup {hash?.Id32Short}.");
return;
}
var s = new BufRefStream();
var sh = new StreamingPacket(
PacketFlags.SYNCHRONIZE
| PacketFlags.FROM_INCLUDED
| PacketFlags.SIGNATURE_INCLUDED
| PacketFlags.MAX_PACKET_SIZE_INCLUDED
| PacketFlags.NO_ACK)
{
From = PublishedDestination.Destination,
SigningKey = MyDestinationInfo.PrivateSigningKey,
ReceiveStreamId = packet.ReceiveStreamId,
SendStreamId = SendId,
NACKs = new List <uint>(),
Payload = new BufLen(BufUtils.RandomBytes(30)),
};
sh.Write(s);
var buf = s.ToByteArray();
var zipped = LZUtils.BCGZipCompressNew(new BufLen(buf));
zipped.PokeFlip16(4353, 4); // source port
zipped.PokeFlip16(25, 6); // dest port
zipped[9] = (byte)PayloadFormat.Streaming; // streaming
Logging.LogInformation($"Program {PublishedDestination}: Sending {zipped:20}.");
PublishedDestination.Send(ls.Destination, zipped);
});
}
public virtual void Write(BufRefStream dest)
{
byte flag = Flag;
if (SessionKey != null)
{
flag |= (byte)DeliveryFlags.Encrypted;
}
if (Delay != 0)
{
flag |= (byte)DeliveryFlags.Delay;
}
dest.Write(flag);
if (SessionKey != null)
{
SessionKey.Write(dest);
}
}
public Garlic(I2PDate expiration, IEnumerable <GarlicClove> cloves)
{
BufRefStream buf = new BufRefStream();
buf.Write((byte)cloves.Count());
foreach (var clove in cloves)
{
clove.Write(buf);
}
// Certificate
buf.Write(new byte[] { 0, 0, 0 });
buf.Write((BufRefLen)BufUtils.Flip32BL(BufUtils.RandomUint()));
expiration.Write(buf);
Data = new BufLen(buf.ToArray());
ParseData(new BufRefLen(Data));
}
