The post IP Camera Hacking: Hacking IP Cameras with Cameradar first appeared on Hackers Arise.

Welcome back, aspiring cyberwarriors!

One of the fundamental principles that separates Linux from other operating systems is its philosophy that nearly everything is a file, and more often than not, these files contain plain text. Configuration files that control how services behave, log files that record system activity, and network captures that reveal traffic patterns. Countless other critical components of the system exist as text files that you can read, modify, and manipulate using simple command-line tools.

In this article, we will explore the essential commands and techniques for manipulating text in Linux. Let’s get rolling!

Step 1: Cat That File

For demonstration purposes, we will use files from the world’s best Network Intrusion Detection System (NIDS), Snort. If some of you have prior experience with Snort, you probably know that the configuration file was called snort.conf. However, in Snort 3, the traditional snort.conf file has been replaced by Lua-based configuration files in snort.lua serving as the primary configuration file.

Now, let’s move on to the cat command. As demonstrated in an earlier tutorial, cat is one of the most basic text display commands. Let’s use cat to view the Snort configuration file located in /etc/snort.

kali > cat /etc/snort/snort.lua

As you can see, snort.lua is displayed on our screen until it reaches the end of the file. Not the most convenient or practical way to work with this file.

Step 2: Take the Head

To view the beginning of a file, use the head command. This command displays the first 10 lines of a file, by default.

kali > head /etc/snort/snort.lua

If we want to see more or fewer than the default 10 lines, we can tell head how many lines to display by putting the number of lines we want (with the – n switch) between the command and the file name.

kali > head -20 /etc/snort/snort.lua

Here we can see that only the first 20 lines of snort.lua are displayed.

Step 3: Grab That Tail

Similar to the head command, we can view the last lines of a file with the tail command. Let’s use it on the snort.lua.

kali > tail /etc/snort/snort.lua

Note that it shows some logging configurations but not all. Let’s see if we can display all of them by retrieving the last 20 lines of the snort.lua file.

kali > tail -20 /etc/snort/snort.lua

Now we can view nearly all the logging rules on one screen.

Step 4: Numbering Those Lines

Sometimes—especially with very long files—we may want the file displayed with line numbers. This is probably the case with snort.lua, which has over 200 lines. This makes it easier to reference changes and come back to the same place within a file. To display a file with a line number, we simply type:

kali > nl /etc/snort/snort.lua

Note that each line now has a number, making referencing much easier.

Step 5: I Grep That

After cat, grep is the most widely used text manipulation command. It’s a filtering command; in other words, it enables us to filter the content of a file for display. If, for instance, we wanted to see all the instances of where the word “log” occurs in our snort.lua file, we could ask cat only to display those lines where it occurs by typing:

kali > cat /etc/snort/snort.lua | grep log

This command will first grab the snort.lua and then “pipe” it (|) to grep, which will take it as input and then look for the occurrences of the word “log” and only display those lines. Grep is a powerful and essential command for working in Linux, as it can save us hours searching for every occurrence of a word or command.

Step 6: I Sed That Works

The sed command allows us to search for occurrences of a word or text pattern and then perform some work on them. The name comes from the concept of a stream editor and is a contraction of those two words. At its most basic, sed operates like the Find and Replace function in Windows. Let’s search for the word “modbus” in the snort.lua file using grep.

kali > cat /etc/snort/snort.lua | grep modbus

We can see that the grep command found four occurrences of the word modbus.

Let’s say we want sed to replace every occurrence of modbus with Modbus (remember, Linux is case-sensitive) and then save the new file as snort2.lua.

We could do this by typing:

kali > sed s/modbus/Modbus/g /etc/snort/snort.lua > snort2.lua

This command says, “search (s) for the word modbus and replace it with the word Modbus globally (i.e., wherever you find it in the file).”

kali > cat /etc/snort/snort2.lua | grep Modbus

Now, when we grep snort2.lua for Modbus, we see that none were found, and when we grep for Modbus, we find four occurrences of Modbus.

If we want to replace only the first occurrence of the word modbus, we could leave out the trailing ‘g’ (for global), and it would replace only the first occurrence.

kali > sed s/modbus/Modbus/ snort.lua > snort2.lua

Step 7: Less is More

Although cat is a good utility for creating and displaying small files, it certainly has its shortcomings when displaying large ones. When we catch the snort.lua, it scrolls through numerous pages until it comes to the end. Not very practical.

For working with larger files, we have two other utilities, more and less. More came first and is the utility that the man (manual) pages use. Let’s open snort.lua with more commands.

kali > more /etc/snort/snort.lua

Notice that more displays only the first page and displays for us in the lower left corner how much of the file is shown (13% in this case).

To see additional lines or pages, we can use the ENTER key, PAGE UP, or PAGE DOWN to move an entire page. To exit more, type “q” for quit.

Less is very similar to more, but with additional functionality; hence the common Linux aficionado quip: “Less is more.”

Let’s open snort.lua with less.

kali > less /etc/snort/snort.lua

Notice near the bottom-left of the screen that ‘less’ has highlighted the file path.

If we hit the / key, less will enable us to search for terms in the file. For instance, let’s search for filters:

/filter

This will immediately take us to the first occurrence of output and highlight it.

We can then look for the next occurrence of filter by typing “n” for next.

As you can see, less took us to the next occurrence of the word filter, highlighted all the search terms, and in this case, took us directly to the filter section of Snort. How convenient!

Summary

This article illustrates essential commands and techniques for manipulating text in Linux, emphasizing the importance of text files in system configuration and logging. We explored commands such as cat, head, tail, nl, grep, and sed, demonstrating how they can enhance your efficiency in handling configuration files like snort.lua.

For more information on using Linux for hacking, check out the book “Linux Basics for Hackers” on Amazon or visit our training center.

The post Linux Basics for Hackers, Part 09: Text Manipulation first appeared on Hackers Arise.

Hackers-Arise Offers the Best Cybersecurity Training on the Planet!

We attract the best students from around the world and make them the best cyberwarriors on the planet!

Don’t take our word for it, look what are students are saying! These are all unsolicited testimonials from real people!

To participate in this state-of-the-art training, we offer multiple training packages. One for nearly every budget and every skill level, such as:

Member Gold

This is a monthly program where you can study online over 40 courses.

Subscriber

This is our most popular program. You can attend live trainings by Master OTW and study over 40 previous courses in the Subscriber package online. These courses are for those in the beginner to intermediate level.

Subscriber Pro

This is our ultimate package. It includes all the courses available at Hackers-Arise. Includes our advanced and specialty courses such as Satellite Hacking, SCADA Hacking, IoT Hacking, IP Camera Hacking, Bitcoin Forensics and many more!

What are you waiting for? Get started in the most exciting field in IT with the best training company, Hackers-Arise!

For more on our many training packages and Subscriptions, click here.

The post Hackers-Arise Offers the Best Cybersecurity Training on the Planet! Listen to What our Students are Saying! first appeared on Hackers Arise.

Kubernetes is now the go-to standard for container orchestration, running mission-critical applications in numerous organizations. However, like any complex system, Kubernetes clusters may have hidden vulnerabilities that attackers can target. But before you begin your Kubernetes journey, let’s take a moment to familiarize you with some essential concepts.

What Does Kubernetes Do?

Kubernetes has become the top platform, transforming application deployment, scaling and management. But what does it actually do? Here’s a breakdown:

1. Runs Containers in a Container Engine: Kubernetes runs containerized applications using runtimes like Docker or CRI-O. It packages apps into containers, deploys them across clusters, and manages their lifecycle.
2. Efficiently Schedules Containers: Kubernetes optimizes resource utilization by intelligently scheduling containers on the best nodes, balancing workloads for performance and efficiency.
3. Keeps Containers Alive: It monitors container health, automatically restarting failed containers and rescheduling them on other nodes when necessary, ensuring high availability.
4. Facilitates Container Communication: Kubernetes handles networking with IP assignment, service discovery, load balancing, and network policies that manage traffic flow between containers and external services.
5. Supports Various Deployment Techniques: It offers rolling updates, blue-green deployments, canary releases, and automated scaling, ensuring flexibility and minimizing downtime during updates.
6. Handles Volumes of Information: Kubernetes supports persistent storage, managing volumes independently of containers to ensure data persistence across restarts and reschedules.

Kubernetes Architecture

Kubernetes gives you the platform to schedule and run containers on clusters of physical or virtual machines. Kubernetes architecture divides a cluster into components that work together to maintain the cluster’s defined state.

A Kubernetes cluster is a set of node machines for running containerized applications. You can visualize a Kubernetes cluster as two parts: the control plane and the compute machines, or nodes. Each node is its own environment, and could be either a physical or virtual machine. Each node runs pods, which are made up of containers.

The Kubernetes API (application programming interface) is the front end of the Kubernetes control plane and is how users interact with their Kubernetes cluster. The API server determines if a request is valid and then processes it.

The Kubernetes API is the interface used to manage, create, and configure Kubernetes clusters. It’s how the users, external components, and parts of your cluster all communicate with each other.

Node: The operating system that runs one or more Pods.

Pod: A wrapper around one or more containers, typically hosting a single application. In most cases, a Pod contains just one container. Pods abstract the underlying container technology in Kubernetes.

Service: Each Pod has its own internal IP, but a Service exposes it externally or internally. The Service acts as a load balancer, ensuring that even if a Pod dies and is replaced (with a different IP), it remains accessible at the same IP of the Service.

Kubelet: The primary agent on each node. It manages the communication between the node and Kubernetes, ensuring only Pods created by Kubernetes are managed. It interacts with the API server to run and monitor Pods.

Kube-proxy: This service facilitates communication between the API server and nodes by managing network rules via iptables.

Sidecar Container: Sidecar containers run alongside the main container within a Pod. They extend functionality without altering the primary container. These containers focus on specialized tasks, complementing the main application.

Master Components:

• API Server: The gateway for communication between users, Pods, and the master process. Only authenticated requests are allowed.
• Scheduler: Responsible for matching Pods to Nodes based on resource availability. It communicates with the Kubelet to launch Pods but doesn’t start them directly.
• Kube Controller Manager: This component ensures that the correct number of Pods or Nodes are running. It checks resources like replica sets and deployments and, if a Pod is missing, triggers the Scheduler to start a new one. It also manages replication, tokens, and API account services.
• etcd: Kubernetes’ persistent, consistent, and distributed key-value storage. It logs every change, storing the complete state of the cluster. Components like the Scheduler and Controller Manager rely on etcd to track changes in node resources and the number of running Pods.
• Cloud Controller Manager: This manages cloud-specific controls, such as when clusters run on platforms like AWS or OpenStack.

Volumes: When data needs to persist beyond the lifecycle of a Pod, it is stored in a physical volume. Kubernetes allows the attachment of local or remote storage to a Pod.

How Kubernetes Works

Kubernetes operates on the principle of maintaining the desired state of a cluster by continuously comparing it with the actual state. This process ensures that applications and services are running as intended, and any deviations are automatically corrected.

In Kubernetes, the desired state represents what you want your applications and infrastructure to look like. This state is defined through Kubernetes objects, which are configurations submitted by developers or system administrators using YAML or JSON files. These files specify various details, including the number of application replicas, the container images to use, resource allocations, and other configuration parameters.

Once a Kubernetes object is created and its desired state is defined, Kubernetes works to ensure that this state is consistently achieved. The system continuously monitors the cluster and takes corrective actions to align the actual state with the defined desired state.

Consider a scenario where you deploy an application with a desired state of having three replicas running at all times. If one of these containers fails, the replica set controller will notice that only two replicas are active. It will then create a new container to replace the failed one, thereby restoring the total number of replicas to the desired state.

Replica sets are a specific type of controller responsible for ensuring that a specified number of Pods (the smallest deployable units in Kubernetes) are running. They handle the scaling and replacement of Pods as needed.

Kubernetes Deployments

A Deployment helps you specify important details about your application, such as which container images to use and how many instances (Pods) of the application should be running. Instead of manually managing updates or scaling, a Deployment automates these tasks.

When you create a Deployment, Kubernetes sets up and maintains the specified number of Pods to match your requirements. If you need to update the application—say, by changing the version of the container image—the Deployment handles this update automatically. It does so in a way that keeps your application running with minimal disruption.

If something goes wrong with an update, you can easily roll back to a previous version using the Deployment. This ensures that you can revert to a stable state without manual intervention. Additionally, you can scale your application up or down by adjusting the number of Pods in the Deployment. Kubernetes takes care of creating or removing Pods as needed to match your desired scale.

Deployments also give you control over how updates are applied. You can pause an update if you need to review or make changes, and then resume it when you’re ready.

Kubernetes Deployments make it easier to manage your applications by automating repetitive tasks like updating and scaling. This means less manual work and more reliable operations, helping you keep the applications running smoothly and consistently.

Summary

Now you have a foundational understanding of Kubernetes and its key concepts. Mastering Kubernetes will enhance your ability to hack a system. Stay tuned for our upcoming articles to dive deeper into advanced topics and techniques.

The post Getting Started With Kubernetes first appeared on Hackers Arise.

Welcome back, aspiring OSINT investigators!

Most people are actively represented on social media. Moreover, they maintain their pages quite actively and publish a huge amount of interesting information about themselves. Therefore, if a person caught our attention during OSINT, it definitely makes sense to find their social media pages and examine them.

In this article, we will figure out how to effectively search by nickname using the Sherlock utility. Let’s get rolling!

What Does Sherlock Do?

Sherlock is an open-source OSINT tool designed to find usernames across a wide range of social networks and websites. It can currently check for a given username across 400+ websites and platforms, allowing investigators to quickly determine where a username is active.

Sherlock is designed to be straightforward for open source investigations: it does not require API keys or login credentials for the sites it checks; instead, it simply constructs the expected profile URL for each site and observes the response to determine whether the username exists on a given platform. This means it only accesses publicly available information and cannot bypass privacy settings or account restrictions.

Sherlock Installation & Usage

To install Sherlock, open a Linux terminal and run the command below.

kali> sudo apt install sherlock

Once the installation is complete, verify that Sherlock is installed correctly by running the help command:

kali> sherlock –help

After reviewing the help, we can move on directly to the search. We can do this by simply running the following command in the terminal:

kali> sherlock <username>

After some time, we can see 49 positive results. However, as with any tool, it’s important to verify whether these profiles match the person you’re searching for.

The results will be saved to a .txt file named after the search term. But according to the help screen, we can save the results in XLSX and CSV formats as well.

kali> sherlock <username> –csv

In the screenshot above, you can see at the top the command itself and at the bottom the results in CSV format.

Another valuable feature is limiting the scope to certain sites, for example, Instagram and GitHub.

kali> sherlock <username> –site GitHub –site Instagram

Moreover, we can modify the timeout and route requests through a proxy. The default timeout is 60 seconds, but let’s try reducing it to 1 second.

kali> sherlock –timeout 1 <username>

Summary

Sherlock is a powerful OSINT tool that offers a fast and efficient way to search for social media profiles across multiple platforms. It’s definitely one to add to your research toolbox!

If you want to improve your OSINT skills, check out this OSINT Investigator Bundle. It covers both fundamental and advanced techniques and includes an OSINT Certified Investigator Voucher.

The post Open-Source Intelligence(OSINT): Sherlock – The Ultimate Username Enumeration Tool first appeared on Hackers Arise.

The post Software Defined Radio (SDR) for Hackers: Choosing the Best Hardware for SDR first appeared on Hackers Arise.