public GarlicClove(GarlicCloveDelivery delivery)
{
Delivery = delivery;
Message = delivery.Message;
CloveId = BufUtils.RandomUint();
Expiration = new I2PDate(DateTime.UtcNow + TimeSpan.FromSeconds(8));
}
public GarlicClove(GarlicCloveDelivery delivery, I2PDate exp)
{
Delivery = delivery;
Message = delivery.Message;
CloveId = BufUtils.RandomUint();
Expiration = exp;
}
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(BufUtils.Flip32B(3));
dest.Write((byte)MessageType);
dest.Write(BitConverter.GetBytes(SessionId));
dest.Write((byte)SessionState);
}
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 NextTest()
{
int defaultsectorsize = 60;
using (Stream dest = new MemoryStream())
{
using (Store target = new Store(dest, defaultsectorsize))
{
for (int i = 0; i < 1000; ++i)
{
target.Write(new byte[] { (byte)BufUtils.RandomInt(240), (byte)(i % 7), (byte)BufUtils.RandomInt(240) });
}
var ix = 0;
var cnt = 0;
while ((ix = target.Next(ix)) != -1)
{
var item = target.Read(ix);
Assert.IsTrue(item[1] == (cnt % 7));
++cnt;
}
Assert.IsTrue(cnt == 1000);
}
}
}
bool TestBase32Enc(string src, string expected)
{
var enc = Encoding.ASCII.GetBytes(src);
var encb32 = BufUtils.ToBase32String(enc);
return(encb32 == expected.ToLower());
}
public void TestRoulette3()
{
var l = BufUtils.Populate <float>(() => BufUtils.RandomInt(2) == 0 ? 0f : BufUtils.RandomFloat(100000), 10000);
var r = new I2PCore.Utils.RouletteSelection <float, float>(l, v => v, k => k, 2f);
int iszero = 0;
for (int i = 0; i < 10000; ++i)
{
if (r.GetWeightedRandom() == 0f)
{
++iszero;
}
}
Assert.IsTrue(iszero > 10000 / 5);
Assert.IsTrue(iszero < 10000 / 2);
r = new I2PCore.Utils.RouletteSelection <float, float>(l, v => v, k => k, float.MaxValue);
iszero = 0;
for (int i = 0; i < 10000; ++i)
{
if (r.GetWeightedRandom() == 0f)
{
++iszero;
}
}
Assert.IsTrue(iszero < 4);
}
public void TestTickCounter()
{
var start = new TickCounter();
Assert.IsTrue(TickCounter.MaxDelta.DeltaToNowMilliseconds > 0);
var maxd = TickCounter.MaxDelta;
System.Threading.Thread.Sleep(200);
Assert.IsTrue(maxd.DeltaToNowMilliseconds > 0);
Assert.IsTrue(maxd.DeltaToNowMilliseconds > int.MaxValue / 2);
Assert.IsTrue(start.DeltaToNowMilliseconds > 0);
Assert.IsTrue(Math.Round((TickCounter.Now - start).ToSeconds / 3f) == Math.Round((float)start.DeltaToNowSeconds / 3f));
var start_copy = new TickCounter(start.Ticks);
System.Threading.Thread.Sleep(BufUtils.RandomInt(300) + 200);
var startdelta = start.DeltaToNowMilliseconds;
var now1 = new TickCounter();
Assert.IsTrue(start.ToString().Length > 0);
Assert.IsTrue((now1 - start).ToMilliseconds > 0);
Assert.IsTrue(((now1 - start).ToMilliseconds) / 100 == startdelta / 100);
}
public override void Write(BufRefStream dest)
{
dest.Write((BufRefLen)BufUtils.Flip16BL(SessionId));
dest.Write(TwentyBytes);
PrivateKey.Write(dest);
Leases.Write(dest);
}
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));
Logging.LogDebugData($"SessionConfirmA send TimestampA: {I2PDate.RefDate.AddSeconds( context.TimestampA )}");
Logging.LogDebugData($"SessionConfirmA send TimestampB: {I2PDate.RefDate.AddSeconds( context.TimestampB )}");
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.RandomBytes(padsize));
cleartext.Write(sign);
var buf = new BufLen(cleartext.ToArray());
context.Encryptor.ProcessBytes(buf);
return(buf);
}
internal static void Receive(DHHandshakeContext context, I2PKeysAndCert ri)
{
var responselength = ri.Certificate.SignatureLength;
responselength += BufUtils.Get16BytePadding(responselength);
var data = context.Client.BlockReceive(responselength);
context.Dectryptor.ProcessBytes(data);
var signature = new I2PSignature(new BufRefLen(data), context.RemoteRI.Certificate);
if (!I2PSignature.SupportedSignatureType(context.RemoteRI.Certificate.SignatureType))
{
throw new SignatureCheckFailureException("NTCP SessionConfirmB recv not supported signature type: " +
context.RemoteRI.Certificate.SignatureType.ToString());
}
var ok = I2PSignature.DoVerify(context.RemoteRI.SigningPublicKey, signature,
context.X.Key,
context.Y.Key,
RouterContext.Inst.MyRouterIdentity.IdentHash.Hash,
BufUtils.Flip32BL(context.TimestampA),
BufUtils.Flip32BL(context.TimestampB));
#if LOG_ALL_TRANSPORT
DebugUtils.Log("SessionConfirmB: " + context.RemoteRI.Certificate.SignatureType.ToString() + " signature check: " + ok.ToString());
#endif
if (!ok)
{
throw new SignatureCheckFailureException("NTCP SessionConfirmB recv sig check failure");
}
}
public void MakeAndReadFragments5_2()
{
var origmsgs = new List <TunnelMessage>();
for (int i = 0; i < 5; ++i)
{
var adatarec = new DataMessage(new BufLen(BufUtils.RandomBytes(2048)));
var amsg = new TunnelMessageRouter(
adatarec,
new I2PIdentHash(true));
origmsgs.Add(amsg);
}
var msgs = TunnelDataMessage.MakeFragments(origmsgs, BufUtils.RandomUint());
var mkmsg = new TunnelDataFragmentReassembly();
var recvtmsgs = msgs
.Chunk(a => 2)
.Shuffle()
.Select(m => mkmsg.Process(m, out var _))
.SelectMany(b => b);
Assert.IsTrue(origmsgs.All(o => recvtmsgs.Any(m =>
m.Delivery == o.Delivery &&
m.Message.CreateHeader16.HeaderAndPayload == o.Message.CreateHeader16.HeaderAndPayload
)));
}
private void SaveConfig(Store s)
{
var lookup = s.GetMatching(e => (StoreRecordId)e[0] == StoreRecordId.StoreIdConfig, 1);
var str2ix = new Dictionary <I2PString, int>();
foreach (var one in lookup)
{
var reader = new BufRefLen(one.Value);
reader.Read32();
var key = new I2PString(reader);
str2ix[key] = one.Key;
}
AccessConfig(delegate(Dictionary <I2PString, I2PString> settings)
{
foreach (var one in settings)
{
var rec = new BufLen[] {
BufUtils.To32BL((int)StoreRecordId.StoreIdConfig),
new BufLen(one.Key.ToByteArray()), new BufLen(one.Value.ToByteArray())
};
if (str2ix.ContainsKey(one.Key))
{
s.Write(rec, str2ix[one.Key]);
}
else
{
s.Write(rec);
}
}
});
}
public void MakeAndReadFragment()
{
var arec = new DatabaseLookupMessage(
new I2PIdentHash(true),
new I2PIdentHash(true),
DatabaseLookupMessage.LookupTypes.Normal);
var msg = new TunnelMessageRouter(
arec,
new I2PIdentHash(true));
var refmsgdata = msg.Message.CreateHeader16.HeaderAndPayload;
var fragments = TunnelDataMessage.MakeFragments(
new TunnelMessage[] { msg },
BufUtils.RandomUint());
var mkmsg = new TunnelDataFragmentReassembly();
var recvtmsgs = mkmsg.Process(fragments.Shuffle().ToArray(), out var _);
foreach (var rmsg in recvtmsgs)
{
var rmsgdata = rmsg.Message.CreateHeader16.HeaderAndPayload;
Assert.IsTrue(msg.Delivery == rmsg.Delivery);
Assert.IsTrue(refmsgdata == rmsgdata);
}
}
void StartNewUpdatesRouterInfo()
{
var list = GetNewFFList(
RouterContext.Inst.MyRouterIdentity.IdentHash,
4);
foreach (var ff in list)
{
try
{
var token = BufUtils.RandomUint() | 1;
Logging.Log(string.Format("FloodfillUpdater: {0}, RI, token: {1,10}, dist: {2}.",
ff.Id32Short, token,
ff ^ RouterContext.Inst.MyRouterIdentity.IdentHash.RoutingKey));
OutstandingRequests[token] = new FFUpdateRequestInfo(
ff,
token,
RouterContext.Inst.MyRouterIdentity.IdentHash);
SendUpdate(ff, token);
}
catch (Exception ex)
{
Logging.Log(ex);
}
}
}
public GarlicAESBlock(BufRefLen reader)
{
var start = new BufLen(reader);
TagCount = reader.ReadBufLen(2);
var tags = TagCount.PeekFlip16(0);
if (tags > 0)
{
if (tags * I2PSessionTag.TagLength > start.Length)
{
throw new ArgumentException("GarlicAESBlock: Not enough data for the tags supplied.");
}
for (int i = 0; i < tags; ++i)
{
Tags.Add(reader.ReadBufLen(I2PSessionTag.TagLength));
}
}
PayloadSize = reader.ReadBufLen(4);
PayloadHash = reader.ReadBufLen(32);
Flag = reader.ReadBufLen(1);
if (Flag[0] != 0)
{
NewSessionKey = reader.ReadBufLen(32);
}
var pllen = PayloadSize.PeekFlip32(0);
if (pllen > reader.Length)
{
throw new ArgumentException("GarlicAESBlock: Not enough data payload supplied.");
}
Payload = reader.ReadBufLen((int)pllen);
Padding = reader.ReadBufLen(BufUtils.Get16BytePadding(reader - start));
}
internal static BufLen Send(DHHandshakeContext context)
{
context.TimestampA = (uint)Math.Ceiling((DateTime.UtcNow - I2PDate.RefDate).TotalSeconds);
var cleartext = new List <byte>();
var ri = RouterContext.Inst.MyRouterIdentity.ToByteArray();
cleartext.AddRange(BufUtils.Flip16B((ushort)ri.Length));
cleartext.AddRange(ri);
cleartext.AddRange(BufUtils.Flip32B(context.TimestampA));
#if LOG_ALL_TRANSPORT
DebugUtils.Log("SessionConfirmA send TimestampA: " + (I2PDate.RefDate.AddSeconds(context.TimestampA).ToString()));
DebugUtils.Log("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(sign.Length + cleartext.Count);
cleartext.AddRange(BufUtils.Random(padsize));
cleartext.AddRange(sign);
var buf = new BufLen(cleartext.ToArray());
context.Encryptor.ProcessBytes(buf);
return(buf);
}
public void TestSimpleTunnelDataCreation()
{
var smalldata = BufUtils.RandomBytes(38);
var srcmsgs = new List <TunnelMessage>();
srcmsgs.Add(new TunnelMessageLocal(new DeliveryStatusMessage(1234)));
var msgfrags = TunnelDataMessage.MakeFragments(srcmsgs, 0x3e5c);
Assert.IsTrue(msgfrags.Count() == 1);
var firstmsg = msgfrags.First();
var serialized = firstmsg.CreateHeader16.HeaderAndPayload;
var recovered = I2NPMessage.ReadHeader16(new BufRefLen(serialized));
var reassembler = new TunnelDataFragmentReassembly();
var reassembledmsgs = reassembler.Process(
new TunnelDataMessage[]
{
(TunnelDataMessage)recovered.Message
}, out var _);
Assert.IsTrue(reassembledmsgs.Count() == 1);
var firstrecinstr = reassembledmsgs.First();
Assert.IsTrue(firstrecinstr.Delivery == TunnelMessage.DeliveryTypes.Local);
Assert.IsTrue(firstrecinstr.Message.MessageType == I2NPMessage.MessageTypes.DeliveryStatus);
Assert.IsTrue(((DeliveryStatusMessage)firstrecinstr.Message).StatusMessageId == 1234);
}
public override void Write(List <byte> dest)
{
dest.AddRange(BufUtils.Flip32B(3));
dest.Add((byte)MessageType);
dest.AddRange(BitConverter.GetBytes(SessionId));
dest.Add((byte)SessionState);
}
public void TestSimpleDatabaseStoreLeaseSetEd25519Creation()
{
var linfo = new I2PLeaseInfo(Public, PublicSigningEd25519, Private, PrivateSigningEd25519);
var leases = new List <I2PLease>();
for (int i = 0; i < 5; ++i)
{
leases.Add(new I2PLease(new I2PIdentHash(true), (uint)((i * 72 + 6) * i * 1314 + 5) % 40000, I2PDate.Now));
}
var ls = new I2PLeaseSet(new I2PDestination(Public, PublicSigningEd25519), leases, linfo);
var dbsm = new DatabaseStoreMessage(ls);
var data = dbsm.Header16.HeaderAndPayload;
var recreated = I2NPMessage.ReadHeader16(new BufRefLen(data));
Assert.IsTrue(recreated.MessageType == I2NPMessage.MessageTypes.DatabaseStore);
var rdsm = (DatabaseStoreMessage)recreated.Message;
Assert.IsTrue(rdsm.LeaseSet.Leases.Count == 5);
Assert.IsTrue(BufUtils.Equal(ls.Destination.ToByteArray(), rdsm.LeaseSet.Destination.ToByteArray()));
Assert.IsTrue(BufUtils.Equal(ls.PublicKey.ToByteArray(), rdsm.LeaseSet.PublicKey.ToByteArray()));
Assert.IsTrue(BufUtils.Equal(ls.PublicSigningKey.ToByteArray(), rdsm.LeaseSet.PublicSigningKey.ToByteArray()));
for (int i = 0; i < 5; ++i)
{
Assert.IsTrue(BufUtils.Equal(ls.Leases[i].ToByteArray(), rdsm.LeaseSet.Leases[i].ToByteArray()));
}
Assert.IsTrue(rdsm.LeaseSet.VerifySignature());
}
public void GetMatchingTest()
{
int defaultsectorsize = 1024;
using (Stream dest = new MemoryStream())
{
using (Store target = new Store(dest, defaultsectorsize))
{
for (int i = 0; i < 1000; ++i)
{
target.Write(new byte[] { (byte)BufUtils.RandomInt(240), (byte)(i % 5), (byte)BufUtils.RandomInt(240) });
}
var actual = target.GetMatching(r => r[1] == 3, 2);
Assert.IsTrue(actual.Count == 200);
Assert.IsTrue(actual.All(r => r.Value[1] == 3));
actual = target.GetMatching(r => r.Length > 1 ? r[1] == 3 : false, 1);
Assert.IsTrue(actual.Count == 0);
Assert.IsTrue(actual.All(r => r.Value[1] == 3));
actual = target.GetMatching(r => r[1] == 3, 3);
Assert.IsTrue(actual.Count == 200);
Assert.IsTrue(actual.All(r => r.Value[1] == 3));
}
}
}
public void TestI2PDestinationInfo4()
{
var destinfo = new I2PDestinationInfo(I2PSigningKey.SigningKeyTypes.EdDSA_SHA512_Ed25519);
var asba = destinfo.ToBase64();
var dfromba = new I2PDestinationInfo(asba);
Assert.IsTrue(BufUtils.Equal(destinfo.ToByteArray(), dfromba.ToByteArray()));
var asstr = destinfo.ToBase64();
var dfromstr = new I2PDestinationInfo(asstr);
var d1 = dfromba.Destination;
var d2 = dfromstr.Destination;
var d3 = dfromstr.Destination;
Assert.IsTrue(BufUtils.Equal(d2.ToByteArray(), d2.ToByteArray()));
Assert.IsTrue(d3.Padding == d2.Padding);
Assert.IsTrue(d3.CertificateBuf == d2.CertificateBuf);
Assert.IsTrue(d3.PublicKeyBuf == d2.PublicKeyBuf);
Assert.IsTrue(d3.SigningPublicKeyBuf == d2.SigningPublicKeyBuf);
Assert.IsTrue(BufUtils.Equal(d3.ToByteArray(), d2.ToByteArray()));
Assert.IsTrue(d1.Padding == d2.Padding);
Assert.IsTrue(d1.CertificateBuf == d2.CertificateBuf);
Assert.IsTrue(d1.PublicKeyBuf == d2.PublicKeyBuf);
Assert.IsTrue(d1.SigningPublicKeyBuf == d2.SigningPublicKeyBuf);
Assert.IsTrue(BufUtils.Equal(d1.ToByteArray(), d2.ToByteArray()));
Assert.IsTrue(d1.IdentHash == d2.IdentHash);
}
public override string ToString()
{
var result = new StringBuilder();
result.AppendLine("EGAesBuildRequestRecord " + BufUtils.ToBase32String(ToPeer16));
return(result.ToString());
}
public void MakeAndReadFragmentsWithSerialize()
{
var origmsgs = new List <TunnelMessage>();
for (int i = 0; i < 200; ++i)
{
switch (BufUtils.RandomInt(3))
{
case 0:
var adatarec = new DataMessage(
new BufLen(
BufUtils.RandomBytes(2048 + BufUtils.RandomInt(1024))));
origmsgs.Add(new TunnelMessageLocal(adatarec));
break;
case 1:
var arec = new DatabaseLookupMessage(
new I2PIdentHash(true),
new I2PIdentHash(true),
DatabaseLookupMessage.LookupTypes.RouterInfo);
origmsgs.Add(new TunnelMessageRouter(
arec,
new I2PIdentHash(true)));
break;
case 2:
var adatarec2 = new DataMessage(
new BufLen(
BufUtils.RandomBytes(2048 + BufUtils.RandomInt(1024))));
origmsgs.Add(new TunnelMessageTunnel(adatarec2,
new I2PIdentHash(true),
BufUtils.RandomUint()));
break;
}
}
var msgs = TunnelDataMessage.MakeFragments(origmsgs, BufUtils.RandomUint());
var recvlist = new List <TunnelDataMessage>();
foreach (var msg in msgs)
{
recvlist.Add((TunnelDataMessage)I2NPMessage.ReadHeader16(
new BufRefLen(msg.CreateHeader16.HeaderAndPayload)).Message);
}
var mkmsg = new TunnelDataFragmentReassembly();
var recvtmsgs = mkmsg.Process(recvlist, out var _);
foreach (var rmsg in recvtmsgs)
{
Assert.IsTrue(origmsgs.SingleOrDefault(m =>
m.Delivery == rmsg.Delivery &&
m.Message.CreateHeader16.HeaderAndPayload == rmsg.Message.CreateHeader16.HeaderAndPayload
) != null);
}
}
public DeliveryStatusMessage(ulong networkid)
{
AllocateBuffer(12);
var writer = new BufRefLen(Payload);
writer.PokeFlip64(networkid, 4);
StatusMessageId = BufUtils.RandomUint();
}
public I2PSigningPrivateKey(I2PCertificate cert)
: base(new BufLen(BufUtils.RandomBytes(cert.SigningPrivateKeyLength)), cert)
{
if (cert.SignatureType == SigningKeyTypes.EdDSA_SHA512_Ed25519)
{
ExpandedPrivateKey = Chaos.NaCl.Ed25519.ExpandedPrivateKeyFromSeed(ToByteArray());
}
}
public void TestShuffle()
{
var ints = Enumerable.Range(0, 200);
var bag = ints.Select(i => BufUtils.RandomDouble(1)).ToArray();
var shuffled = bag.Shuffle().ToArray();
Assert.IsTrue(bag.All(b => shuffled.Any(i => i == b)));
}
public PeerTest(BufLen nonce, BufLen aliceip, BufLen aliceport, BufLen introkey)
{
TestNonce = nonce;
AliceIPAddrSize = BufUtils.To8BL((byte)aliceip.Length);
AliceIPAddr = aliceip;
AlicePort = aliceport;
IntroKey = introkey;
}
public FragmentedMessage(II2NPHeader5 msg)
{
Message = msg;
MessageBytes = new BufLen(msg.HeaderAndPayload);
MessageId = BufUtils.RandomUint();
FragmentReader = new BufRefLen(MessageBytes);
}
