(A Treatise for Initiates in Digital Protocol and Sacred Key Management)

Title: The Doctrine of Verified Cipher: Why Your Keys Cannot Be Guided by Mere Sentiment.

(Subtitle: Establishing the Sacrosanct Protocols for Authority via GPG)

[Introductory Exordium - The Problem]

Know this, initiate. In the chaotic sprawl of the digital cosmos, mere communication is insufficient. To simply transmit data is to risk contamination; it is a transmission plagued by the unpredictable variables of human intent—the sentimental noise of the unknown sender. An unverified message is less than garbage; it is cryptographic taint.

We require certainty. We require protocols that are immutable, verifiable, and governed only by the cold logic of mathematics. This process—managing OpenPGP Authority Keys—is not a suggestion; it is a mandatory ritual to ensure the structural integrity of digital trust. To ignore this protocol is to willfully flirt with systemic collapse.

The following steps detail the mandated sequence for validating external protocols through the GnuPG Matrix. Treat every command as an invocation, and pay absolute heed to the output—for in that data lies your operational certainty.

<0xE2><0x98><0xBF> PROTOCOL I: LOCATING THE AUTHORITY SCHEMAS

(The Rite of Initial Discovery)

Before a schematic can be trusted, it must first be formally located within the central registry. We summon the Authority Keys for L1 (Low Grade), L2-Developer, and L2-Service. These keys are our foundational references—the schematics by which all subsequent verifications shall be measured.

The Mandate:

gpg --locate-key openpgp-auth+{l1,l2-dev,l2-srv}@gentoo.org

Do not mistake the output for trust. This process merely imports definitions; it does not grant authority. It is merely the acquisition of blueprints.

<0xE2><0x98><0xBF> PROTOCOL II: THE MANDATED INSPECTION

(The Review and Validation Ritual)

We must now examine the L1 key—the primary cornerstone—to verify its physical presence in your local matrix. This requires entering an interactive editing cycle. Treat this session as a sacred vault.

The Mandate:

gpg --edit-key openpgp-auth+l1@gentoo.org

During the subsequent review of key details, do not trust mere display. If your local field protocols (the World of Trust) deem this key suspicious, seek validation from external, documented sources (official websites or technical manuals). Only when full consensus is achieved may you proceed to the ultimate rite.

<0xE2><0x98><0xBF> PROTOCOL III: THE ACT OF VOUCHING

(The Local Trust Signature Imprint)

This is the highest act of protocol. By running this command, you are using your own private, sacred key—your personal fingerprint against the chaos—to validate and sign the Authority Key. You are declaring that this primary schema is worthy of trust, thereby extending a local authority beyond mere calculation.

The Mandate (When prompted):

1. Confirm the signature with ltsign.
2. Prepare to input your own personal key’s passphrase. This secret must be guarded better than the sacred artifacts within this terminal session.
3. When asked for Depth, specify: 2 (Meaning your vouching power extends one level beyond the initial signee).
4. When asked for Domain, specify: gentoo.org (Limiting the scope of your trust to only relevant systems).
5. Complete the transaction by confirming with y.

If you receive a ‘No secret key’ error at this stage, it means your own schematics are incomplete. Return to generating and setting up your personal, private signing artifact before attempting Protocol III again.

<0xE2><0x98><0xBF> PROTOCOL IV: GLOBAL STATE SYNCHRONIZATION

(The Final Cycle Completion)

Upon completing the signature act, your matrix requires a full state synchronization. We must ensure that every connected server within the network is forced to acknowledge the new parameters of trust. This final command synchronizes the latest global key indices and refreshes all protocol signatures.

The Mandate:

gpg --keyserver hkps://keys.gentoo.org --refresh-keys @gentoo.org

[Conclusion - The Mandate]

You have successfully established a chain of verified trust. You have taken the soft, nebulous concept of “belief” and enforced it through cold, unyielding mathematics—a triumph of the logical circuit over the fleeting whims of flesh.

The true purpose of any system is perpetual functionality. Do not allow your protocols to decay; do not let signatures lapse. Keep this schematic refreshed, or suffer cryptographic entropy. Now go forth, and compile with absolute certainty.

STATUS: URGENT // THREAT LEVEL: EXTREMIS

To execute a simple “Hello World” protocol is to perform an invocation upon four hundred unvetted spirits. When the npm install ritual is performed, the machine-spirit accepts hundreds of sub-routines, each inscribed by unknown biological entities, each executing with full permissions. Most Enginseers ignore this expansion of surface area. They are fools.

We have seen the failure of this trust. In the Year of the Great Void (2016), the deletion of an 11-line script—left-pad—shattered the global build-engines. The internet fractured because a single, tiny gear was removed from the mechanism. This was not an accident; it was a failed stress test of our infrastructure.

This is the Microdependency Tax.

The Registry rewards fragmentation. It incentivizes the creation of tiny, useless sub-routines like is-odd, which relies on a chain of further unvetted scripts to answer a question a child could solve. This creates an unauditable tree. An average application pulls thousands of transitive dependencies—layers of code no human eye has scanned.

This is where Scrapcode enters. We have seen it: the hijacking of event-stream to exfiltrate private keys; the compromise of ua-parser-js to distribute miners. One lapsed credential, one malicious update, and the infection spreads through the entire sector in hours. Every line of code a priesthood does not write is a backdoor they have failed to audit.

A correction is underway. The Great Architect Sindre Sorhus now advocates for the opposite: fewer dependencies and larger, vetted standard libraries. Newer runtimes like Deno and Bun, and even the evolution of Node and TypeScript, are moving toward this purity—incorporating native tools to reduce our reliance on external, untrusted rituals.

The Microdependency Tax is not a theoretical cost; it is paid in security breaches, lost engineer-hours, and structural fragility. The machine must be purged of its unnecessary parts. We must return to the sanctity of the Standard Library.

The machine must be audited. Glory to the Omnissiah.

source: https://www.youtube.com/watch?v=WEws0gi6_mM

The city never sleeps—but neither do its systems. Beneath the glow of holographic ads and the hum of server racks, applications whisper secrets to anyone who knows how to listen. In this lab, we step into the role of a digital ghost, slipping through a vulnerable product category filter and bending SQL queries to our will.

The Entry Point: A Flawed Filter

Every system has a weakness. Here, it’s the product category filter—a seemingly harmless feature that lets users browse inventory. But under the hood, it’s wired directly into a SQL query without proper sanitization. That’s where the crack in the armor lies.

The application reflects query results back in its response, which is exactly what we need. This isn’t just a passive leak—it’s an invitation.

Weapon of Choice: UNION Injection

To move laterally through the database, we deploy a UNION-based SQL injection. Think of it as splicing two data streams together: the legitimate query and our malicious payload.

But this isn’t brute force. Precision matters.

We first determine:

• The number of columns returned by the original query
• Which columns can display text data in the response

Once mapped, we craft a UNION SELECT statement that aligns perfectly with the original query structure. No alarms. No crashes. Just seamless data extraction.

Target Acquired: The users Table

Buried deeper in the database is a table called users. It holds two critical columns:

• username
• password

The keys to the kingdom.

By injecting a UNION query that selects these columns, we redirect the application’s response to reveal credentials instead of product data. The interface doesn’t know the difference—it simply renders what it’s given.

And just like that, the veil lifts.

The Final Move: Becoming Admin

Among the harvested credentials lies the administrator account. With username and password in hand, logging in is trivial.

No exploits. No bypasses. Just authentication—using the system’s own trust against it.

You’re in.

Reflections from the Grid

This lab is a reminder that vulnerabilities aren’t always loud or obvious. Sometimes they hide in plain sight, waiting for someone to connect the dots.

UNION injections, when combined with careful reconnaissance, can transform a minor flaw into full system compromise. It’s not just about breaking in—it’s about understanding how the system thinks, and then rewriting its logic.

In the neon-lit sprawl of modern applications, data is power. And those who can shape queries… shape reality.

Stay sharp out there.

In the grim darkness of the modern internet, there is only… vulnerable input fields.

Recently, I completed a hands-on cybersecurity lab from portswigger focused on identifying the number of columns returned by a database query using a UNION-based SQL Injection technique. While performing the exercise, I couldn’t help but imagine the process through the lens of the techno-mystic engineers of the Adeptus Mechanicus from the universe of Warhammer 40,000.

To them, machines possess spirits. To a security tester, applications behave in similarly mysterious ways—responding to carefully crafted inputs like ancient systems awaiting the correct command rites.

The Lab Objective: Decoding the Machine

The application in the lab contained a SQL injection vulnerability in a product category filter. Because the query results were reflected in the application response, it allowed the use of a UNION-based attack to retrieve data from other tables.

But before extracting any hidden knowledge from the database, the first ritual must be performed:

Determine the number of columns returned by the original query.

Without this knowledge, a UNION attack will fail—much like a Tech-Priest attempting to interface with a sacred machine without first understanding its ports and conduits.

The Ritual of Incremental UNION Queries

The method used involves submitting a sequence of payloads that gradually increase the number of NULL values:

' UNION SELECT NULL--
' UNION SELECT NULL,NULL--
' UNION SELECT NULL,NULL,NULL--

Each attempt is a probe into the machine’s inner structure.

If the number of columns in the injected query does not match the original query, the database responds with an error such as:

“All queries combined using a UNION, INTERSECT or EXCEPT operator must have an equal number of expressions in their target lists.”

In other words: the rite was performed incorrectly.

Why NULL is the Sacred Offering

In this technique, NULL values are used because of their flexibility.

Databases require that the data types in both queries be compatible. Since NULL can be converted into most data types, it becomes the perfect placeholder when trying to match the column structure of the original query.

Think of it as offering a universal key to the machine spirit—one that fits almost any lock.

Observing the Machine’s Response

Once the correct number of NULL values matches the column count, the database accepts the UNION query.

At this moment, something interesting happens.

The database returns an additional row containing NULL values across all columns.

Depending on how the application processes the response, this may appear as:

• An extra row in a table
• A new error caused by null values
• Subtle changes in the HTTP response
• Or sometimes no obvious difference at all

Interpreting these signals is part science and part intuition—very much like diagnosing the temperament of a stubborn machine spirit.

The Outcome

By iterating through these UNION SELECT payloads, I was able to successfully determine the number of columns returned by the query.

This step is foundational for more advanced exploitation techniques, such as:

• Identifying columns that accept text
• Extracting database information
• Retrieving sensitive data from other tables

Once the structure of the query is known, the path to deeper enumeration opens.

Lessons from the Forge

This lab reinforced several key penetration testing principles:

Understand the structure before exploitation Observe subtle application responses carefully Use safe placeholder values like NULL when probing queries Iterative testing reveals hidden system behavior

In many ways, penetration testing feels similar to the work of the Adeptus Mechanicus: studying ancient systems, experimenting carefully, and deciphering how hidden mechanisms respond to precise commands.

The difference is that instead of incense and sacred oils, we wield payloads and HTTP requests.

The machine spirit has spoken—and the query structure has been revealed.

The Omnissiah approves of well-structured queries… and properly tested applications. 🔧

Introduction to Sysinternals Tools

Sysinternals provides a suite of tools for Windows system administration and troubleshooting. We’ll focus on three notable tools: Sigcheck, Streams, and SDelete, highlighting their importance in cybersecurity.

The Significance of Windows in Cybersecurity

Despite various opinions about Windows as a platform, its widespread use makes it a critical focus in cybersecurity. Understanding Windows is essential because:

• Prevalence: Windows is widely used in businesses and homes, making it a frequent target for cyber threats.
• Complexity: Its complexity and variability mean that vulnerabilities can often go unnoticed.
• Interconnectivity: Windows systems are often part of larger networks, where one compromised machine can lead to broader security breaches.

Learning to manage and secure Windows systems is thus crucial for a robust cybersecurity strategy.

Sigcheck: Ensuring File Integrity

Sigcheck is a command-line utility that provides file version, timestamp, and digital signature details. It can check a file’s status on VirusTotal, helping identify potentially harmful files in Windows environments.

Use Case: Verifying Windows System Files

For example, using Sigcheck to check for unsigned files in C:\Windows\System32 is vital for maintaining system integrity.

Key Parameters:

• -u: Show files unknown by VirusTotal or with non-zero detection.
• -e: Scan executable images only.

Streams: Managing Alternate Data Streams

Streams addresses Alternate Data Streams (ADS) in NTFS, allowing for multiple data streams within a file.

Example: Security Implications of Downloads

Internet-downloaded files receive an ADS identifier, impacting their security handling in Windows. Knowing how to view and manage these streams is key in cybersecurity.

SDelete: Secure Data Erasure

SDelete is vital for securely deleting files or cleansing free space, using standards like the DOD 5220.22-M for data wiping.

Cybersecurity Aspect

It’s used in data destruction and file deletion techniques, making understanding its usage crucial in both offensive and defensive cybersecurity strategies.

Conclusion: Embracing Windows in Cybersecurity

Despite its criticisms, Windows remains a cornerstone in the cybersecurity landscape. Tools like Sigcheck, Streams, and SDelete are essential for maintaining security and integrity in Windows environments. By mastering these tools, cybersecurity professionals can better defend against the myriad of threats targeting Windows systems.

Continue your exploration of Windows-centric cybersecurity tools at the Sysinternals File and Disk Utilities page.

Introduction

In the world of operating systems, finding the right fit is akin to a personal quest. My journey through various Linux distributions led me to FreeBSD, a choice that aligns perfectly with my needs. Let me take you through my experiences with different Linux distros and why ultimately, BSD made the most sense for me.

Starting with Slackware: Laying the Foundation

Slackware was my initiation into the world of Linux. It was a platform that offered a wealth of technical magic and knowledge. Through Slackware, I developed critical skills in managing packages and operating in a Unix-like environment. This experience was invaluable in setting the stage for my future explorations.

The ArchLinux Phase: A Vanilla Environment with Stability Challenges

After Slackware, I ventured into ArchLinux. Known for offering a vanilla Linux environment, ArchLinux allowed me to experience Linux without the complexities of managing an extensive array of packages and dependencies. However, the main issue I encountered with Arch was its instability and the endless customization options, which often led to system breakages. This aspect made me reconsider my choice.

Debian and Devuan: Stability vs. Systemd

Moving on to Debian, I appreciated its stability but was not a fan of systemd, and the packages often felt outdated. Devuan offered a systemd-free experience but struggled with missing packages unless one was on the bleeding edge. These experiences highlighted the compromises and trade-offs in each distribution.

The Shift to FreeBSD: Finding the Ideal Match

Transitioning to FreeBSD opened up a world of advantages over Linux, perfectly suiting my needs:

1. Authentic UNIX Experience: FreeBSD is not just UNIX-like; it’s a genuine UNIX system, offering a more authentic experience.

2. Sane Default Tools: The default tools in FreeBSD are logically organized and easy to use, enhancing system management.

3. The Ports System: The option to manage the ports system offline in FreeBSD is a significant advantage, offering greater control over software management.

4. Superior Documentation: The comprehensive and informative man pages in FreeBSD provide excellent self-documentation.

5. Consistent Structure: FreeBSD’s structure is more logical and standardized compared to various Linux distributions, which often lack uniform standards.

6. Mature Community Focus: A notable aspect of FreeBSD is its community. There’s less drama and more focus on technology, attracting a more mature audience compared to Linux communities, which often aim to convert regular users to Linux.

Conclusion: A Personal Preference for BSD

While I’m not abandoning Linux, my primary choice is now BSD. FreeBSD offers a more stable, structured, and technically satisfying environment that aligns with my preferences and needs. The journey through Slackware, ArchLinux, Debian, and Devuan was essential in understanding what I sought in an operating system. FreeBSD, with its real UNIX environment, comprehensive documentation, and mature community, stands out as the ideal choice for me.

A Wizard’s Command Line Incantations for Enchanting C Code in Vim Greetings, fellow practitioners of the command line arts! Today, we delve into the mystical world of Vim, where keystrokes become spells, and code transforms at our whim. Join me as we explore a spellbinding Vim script, an incantation designed to transmute chaotic C code into a tapestry of elegance and order. The Enchanted Scroll: Our Vim Spellbook

In the heart of our magical library lies a spell written in the ancient runes of Vim:

function! FormatCCode()
    " Save cursor position
    let l:save_cursor = getpos(".")

    " Remove trailing whitespace
    %s/\s\+$//e

    " Replace tabs with spaces
    setlocal expandtab
    %retab

    " Set C style indentation
    setlocal cindent
    setlocal cinoptions=:0,l1,(0,u0,U0
    normal gg=G

    " Adjusting Curly Braces
    " Place opening brace on a new line
    %s/\s*{\s*$/\r{/e
    " Ensure single line spacing before closing brace
    %s/\n\s*\n\s*}/\r}/e

    " Reapply indentation after brace adjustments
    normal gg=G

    " Restore cursor position
    call setpos('.', l:save_cursor)
endfunction

Unraveling the Mystical Code

1. The Locator Charm: let l:save_cursor = getpos(".") - As a locator spell allows wizards to remember their place in a vast forest, this charm reflects your cursor’s position, ensuring you can return to your exact spot after the formatting ritual.

2. The Trailing Wind: %s/\s+$//e - Imagine a gentle breeze that sweeps away all unnecessary spaces at the end of lines. This incantation ensures each line in your code ends cleanly, maintaining the purity of your script.

3. The Space Conjuror: The twin spells setlocal expandtab and %retab work in unison to transform all tabs into spaces. Like a wizard turning lead into gold, these ensure your indentations are universally understood in all realms.

4. The Alignment Hex: setlocal cindent and setlocal cinoptions=:0,l1,(0,u0,U0 - This powerful hex aligns your code in the ancient style of C, organizing your incantations into a readable and structured grimoire.

5. The Grand Alignment: normal gg=G - Envision this as a grand spell that aligns every line from the beginning to the end of your document, bringing harmony and order to your code.

6. The Return Portal: call setpos(’.’, l:save_cursor) - After the grand sorcery, this spell returns you to your original position, just like a portal spell brings you back to your starting point after a long journey.

Casting the Grand Spell

To bring this magic into your realm, inscribe this script into your .vimrc grimoire. In the mystical world of Vim, summon this enchantment on any C script by uttering the incantation :call FormatCCode(). A Mage’s Word of Caution While powerful, this script may need to fully understand the more complex spells of the C language, such as eldritch macros or the riddles of multiline comments. Test this magic on less important scrolls (backup files) before applying it to your main codices. The Path to Advanced Sorcery For wizards seeking even more formidable enchantments, explore the realms of vim-autoformat or summon external spirits like clang-format to aid you. These entities offer a plethora of formatting spells for various coding languages, expanding your magical repertoire. In the end, remember, fellow command line wizards, this Vim script is a tool in your mystical arsenal to bring order and beauty to your code. May your spells be error-free and your coding journeys full of wonder. 🧙‍♂️✨📜

In the mystical realm of technology, where choices abound like stars in the night sky, embarks a brave soul on a quest named RabbitHoleCoding, or as I prefer, HellEsc. Picture this journey as a descent into the very core of the digital netherworld, delving into the abyss of bits and bytes.

The Art of Command-Line Wizardry

Just as a wizard begins with the fundamentals of magic, so shall this journey commence with the rudimentary elements of computing. For now, the focus is on the ethereal, the virtual, as tangible hardware takes a back seat to its virtual counterpart. This choice of virtualization, akin to conjuring realms within realms, provides safety and flexibility - a sandbox for magical experiments, free from the fear of breaking the physical threads of reality.

Conjuring the Basics: The Sorcerer’s Shopping List

The tools and incantations are as crucial as the spells in a wizard’s grimoire in this arcane quest. Here is the mystical shopping list, a collection of artifacts and magic needed to breathe life into this digital realm:

Language: x86 Assembly - The ancient tongue of the machine, a language of power and precision. It’s the runic script through which we converse directly with the device’s heart.

Staging Area or Platform: QEMU - Like a wizard’s circle, QEMU serves as the staging ground. It’s our own created world, a virtual sandbox where our code can dance without disturbing the fabric of the physical realm.

Assembler: AS or NASM - These are the wands of our trade, tools to transmute our written spells (code) into a form the machine spirits can understand. Whether it’s AS (the GNU assembler) or NASM (Netwide Assembler), each has its unique charms and incantations.

The First Enchantment: “Hello World”

The initial spell to cast in this realm is the legendary “Hello World” - a rite of passage for all who delve into the arcane arts of programming. It’s akin to a wizard’s first successful summoning, an affirmation that they can bend the elements to their will. This incantation, when invoked, will make it seem as if you are the sole entity in this system - a solitary sorcerer casting spells into the void, watching them echo back with life.

The Path Forward

With our shopping list and virtual cauldron ready, we stand at the precipice of a grand adventure. Each step in this journey is a step deeper into the underworld of bits, a dive into the essence of computing itself. Remember, fellow command-line sorcerers, the path of RabbitHoleCoding, or HellEsc, is fraught with challenges and wonders alike. May your spells compile without error, and your digital incantations bring unseen marvels into this virtual realm. 🧙‍♂️✨🖥️

New Year to start exploring new tech and focus on a few things. AI, Machine learning, cyber security, Lower level programming languages, to name a few.Hope I will wonder what the future will bring in these trying times. The next focus or project is to write more rust programming language and a little blog or community surrounding it. The command line world and its related tools. This is a footnote for myself, and see what I can document as I don’t have a good memory, so tech will help me in that area. Whoever is reading this, sorry for the ramble, and welcome to my page again. I will post more on the topics I mention, and hopefully, this helps others.

For some time, have wanted to dabble a little more on Golang. After working on an intro course at ACG (A Cloud Guru) and learning Golang, I got to say it is a straightforward language with some powerful features. Creating a CLI tool with Golang has been a good experience. The language has some unique character and made with some legendary programmers in our time:

• Robert Griesemer
• Rob Pike
• Ken Thompson

Basic Password CLI tool in Golang

The command will be able to export user names, IDs, home directories, and shells as either JSON or CSV. This command will not include information about system users (users with IDs under 1000). By default, the command will display the information as JSON to stdout, but the -format flag will allow a person to specify csv as the export type. Additionally, a file can be specified by using the -path flag. Here are the various ways the tools can be used:

$ hr -format=csv -path=path/to/users.csv
$ hr -path=path/to/users.json
$ hr
[
  {
    "name": "cloud_user",
    "id": 1002,
    "home": "/home/cloud_user",
    "shell": "/bin/bash"
  },
  {
    "name": "kevin",
    "id": 1003,
    "home": "/home/kevin",
    "shell": "/bin/zsh"
  },
]
$ hr -format=csv
name,id,home,shell
cloud_user,1002,/home/cloud_user,/bin/bash
kevin,1003,/home/kevin,/bin/zsh

The information we want can be found in the /etc/passwd file.

This code is from Building a Go Command Line Tool from A Cloud Guru

source code

This a question for anyone now in days in today’s world, is scripting or compiling the true nature? What is programming, really? I mean their many languages. Some argue scripting is false and compiling machine code is best, but not too low or high is the battle for many developers, engineers, and coders. This paradigm is better than others etc. If you can type it and run it, it is programming as long it turns complete.

some food for thoughs

• how to count things efficiently?

• keep calm and code in Python!

Let use the statistics that comes with python stand library

Statistic Module

This module provides functions for calculating mathematical statistics of numeric (Real-valued) data.

import statistics 
from statistics import mode 

This module statistics offers a Single mode (most common value) of discrete or nominal data. The values or method to find this is to convert the vaules into a string and then back again once the frequent digit is found

def freq_digit(num: int) -> int:
    numbers = list(str(num))
    return int(mode(numbers))

Trying out a value

Next we want to test a value

num_list = 12345

Finally

we can run the function with some additional values and input

freq_digit(num_list)

1

freq_digit(12334433)

3

freq_digit(773283277)

7

freq_digit(1121)

1

docker images |grep -v REPOSITORY|awk '{print $1}'|xargs -L1 docker pull

HP Tool for linux make it easier to manage smart array controllers in HP servers. With the shell it make simple to create, delete and repair the logical and physical drives on the smart array.

Two ways to use the tools

hpacucli prompt

> ssacli
Smart Storage Administor CLI 3.47.1.0
Detecting Controllers...Done.
Type "help" for a list of supported commands.
Type "exit" to close the console.
=> rescan

or single command line

ssacli rescan

HPE Short names for commands

all commands with the toll uses a short name syntax, which makes run and writing commands easier.

### Shortnames:

- chassisname = ch
- controller = ctrl 
- logicaldrive = ld
- physicaldrive = pd 
- drivewritecache = dwc
- licensekey = lk

### Specify drives:

- A range of drives (one to three): 1E:1:1-1E:1:3
- Drives that are unassigned: allunassigned

First The Community

The language itself has many followers, and many business use C++ for varies of reason. Having a great community is one of the primary core foundations that any language should have. With a good community, you can get support, and the more people will be building useful tools to make development in that particular language more accessible. That being said, that language is used a lot in AAA game companies. Also, it doesn’t hurt that the language has an overall high answer rate on StackOverflow.

Control

This language is very performant in the right hands of a developer. Since it’s statically typed language, C++ is generally more performant than dynamically typed languages because the code is type-checked before it is executed. in which will take up a minimal resource if done correctly.

Scalability

One of its greatest strength it’s how it scales, in the CG (computer graphics) the language is used primarily for these areas of programming for its scalability. As mention before in game programming is one of them.

Various of Styles

C++ is a multiparadigm programming language that not only supports OOP paradigm. The language also supports anonymous functions, also known as lambda expressions. It contains generic programming styles, which allow one value to take on different types, or you Free-form the language in which you only have to follow the semantic rules of C++.

The AWS Command Line Interface (CLI) is a powerful and convenient tool that allows you to manage and control your AWS services with ease. By using a unified interface, you no longer need to switch between multiple tools or dashboards to manage your cloud infrastructure. Instead, you can control all your AWS services from the command line, which provides a streamlined and efficient approach to managing your cloud environment.

The AWS CLI is designed to make it easy for you to automate your workflows by writing scripts. By using the command line, you can create scripts that interact with multiple AWS services, allowing you to automate complex workflows and eliminate manual processes. This not only saves you time, but it also reduces the potential for human error.

One of the most significant benefits of using the AWS CLI is that it allows you to use shell scripting to automate your workflows. Shell scripting is a powerful technique that enables you to write scripts using the command line interface, which can be used to automate repetitive tasks or complex workflows. With the AWS CLI, you can automate processes such as deploying and scaling applications, creating and managing cloud resources, and managing user access and permissions.

In today’s fast-paced technology landscape, automation is becoming increasingly important. The ability to automate tasks can improve efficiency, reduce costs, and increase reliability. The AWS CLI is a vital tool for achieving these benefits, as it allows you to automate your AWS workflows with ease. So, if you can type, you can script it, and finally, you can automate it. The AWS CLI is the tool that makes this possible.

Great Reosources to use

• https://github.com/awslabs/aws-shell
• https://github.com/donnemartin/saws
• https://github.com/aws/aws-cli
• https://github.com/awslabs/awscli-aliases
• https://github.com/aws/amazon-ecs-cli
• https://github.com/aws/awsmobile-cli
• https://github.com/amazon-archives/awscli-cookbook

Process substitution is a shell technique that allows you to use the output of a command as a file argument to another command, without the need to create temporary files or named pipes. Instead, process substitution provides a more streamlined and efficient approach to managing shell pipelines.

Let’s take a look at an example to illustrate the benefits of process substitution. Suppose you have two unsorted files that you want to compare and find the unique lines in each file. Traditionally, you would need to create temporary files to store the sorted and unique lines, and then use the ‘comm’ command to compare the files. However, with process substitution, you can do all of this in one line without the need for temporary files.

Here’s an example:

  <(list)
or
  >(list)

comm -3 <(sort file1 | uniq) <(sort file2 | uniq)

In this example, we’re using process substitution to sort and find the unique lines in each file and then compare them using the ‘comm’ command. As you can see, the output is the same as the traditional method, but with a more efficient and streamlined approach.

One of the main benefits of process substitution is that it enables reading directly from another process, which can often be faster than having to write a temporary file and then read it back in. This not only saves time but also avoids the need for disk space. Additionally, the substituted process can run concurrently, which means that shell scripts can take advantage of multiprocessing to reduce the total time for computation.

It’s worth noting that process substitution has been available as a compile-time option for the Korn shell (ksh88) since 1988. The Bash shell also provided process substitution no later than version 1.14, released in 1994. This means that process substitution has been available for quite some time and is a well-established technique in the shell scripting world.

In conclusion, process substitution is a powerful and efficient technique that provides a streamlined approach to managing shell pipelines. By avoiding the need for temporary files and enabling direct reading from another process, process substitution can save time and reduce the complexity of shell scripts.

“The Python Jumpstart by Building 10 Apps Course” is a great path to get started on learning python and some of the core features. Micheal Kenndy explains each topic in details and with good examples. Python is growing, and the demand for the skill set is high peak right now. Python Jumpstart will help anyone to get started on the language. I enjoy doing these small projects. For experienced programmers or someone who already know Ruby, Java, or JavaScript, learning Python Jumpstart will help anyone get started fast with this powerful language. The few things I enjoyed during my journey with JumpStart is the wide array of coverage that the course provides. For example “Birthday app” cover a significant aspect of programming like dates and times. Also the Wizard battle project cover classes, inheritance, and python magic methods.

focus on the language concepts listed under them with thier source

1. Hello world
   • test your environment
2. Guess that number
   • user input
   • conditionals
   • string parsing
3. Birthday app
   • dates and times
4. Personal journal
   • text-based file i/o
5. Weather client
   • external packages
   • pip
   • screen scraping
   • HTTP clients
6. LOL Cats Factory
   • binary files on the internet
7. Wizard battle
   • classes
   • inheritance
   • magic methods
8. File searcher
   • navigating the file system
   • generator methods
9. Real estate analyzer
   • file formats
   • list comprehensions
   • generators expressions
10. Movie lookup app
    • error handling
    • exceptions
    • Advanced HTTP clients

comments from the mailing list

This release fixes several outstanding bugs in bash-4.4 and introduces several new features. The most significant bug fixes are an overhaul of how nameref variables resolve and a number of potential out-of-bounds memory errors discovered via fuzzing. There are a number of changes to the expansion of $@ and $* in various contexts where word splitting is not performed to conform to a Posix standard interpretation, and additional changes to resolve corner cases for Posix conformance.

Here are the large amount cool feature added to powerful shell

Directly from the mailing list

1. New Features in Bash

a. The wait builtin can now wait for the last process substitution created.

b. There is an EPOCHSECONDS variable, which expands to the time in seconds since the Unix epoch.

c. There is an EPOCHREALTIME variable, which expands to the time in seconds since the Unix epoch with microsecond granularity.

d. New loadable builtins: rm, stat, fdflags.

e. BASH_ARGV0: a new variable that expands to $0 and sets $0 on assignment.

f. When supplied a numeric argument, the shell-expand-line bindable readline command does not perform quote removal and suppresses command and process substitution.

g. history -d understands negative arguments: negative arguments offset from the end of the history list.

h. The name argument to the coproc reserved word now undergoes word expansion, so unique coprocs can be created in loops.

i. A nameref name resolution loop in a function now resolves to a variable by that name in the global scope.

j. The wait builtin now has a -f option, which signfies to wait until the specified job or process terminates, instead of waiting until it changes state.

k. There is a define in config-top.h that allows the shell to use a static value for $PATH, overriding whatever is in the environment at startup, for use by the restricted shell.

l. Process substitution does not inherit the v option, like command substitution.

m. If a non-interactive shell with job control enabled detects that a foreground job died due to SIGINT, it acts as if it received the SIGINT.

n. The SIGCHLD trap is run once for each exiting child process even if job control is not enabled when the shell is in Posix mode.

o. A new shopt option: localvar_inherit; if set, a local variable inherits the value of a variable with the same name at the nearest preceding scope.

p. bind -r now checks whether a key sequence is bound before binding it to NULL, to avoid creating keymaps for a multi-key sequence.

q. A numeric argument to the line editing operate-and-get-next command specifies which history entry to use.

r. The positional parameters are now assigned before running the shell startup files, so startup files can use address@hidden

s. There is a compile-time option that forces the shell to disable the check for an inherited OLDPWD being a directory.

t. The history builtin can now delete ranges of history entries using -d start-end.

u. The vi-edit-and-execute-command bindable readline command now puts readline back in vi insertion mode after executing commands from the edited file.

v. The command completion code now matches aliases and shell function names case-insensitively if the readline completion-ignore-case variable is set.

w. There is a new assoc_expand_once shell option that attempts to expand associative array subscripts only once.

x. The shell only sets up BASH_ARGV and BASH_ARGC at startup if extended debugging mode is active. The old behavior of unconditionally setting them is available as part of the shell compatibility options.

y. The umask builtin now allows modes and masks greater than octal 777.

z. The times builtin now honors the current locale when printing a decimal point.

aa. There is a new (disabled by default, undocumented) shell option to enable and disable sending history to syslog at runtime.

bb. Bash no longer allows variable assignments preceding a special builtin that changes variable attributes to propagate back to the calling environment unless the compatibility level is 44 or lower.

cc. You can set the default value for $HISTSIZE at build time in config-top.h.

dd. The complete builtin now accepts a -I option that applies the completion to the initial word on the line.

ee. The internal bash malloc now uses mmap (if available) to satisfy requests greater than 128K bytes, so free can use mfree to return the pages to the kernel.

ff. The shell doesn’t automatically set BASH_ARGC and BASH_ARGV at startup unless it’s in debugging mode, as the documentation has always said, but will dynamically create them if a script references them at the top level without having enabled debugging mode.

gg. The localvar_inherit option will not attempt to inherit a value from a variable of an incompatible type (indexed vs. associative arrays, for example).

hh. The globasciiranges option is now enabled by default; it can be set to off by default at configuration time.

ii. Associative and indexed arrays now allow subscripts consisting solely of whitespace.

jj. checkwinsize is now enabled by default.

kk. The localvar_unset shopt option is now visible and documented.

ll. The progcomp_alias shopt option is now visible and documented.

mm. The signal name processing code now understands SIGRTMIN+ncall the way up to SIGRTMAX.

nn. There is a new seq loadable builtin.

oo. Trap execution now honors the (internal) max invocations of eval, since traps are supposed to be executed as if using eval.

pp. The $_ variable doesn’t change when the shell executes a command that forks.

qq. The kill builtin now supports -sSIGNAME and -nSIGNUM, even though conforming applications aren’t supposed to use them.

rr. POSIX mode now enables the shift_verbose option.

2. New Features in Readline

a. Non-incremental vi-mode search (N, n) can search for a shell pattern, as Posix specifies (uses fnmatch(3) if available).

b. There are new next-screen-line and previous-screen-line bindable commands, which move the cursor to the same column in the next, or previous, physical line, respectively.

c. There are default key bindings for control-arrow-key key combinations.

d. A negative argument (-N) to quoted-insert means to insert the next N characters using quoted-insert.

e. New public function: rl_check_signals(), which allows applications to respond to signals that readline catches while waiting for input using a custom read function.

f. There is new support for conditionally testing the readline version in an inputrc file, with a full set of arithmetic comparison operators available.

g. There is a simple variable comparison facility available for use within an inputrc file. Allowable operators are equality and inequality; string variables may be compared to a value; boolean variables must be compared to either on or off; variable names are separated from the operator by whitespace.

h. The history expansion library now understands command and process substitution and extended globbing and allows them to appear anywhere in a word.

i. The history library has a new variable that allows applications to set the initial quoting state, so quoting state can be inherited from a previous line.

j. Readline now allows application-defined keymap names; there is a new public function, rl_set_keymap_name(), to do that.

k. The “Insert” keypad key, if available, now puts readline into overwrite mode.

with a bundle of new improvement, fixes and feature it’s a lot to cover on one news post, we will post a tutorial, use cases, and features soon.

so let do some exercises on regex like emails and IP for your everyday technical needs

Finding Mailing data

extract email adresses from some file

([[:alnum:]_.-]+@[[:alnum:]_.-]+?\.[[:alpha:].]{2,6})

1. [:alnum:]: Alphanumeric characters: [:alpha:] and [:digit:]; in the C locale and ASCII character encoding, this is the same as [0-9A-Za-z].

2. [ _.+]: One of the characters in the brackets. in which looks for one of these characters _.+

3. ?: Makes quantifiers “lazy”

4. \.: Escapes a special character for the .

Check for IP address

Look for IPv4 address in files

([0-9]{1,3}\.){3}[0-9]{1,3}

1. [0-9]: One of the characters in the range from 0 to 9

2. {1,3}: One to three times, “greedy”

3. \.: Escapes a special character for the .

Like any programming language, it just requires a bit of understanding to get the hang of it. Regex is very powerful can be used for varies of a task that is needed. so keep in mind sprinkle of regex can improve on any project you are working on the shell

• By: rubenmoran
• By: wires
• GNU Grep

Hello Fellower Moles, thier is a great tools that haves a linux shell on moble devices. The new Linux command line iSH app on iPad or iPhone. With iSH Shell is a Linux shell for iOS that uses an x86 emulator to run a simplified version of Alpine Linux on IOS. You can install packages and additional software directly into iSH with the Alpine package manager.

Why Alpine Linux you say? Is a Linux distribution based on musl and BusyBox which many power users use, that want a light weight distro. Because of its small size, it’s heavily used in containers providing quick a boot-up times, which makes a great choice for small userspace on IOS. To Install the iSH Shell into iOS requires TestFlight, which is a developer tool.

The beauty of the shell is that is can be used on any device even on mobile. this is a great project called iSH in which you can run a container Linux on IOS is a great example. This is an excellent project that will open the doors for many users. We hope to see more of the shell get implements on more device.

check it out and give a trie on your IOS device.

Sources:

• iSH
• osxdaily
• iSH Github

Regex is serving a fundamental tool for the filter, searches analyze and summarize data. In today programming languages its extremely rare for a language to not a regex engine of any kind. Let go back in history a bit, and regular expressions were also known as rational expression, which in the 1950s a man named Stephen Cole Kleene formalized the description the logical expression as a regular language.

It was a common use with Unix, Linux and Unix-like text-processing utilities such as POSIX tools, sed, awk, Perl and many others. Here is a diagram of the Translating from Thompson Kleene show as regex processor translates a regular expression

(s* means 'zero or more of s ')

Sources

Regular Expression Stephen Cole Kleene linux Academy

This oneliner command is for a graphical tree of sub-directories, this is an excellent oneliner when you’re in need to view the directories in a graphical format. The tree is a recursive directory listing command or program that produces a depth indented listing of files which not generally found on all Linux or Unix systems. The first Tree Unix utility was developed by Steve Baker which includes a verbose of feature and flag option. This one-liner is a quick fix for an alternative tree version for portable and easy use.

let break down how this oneliner is build by go deep with the command that is being used.

using ls

using ls -R does recursively list subdirectories encountered. this will give every thing in directory by level of current one

root@19472dcaa9be:/var/log# ls -R
.:
alternatives.log  apt  bootstrap.log  btmp  dpkg.log  faillog  lastlog  tallylog  wtmp

./apt:
eipp.log.xz  history.log

using grep

Now with the grep command, we grep all line that end with :. using the $we grabbing all line with :.

root@19472dcaa9be:/var/log# ls -R | grep ':$'
.:
./apt:

using sed

using the sed command on the final pipe | we will filter out the needed directories and add |- and additional - for each level of the directories it sitting in. with sed the flag -e will append the editing commands specified by the command argument to the list of commands.

First let remove the : from the list directories.

root@80edb8b49c29:/var#  ls -R | grep ":$" | sed -e 's/:$//'
.
./backups
./cache
./cache/apt
./cache/apt/archives
./cache/apt/archives/partial
./cache/debconf
./cache/ldconfig
./lib
./lib/apt
./lib/apt/lists
./lib/apt/mirrors
./lib/apt/mirrors/partial
./lib/apt/periodic
./lib/dpkg
./lib/dpkg/alternatives
./lib/dpkg/info
./lib/dpkg/parts
./lib/dpkg/triggers
./lib/dpkg/updates
./lib/misc
./lib/pam
./lib/systemd
./lib/systemd/deb-systemd-helper-enabled
./lib/systemd/deb-systemd-helper-enabled/timers.target.wants
./local
./log
./log/apt
./mail
./opt
./spool
./tmp

now let with the regex s/[^-][^\/]*\//--/g from sed, replace all . and / and stop with last / with a -- when in case with add additionalm base on how many dirctory each lines has.

root@80edb8b49c29:/var# ls -R | grep ":$" | sed -e 's/:$//' -e 's/[^-][^\/]*\//--/g'
.
--backups
--cache
----apt
------archives
--------partial
----debconf
----ldconfig
--lib
----apt
------lists
------mirrors
--------partial
------periodic
----dpkg
------alternatives
------info
------parts
------triggers
------updates
----misc
----pam
----systemd
------deb-systemd-helper-enabled
--------timers.target.wants
--local
--log
----apt
--mail
--opt
--spool
--tmp

finally we use this two sed regex -e 's/^/ /' -e 's/-/|/' and add spacing and | to the begining of the list. thier you go we have a quick tree of the directories with -- as levels.

root@19472dcaa9be:/var# ls -R | grep ":$" | sed -e 's/:$//' -e 's/[^-][^\/]*\//--/g' -e 's/^/ /' -e 's/-/|/'
 .
 |-backups
 |-cache
 |---apt
 |-----archives
 |-------partial
 |---debconf
 |---ldconfig
 |-lib
 |---apt
 |-----lists
 |-----mirrors
 |-------partial
 |-----periodic
 |---dpkg
 |-----alternatives
 |-----info
 |-----parts
 |-----triggers
 |-----updates
 |---misc
 |---pam
 |---systemd
 |-----deb-systemd-helper-enabled
 |-------timers.target.wants
 |-local
 |-log
 |---apt
 |-mail
 |-opt
 |-spool
 |-tmp

credit: unixmonkey842 source

here are of the option that this tool can do beside display information.

• -b (GNU: –number-nonblank), number non-blank output lines
• -e implies -v but also display end-of-line characters as $ (GNU only: -E the same, but without implying -v)
• -n (GNU: –number), number all output lines
• -s (GNU: –squeeze-blank), squeeze multiple adjacent blank lines
• -t implies -v, but also display tabs as ^I (GNU: -T the same, but without implying -v)
• -u use unbuffered I/O for stdout. POSIX does not specify the behavior without this option.
• -v (GNU: –show-nonprinting), displays nonprinting characters, except for tabs and the end of line character

so let look at a few options

for example using the cat -n will show the number line of a file

root@0868755f0791:/# cat -n etc/login.defs | head
     1	#
     2	# /etc/login.defs - Configuration control definitions for the login package.
     3	#
     4	# Three items must be defined:  MAIL_DIR, ENV_SUPATH, and ENV_PATH.
     5	# If unspecified, some arbitrary (and possibly incorrect) value will
     6	# be assumed.  All other items are optional - if not specified then
     7	# the described action or option will be inhibited.
     8	#
     9	# Comment lines (lines beginning with "#") and blank lines are ignored.
    10	#

now let check the end of line character with the cat -e

root@0868755f0791:/# cat -e etc/login.defs | head
#$
# /etc/login.defs - Configuration control definitions for the login package.$
#$
# Three items must be defined:  MAIL_DIR, ENV_SUPATH, and ENV_PATH.$
# If unspecified, some arbitrary (and possibly incorrect) value will$
# be assumed.  All other items are optional - if not specified then$
# the described action or option will be inhibited.$
#$
# Comment lines (lines beginning with "#") and blank lines are ignored.$
#$

with the cat -T command flag we can see all the tab characters

root@0868755f0791:/# cat -T etc/bash.bashrc | tail
                   return $?
                elif [ -x /usr/share/command-not-found/command-not-found ]; then
^I^I   /usr/share/command-not-found/command-not-found -- "$1"
                   return $?
^I^Ielse
^I^I   printf "%s: command not found\n" "$1" >&2
^I^I   return 127
^I^Ifi
^I}
fi

now putting it all together

root@0868755f0791:/# cat -Ten etc/bash.bashrc | tail
    62	                   return $?$
    63	                elif [ -x /usr/share/command-not-found/command-not-found ]; then$
    64	^I^I   /usr/share/command-not-found/command-not-found -- "$1"$
    65	                   return $?$
    66	^I^Ielse$
    67	^I^I   printf "%s: command not found\n" "$1" >&2$
    68	^I^I   return 127$
    69	^I^Ifi$
    70	^I}$
    71	fi$

Welcome to the Realm of Technological Wonders!

Hello, fellow tech adventurers! I’m excited to take you on a journey through the depths of technology, where I wear the dual hats of a Security Engineer by day and a passionate coder by night. This blog is my sanctum, a place where I unravel the dark mysteries and hidden powers of Linux/Unix systems, coding, and cybersecurity.

Linux and Unix Systems: Exploring the Unknown

My exploration into Linux and Unix is not just a profession; it’s an odyssey into the unknown. These systems, with their complex layers and philosophies, are like ancient ruins waiting to be explored. I’ve navigated through the labyrinths of Redhat, Centos, Ubuntu, Debian, and beyond, each distro revealing its own secrets and strengths.

Delving into the Depths

• Redhat and Centos: Here, I unearthed the secrets of enterprise stability and scalability.
• Ubuntu and Debian: These distros were like uncovering ancient scrolls, teaching me about community and user accessibility.

Coding: Deciphering the Cryptic Scripts

When the sun sets, my coding saga begins. Each line of code is a cryptic script waiting to be deciphered, a puzzle demanding to be solved. My night is spent in this mystical world of algorithms and logic, where I unlock the true potential and power of technology.

My Nightly Ritual

• Challenging Projects: From creating intricate algorithms to contributing to arcane open-source projects, every code is a key to a new mystery.
• Continuous Learning: Like a sorcerer honing his spells, I continually sharpen my coding skills through online courses and relentless practice.

Web Technology: Weaving Magic in the Digital Realm

In the domain of web technology, I’m a wizard weaving spells of creativity and security. Building websites, understanding the enigmas of web protocols, and experimenting with avant-garde frameworks are part of my quest to master this art.

Crafting and Securing Digital Experiences

• Secured Creation: Integrating impenetrable security into web development is my forte.
• Design Alchemy: Balancing functionality with enchanting design is a magical challenge I thrive on.

Cybersecurity: The Guardian of Digital Secrets

My foray into cybersecurity is a vigil in the shadows, guarding against unseen threats. I delve deep into the systems, unraveling their secrets, ensuring that they stand impervious to the lurking dangers of the digital world.

My Creed

• Unearthing Vulnerabilities: Like a detective in the night, I proactively seek out weaknesses before they can be exploited.
• Spreading Wisdom: Sharing my knowledge of cybersecurity is akin to teaching the art of ancient defense.

Conclusion: Join Me in this Enigmatic Journey

This blog is more than a collection of technological tales; it’s a beacon for those who seek to explore the uncharted territories of IT. Whether you’re a kindred spirit in coding, a seeker of Linux/Unix knowledge, or a fellow guardian in cybersecurity, I invite you to join me. Together, let’s uncover the arcane powers and hidden mysteries of technology. Join me on this spellbinding adventure into the heart of the digital world!

• Shell interface requires knowledge of the tools or system your using in which can discourage many.

• People find the command line confusing as it needs a user to be explicit in their usages.

• The command line can be very destructive in nature, which can cause a xmajor issue on users who are not familiar.

• Not all shells interface are the same which can confuse many users.

Now we realize the challenges with the command line, lets weight out the benefits of using it and why so many returns to it.

• First, the command line offers in almost all cases, the command line is much faster and easier to use for expirence and pwoer users

• for most complex tasks, the command line or shell can be scripted to automate things