internal static Enum GetArbitraryValue(Type enumType)
{
Array enumValues = GetEnumValues(enumType);
int index = (int)(DateTimeUtilities.CurrentUnixMs() & 0x7FFFFFFF) % enumValues.Length;
return((Enum)enumValues.GetValue(index));
}
private void randMult(string curveName)
{
X9ECParameters spec = SecNamedCurves.GetByName(curveName);
BigInteger n = spec.N;
ECPoint g = (ECPoint)spec.G;
SecureRandom random = new SecureRandom(); //SecureRandom.getInstance("SHA1PRNG", "SUN");
BigInteger k = new BigInteger(n.BitLength - 1, random);
ECPoint qMultiply = null;
long startTime = DateTimeUtilities.CurrentUnixMs();
for (int i = 0; i < NUM_ROUNDS; i++)
{
qMultiply = g.Multiply(k);
}
long endTime = DateTimeUtilities.CurrentUnixMs();
double avgDuration = (double)(endTime - startTime) / NUM_ROUNDS;
Console.WriteLine(curveName);
Console.Write("Millis : ");
Console.WriteLine(avgDuration);
Console.WriteLine();
}
private void DumpDatagram(string verb, byte[] buf, int off, int len)
{
long timestamp = DateTimeUtilities.CurrentUnixMs() - launchTimestamp;
StringBuilder sb = new StringBuilder("(+" + timestamp + "ms) " + verb + " " + len + " byte datagram:");
for (int pos = 0; pos < len; ++pos)
{
if (pos % 16 == 0)
{
sb.Append(Environment.NewLine);
sb.Append(" ");
}
else if (pos % 16 == 8)
{
sb.Append('-');
}
else
{
sb.Append(' ');
}
int val = buf[off + pos] & 0xFF;
sb.Append(HEX_CHARS[val >> 4]);
sb.Append(HEX_CHARS[val & 0xF]);
}
Dump(sb.ToString());
}
/// <summary>Return a V3 signature object containing the current signature state.</summary>
public PgpSignature Generate()
{
long creationTime = DateTimeUtilities.CurrentUnixMs() / 1000L;
byte[] hData = new byte[]
{
(byte)signatureType,
(byte)(creationTime >> 24),
(byte)(creationTime >> 16),
(byte)(creationTime >> 8),
(byte)creationTime
};
sig.BlockUpdate(hData, 0, hData.Length);
dig.BlockUpdate(hData, 0, hData.Length);
byte[] sigBytes = sig.GenerateSignature();
byte[] digest = DigestUtilities.DoFinal(dig);
byte[] fingerPrint = new byte[] { digest[0], digest[1] };
// an RSA signature
bool isRsa = keyAlgorithm == PublicKeyAlgorithmTag.RsaSign ||
keyAlgorithm == PublicKeyAlgorithmTag.RsaGeneral;
MPInteger[] sigValues = isRsa
? PgpUtilities.RsaSigToMpi(sigBytes)
: PgpUtilities.DsaSigToMpi(sigBytes);
return(new PgpSignature(
new SignaturePacket(3, signatureType, privKey.KeyId, keyAlgorithm,
hashAlgorithm, creationTime * 1000L, fingerPrint, sigValues)));
}
internal static global::System.Enum GetArbitraryValue(global::System.Type enumType)
{
global::System.Array enumValues = GetEnumValues(enumType);
int num = (int)(DateTimeUtilities.CurrentUnixMs() & 0x7FFFFFFF) % enumValues.get_Length();
return((global::System.Enum)enumValues.GetValue(num));
}
internal static Enum GetArbitraryValue(System.Type enumType)
{
Array values = GetEnumValues(enumType);
int pos = (int)(DateTimeUtilities.CurrentUnixMs() & int.MaxValue) % values.Length;
return((Enum)values.GetValue(pos));
}
internal Message ReceiveMessage()
{
long currentTimeMillis = DateTimeUtilities.CurrentUnixMs();
if (mResendTimeout == null)
{
mResendMillis = InitialResendMillis;
mResendTimeout = new Timeout(mResendMillis, currentTimeMillis);
PrepareInboundFlight(Platform.CreateHashtable());
}
byte[] buf = null;
for (;;)
{
if (mRecordLayer.IsClosed)
{
throw new TlsFatalAlert(AlertDescription.user_canceled);
}
Message pending = GetPendingMessage();
if (pending != null)
{
return(pending);
}
int handshakeMillis = Timeout.GetWaitMillis(mHandshakeTimeout, currentTimeMillis);
if (handshakeMillis < 0)
{
throw new TlsFatalAlert(AlertDescription.handshake_failure);
}
int waitMillis = System.Math.Max(1, Timeout.GetWaitMillis(mResendTimeout, currentTimeMillis));
if (handshakeMillis > 0)
{
waitMillis = System.Math.Min(waitMillis, handshakeMillis);
}
int receiveLimit = mRecordLayer.GetReceiveLimit();
if (buf == null || buf.Length < receiveLimit)
{
buf = new byte[receiveLimit];
}
int received = mRecordLayer.Receive(buf, 0, receiveLimit, waitMillis);
if (received < 0)
{
ResendOutboundFlight();
}
else
{
ProcessRecord(MaxReceiveAhead, mRecordLayer.ReadEpoch, buf, 0, received);
}
currentTimeMillis = DateTimeUtilities.CurrentUnixMs();
}
}
private double RandMult(SecureRandom random, ECPoint g, BigInteger n)
{
BigInteger[] ks = new BigInteger[128];
for (int i = 0; i < ks.Length; ++i)
{
ks[i] = new BigInteger(n.BitLength - 1, random);
}
int ki = 0;
ECPoint p = g;
for (int i = 1; i <= PRE_ROUNDS; i++)
{
for (int j = 0; j < MULTS_PER_ROUND; ++j)
{
BigInteger k = ks[ki];
p = g.Multiply(k);
if ((ki & 1) != 0)
{
g = p;
}
if (++ki == ks.Length)
{
ki = 0;
}
}
}
double minElapsed = Double.MaxValue, maxElapsed = Double.MinValue, totalElapsed = 0.0;
for (int i = 1; i <= NUM_ROUNDS; i++)
{
long startTime = DateTimeUtilities.CurrentUnixMs();
for (int j = 0; j < MULTS_PER_ROUND; ++j)
{
BigInteger k = ks[ki];
p = g.Multiply(k);
if ((ki & 1) != 0)
{
g = p;
}
if (++ki == ks.Length)
{
ki = 0;
}
}
long endTime = DateTimeUtilities.CurrentUnixMs();
double roundElapsed = (double)(endTime - startTime);
minElapsed = System.Math.Min(minElapsed, roundElapsed);
maxElapsed = System.Math.Max(maxElapsed, roundElapsed);
totalElapsed += roundElapsed;
}
return((totalElapsed - minElapsed - maxElapsed) / (NUM_ROUNDS - 2) / MULTS_PER_ROUND);
}
internal static void WriteGmtUnixTime(byte[] buf, int offset)
{
int t = (int)(DateTimeUtilities.CurrentUnixMs() / 1000L);
buf[offset] = (byte)(t >> 24);
buf[offset + 1] = (byte)(t >> 16);
buf[offset + 2] = (byte)(t >> 8);
buf[offset + 3] = (byte)t;
}
private void RandomTests()
{
SecureRandom srng = new SecureRandom();
srng.SetSeed(DateTimeUtilities.CurrentUnixMs());
for (int i = 0; i < 10; ++i)
{
RandomTest(srng);
}
}
public X931SecureRandom Build(IBlockCipher engine, KeyParameter key, bool predictionResistant)
{
if (mDateTimeVector == null)
{
mDateTimeVector = new byte[engine.GetBlockSize()];
Pack.UInt64_To_BE((ulong)DateTimeUtilities.CurrentUnixMs(), mDateTimeVector, 0);
}
engine.Init(forEncryption: true, key);
return(new X931SecureRandom(mRandom, new X931Rng(engine, mDateTimeVector, mEntropySourceProvider.Get(engine.GetBlockSize() * 8)), predictionResistant));
}
private void RandomTests()
{
SecureRandom srng = new SecureRandom();
srng.SetSeed(DateTimeUtilities.CurrentUnixMs());
RandomTests(srng, null);
RandomTests(srng, new BasicGcmMultiplier());
RandomTests(srng, new Tables8kGcmMultiplier());
RandomTests(srng, new Tables64kGcmMultiplier());
}
private void RandomTests()
{
SecureRandom random = new SecureRandom();
random.SetSeed(DateTimeUtilities.CurrentUnixMs());
for (int i = 0; i < 100; ++i)
{
RandomTest(random);
}
}
internal static Enum GetArbitraryValue(System.Type enumType)
{
Array values = GetEnumValues(enumType);
int pos = (int)(DateTimeUtilities.CurrentUnixMs() & int.MaxValue) % values.Length;
#if WINDOWS_PHONE
var strVal = values.GetValue(pos).ToString();
return((Enum)Enum.Parse(enumType, strVal, true));
#else
return((Enum)values.GetValue(pos));
#endif
}
private void RandMult(string label, X9ECParameters spec)
{
ECCurve C = spec.Curve;
ECPoint G = (ECPoint)spec.G;
BigInteger n = spec.N;
SecureRandom random = new SecureRandom();
random.SetSeed(DateTimeUtilities.CurrentUnixMs());
Console.WriteLine(label);
int[] coords = ECCurve.GetAllCoordinateSystems();
for (int i = 0; i < coords.Length; ++i)
{
int coord = coords[i];
if (C.SupportsCoordinateSystem(coord))
{
ECCurve c = C;
ECPoint g = G;
bool defaultCoord = (c.CoordinateSystem == coord);
if (!defaultCoord)
{
c = C.Configure().SetCoordinateSystem(coord).Create();
g = c.ImportPoint(G);
}
double avgRate = RandMult(random, g, n);
string coordName = COORD_NAMES[coord];
StringBuilder sb = new StringBuilder();
sb.Append(" ");
sb.Append(defaultCoord ? '*' : ' ');
sb.Append(coordName);
for (int j = sb.Length; j < 30; ++j)
{
sb.Append(' ');
}
sb.Append(": ");
sb.Append(avgRate);
sb.Append(" mults/sec");
for (int j = sb.Length; j < 64; ++j)
{
sb.Append(' ');
}
sb.Append('(');
sb.Append(1000.0 / avgRate);
sb.Append(" millis/mult)");
Console.WriteLine(sb.ToString());
}
}
}
internal virtual void HandshakeSuccessful(DtlsHandshakeRetransmit retransmit)
{
if (this.mReadEpoch == this.mCurrentEpoch || this.mWriteEpoch == this.mCurrentEpoch)
{
throw new InvalidOperationException();
}
if (retransmit != null)
{
this.mRetransmit = retransmit;
this.mRetransmitEpoch = this.mCurrentEpoch;
this.mRetransmitExpiry = DateTimeUtilities.CurrentUnixMs() + 240000L;
}
this.mInHandshake = false;
this.mCurrentEpoch = this.mPendingEpoch;
this.mPendingEpoch = null;
}
internal virtual void HandshakeSuccessful(DtlsHandshakeRetransmit retransmit)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
if (mReadEpoch == mCurrentEpoch || mWriteEpoch == mCurrentEpoch)
{
throw new InvalidOperationException();
}
if (retransmit != null)
{
mRetransmit = retransmit;
mRetransmitEpoch = mCurrentEpoch;
mRetransmitExpiry = DateTimeUtilities.CurrentUnixMs() + 240000;
}
mInHandshake = false;
mCurrentEpoch = mPendingEpoch;
mPendingEpoch = null;
}
protected static byte[] CreateRandomBlock(bool useGMTUnixTime, SecureRandom random, string asciiLabel)
{
/*
* We use the TLS 1.0 PRF on the SecureRandom output, to guard against RNGs where the raw
* output could be used to recover the internal state.
*/
byte[] secret = new byte[32];
random.NextBytes(secret);
byte[] seed = new byte[8];
// TODO Use high-resolution timer
TlsUtilities.WriteUint64(DateTimeUtilities.CurrentUnixMs(), seed, 0);
byte[] result = TlsUtilities.PRF(secret, asciiLabel, seed, 32);
if (useGMTUnixTime)
{
TlsUtilities.WriteGmtUnixTime(result, 0);
}
return(result);
}
public virtual int Receive(byte[] buf, int off, int len, int waitMillis)
{
long endMillis = DateTimeUtilities.CurrentUnixMs() + waitMillis;
for (;;)
{
int length = transport.Receive(buf, off, len, waitMillis);
if (length < 0 || !LostPacket(percentPacketLossReceiving))
{
return(length);
}
Console.WriteLine("PACKET LOSS (" + length + " byte packet not received)");
long now = DateTimeUtilities.CurrentUnixMs();
if (now >= endMillis)
{
return(-1);
}
waitMillis = (int)(endMillis - now);
}
}
private double RandMult(SecureRandom random, ECPoint g, BigInteger n)
{
BigInteger[] ks = new BigInteger[128];
for (int i = 0; i < ks.Length; ++i)
{
ks[i] = new BigInteger(n.BitLength - 1, random);
}
int ki = 0;
ECPoint p = g;
for (int i = 1; i <= PRE_ROUNDS; i++)
{
BigInteger k = ks[ki];
p = g.Multiply(k);
if (++ki == ks.Length)
{
ki = 0;
g = p;
}
}
long startTime = DateTimeUtilities.CurrentUnixMs();
for (int i = 1; i <= NUM_ROUNDS; i++)
{
BigInteger k = ks[ki];
p = g.Multiply(k);
if (++ki == ks.Length)
{
ki = 0;
g = p;
}
}
long endTime = DateTimeUtilities.CurrentUnixMs();
return((double)(endTime - startTime) / NUM_ROUNDS);
}
public virtual int Receive(byte[] buf, int off, int len, int waitMillis)
{
long currentTimeMillis = DateTimeUtilities.CurrentUnixMs();
Timeout timeout = Timeout.ForWaitMillis(waitMillis, currentTimeMillis);
byte[] record = null;
while (waitMillis >= 0)
{
if (mRetransmitTimeout != null && mRetransmitTimeout.RemainingMillis(currentTimeMillis) < 1)
{
mRetransmit = null;
mRetransmitEpoch = null;
mRetransmitTimeout = null;
}
int receiveLimit = mTransport.GetReceiveLimit();
if (record == null || record.Length < receiveLimit)
{
record = new byte[receiveLimit];
}
int received = ReceiveRecord(record, 0, receiveLimit, waitMillis);
int processed = ProcessRecord(received, record, buf, off);
if (processed >= 0)
{
return(processed);
}
currentTimeMillis = DateTimeUtilities.CurrentUnixMs();
waitMillis = Timeout.GetWaitMillis(timeout, currentTimeMillis);
}
return(-1);
}
public PgpSignature Generate()
{
long num = DateTimeUtilities.CurrentUnixMs() / 1000;
byte[] array = new byte[5]
{
(byte)signatureType,
(byte)(num >> 24),
(byte)(num >> 16),
(byte)(num >> 8),
(byte)num
};
sig.BlockUpdate(array, 0, array.Length);
dig.BlockUpdate(array, 0, array.Length);
byte[] encoding = sig.GenerateSignature();
byte[] array2 = DigestUtilities.DoFinal(dig);
byte[] fingerprint = new byte[2]
{
array2[0],
array2[1]
};
MPInteger[] signature = ((keyAlgorithm == PublicKeyAlgorithmTag.RsaSign || keyAlgorithm == PublicKeyAlgorithmTag.RsaGeneral) ? PgpUtilities.RsaSigToMpi(encoding) : PgpUtilities.DsaSigToMpi(encoding));
return(new PgpSignature(new SignaturePacket(3, signatureType, privKey.KeyId, keyAlgorithm, hashAlgorithm, num * 1000, fingerprint, signature)));
}
internal static Timeout ForWaitMillis(int waitMillis)
{
return(ForWaitMillis(waitMillis, DateTimeUtilities.CurrentUnixMs()));
}
internal Timeout(long durationMillis)
: this(durationMillis, DateTimeUtilities.CurrentUnixMs())
{
}
private double RandMult(SecureRandom random, ECPoint g, BigInteger n)
{
BigInteger[] ks = new BigInteger[128];
for (int i = 0; i < ks.Length; ++i)
{
ks[i] = new BigInteger(n.BitLength - 1, random);
}
int ki = 0;
ECPoint p = g;
{
long startTime = DateTimeUtilities.CurrentUnixMs();
long goalTime = startTime + MILLIS_WARMUP;
do
{
BigInteger k = ks[ki];
p = g.Multiply(k);
if ((ki & 1) != 0)
{
g = p;
}
if (++ki == ks.Length)
{
ki = 0;
}
}while (DateTimeUtilities.CurrentUnixMs() < goalTime);
}
double minRate = Double.MaxValue, maxRate = Double.MinValue, totalRate = 0.0;
for (int i = 1; i <= NUM_ROUNDS; i++)
{
long startTime = DateTimeUtilities.CurrentUnixMs();
long goalTime = startTime + MILLIS_PER_ROUND;
long count = 0, endTime;
do
{
++count;
for (int j = 0; j < MULTS_PER_CHECK; ++j)
{
BigInteger k = ks[ki];
p = g.Multiply(k);
if ((ki & 1) != 0)
{
g = p;
}
if (++ki == ks.Length)
{
ki = 0;
}
}
endTime = DateTimeUtilities.CurrentUnixMs();
}while (endTime < goalTime);
double roundElapsed = (double)(endTime - startTime);
double roundRate = count * MULTS_PER_CHECK * 1000L / roundElapsed;
minRate = System.Math.Min(minRate, roundRate);
maxRate = System.Math.Max(maxRate, roundRate);
totalRate += roundRate;
}
return((totalRate - minRate - maxRate) / (NUM_ROUNDS - 2));
}
public virtual int Receive(byte[] buf, int off, int len, int waitMillis)
{
byte[] array = null;
int result;
while (true)
{
int num = Math.Min(len, this.GetReceiveLimit()) + 13;
if (array == null || array.Length < num)
{
array = new byte[num];
}
try
{
if (this.mRetransmit != null && DateTimeUtilities.CurrentUnixMs() > this.mRetransmitExpiry)
{
this.mRetransmit = null;
this.mRetransmitEpoch = null;
}
int num2 = this.ReceiveRecord(array, 0, num, waitMillis);
if (num2 < 0)
{
result = num2;
}
else
{
if (num2 < 13)
{
continue;
}
int num3 = TlsUtilities.ReadUint16(array, 11);
if (num2 != num3 + 13)
{
continue;
}
byte b = TlsUtilities.ReadUint8(array, 0);
switch (b)
{
case 20:
case 21:
case 22:
case 23:
case 24:
{
int num4 = TlsUtilities.ReadUint16(array, 3);
DtlsEpoch dtlsEpoch = null;
if (num4 == this.mReadEpoch.Epoch)
{
dtlsEpoch = this.mReadEpoch;
}
else if (b == 22 && this.mRetransmitEpoch != null && num4 == this.mRetransmitEpoch.Epoch)
{
dtlsEpoch = this.mRetransmitEpoch;
}
if (dtlsEpoch == null)
{
continue;
}
long num5 = TlsUtilities.ReadUint48(array, 5);
if (dtlsEpoch.ReplayWindow.ShouldDiscard(num5))
{
continue;
}
ProtocolVersion other = TlsUtilities.ReadVersion(array, 1);
if (this.mDiscoveredPeerVersion != null && !this.mDiscoveredPeerVersion.Equals(other))
{
continue;
}
byte[] array2 = dtlsEpoch.Cipher.DecodeCiphertext(DtlsRecordLayer.GetMacSequenceNumber(dtlsEpoch.Epoch, num5), b, array, 13, num2 - 13);
dtlsEpoch.ReplayWindow.ReportAuthenticated(num5);
if (array2.Length > this.mPlaintextLimit)
{
continue;
}
if (this.mDiscoveredPeerVersion == null)
{
this.mDiscoveredPeerVersion = other;
}
switch (b)
{
case 20:
for (int i = 0; i < array2.Length; i++)
{
byte b2 = TlsUtilities.ReadUint8(array2, i);
if (b2 == 1 && this.mPendingEpoch != null)
{
this.mReadEpoch = this.mPendingEpoch;
}
}
continue;
case 21:
if (array2.Length == 2)
{
byte b3 = array2[0];
byte b4 = array2[1];
this.mPeer.NotifyAlertReceived(b3, b4);
if (b3 == 2)
{
this.Fail(b4);
throw new TlsFatalAlert(b4);
}
if (b4 == 0)
{
this.CloseTransport();
}
}
continue;
case 22:
if (!this.mInHandshake)
{
if (this.mRetransmit != null)
{
this.mRetransmit.ReceivedHandshakeRecord(num4, array2, 0, array2.Length);
}
continue;
}
break;
case 23:
if (this.mInHandshake)
{
continue;
}
break;
case 24:
continue;
}
if (!this.mInHandshake && this.mRetransmit != null)
{
this.mRetransmit = null;
this.mRetransmitEpoch = null;
}
Array.Copy(array2, 0, buf, off, array2.Length);
result = array2.Length;
break;
}
default:
continue;
}
}
}
catch (IOException ex)
{
throw ex;
}
break;
}
return(result);
}
public virtual int Receive(byte[] buf, int off, int len, int waitMillis)
{
byte[] record = null;
for (;;)
{
int receiveLimit = System.Math.Min(len, GetReceiveLimit()) + RECORD_HEADER_LENGTH;
if (record == null || record.Length < receiveLimit)
{
record = new byte[receiveLimit];
}
try
{
if (mRetransmit != null && DateTimeUtilities.CurrentUnixMs() > mRetransmitExpiry)
{
mRetransmit = null;
mRetransmitEpoch = null;
}
int received = ReceiveRecord(record, 0, receiveLimit, waitMillis);
if (received < 0)
{
return(received);
}
if (received < RECORD_HEADER_LENGTH)
{
continue;
}
int length = TlsUtilities.ReadUint16(record, 11);
if (received != (length + RECORD_HEADER_LENGTH))
{
continue;
}
byte type = TlsUtilities.ReadUint8(record, 0);
// TODO Support user-specified custom protocols?
switch (type)
{
case ContentType.alert:
case ContentType.application_data:
case ContentType.change_cipher_spec:
case ContentType.handshake:
case ContentType.heartbeat:
break;
default:
// TODO Exception?
continue;
}
int epoch = TlsUtilities.ReadUint16(record, 3);
DtlsEpoch recordEpoch = null;
if (epoch == mReadEpoch.Epoch)
{
recordEpoch = mReadEpoch;
}
else if (type == ContentType.handshake && mRetransmitEpoch != null &&
epoch == mRetransmitEpoch.Epoch)
{
recordEpoch = mRetransmitEpoch;
}
if (recordEpoch == null)
{
continue;
}
long seq = TlsUtilities.ReadUint48(record, 5);
if (recordEpoch.ReplayWindow.ShouldDiscard(seq))
{
continue;
}
ProtocolVersion version = TlsUtilities.ReadVersion(record, 1);
if (!version.IsDtls)
{
continue;
}
if (mReadVersion != null && !mReadVersion.Equals(version))
{
continue;
}
byte[] plaintext = recordEpoch.Cipher.DecodeCiphertext(
GetMacSequenceNumber(recordEpoch.Epoch, seq), type, record, RECORD_HEADER_LENGTH,
received - RECORD_HEADER_LENGTH);
recordEpoch.ReplayWindow.ReportAuthenticated(seq);
if (plaintext.Length > this.mPlaintextLimit)
{
continue;
}
if (mReadVersion == null)
{
mReadVersion = version;
}
switch (type)
{
case ContentType.alert:
{
if (plaintext.Length == 2)
{
byte alertLevel = plaintext[0];
byte alertDescription = plaintext[1];
mPeer.NotifyAlertReceived(alertLevel, alertDescription);
if (alertLevel == AlertLevel.fatal)
{
Failed();
throw new TlsFatalAlert(alertDescription);
}
// TODO Can close_notify be a fatal alert?
if (alertDescription == AlertDescription.close_notify)
{
CloseTransport();
}
}
continue;
}
case ContentType.application_data:
{
if (mInHandshake)
{
// TODO Consider buffering application data for new epoch that arrives
// out-of-order with the Finished message
continue;
}
break;
}
case ContentType.change_cipher_spec:
{
// Implicitly receive change_cipher_spec and change to pending cipher state
for (int i = 0; i < plaintext.Length; ++i)
{
byte message = TlsUtilities.ReadUint8(plaintext, i);
if (message != ChangeCipherSpec.change_cipher_spec)
{
continue;
}
if (mPendingEpoch != null)
{
mReadEpoch = mPendingEpoch;
}
}
continue;
}
case ContentType.handshake:
{
if (!mInHandshake)
{
if (mRetransmit != null)
{
mRetransmit.ReceivedHandshakeRecord(epoch, plaintext, 0, plaintext.Length);
}
// TODO Consider support for HelloRequest
continue;
}
break;
}
case ContentType.heartbeat:
{
// TODO[RFC 6520]
continue;
}
}
/*
* NOTE: If we receive any non-handshake data in the new epoch implies the peer has
* received our final flight.
*/
if (!mInHandshake && mRetransmit != null)
{
this.mRetransmit = null;
this.mRetransmitEpoch = null;
}
Array.Copy(plaintext, 0, buf, off, plaintext.Length);
return(plaintext.Length);
}
catch (IOException e)
{
// NOTE: Assume this is a timeout for the moment
throw e;
}
}
}
/// <summary>Connects to the remote system.</summary>
/// <param name="verifyer">Will be used when a certificate is received to verify
/// that this certificate is accepted by the client.</param>
/// <exception cref="IOException">If handshake was not successful</exception>
public virtual void Connect(
ICertificateVerifyer verifyer)
{
this.verifyer = verifyer;
/*
* Send Client hello
*
* First, generate some random data.
*/
this.clientRandom = new byte[32];
/*
* TLS 1.0 requires a unix-timestamp in the first 4 bytes
*/
int t = (int)(DateTimeUtilities.CurrentUnixMs() / 1000L);
this.clientRandom[0] = (byte)(t >> 24);
this.clientRandom[1] = (byte)(t >> 16);
this.clientRandom[2] = (byte)(t >> 8);
this.clientRandom[3] = (byte)t;
random.NextBytes(this.clientRandom, 4, 28);
MemoryStream outStr = new MemoryStream();
TlsUtilities.WriteVersion(outStr);
outStr.Write(this.clientRandom, 0, this.clientRandom.Length);
/*
* Length of Session id
*/
TlsUtilities.WriteUint8((short)0, outStr);
/*
* Cipher suites
*/
TlsCipherSuiteManager.WriteCipherSuites(outStr);
/*
* Compression methods, just the null method.
*/
byte[] compressionMethods = new byte[] { 0x00 };
TlsUtilities.WriteUint8((short)compressionMethods.Length, outStr);
outStr.Write(compressionMethods, 0, compressionMethods.Length);
MemoryStream bos = new MemoryStream();
TlsUtilities.WriteUint8(HP_CLIENT_HELLO, bos);
TlsUtilities.WriteUint24((int)outStr.Length, bos);
byte[] outBytes = outStr.ToArray();
bos.Write(outBytes, 0, outBytes.Length);
byte[] message = bos.ToArray();
rs.WriteMessage(RL_HANDSHAKE, message, 0, message.Length);
connection_state = CS_CLIENT_HELLO_SEND;
/*
* We will now read data, until we have completed the handshake.
*/
while (connection_state != CS_DONE)
{
rs.ReadData();
}
this.tlsInputStream = new TlsInputStream(this);
this.tlsOutputStream = new TlsOuputStream(this);
}
public LoggingDatagramTransport(DatagramTransport transport, TextWriter output)
{
this.transport = transport;
this.output = output;
this.launchTimestamp = DateTimeUtilities.CurrentUnixMs();
}
public virtual int Receive(byte[] buf, int off, int len, int waitMillis)
{
//IL_02c8: Expected O, but got Unknown
byte[] array = null;
while (true)
{
int num = Math.Min(len, GetReceiveLimit()) + 13;
if (array == null || array.Length < num)
{
array = new byte[num];
}
try
{
if (mRetransmit != null && DateTimeUtilities.CurrentUnixMs() > mRetransmitExpiry)
{
mRetransmit = null;
mRetransmitEpoch = null;
}
int num2 = ReceiveRecord(array, 0, num, waitMillis);
if (num2 < 0)
{
return(num2);
}
if (num2 < 13)
{
continue;
}
int num3 = TlsUtilities.ReadUint16(array, 11);
if (num2 != num3 + 13)
{
continue;
}
byte b = TlsUtilities.ReadUint8(array, 0);
switch (b)
{
case 20:
case 21:
case 22:
case 23:
case 24:
{
int num4 = TlsUtilities.ReadUint16(array, 3);
DtlsEpoch dtlsEpoch = null;
if (num4 == mReadEpoch.Epoch)
{
dtlsEpoch = mReadEpoch;
}
else if (b == 22 && mRetransmitEpoch != null && num4 == mRetransmitEpoch.Epoch)
{
dtlsEpoch = mRetransmitEpoch;
}
if (dtlsEpoch == null)
{
break;
}
long num5 = TlsUtilities.ReadUint48(array, 5);
if (dtlsEpoch.ReplayWindow.ShouldDiscard(num5))
{
break;
}
ProtocolVersion protocolVersion = TlsUtilities.ReadVersion(array, 1);
if (!protocolVersion.IsDtls || (mReadVersion != null && !mReadVersion.Equals(protocolVersion)))
{
break;
}
byte[] array2 = dtlsEpoch.Cipher.DecodeCiphertext(GetMacSequenceNumber(dtlsEpoch.Epoch, num5), b, array, 13, num2 - 13);
dtlsEpoch.ReplayWindow.ReportAuthenticated(num5);
if (array2.Length > mPlaintextLimit)
{
break;
}
if (mReadVersion == null)
{
mReadVersion = protocolVersion;
}
switch (b)
{
case 21:
if (array2.Length == 2)
{
byte b2 = array2[0];
byte b3 = array2[1];
mPeer.NotifyAlertReceived(b2, b3);
if (b2 == 2)
{
Fail(b3);
throw new TlsFatalAlert(b3);
}
if (b3 == 0)
{
CloseTransport();
}
}
goto end_IL_0022;
case 23:
if (!mInHandshake)
{
break;
}
goto end_IL_0022;
case 20:
{
for (int i = 0; i < array2.Length; i++)
{
byte b4 = TlsUtilities.ReadUint8(array2, i);
if (b4 == 1 && mPendingEpoch != null)
{
mReadEpoch = mPendingEpoch;
}
}
goto end_IL_0022;
}
case 22:
if (mInHandshake)
{
break;
}
if (mRetransmit != null)
{
mRetransmit.ReceivedHandshakeRecord(num4, array2, 0, array2.Length);
}
goto end_IL_0022;
case 24:
goto end_IL_0022;
}
if (!mInHandshake && mRetransmit != null)
{
mRetransmit = null;
mRetransmitEpoch = null;
}
global::System.Array.Copy((global::System.Array)array2, 0, (global::System.Array)buf, off, array2.Length);
return(array2.Length);
}
}
end_IL_0022 :;
}
catch (IOException val)
{
IOException val2 = val;
throw val2;
}
}
}
