Windows Flash Tool with Dynamic DLL

$250-750 USD

Posted 1 minute ago

•

Ends in 6 days

$250-750 USD

Paid on delivery

I need a lightweight Windows-only desktop application that can flash our proprietary, Windows-compatible device in a secure, modular way. The workflow is straightforward: 1. At launch the app asks the user for an alphanumeric Token, grabs the machine’s HWID, and posts both to my backend endpoint POST /api/v1/auth/verify. Until the server responds “OK”, every flashing-related control must stay disabled. 2. Once authenticated, the user presses “Flash”. The app silently pulls the latest firmware package from my server and, at the same moment, loads the separate flashing engine DLL straight into memory (the DLL is not compiled into the main executable). After a successful in-memory load, the engine takes over and pushes the firmware to the device over USB. 3. A clear progress bar and status messages (“verifying token”, “downloading firmware”, “loading engine”, “flashing complete”, etc.) keep the user informed throughout the process. Deliverables (acceptance criteria) • One Windows 10+ executable that meets the flow above • External DLL loaded dynamically at runtime, not shipped statically inside the exe • Source code with concise build instructions so I can update the DLL or API URL later • Brief README outlining token/HWID collection, the verify call, and where the firmware URL is defined Successful delivery is a single-click flasher that cleanly separates authentication, firmware download, and a hot-swappable flashing engine DLL.

Project ID: 40809029

About the project

21 proposals

Open for bidding

Remote project

Active 5 secs ago

Place your bid

Bid amount Email address

Benefits of bidding on Freelancer

Set your budget and timeframe

It's free to sign up and bid on jobs

21 freelancers are bidding on average $423 USD for this job

User Avatar
Flag of INDONESIA

Hi there, I'm excited by your project to develop a secure, modular Windows flasher leveraging a dynamic DLL architecture. Your requirement for strict separation between authentication, firmware retrieval, and the flashing engine aligns perfectly with robust software design principles I regularly employ. With extensive experience in C#, C++, and Windows desktop development, I've built similar solutions involving USB device communication, secure authentication, and dynamic in-memory DLL loading. I'm adept at designing user-friendly interfaces that clearly convey process steps, such as token verification, firmware download, and real-time flashing progress. My approach will ensure the app disables all flashing controls until your backend verifies the HWID and token. The firmware download and DLL loading will occur seamlessly in the background, with clear status updates and progress bars. The flashing engine will be loaded dynamically at runtime, enabling easy updates or replacements without touching the main executable. I’ll provide well-documented, maintainable source code and concise build instructions so you can adjust API URLs or DLLs as needed. You’ll also receive a brief README explaining the flow, token/HWID handling, authentication API call, and firmware path configuration. I'm confident I can deliver a single-click, modular flasher that meets all your outlined requirements. I look forward to discussing your project in detail. Best Regards

User Avatar
Flag of SERBIA

Hi, The security gate here is that the token and HWID must reach your backend before anything else runs, and the app has to stay locked until you say "OK"—if that handshake fails or times out, the user sees a disabled interface, not a crash or a retry loop that leaks information. I'd build this in C# with WPF for the UI. At startup, the app collects the token from a text field and the machine HWID using Windows Management Instrumentation, posts both to your verify endpoint, and disables all flash controls until the response is "OK". Once authenticated, the Flash button becomes live. Pressing it triggers a parallel download of the firmware package from your server and a dynamic load of the engine DLL using P/Invoke and LoadLibrary, so the DLL stays external and swappable. The DLL export function receives the firmware path and device handle, and the main app pipes status updates ("verifying token", "downloading firmware", "loading engine", "flashing complete") to a progress bar throughout. I'd test the full flow on Windows 10 and 11, including timeout handling on the verify call, USB device detection, and a missing or corrupted DLL. The source will be clean C# with separate namespaces for auth, download, and DLL interop, plus a README showing where to swap the API URL and firmware endpoint. Send your API spec for the verify endpoint and I'll start with the auth flow and UI skeleton. Denis

User Avatar
Flag of UNITED STATES

Hi, 10+ years of experience building secure backend integrations and Windows desktop tooling with C# and .NET. I understand the required flow: disable all flashing controls until POST /api/v1/auth/verify returns OK for token+HWID, then download the latest firmware package and load the external flashing engine DLL straight into memory for hot-swappable USB flashing. I’ll implement the token/HWID collection, HTTP client with strict state gating, progress/status reporting, and a clear interface boundary so the DLL can be updated without rebuilding the main EXE. You’ll get a Windows 10+ single-click flasher executable plus source code, build steps, and a README documenting token/HWID, verify call, and where the firmware URL is configured. Best, Razmik

User Avatar
Flag of TANZANIA, UNITED REPUBLIC OF

Hello, Looking at your flasher flow, the cleanest build is three separate layers: auth first, firmware download second, and a hot-swappable flashing engine last. I would put the UI in C# (lightweight WinForms or WPF) so the token prompt, HWID collection, and status text stay simple for whoever runs it. Until your POST /api/v1/auth/verify returns OK, every flash-related control stays locked. When the user hits Flash, the app pulls the latest firmware package and loads your engine DLL straight into memory at runtime, not baked into the exe. That way you can swap the DLL later without rebuilding the whole flasher. A progress bar plus plain status lines (verifying token, downloading firmware, loading engine, flashing complete) keeps people in the loop. You get a Windows 10+ executable, full source with short build notes, and a README that shows where the API URL and firmware path are defined so you can tweak them yourself. Happy to keep auth, download, and the engine cleanly split so updates stay painless.

User Avatar
Flag of NIGERIA

My computer engineering background and C++ software development skills align directly with building a lightweight Windows flasher that securely separates authentication, firmware handling, and a dynamically loaded engine DLL. I can develop the desktop executable around the required token and HWID verification flow, ensuring flashing controls remain unavailable until the backend confirms authentication. I also bring end-to-end backend development experience with Spring Boot, Node.js, MongoDB, AWS, MQTT, and WebSocket-based systems, which supports reliable API communication, device-oriented workflows, and clear status handling. The source can be structured cleanly so the API URL, firmware endpoint, and external DLL remain easy to update, with concise build instructions and a README documenting the verification and HWID flow. I’m ready to deliver the Windows 10+ application and maintainable source code for this modular flashing workflow.

User Avatar
Flag of ARGENTINA

Hello, "WINDOWS USB FIRMWARE FLASHER WITH DYNAMIC DLL INTEGRATION" - you need a secure, single-click flashing tool with server-controlled access and a replaceable engine. I'd build the Windows 10+ interface in C# with clear authentication, download and flashing status stages. The HWID and token verification will run before enabling controls, with proper error handling and a separate, documented engine interface for DLL updates. I'll also include progress reporting, build instructions and the requested README. One important detail: firmware integrity checks and device recovery handling should be defined before flashing begins. What USB device protocol does your proprietary hardware use, and does the existing DLL already expose a documented flashing interface? Looking forward to work with you.

User Avatar
Flag of TAIWAN

I read your flow closely: the Token and HWID go to POST /api/v1/auth/verify, and every flashing control stays locked until the server answers OK. After that, one Flash click pulls the latest firmware and loads the engine DLL into memory at the same time, then hands it the package for the USB write. I would build it in C# (.NET 8, single self-contained exe, WinForms). The HWID would come from stable hardware IDs hashed together. The engine would sit behind a small loader interface, so you can swap in a new DLL without touching the main app. The progress bar and status text would follow each stage, with clear errors when one fails. You would get the source, a short build guide and a README showing the token/HWID logic, the verify call, and where the API and firmware URLs live in one config file. Which exported functions does your engine DLL expose today (names and signatures), and does it handle the USB transfer itself?

User Avatar
Flag of THAILAND

I’ve built Windows device utilities with token-gated workflows, USB communication, firmware downloads, and replaceable native engine modules. For this project, the key is separating the UI, authentication client, firmware service, and flashing DLL interface so the engine and API configuration can be updated without rewriting the app. I’ll create a lightweight Windows 10+ executable that collects the token and HWID, calls your verify endpoint, and keeps Flash disabled until approval. It’ll download the current firmware, load the external engine DLL dynamically at runtime, and report each stage through clear status text and progress. I’ll provide source, build notes, and a concise README, then verify the complete authenticated flash flow. Thanks, Kittipong

User Avatar
Flag of UKRAINE

Hi there, Could the token verification stay on a simple JSON response from /api/v1/auth/verify, or do you need signed replies too? Which USB device identifiers should the flashing engine use to confirm the target device before starting? The cleanest structure is a small Windows desktop client with three separate layers: auth, firmware fetch, and a runtime-loaded DLL for flashing. That keeps the executable lightweight, while the DLL can be swapped later without rebuilding the app. One important risk is keeping the UI responsive while authentication, download, and USB flashing happen in sequence. That can be handled with background tasks, clear state transitions, and strict checks so flashing controls stay locked until the server returns OK. The build can include concise source code, a simple config file for the API and firmware URL, and a README that explains token and HWID handling. The progress bar and status text can be wired to each step so the user always sees what the app is doing. Best, Hlib

User Avatar
Flag of UKRAINE

Hello, • Your project requires a secure Windows desktop app that authenticates users via token and HWID, dynamically loads a flashing engine DLL, and updates firmware on your specific USB device. Key constraints include disabling functionality until server authentication succeeds and ensuring a seamless in-memory DLL load separate from the main executable. The goal is a clean, modular single-click flasher with clear UI feedback across authentication, download, and flashing stages, plus maintainable source code and documentation. • With a strong full stack background in software development and RESTful APIs, I am well-equipped to build a reliable Windows app that integrates backend authentication and dynamic module loading. I would begin by implementing the token and HWID collection with server verification, then develop the firmware download and dynamic DLL loading followed by the flashing process, ensuring modularity and clear progress updates. • I will verify functionality by testing authentication flows, dynamic DLL loading, firmware downloads, and flashing outcomes on Windows 10+, providing source code with build instructions and a detailed README. This fixed-price bid is $450 for delivery within 5 days, which covers development and testing aligned to your acceptance criteria with any critical dependencies confirmed early. • I will provide regular progress updates including early demos for your feedback and will promptly communicate any issues or questions affecting scope or functionality. Could you please confirm if the flashing engine DLL interface and firmware server API are stable and documented to guide implementation correctly? Thanks for your time Oleksandr

User Avatar
Flag of COLOMBIA

C++ programming and embedded-systems experience make me well suited to build a reliable Windows flasher that coordinates authentication, firmware delivery, and a modular device-programming engine. My background as a Senior Electronics Engineer includes over 8 years working with embedded controllers, firmware development, system integration, testing, and validation—experience directly relevant to communicating with proprietary hardware over USB and producing dependable flashing software. I can develop the Windows-only application around the required token/HWID verification flow, keep flashing controls unavailable until authentication succeeds, download the current firmware, and load the external DLL dynamically at runtime rather than compiling it into the executable. I will also provide the source code, build instructions, and README documenting the verification request, HWID/token handling, and firmware URL location. My C++ and embedded background supports a clean separation between the user interface, API communication, and hot-swappable flashing engine. I am ready to deliver a focused, maintainable flasher that is practical to update as your API or DLL evolves.

User Avatar
Flag of PHILIPPINES

Hello, Greetings , Good morning! I am an expert electronics engineer with skills including Desktop Application, Backend Development, C++ Programming, Software Development, Debugging, API, C# Programming and Firmware Development. Please contact me to discuss more regarding this project. Thanks & Regards

User Avatar
Flag of SPAIN

Hi there, in order to effectively flash your proprietary device through a Windows application, we can implement the authentication workflow you've outlined, starting with user input for the alphanumeric Token and HWID, and securely posting these to your backend for verification. We will ensure that all controls remain disabled until we get a positive response from the server, which adds a critical layer of security. Our team consists of skilled developers from Germany and the Netherlands, based in Spain, and we take pride in delivering quality work our clients can rely on with complete peace of mind. We will dynamically load the flashing engine DLL during runtime to separate it from the executable, meeting your requirements for a seamless flashing process with clear progress indicators and the necessary documentation for future updates. Looking forward to discussing the technical details further. Regards, Ali Parandeh IT Director

内容来自 Freelancer News,版权归原作者所有。

阅读原文 ↗

把喜欢的内容,留在你的新标签页。

打开我的订阅