public byte[] EncodeToProtocol(Level level, byte[] timestamp, string hostName, string serviceName, string message, byte[] initVector)
{
byte[] bufOut = null;
using (var stream = new MemoryStream(16 + HOST_NAME_SIZE + SERVICE_NAME_SIZE + PLUGIN_OUTPUT_SIZE))
{
stream.WriteShort(Nsca_VERSION); //bytes 0-1
stream.WriteShort(0); //bytes 2-3
stream.WriteInt(0); //bytes 4-8
stream.Write(timestamp, 0, 4); //bytes 9-13
stream.WriteShort((short)level); //bytes 14-15
stream.WriteFixedString(hostName, HOST_NAME_SIZE);
if (string.IsNullOrWhiteSpace(serviceName) == false)
stream.WriteFixedString(serviceName, SERVICE_NAME_SIZE); // process service check result
else
stream.WriteFixedString("\x0", SERVICE_NAME_SIZE); // process host check result
stream.WriteFixedString(message, PLUGIN_OUTPUT_SIZE);
stream.WriteShort(0);
int hash = CRC32.Compute(stream.ToArray());
stream.Position = 4;
stream.WriteInt(hash);
var encryptor = EncryptorFactory.CreateEncryptor(settings.EncryptionType);
bufOut = encryptor.Encrypt(stream.ToArray(), initVector, settings.Password);
}
return bufOut;
}
public static MemoryStream NewPkt(PktType p)
{
var ms = new MemoryStream();
ms.WriteShort(_Header);
ms.WriteShort((int)p);
ms.WriteInt((int)ms.Length - HeadLength);
return ms;
}
public void Receive_copies_data_from_inputStream()
{
var deltaStream = new MemoryStream();
deltaStream.WriteByte(DeltaStreamer.DeltaStreamConstants.COPY_BLOCK_START_MARKER);
deltaStream.WriteLong(4); // Start the copy from byte four
deltaStream.WriteInt(10); // Copy 10 bytes
deltaStream.Seek(0, SeekOrigin.Begin);
var inputStream = new MemoryStream(); // Must have 4 + 10 bytes
for (int i = 0; i < 20; ++i) inputStream.WriteByte((byte) (255 - i));
inputStream.Seek(0, SeekOrigin.Begin);
var outputStream = new MemoryStream();
var streamer = new DeltaStreamer();
streamer.Receive(deltaStream, inputStream, outputStream);
Assert.AreEqual(10, outputStream.Length);
outputStream.GetBuffer().Take(14).SequenceEqual(inputStream.GetBuffer().Skip(3).Take(14));
}
public byte[] EncodeToProtocol(Level level, byte[] timestamp, string hostName, string serviceName, string message, byte[] initVector)
{
using (var stream = new MemoryStream(16 + HOST_NAME_SIZE + SERVICE_NAME_SIZE + PLUGIN_OUTPUT_SIZE))
{
stream.WriteShort(NSCA_VERSION); //bytes 0-1
stream.WriteShort(0); //bytes 2-3
stream.WriteInt(0); //bytes 4-8
stream.Write(timestamp, 0, 4); //bytes 9-13
stream.WriteShort((short) level); //bytes 14-15
stream.WriteFixedString(hostName, HOST_NAME_SIZE);
stream.WriteFixedString(serviceName, SERVICE_NAME_SIZE);
stream.WriteFixedString(message, PLUGIN_OUTPUT_SIZE);
stream.WriteShort(0);
int hash = CRC32.Compute(stream.ToArray());
stream.Position = 4;
stream.WriteInt(hash);
var encryptor = EncryptorFactory.CreateEncryptor(settings.EncryptionType);
return encryptor.Encrypt(stream.ToArray(), initVector, settings.Password);
}
}
public static Stream Serialize(this Bin bin)
{
Stream serialized = new MemoryStream();
serialized.WriteUint((uint)bin.Count);
var alias = TypeIdentity.Instance.FindAlias(bin.GetInnerType());
serialized.WriteUint(alias.UnicodeLength());
serialized.WriteUnicode(alias);
for (int i = 0; i < bin.Count; i++)
{
if (bin.GetInnerType() == typeof(bool))
{
serialized.WriteBool((bool)bin[i]);
}
if (bin.GetInnerType() == typeof(int))
{
serialized.WriteInt((int)bin[i]);
}
if (bin.GetInnerType() == typeof(float))
{
serialized.WriteFloat((float)bin[i]);
}
if (bin.GetInnerType() == typeof(double))
{
serialized.WriteDouble((double)bin[i]);
}
if (bin.GetInnerType() == typeof(string))
{
var l = ((string)bin[i]).UnicodeLength();
serialized.WriteUint(l);
if (l>0) serialized.WriteUnicode((string)bin[i]);
}
if (bin.GetInnerType() == typeof(RGBAColor))
{
serialized.WriteDouble(((RGBAColor)bin[i]).R);
serialized.WriteDouble(((RGBAColor)bin[i]).G);
serialized.WriteDouble(((RGBAColor)bin[i]).B);
serialized.WriteDouble(((RGBAColor)bin[i]).A);
}
if (bin.GetInnerType() == typeof(Vector2D))
{
serialized.WriteDouble(((Vector2D)bin[i]).x);
serialized.WriteDouble(((Vector2D)bin[i]).y);
}
if (bin.GetInnerType() == typeof(Vector3D))
{
serialized.WriteDouble(((Vector3D)bin[i]).x);
serialized.WriteDouble(((Vector3D)bin[i]).y);
serialized.WriteDouble(((Vector3D)bin[i]).z);
}
if (bin.GetInnerType() == typeof(Vector4D))
{
serialized.WriteDouble(((Vector4D)bin[i]).x);
serialized.WriteDouble(((Vector4D)bin[i]).y);
serialized.WriteDouble(((Vector4D)bin[i]).z);
serialized.WriteDouble(((Vector4D)bin[i]).w);
}
if (bin.GetInnerType() == typeof(Matrix4x4))
{
for (int j = 0; j < 16; j++)
{
serialized.WriteDouble(((Matrix4x4)bin[i]).Values[j]);
}
}
if (bin.GetInnerType() == typeof(Stream))
{
var l = ((Stream)bin[i]).Length;
serialized.WriteUint((uint)l);
if (l > 0)
{
((Stream) bin[i]).Position = 0;
((Stream) bin[i]).CopyTo(serialized, (int) l);
}
}
if (bin.GetInnerType() == typeof(Time.Time))
{
var t = (Time.Time) bin[i];
var time = t.UniversalTime.ToString("yyyy-MM-dd HH:mm:ss.ffff");
var zone = t.TimeZone.Id;
serialized.WriteUint(time.UnicodeLength());
serialized.WriteUnicode(time);
serialized.WriteUint(zone.UnicodeLength());
serialized.WriteUnicode(zone);
}
}
serialized.Position = 0;
return serialized;
}
public static void ClosePkt(MemoryStream ms)
{
ms.Position = 4;
ms.WriteInt((int)ms.Length - HeadLength);
}
/// <summary>
/// Encrypts a value using the requested certificate.
/// The certificate must have a valid RSA public key.
/// </summary>
/// <param name="value">The value to be encrypted.</param>
/// <param name="certificate">The certificate used to encrypt the value.</param>
/// <remarks>
/// First a cryptographically random AES key is generated.
/// The value is encrypted using that AES key.
/// The AES key is then encrypted using the RSA key from the certificate.
/// Then the encrypted value is joined with the encrypted AES key.
/// That result is base 64 encoded and returned.
///
/// The format of the result in binary (before base 64 encoding) is the following:
/// [AES key length in bytes] - Length: 4 bytes
/// [AES block size in bytes] - Length: 4 bytes
/// [AES key encrypted length in bytes] - Length: 4 bytes
/// [AES initialization vector encrypted length in bytes] - Length: 4 bytes
/// [Certificate public key length in bytes] - Length: 4 bytes
/// [Certificate public key] - Length: Public key length
/// [Encrypted AES key] - Length: AES key encrypted length bytes
/// [Encrypted AES initialization vector] - Length: AES Block size bytes
/// [Encrypted value] - Length: remaining data length
/// </remarks>
/// <returns>The encrypted, base64-encoded value.</returns>
public static string Encrypt(string value, X509Certificate2 certificate)
{
const int keySizeBits = 256;
const int keySizeBytes = keySizeBits / 8;
const int blockSizeBits = 128;
const int blockSizeBytes = blockSizeBits / 8;
// Get the RSA key from the certificate
var rsa = certificate.PublicKey.Key as RSACryptoServiceProvider;
if (rsa == null)
{
throw new InvalidOperationException("Certificate does not contain an RSA public key.");
}
// Get the public key as a byte array
var publicKey = certificate.GetPublicKey();
using (var aes = new AesManaged
{
KeySize = keySizeBits,
BlockSize = blockSizeBits,
Mode = CipherMode.CBC
})
{
// Generate a cryptographically random initialization vector and key
aes.GenerateIV();
aes.GenerateKey();
if (aes.IV.Length != blockSizeBytes)
{
throw new InvalidOperationException("AES IV size is not equal to the block size.");
}
// Encrypt the AES key and initialization vector
var keyBytes = rsa.Encrypt(aes.Key, false);
var ivBytes = rsa.Encrypt(aes.IV, false);
using (var memory = new MemoryStream())
{
// Write the AES key length and block size
memory.WriteInt(keySizeBytes);
memory.WriteInt(blockSizeBytes);
// Write the sizes of the encrypted AES key and initialization vector
memory.WriteInt(keyBytes.Length);
memory.WriteInt(ivBytes.Length);
// Write the size of the certificate public key
memory.WriteInt(publicKey.Length);
// Write the public key
memory.Write(publicKey, 0, publicKey.Length);
// Write the encrypted AES key and initialization vector
memory.Write(keyBytes, 0, keyBytes.Length);
memory.Write(ivBytes, 0, ivBytes.Length);
// Encrypt and write the actual value using the aes encryption
using (var transform = aes.CreateEncryptor())
using (var crypto = new CryptoStream(memory, transform, CryptoStreamMode.Write))
{
var bytes = Encoding.UTF8.GetBytes(value);
crypto.Write(bytes, 0, bytes.Length);
crypto.FlushFinalBlock();
}
// Return the base 64 encoded result
return Convert.ToBase64String(memory.ToArray(), Base64FormattingOptions.InsertLineBreaks);
}
}
}
public void Receive_writes_new_bytes_from_deltaStream()
{
var deltaStream = new MemoryStream();
deltaStream.WriteByte(DeltaStreamer.DeltaStreamConstants.NEW_BLOCK_START_MARKER);
deltaStream.WriteInt(10); // Write 10 bytes
for (int i = 0; i < 10; ++i) deltaStream.WriteByte((byte) (200 - i));
deltaStream.Seek(0, SeekOrigin.Begin);
var inputStream = new MemoryStream(); // empty
var outputStream = new MemoryStream();
var streamer = new DeltaStreamer();
streamer.Receive(deltaStream, inputStream, outputStream);
Assert.AreEqual(10, outputStream.Length);
outputStream.GetBuffer().Take(10).SequenceEqual(deltaStream.GetBuffer().Skip(5).Take(10));
}
public long SentMessage(string their_name, byte[] their_pubkey, string txt, byte[] myprv, byte[] msgid, byte[]replyTo)
{
if (replyTo == null)
replyTo = new byte[16];
long foundId = 0, prvId=0;
foreach (var v in pubkeys)
{
if(their_pubkey.ArraysEqual(v.key))
{
foundId=v.id;
break;
}
}
if (myprv != null)
{
foreach (var v in prvkeys)
{
if (myprv.ArraysEqual(v.key))
{
prvId = v.id;
break;
}
}
if (prvId == 0)
throw new Exception();
}
if (foundId == 0) { foundId = newpub(their_pubkey, their_name); }
byte[] msgbuf;
using (var ms = new MemoryStream())
{
ms.WriteInt((int)foundId);
ms.WriteInt((int)prvId);
ms.Write(msgid, 0, msgid.Length);
ms.Write(replyTo, 0, replyTo.Length);
var txtbuf = Encoding.UTF8.GetBytes(txt);
ms.Write(txtbuf, 0, txtbuf.Length);
ms.Flush();
msgbuf = ms.ToArray();
}
var idq = conn.Query<long>("select id from outbox order by id desc limit 1",new{});
long id = idq.Count() == 0 ? 1 : idq.First() + 1;
var iv = ArrayrXor(outbox_iv, id);
if (conn.Execute("insert into outbox(id, msg) select @id, @msg", new { id = id, msg = enc(msgbuf, iv) }) != 1)
throw new Exception();
return foundId;
}