public override bool Equals(object obj) { if (obj is null) { return(false); } if (ReferenceEquals(this, obj)) { return(true); } NodeContact contact = obj as NodeContact; if (contact == null) { return(false); } if (_nodeEP.Equals(contact._nodeEP)) { return(true); } return(_nodeId.Equals(contact._nodeId)); }
public bool IsThisNetwork(BinaryNumber networkID) { if (_isResponse) { throw new Exception("Packet is not a query."); } BinaryNumber computedHmac; using (HMACSHA256 hmacSHA256 = new HMACSHA256(networkID.Number)) { computedHmac = new BinaryNumber(hmacSHA256.ComputeHash(_challenge.Number)); //computed hmac } return(_hmac.Equals(computedHmac)); }
public static List <IPEndPoint> GetPeerEPs(BinaryNumber channelName, Connection requestingConnection) { BinaryNumber localPeerID = requestingConnection.LocalPeerID; BinaryNumber remotePeerID = requestingConnection.RemotePeerID; lock (_relays) { foreach (KeyValuePair <BinaryNumber, TcpRelayService> itemRelay in _relays) { BinaryNumber computedChannelName = Connection.GetChannelName(localPeerID, remotePeerID, itemRelay.Key); if (computedChannelName.Equals(channelName)) { Dictionary <BinaryNumber, Connection> relayConnections = itemRelay.Value._relayConnections; List <IPEndPoint> peerEPs = new List <IPEndPoint>(relayConnections.Count); lock (relayConnections) { foreach (KeyValuePair <BinaryNumber, Connection> itemProxyConnection in relayConnections) { peerEPs.Add(itemProxyConnection.Value.RemotePeerEP); } } return(peerEPs); } } } return(null); }
public bool IsValid(SecureChannelHandshakeHello hello, byte[] masterKey) { using (MemoryStream mS = new MemoryStream(32)) { hello.WriteTo(mS); mS.Position = 0; BinaryNumber computedHmac = new BinaryNumber((new HMACSHA256(masterKey)).ComputeHash(mS)); return(_hmac.Equals(computedHmac)); } }
public override bool Equals(object obj) { if (obj is null) { return(false); } if (ReferenceEquals(this, obj)) { return(true); } if (obj is DnsTSIGRecord other) { if (!_algorithmName.Equals(other._algorithmName, StringComparison.OrdinalIgnoreCase)) { return(false); } if (_timeSigned != other._timeSigned) { return(false); } if (_fudge != other._fudge) { return(false); } if (!BinaryNumber.Equals(_mac, other._mac)) { return(false); } if (_originalID != other._originalID) { return(false); } if (_error != other._error) { return(false); } if (!BinaryNumber.Equals(_otherData, other._otherData)) { return(false); } return(true); } return(false); }
public static bool IsUserIdValid(byte[] publicKey, BinaryNumber userId) { if (userId.Value.Length != 20) { return(false); } byte[] random = new byte[4]; Buffer.BlockCopy(userId.Value, 0, random, 0, 4); byte[] generatedValue = GenerateUserId(publicKey, random); return(BinaryNumber.Equals(userId.Value, generatedValue)); }
public override bool Equals(object obj) { if (obj == null) { return(false); } if (ReferenceEquals(this, obj)) { return(true); } MeshNetworkPeerInfo objPeerInfo = obj as MeshNetworkPeerInfo; return(_peerUserId.Equals(objPeerInfo._peerUserId)); }
internal void MeshNetworkRequest(Connection connection, BinaryNumber networkId, Stream channel) { MeshNetwork network = null; lock (_networks) { if (_networks.ContainsKey(networkId)) { network = _networks[networkId]; } } if (network == null) { if (!networkId.Equals(_maskedUserId)) { //no network found channel.Dispose(); return; } //private network connection invitation attempt if (!_allowInboundInvitations || (_allowOnlyLocalInboundInvitations && ((connection.RemotePeerEP.AddressFamily == AddressFamily.Unspecified) || !NetUtilities.IsPrivateIP((connection.RemotePeerEP as IPEndPoint).Address)))) { //not allowed channel.Dispose(); return; } //accept invitation network = MeshNetwork.AcceptPrivateNetworkInvitation(_connectionManager, connection, channel); //add network lock (_networks) { _networks.Add(network.NetworkId, network); } //notify UI RaiseEventInvitationReceived(network); } else { network.AcceptConnectionAndJoinNetwork(connection, channel); } }
public bool Equals(DiscoveryPacket obj) { if (ReferenceEquals(null, obj)) { return(false); } if (ReferenceEquals(this, obj)) { return(true); } if (!_challenge.Equals(obj._challenge)) { return(false); } return(true); }
public MeshNode(Stream s, string password, string profileFolder, TorController torController) { _password = password; _profileFolder = profileFolder; switch (s.ReadByte()) //version { case 1: //read headers and init decryptor Aes decryptionAlgo = Aes.Create(); decryptionAlgo.Key = MeshNetwork.GetKdfValue32(Encoding.UTF8.GetBytes(password), s.ReadBytes(32), 1, 1 * 1024 * 1024); //salt decryptionAlgo.IV = s.ReadBytes(16); //IV decryptionAlgo.Padding = PaddingMode.ISO10126; decryptionAlgo.Mode = CipherMode.CBC; byte[] hmac = s.ReadBytes(32); //hmac long cipherTextStartPosition = s.Position; //authenticate data in Encrypt-then-MAC (EtM) mode using (HMAC aeHmac = new HMACSHA256(decryptionAlgo.Key)) { byte[] computedHmac = aeHmac.ComputeHash(s); if (!BinaryNumber.Equals(hmac, computedHmac)) { throw new CryptographicException("Invalid password or data tampered."); } } //decrypt data and init node s.Position = cipherTextStartPosition; CryptoStream cS = new CryptoStream(s, decryptionAlgo.CreateDecryptor(), CryptoStreamMode.Read); InitMeshNode(new BinaryReader(cS), torController); break; case -1: throw new EndOfStreamException(); default: throw new InvalidDataException("MeshNode format version not supported."); } }
private void LocalDiscovery_PeerDiscovered(LocalPeerDiscovery sender, IPEndPoint peerEP, BinaryNumber networkID) { lock (_chats) { if (_chats.ContainsKey(networkID)) { _chats[networkID].Network.MakeConnection(peerEP); } else { foreach (KeyValuePair <BinaryNumber, BitChat> chat in _chats) { if (networkID.Equals(chat.Value.Network.MaskedPeerEmailAddress)) { chat.Value.Network.SendInvitation(new IPEndPoint[] { peerEP }); break; } } } } }
private BitChatNetwork FindBitChatNetwork(Connection connection, BinaryNumber channelName) { //find network by channel name lock (_chats) { foreach (KeyValuePair <BinaryNumber, BitChat> chat in _chats) { BitChatNetwork network = chat.Value.Network; if (network.Status == BitChatNetworkStatus.Online) { BinaryNumber computedChannelName = network.GetChannelName(connection.LocalPeerID, connection.RemotePeerID); if (computedChannelName.Equals(channelName)) { return(network); } } } } return(null); }
public bool Equals(PeerInfo obj) { if (ReferenceEquals(null, obj)) { return(false); } if (ReferenceEquals(this, obj)) { return(true); } if (!_peerEP.Equals(obj._peerEP)) { return(false); } if (!_networkID.Equals(obj._networkID)) { return(false); } return(true); }
private int ReadSecureChannelPacket() { //read secure channel packet //read first block to read the encrypted packet size OffsetStream.StreamRead(_baseStream, _readEncryptedData, 0, _blockSizeBytes); _cryptoDecryptor.TransformBlock(_readEncryptedData, 0, _blockSizeBytes, _readBufferData, 0); _readBufferPosition = _blockSizeBytes; //read packet header 2 byte length int dataLength = BitConverter.ToUInt16(_readBufferData, 0); _readBufferLength = dataLength; dataLength -= _blockSizeBytes; if (_cryptoDecryptor.CanTransformMultipleBlocks) { if (dataLength > 0) { int pendingBlocks = dataLength / _blockSizeBytes; if (dataLength % _blockSizeBytes > 0) { pendingBlocks++; } int pendingBytes = pendingBlocks * _blockSizeBytes; //read pending blocks OffsetStream.StreamRead(_baseStream, _readEncryptedData, _readBufferPosition, pendingBytes); _cryptoDecryptor.TransformBlock(_readEncryptedData, _readBufferPosition, pendingBytes, _readBufferData, _readBufferPosition); _readBufferPosition += pendingBytes; } } else { while (dataLength > 0) { //read next block OffsetStream.StreamRead(_baseStream, _readEncryptedData, _readBufferPosition, _blockSizeBytes); _cryptoDecryptor.TransformBlock(_readEncryptedData, _readBufferPosition, _blockSizeBytes, _readBufferData, _readBufferPosition); _readBufferPosition += _blockSizeBytes; dataLength -= _blockSizeBytes; } } //read auth hmac BinaryNumber authHMAC = new BinaryNumber(new byte[_authHMACSize]); OffsetStream.StreamRead(_baseStream, authHMAC.Number, 0, _authHMACSize); //verify auth hmac with computed hmac BinaryNumber computedAuthHMAC = new BinaryNumber(_authHMACDecrypt.ComputeHash(_readEncryptedData, 0, _readBufferPosition)); if (!computedAuthHMAC.Equals(authHMAC)) { throw new SecureChannelException(SecureChannelCode.InvalidMessageHMACReceived, _remotePeerEP, _remotePeerCert); } _readBufferPosition = 3; //return bytes available in this packet to read return(_readBufferLength - _readBufferPosition); }
public void ReadMessage(int number, Stream output) { lock (_lock) { if (_disposed) { return; } //seek to index location int indexPosition = number * 4; if (indexPosition >= _index.Length) { throw new IOException("Cannot read message from message store: message number out of range."); } _index.Position = indexPosition; //read message offset byte[] buffer = new byte[4]; _index.ReadBytes(buffer, 0, 4); uint messageOffset = BitConverter.ToUInt32(buffer, 0); //seek to message offset _data.Position = messageOffset; //read data BinaryReader bR = new BinaryReader(_data); byte[] IV; byte[] encryptedData; switch (bR.ReadByte()) //version { case 1: IV = bR.ReadBuffer(); encryptedData = bR.ReadBuffer(); byte[] aeHmac = bR.ReadBuffer(); //verification for authenticated encryption in Encrypt-then-MAC (EtM) mode BinaryNumber computedAeHmac; using (HMAC hmac = new HMACSHA256(_key)) { computedAeHmac = new BinaryNumber(hmac.ComputeHash(encryptedData)); } if (!computedAeHmac.Equals(new BinaryNumber(aeHmac))) { throw new CryptographicException("Cannot read message from message store: message is corrupt or tampered."); } break; default: throw new InvalidDataException("Cannot read message from message store: message version not supported."); } using (MemoryStream src = new MemoryStream(encryptedData, 0, encryptedData.Length)) { _crypto.IV = IV; Decrypt(src, output); } } }
public bool IsPskAuthValid(SecureChannelHandshakeHello serverHello, SecureChannelHandshakeHello clientHello, byte[] psk) { BinaryNumber generatedPskAuthValue = GetPskAuthValue(serverHello.SupportedCiphers, _ephemeralPublicKey, serverHello.Nonce.Value, clientHello.Nonce.Value, psk); return(_pskAuth.Equals(generatedPskAuthValue)); }
public byte[] ReadMessage(int number) { lock (_lock) { //seek to index location int indexPosition = number * 4; if (indexPosition >= _index.Length) { throw new IOException("Cannot read message from message store: message number out of range."); } _index.Position = indexPosition; //read message offset byte[] buffer = new byte[4]; OffsetStream.StreamRead(_index, buffer, 0, 4); uint messageOffset = BitConverter.ToUInt32(buffer, 0); //seek to message offset _data.Position = messageOffset; //read data BincodingDecoder decoder = new BincodingDecoder(_data); byte[] IV; byte[] encryptedData; switch (decoder.DecodeNext().GetByteValue()) //version { case 1: IV = decoder.DecodeNext().Value; encryptedData = decoder.DecodeNext().Value; byte[] aeHmac = decoder.DecodeNext().Value; //verify hmac BinaryNumber computedAeHmac; using (HMAC hmac = new HMACSHA256(_key)) { computedAeHmac = new BinaryNumber(hmac.ComputeHash(encryptedData)); } if (!computedAeHmac.Equals(new BinaryNumber(aeHmac))) { throw new CryptoException("Cannot read message from message store: message is corrupt or tampered."); } break; default: throw new IOException("Cannot read message from message store: message version not supported."); } using (MemoryStream mS = new MemoryStream(encryptedData.Length)) { using (MemoryStream src = new MemoryStream(encryptedData, 0, encryptedData.Length)) { _crypto.IV = IV; _crypto.Decrypt(src, mS); } return(mS.ToArray()); } } }