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