private void DeserializeObjects(Block block, byte[] data) { using (var ms = new MemoryStream(data)) { using (var br = new BinaryReader(ms)) { // Version: var context = new BlockDeserializeContext(br, _typeProvider); // Nonce: var nonce = context.br.ReadBuffer(); if (nonce != null) { // Data: using (var dms = new MemoryStream(StreamEncryption.EncryptChaCha20(context.br.ReadBuffer(), nonce, _typeProvider.SecretKey))) { using (var dbr = new BinaryReader(dms)) { var dc = new BlockDeserializeContext(dbr, _typeProvider); block.DeserializeObjects(dc); } } } else { // Data: block.DeserializeObjects(context); } } } }
public void StreamEncryptionEncryptChaCha20BadKey() { StreamEncryption.EncryptChaCha20( Encoding.UTF8.GetBytes("Adam Caudill"), Encoding.UTF8.GetBytes("ABCDEFGH"), Encoding.UTF8.GetBytes("123456789012345678901234567890")); }
private void Start() { int x = NativeLibsodium.sodium_init(); Debug.Log(x); const string MESSAGE = "Test message to encrypt"; byte[] nonce = StreamEncryption.GenerateNonceChaCha20(); byte[] key = StreamEncryption.GenerateKey(); //encrypt it byte[] encrypted = StreamEncryption.EncryptChaCha20(MESSAGE, nonce, key); //decrypt it byte[] decrypted = StreamEncryption.DecryptChaCha20(encrypted, nonce, key); string str_origin = MESSAGE; string str_encrypted = Encoding.UTF8.GetString(encrypted); string str_decrypted = Encoding.UTF8.GetString(decrypted); Debug.Log(str_origin); Debug.Log(str_encrypted); Debug.Log(str_decrypted); txt_origin.text = str_origin; txt_encrypted.text = str_encrypted; txt_decrypted.text = str_decrypted; }
public void StreamEncryptionEncryptChaCha20BadNonce() { StreamEncryption.EncryptChaCha20( Encoding.UTF8.GetBytes("Adam Caudill"), Encoding.UTF8.GetBytes("ABC"), Encoding.UTF8.GetBytes("12345678901234567890123456789012")); }
public ConnectPacketData GetConnectPacket() { var connectPacketData = new ConnectPacketData { AddressType = _connection.AddressType, DestPort = _connection.DestPort, RouteCount = (uint)_connection.ReturnRoutes.Length, ReturnRoutes = // TODO }; if (_connection.AddressType == DestAddressType.DomainName) { connectPacketData.DestDomainName = _connection.DestDomainName; } else { connectPacketData.DestIpAddress = _connection.DestIpAddress; } var bytesToEncrypt = new byte[PacketContent.MaxSendDataLen + 27]; var buffer = new WriteBuffer(bytesToEncrypt, 0); buffer.Write(_connection.UserId); buffer.Write(_connection.ConnectionId); buffer.Write(_connection.NextSequenceId); buffer.Write((byte)PacketDataType.Connect); buffer.Write(connectPacketData); var paddingLength = bytesToEncrypt.Length - buffer.TotalWritten; buffer.Write(new byte[paddingLength]); var route = GenerateRoute(_possibleNodes); var encrypted = SecretBox.Create(bytesToEncrypt, OneNonce, route.Nodes[2].SymmetricKey); var destIdAndDataLen = new byte[10]; buffer.Buffer = destIdAndDataLen; buffer.Write((ulong)0); buffer.Write((ushort)(encrypted.Length - 16)); var innerPacketBytes = new byte[bytesToEncrypt.Length + 67]; buffer.Buffer = innerPacketBytes; buffer.Write(route.Nodes[2].Node.Id); buffer.Write(route.Nodes[2].EphemeralPublicKey); buffer.Write((byte)(route.Nodes[2].SymmetricKey[31] & 1)); buffer.Write(StreamEncryption.EncryptChaCha20(destIdAndDataLen, ZeroNonce, route.Nodes[2].SymmetricKey)); buffer.Write(encrypted); encrypted = SecretBox.Create(encrypted, OneNonce, route.Nodes[2].SymmetricKey); var destId = new byte[8]; buffer.Buffer = destId; buffer.Write(route.Nodes[1].Node.Id); }
public void CreateSecretBoxChaCha20() { var expected = Utilities.HexToBinary("a6ce598d8b865fb328581bcd"); var actual = StreamEncryption.EncryptChaCha20( Encoding.UTF8.GetBytes("Adam Caudill"), Encoding.UTF8.GetBytes("ABCDEFGH"), Encoding.UTF8.GetBytes("12345678901234567890123456789012")); Assert.AreEqual(expected, actual); }
public void StreamEncryptionEncryptChaCha20BadNonce() { Assert.Throws <NonceOutOfRangeException>(() => { StreamEncryption.EncryptChaCha20( Encoding.UTF8.GetBytes("Adam Caudill"), Encoding.UTF8.GetBytes("ABC"), Encoding.UTF8.GetBytes("12345678901234567890123456789012")); }); }
public void Stream_Encryption_Basic() { var nonce = StreamEncryption.GenerateNonceChaCha20(); var key = StreamEncryption.GenerateKey(); var messageString = "Test message to encrypt"; var encrypted = StreamEncryption.EncryptChaCha20(messageString, nonce, key); var decrypted = StreamEncryption.DecryptChaCha20(encrypted, nonce, key); Assert.AreEqual(messageString, Encoding.UTF8.GetString(decrypted)); }
public byte[] Encrypt(byte[] message, long nonce, bool isInvalidClientPayload = false) { byte[] messageVar = new byte[] { }; if (isInvalidClientPayload) { messageVar = StreamEncryption.EncryptChaCha20(message, BitConverter.GetBytes(nonce), Convert.FromBase64String(ChaChaEncryptionKey2)); } else { messageVar = StreamEncryption.EncryptChaCha20(message, BitConverter.GetBytes(nonce), Convert.FromBase64String(ChaChaEncryptionKey)); } return(messageVar); }
public void ChaCha20Test() { var key = StreamEncryption.GenerateKey(); var nonce = StreamEncryption.GenerateNonceChaCha20(); string message = "Hello, World!"; var cipherText = StreamEncryption.EncryptChaCha20(message, nonce, key); var decrypted = StreamEncryption.DecryptChaCha20(cipherText, nonce, key); Assert.AreEqual(message, System.Text.Encoding.UTF8.GetString(decrypted)); byte[] byteMessage = System.Text.Encoding.UTF8.GetBytes(message); cipherText = StreamEncryption.EncryptChaCha20(byteMessage, nonce, key); decrypted = StreamEncryption.DecryptChaCha20(cipherText, nonce, key); Assert.AreEqual(Convert.ToBase64String(byteMessage), Convert.ToBase64String(decrypted)); }
public void TestChaCha20() { int x = NativeLibsodium.sodium_init(); Assert.True(x == 0 || x == 1); const string MESSAGE = "Test message to encrypt"; byte[] nonce = StreamEncryption.GenerateNonceChaCha20(); byte[] key = StreamEncryption.GenerateKey(); //encrypt it byte[] encrypted = StreamEncryption.EncryptChaCha20(MESSAGE, nonce, key); //decrypt it byte[] decrypted = StreamEncryption.DecryptChaCha20(encrypted, nonce, key); Assert.AreEqual(MESSAGE, decrypted); }
private byte[] SerializeObjects(Block block) { byte[] data; using (var ms = new MemoryStream()) { using (var bw = new BinaryWriter(ms, Encoding.UTF8)) { // Version: var context = new BlockSerializeContext(bw, _typeProvider); if (context.typeProvider.SecretKey != null) { // Nonce: var nonce = StreamEncryption.GenerateNonceChaCha20(); context.bw.WriteBuffer(nonce); // Data: using (var ems = new MemoryStream()) { using (var ebw = new BinaryWriter(ems, Encoding.UTF8)) { var ec = new BlockSerializeContext(ebw, _typeProvider, context.Version); block.SerializeObjects(ec); context.bw.WriteBuffer(StreamEncryption.EncryptChaCha20(ems.ToArray(), nonce, ec.typeProvider.SecretKey)); } } } else { // Data: context.bw.Write(false); block.SerializeObjects(context); } data = ms.ToArray(); } } return(data); }
/// <summary> /// Encrypt a message using provided key and nonce /// </summary> /// <param name="message">Plaintext message</param> /// <param name="key">Plaintext/Base64-encoded key</param> /// <param name="nonce">Base64-encoded nonce (generate using GenerateNonce())</param> /// <returns> /// Base64-encoded encrypted message /// </returns> public static string Encrypt(string message, string key, string nonce) { // Validate parameters if (string.IsNullOrEmpty(key)) { throw new ArgumentNullException(nameof(key)); } if (string.IsNullOrEmpty(message)) { throw new ArgumentNullException(nameof(message)); } if (string.IsNullOrEmpty(nonce)) { throw new ArgumentNullException(nameof(nonce)); } // Check nonce is Base64 if (!Utils.IsBase64(nonce)) { throw new ArgumentException($"{nameof(nonce)} must be base64-encoded string"); } byte[] nonce_bytes = Convert.FromBase64String(nonce); // Convert key to bytes byte[] key_bytes; if (Utils.IsBase64(key)) { // Key is Base64, convert to raw bytes key_bytes = Convert.FromBase64String(key); } else { // Key is plaintext string, fallback to raw ASCII bytes key_bytes = Encoding.ASCII.GetBytes(key); } // Encrypt the message byte[] encrypted = StreamEncryption.EncryptChaCha20(message, nonce_bytes, key_bytes); // Return the raw bytes as Base64 return(Convert.ToBase64String(encrypted)); }
private void Start() { int x = NativeLibsodium.sodium_init(); Debug.Log(x); const string MESSAGE = "Test message to encrypt"; byte[] nonce = StreamEncryption.GenerateNonceChaCha20(); byte[] key = StreamEncryption.GenerateKey(); //encrypt it byte[] encrypted = StreamEncryption.EncryptChaCha20(MESSAGE, nonce, key); //decrypt it byte[] decrypted = StreamEncryption.DecryptChaCha20(encrypted, nonce, key); Debug.Log(MESSAGE); Debug.Log(Encoding.UTF8.GetString(encrypted)); Debug.Log(Encoding.UTF8.GetString(decrypted)); }
public void RoundTripCheck(IHashProvider hashProvider, IBlockObjectTypeProvider typeProvider) { // Serialize a first time var firstMemoryStream = new MemoryStream(); var firstSerializeContext = new BlockSerializeContext(new BinaryWriter(firstMemoryStream), typeProvider); byte[] nonce; if (typeProvider.SecretKey != null) { nonce = StreamEncryption.GenerateNonceChaCha20(); firstSerializeContext.bw.WriteBuffer(nonce); using (var ems = new MemoryStream()) { using (var ebw = new BinaryWriter(ems)) { var ec = new BlockSerializeContext(ebw, typeProvider, firstSerializeContext.Version); Serialize(ec); firstSerializeContext.bw.WriteBuffer(StreamEncryption.EncryptChaCha20(ems.ToArray(), nonce, ec.typeProvider.SecretKey)); } } } else { firstSerializeContext.bw.Write(false); Serialize(firstSerializeContext); } byte[] originalData = firstMemoryStream.ToArray(); // Then deserialize that data { var br = new BinaryReader(new MemoryStream(originalData)); var deserializeContext = new BlockDeserializeContext(br, typeProvider); nonce = deserializeContext.br.ReadBuffer(); Block deserialized; if (nonce != null) { using (var dms = new MemoryStream(StreamEncryption.DecryptChaCha20(deserializeContext.br.ReadBuffer(), nonce, typeProvider.SecretKey))) { using (var dbr = new BinaryReader(dms)) { var dc = new BlockDeserializeContext(dbr, typeProvider); deserialized = new Block(dc); } } } else { deserialized = new Block(deserializeContext); } // Then serialize that deserialized data and see if it matches { var secondMemoryStream = new MemoryCompareStream(originalData); var secondSerializeContext = new BlockSerializeContext(new BinaryWriter(secondMemoryStream), typeProvider); if (typeProvider.SecretKey != null) { secondSerializeContext.bw.WriteBuffer(nonce); using (var ems = new MemoryStream()) { using (var ebw = new BinaryWriter(ems)) { var ec = new BlockSerializeContext(ebw, typeProvider, secondSerializeContext.Version); deserialized.Serialize(ec); secondSerializeContext.bw.WriteBuffer(StreamEncryption.EncryptChaCha20(ems.ToArray(), nonce, ec.typeProvider.SecretKey)); } } } else { secondSerializeContext.bw.Write(false); deserialized.Serialize(secondSerializeContext); } } } }
public byte[] Encrypt(byte[] message, long nonce) { return(StreamEncryption.EncryptChaCha20(message, GetNonceBytes(nonce), _crypteKey)); }
public byte[] Encrypt(byte[] message, long nonce) { var nonceByte = BitConverter.GetBytes(nonce); return(StreamEncryption.EncryptChaCha20(message, nonceByte, ChaChaEncryptionKey)); }
public byte[] Encrypt_Fake(byte[] message, long tmpNonce) { return(StreamEncryption.EncryptChaCha20(message, BitConverter.GetBytes(tmpNonce), Convert.FromBase64String(ChaChaEncryptionKeyFake))); }