DEV Community: Kremilly

ShadowJS: A Fast and Lightweight JavaScript Obfuscator Built with Rust

Kremilly — Fri, 27 Dec 2024 17:23:01 +0000

Hello Dev Community! 👋

Today, I want to introduce a new tool that I’ve been working on: ShadowJS – a fast, lightweight JavaScript obfuscator built with Rust. If you're looking for a way to protect your JavaScript code and prevent tampering, this might be the tool for you.

What is ShadowJS?

ShadowJS is a simple yet powerful JavaScript obfuscator designed to protect your code by converting readable identifiers into cryptic, hard-to-decipher formats. By doing so, it ensures that your proprietary logic remains safe, without sacrificing performance.

Built with Rust, ShadowJS is lightweight and fast, making it ideal for use in production environments where speed and efficiency matter.

Features

Fast & Lightweight: ShadowJS is built in Rust, offering speed and minimal resource usage.
Customizable Obfuscation: The tool generates random, hard-to-read identifiers that make it difficult for anyone to reverse-engineer your code.
Security Focused: It helps protect your code by converting readable variables and function names into obscure identifiers.
Easy to Use: Just a simple command-line interface that lets you obfuscate your JavaScript code in seconds.

How Does It Work?

ShadowJS uses regular expressions to identify JavaScript variables and function names in the code. It then replaces those identifiers with random, unique strings, keeping the rest of the JavaScript code intact.

Here’s how it works in a nutshell:

Reserved Words: ShadowJS doesn’t obfuscate JavaScript keywords like function, return, if, etc., to ensure the code remains valid and functional.
Random Identifiers: Non-reserved identifiers are replaced with random strings to obscure the code’s meaning.

Why Rust?

I chose Rust for this project because of its performance and safety guarantees. Rust ensures that ShadowJS runs efficiently, even on large JavaScript files, while also providing memory safety without needing a garbage collector.

Additionally, Rust makes it easy to build fast command-line tools, which is perfect for this kind of utility.

Installation

If you want to try out ShadowJS, here’s how you can get started:

Step 1: Install Rust

First, make sure you have Rust installed. If you don’t have it yet, follow the official instructions here.

Step 2: Install crate

cargo install shadowjs

Usage Example

For example, to obfuscate input.js and save the result in output.min.js, simply run:

shadowjs input.js output.min.js

That’s it! You’ve successfully obfuscated your JavaScript code with ShadowJS. 🔐

Why Should You Use ShadowJS?

JavaScript is often exposed to the public, which means that anyone can inspect and modify it. By obfuscating your code, you add an extra layer of protection. This can be particularly useful when dealing with proprietary algorithms, business logic, or preventing unauthorized tampering.

Contributing

If you find any bugs or have suggestions to improve ShadowJS, feel free to open an issue or submit a pull request on GitHub. I’d love to have contributions from the community to make this tool even better!

License

ShadowJS is licensed under the MIT License. See the LICENSE file for more details.

That’s all for today! I hope ShadowJS can be a helpful tool for your next project. If you have any questions or need further clarification, feel free to reach out in the comments. Let’s keep building great things! 🚀

A simple tool for automated MySQL database dumps and restores

Kremilly — Tue, 05 Nov 2024 17:05:32 +0000

Hey everyone! 👋

I’ve recently built a Rust-based tool called DumpSync that allows for automatic MySQL database dumps and restores. It’s designed for easy backups, restorations, or even transferring databases between servers.

Overview

DumpSync enables scheduled MySQL database dumps at configurable intervals, saving them to a directory of your choice. You can configure it using environment variables or command-line arguments, which makes it adaptable for various use cases — whether you're running regular backups or managing data migration tasks.

Features:

Automatic dumps at specified intervals
Environment variable and command-line configurations
Saves dumps in a specified directory for easy management

Check it out on GitHub and let me know what you think! I’d love to get feedback, suggestions, or ideas for improvement. 😊

Why Use Rust?

Kremilly — Thu, 25 Jul 2024 14:45:10 +0000

Creation of the Language

Rust was created in 2006 by the Mozilla engineering team to address critical problems in software development, especially those related to memory safety, concurrency, and performance. Highly versatile, it has garnered increasing interest in recent years. Its elegant syntax and powerful safety tools make it a popular choice among developers seeking performance and reliability. The vibrant community and ongoing support from the Mozilla Foundation also contribute to its prominence in the modern programming landscape.

Strengths of the Language

Like all programming languages, Rust has several strengths that make it stand out among other languages on the market. Here are some of the main reasons to consider using Rust:

Memory Safety: Rust is designed to eliminate memory errors, such as out-of-bounds array accesses and null pointer dereferencing, without the need for a garbage collector. It achieves this through its ownership and borrowing system.
Concurrency: Rust offers modern tools for concurrent programming. Thanks to its ownership system, it is harder to make common concurrency mistakes, such as race conditions.
Performance: Rust is a compiled language that offers performance comparable to C++ in many cases. It is designed to be fast and provides fine control over low-level details when necessary.
Interoperability with C: Rust can easily interoperate with C code, making it suitable for rewriting critical parts of existing systems or creating high-performance extensions for languages like Python.
Modern Tools: Rust comes with a package manager and build system called Cargo. It simplifies project compilation, dependency management, and library publishing.
Rapid Evolution: The Rust community is active and constantly improving the language, libraries, and tools.
Active and Welcoming Community: The Rust community is known for being extremely welcoming and active. There are many resources, such as "The Rust Book," to help new users learn the language.
Use in Various Domains: Rust is being adopted in various areas, from embedded systems to web development (e.g., with frameworks like Rocket and via WebAssembly).
Zero-Cost Abstractions: Like C++, Rust allows programmers to write abstractions without performance penalties.
Adoption by Companies: Large companies such as Microsoft, Google, and Facebook have shown interest in Rust and have explored its use in various projects.

Where is Rust Used?

Rust can be used in any system that requires careful handling of allocation and resource safety on the machine running the code. Here is a small list of examples where the language is being used:

Browsers (e.g., the Servo rendering engine)
Operating Systems (e.g., Redox OS)
Blockchain (e.g., Polkadot)
Development Tools (e.g., ripgrep, a text search tool)

It is Worth Noting That...

The adoption of any programming language depends on the specific needs of the project, the team, and the application domain. Rust may not be the right choice for all projects, but its features make it an attractive option for many scenarios, especially when memory safety and performance are primary concerns.

Additionally, Rust's emphasis on memory safety and its innovative approach to handling concurrency and parallelism make it particularly suitable for sensitive applications, such as embedded systems, where reliability is crucial. Its robustness and exceptional performance also make it an attractive choice for developing distributed systems infrastructure and networks, where scalability and resilience are key. As the demand for reliable and efficient software continues to grow, Rust emerges as a powerful and relevant tool to tackle the challenges of modern software development.

How to add pinned repos in your portfolio or website?

Kremilly — Wed, 22 Nov 2023 17:29:40 +0000

If you want to add your pinned repositories to your portfolio or website and can't find an API that works for this, then your problems are over. I've created an API that does exactly that, and its usage is extremely easy. Simply pass your GitHub username as a query parameter.

https://api.kremilly.com/github?user=YOUR_USERNAME

Example of use:

fetch('https://api.kremilly.com/github?user=kremilly').then(
   json => json.json()
).then(callback => { 
   console.log(callback) 
})

Replace YOUR_USERNAME with your GitHub username.

The API will return a JSON with all your pinned repositories (if any; otherwise, it will return an empty JSON).