De-Coder’s Ring

Consumable Security and Technology

Category: elasticsearch (page 1 of 3)

Network Monitoring on the Cheap

I’ve regularly blogged about Suricata, Logstash and Elasticsearch.  Shoot, I’ve built multiple successful commercial tools using that technical stack.  The thing that made us successful wasn’t the tech, but it was how we used the tech to solve a problem that our customers had at that moment in time.

Now it’s time for me to share the secret on how to do it.

Ok, not a secret at all.  If you google, you can figure it out.

With this podcast, I want to introduce the topic to put some context around why those tools are the right tools.

I want to evangelize the idea of EVERYONE monitoring your home or work network with basic rules from places like Emerging Threats.  It’s free, and it’s invaluable to finding/stopping malware/viruses on your network.  Do it now!

Suricata

https://www.elastic.co/

https://redmine.openinfosecfoundation.org/projects/suricata/wiki/_Logstash_Kibana_and_Suricata_JSON_output

https://rules.emergingthreats.net/open/suricata-1.3/

Subscribe here : https://fauie.com/feed/podcast

Kent Brake – Interview

This is another exciting podcast for the Decoder’s Ring series!

My friend Kent Brake joined me with a wealth of knowledge around cybersecurity and a few tools we can use to get a new network and host-based system monitoring.

Kent’s a seasons security architect and is currently working as a Solutions Architect for a company that you probably know.

In this podcast, we talk about how to start building a network security solution.  We discuss Bro, Suricata, Elasticsearch, Greylog, Splunk and all kinds of fun stuff you can use to create a new monitoring system.

OSQuery?  Yep, talked about that too!

Subscribe here : https://fauie.com/feed/podcast

Inverting the Message Bus

I had a conversation this morning, where I just (maybe I’m slow) realized how Apache Kafka has inverted the responsibility in the world of message passing.

Traditional enterprise services busses ( Wikipedia: Enterprise Service Bus ) typically have some smarts built in.  The bus itself routes messages, transforms messages and orchestrates actions based on message attributes.  This was the first attempt at building a great mediation layer in an enterprise.  Some advantages of the traditional ESB were:

  • Producer/Consume Language Agnostic
  • Input/Output format changes (XML, JSON, etc)
  • Defined routing and actions on messages

The challenges were typical for traditional enterprise software.  Scaling was a mess and licenses could be cost prohibitive to scale.   This meant lower adoption and general loss of the advantages for smaller projects or customers.

Talk about a huge and complex stack!   Look at this picture for the ‘core’ capabilities of an Enterprise Service Bus:

 

ESB Component Hive

ESB Component Hive

Now let’s take a look at Apache Kafka.

Kafka Diagram

Kafka Diagram

Ok, that’s a lot of arrows, and lines and block, oh my.

BUT, The thing to notice here that’s SUPER important, is that they’re all outside the Kafka box.  Kafka isn’t smart.  In fact, Kafka was designed to be dumb.    There is no message routing, there’s no message format changes, nothing.    The big box in the middle is dumb.    It scales really well, and stays dumb.

In fact, the only ‘type’ of communication that Kafka has is publish/subscribe.   One(to-many) clients produce messages to a topic.    They send in data.   Doesn’t matter if it’s JSON, XML, yiddish, etc.   It goes to the topic.   Kafka batches them up, and ‘persists’ them as a log file.   That’s it.  A big old data file on disk.  The smarts of Kafka comes next…  One Consumer Group (which may be MANY actual instances of software, but with the same group ID) subscribe to a topic… or more than one topic.    Kafka (Zookeeper help) remembers which client in the client group has seen which block of messages.  Ok, that sounds confusing. I’ll try again.

Kafka coordinates which blocks of data get to which client.   If the clients are in the same client group, then data is only sent out once to a member of the client group.    More than one client group can subscribe to a topic, so you can have multiple consumer processes for each topic.

Now, instead of the message bus sending messages from one function to another, that work is left up to the clients.   For instance, let’s say you have to ingest an email from a mail server and test it to see if there’s a malicious reply-to address.

First, the message comes in as plain text to the ‘email_ingest‘ topic.   This can be published to by many clients reading data from many servers.  Let’s assume Logstash.  Logstash will send the message in as plain text.    After the message is in the ‘email_ingest‘ topic, another program will transform that message to JSON.  This program subscribes to ‘email_ingest‘, pulls each message, transforms to JSON, and publishes it back to another topic ‘email_jsonified‘.

The last piece of the puzzle is the code that calls the email hygiene function.   This piece of code takes the longest, due to calling an external API, so needs to scale horizontally the most.    This function reads from ‘email_jsonified‘, calls the external API, and if there’s a malicious IP or reply-to detected, publishes the message on the last topic ’email_alert’.   ‘email_alert‘ is subscribed to by another Logstash instance, to push the message into Elasticsearch for visualization in Kibana.

Sounds complicated right?

The big difference here, is that the intelligence moved into the clients.   The clients need to handle the orchestration, error handling, reporting, etc.   That has some pros and cons.  It’s great that clients can now be written in many technologies, and there is more ‘freedom’ for a development group to do their own thing in a language or framework they’re best suited for.   That can also be bad.  Errors add a new challenge.  Dead letter queues can be a pain to manage, but, again, it puts the onus on the client organization (in the case of a distributed set of teams) to handle their own errors.

Kafka scales horizontally on a small footprint really easily.  It’s mostly a network IO bound system, instead of a CPU or memory bound system.  It’s important to keep an eye on disk space, memory and CPU, but they tend not to be an issue if you set up your retention policies in an environment appropriate manner.

Reach out if you have any questions

Do you prefer RabbitMQ?  ActiveMQ?  Kafka?  (They’re not the same, but similar!)

Moving from Splunk to Elasticsearch

Splunk is magical.   It is a wonderful technology that has allowed many practitioners the ability to slice and dice data, in ways that they couldn’t do before.  I’ve been on the user side, and the application developer side of things.  I’ve worked closely with folks within the Splunk organization over the year, and want to publicly say “It’s awesome!”

The challenge I’m finding with partners, clients, etc, is that Splunk gets expensive, fast.

We need to add data, but the more data we add, the pricier in gets.

In steps Elasticsearch.

Elasticsearch is free/open source software that provides full text search capabilities in a highly scalable fashion.  Did I mention it’s free?  Just pay for hardware.

Throwing an Elastic cluster, and scaling it up, is a super simple task in a cloud provider like Elasticsearch.

One new topic for this blog, is migrating from Splunk to ES.  I’ll do a side by side to view inputs!

 

 

Older posts

© 2017 De-Coder’s Ring

Theme by Anders NorenUp ↑